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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
19,700
|
dach_finalize_base64_by_link
|
xtate/src/util-data/data-chain.c
|
DataLink *dach_finalize_base64_by_link(DataLink *link,
struct DachBase64 *base64) {
unsigned x = base64->temp;
switch (base64->state) {
case 0:
break;
case 1:
link = dach_append_char_by_link(link, b64[(x >> 18) & 0x3F]);
link = dach_append_char_by_link(link, b64[(x >> 12) & 0x3F]);
link = dach_append_by_link(link, "==", 2);
break;
case 2:
link = dach_append_char_by_link(link, b64[(x >> 18) & 0x3F]);
link = dach_append_char_by_link(link, b64[(x >> 12) & 0x3F]);
link = dach_append_char_by_link(link, b64[(x >> 6) & 0x3F]);
link = dach_append_char_by_link(link, '=');
break;
}
return link;
}
|
O3
|
c
|
dach_finalize_base64_by_link:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl (%rsi), %ebx
movl %ebx, %eax
andl $0x3, %eax
cmpl $0x2, %eax
je 0x50035
cmpl $0x1, %eax
jne 0x500b2
movl %ebx, %eax
shrl $0x14, %eax
andl $0x3f, %eax
leaq 0x23f6a(%rip), %r14 # 0x73f4f
movb (%rax,%r14), %al
leaq 0xa(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
callq 0x4f22b
shrl $0xe, %ebx
andl $0x3f, %ebx
movb (%rbx,%r14), %cl
leaq 0xb(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4f22b
leaq 0x30b4d(%rip), %rsi # 0x80b6c
movl $0x2, %edx
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x4f22b
movl %ebx, %r14d
shrl $0x8, %r14d
movl %ebx, %eax
shrl $0x14, %eax
andl $0x3f, %eax
leaq 0x23f04(%rip), %r15 # 0x73f4f
movb (%rax,%r15), %al
leaq 0xc(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
callq 0x4f22b
shrl $0xe, %ebx
andl $0x3f, %ebx
movb (%rbx,%r15), %cl
leaq 0xd(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4f22b
andl $0x3f, %r14d
movb (%r14,%r15), %cl
leaq 0xe(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4f22b
leaq 0xf(%rsp), %rsi
movb $0x3d, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4f22b
movq %rax, %rdi
movq %rdi, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
dach_finalize_base64_by_link:
push r15
push r14
push rbx
sub rsp, 10h
mov ebx, [rsi]
mov eax, ebx
and eax, 3
cmp eax, 2
jz short loc_50035
cmp eax, 1
jnz loc_500B2
mov eax, ebx
shr eax, 14h
and eax, 3Fh
lea r14, aAbcdefghijklmn; "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklm"...
mov al, [rax+r14]
lea rsi, [rsp+28h+var_1E]
mov [rsi], al
mov edx, 1
call dach_append_by_link
shr ebx, 0Eh
and ebx, 3Fh
mov cl, [rbx+r14]
lea rsi, [rsp+28h+var_1D]
mov [rsi], cl
mov edx, 1
mov rdi, rax
call dach_append_by_link
lea rsi, asc_80B1E+4Eh; "=="
mov edx, 2
mov rdi, rax
add rsp, 10h
pop rbx
pop r14
pop r15
jmp dach_append_by_link
loc_50035:
mov r14d, ebx
shr r14d, 8
mov eax, ebx
shr eax, 14h
and eax, 3Fh
lea r15, aAbcdefghijklmn; "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklm"...
mov al, [rax+r15]
lea rsi, [rsp+28h+var_1C]
mov [rsi], al
mov edx, 1
call dach_append_by_link
shr ebx, 0Eh
and ebx, 3Fh
mov cl, [rbx+r15]
lea rsi, [rsp+28h+var_1B]
mov [rsi], cl
mov edx, 1
mov rdi, rax
call dach_append_by_link
and r14d, 3Fh
mov cl, [r14+r15]
lea rsi, [rsp+28h+var_1A]
mov [rsi], cl
mov edx, 1
mov rdi, rax
call dach_append_by_link
lea rsi, [rsp+28h+var_19]
mov byte ptr [rsi], 3Dh ; '='
mov edx, 1
mov rdi, rax
call dach_append_by_link
mov rdi, rax
loc_500B2:
mov rax, rdi
add rsp, 10h
pop rbx
pop r14
pop r15
retn
|
long long dach_finalize_base64_by_link(long long a1, unsigned int *a2)
{
unsigned int v2; // ebx
int v3; // eax
long long v4; // rax
long long v5; // rax
long long v7; // rax
long long v8; // rax
long long v9; // rax
char v10; // [rsp+Ah] [rbp-1Eh] BYREF
char v11; // [rsp+Bh] [rbp-1Dh] BYREF
char v12; // [rsp+Ch] [rbp-1Ch] BYREF
char v13; // [rsp+Dh] [rbp-1Bh] BYREF
char v14; // [rsp+Eh] [rbp-1Ah] BYREF
char v15[25]; // [rsp+Fh] [rbp-19h] BYREF
v2 = *a2;
v3 = *a2 & 3;
if ( v3 == 2 )
{
v12 = aAbcdefghijklmn[(v2 >> 20) & 0x3F];
v7 = dach_append_by_link(a1, (long long)&v12, 1LL);
v13 = aAbcdefghijklmn[(v2 >> 14) & 0x3F];
v8 = dach_append_by_link(v7, (long long)&v13, 1LL);
v14 = aAbcdefghijklmn[(v2 >> 8) & 0x3F];
v9 = dach_append_by_link(v8, (long long)&v14, 1LL);
v15[0] = 61;
return dach_append_by_link(v9, (long long)v15, 1LL);
}
else if ( v3 == 1 )
{
v10 = aAbcdefghijklmn[(v2 >> 20) & 0x3F];
v4 = dach_append_by_link(a1, (long long)&v10, 1LL);
v11 = aAbcdefghijklmn[(v2 >> 14) & 0x3F];
v5 = dach_append_by_link(v4, (long long)&v11, 1LL);
return dach_append_by_link(v5, (long long)"==", 2LL);
}
return a1;
}
|
dach_finalize_base64_by_link:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV EBX,dword ptr [RSI]
MOV EAX,EBX
AND EAX,0x3
CMP EAX,0x2
JZ 0x00150035
CMP EAX,0x1
JNZ 0x001500b2
MOV EAX,EBX
SHR EAX,0x14
AND EAX,0x3f
LEA R14,[0x173f4f]
MOV AL,byte ptr [RAX + R14*0x1]
LEA RSI,[RSP + 0xa]
MOV byte ptr [RSI],AL
MOV EDX,0x1
CALL 0x0014f22b
SHR EBX,0xe
AND EBX,0x3f
MOV CL,byte ptr [RBX + R14*0x1]
LEA RSI,[RSP + 0xb]
MOV byte ptr [RSI],CL
MOV EDX,0x1
MOV RDI,RAX
CALL 0x0014f22b
LEA RSI,[0x180b6c]
MOV EDX,0x2
MOV RDI,RAX
ADD RSP,0x10
POP RBX
POP R14
POP R15
JMP 0x0014f22b
LAB_00150035:
MOV R14D,EBX
SHR R14D,0x8
MOV EAX,EBX
SHR EAX,0x14
AND EAX,0x3f
LEA R15,[0x173f4f]
MOV AL,byte ptr [RAX + R15*0x1]
LEA RSI,[RSP + 0xc]
MOV byte ptr [RSI],AL
MOV EDX,0x1
CALL 0x0014f22b
SHR EBX,0xe
AND EBX,0x3f
MOV CL,byte ptr [RBX + R15*0x1]
LEA RSI,[RSP + 0xd]
MOV byte ptr [RSI],CL
MOV EDX,0x1
MOV RDI,RAX
CALL 0x0014f22b
AND R14D,0x3f
MOV CL,byte ptr [R14 + R15*0x1]
LEA RSI,[RSP + 0xe]
MOV byte ptr [RSI],CL
MOV EDX,0x1
MOV RDI,RAX
CALL 0x0014f22b
LEA RSI,[RSP + 0xf]
MOV byte ptr [RSI],0x3d
MOV EDX,0x1
MOV RDI,RAX
CALL 0x0014f22b
MOV RDI,RAX
LAB_001500b2:
MOV RAX,RDI
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
int8 dach_finalize_base64_by_link(int8 param_1,uint *param_2)
{
uint uVar1;
int8 uVar2;
char local_1e;
char local_1d;
char local_1c;
char local_1b;
char local_1a [2];
uVar1 = *param_2;
if ((uVar1 & 3) == 2) {
local_1c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
[uVar1 >> 0x14 & 0x3f];
uVar2 = dach_append_by_link(param_1,&local_1c,1);
local_1b = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
[uVar1 >> 0xe & 0x3f];
uVar2 = dach_append_by_link(uVar2,&local_1b,1);
local_1a[0] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
[uVar1 >> 8 & 0x3f];
uVar2 = dach_append_by_link(uVar2,local_1a,1);
local_1a[1] = 0x3d;
param_1 = dach_append_by_link(uVar2,local_1a + 1,1);
}
else if ((uVar1 & 3) == 1) {
local_1e = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
[uVar1 >> 0x14 & 0x3f];
uVar2 = dach_append_by_link(param_1,&local_1e,1);
local_1d = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
[uVar1 >> 0xe & 0x3f];
uVar2 = dach_append_by_link(uVar2,&local_1d,1);
uVar2 = dach_append_by_link(uVar2,"==",2);
return uVar2;
}
return param_1;
}
|
|
19,701
|
nglog::tools::GetSymbolFromObjectFile(int, unsigned long, char*, unsigned long, unsigned long)
|
ng-log[P]ng-log/src/symbolize.cc
|
static bool GetSymbolFromObjectFile(const int fd, uint64_t pc, char* out,
size_t out_size, uint64_t base_address) {
// Read the ELF header.
ElfW(Ehdr) elf_header;
if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
return false;
}
ElfW(Shdr) symtab, strtab;
// Consult a regular symbol table first.
if (GetSectionHeaderByType(fd, elf_header.e_shnum, elf_header.e_shoff,
SHT_SYMTAB, &symtab)) {
if (!ReadFromOffsetExact(
fd, &strtab, sizeof(strtab),
elf_header.e_shoff + symtab.sh_link * sizeof(symtab))) {
return false;
}
if (FindSymbol(pc, fd, out, out_size, base_address, &strtab, &symtab)) {
return true; // Found the symbol in a regular symbol table.
}
}
// If the symbol is not found, then consult a dynamic symbol table.
if (GetSectionHeaderByType(fd, elf_header.e_shnum, elf_header.e_shoff,
SHT_DYNSYM, &symtab)) {
if (!ReadFromOffsetExact(
fd, &strtab, sizeof(strtab),
elf_header.e_shoff + symtab.sh_link * sizeof(symtab))) {
return false;
}
if (FindSymbol(pc, fd, out, out_size, base_address, &strtab, &symtab)) {
return true; // Found the symbol in a dynamic symbol table.
}
}
return false;
}
|
O0
|
cpp
|
nglog::tools::GetSymbolFromObjectFile(int, unsigned long, char*, unsigned long, unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x8(%rbp), %edi
leaq -0x68(%rbp), %rsi
movl $0x40, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4dd20
testb $0x1, %al
jne 0x4ea70
movb $0x0, -0x1(%rbp)
jmp 0x4eb8c
movl -0x8(%rbp), %edi
movw -0x2c(%rbp), %ax
movq -0x40(%rbp), %rdx
movl $0x2, %ecx
leaq -0xa8(%rbp), %r8
movzwl %ax, %esi
callq 0x4f270
testb $0x1, %al
jne 0x4ea95
jmp 0x4eaff
movl -0x8(%rbp), %edi
movq -0x40(%rbp), %rcx
movl -0x80(%rbp), %eax
shlq $0x6, %rax
addq %rax, %rcx
leaq -0xe8(%rbp), %rsi
movl $0x40, %edx
callq 0x4dd20
testb $0x1, %al
jne 0x4eac4
movb $0x0, -0x1(%rbp)
jmp 0x4eb8c
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0xe8(%rbp), %r9
leaq -0xa8(%rbp), %rax
movq %rax, (%rsp)
callq 0x4f420
testb $0x1, %al
jne 0x4eaf4
jmp 0x4eafd
movb $0x1, -0x1(%rbp)
jmp 0x4eb8c
jmp 0x4eaff
movl -0x8(%rbp), %edi
movw -0x2c(%rbp), %ax
movq -0x40(%rbp), %rdx
movl $0xb, %ecx
leaq -0xa8(%rbp), %r8
movzwl %ax, %esi
callq 0x4f270
testb $0x1, %al
jne 0x4eb24
jmp 0x4eb88
movl -0x8(%rbp), %edi
movq -0x40(%rbp), %rcx
movl -0x80(%rbp), %eax
shlq $0x6, %rax
addq %rax, %rcx
leaq -0xe8(%rbp), %rsi
movl $0x40, %edx
callq 0x4dd20
testb $0x1, %al
jne 0x4eb50
movb $0x0, -0x1(%rbp)
jmp 0x4eb8c
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0xe8(%rbp), %r9
leaq -0xa8(%rbp), %rax
movq %rax, (%rsp)
callq 0x4f420
testb $0x1, %al
jne 0x4eb80
jmp 0x4eb86
movb $0x1, -0x1(%rbp)
jmp 0x4eb8c
jmp 0x4eb88
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_ZN5nglog5toolsL23GetSymbolFromObjectFileEimPcmm:
push rbp
mov rbp, rsp
sub rsp, 0F0h
mov dword ptr [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov edi, dword ptr [rbp+var_8]; this
lea rsi, [rbp+var_68]; int
mov edx, offset dword_40; void *
xor eax, eax
mov ecx, eax; unsigned __int64
call _ZN5nglog5toolsL19ReadFromOffsetExactEiPvmm; nglog::tools::ReadFromOffsetExact(int,void *,ulong,ulong)
test al, 1
jnz short loc_4EA70
mov byte ptr [rbp+var_8+7], 0
jmp loc_4EB8C
loc_4EA70:
mov edi, dword ptr [rbp+var_8]
mov ax, [rbp+var_2C]
mov rdx, [rbp+var_40]
mov ecx, 2
lea r8, [rbp+var_A8]
movzx esi, ax
call _ZN5nglog5toolsL22GetSectionHeaderByTypeEitmjP10Elf64_Shdr; nglog::tools::GetSectionHeaderByType(int,ushort,ulong,uint,Elf64_Shdr *)
test al, 1
jnz short loc_4EA95
jmp short loc_4EAFF
loc_4EA95:
mov edi, dword ptr [rbp+var_8]; this
mov rcx, [rbp+var_40]
mov eax, [rbp+var_80]
shl rax, 6
add rcx, rax; unsigned __int64
lea rsi, [rbp+var_E8]; int
mov edx, offset dword_40; void *
call _ZN5nglog5toolsL19ReadFromOffsetExactEiPvmm; nglog::tools::ReadFromOffsetExact(int,void *,ulong,ulong)
test al, 1
jnz short loc_4EAC4
mov byte ptr [rbp+var_8+7], 0
jmp loc_4EB8C
loc_4EAC4:
mov rdi, [rbp+var_10]
mov esi, dword ptr [rbp+var_8]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
lea r9, [rbp+var_E8]
lea rax, [rbp+var_A8]
mov [rsp+0F0h+var_F0], rax
call _ZN5nglog5toolsL10FindSymbolEmiPcmmPK10Elf64_ShdrS4_; nglog::tools::FindSymbol(ulong,int,char *,ulong,ulong,Elf64_Shdr const*,Elf64_Shdr const*)
test al, 1
jnz short loc_4EAF4
jmp short loc_4EAFD
loc_4EAF4:
mov byte ptr [rbp+var_8+7], 1
jmp loc_4EB8C
loc_4EAFD:
jmp short $+2
loc_4EAFF:
mov edi, dword ptr [rbp+var_8]
mov ax, [rbp+var_2C]
mov rdx, [rbp+var_40]
mov ecx, 0Bh
lea r8, [rbp+var_A8]
movzx esi, ax
call _ZN5nglog5toolsL22GetSectionHeaderByTypeEitmjP10Elf64_Shdr; nglog::tools::GetSectionHeaderByType(int,ushort,ulong,uint,Elf64_Shdr *)
test al, 1
jnz short loc_4EB24
jmp short loc_4EB88
loc_4EB24:
mov edi, dword ptr [rbp+var_8]; this
mov rcx, [rbp+var_40]
mov eax, [rbp+var_80]
shl rax, 6
add rcx, rax; unsigned __int64
lea rsi, [rbp+var_E8]; int
mov edx, offset dword_40; void *
call _ZN5nglog5toolsL19ReadFromOffsetExactEiPvmm; nglog::tools::ReadFromOffsetExact(int,void *,ulong,ulong)
test al, 1
jnz short loc_4EB50
mov byte ptr [rbp+var_8+7], 0
jmp short loc_4EB8C
loc_4EB50:
mov rdi, [rbp+var_10]
mov esi, dword ptr [rbp+var_8]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
lea r9, [rbp+var_E8]
lea rax, [rbp+var_A8]
mov [rsp+0F0h+var_F0], rax
call _ZN5nglog5toolsL10FindSymbolEmiPcmmPK10Elf64_ShdrS4_; nglog::tools::FindSymbol(ulong,int,char *,ulong,ulong,Elf64_Shdr const*,Elf64_Shdr const*)
test al, 1
jnz short loc_4EB80
jmp short loc_4EB86
loc_4EB80:
mov byte ptr [rbp+var_8+7], 1
jmp short loc_4EB8C
loc_4EB86:
jmp short $+2
loc_4EB88:
mov byte ptr [rbp+var_8+7], 0
loc_4EB8C:
mov al, byte ptr [rbp+var_8+7]
and al, 1
add rsp, 0F0h
pop rbp
retn
|
char nglog::tools::GetSymbolFromObjectFile(
nglog::tools *this,
long long a2,
long long a3,
char *a4,
unsigned long long a5)
{
unsigned long long v5; // r8
unsigned long long v6; // r8
int v8[16]; // [rsp+8h] [rbp-E8h] BYREF
_BYTE v9[40]; // [rsp+48h] [rbp-A8h] BYREF
unsigned int v10; // [rsp+70h] [rbp-80h]
int v11; // [rsp+88h] [rbp-68h] BYREF
long long v12; // [rsp+B0h] [rbp-40h]
unsigned __int16 v13; // [rsp+C4h] [rbp-2Ch]
unsigned long long v14; // [rsp+C8h] [rbp-28h]
char *v15; // [rsp+D0h] [rbp-20h]
long long v16; // [rsp+D8h] [rbp-18h]
long long v17; // [rsp+E0h] [rbp-10h]
unsigned int v18; // [rsp+E8h] [rbp-8h]
v18 = (unsigned int)this;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
if ( nglog::tools::ReadFromOffsetExact((nglog::tools *)(unsigned int)this, (int)&v11, &dword_40, 0LL, a5) )
{
if ( (nglog::tools::GetSectionHeaderByType(v18, v13, v12, 2LL, v9) & 1) != 0 )
{
if ( !nglog::tools::ReadFromOffsetExact(
(nglog::tools *)v18,
(int)v8,
&dword_40,
((unsigned long long)v10 << 6) + v12,
v5) )
return 0;
if ( (nglog::tools::FindSymbol(v17, v18, v16, (_DWORD)v15, v14, (unsigned int)v8, (long long)v9) & 1) != 0 )
return 1;
}
if ( (nglog::tools::GetSectionHeaderByType(v18, v13, v12, 11LL, v9) & 1) != 0 )
{
if ( !nglog::tools::ReadFromOffsetExact(
(nglog::tools *)v18,
(int)v8,
&dword_40,
((unsigned long long)v10 << 6) + v12,
v6) )
return 0;
if ( (nglog::tools::FindSymbol(v17, v18, v16, (_DWORD)v15, v14, (unsigned int)v8, (long long)v9) & 1) != 0 )
return 1;
}
return 0;
}
return 0;
}
|
GetSymbolFromObjectFile:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xf0
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV EDI,dword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x68]
MOV EDX,0x40
XOR EAX,EAX
MOV ECX,EAX
CALL 0x0014dd20
TEST AL,0x1
JNZ 0x0014ea70
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0014eb8c
LAB_0014ea70:
MOV EDI,dword ptr [RBP + -0x8]
MOV AX,word ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x40]
MOV ECX,0x2
LEA R8,[RBP + -0xa8]
MOVZX ESI,AX
CALL 0x0014f270
TEST AL,0x1
JNZ 0x0014ea95
JMP 0x0014eaff
LAB_0014ea95:
MOV EDI,dword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x80]
SHL RAX,0x6
ADD RCX,RAX
LEA RSI,[RBP + -0xe8]
MOV EDX,0x40
CALL 0x0014dd20
TEST AL,0x1
JNZ 0x0014eac4
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0014eb8c
LAB_0014eac4:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
LEA R9,[RBP + -0xe8]
LEA RAX,[RBP + -0xa8]
MOV qword ptr [RSP],RAX
CALL 0x0014f420
TEST AL,0x1
JNZ 0x0014eaf4
JMP 0x0014eafd
LAB_0014eaf4:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0014eb8c
LAB_0014eafd:
JMP 0x0014eaff
LAB_0014eaff:
MOV EDI,dword ptr [RBP + -0x8]
MOV AX,word ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x40]
MOV ECX,0xb
LEA R8,[RBP + -0xa8]
MOVZX ESI,AX
CALL 0x0014f270
TEST AL,0x1
JNZ 0x0014eb24
JMP 0x0014eb88
LAB_0014eb24:
MOV EDI,dword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x80]
SHL RAX,0x6
ADD RCX,RAX
LEA RSI,[RBP + -0xe8]
MOV EDX,0x40
CALL 0x0014dd20
TEST AL,0x1
JNZ 0x0014eb50
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0014eb8c
LAB_0014eb50:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
LEA R9,[RBP + -0xe8]
LEA RAX,[RBP + -0xa8]
MOV qword ptr [RSP],RAX
CALL 0x0014f420
TEST AL,0x1
JNZ 0x0014eb80
JMP 0x0014eb86
LAB_0014eb80:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0014eb8c
LAB_0014eb86:
JMP 0x0014eb88
LAB_0014eb88:
MOV byte ptr [RBP + -0x1],0x0
LAB_0014eb8c:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0xf0
POP RBP
RET
|
/* nglog::tools::GetSymbolFromObjectFile(int, unsigned long, char*, unsigned long, unsigned long) */
int1
nglog::tools::GetSymbolFromObjectFile
(int param_1,ulong param_2,char *param_3,ulong param_4,ulong param_5)
{
ulong uVar1;
Elf64_Shdr local_f0;
Elf64_Shdr local_b0;
int1 local_70 [40];
ulong local_48;
ushort local_34;
ulong local_30;
ulong local_28;
char *local_20;
ulong local_18;
int local_10;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
uVar1 = ReadFromOffsetExact(param_1,local_70,0x40,0);
if ((uVar1 & 1) == 0) {
return 0;
}
uVar1 = GetSectionHeaderByType(local_10,local_34,local_48,2,&local_b0);
if ((uVar1 & 1) != 0) {
uVar1 = ReadFromOffsetExact(local_10,&local_f0,0x40,local_48 + (ulong)local_b0.sh_link * 0x40);
if ((uVar1 & 1) == 0) {
return 0;
}
uVar1 = FindSymbol(local_18,local_10,local_20,local_28,local_30,&local_f0,&local_b0);
if ((uVar1 & 1) != 0) {
return 1;
}
}
uVar1 = GetSectionHeaderByType(local_10,local_34,local_48,0xb,&local_b0);
if ((uVar1 & 1) != 0) {
uVar1 = ReadFromOffsetExact(local_10,&local_f0,0x40,local_48 + (ulong)local_b0.sh_link * 0x40);
if ((uVar1 & 1) == 0) {
return 0;
}
uVar1 = FindSymbol(local_18,local_10,local_20,local_28,local_30,&local_f0,&local_b0);
if ((uVar1 & 1) != 0) {
return 1;
}
}
return 0;
}
|
|
19,702
|
my_hash_sort_ucs2_nopad_bin
|
eloqsql/strings/ctype-ucs2.c
|
static void
my_hash_sort_ucs2_nopad_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
const uchar *end= key + len;
register ulong m1= *nr1, m2= *nr2;
for ( ; key < end ; key++)
{
MY_HASH_ADD(m1, m2, (uint)*key);
}
*nr1= m1;
*nr2= m2;
}
|
O0
|
c
|
my_hash_sort_ucs2_nopad_bin:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x73e3e
jmp 0x73df6
movq -0x38(%rbp), %rax
andq $0x3f, %rax
addq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x38(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x40(%rbp)
jmp 0x73e30
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x73dea
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_hash_sort_ucs2_nopad_bin:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_40], rax
loc_73DEA:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_30]
jnb short loc_73E3E
jmp short $+2
loc_73DF6:
mov rax, [rbp+var_38]
and rax, 3Fh
add rax, [rbp+var_40]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_38]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_38]
mov [rbp+var_38], rax
mov rax, [rbp+var_40]
add rax, 3
mov [rbp+var_40], rax
jmp short $+2
loc_73E30:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_73DEA
loc_73E3E:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_40]
mov rax, [rbp+var_28]
mov [rax], rcx
pop rbp
retn
|
_QWORD * my_hash_sort_ucs2_nopad_bin(long long a1, unsigned __int8 *a2, long long a3, long long *a4, _QWORD *a5)
{
_QWORD *result; // rax
long long v6; // [rsp+0h] [rbp-40h]
long long v7; // [rsp+8h] [rbp-38h]
unsigned __int8 *v8; // [rsp+30h] [rbp-10h]
v8 = a2;
v7 = *a4;
v6 = *a5;
while ( v8 < &a2[a3] )
{
v7 ^= (v7 << 8) + *v8 * (v6 + (v7 & 0x3F));
v6 += 3LL;
++v8;
}
*a4 = v7;
result = a5;
*a5 = v6;
return result;
}
|
my_hash_sort_ucs2_nopad_bin:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
LAB_00173dea:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00173e3e
JMP 0x00173df6
LAB_00173df6:
MOV RAX,qword ptr [RBP + -0x38]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x38]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x3
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00173e30
LAB_00173e30:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00173dea
LAB_00173e3e:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
POP RBP
RET
|
void my_hash_sort_ucs2_nopad_bin
(int8 param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
long local_48;
ulong local_40;
byte *local_18;
local_40 = *param_4;
local_48 = *param_5;
for (local_18 = param_2; local_18 < param_2 + param_3; local_18 = local_18 + 1) {
local_40 = ((local_40 & 0x3f) + local_48) * (ulong)*local_18 + local_40 * 0x100 ^ local_40;
local_48 = local_48 + 3;
}
*param_4 = local_40;
*param_5 = local_48;
return;
}
|
|
19,703
|
mi_read_dynamic_record
|
eloqsql/storage/myisam/mi_dynrec.c
|
int _mi_read_dynamic_record(MI_INFO *info, my_off_t filepos, uchar *buf)
{
int block_of_record;
uint b_type,UNINIT_VAR(left_length);
uchar *UNINIT_VAR(to);
MI_BLOCK_INFO block_info;
File file;
DBUG_ENTER("mi_read_dynamic_record");
if (filepos != HA_OFFSET_ERROR)
{
file=info->dfile;
block_of_record= 0; /* First block of record is numbered as zero. */
block_info.second_read= 0;
do
{
/* A corrupted table can have wrong pointers. (Bug# 19835) */
if (filepos == HA_OFFSET_ERROR)
goto panic;
if (info->opt_flag & WRITE_CACHE_USED &&
info->rec_cache.pos_in_file < filepos + MI_BLOCK_INFO_HEADER_LENGTH &&
flush_io_cache(&info->rec_cache))
goto err;
info->rec_cache.seek_not_done=1;
if ((b_type= _mi_get_block_info(&block_info, file, filepos))
& (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
BLOCK_FATAL_ERROR))
{
if (b_type & (BLOCK_SYNC_ERROR | BLOCK_DELETED))
my_errno=HA_ERR_RECORD_DELETED;
goto err;
}
if (block_of_record++ == 0) /* First block */
{
if (block_info.rec_len > (uint) info->s->base.max_pack_length)
goto panic;
if (info->s->base.blobs)
{
if (!(to=mi_alloc_rec_buff(info, block_info.rec_len,
&info->rec_buff)))
goto err;
}
else
to= info->rec_buff;
left_length=block_info.rec_len;
}
if (left_length < block_info.data_len || ! block_info.data_len)
goto panic; /* Wrong linked record */
/* copy information that is already read */
{
uint offset= (uint) (block_info.filepos - filepos);
uint prefetch_len= (sizeof(block_info.header) - offset);
filepos+= sizeof(block_info.header);
if (prefetch_len > block_info.data_len)
prefetch_len= block_info.data_len;
if (prefetch_len)
{
memcpy((uchar*) to, block_info.header + offset, prefetch_len);
block_info.data_len-= prefetch_len;
left_length-= prefetch_len;
to+= prefetch_len;
}
}
/* read rest of record from file */
if (block_info.data_len)
{
if (info->opt_flag & WRITE_CACHE_USED &&
info->rec_cache.pos_in_file < filepos + block_info.data_len &&
flush_io_cache(&info->rec_cache))
goto err;
/*
What a pity that this method is not called 'file_pread' and that
there is no equivalent without seeking. We are at the right
position already. :(
*/
if (info->s->file_read(info, (uchar*) to, block_info.data_len,
filepos, MYF(MY_NABP)))
goto panic;
left_length-=block_info.data_len;
to+=block_info.data_len;
}
filepos= block_info.next_filepos;
} while (left_length);
info->update|= HA_STATE_AKTIV; /* We have a aktive record */
fast_mi_writeinfo(info);
DBUG_RETURN(_mi_rec_unpack(info,buf,info->rec_buff,block_info.rec_len) !=
MY_FILE_ERROR ? 0 : -1);
}
fast_mi_writeinfo(info);
DBUG_RETURN(-1); /* Wrong data to read */
panic:
my_errno=HA_ERR_WRONG_IN_RECORD;
err:
(void) _mi_writeinfo(info,0);
DBUG_RETURN(-1);
}
|
O0
|
c
|
mi_read_dynamic_record:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq %rdx, -0x80(%rbp)
movl -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x98(%rbp)
cmpq $-0x1, -0x78(%rbp)
je 0xad2c4
movq -0x70(%rbp), %rax
movl 0x1c0(%rax), %eax
movl %eax, -0x9c(%rbp)
movl $0x0, -0x84(%rbp)
movl $0x0, -0x10(%rbp)
cmpq $-0x1, -0x78(%rbp)
jne 0xacfb6
jmp 0xad2ea
movq -0x70(%rbp), %rax
movl 0x1c8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xacfff
movq -0x70(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x78(%rbp), %rcx
addq $0x14, %rcx
cmpq %rcx, %rax
jae 0xacfff
movq -0x70(%rbp), %rdi
addq $0x220, %rdi # imm = 0x220
movl $0x1, %esi
callq 0xe2310
cmpl $0x0, %eax
je 0xacfff
jmp 0xad2f5
movq -0x70(%rbp), %rax
movl $0x1, 0x300(%rax)
movl -0x9c(%rbp), %esi
movq -0x78(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0xab440
movl %eax, -0x88(%rbp)
andl $0x3c, %eax
cmpl $0x0, %eax
je 0xad04c
movl -0x88(%rbp), %eax
andl $0x14, %eax
cmpl $0x0, %eax
je 0xad047
callq 0xf7a70
movl $0x86, (%rax)
jmp 0xad2f5
movl -0x84(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x84(%rbp)
cmpl $0x0, %eax
jne 0xad0d8
movq -0x48(%rbp), %rax
movq -0x70(%rbp), %rcx
movq (%rcx), %rcx
movq 0x158(%rcx), %rcx
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0xad080
jmp 0xad2ea
movq -0x70(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x188(%rax)
je 0xad0bc
movq -0x70(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x70(%rbp), %rdx
addq $0x120, %rdx # imm = 0x120
callq 0xb8500
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
jne 0xad0ba
jmp 0xad2f5
jmp 0xad0ce
movq -0x70(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x48(%rbp), %rax
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
cmpq -0x40(%rbp), %rax
jb 0xad0eb
cmpq $0x0, -0x40(%rbp)
jne 0xad0f0
jmp 0xad2ea
movq -0x28(%rbp), %rax
subq -0x78(%rbp), %rax
movl %eax, -0xa0(%rbp)
movl -0xa0(%rbp), %eax
movl %eax, %ecx
movl $0x14, %eax
subq %rcx, %rax
movl %eax, -0xa4(%rbp)
movq -0x78(%rbp), %rax
addq $0x14, %rax
movq %rax, -0x78(%rbp)
movl -0xa4(%rbp), %eax
cmpq -0x40(%rbp), %rax
jbe 0xad136
movq -0x40(%rbp), %rax
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
je 0xad1a0
movq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl -0xa0(%rbp), %eax
addq %rax, %rsi
movl -0xa4(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movl -0xa4(%rbp), %eax
movl %eax, %ecx
movq -0x40(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0xa4(%rbp), %ecx
movl -0x8c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8c(%rbp)
movl -0xa4(%rbp), %ecx
movq -0x98(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xad24d
movq -0x70(%rbp), %rax
movl 0x1c8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xad1f4
movq -0x70(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x78(%rbp), %rcx
addq -0x40(%rbp), %rcx
cmpq %rcx, %rax
jae 0xad1f4
movq -0x70(%rbp), %rdi
addq $0x220, %rdi # imm = 0x220
movl $0x1, %esi
callq 0xe2310
cmpl $0x0, %eax
je 0xad1f4
jmp 0xad2f5
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x2e0(%rax), %rax
movq -0x70(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x78(%rbp), %rcx
movl $0x4, %r8d
callq *%rax
cmpq $0x0, %rax
je 0xad228
jmp 0xad2ea
movq -0x40(%rbp), %rcx
movl -0x8c(%rbp), %eax
subq %rcx, %rax
movl %eax, -0x8c(%rbp)
movq -0x40(%rbp), %rax
addq -0x98(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpl $0x0, -0x8c(%rbp)
jne 0xacfaa
movq -0x70(%rbp), %rax
movl 0x1d0(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x1d0(%rax)
movq -0x70(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x368(%rax)
jne 0xad290
movq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0xb2980
jmp 0xad292
movq -0x70(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x70(%rbp), %rax
movq 0x120(%rax), %rdx
movq -0x48(%rbp), %rcx
callq 0xac8c0
movq %rax, %rdx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpq $-0x1, %rdx
cmovnel %ecx, %eax
movl %eax, -0x64(%rbp)
jmp 0xad307
movq -0x70(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x368(%rax)
jne 0xad2df
movq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0xb2980
jmp 0xad2e1
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
jmp 0xad307
callq 0xf7a70
movl $0x7f, (%rax)
movq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0xb2980
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
movl -0x64(%rbp), %eax
movl %eax, -0xa8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xad331
movl -0xa8(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
callq 0x2a250
nopw %cs:(%rax,%rax)
|
_mi_read_dynamic_record:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_70], rdi
mov [rbp+var_78], rsi
mov [rbp+var_80], rdx
mov eax, [rbp+var_8C]
mov [rbp+var_8C], eax
mov rax, [rbp+var_98]
mov [rbp+var_98], rax
cmp [rbp+var_78], 0FFFFFFFFFFFFFFFFh
jz loc_AD2C4
mov rax, [rbp+var_70]
mov eax, [rax+1C0h]
mov [rbp+var_9C], eax
mov [rbp+var_84], 0
mov [rbp+var_10], 0
loc_ACFAA:
cmp [rbp+var_78], 0FFFFFFFFFFFFFFFFh
jnz short loc_ACFB6
jmp loc_AD2EA
loc_ACFB6:
mov rax, [rbp+var_70]
mov eax, [rax+1C8h]
and eax, 10h
cmp eax, 0
jz short loc_ACFFF
mov rax, [rbp+var_70]
mov rax, [rax+220h]
mov rcx, [rbp+var_78]
add rcx, 14h
cmp rax, rcx
jnb short loc_ACFFF
mov rdi, [rbp+var_70]
add rdi, 220h
mov esi, 1
call my_b_flush_io_cache
cmp eax, 0
jz short loc_ACFFF
jmp loc_AD2F5
loc_ACFFF:
mov rax, [rbp+var_70]
mov dword ptr [rax+300h], 1
mov esi, [rbp+var_9C]
mov rdx, [rbp+var_78]
lea rdi, [rbp+var_60]
call _mi_get_block_info
mov [rbp+var_88], eax
and eax, 3Ch
cmp eax, 0
jz short loc_AD04C
mov eax, [rbp+var_88]
and eax, 14h
cmp eax, 0
jz short loc_AD047
call _my_thread_var
mov dword ptr [rax], 86h
loc_AD047:
jmp loc_AD2F5
loc_AD04C:
mov eax, [rbp+var_84]
mov ecx, eax
add ecx, 1
mov [rbp+var_84], ecx
cmp eax, 0
jnz short loc_AD0D8
mov rax, [rbp+var_48]
mov rcx, [rbp+var_70]
mov rcx, [rcx]
mov rcx, [rcx+158h]
mov ecx, ecx
cmp rax, rcx
jbe short loc_AD080
jmp loc_AD2EA
loc_AD080:
mov rax, [rbp+var_70]
mov rax, [rax]
cmp dword ptr [rax+188h], 0
jz short loc_AD0BC
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_70]
add rdx, 120h
call mi_alloc_rec_buff
mov [rbp+var_98], rax
cmp rax, 0
jnz short loc_AD0BA
jmp loc_AD2F5
loc_AD0BA:
jmp short loc_AD0CE
loc_AD0BC:
mov rax, [rbp+var_70]
mov rax, [rax+120h]
mov [rbp+var_98], rax
loc_AD0CE:
mov rax, [rbp+var_48]
mov [rbp+var_8C], eax
loc_AD0D8:
mov eax, [rbp+var_8C]
cmp rax, [rbp+var_40]
jb short loc_AD0EB
cmp [rbp+var_40], 0
jnz short loc_AD0F0
loc_AD0EB:
jmp loc_AD2EA
loc_AD0F0:
mov rax, [rbp+var_28]
sub rax, [rbp+var_78]
mov [rbp+var_A0], eax
mov eax, [rbp+var_A0]
mov ecx, eax
mov eax, 14h
sub rax, rcx
mov [rbp+var_A4], eax
mov rax, [rbp+var_78]
add rax, 14h
mov [rbp+var_78], rax
mov eax, [rbp+var_A4]
cmp rax, [rbp+var_40]
jbe short loc_AD136
mov rax, [rbp+var_40]
mov [rbp+var_A4], eax
loc_AD136:
cmp [rbp+var_A4], 0
jz short loc_AD1A0
mov rdi, [rbp+var_98]
lea rsi, [rbp+var_60]
mov eax, [rbp+var_A0]
add rsi, rax
mov eax, [rbp+var_A4]
mov edx, eax
call _memcpy
mov eax, [rbp+var_A4]
mov ecx, eax
mov rax, [rbp+var_40]
sub rax, rcx
mov [rbp+var_40], rax
mov ecx, [rbp+var_A4]
mov eax, [rbp+var_8C]
sub eax, ecx
mov [rbp+var_8C], eax
mov ecx, [rbp+var_A4]
mov rax, [rbp+var_98]
mov ecx, ecx
add rax, rcx
mov [rbp+var_98], rax
loc_AD1A0:
cmp [rbp+var_40], 0
jz loc_AD24D
mov rax, [rbp+var_70]
mov eax, [rax+1C8h]
and eax, 10h
cmp eax, 0
jz short loc_AD1F4
mov rax, [rbp+var_70]
mov rax, [rax+220h]
mov rcx, [rbp+var_78]
add rcx, [rbp+var_40]
cmp rax, rcx
jnb short loc_AD1F4
mov rdi, [rbp+var_70]
add rdi, 220h
mov esi, 1
call my_b_flush_io_cache
cmp eax, 0
jz short loc_AD1F4
jmp loc_AD2F5
loc_AD1F4:
mov rax, [rbp+var_70]
mov rax, [rax]
mov rax, [rax+2E0h]
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_98]
mov rdx, [rbp+var_40]
mov rcx, [rbp+var_78]
mov r8d, 4
call rax
cmp rax, 0
jz short loc_AD228
jmp loc_AD2EA
loc_AD228:
mov rcx, [rbp+var_40]
mov eax, [rbp+var_8C]
sub rax, rcx
mov [rbp+var_8C], eax
mov rax, [rbp+var_40]
add rax, [rbp+var_98]
mov [rbp+var_98], rax
loc_AD24D:
mov rax, [rbp+var_20]
mov [rbp+var_78], rax
cmp [rbp+var_8C], 0
jnz loc_ACFAA
mov rax, [rbp+var_70]
mov ecx, [rax+1D0h]
or ecx, 2
mov [rax+1D0h], ecx
mov rax, [rbp+var_70]
mov rax, [rax]
cmp dword ptr [rax+368h], 0
jnz short loc_AD290
mov rdi, [rbp+var_70]
xor esi, esi
call _mi_writeinfo
loc_AD290:
jmp short $+2
loc_AD292:
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_80]
mov rax, [rbp+var_70]
mov rdx, [rax+120h]
mov rcx, [rbp+var_48]
call _mi_rec_unpack
mov rdx, rax
mov eax, 0FFFFFFFFh
xor ecx, ecx
cmp rdx, 0FFFFFFFFFFFFFFFFh
cmovnz eax, ecx
mov [rbp+var_64], eax
jmp short loc_AD307
loc_AD2C4:
mov rax, [rbp+var_70]
mov rax, [rax]
cmp dword ptr [rax+368h], 0
jnz short loc_AD2DF
mov rdi, [rbp+var_70]
xor esi, esi
call _mi_writeinfo
loc_AD2DF:
jmp short $+2
loc_AD2E1:
mov [rbp+var_64], 0FFFFFFFFh
jmp short loc_AD307
loc_AD2EA:
call _my_thread_var
mov dword ptr [rax], 7Fh
loc_AD2F5:
mov rdi, [rbp+var_70]
xor esi, esi
call _mi_writeinfo
mov [rbp+var_64], 0FFFFFFFFh
loc_AD307:
mov eax, [rbp+var_64]
mov [rbp+var_A8], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_AD331
mov eax, [rbp+var_A8]
add rsp, 0B0h
pop rbp
retn
loc_AD331:
call ___stack_chk_fail
|
long long mi_read_dynamic_record(char *a1, const char *a2, const char *a3)
{
long long v4; // rdx
unsigned int v5; // eax
unsigned int v7; // [rsp+Ch] [rbp-A4h]
int v8; // [rsp+10h] [rbp-A0h]
unsigned int v9; // [rsp+14h] [rbp-9Ch]
long long v10; // [rsp+18h] [rbp-98h]
unsigned int v11; // [rsp+24h] [rbp-8Ch]
char block_info; // [rsp+28h] [rbp-88h]
int v13; // [rsp+2Ch] [rbp-84h]
long long v15; // [rsp+38h] [rbp-78h]
long long v16; // [rsp+38h] [rbp-78h]
unsigned long long v17; // [rsp+40h] [rbp-70h]
char v19[24]; // [rsp+50h] [rbp-60h] BYREF
const char *v20; // [rsp+68h] [rbp-48h]
unsigned long long v21; // [rsp+70h] [rbp-40h]
long long v22; // [rsp+88h] [rbp-28h]
long long v23; // [rsp+90h] [rbp-20h]
int v24; // [rsp+A0h] [rbp-10h]
unsigned long long v25; // [rsp+A8h] [rbp-8h]
v25 = __readfsqword(0x28u);
v17 = (unsigned long long)a1;
v15 = (long long)a2;
if ( a2 != (const char *)-1LL )
{
v9 = *((_DWORD *)a1 + 112);
v13 = 0;
v24 = 0;
while ( v15 != -1 )
{
if ( (*(_DWORD *)(v17 + 456) & 0x10) != 0
&& *(_QWORD *)(v17 + 544) < (unsigned long long)(v15 + 20)
&& (unsigned int)my_b_flush_io_cache(v17 + 544, 1LL) )
{
goto LABEL_41;
}
*(_DWORD *)(v17 + 768) = 1;
a2 = (const char *)v9;
a1 = v19;
block_info = mi_get_block_info(v19, (const char *)v9, v15);
if ( (block_info & 0x3C) != 0 )
{
if ( (block_info & 0x14) != 0 )
*(_DWORD *)my_thread_var(v19, (const char *)v9) = 134;
goto LABEL_41;
}
if ( !v13++ )
{
if ( (unsigned long long)v20 > (unsigned int)*(_QWORD *)(*(_QWORD *)v17 + 344LL) )
break;
if ( *(_DWORD *)(*(_QWORD *)v17 + 392LL) )
{
a1 = (char *)v17;
a2 = v20;
v10 = mi_alloc_rec_buff(v17, v20, v17 + 288);
if ( !v10 )
goto LABEL_41;
}
else
{
v10 = *(_QWORD *)(v17 + 288);
}
v11 = (unsigned int)v20;
}
if ( v11 < v21 || !v21 )
break;
v8 = v22 - v15;
v7 = 20 - (v22 - v15);
v16 = v15 + 20;
if ( v7 > v21 )
v7 = v21;
if ( v7 )
{
a1 = (char *)v10;
a2 = &v19[v8];
memcpy(v10, a2, v7);
v21 -= v7;
v11 -= v7;
v10 += v7;
}
if ( v21 )
{
if ( (*(_DWORD *)(v17 + 456) & 0x10) != 0
&& *(_QWORD *)(v17 + 544) < v21 + v16
&& (unsigned int)my_b_flush_io_cache(v17 + 544, 1LL) )
{
goto LABEL_41;
}
a1 = (char *)v17;
a2 = (const char *)v10;
if ( (*(long long ( **)(unsigned long long, long long, unsigned long long, long long, long long))(*(_QWORD *)v17 + 736LL))(
v17,
v10,
v21,
v16,
4LL) )
{
break;
}
v11 -= v21;
v10 += v21;
}
v15 = v23;
if ( !v11 )
{
*(_DWORD *)(v17 + 464) |= 2u;
if ( !*(_DWORD *)(*(_QWORD *)v17 + 872LL) )
mi_writeinfo(v17, 0LL);
v4 = mi_rec_unpack(v17, a3, *(unsigned __int8 **)(v17 + 288), (unsigned long long)v20);
v5 = -1;
if ( v4 != -1 )
return 0;
return v5;
}
}
*(_DWORD *)my_thread_var(a1, a2) = 127;
LABEL_41:
mi_writeinfo(v17, 0LL);
return (unsigned int)-1;
}
if ( !*(_DWORD *)(*(_QWORD *)a1 + 872LL) )
mi_writeinfo(a1, 0LL);
return (unsigned int)-1;
}
|
_mi_read_dynamic_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x78],RSI
MOV qword ptr [RBP + -0x80],RDX
MOV EAX,dword ptr [RBP + -0x8c]
MOV dword ptr [RBP + -0x8c],EAX
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x98],RAX
CMP qword ptr [RBP + -0x78],-0x1
JZ 0x001ad2c4
MOV RAX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RAX + 0x1c0]
MOV dword ptr [RBP + -0x9c],EAX
MOV dword ptr [RBP + -0x84],0x0
MOV dword ptr [RBP + -0x10],0x0
LAB_001acfaa:
CMP qword ptr [RBP + -0x78],-0x1
JNZ 0x001acfb6
JMP 0x001ad2ea
LAB_001acfb6:
MOV RAX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RAX + 0x1c8]
AND EAX,0x10
CMP EAX,0x0
JZ 0x001acfff
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x220]
MOV RCX,qword ptr [RBP + -0x78]
ADD RCX,0x14
CMP RAX,RCX
JNC 0x001acfff
MOV RDI,qword ptr [RBP + -0x70]
ADD RDI,0x220
MOV ESI,0x1
CALL 0x001e2310
CMP EAX,0x0
JZ 0x001acfff
JMP 0x001ad2f5
LAB_001acfff:
MOV RAX,qword ptr [RBP + -0x70]
MOV dword ptr [RAX + 0x300],0x1
MOV ESI,dword ptr [RBP + -0x9c]
MOV RDX,qword ptr [RBP + -0x78]
LEA RDI,[RBP + -0x60]
CALL 0x001ab440
MOV dword ptr [RBP + -0x88],EAX
AND EAX,0x3c
CMP EAX,0x0
JZ 0x001ad04c
MOV EAX,dword ptr [RBP + -0x88]
AND EAX,0x14
CMP EAX,0x0
JZ 0x001ad047
CALL 0x001f7a70
MOV dword ptr [RAX],0x86
LAB_001ad047:
JMP 0x001ad2f5
LAB_001ad04c:
MOV EAX,dword ptr [RBP + -0x84]
MOV ECX,EAX
ADD ECX,0x1
MOV dword ptr [RBP + -0x84],ECX
CMP EAX,0x0
JNZ 0x001ad0d8
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x158]
MOV ECX,ECX
CMP RAX,RCX
JBE 0x001ad080
JMP 0x001ad2ea
LAB_001ad080:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x188],0x0
JZ 0x001ad0bc
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x70]
ADD RDX,0x120
CALL 0x001b8500
MOV qword ptr [RBP + -0x98],RAX
CMP RAX,0x0
JNZ 0x001ad0ba
JMP 0x001ad2f5
LAB_001ad0ba:
JMP 0x001ad0ce
LAB_001ad0bc:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x120]
MOV qword ptr [RBP + -0x98],RAX
LAB_001ad0ce:
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x8c],EAX
LAB_001ad0d8:
MOV EAX,dword ptr [RBP + -0x8c]
CMP RAX,qword ptr [RBP + -0x40]
JC 0x001ad0eb
CMP qword ptr [RBP + -0x40],0x0
JNZ 0x001ad0f0
LAB_001ad0eb:
JMP 0x001ad2ea
LAB_001ad0f0:
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr [RBP + -0x78]
MOV dword ptr [RBP + -0xa0],EAX
MOV EAX,dword ptr [RBP + -0xa0]
MOV ECX,EAX
MOV EAX,0x14
SUB RAX,RCX
MOV dword ptr [RBP + -0xa4],EAX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x14
MOV qword ptr [RBP + -0x78],RAX
MOV EAX,dword ptr [RBP + -0xa4]
CMP RAX,qword ptr [RBP + -0x40]
JBE 0x001ad136
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0xa4],EAX
LAB_001ad136:
CMP dword ptr [RBP + -0xa4],0x0
JZ 0x001ad1a0
MOV RDI,qword ptr [RBP + -0x98]
LEA RSI,[RBP + -0x60]
MOV EAX,dword ptr [RBP + -0xa0]
ADD RSI,RAX
MOV EAX,dword ptr [RBP + -0xa4]
MOV EDX,EAX
CALL 0x0012a090
MOV EAX,dword ptr [RBP + -0xa4]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x40]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV ECX,dword ptr [RBP + -0xa4]
MOV EAX,dword ptr [RBP + -0x8c]
SUB EAX,ECX
MOV dword ptr [RBP + -0x8c],EAX
MOV ECX,dword ptr [RBP + -0xa4]
MOV RAX,qword ptr [RBP + -0x98]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x98],RAX
LAB_001ad1a0:
CMP qword ptr [RBP + -0x40],0x0
JZ 0x001ad24d
MOV RAX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RAX + 0x1c8]
AND EAX,0x10
CMP EAX,0x0
JZ 0x001ad1f4
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x220]
MOV RCX,qword ptr [RBP + -0x78]
ADD RCX,qword ptr [RBP + -0x40]
CMP RAX,RCX
JNC 0x001ad1f4
MOV RDI,qword ptr [RBP + -0x70]
ADD RDI,0x220
MOV ESI,0x1
CALL 0x001e2310
CMP EAX,0x0
JZ 0x001ad1f4
JMP 0x001ad2f5
LAB_001ad1f4:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x2e0]
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x98]
MOV RDX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x78]
MOV R8D,0x4
CALL RAX
CMP RAX,0x0
JZ 0x001ad228
JMP 0x001ad2ea
LAB_001ad228:
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x8c]
SUB RAX,RCX
MOV dword ptr [RBP + -0x8c],EAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x98],RAX
LAB_001ad24d:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x78],RAX
CMP dword ptr [RBP + -0x8c],0x0
JNZ 0x001acfaa
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,dword ptr [RAX + 0x1d0]
OR ECX,0x2
MOV dword ptr [RAX + 0x1d0],ECX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x368],0x0
JNZ 0x001ad290
MOV RDI,qword ptr [RBP + -0x70]
XOR ESI,ESI
CALL 0x001b2980
LAB_001ad290:
JMP 0x001ad292
LAB_001ad292:
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RBP + -0x70]
MOV RDX,qword ptr [RAX + 0x120]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x001ac8c0
MOV RDX,RAX
MOV EAX,0xffffffff
XOR ECX,ECX
CMP RDX,-0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x64],EAX
JMP 0x001ad307
LAB_001ad2c4:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x368],0x0
JNZ 0x001ad2df
MOV RDI,qword ptr [RBP + -0x70]
XOR ESI,ESI
CALL 0x001b2980
LAB_001ad2df:
JMP 0x001ad2e1
LAB_001ad2e1:
MOV dword ptr [RBP + -0x64],0xffffffff
JMP 0x001ad307
LAB_001ad2ea:
CALL 0x001f7a70
MOV dword ptr [RAX],0x7f
LAB_001ad2f5:
MOV RDI,qword ptr [RBP + -0x70]
XOR ESI,ESI
CALL 0x001b2980
MOV dword ptr [RBP + -0x64],0xffffffff
LAB_001ad307:
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0xa8],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001ad331
MOV EAX,dword ptr [RBP + -0xa8]
ADD RSP,0xb0
POP RBP
RET
LAB_001ad331:
CALL 0x0012a250
|
int4 _mi_read_dynamic_record(long *param_1,long param_2,int8 param_3)
{
int iVar1;
uint uVar2;
long lVar3;
long lVar4;
int4 *puVar5;
long in_FS_OFFSET;
uint local_ac;
void *local_a0;
uint local_94;
int local_8c;
long local_80;
int4 local_6c;
int1 local_68 [24];
ulong local_50;
ulong local_48;
int8 local_30;
long local_28;
int4 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 == -1) {
if (*(int *)(*param_1 + 0x368) == 0) {
_mi_writeinfo(param_1,0);
}
local_6c = 0xffffffff;
}
else {
lVar4 = param_1[0x38];
local_8c = 0;
local_18 = 0;
local_80 = param_2;
do {
if (local_80 == -1) {
LAB_001ad2ea:
puVar5 = (int4 *)_my_thread_var();
*puVar5 = 0x7f;
LAB_001ad2f5:
_mi_writeinfo(param_1,0);
local_6c = 0xffffffff;
goto LAB_001ad307;
}
if ((((*(uint *)(param_1 + 0x39) & 0x10) != 0) && ((ulong)param_1[0x44] < local_80 + 0x14U))
&& (iVar1 = my_b_flush_io_cache(param_1 + 0x44,1), iVar1 != 0)) goto LAB_001ad2f5;
*(int4 *)(param_1 + 0x60) = 1;
uVar2 = _mi_get_block_info(local_68,(int)lVar4,local_80);
if ((uVar2 & 0x3c) != 0) {
if ((uVar2 & 0x14) != 0) {
puVar5 = (int4 *)_my_thread_var();
*puVar5 = 0x86;
}
goto LAB_001ad2f5;
}
if (local_8c == 0) {
if ((*(ulong *)(*param_1 + 0x158) & 0xffffffff) < local_50) goto LAB_001ad2ea;
if (*(int *)(*param_1 + 0x188) == 0) {
local_a0 = (void *)param_1[0x24];
}
else {
local_a0 = (void *)mi_alloc_rec_buff(param_1,local_50,param_1 + 0x24);
if (local_a0 == (void *)0x0) goto LAB_001ad2f5;
}
local_94 = (uint)local_50;
}
if ((local_94 < local_48) || (local_48 == 0)) goto LAB_001ad2ea;
uVar2 = (int)local_30 - (int)local_80;
local_ac = 0x14 - uVar2;
if (local_48 < local_ac) {
local_ac = (uint)local_48;
}
if (local_ac != 0) {
memcpy(local_a0,local_68 + uVar2,(ulong)local_ac);
local_48 = local_48 - local_ac;
local_94 = local_94 - local_ac;
local_a0 = (void *)((long)local_a0 + (ulong)local_ac);
}
if (local_48 != 0) {
if ((((*(uint *)(param_1 + 0x39) & 0x10) != 0) &&
((ulong)param_1[0x44] < local_80 + 0x14 + local_48)) &&
(iVar1 = my_b_flush_io_cache(param_1 + 0x44,1), iVar1 != 0)) goto LAB_001ad2f5;
lVar3 = (**(code **)(*param_1 + 0x2e0))(param_1,local_a0,local_48,local_80 + 0x14,4);
if (lVar3 != 0) goto LAB_001ad2ea;
local_94 = local_94 - (int)local_48;
local_a0 = (void *)(local_48 + (long)local_a0);
}
local_80 = local_28;
local_8c = local_8c + 1;
} while (local_94 != 0);
*(uint *)(param_1 + 0x3a) = *(uint *)(param_1 + 0x3a) | 2;
if (*(int *)(*param_1 + 0x368) == 0) {
_mi_writeinfo(param_1,0);
}
lVar4 = _mi_rec_unpack(param_1,param_3,param_1[0x24]);
local_6c = 0xffffffff;
if (lVar4 != -1) {
local_6c = 0;
}
}
LAB_001ad307:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_6c;
}
|
|
19,704
|
ELFIO::elfio::load_sections(std::istream&)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio.hpp
|
Elf_Half load_sections( std::istream& stream )
{
Elf_Half entry_size = header->get_section_entry_size();
Elf_Half num = header->get_sections_num();
Elf64_Off offset = header->get_sections_offset();
for ( Elf_Half i = 0; i < num; ++i ) {
section* sec = create_section();
sec->load( stream, (std::streamoff)offset + i * entry_size );
sec->set_index( i );
// To mark that the section is not permitted to reassign address
// during layout calculation
sec->set_address( sec->get_address() );
}
Elf_Half shstrndx = get_section_name_str_index();
if ( SHN_UNDEF != shstrndx ) {
string_section_accessor str_reader( sections[shstrndx] );
for ( Elf_Half i = 0; i < num; ++i ) {
Elf_Word section_offset = sections[i]->get_name_string_offset();
const char* p = str_reader.get_string( section_offset );
if ( p != 0 ) {
sections[i]->set_name( p );
}
}
}
return num;
}
|
O0
|
cpp
|
ELFIO::elfio::load_sections(std::istream&):
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movw %ax, %cx
movq 0x38(%rsp), %rax
movw %cx, 0xc6(%rsp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
movw %ax, %cx
movq 0x38(%rsp), %rax
movw %cx, 0xc4(%rsp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0xd0(%rax)
movq %rax, 0xb8(%rsp)
movw $0x0, 0xb6(%rsp)
movzwl 0xb6(%rsp), %eax
movzwl 0xc4(%rsp), %ecx
cmpl %ecx, %eax
jge 0x1b992
movq 0x38(%rsp), %rdi
callq 0x189b0
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb8(%rsp), %rsi
movzwl 0xb6(%rsp), %eax
movzwl 0xc6(%rsp), %ecx
imull %ecx, %eax
cltq
addq %rax, %rsi
leaq 0x98(%rsp), %rdi
callq 0x18200
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x98(%rsp), %rdx
movq 0xa0(%rsp), %rcx
movq (%rdi), %rax
callq *0xf8(%rax)
movq 0xa8(%rsp), %rdi
movw 0xb6(%rsp), %cx
movq (%rdi), %rax
movzwl %cx, %esi
callq *0xf0(%rax)
movq 0xa8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xa8(%rsp), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
movq 0x30(%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x90(%rax)
movw 0xb6(%rsp), %ax
addw $0x1, %ax
movw %ax, 0xb6(%rsp)
jmp 0x1b89a
movq 0x38(%rsp), %rdi
callq 0x1b3c0
movw %ax, 0x96(%rsp)
movzwl 0x96(%rsp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1bb06
movq 0x38(%rsp), %rdi
movzwl 0x96(%rsp), %esi
callq 0x168d0
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x1b430
movw $0x0, 0x86(%rsp)
movzwl 0x86(%rsp), %eax
movzwl 0xc4(%rsp), %ecx
cmpl %ecx, %eax
jge 0x1bb04
movq 0x38(%rsp), %rdi
movzwl 0x86(%rsp), %esi
callq 0x168d0
movq %rax, %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movl %eax, 0x80(%rsp)
movl 0x80(%rsp), %esi
leaq 0x88(%rsp), %rdi
callq 0x1bf20
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0x1bae9
movq 0x38(%rsp), %rdi
movzwl 0x86(%rsp), %esi
callq 0x168d0
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x153b0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0x152e0
jmp 0x1ba8a
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq 0x58(%rsp), %rsi
callq *%rax
jmp 0x1ba9f
leaq 0x58(%rsp), %rdi
callq 0x15140
leaq 0x57(%rsp), %rdi
callq 0x15210
jmp 0x1bae9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1badd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x15140
leaq 0x57(%rsp), %rdi
callq 0x15210
jmp 0x1bb16
jmp 0x1baeb
movw 0x86(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x86(%rsp)
jmp 0x1b9e2
jmp 0x1bb06
movw 0xc4(%rsp), %ax
addq $0xd8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x153a0
|
_ZN5ELFIO5elfio13load_sectionsERSi:
sub rsp, 0D8h
mov [rsp+0D8h+var_8], rdi
mov [rsp+0D8h+var_10], rsi
mov rax, [rsp+0D8h+var_8]
mov [rsp+0D8h+var_A0], rax
mov rdi, [rax+10h]
mov rax, [rdi]
call qword ptr [rax+40h]
mov cx, ax
mov rax, [rsp+0D8h+var_A0]
mov [rsp+0D8h+var_12], cx
mov rdi, [rax+10h]
mov rax, [rdi]
call qword ptr [rax+0C0h]
mov cx, ax
mov rax, [rsp+0D8h+var_A0]
mov [rsp+0D8h+var_14], cx
mov rdi, [rax+10h]
mov rax, [rdi]
call qword ptr [rax+0D0h]
mov [rsp+0D8h+var_20], rax
mov [rsp+0D8h+var_22], 0
loc_1B89A:
movzx eax, [rsp+0D8h+var_22]
movzx ecx, [rsp+0D8h+var_14]
cmp eax, ecx
jge loc_1B992
mov rdi, [rsp+0D8h+var_A0]; this
call _ZN5ELFIO5elfio14create_sectionEv; ELFIO::elfio::create_section(void)
mov [rsp+0D8h+var_30], rax
mov rax, [rsp+0D8h+var_30]
mov [rsp+0D8h+var_B8], rax
mov rax, [rsp+0D8h+var_10]
mov [rsp+0D8h+var_B0], rax
mov rsi, [rsp+0D8h+var_20]
movzx eax, [rsp+0D8h+var_22]
movzx ecx, [rsp+0D8h+var_12]
imul eax, ecx
cdqe
add rsi, rax
lea rdi, [rsp+0D8h+var_40]
call _ZNSt4fposI11__mbstate_tEC2El; std::fpos<__mbstate_t>::fpos(long)
mov rdi, [rsp+0D8h+var_B8]
mov rsi, [rsp+0D8h+var_B0]
mov rdx, [rsp+0D8h+var_40]
mov rcx, [rsp+0D8h+var_38]
mov rax, [rdi]
call qword ptr [rax+0F8h]
mov rdi, [rsp+0D8h+var_30]
mov cx, [rsp+0D8h+var_22]
mov rax, [rdi]
movzx esi, cx
call qword ptr [rax+0F0h]
mov rax, [rsp+0D8h+var_30]
mov [rsp+0D8h+var_A8], rax
mov rdi, [rsp+0D8h+var_30]
mov rax, [rdi]
call qword ptr [rax+88h]
mov rdi, [rsp+0D8h+var_A8]
mov rsi, rax
mov rax, [rdi]
call qword ptr [rax+90h]
mov ax, [rsp+0D8h+var_22]
add ax, 1
mov [rsp+0D8h+var_22], ax
jmp loc_1B89A
loc_1B992:
mov rdi, [rsp+0D8h+var_A0]; this
call _ZNK5ELFIO5elfio26get_section_name_str_indexEv; ELFIO::elfio::get_section_name_str_index(void)
mov [rsp+0D8h+var_42], ax
movzx ecx, [rsp+0D8h+var_42]
xor eax, eax
cmp eax, ecx
jz loc_1BB06
mov rdi, [rsp+0D8h+var_A0]
movzx esi, [rsp+0D8h+var_42]
call _ZNK5ELFIO5elfio8SectionsixEj; ELFIO::elfio::Sections::operator[](uint)
mov rsi, rax
lea rdi, [rsp+0D8h+var_50]
call _ZN5ELFIO32string_section_accessor_templateINS_7sectionEEC2EPS1_; ELFIO::string_section_accessor_template<ELFIO::section>::string_section_accessor_template(ELFIO::section*)
mov [rsp+0D8h+var_52], 0
loc_1B9E2:
movzx eax, [rsp+0D8h+var_52]
movzx ecx, [rsp+0D8h+var_14]
cmp eax, ecx
jge loc_1BB04
mov rdi, [rsp+0D8h+var_A0]
movzx esi, [rsp+0D8h+var_52]
call _ZNK5ELFIO5elfio8SectionsixEj; ELFIO::elfio::Sections::operator[](uint)
mov rdi, rax
mov rax, [rdi]
call qword ptr [rax+0A8h]
mov [rsp+0D8h+var_58], eax
mov esi, [rsp+0D8h+var_58]
lea rdi, [rsp+0D8h+var_50]
call _ZNK5ELFIO32string_section_accessor_templateINS_7sectionEE10get_stringEj; ELFIO::string_section_accessor_template<ELFIO::section>::get_string(uint)
mov [rsp+0D8h+var_60], rax
cmp [rsp+0D8h+var_60], 0
jz loc_1BAE9
mov rdi, [rsp+0D8h+var_A0]
movzx esi, [rsp+0D8h+var_52]
call _ZNK5ELFIO5elfio8SectionsixEj; ELFIO::elfio::Sections::operator[](uint)
mov [rsp+0D8h+var_D0], rax
mov rax, [rsp+0D8h+var_60]
mov [rsp+0D8h+var_C8], rax
lea rdi, [rsp+0D8h+var_81]
mov [rsp+0D8h+var_C0], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+0D8h+var_C8]
mov rdx, [rsp+0D8h+var_C0]
lea rdi, [rsp+0D8h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
jmp short $+2
loc_1BA8A:
mov rdi, [rsp+0D8h+var_D0]
mov rax, [rdi]
mov rax, [rax+20h]
lea rsi, [rsp+0D8h+var_80]
call rax
jmp short $+2
loc_1BA9F:
lea rdi, [rsp+0D8h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+0D8h+var_81]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_1BAE9
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
jmp short loc_1BADD
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
lea rdi, [rsp+arg_50]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1BADD:
lea rdi, [rsp+arg_4F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_1BB16
loc_1BAE9:
jmp short $+2
loc_1BAEB:
mov ax, [rsp+0D8h+var_52]
add ax, 1
mov [rsp+0D8h+var_52], ax
jmp loc_1B9E2
loc_1BB04:
jmp short $+2
loc_1BB06:
mov ax, [rsp+0D8h+var_14]
add rsp, 0D8h
retn
loc_1BB16:
mov rdi, [rsp+arg_40]
call __Unwind_Resume
|
unsigned __int16 ELFIO::elfio::load_sections(ELFIO::elfio *this, std::istream *a2)
{
long long v2; // rax
long long v3; // rax
long long v4; // rax
long long v6; // [rsp+8h] [rbp-D0h]
long long v7; // [rsp+10h] [rbp-C8h]
long long v8; // [rsp+20h] [rbp-B8h]
std::istream *v9; // [rsp+28h] [rbp-B0h]
long long v10; // [rsp+30h] [rbp-A8h]
char v12; // [rsp+57h] [rbp-81h] BYREF
_BYTE v13[32]; // [rsp+58h] [rbp-80h] BYREF
long long string; // [rsp+78h] [rbp-60h]
unsigned int v15; // [rsp+80h] [rbp-58h]
unsigned __int16 j; // [rsp+86h] [rbp-52h]
long long v17; // [rsp+88h] [rbp-50h] BYREF
unsigned __int16 section_name_str_index; // [rsp+96h] [rbp-42h]
_QWORD v19[2]; // [rsp+98h] [rbp-40h] BYREF
long long section; // [rsp+A8h] [rbp-30h]
unsigned __int16 i; // [rsp+B6h] [rbp-22h]
long long v22; // [rsp+B8h] [rbp-20h]
unsigned __int16 v23; // [rsp+C4h] [rbp-14h]
unsigned __int16 v24; // [rsp+C6h] [rbp-12h]
std::istream *v25; // [rsp+C8h] [rbp-10h]
ELFIO::elfio *v26; // [rsp+D0h] [rbp-8h]
v26 = this;
v25 = a2;
v24 = (*(long long ( **)(_QWORD))(**((_QWORD **)this + 2) + 64LL))(*((_QWORD *)this + 2));
v23 = (*(long long ( **)(_QWORD))(**((_QWORD **)this + 2) + 192LL))(*((_QWORD *)this + 2));
v22 = (*(long long ( **)(_QWORD))(**((_QWORD **)this + 2) + 208LL))(*((_QWORD *)this + 2));
for ( i = 0; i < (int)v23; ++i )
{
section = ELFIO::elfio::create_section(this);
v8 = section;
v9 = v25;
std::fpos<__mbstate_t>::fpos(v19, v24 * i + v22);
(*(void ( **)(long long, std::istream *, _QWORD, _QWORD))(*(_QWORD *)v8 + 248LL))(v8, v9, v19[0], v19[1]);
(*(void ( **)(long long, _QWORD))(*(_QWORD *)section + 240LL))(section, i);
v10 = section;
v2 = (*(long long ( **)(long long))(*(_QWORD *)section + 136LL))(section);
(*(void ( **)(long long, long long))(*(_QWORD *)v10 + 144LL))(v10, v2);
}
section_name_str_index = ELFIO::elfio::get_section_name_str_index(this);
if ( section_name_str_index )
{
v3 = ELFIO::elfio::Sections::operator[](this, section_name_str_index);
ELFIO::string_section_accessor_template<ELFIO::section>::string_section_accessor_template(&v17, v3);
for ( j = 0; j < (int)v23; ++j )
{
v4 = ELFIO::elfio::Sections::operator[](this, j);
v15 = (*(long long ( **)(long long))(*(_QWORD *)v4 + 168LL))(v4);
string = ELFIO::string_section_accessor_template<ELFIO::section>::get_string(&v17, v15);
if ( string )
{
v6 = ELFIO::elfio::Sections::operator[](this, j);
v7 = string;
std::allocator<char>::allocator();
std::string::basic_string(v13, v7, &v12);
(*(void ( **)(long long, _BYTE *))(*(_QWORD *)v6 + 32LL))(v6, v13);
std::string::~string(v13);
std::allocator<char>::~allocator(&v12);
}
}
}
return v23;
}
|
load_sections:
SUB RSP,0xd8
MOV qword ptr [RSP + 0xd0],RDI
MOV qword ptr [RSP + 0xc8],RSI
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x40]
MOV CX,AX
MOV RAX,qword ptr [RSP + 0x38]
MOV word ptr [RSP + 0xc6],CX
MOV RDI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xc0]
MOV CX,AX
MOV RAX,qword ptr [RSP + 0x38]
MOV word ptr [RSP + 0xc4],CX
MOV RDI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xd0]
MOV qword ptr [RSP + 0xb8],RAX
MOV word ptr [RSP + 0xb6],0x0
LAB_0011b89a:
MOVZX EAX,word ptr [RSP + 0xb6]
MOVZX ECX,word ptr [RSP + 0xc4]
CMP EAX,ECX
JGE 0x0011b992
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x001189b0
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV qword ptr [RSP + 0x28],RAX
MOV RSI,qword ptr [RSP + 0xb8]
MOVZX EAX,word ptr [RSP + 0xb6]
MOVZX ECX,word ptr [RSP + 0xc6]
IMUL EAX,ECX
CDQE
ADD RSI,RAX
LEA RDI,[RSP + 0x98]
CALL 0x00118200
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x98]
MOV RCX,qword ptr [RSP + 0xa0]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xf8]
MOV RDI,qword ptr [RSP + 0xa8]
MOV CX,word ptr [RSP + 0xb6]
MOV RAX,qword ptr [RDI]
MOVZX ESI,CX
CALL qword ptr [RAX + 0xf0]
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0xa8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x88]
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,RAX
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x90]
MOV AX,word ptr [RSP + 0xb6]
ADD AX,0x1
MOV word ptr [RSP + 0xb6],AX
JMP 0x0011b89a
LAB_0011b992:
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x0011b3c0
MOV word ptr [RSP + 0x96],AX
MOVZX ECX,word ptr [RSP + 0x96]
XOR EAX,EAX
CMP EAX,ECX
JZ 0x0011bb06
MOV RDI,qword ptr [RSP + 0x38]
MOVZX ESI,word ptr [RSP + 0x96]
CALL 0x001168d0
MOV RSI,RAX
LEA RDI,[RSP + 0x88]
CALL 0x0011b430
MOV word ptr [RSP + 0x86],0x0
LAB_0011b9e2:
MOVZX EAX,word ptr [RSP + 0x86]
MOVZX ECX,word ptr [RSP + 0xc4]
CMP EAX,ECX
JGE 0x0011bb04
MOV RDI,qword ptr [RSP + 0x38]
MOVZX ESI,word ptr [RSP + 0x86]
CALL 0x001168d0
MOV RDI,RAX
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xa8]
MOV dword ptr [RSP + 0x80],EAX
MOV ESI,dword ptr [RSP + 0x80]
LEA RDI,[RSP + 0x88]
CALL 0x0011bf20
MOV qword ptr [RSP + 0x78],RAX
CMP qword ptr [RSP + 0x78],0x0
JZ 0x0011bae9
MOV RDI,qword ptr [RSP + 0x38]
MOVZX ESI,word ptr [RSP + 0x86]
CALL 0x001168d0
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0x57]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x001153b0
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
LAB_0011ba7e:
LEA RDI,[RSP + 0x58]
CALL 0x001152e0
JMP 0x0011ba8a
LAB_0011ba8a:
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x20]
LAB_0011ba96:
LEA RSI,[RSP + 0x58]
CALL RAX
LAB_0011ba9d:
JMP 0x0011ba9f
LAB_0011ba9f:
LEA RDI,[RSP + 0x58]
CALL 0x00115140
LEA RDI,[RSP + 0x57]
CALL 0x00115210
JMP 0x0011bae9
LAB_0011bae9:
JMP 0x0011baeb
LAB_0011baeb:
MOV AX,word ptr [RSP + 0x86]
ADD AX,0x1
MOV word ptr [RSP + 0x86],AX
JMP 0x0011b9e2
LAB_0011bb04:
JMP 0x0011bb06
LAB_0011bb06:
MOV AX,word ptr [RSP + 0xc4]
ADD RSP,0xd8
RET
|
/* ELFIO::elfio::load_sections(std::istream&) */
ushort __thiscall ELFIO::elfio::load_sections(elfio *this,istream *param_1)
{
char *pcVar1;
istream *piVar2;
long *plVar3;
int8 uVar4;
section *psVar5;
int8 extraout_RDX;
allocator local_81;
string local_80 [32];
char *local_60;
uint local_58;
ushort local_52;
string_section_accessor_template<ELFIO::section> local_50 [14];
ushort local_42;
int8 local_40;
int8 local_38;
long *local_30;
ushort local_22;
long local_20;
ushort local_14;
ushort local_12;
istream *local_10;
elfio *local_8;
local_10 = param_1;
local_8 = this;
local_12 = (**(code **)(**(long **)(this + 0x10) + 0x40))();
local_14 = (**(code **)(**(long **)(this + 0x10) + 0xc0))();
local_20 = (**(code **)(**(long **)(this + 0x10) + 0xd0))();
for (local_22 = 0; local_22 < local_14; local_22 = local_22 + 1) {
plVar3 = (long *)create_section(this);
piVar2 = local_10;
local_30 = plVar3;
std::fpos<__mbstate_t>::fpos
((fpos<__mbstate_t> *)&local_40,local_20 + (int)((uint)local_22 * (uint)local_12));
(**(code **)(*plVar3 + 0xf8))(plVar3,piVar2,local_40,local_38);
(**(code **)(*local_30 + 0xf0))(local_30,local_22,extraout_RDX,local_22);
plVar3 = local_30;
uVar4 = (**(code **)(*local_30 + 0x88))();
(**(code **)(*plVar3 + 0x90))(plVar3,uVar4);
}
local_42 = get_section_name_str_index(this);
if (local_42 != 0) {
psVar5 = (section *)Sections::operator[]((Sections *)this,(uint)local_42);
string_section_accessor_template<ELFIO::section>::string_section_accessor_template
(local_50,psVar5);
for (local_52 = 0; local_52 < local_14; local_52 = local_52 + 1) {
plVar3 = (long *)Sections::operator[]((Sections *)this,(uint)local_52);
local_58 = (**(code **)(*plVar3 + 0xa8))();
local_60 = (char *)string_section_accessor_template<ELFIO::section>::get_string
(local_50,local_58);
if (local_60 != (char *)0x0) {
plVar3 = (long *)Sections::operator[]((Sections *)this,(uint)local_52);
pcVar1 = local_60;
std::allocator<char>::allocator();
/* try { // try from 0011ba7e to 0011ba87 has its CatchHandler @ 0011bab5 */
std::__cxx11::string::string(local_80,pcVar1,&local_81);
/* try { // try from 0011ba96 to 0011ba9c has its CatchHandler @ 0011bac5 */
(**(code **)(*plVar3 + 0x20))(plVar3,local_80);
std::__cxx11::string::~string(local_80);
std::allocator<char>::~allocator((allocator<char> *)&local_81);
}
}
}
return local_14;
}
|
|
19,705
|
ELFIO::elfio::load_sections(std::istream&)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio.hpp
|
Elf_Half load_sections( std::istream& stream )
{
Elf_Half entry_size = header->get_section_entry_size();
Elf_Half num = header->get_sections_num();
Elf64_Off offset = header->get_sections_offset();
for ( Elf_Half i = 0; i < num; ++i ) {
section* sec = create_section();
sec->load( stream, (std::streamoff)offset + i * entry_size );
sec->set_index( i );
// To mark that the section is not permitted to reassign address
// during layout calculation
sec->set_address( sec->get_address() );
}
Elf_Half shstrndx = get_section_name_str_index();
if ( SHN_UNDEF != shstrndx ) {
string_section_accessor str_reader( sections[shstrndx] );
for ( Elf_Half i = 0; i < num; ++i ) {
Elf_Word section_offset = sections[i]->get_name_string_offset();
const char* p = str_reader.get_string( section_offset );
if ( p != 0 ) {
sections[i]->set_name( p );
}
}
}
return num;
}
|
O1
|
cpp
|
ELFIO::elfio::load_sections(std::istream&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %r12d
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
movl %eax, %ebp
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0xd0(%rax)
movq %rax, %r15
movzwl %bp, %eax
movq %rax, 0x8(%rsp)
movw %bp, 0x6(%rsp)
testw %bp, %bp
je 0xdc8d
movzwl %r12w, %r13d
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xca4c
movq %rax, %r12
movq (%rax), %rax
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq *0xf8(%rax)
movq (%r12), %rax
movzwl %bp, %esi
movq %r12, %rdi
callq *0xf0(%rax)
movq (%r12), %rax
movq %r12, %rdi
callq *0x88(%rax)
movq (%r12), %rcx
movq %r12, %rdi
movq %rax, %rsi
callq *0x90(%rcx)
incq %rbp
addq %r13, %r15
cmpq %rbp, 0x8(%rsp)
jne 0xdc34
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xdca1
movq (%rdi), %rax
callq *0x100(%rax)
jmp 0xdca3
xorl %eax, %eax
testw %ax, %ax
je 0xdda6
movzwl %ax, %eax
movq (%rbx), %rdx
movq 0x18(%rdx), %rcx
movq 0x20(%rdx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0xdccc
movq (%rcx,%rax,8), %r14
jmp 0xdccf
xorl %r14d, %r14d
cmpw $0x0, 0x6(%rsp)
je 0xdda6
xorl %r15d, %r15d
movq %rbx, 0x10(%rsp)
movq (%rbx), %rax
movq 0x18(%rax), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
testq %r14, %r14
je 0xdd29
movl %eax, %r13d
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
cmpq %r13, %rax
jbe 0xdd29
movq (%r14), %rax
movq %r14, %rdi
callq *0xc0(%rax)
testq %rax, %rax
je 0xdd29
movq %rax, %r12
addq %r13, %r12
jmp 0xdd2c
xorl %r12d, %r12d
testq %r12, %r12
je 0xdd98
movq (%rbx), %rcx
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0xdd4e
movq (%rax,%r15,8), %r13
jmp 0xdd51
xorl %r13d, %r13d
leaq 0x28(%rsp), %rbp
movq %rbp, 0x18(%rsp)
movq %r12, %rdi
callq 0xb0e0
leaq (%rax,%r12), %rdx
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xea5a
movq (%r13), %rax
movq %r13, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
movq 0x10(%rsp), %rbx
je 0xdd98
callq 0xb1a0
incq %r15
cmpq %r15, 0x8(%rsp)
jne 0xdce3
movzwl 0x6(%rsp), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0xddcc
callq 0xb1a0
movq %rbx, %rdi
callq 0xb360
|
_ZN5ELFIO5elfio13load_sectionsERSi:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r14, rsi
mov rbx, rdi
mov rdi, [rdi+10h]
mov rax, [rdi]
call qword ptr [rax+40h]
mov r12d, eax
mov rdi, [rbx+10h]
mov rax, [rdi]
call qword ptr [rax+0C0h]
mov ebp, eax
mov rdi, [rbx+10h]
mov rax, [rdi]
call qword ptr [rax+0D0h]
mov r15, rax
movzx eax, bp
mov [rsp+68h+var_60], rax
mov [rsp+68h+var_62], bp
test bp, bp
jz short loc_DC8D
movzx r13d, r12w
xor ebp, ebp
loc_DC34:
mov rdi, rbx; this
call _ZN5ELFIO5elfio14create_sectionEv; ELFIO::elfio::create_section(void)
mov r12, rax
mov rax, [rax]
mov rdi, r12
mov rsi, r14
mov rdx, r15
xor ecx, ecx
call qword ptr [rax+0F8h]
mov rax, [r12]
movzx esi, bp
mov rdi, r12
call qword ptr [rax+0F0h]
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+88h]
mov rcx, [r12]
mov rdi, r12
mov rsi, rax
call qword ptr [rcx+90h]
inc rbp
add r15, r13
cmp [rsp+68h+var_60], rbp
jnz short loc_DC34
loc_DC8D:
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_DCA1
mov rax, [rdi]
call qword ptr [rax+100h]
jmp short loc_DCA3
loc_DCA1:
xor eax, eax
loc_DCA3:
test ax, ax
jz loc_DDA6
movzx eax, ax
mov rdx, [rbx]
mov rcx, [rdx+18h]
mov rdx, [rdx+20h]
sub rdx, rcx
sar rdx, 3
cmp rdx, rax
jbe short loc_DCCC
mov r14, [rcx+rax*8]
jmp short loc_DCCF
loc_DCCC:
xor r14d, r14d
loc_DCCF:
cmp [rsp+68h+var_62], 0
jz loc_DDA6
xor r15d, r15d
mov [rsp+68h+var_58], rbx
loc_DCE3:
mov rax, [rbx]
mov rax, [rax+18h]
mov rdi, [rax+r15*8]
mov rax, [rdi]
call qword ptr [rax+0A8h]
test r14, r14
jz short loc_DD29
mov r13d, eax
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+98h]
cmp rax, r13
jbe short loc_DD29
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+0C0h]
test rax, rax
jz short loc_DD29
mov r12, rax
add r12, r13
jmp short loc_DD2C
loc_DD29:
xor r12d, r12d
loc_DD2C:
test r12, r12
jz short loc_DD98
mov rcx, [rbx]
mov rax, [rcx+18h]
mov rcx, [rcx+20h]
sub rcx, rax
sar rcx, 3
cmp rcx, r15
jbe short loc_DD4E
mov r13, [rax+r15*8]
jmp short loc_DD51
loc_DD4E:
xor r13d, r13d
loc_DD51:
lea rbp, [rsp+68h+var_40]
mov [rsp+68h+var_50], rbp
mov rdi, r12
call _strlen
lea rdx, [rax+r12]
lea rbx, [rsp+68h+var_50]
mov rdi, rbx
mov rsi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rax, [r13+0]
mov rdi, r13
mov rsi, rbx
call qword ptr [rax+20h]
mov rdi, [rsp+68h+var_50]; void *
cmp rdi, rbp
mov rbx, [rsp+68h+var_58]
jz short loc_DD98
call __ZdlPv; operator delete(void *)
loc_DD98:
inc r15
cmp [rsp+68h+var_60], r15
jnz loc_DCE3
loc_DDA6:
movzx eax, [rsp+68h+var_62]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_10]; void *
cmp rdi, rbp
jz short loc_DDCC
call __ZdlPv; operator delete(void *)
loc_DDCC:
mov rdi, rbx
call __Unwind_Resume
|
long long ELFIO::elfio::load_sections(ELFIO::elfio *this, std::istream *a2)
{
ELFIO::elfio *v2; // rbx
unsigned __int16 v3; // r12
unsigned __int16 v4; // bp
long long v5; // r15
long long v6; // r13
long long v7; // rbp
long long section; // r12
long long v9; // rax
long long v10; // rdi
unsigned __int16 v11; // ax
long long v12; // rcx
long long v13; // r14
unsigned long long v14; // r15
long long v15; // rdi
unsigned int v16; // eax
long long v17; // r13
long long v18; // rax
long long v19; // r12
long long v20; // rax
long long v21; // r13
long long v22; // rax
unsigned __int16 v24; // [rsp+6h] [rbp-62h]
long long v25; // [rsp+8h] [rbp-60h]
ELFIO::elfio *v26; // [rsp+10h] [rbp-58h]
void *v27[2]; // [rsp+18h] [rbp-50h] BYREF
_BYTE v28[64]; // [rsp+28h] [rbp-40h] BYREF
v2 = this;
v3 = (*(long long ( **)(_QWORD))(**((_QWORD **)this + 2) + 64LL))(*((_QWORD *)this + 2));
v4 = (*(long long ( **)(_QWORD))(**((_QWORD **)v2 + 2) + 192LL))(*((_QWORD *)v2 + 2));
v5 = (*(long long ( **)(_QWORD))(**((_QWORD **)v2 + 2) + 208LL))(*((_QWORD *)v2 + 2));
v25 = v4;
v24 = v4;
if ( v4 )
{
v6 = v3;
v7 = 0LL;
do
{
section = ELFIO::elfio::create_section(this);
(*(void ( **)(long long, std::istream *, long long, _QWORD))(*(_QWORD *)section + 248LL))(
section,
a2,
v5,
0LL);
(*(void ( **)(long long, _QWORD))(*(_QWORD *)section + 240LL))(section, (unsigned __int16)v7);
v9 = (*(long long ( **)(long long))(*(_QWORD *)section + 136LL))(section);
(*(void ( **)(long long, long long))(*(_QWORD *)section + 144LL))(section, v9);
++v7;
v5 += v6;
}
while ( v25 != v7 );
}
v10 = *((_QWORD *)this + 2);
if ( v10 )
v11 = (*(long long ( **)(long long))(*(_QWORD *)v10 + 256LL))(v10);
else
v11 = 0;
if ( v11 )
{
v12 = *(_QWORD *)(*(_QWORD *)v2 + 24LL);
v13 = (*(_QWORD *)(*(_QWORD *)v2 + 32LL) - v12) >> 3 <= (unsigned long long)v11 ? 0LL : *(_QWORD *)(v12 + 8LL * v11);
if ( v24 )
{
v14 = 0LL;
v26 = v2;
do
{
v15 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)v2 + 24LL) + 8 * v14);
v16 = (*(long long ( **)(long long))(*(_QWORD *)v15 + 168LL))(v15);
if ( v13
&& (v17 = v16, (*(long long ( **)(long long))(*(_QWORD *)v13 + 152LL))(v13) > (unsigned long long)v16)
&& (v18 = (*(long long ( **)(long long))(*(_QWORD *)v13 + 192LL))(v13)) != 0 )
{
v19 = v17 + v18;
}
else
{
v19 = 0LL;
}
if ( v19 )
{
v20 = *(_QWORD *)(*(_QWORD *)v2 + 24LL);
if ( (*(_QWORD *)(*(_QWORD *)v2 + 32LL) - v20) >> 3 <= v14 )
v21 = 0LL;
else
v21 = *(_QWORD *)(v20 + 8 * v14);
v27[0] = v28;
v22 = strlen(v19);
std::string::_M_construct<char const*>(v27, v19, v22 + v19);
(*(void ( **)(long long, void **))(*(_QWORD *)v21 + 32LL))(v21, v27);
v2 = v26;
if ( v27[0] != v28 )
operator delete(v27[0]);
}
++v14;
}
while ( v25 != v14 );
}
}
return v24;
}
|
load_sections:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x40]
MOV R12D,EAX
MOV RDI,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xc0]
MOV EBP,EAX
MOV RDI,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xd0]
MOV R15,RAX
MOVZX EAX,BP
MOV qword ptr [RSP + 0x8],RAX
MOV word ptr [RSP + 0x6],BP
TEST BP,BP
JZ 0x0010dc8d
MOVZX R13D,R12W
XOR EBP,EBP
LAB_0010dc34:
MOV RDI,RBX
CALL 0x0010ca4c
MOV R12,RAX
MOV RAX,qword ptr [RAX]
MOV RDI,R12
MOV RSI,R14
MOV RDX,R15
XOR ECX,ECX
CALL qword ptr [RAX + 0xf8]
MOV RAX,qword ptr [R12]
MOVZX ESI,BP
MOV RDI,R12
CALL qword ptr [RAX + 0xf0]
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x88]
MOV RCX,qword ptr [R12]
MOV RDI,R12
MOV RSI,RAX
CALL qword ptr [RCX + 0x90]
INC RBP
ADD R15,R13
CMP qword ptr [RSP + 0x8],RBP
JNZ 0x0010dc34
LAB_0010dc8d:
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x0010dca1
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x100]
JMP 0x0010dca3
LAB_0010dca1:
XOR EAX,EAX
LAB_0010dca3:
TEST AX,AX
JZ 0x0010dda6
MOVZX EAX,AX
MOV RDX,qword ptr [RBX]
MOV RCX,qword ptr [RDX + 0x18]
MOV RDX,qword ptr [RDX + 0x20]
SUB RDX,RCX
SAR RDX,0x3
CMP RDX,RAX
JBE 0x0010dccc
MOV R14,qword ptr [RCX + RAX*0x8]
JMP 0x0010dccf
LAB_0010dccc:
XOR R14D,R14D
LAB_0010dccf:
CMP word ptr [RSP + 0x6],0x0
JZ 0x0010dda6
XOR R15D,R15D
MOV qword ptr [RSP + 0x10],RBX
LAB_0010dce3:
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + 0x18]
MOV RDI,qword ptr [RAX + R15*0x8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xa8]
TEST R14,R14
JZ 0x0010dd29
MOV R13D,EAX
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x98]
CMP RAX,R13
JBE 0x0010dd29
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0xc0]
TEST RAX,RAX
JZ 0x0010dd29
MOV R12,RAX
ADD R12,R13
JMP 0x0010dd2c
LAB_0010dd29:
XOR R12D,R12D
LAB_0010dd2c:
TEST R12,R12
JZ 0x0010dd98
MOV RCX,qword ptr [RBX]
MOV RAX,qword ptr [RCX + 0x18]
MOV RCX,qword ptr [RCX + 0x20]
SUB RCX,RAX
SAR RCX,0x3
CMP RCX,R15
JBE 0x0010dd4e
MOV R13,qword ptr [RAX + R15*0x8]
JMP 0x0010dd51
LAB_0010dd4e:
XOR R13D,R13D
LAB_0010dd51:
LEA RBP,[RSP + 0x28]
MOV qword ptr [RSP + 0x18],RBP
MOV RDI,R12
CALL 0x0010b0e0
LEA RDX,[RAX + R12*0x1]
LEA RBX,[RSP + 0x18]
MOV RDI,RBX
MOV RSI,R12
CALL 0x0010ea5a
MOV RAX,qword ptr [R13]
LAB_0010dd7b:
MOV RDI,R13
MOV RSI,RBX
CALL qword ptr [RAX + 0x20]
LAB_0010dd84:
MOV RDI,qword ptr [RSP + 0x18]
CMP RDI,RBP
MOV RBX,qword ptr [RSP + 0x10]
JZ 0x0010dd98
CALL 0x0010b1a0
LAB_0010dd98:
INC R15
CMP qword ptr [RSP + 0x8],R15
JNZ 0x0010dce3
LAB_0010dda6:
MOVZX EAX,word ptr [RSP + 0x6]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ELFIO::elfio::load_sections(std::istream&) */
ushort __thiscall ELFIO::elfio::load_sections(elfio *this,istream *param_1)
{
ushort uVar1;
ushort uVar2;
uint uVar3;
long lVar4;
long *plVar5;
int8 uVar6;
ulong uVar7;
size_t sVar8;
ulong uVar9;
char *__s;
long *plVar10;
int1 *local_50 [2];
int1 local_40 [16];
uVar1 = (**(code **)(**(long **)(this + 0x10) + 0x40))();
uVar2 = (**(code **)(**(long **)(this + 0x10) + 0xc0))();
lVar4 = (**(code **)(**(long **)(this + 0x10) + 0xd0))();
if (uVar2 != 0) {
uVar9 = 0;
do {
plVar5 = (long *)create_section(this);
(**(code **)(*plVar5 + 0xf8))(plVar5,param_1,lVar4,0);
(**(code **)(*plVar5 + 0xf0))(plVar5,uVar9 & 0xffff);
uVar6 = (**(code **)(*plVar5 + 0x88))(plVar5);
(**(code **)(*plVar5 + 0x90))(plVar5,uVar6);
uVar9 = uVar9 + 1;
lVar4 = lVar4 + (ulong)uVar1;
} while (uVar2 != uVar9);
}
if (*(long **)(this + 0x10) == (long *)0x0) {
uVar1 = 0;
}
else {
uVar1 = (**(code **)(**(long **)(this + 0x10) + 0x100))();
}
if (uVar1 != 0) {
lVar4 = *(long *)(*(long *)this + 0x18);
if ((ulong)uVar1 < (ulong)(*(long *)(*(long *)this + 0x20) - lVar4 >> 3)) {
plVar5 = *(long **)(lVar4 + (ulong)uVar1 * 8);
}
else {
plVar5 = (long *)0x0;
}
if (uVar2 != 0) {
uVar9 = 0;
do {
uVar3 = (**(code **)(**(long **)(*(long *)(*(long *)this + 0x18) + uVar9 * 8) + 0xa8))();
if (plVar5 == (long *)0x0) {
LAB_0010dd29:
__s = (char *)0x0;
}
else {
uVar7 = (**(code **)(*plVar5 + 0x98))(plVar5);
if (uVar7 <= uVar3) goto LAB_0010dd29;
lVar4 = (**(code **)(*plVar5 + 0xc0))(plVar5);
if (lVar4 == 0) goto LAB_0010dd29;
__s = (char *)(lVar4 + (ulong)uVar3);
}
if (__s != (char *)0x0) {
lVar4 = *(long *)(*(long *)this + 0x18);
if (uVar9 < (ulong)(*(long *)(*(long *)this + 0x20) - lVar4 >> 3)) {
plVar10 = *(long **)(lVar4 + uVar9 * 8);
}
else {
plVar10 = (long *)0x0;
}
local_50[0] = local_40;
sVar8 = strlen(__s);
std::__cxx11::string::_M_construct<char_const*>(local_50,__s,__s + sVar8);
/* try { // try from 0010dd7b to 0010dd83 has its CatchHandler @ 0010ddba */
(**(code **)(*plVar10 + 0x20))(plVar10,local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0]);
}
}
uVar9 = uVar9 + 1;
} while (uVar2 != uVar9);
}
}
return uVar2;
}
|
|
19,706
|
ELFIO::elfio::load_sections(std::istream&)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio.hpp
|
Elf_Half load_sections( std::istream& stream )
{
Elf_Half entry_size = header->get_section_entry_size();
Elf_Half num = header->get_sections_num();
Elf64_Off offset = header->get_sections_offset();
for ( Elf_Half i = 0; i < num; ++i ) {
section* sec = create_section();
sec->load( stream, (std::streamoff)offset + i * entry_size );
sec->set_index( i );
// To mark that the section is not permitted to reassign address
// during layout calculation
sec->set_address( sec->get_address() );
}
Elf_Half shstrndx = get_section_name_str_index();
if ( SHN_UNDEF != shstrndx ) {
string_section_accessor str_reader( sections[shstrndx] );
for ( Elf_Half i = 0; i < num; ++i ) {
Elf_Word section_offset = sections[i]->get_name_string_offset();
const char* p = str_reader.get_string( section_offset );
if ( p != 0 ) {
sections[i]->set_name( p );
}
}
}
return num;
}
|
O3
|
cpp
|
ELFIO::elfio::load_sections(std::istream&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %r12d
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
movl %eax, %ebx
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0xd0(%rax)
movw %bx, 0x6(%rsp)
testw %bx, %bx
je 0xdc3e
movq %rax, %r15
movzwl %r12w, %r13d
movzwl 0x6(%rsp), %ebp
xorl %ebx, %ebx
movq %r14, %rdi
callq 0xc9fc
movq %rax, %r12
movq (%rax), %rax
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq *0xf8(%rax)
movq (%r12), %rax
movzwl %bx, %esi
movq %r12, %rdi
callq *0xf0(%rax)
movq (%r12), %rax
movq %r12, %rdi
callq *0x88(%rax)
movq (%r12), %rcx
movq %r12, %rdi
movq %rax, %rsi
callq *0x90(%rcx)
incq %rbx
addq %r13, %r15
cmpq %rbx, %rbp
jne 0xdbe5
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xdd67
movq %r14, %r13
movq (%rdi), %rax
callq *0x100(%rax)
testw %ax, %ax
je 0xdd67
movzwl %ax, %eax
movq (%r13), %rdx
movq 0x18(%rdx), %rcx
movq 0x20(%rdx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0xdc81
movq (%rcx,%rax,8), %r14
jmp 0xdc84
xorl %r14d, %r14d
cmpw $0x0, 0x6(%rsp)
je 0xdd67
movzwl 0x6(%rsp), %r15d
xorl %ebp, %ebp
movq %r15, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq (%r13), %rax
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
testq %r14, %r14
je 0xdd5b
movl %eax, %ebx
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
cmpq %rbx, %rax
jbe 0xdd5b
movq (%r14), %rax
movq %r14, %rdi
callq *0xc0(%rax)
testq %rax, %rax
je 0xdd5b
movq %rax, %r12
movq (%r13), %rcx
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
jbe 0xdd09
movq (%rax,%rbp,8), %r13
jmp 0xdd0c
xorl %r13d, %r13d
addq %rbx, %r12
leaq 0x28(%rsp), %rbx
movq %rbx, 0x18(%rsp)
movq %r12, %rdi
callq 0xb0e0
leaq (%rax,%r12), %rdx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xe9da
movq (%r13), %rax
movq %r13, %rdi
movq %r15, %rsi
callq *0x20(%rax)
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
movq 0x10(%rsp), %r13
movq 0x8(%rsp), %r15
je 0xdd5b
callq 0xb1a0
incq %rbp
cmpq %rbp, %r15
jne 0xdca2
movzwl 0x6(%rsp), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rcx
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %rcx, %rdi
je 0xdd90
callq 0xb1a0
movq %rbx, %rdi
callq 0xb360
|
_ZN5ELFIO5elfio13load_sectionsERSi:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rsp+68h+var_60], rsi
mov r14, rdi
mov rdi, [rdi+10h]
mov rax, [rdi]
call qword ptr [rax+40h]
mov r12d, eax
mov rdi, [r14+10h]
mov rax, [rdi]
call qword ptr [rax+0C0h]
mov ebx, eax
mov rdi, [r14+10h]
mov rax, [rdi]
call qword ptr [rax+0D0h]
mov [rsp+68h+var_62], bx
test bx, bx
jz short loc_DC3E
mov r15, rax
movzx r13d, r12w
movzx ebp, [rsp+68h+var_62]
xor ebx, ebx
loc_DBE5:
mov rdi, r14; this
call _ZN5ELFIO5elfio14create_sectionEv; ELFIO::elfio::create_section(void)
mov r12, rax
mov rax, [rax]
mov rdi, r12
mov rsi, [rsp+68h+var_60]
mov rdx, r15
xor ecx, ecx
call qword ptr [rax+0F8h]
mov rax, [r12]
movzx esi, bx
mov rdi, r12
call qword ptr [rax+0F0h]
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+88h]
mov rcx, [r12]
mov rdi, r12
mov rsi, rax
call qword ptr [rcx+90h]
inc rbx
add r15, r13
cmp rbp, rbx
jnz short loc_DBE5
loc_DC3E:
mov rdi, [r14+10h]
test rdi, rdi
jz loc_DD67
mov r13, r14
mov rax, [rdi]
call qword ptr [rax+100h]
test ax, ax
jz loc_DD67
movzx eax, ax
mov rdx, [r13+0]
mov rcx, [rdx+18h]
mov rdx, [rdx+20h]
sub rdx, rcx
sar rdx, 3
cmp rdx, rax
jbe short loc_DC81
mov r14, [rcx+rax*8]
jmp short loc_DC84
loc_DC81:
xor r14d, r14d
loc_DC84:
cmp [rsp+68h+var_62], 0
jz loc_DD67
movzx r15d, [rsp+68h+var_62]
xor ebp, ebp
mov [rsp+68h+var_60], r15
mov [rsp+68h+var_58], r13
loc_DCA2:
mov rax, [r13+0]
mov rax, [rax+18h]
mov rdi, [rax+rbp*8]
mov rax, [rdi]
call qword ptr [rax+0A8h]
test r14, r14
jz loc_DD5B
mov ebx, eax
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+98h]
cmp rax, rbx
jbe loc_DD5B
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+0C0h]
test rax, rax
jz short loc_DD5B
mov r12, rax
mov rcx, [r13+0]
mov rax, [rcx+18h]
mov rcx, [rcx+20h]
sub rcx, rax
sar rcx, 3
cmp rcx, rbp
jbe short loc_DD09
mov r13, [rax+rbp*8]
jmp short loc_DD0C
loc_DD09:
xor r13d, r13d
loc_DD0C:
add r12, rbx
lea rbx, [rsp+68h+var_40]
mov [rsp+68h+var_50], rbx
mov rdi, r12
call _strlen
lea rdx, [rax+r12]
lea r15, [rsp+68h+var_50]
mov rdi, r15
mov rsi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rax, [r13+0]
mov rdi, r13
mov rsi, r15
call qword ptr [rax+20h]
mov rdi, [rsp+68h+var_50]; void *
cmp rdi, rbx
mov r13, [rsp+68h+var_58]
mov r15, [rsp+68h+var_60]
jz short loc_DD5B
call __ZdlPv; operator delete(void *)
loc_DD5B:
inc rbp
cmp r15, rbp
jnz loc_DCA2
loc_DD67:
movzx eax, [rsp+68h+var_62]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rcx, rbx
mov rbx, rax
mov rdi, [rsp+arg_10]; void *
cmp rdi, rcx
jz short loc_DD90
call __ZdlPv; operator delete(void *)
loc_DD90:
mov rdi, rbx
call __Unwind_Resume
|
long long ELFIO::elfio::load_sections(ELFIO::elfio *this, std::istream *a2)
{
unsigned __int16 v3; // r12
unsigned __int16 v4; // bx
long long v5; // rax
long long v6; // r15
long long v7; // r13
long long v8; // rbx
long long section; // r12
long long v10; // rax
long long v11; // rdi
ELFIO::elfio *v12; // r13
unsigned __int16 v13; // ax
long long v14; // rcx
long long v15; // r14
long long v16; // r15
unsigned long long v17; // rbp
long long v18; // rdi
unsigned int v19; // eax
long long v20; // rbx
long long v21; // rax
long long v22; // r12
long long v23; // rax
long long v24; // r13
long long v25; // r12
long long v26; // rax
unsigned __int16 v28; // [rsp+6h] [rbp-62h]
ELFIO::elfio *v29; // [rsp+10h] [rbp-58h]
void *v30[2]; // [rsp+18h] [rbp-50h] BYREF
_BYTE v31[64]; // [rsp+28h] [rbp-40h] BYREF
v3 = (*(long long ( **)(_QWORD))(**((_QWORD **)this + 2) + 64LL))(*((_QWORD *)this + 2));
v4 = (*(long long ( **)(_QWORD))(**((_QWORD **)this + 2) + 192LL))(*((_QWORD *)this + 2));
v5 = (*(long long ( **)(_QWORD))(**((_QWORD **)this + 2) + 208LL))(*((_QWORD *)this + 2));
v28 = v4;
if ( v4 )
{
v6 = v5;
v7 = v3;
v8 = 0LL;
do
{
section = ELFIO::elfio::create_section(this);
(*(void ( **)(long long, std::istream *, long long, _QWORD))(*(_QWORD *)section + 248LL))(
section,
a2,
v6,
0LL);
(*(void ( **)(long long, _QWORD))(*(_QWORD *)section + 240LL))(section, (unsigned __int16)v8);
v10 = (*(long long ( **)(long long))(*(_QWORD *)section + 136LL))(section);
(*(void ( **)(long long, long long))(*(_QWORD *)section + 144LL))(section, v10);
++v8;
v6 += v7;
}
while ( v28 != v8 );
}
v11 = *((_QWORD *)this + 2);
if ( v11 )
{
v12 = this;
v13 = (*(long long ( **)(long long))(*(_QWORD *)v11 + 256LL))(v11);
if ( v13 )
{
v14 = *(_QWORD *)(*(_QWORD *)this + 24LL);
v15 = (*(_QWORD *)(*(_QWORD *)this + 32LL) - v14) >> 3 <= (unsigned long long)v13
? 0LL
: *(_QWORD *)(v14 + 8LL * v13);
if ( v28 )
{
v16 = v28;
v17 = 0LL;
v29 = v12;
do
{
v18 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)v12 + 24LL) + 8 * v17);
v19 = (*(long long ( **)(long long))(*(_QWORD *)v18 + 168LL))(v18);
if ( v15 )
{
v20 = v19;
if ( (*(long long ( **)(long long))(*(_QWORD *)v15 + 152LL))(v15) > (unsigned long long)v19 )
{
v21 = (*(long long ( **)(long long))(*(_QWORD *)v15 + 192LL))(v15);
if ( v21 )
{
v22 = v21;
v23 = *(_QWORD *)(*(_QWORD *)v12 + 24LL);
if ( (*(_QWORD *)(*(_QWORD *)v12 + 32LL) - v23) >> 3 <= v17 )
v24 = 0LL;
else
v24 = *(_QWORD *)(v23 + 8 * v17);
v25 = v20 + v22;
v30[0] = v31;
v26 = strlen(v25);
std::string::_M_construct<char const*>(v30, v25, v26 + v25);
(*(void ( **)(long long, void **))(*(_QWORD *)v24 + 32LL))(v24, v30);
v12 = v29;
v16 = v28;
if ( v30[0] != v31 )
operator delete(v30[0]);
}
}
}
++v17;
}
while ( v16 != v17 );
}
}
}
return v28;
}
|
load_sections:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x8],RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x40]
MOV R12D,EAX
MOV RDI,qword ptr [R14 + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xc0]
MOV EBX,EAX
MOV RDI,qword ptr [R14 + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xd0]
MOV word ptr [RSP + 0x6],BX
TEST BX,BX
JZ 0x0010dc3e
MOV R15,RAX
MOVZX R13D,R12W
MOVZX EBP,word ptr [RSP + 0x6]
XOR EBX,EBX
LAB_0010dbe5:
MOV RDI,R14
CALL 0x0010c9fc
MOV R12,RAX
MOV RAX,qword ptr [RAX]
MOV RDI,R12
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R15
XOR ECX,ECX
CALL qword ptr [RAX + 0xf8]
MOV RAX,qword ptr [R12]
MOVZX ESI,BX
MOV RDI,R12
CALL qword ptr [RAX + 0xf0]
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x88]
MOV RCX,qword ptr [R12]
MOV RDI,R12
MOV RSI,RAX
CALL qword ptr [RCX + 0x90]
INC RBX
ADD R15,R13
CMP RBP,RBX
JNZ 0x0010dbe5
LAB_0010dc3e:
MOV RDI,qword ptr [R14 + 0x10]
TEST RDI,RDI
JZ 0x0010dd67
MOV R13,R14
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x100]
TEST AX,AX
JZ 0x0010dd67
MOVZX EAX,AX
MOV RDX,qword ptr [R13]
MOV RCX,qword ptr [RDX + 0x18]
MOV RDX,qword ptr [RDX + 0x20]
SUB RDX,RCX
SAR RDX,0x3
CMP RDX,RAX
JBE 0x0010dc81
MOV R14,qword ptr [RCX + RAX*0x8]
JMP 0x0010dc84
LAB_0010dc81:
XOR R14D,R14D
LAB_0010dc84:
CMP word ptr [RSP + 0x6],0x0
JZ 0x0010dd67
MOVZX R15D,word ptr [RSP + 0x6]
XOR EBP,EBP
MOV qword ptr [RSP + 0x8],R15
MOV qword ptr [RSP + 0x10],R13
LAB_0010dca2:
MOV RAX,qword ptr [R13]
MOV RAX,qword ptr [RAX + 0x18]
MOV RDI,qword ptr [RAX + RBP*0x8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xa8]
TEST R14,R14
JZ 0x0010dd5b
MOV EBX,EAX
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x98]
CMP RAX,RBX
JBE 0x0010dd5b
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0xc0]
TEST RAX,RAX
JZ 0x0010dd5b
MOV R12,RAX
MOV RCX,qword ptr [R13]
MOV RAX,qword ptr [RCX + 0x18]
MOV RCX,qword ptr [RCX + 0x20]
SUB RCX,RAX
SAR RCX,0x3
CMP RCX,RBP
JBE 0x0010dd09
MOV R13,qword ptr [RAX + RBP*0x8]
JMP 0x0010dd0c
LAB_0010dd09:
XOR R13D,R13D
LAB_0010dd0c:
ADD R12,RBX
LEA RBX,[RSP + 0x28]
MOV qword ptr [RSP + 0x18],RBX
MOV RDI,R12
CALL 0x0010b0e0
LEA RDX,[RAX + R12*0x1]
LEA R15,[RSP + 0x18]
MOV RDI,R15
MOV RSI,R12
CALL 0x0010e9da
MOV RAX,qword ptr [R13]
LAB_0010dd39:
MOV RDI,R13
MOV RSI,R15
CALL qword ptr [RAX + 0x20]
LAB_0010dd42:
MOV RDI,qword ptr [RSP + 0x18]
CMP RDI,RBX
MOV R13,qword ptr [RSP + 0x10]
MOV R15,qword ptr [RSP + 0x8]
JZ 0x0010dd5b
CALL 0x0010b1a0
LAB_0010dd5b:
INC RBP
CMP R15,RBP
JNZ 0x0010dca2
LAB_0010dd67:
MOVZX EAX,word ptr [RSP + 0x6]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ELFIO::elfio::load_sections(std::istream&) */
ushort __thiscall ELFIO::elfio::load_sections(elfio *this,istream *param_1)
{
long lVar1;
ushort uVar2;
ushort uVar3;
uint uVar4;
long lVar5;
long *plVar6;
int8 uVar7;
ulong uVar8;
size_t sVar9;
ulong uVar10;
char *__s;
long *plVar11;
int1 *local_50 [2];
int1 local_40 [16];
uVar2 = (**(code **)(**(long **)(this + 0x10) + 0x40))();
uVar3 = (**(code **)(**(long **)(this + 0x10) + 0xc0))();
lVar5 = (**(code **)(**(long **)(this + 0x10) + 0xd0))();
if (uVar3 != 0) {
uVar10 = 0;
do {
plVar6 = (long *)create_section(this);
(**(code **)(*plVar6 + 0xf8))(plVar6,param_1,lVar5,0);
(**(code **)(*plVar6 + 0xf0))(plVar6,uVar10 & 0xffff);
uVar7 = (**(code **)(*plVar6 + 0x88))(plVar6);
(**(code **)(*plVar6 + 0x90))(plVar6,uVar7);
uVar10 = uVar10 + 1;
lVar5 = lVar5 + (ulong)uVar2;
} while (uVar3 != uVar10);
}
if (*(long **)(this + 0x10) != (long *)0x0) {
uVar2 = (**(code **)(**(long **)(this + 0x10) + 0x100))();
if (uVar2 != 0) {
lVar5 = *(long *)(*(long *)this + 0x18);
if ((ulong)uVar2 < (ulong)(*(long *)(*(long *)this + 0x20) - lVar5 >> 3)) {
plVar6 = *(long **)(lVar5 + (ulong)uVar2 * 8);
}
else {
plVar6 = (long *)0x0;
}
if (uVar3 != 0) {
uVar10 = 0;
do {
uVar4 = (**(code **)(**(long **)(*(long *)(*(long *)this + 0x18) + uVar10 * 8) + 0xa8))();
if (plVar6 != (long *)0x0) {
uVar8 = (**(code **)(*plVar6 + 0x98))(plVar6);
if (uVar4 < uVar8) {
lVar5 = (**(code **)(*plVar6 + 0xc0))(plVar6);
if (lVar5 != 0) {
lVar1 = *(long *)(*(long *)this + 0x18);
if (uVar10 < (ulong)(*(long *)(*(long *)this + 0x20) - lVar1 >> 3)) {
plVar11 = *(long **)(lVar1 + uVar10 * 8);
}
else {
plVar11 = (long *)0x0;
}
__s = (char *)(lVar5 + (ulong)uVar4);
local_50[0] = local_40;
sVar9 = strlen(__s);
std::__cxx11::string::_M_construct<char_const*>(local_50,__s,__s + sVar9);
/* try { // try from 0010dd39 to 0010dd41 has its CatchHandler @ 0010dd7b */
(**(code **)(*plVar11 + 0x20))(plVar11,local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0]);
}
}
}
}
uVar10 = uVar10 + 1;
} while (uVar3 != uVar10);
}
}
}
return uVar3;
}
|
|
19,707
|
nglog::tools::SafeAppendString(char const*, char*, unsigned long)
|
ng-log[P]ng-log/src/symbolize.cc
|
static void SafeAppendString(const char* source, char* dest, size_t dest_size) {
size_t dest_string_length = strlen(dest);
NGLOG_SAFE_ASSERT(dest_string_length < dest_size);
dest += dest_string_length;
dest_size -= dest_string_length;
strncpy(dest, source, dest_size);
// Making sure |dest| is always null-terminated.
dest[dest_size - 1] = '\0';
}
|
O1
|
cpp
|
nglog::tools::SafeAppendString(char const*, char*, unsigned long):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x71f0
movq %rbx, %rdx
subq %rax, %rdx
jbe 0x20c12
addq %r14, %rax
movq %rax, %rdi
movq %r15, %rsi
callq 0x7240
movb $0x0, -0x1(%r14,%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x72b0
|
_ZN5nglog5toolsL16SafeAppendStringEPKcPcm:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, rsi
call _strlen
mov rdx, rbx
sub rdx, rax
jbe short loc_20C12
add rax, r14
mov rdi, rax
mov rsi, r15
call _strncpy
mov byte ptr [r14+rbx-1], 0
pop rbx
pop r14
pop r15
retn
loc_20C12:
call _abort
|
long long nglog::tools::SafeAppendString(nglog::tools *this, const char *a2, char *a3)
{
unsigned long long v4; // rax
long long result; // rax
v4 = strlen(a2);
if ( (unsigned long long)a3 <= v4 )
abort(a2);
result = strncpy(&a2[v4], this, &a3[-v4]);
a3[(_QWORD)a2 - 1] = 0;
return result;
}
|
SafeAppendString:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,RSI
CALL 0x001071f0
MOV RDX,RBX
SUB RDX,RAX
JBE 0x00120c12
ADD RAX,R14
MOV RDI,RAX
MOV RSI,R15
CALL 0x00107240
MOV byte ptr [R14 + RBX*0x1 + -0x1],0x0
POP RBX
POP R14
POP R15
RET
LAB_00120c12:
CALL 0x001072b0
|
/* nglog::tools::SafeAppendString(char const*, char*, unsigned long) */
void nglog::tools::SafeAppendString(char *param_1,char *param_2,ulong param_3)
{
size_t sVar1;
sVar1 = strlen(param_2);
if (sVar1 <= param_3 && param_3 - sVar1 != 0) {
strncpy(param_2 + sVar1,param_1,param_3 - sVar1);
param_2[param_3 - 1] = '\0';
return;
}
/* WARNING: Subroutine does not return */
abort();
}
|
|
19,708
|
nglog::tools::SafeAppendString(char const*, char*, unsigned long)
|
ng-log[P]ng-log/src/symbolize.cc
|
static void SafeAppendString(const char* source, char* dest, size_t dest_size) {
size_t dest_string_length = strlen(dest);
NGLOG_SAFE_ASSERT(dest_string_length < dest_size);
dest += dest_string_length;
dest_size -= dest_string_length;
strncpy(dest, source, dest_size);
// Making sure |dest| is always null-terminated.
dest[dest_size - 1] = '\0';
}
|
O3
|
cpp
|
nglog::tools::SafeAppendString(char const*, char*, unsigned long):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x71f0
movq %rbx, %rdx
subq %rax, %rdx
jbe 0x209dc
addq %r14, %rax
movq %rax, %rdi
movq %r15, %rsi
callq 0x7240
movb $0x0, -0x1(%r14,%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x72b0
|
_ZN5nglog5toolsL16SafeAppendStringEPKcPcm:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, rsi
call _strlen
mov rdx, rbx
sub rdx, rax
jbe short loc_209DC
add rax, r14
mov rdi, rax
mov rsi, r15
call _strncpy
mov byte ptr [r14+rbx-1], 0
pop rbx
pop r14
pop r15
retn
loc_209DC:
call _abort
|
long long nglog::tools::SafeAppendString(nglog::tools *this, const char *a2, char *a3)
{
unsigned long long v4; // rax
long long result; // rax
v4 = strlen(a2);
if ( (unsigned long long)a3 <= v4 )
abort(a2);
result = strncpy(&a2[v4], this, &a3[-v4]);
a3[(_QWORD)a2 - 1] = 0;
return result;
}
|
SafeAppendString:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,RSI
CALL 0x001071f0
MOV RDX,RBX
SUB RDX,RAX
JBE 0x001209dc
ADD RAX,R14
MOV RDI,RAX
MOV RSI,R15
CALL 0x00107240
MOV byte ptr [R14 + RBX*0x1 + -0x1],0x0
POP RBX
POP R14
POP R15
RET
LAB_001209dc:
CALL 0x001072b0
|
/* nglog::tools::SafeAppendString(char const*, char*, unsigned long) */
void nglog::tools::SafeAppendString(char *param_1,char *param_2,ulong param_3)
{
size_t sVar1;
sVar1 = strlen(param_2);
if (sVar1 <= param_3 && param_3 - sVar1 != 0) {
strncpy(param_2 + sVar1,param_1,param_3 - sVar1);
param_2[param_3 - 1] = '\0';
return;
}
/* WARNING: Subroutine does not return */
abort();
}
|
|
19,709
|
Bfree
|
eloqsql/libmariadb/libmariadb/ma_dtoa.c
|
static void Bfree(Bigint *v, Stack_alloc *alloc)
{
char *gptr= (char*) v; /* generic pointer */
if (gptr < alloc->begin || gptr >= alloc->end)
free(gptr);
else if (v->k <= Kmax)
{
/*
Maintain free lists only for stack objects: this way we don't
have to bother with freeing lists in the end of dtoa;
heap should not be used normally anyway.
*/
v->p.next= alloc->freelist[v->k];
alloc->freelist[v->k]= v;
}
}
|
O0
|
c
|
Bfree:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x4f2c3
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x4f2ce
movq -0x18(%rbp), %rdi
callq 0x14530
jmp 0x4f307
movq -0x8(%rbp), %rax
cmpl $0xf, 0x8(%rax)
jg 0x4f305
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq 0x18(%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, 0x18(%rax,%rcx,8)
jmp 0x4f307
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
Bfree:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx]
jb short loc_4F2C3
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
jb short loc_4F2CE
loc_4F2C3:
mov rdi, [rbp+var_18]
call _free
jmp short loc_4F307
loc_4F2CE:
mov rax, [rbp+var_8]
cmp dword ptr [rax+8], 0Fh
jg short loc_4F305
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+8]
mov rcx, [rax+rcx*8+18h]
mov rax, [rbp+var_8]
mov [rax], rcx
mov rdx, [rbp+var_8]
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+8]
mov [rax+rcx*8+18h], rdx
loc_4F305:
jmp short $+2
loc_4F307:
add rsp, 20h
pop rbp
retn
|
long long Bfree(unsigned long long a1, unsigned long long *a2)
{
long long result; // rax
if ( a1 < *a2 || a1 >= a2[2] )
return free(a1);
result = a1;
if ( *(int *)(a1 + 8) <= 15 )
{
*(_QWORD *)a1 = a2[*(int *)(a1 + 8) + 3];
result = (long long)a2;
a2[*(int *)(a1 + 8) + 3] = a1;
}
return result;
}
|
Bfree:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX]
JC 0x0014f2c3
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JC 0x0014f2ce
LAB_0014f2c3:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00114530
JMP 0x0014f307
LAB_0014f2ce:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x8],0xf
JG 0x0014f305
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x8]
MOV RCX,qword ptr [RAX + RCX*0x8 + 0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x8]
MOV qword ptr [RAX + RCX*0x8 + 0x18],RDX
LAB_0014f305:
JMP 0x0014f307
LAB_0014f307:
ADD RSP,0x20
POP RBP
RET
|
void Bfree(ulong *param_1,ulong *param_2)
{
if ((param_1 < (ulong *)*param_2) || ((ulong *)param_2[2] <= param_1)) {
free(param_1);
}
else if ((int)param_1[1] < 0x10) {
*param_1 = param_2[(long)(int)param_1[1] + 3];
param_2[(long)(int)param_1[1] + 3] = (ulong)param_1;
}
return;
}
|
|
19,710
|
ma_skip_pack_key
|
eloqsql/storage/maria/ma_search.c
|
uchar *_ma_skip_pack_key(MARIA_KEY *key, uint page_flag,
uint nod_flag, uchar *page)
{
reg1 HA_KEYSEG *keyseg;
for (keyseg= key->keyinfo->seg ; keyseg->type ; keyseg++)
{
if (keyseg->flag & HA_PACK_KEY)
{
/* key with length, packed to previous key */
uint packed= *page & 128, length;
if (keyseg->length >= 127)
{
length= mi_uint2korr(page) & 32767;
page+= 2;
}
else
length= *page++ & 127;
if (packed)
{
if (length == 0) /* Same key */
continue;
get_key_length(length,page);
page+= length;
continue;
}
if ((keyseg->flag & HA_NULL_PART) && length)
{
/*
Keys that can have null use length+1 as the length for date as the
number 0 is reserved for keys that have a NULL value
*/
length--;
}
page+= length;
}
else
{
if (keyseg->flag & HA_NULL_PART)
if (!*page++)
continue;
if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
{
uint length;
get_key_length(length,page);
page+=length;
}
else
page+= keyseg->length;
}
}
page+= keyseg->length;
if ((page_flag & KEYPAGE_FLAG_HAS_TRANSID) && key_has_transid(page-1))
page+= transid_packed_length(page);
return page + nod_flag;
}
|
O0
|
c
|
ma_skip_pack_key:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, 0x18(%rax)
je 0x6b8c4
movq -0x20(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x6b7fa
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x14(%rax), %eax
cmpl $0x7f, %eax
jl 0x6b736
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
andl $0x7fff, %eax # imm = 0x7FFF
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x6b74e
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x6b7c6
cmpl $0x0, -0x28(%rbp)
jne 0x6b75f
jmp 0x6b8b3
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0x6b784
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x6b7b1
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
movzwl %ax, %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6b8b3
movq -0x20(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x6b7e5
cmpl $0x0, -0x28(%rbp)
je 0x6b7e5
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6b8b1
movq -0x20(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x6b825
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpb $0x0, (%rax)
jne 0x6b823
jmp 0x6b8b3
jmp 0x6b825
movq -0x20(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x29, %eax
cmpl $0x0, %eax
je 0x6b899
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0x6b85a
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x6b887
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
movzwl %ax, %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6b8af
movq -0x20(%rbp), %rax
movzwl 0x14(%rax), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6b8b1
jmp 0x6b8b3
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0x6b6c5
movq -0x20(%rbp), %rax
movzwl 0x14(%rax), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x6b92c
movq -0x18(%rbp), %rax
movzbl -0x1(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6b92c
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xf3, %eax
jge 0x6b90d
movl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6b91c
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
subl $0xf8, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
addq %rcx, %rax
popq %rbp
retq
nopl (%rax,%rax)
|
_ma_skip_pack_key:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov [rbp+var_18], rcx
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov rax, [rax+0C0h]
mov [rbp+var_20], rax
loc_6B6C5:
mov rax, [rbp+var_20]
cmp byte ptr [rax+18h], 0
jz loc_6B8C4
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+12h]
and eax, 2
cmp eax, 0
jz loc_6B7FA
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
and eax, 80h
mov [rbp+var_24], eax
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+14h]
cmp eax, 7Fh
jl short loc_6B736
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
and eax, 7FFFh
mov [rbp+var_28], eax
mov rax, [rbp+var_18]
add rax, 2
mov [rbp+var_18], rax
jmp short loc_6B74E
loc_6B736:
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
movzx eax, byte ptr [rax]
and eax, 7Fh
mov [rbp+var_28], eax
loc_6B74E:
cmp [rbp+var_24], 0
jz short loc_6B7C6
cmp [rbp+var_28], 0
jnz short loc_6B75F
jmp loc_6B8B3
loc_6B75F:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 0FFh
jz short loc_6B784
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
movzx eax, byte ptr [rax]
mov [rbp+var_28], eax
jmp short loc_6B7B1
loc_6B784:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
movzx eax, ax
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_28], eax
mov rax, [rbp+var_18]
add rax, 3
mov [rbp+var_18], rax
loc_6B7B1:
mov ecx, [rbp+var_28]
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp loc_6B8B3
loc_6B7C6:
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+12h]
and eax, 10h
cmp eax, 0
jz short loc_6B7E5
cmp [rbp+var_28], 0
jz short loc_6B7E5
mov eax, [rbp+var_28]
add eax, 0FFFFFFFFh
mov [rbp+var_28], eax
loc_6B7E5:
mov ecx, [rbp+var_28]
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp loc_6B8B1
loc_6B7FA:
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+12h]
and eax, 10h
cmp eax, 0
jz short loc_6B825
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
cmp byte ptr [rax], 0
jnz short loc_6B823
jmp loc_6B8B3
loc_6B823:
jmp short $+2
loc_6B825:
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+12h]
and eax, 29h
cmp eax, 0
jz short loc_6B899
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 0FFh
jz short loc_6B85A
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
jmp short loc_6B887
loc_6B85A:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
movzx eax, ax
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_2C], eax
mov rax, [rbp+var_18]
add rax, 3
mov [rbp+var_18], rax
loc_6B887:
mov ecx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp short loc_6B8AF
loc_6B899:
mov rax, [rbp+var_20]
movzx ecx, word ptr [rax+14h]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
loc_6B8AF:
jmp short $+2
loc_6B8B1:
jmp short $+2
loc_6B8B3:
mov rax, [rbp+var_20]
add rax, 20h ; ' '
mov [rbp+var_20], rax
jmp loc_6B6C5
loc_6B8C4:
mov rax, [rbp+var_20]
movzx ecx, word ptr [rax+14h]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov eax, [rbp+var_C]
and eax, 2
cmp eax, 0
jz short loc_6B92C
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax-1]
and eax, 1
cmp eax, 0
jz short loc_6B92C
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 0F3h
jge short loc_6B90D
mov eax, 1
mov [rbp+var_30], eax
jmp short loc_6B91C
loc_6B90D:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
sub eax, 0F8h
mov [rbp+var_30], eax
loc_6B91C:
mov ecx, [rbp+var_30]
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
loc_6B92C:
mov rax, [rbp+var_18]
mov ecx, [rbp+var_10]
add rax, rcx
pop rbp
retn
|
unsigned __int8 * ma_skip_pack_key(long long a1, char a2, int a3, unsigned __int16 *a4)
{
unsigned __int16 *v4; // rax
unsigned __int16 *v5; // rax
unsigned __int16 *v6; // rax
unsigned __int16 *v7; // rax
unsigned int v9; // [rsp+0h] [rbp-30h]
int v10; // [rsp+4h] [rbp-2Ch]
unsigned int v11; // [rsp+8h] [rbp-28h]
int v12; // [rsp+8h] [rbp-28h]
int v13; // [rsp+Ch] [rbp-24h]
long long i; // [rsp+10h] [rbp-20h]
char *v16; // [rsp+18h] [rbp-18h]
char *v17; // [rsp+18h] [rbp-18h]
unsigned __int8 *v18; // [rsp+18h] [rbp-18h]
for ( i = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 192LL); *(_BYTE *)(i + 24); i += 32LL )
{
if ( (*(_WORD *)(i + 18) & 2) != 0 )
{
v13 = *(_BYTE *)a4 & 0x80;
if ( *(unsigned __int16 *)(i + 20) < 0x7Fu )
{
v4 = a4;
a4 = (unsigned __int16 *)((char *)a4 + 1);
v11 = *(_BYTE *)v4 & 0x7F;
}
else
{
v11 = _byteswap_ushort(*a4++) & 0x7FFF;
}
if ( v13 )
{
if ( v11 )
{
if ( *(unsigned __int8 *)a4 == 255 )
{
v12 = _byteswap_ushort(*(unsigned __int16 *)((char *)a4 + 1));
v16 = (char *)a4 + 3;
}
else
{
v5 = a4;
v16 = (char *)a4 + 1;
v12 = *(unsigned __int8 *)v5;
}
a4 = (unsigned __int16 *)&v16[v12];
}
}
else
{
if ( (*(_WORD *)(i + 18) & 0x10) != 0 && v11 )
--v11;
a4 = (unsigned __int16 *)((char *)a4 + v11);
}
}
else if ( (*(_WORD *)(i + 18) & 0x10) == 0 || (v6 = a4, a4 = (unsigned __int16 *)((char *)a4 + 1), *(_BYTE *)v6) )
{
if ( (*(_WORD *)(i + 18) & 0x29) != 0 )
{
if ( *(unsigned __int8 *)a4 == 255 )
{
v10 = _byteswap_ushort(*(unsigned __int16 *)((char *)a4 + 1));
v17 = (char *)a4 + 3;
}
else
{
v7 = a4;
v17 = (char *)a4 + 1;
v10 = *(unsigned __int8 *)v7;
}
a4 = (unsigned __int16 *)&v17[v10];
}
else
{
a4 = (unsigned __int16 *)((char *)a4 + *(unsigned __int16 *)(i + 20));
}
}
}
v18 = (unsigned __int8 *)a4 + *(unsigned __int16 *)(i + 20);
if ( (a2 & 2) != 0 && (*(v18 - 1) & 1) != 0 )
{
if ( *v18 >= 0xF3u )
v9 = *v18 - 248;
else
v9 = 1;
v18 += v9;
}
return &v18[a3];
}
|
_ma_skip_pack_key:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV qword ptr [RBP + -0x18],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xc0]
MOV qword ptr [RBP + -0x20],RAX
LAB_0016b6c5:
MOV RAX,qword ptr [RBP + -0x20]
CMP byte ptr [RAX + 0x18],0x0
JZ 0x0016b8c4
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x2
CMP EAX,0x0
JZ 0x0016b7fa
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x80
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x14]
CMP EAX,0x7f
JL 0x0016b736
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
AND EAX,0x7fff
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016b74e
LAB_0016b736:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOVZX EAX,byte ptr [RAX]
AND EAX,0x7f
MOV dword ptr [RBP + -0x28],EAX
LAB_0016b74e:
CMP dword ptr [RBP + -0x24],0x0
JZ 0x0016b7c6
CMP dword ptr [RBP + -0x28],0x0
JNZ 0x0016b75f
JMP 0x0016b8b3
LAB_0016b75f:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xff
JZ 0x0016b784
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x0016b7b1
LAB_0016b784:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x3
MOV qword ptr [RBP + -0x18],RAX
LAB_0016b7b1:
MOV ECX,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016b8b3
LAB_0016b7c6:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x10
CMP EAX,0x0
JZ 0x0016b7e5
CMP dword ptr [RBP + -0x28],0x0
JZ 0x0016b7e5
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x28],EAX
LAB_0016b7e5:
MOV ECX,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016b8b1
LAB_0016b7fa:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x10
CMP EAX,0x0
JZ 0x0016b825
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
CMP byte ptr [RAX],0x0
JNZ 0x0016b823
JMP 0x0016b8b3
LAB_0016b823:
JMP 0x0016b825
LAB_0016b825:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x29
CMP EAX,0x0
JZ 0x0016b899
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xff
JZ 0x0016b85a
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0016b887
LAB_0016b85a:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x3
MOV qword ptr [RBP + -0x18],RAX
LAB_0016b887:
MOV ECX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016b8af
LAB_0016b899:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,word ptr [RAX + 0x14]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
LAB_0016b8af:
JMP 0x0016b8b1
LAB_0016b8b1:
JMP 0x0016b8b3
LAB_0016b8b3:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x20
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0016b6c5
LAB_0016b8c4:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,word ptr [RAX + 0x14]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x2
CMP EAX,0x0
JZ 0x0016b92c
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + -0x1]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0016b92c
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xf3
JGE 0x0016b90d
MOV EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016b91c
LAB_0016b90d:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
SUB EAX,0xf8
MOV dword ptr [RBP + -0x30],EAX
LAB_0016b91c:
MOV ECX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
LAB_0016b92c:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x10]
ADD RAX,RCX
POP RBP
RET
|
byte * _ma_skip_pack_key(long param_1,uint param_2,uint param_3,byte *param_4)
{
byte bVar1;
byte *pbVar2;
uint local_38;
uint local_34;
uint local_30;
long local_28;
byte *local_20;
local_20 = param_4;
for (local_28 = *(long *)(*(long *)(param_1 + 8) + 0xc0); *(char *)(local_28 + 0x18) != '\0';
local_28 = local_28 + 0x20) {
if ((*(ushort *)(local_28 + 0x12) & 2) == 0) {
if (((*(ushort *)(local_28 + 0x12) & 0x10) == 0) ||
(pbVar2 = local_20 + 1, bVar1 = *local_20, local_20 = pbVar2, bVar1 != 0)) {
if ((*(ushort *)(local_28 + 0x12) & 0x29) == 0) {
local_20 = local_20 + (int)(uint)*(ushort *)(local_28 + 0x14);
}
else {
if (*local_20 == 0xff) {
local_34 = (uint)CONCAT11(local_20[1],local_20[2]);
local_20 = local_20 + 3;
}
else {
local_34 = (uint)*local_20;
local_20 = local_20 + 1;
}
local_20 = local_20 + local_34;
}
}
}
else {
bVar1 = *local_20;
if (*(ushort *)(local_28 + 0x14) < 0x7f) {
local_30 = *local_20 & 0x7f;
local_20 = local_20 + 1;
}
else {
local_30 = (uint)local_20[1] | (*local_20 & 0x7f) << 8;
local_20 = local_20 + 2;
}
if ((bVar1 & 0x80) == 0) {
if (((*(ushort *)(local_28 + 0x12) & 0x10) != 0) && (local_30 != 0)) {
local_30 = local_30 - 1;
}
local_20 = local_20 + local_30;
}
else if (local_30 != 0) {
if (*local_20 == 0xff) {
local_30 = (uint)CONCAT11(local_20[1],local_20[2]);
local_20 = local_20 + 3;
}
else {
local_30 = (uint)*local_20;
local_20 = local_20 + 1;
}
local_20 = local_20 + local_30;
}
}
}
local_20 = local_20 + (int)(uint)*(ushort *)(local_28 + 0x14);
if (((param_2 & 2) != 0) && ((local_20[-1] & 1) != 0)) {
if (*local_20 < 0xf3) {
local_38 = 1;
}
else {
local_38 = *local_20 - 0xf8;
}
local_20 = local_20 + local_38;
}
return local_20 + param_3;
}
|
|
19,711
|
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);
}
|
O3
|
c
|
mi_ft_add:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
leaq 0x90(%rdi), %rbx
movq %rcx, %rdx
movq %rbx, %rcx
callq 0x77333
testq %rax, %rax
je 0x77863
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movq %rax, %rcx
movq %r14, %r8
callq 0x777a7
movl %eax, %r14d
jmp 0x77869
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movl $0x2, %esi
movq %rbx, %rdi
callq 0x9fbf7
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_mi_ft_add:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15, rdx
mov r12d, esi
mov r13, rdi
lea rbx, [rdi+90h]
mov rdx, rcx
mov rcx, rbx
call _mi_ft_parserecord
test rax, rax
jz short loc_77863
mov rdi, r13
mov esi, r12d
mov rdx, r15
mov rcx, rax
mov r8, r14
call _mi_ft_store
mov r14d, eax
jmp short loc_77869
loc_77863:
mov r14d, 0FFFFFFFFh
loc_77869:
mov esi, 2
mov rdi, rbx
call free_root
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long mi_ft_add(_QWORD *a1, unsigned int a2, long long a3, long long a4, long long a5, __m128i a6)
{
_QWORD *v8; // rax
unsigned int v9; // r14d
v8 = mi_ft_parserecord(a1, a2, a4, (long long)(a1 + 18));
if ( v8 )
v9 = mi_ft_store((long long)a1, a2, a3, v8, a5, a6);
else
v9 = -1;
free_root(a1 + 18, 2LL);
return v9;
}
|
_mi_ft_add:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15,RDX
MOV R12D,ESI
MOV R13,RDI
LEA RBX,[RDI + 0x90]
MOV RDX,RCX
MOV RCX,RBX
CALL 0x00177333
TEST RAX,RAX
JZ 0x00177863
MOV RDI,R13
MOV ESI,R12D
MOV RDX,R15
MOV RCX,RAX
MOV R8,R14
CALL 0x001777a7
MOV R14D,EAX
JMP 0x00177869
LAB_00177863:
MOV R14D,0xffffffff
LAB_00177869:
MOV ESI,0x2
MOV RDI,RBX
CALL 0x0019fbf7
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4
_mi_ft_add(long param_1,ulong param_2,int8 param_3,int8 param_4,int8 param_5)
{
int4 uVar1;
long lVar2;
lVar2 = _mi_ft_parserecord(param_1,param_2,param_4,param_1 + 0x90);
if (lVar2 == 0) {
uVar1 = 0xffffffff;
}
else {
uVar1 = _mi_ft_store(param_1,param_2 & 0xffffffff,param_3,lVar2,param_5);
}
free_root(param_1 + 0x90,2);
return uVar1;
}
|
|
19,712
|
minja::Parser::unterminated(minja::TemplateToken const&) const
|
monkey531[P]llama/common/minja.hpp
|
std::runtime_error unterminated(const TemplateToken & token) const {
return std::runtime_error("Unterminated " + TemplateToken::typeToString(token.type)
+ error_location_suffix(*template_str, token.location.pos));
}
|
O1
|
cpp
|
minja::Parser::unterminated(minja::TemplateToken const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdx), %esi
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x9b2f2
leaq 0x59a4c(%rip), %rcx # 0xf4256
movl $0xd, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1b9f0
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x9a844
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x9a84c
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r15), %rsi
movq 0x20(%r14), %rdx
leaq 0x48(%rsp), %rdi
callq 0x78698
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x50(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x9a897
movq 0x38(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x9a8b6
leaq 0x58(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x9a8b1
movq 0x58(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x9a8c7
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1b270
jmp 0x9a8d5
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1b9f0
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x9a8f9
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x9a8ff
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1be30
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a944
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8f0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a95f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x9a976
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8f0
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a991
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a9c6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8f0
jmp 0x9a9c6
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a9e6
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1b8f0
jmp 0x9a9e6
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x9aa02
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8f0
jmp 0x9aa02
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9aa1d
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq %rbx, %rdi
callq 0x1bfb0
nop
|
_ZNK5minja6Parser12unterminatedERKNS_13TemplateTokenE:
push r15; int
push r14; int
push r12; int
push rbx; int
sub rsp, 88h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov esi, [rdx+8]
lea r12, [rsp+0A8h+var_40]
mov rdi, r12
call _ZN5minja13TemplateToken12typeToStringB5cxx11ENS0_4TypeE; minja::TemplateToken::typeToString(minja::TemplateToken::Type)
lea rcx, aUnterminated; "Unterminated "
mov r8d, 0Dh
mov rdi, r12
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
lea r12, [rsp+0A8h+var_70]
mov [r12-10h], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h; int
cmp rdx, rcx
jz short loc_9A844
mov [rsp+0A8h+var_80], rdx
mov rdx, [rcx]
mov [rsp+0A8h+var_70], rdx
jmp short loc_9A84C
loc_9A844:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
loc_9A84C:
mov rdx, [rax+8]
mov qword ptr [rsp+0A8h+var_78], rdx; int
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rsi, [r15]; int
mov rdx, [r14+20h]; int
lea rdi, [rsp+0A8h+var_60]; int
call _ZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; minja::error_location_suffix(std::string const&,ulong)
mov rcx, [rsp+0A8h+var_80]
mov r8, qword ptr [rsp+0A8h+var_78]
mov rdx, [rsp+0A8h+var_58]
lea rax, [rdx+r8]
mov esi, 0Fh
cmp rcx, r12
jz short loc_9A897
mov rsi, [rsp+0A8h+var_70]
loc_9A897:
cmp rax, rsi
jbe short loc_9A8B6
lea rdi, [rsp+0A8h+var_50]
mov esi, 0Fh
cmp [rdi-10h], rdi
jz short loc_9A8B1
mov rsi, [rsp+0A8h+var_50]
loc_9A8B1:
cmp rax, rsi
jbe short loc_9A8C7
loc_9A8B6:
mov rsi, qword ptr [rsp+0A8h+var_60]
lea rdi, [rsp+0A8h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
jmp short loc_9A8D5
loc_9A8C7:
lea rdi, [rsp+0A8h+var_60]
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
loc_9A8D5:
lea rdx, [rsp+0A8h+var_90]
mov [rdx-10h], rdx
mov rsi, [rax]
lea rcx, [rax+10h]
cmp rsi, rcx
jz short loc_9A8F9
mov [rsp+0A8h+var_A0], rsi
mov rdx, [rcx]
mov [rsp+0A8h+var_90], rdx
jmp short loc_9A8FF
loc_9A8F9:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
loc_9A8FF:
mov rdx, rax
add rdx, 8
mov rsi, [rax+8]
mov [rsp+0A8h+var_98], rsi
mov [rax], rcx
mov qword ptr [rdx], 0
mov byte ptr [rcx], 0
lea rsi, [rsp+0A8h+var_A0]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
lea rax, [rsp+0A8h+var_90]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9A944
mov rsi, [rsp+0A8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9A944:
lea rax, [rsp+0A8h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9A95F
mov rsi, [rsp+0A8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9A95F:
mov rdi, [rsp+0A8h+var_80]; void *
cmp rdi, r12
jz short loc_9A976
mov rsi, [rsp+0A8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9A976:
lea rax, [rsp+0A8h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9A991
mov rsi, [rsp+0A8h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9A991:
mov rax, rbx
add rsp, 88h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9A9C6
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9A9C6
mov rbx, rax
loc_9A9C6:
lea rax, [rsp+arg_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9A9E6
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9A9E6
mov rbx, rax
loc_9A9E6:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r12
jz short loc_9AA02
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9AA02
mov rbx, rax
loc_9AA02:
lea rax, [rsp+arg_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9AA1D
mov rsi, [rsp+arg_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9AA1D:
mov rdi, rbx
call __Unwind_Resume
|
minja::Parser * minja::Parser::unterminated(minja::Parser *this, const minja::TemplateToken *a2, long long a3)
{
long long v4; // rax
__int128 *v5; // rcx
unsigned long long v6; // rax
unsigned long long v7; // rsi
unsigned long long v8; // rsi
void **v9; // rax
__int128 *v10; // rcx
void *v12[2]; // [rsp+8h] [rbp-A0h] BYREF
__int128 v13; // [rsp+18h] [rbp-90h] BYREF
void *v14; // [rsp+28h] [rbp-80h] BYREF
int v15[2]; // [rsp+30h] [rbp-78h]
__int128 v16; // [rsp+38h] [rbp-70h] BYREF
int v17[2]; // [rsp+48h] [rbp-60h] BYREF
long long v18; // [rsp+50h] [rbp-58h]
_QWORD v19[2]; // [rsp+58h] [rbp-50h] BYREF
void *v20[2]; // [rsp+68h] [rbp-40h] BYREF
long long v21; // [rsp+78h] [rbp-30h] BYREF
minja::TemplateToken::typeToString[abi:cxx11](v20, *(unsigned int *)(a3 + 8));
v4 = std::string::replace(v20, 0LL, 0LL, "Unterminated ", 13LL);
v14 = &v16;
v5 = (__int128 *)(v4 + 16);
if ( *(_QWORD *)v4 == v4 + 16 )
{
v16 = *v5;
}
else
{
v14 = *(void **)v4;
*(_QWORD *)&v16 = *(_QWORD *)v5;
}
*(_QWORD *)v15 = *(_QWORD *)(v4 + 8);
*(_QWORD *)v4 = v5;
*(_QWORD *)(v4 + 8) = 0LL;
*(_BYTE *)(v4 + 16) = 0;
minja::error_location_suffix((long long)v17, *(_QWORD *)a2, *(_QWORD *)(a3 + 32));
v6 = v18 + *(_QWORD *)v15;
v7 = 15LL;
if ( v14 != &v16 )
v7 = v16;
if ( v6 <= v7 )
goto LABEL_10;
v8 = 15LL;
if ( *(_QWORD **)v17 != v19 )
v8 = v19[0];
if ( v6 <= v8 )
v9 = (void **)std::string::replace(v17, 0LL, 0LL, v14, *(_QWORD *)v15);
else
LABEL_10:
v9 = (void **)std::string::_M_append(&v14, *(_QWORD *)v17, v18);
v12[0] = &v13;
v10 = (__int128 *)(v9 + 2);
if ( *v9 == v9 + 2 )
{
v13 = *v10;
}
else
{
v12[0] = *v9;
*(_QWORD *)&v13 = *(_QWORD *)v10;
}
v12[1] = v9[1];
*v9 = v10;
v9[1] = 0LL;
*(_BYTE *)v10 = 0;
std::runtime_error::runtime_error(this, v12);
if ( v12[0] != &v13 )
operator delete(v12[0], v13 + 1);
if ( *(_QWORD **)v17 != v19 )
operator delete(*(void **)v17, v19[0] + 1LL);
if ( v14 != &v16 )
operator delete(v14, v16 + 1);
if ( v20[0] != &v21 )
operator delete(v20[0], v21 + 1);
return this;
}
|
unterminated:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV ESI,dword ptr [RDX + 0x8]
LEA R12,[RSP + 0x68]
MOV RDI,R12
CALL 0x0019b2f2
LAB_0019a803:
LEA RCX,[0x1f4256]
MOV R8D,0xd
MOV RDI,R12
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011b9f0
LEA R12,[RSP + 0x38]
MOV qword ptr [R12 + -0x10],R12
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x0019a844
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x38],RDX
JMP 0x0019a84c
LAB_0019a844:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
LAB_0019a84c:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R14 + 0x20]
LAB_0019a86b:
LEA RDI,[RSP + 0x48]
CALL 0x00178698
MOV RCX,qword ptr [RSP + 0x28]
MOV R8,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x50]
LEA RAX,[RDX + R8*0x1]
MOV ESI,0xf
CMP RCX,R12
JZ 0x0019a897
MOV RSI,qword ptr [RSP + 0x38]
LAB_0019a897:
CMP RAX,RSI
JBE 0x0019a8b6
LEA RDI,[RSP + 0x58]
MOV ESI,0xf
CMP qword ptr [RDI + -0x10],RDI
JZ 0x0019a8b1
MOV RSI,qword ptr [RSP + 0x58]
LAB_0019a8b1:
CMP RAX,RSI
JBE 0x0019a8c7
LAB_0019a8b6:
MOV RSI,qword ptr [RSP + 0x48]
LAB_0019a8bb:
LEA RDI,[RSP + 0x28]
CALL 0x0011b270
JMP 0x0019a8d5
LAB_0019a8c7:
LEA RDI,[RSP + 0x48]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011b9f0
LAB_0019a8d5:
LEA RDX,[RSP + 0x18]
MOV qword ptr [RDX + -0x10],RDX
MOV RSI,qword ptr [RAX]
LEA RCX,[RAX + 0x10]
CMP RSI,RCX
JZ 0x0019a8f9
MOV qword ptr [RSP + 0x8],RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x0019a8ff
LAB_0019a8f9:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
LAB_0019a8ff:
MOV RDX,RAX
ADD RDX,0x8
MOV RSI,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RAX],RCX
MOV qword ptr [RDX],0x0
MOV byte ptr [RCX],0x0
LAB_0019a91c:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0011be30
LAB_0019a929:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0019a944
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8f0
LAB_0019a944:
LEA RAX,[RSP + 0x58]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0019a95f
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0011b8f0
LAB_0019a95f:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R12
JZ 0x0019a976
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011b8f0
LAB_0019a976:
LEA RAX,[RSP + 0x78]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0019a991
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x0011b8f0
LAB_0019a991:
MOV RAX,RBX
ADD RSP,0x88
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::Parser::unterminated(minja::TemplateToken const&) const */
TemplateToken * minja::Parser::unterminated(TemplateToken *param_1)
{
long *plVar1;
int8 *puVar2;
ulong *puVar3;
long in_RDX;
int8 *in_RSI;
ulong uVar4;
long *local_a0;
int8 local_98;
long local_90;
int8 uStack_88;
ulong *local_80;
long local_78;
ulong local_70;
long lStack_68;
ulong *local_60;
long local_58;
ulong local_50 [2];
long *local_40 [2];
long local_30 [2];
TemplateToken::typeToString_abi_cxx11_((TemplateToken *)local_40);
/* try { // try from 0019a803 to 0019a81b has its CatchHandler @ 0019a9ff */
plVar1 = (long *)std::__cxx11::string::replace((ulong)local_40,0,(char *)0x0,0x1f4256);
puVar3 = (ulong *)(plVar1 + 2);
if ((ulong *)*plVar1 == puVar3) {
local_70 = *puVar3;
lStack_68 = plVar1[3];
local_80 = &local_70;
}
else {
local_70 = *puVar3;
local_80 = (ulong *)*plVar1;
}
local_78 = plVar1[1];
*plVar1 = (long)puVar3;
plVar1[1] = 0;
*(int1 *)(plVar1 + 2) = 0;
/* try { // try from 0019a86b to 0019a874 has its CatchHandler @ 0019a9e3 */
error_location_suffix((minja *)&local_60,(string *)*in_RSI,*(ulong *)(in_RDX + 0x20));
uVar4 = 0xf;
if (local_80 != &local_70) {
uVar4 = local_70;
}
if (uVar4 < (ulong)(local_58 + local_78)) {
uVar4 = 0xf;
if (local_60 != local_50) {
uVar4 = local_50[0];
}
if ((ulong)(local_58 + local_78) <= uVar4) {
puVar2 = (int8 *)
std::__cxx11::string::replace((ulong)&local_60,0,(char *)0x0,(ulong)local_80);
goto LAB_0019a8d5;
}
}
/* try { // try from 0019a8bb to 0019a8d4 has its CatchHandler @ 0019a9c3 */
puVar2 = (int8 *)std::__cxx11::string::_M_append((char *)&local_80,(ulong)local_60);
LAB_0019a8d5:
local_a0 = &local_90;
plVar1 = puVar2 + 2;
if ((long *)*puVar2 == plVar1) {
local_90 = *plVar1;
uStack_88 = puVar2[3];
}
else {
local_90 = *plVar1;
local_a0 = (long *)*puVar2;
}
local_98 = puVar2[1];
*puVar2 = plVar1;
puVar2[1] = 0;
*(int1 *)plVar1 = 0;
/* try { // try from 0019a91c to 0019a928 has its CatchHandler @ 0019a9a3 */
std::runtime_error::runtime_error((runtime_error *)param_1,(string *)&local_a0);
if (local_a0 != &local_90) {
operator_delete(local_a0,local_90 + 1);
}
if (local_60 != local_50) {
operator_delete(local_60,local_50[0] + 1);
}
if (local_80 != &local_70) {
operator_delete(local_80,local_70 + 1);
}
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
return param_1;
}
|
|
19,713
|
js_execute_async_module
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_execute_async_module(JSContext *ctx, JSModuleDef *m)
{
JSValue promise, m_obj;
JSValue resolve_funcs[2], ret_val;
promise = js_async_function_call(ctx, m->func_obj, JS_UNDEFINED, 0, NULL, 0);
if (JS_IsException(promise))
return -1;
m_obj = JS_NewModuleValue(ctx, m);
resolve_funcs[0] = JS_NewCFunctionData(ctx, js_async_module_execution_fulfilled, 0, 0, 1, (JSValueConst *)&m_obj);
resolve_funcs[1] = JS_NewCFunctionData(ctx, js_async_module_execution_rejected, 0, 0, 1, (JSValueConst *)&m_obj);
ret_val = js_promise_then(ctx, promise, 2, (JSValueConst *)resolve_funcs);
JS_FreeValue(ctx, ret_val);
JS_FreeValue(ctx, m_obj);
JS_FreeValue(ctx, resolve_funcs[0]);
JS_FreeValue(ctx, resolve_funcs[1]);
JS_FreeValue(ctx, promise);
return 0;
}
|
O1
|
c
|
js_execute_async_module:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x68(%rsi), %rsi
movq 0x70(%r12), %rdx
andq $0x0, (%rsp)
pushq $0x3
popq %r8
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x106c2
movq %rdx, %r15
cmpl $0x6, %r15d
jne 0x110f7
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl (%r12)
leaq 0x30(%rsp), %r14
movq %r12, (%r14)
movq $-0x3, 0x8(%r14)
leaq 0x33d49(%rip), %rsi # 0x44e5b
pushq $0x1
popq %r8
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r9
movq %rax, %r13
callq 0x210ea
movq %rax, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x40(%rsp), %rbp
movq %rax, (%rbp)
movq %rdx, 0x8(%rbp)
leaq 0x33e8b(%rip), %rsi # 0x44fd1
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
pushq $0x1
popq %r8
movq %r14, %r9
callq 0x210ea
movq %rax, %r14
movq %rdx, 0x18(%rsp)
movq %rax, 0x10(%rbp)
movq %rdx, 0x18(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbp, %r8
callq 0x43f7a
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x1d8c6
movq 0x18(%rbx), %rdi
pushq $-0x3
popq %rdx
movq %r12, %rsi
callq 0x1d8c6
movq 0x18(%rbx), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x1d8c6
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movq 0x18(%rsp), %rdx
callq 0x1d8c6
movq 0x18(%rbx), %rdi
movq %r13, %rsi
movq %r15, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1d8c6
|
js_execute_async_module:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12, rsi
mov rbx, rdi
mov rsi, [rsi+68h]
mov rdx, [r12+70h]
and [rsp+98h+var_98], 0
push 3
pop r8
xor ecx, ecx
xor r9d, r9d
call js_async_function_call
mov r15, rdx
cmp r15d, 6
jnz short loc_110F7
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_110F7:
inc dword ptr [r12]
lea r14, [rsp+98h+var_68]
mov [r14], r12
mov qword ptr [r14+8], 0FFFFFFFFFFFFFFFDh
lea rsi, js_async_module_execution_fulfilled
push 1
pop r8
mov rdi, rbx
xor edx, edx
xor ecx, ecx
mov r9, r14
mov r13, rax
call JS_NewCFunctionData
mov [rsp+98h+var_70], rax
mov [rsp+98h+var_78], rdx
lea rbp, [rsp+98h+var_58]
mov [rbp+0], rax
mov [rbp+8], rdx
lea rsi, js_async_module_execution_rejected
mov rdi, rbx
xor edx, edx
xor ecx, ecx
push 1
pop r8
mov r9, r14
call JS_NewCFunctionData
mov r14, rax
mov [rsp+98h+var_80], rdx
mov [rbp+10h], rax
mov [rbp+18h], rdx
mov rdi, rbx
mov rsi, r13
mov rdx, r15
mov r8, rbp
call js_promise_then
mov rdi, [rbx+18h]
mov rsi, rax
call JS_FreeValueRT
mov rdi, [rbx+18h]
push 0FFFFFFFFFFFFFFFDh
pop rdx
mov rsi, r12
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, [rsp+98h+var_70]
mov rdx, [rsp+98h+var_78]
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, r14
mov rdx, [rsp+98h+var_80]
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, r13
mov rdx, r15
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_FreeValueRT
|
unsigned long long js_execute_async_module(long long a1, long long a2)
{
unsigned long long result; // rax
long long v3; // rdx
long long v4; // r15
unsigned long long v5; // r13
long long v6; // rdx
long long v7; // r14
long long v8; // rdx
long long v9; // rcx
long long v10; // rax
long long v11; // [rsp+28h] [rbp-70h]
_QWORD v12[2]; // [rsp+30h] [rbp-68h] BYREF
_QWORD v13[11]; // [rsp+40h] [rbp-58h] BYREF
result = js_async_function_call(a1, *(_QWORD *)(a2 + 104), *(_QWORD *)(a2 + 112), 0, 3, 0, 0LL);
v4 = v3;
if ( (_DWORD)v3 != 6 )
{
++*(_DWORD *)a2;
v12[0] = a2;
v12[1] = -3LL;
v5 = result;
v11 = JS_NewCFunctionData(a1, js_async_module_execution_fulfilled, 0LL, 0LL, 1LL, v12);
v13[0] = v11;
v13[1] = v6;
v7 = JS_NewCFunctionData(a1, js_async_module_execution_rejected, 0LL, 0LL, 1LL, v12);
v13[2] = v7;
v13[3] = v8;
v10 = js_promise_then(a1, v5, v4, v9, v13);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v10);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), a2);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v11);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v7);
return JS_FreeValueRT(*(_QWORD *)(a1 + 24), v5);
}
return result;
}
|
js_execute_async_module:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RSI + 0x68]
MOV RDX,qword ptr [R12 + 0x70]
AND qword ptr [RSP],0x0
PUSH 0x3
POP R8
XOR ECX,ECX
XOR R9D,R9D
CALL 0x001106c2
MOV R15,RDX
CMP R15D,0x6
JNZ 0x001110f7
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001110f7:
INC dword ptr [R12]
LEA R14,[RSP + 0x30]
MOV qword ptr [R14],R12
MOV qword ptr [R14 + 0x8],-0x3
LEA RSI,[0x144e5b]
PUSH 0x1
POP R8
MOV RDI,RBX
XOR EDX,EDX
XOR ECX,ECX
MOV R9,R14
MOV R13,RAX
CALL 0x001210ea
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x20],RDX
LEA RBP,[RSP + 0x40]
MOV qword ptr [RBP],RAX
MOV qword ptr [RBP + 0x8],RDX
LEA RSI,[0x144fd1]
MOV RDI,RBX
XOR EDX,EDX
XOR ECX,ECX
PUSH 0x1
POP R8
MOV R9,R14
CALL 0x001210ea
MOV R14,RAX
MOV qword ptr [RSP + 0x18],RDX
MOV qword ptr [RBP + 0x10],RAX
MOV qword ptr [RBP + 0x18],RDX
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R15
MOV R8,RBP
CALL 0x00143f7a
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,RAX
CALL 0x0011d8c6
MOV RDI,qword ptr [RBX + 0x18]
PUSH -0x3
POP RDX
MOV RSI,R12
CALL 0x0011d8c6
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x0011d8c6
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R14
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x0011d8c6
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R13
MOV RDX,R15
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0011d8c6
|
void js_execute_async_module(long param_1,int *param_2)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
int1 auVar6 [16];
int *local_68;
int8 local_60;
int1 local_58 [16];
int1 local_48 [16];
auVar6 = js_async_function_call
(param_1,*(int8 *)(param_2 + 0x1a),*(int8 *)(param_2 + 0x1c),0,3,0,
0);
if (auVar6._8_4_ == 6) {
return;
}
*param_2 = *param_2 + 1;
local_60 = 0xfffffffffffffffd;
local_68 = param_2;
local_58 = JS_NewCFunctionData(param_1,js_async_module_execution_fulfilled,0,0,1,&local_68);
uVar4 = local_58._8_8_;
uVar1 = local_58._0_8_;
local_48 = JS_NewCFunctionData(param_1,js_async_module_execution_rejected,0,0,1,&local_68);
uVar5 = local_48._8_8_;
uVar2 = local_48._0_8_;
uVar3 = js_promise_then(param_1,auVar6._0_8_,auVar6._8_8_);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar3);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),param_2,0xfffffffffffffffd);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar1,uVar4);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar2,uVar5);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar6._0_8_,auVar6._8_8_);
return;
}
|
|
19,714
|
js_execute_async_module
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_execute_async_module(JSContext *ctx, JSModuleDef *m)
{
JSValue promise, m_obj;
JSValue resolve_funcs[2], ret_val;
promise = js_async_function_call(ctx, m->func_obj, JS_UNDEFINED, 0, NULL, 0);
if (JS_IsException(promise))
return -1;
m_obj = JS_NewModuleValue(ctx, m);
resolve_funcs[0] = JS_NewCFunctionData(ctx, js_async_module_execution_fulfilled, 0, 0, 1, (JSValueConst *)&m_obj);
resolve_funcs[1] = JS_NewCFunctionData(ctx, js_async_module_execution_rejected, 0, 0, 1, (JSValueConst *)&m_obj);
ret_val = js_promise_then(ctx, promise, 2, (JSValueConst *)resolve_funcs);
JS_FreeValue(ctx, ret_val);
JS_FreeValue(ctx, m_obj);
JS_FreeValue(ctx, resolve_funcs[0]);
JS_FreeValue(ctx, resolve_funcs[1]);
JS_FreeValue(ctx, promise);
return 0;
}
|
O2
|
c
|
js_execute_async_module:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rsi), %rsi
movq 0x70(%r14), %rdx
andq $0x0, (%rsp)
pushq $0x3
popq %r8
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x2fc9c
movq %rdx, %r12
cmpl $0x6, %r12d
jne 0x3c8ba
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl (%r14)
leaq 0x30(%rsp), %r13
movq %r14, (%r13)
movq $-0x3, 0x8(%r13)
leaq 0x1ba(%rip), %rsi # 0x3ca8f
pushq $0x1
popq %r8
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r13, %r9
movq %rax, %r15
callq 0x1b3ba
movq %rax, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x40(%rsp), %rbp
movq %rax, (%rbp)
movq %rdx, 0x8(%rbp)
leaq 0x2ed(%rip), %rsi # 0x3cbf6
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
pushq $0x1
popq %r8
movq %r13, %r9
callq 0x1b3ba
movq %rax, 0x18(%rsp)
movq %rdx, %r13
movq %rax, 0x10(%rbp)
movq %rdx, 0x18(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbp, %r8
callq 0x3b993
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1801e
pushq $-0x3
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1801e
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x1801e
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movq %r13, %rdx
callq 0x1801e
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1801e
|
js_execute_async_module:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, rsi
mov rbx, rdi
mov rsi, [rsi+68h]
mov rdx, [r14+70h]
and [rsp+98h+var_98], 0
push 3
pop r8
xor ecx, ecx
xor r9d, r9d
call js_async_function_call
mov r12, rdx
cmp r12d, 6
jnz short loc_3C8BA
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3C8BA:
inc dword ptr [r14]
lea r13, [rsp+98h+var_68]
mov [r13+0], r14
mov qword ptr [r13+8], 0FFFFFFFFFFFFFFFDh
lea rsi, js_async_module_execution_fulfilled
push 1
pop r8
mov rdi, rbx
xor edx, edx
xor ecx, ecx
mov r9, r13
mov r15, rax
call JS_NewCFunctionData
mov [rsp+98h+var_70], rax
mov [rsp+98h+var_78], rdx
lea rbp, [rsp+98h+var_58]
mov [rbp+0], rax
mov [rbp+8], rdx
lea rsi, js_async_module_execution_rejected
mov rdi, rbx
xor edx, edx
xor ecx, ecx
push 1
pop r8
mov r9, r13
call JS_NewCFunctionData
mov [rsp+98h+var_80], rax
mov r13, rdx
mov [rbp+10h], rax
mov [rbp+18h], rdx
mov rdi, rbx
mov rsi, r15
mov rdx, r12
mov r8, rbp
call js_promise_then
mov rdi, rbx
mov rsi, rax
call JS_FreeValue
push 0FFFFFFFFFFFFFFFDh
pop rdx
mov rdi, rbx
mov rsi, r14
call JS_FreeValue
mov rdi, rbx
mov rsi, [rsp+98h+var_70]
mov rdx, [rsp+98h+var_78]
call JS_FreeValue
mov rdi, rbx
mov rsi, [rsp+98h+var_80]
mov rdx, r13
call JS_FreeValue
mov rdi, rbx
mov rsi, r15
mov rdx, r12
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_FreeValue
|
unsigned long long js_execute_async_module(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
unsigned long long result; // rax
long long v11; // rdx
long long v12; // r12
long long v13; // r15
long long v14; // rdx
long long v15; // rdx
long long v16; // r13
long long v17; // rcx
double v18; // xmm4_8
double v19; // xmm5_8
unsigned long long v20; // rax
long long v21; // rdx
unsigned long long v22; // [rsp+18h] [rbp-80h]
long long v23; // [rsp+20h] [rbp-78h]
unsigned long long v24; // [rsp+28h] [rbp-70h]
_QWORD v25[2]; // [rsp+30h] [rbp-68h] BYREF
_QWORD v26[11]; // [rsp+40h] [rbp-58h] BYREF
result = js_async_function_call(a1, *(_QWORD *)(a2 + 104), *(_QWORD *)(a2 + 112), 0, 3, 0, 0LL);
v12 = v11;
if ( (_DWORD)v11 != 6 )
{
++*(_DWORD *)a2;
v25[0] = a2;
v25[1] = -3LL;
v13 = result;
v24 = JS_NewCFunctionData(a1, (long long)js_async_module_execution_fulfilled, 0, 0, 1u, (long long)v25);
v23 = v14;
v26[0] = v24;
v26[1] = v14;
v22 = JS_NewCFunctionData(a1, (long long)js_async_module_execution_rejected, 0, 0, 1u, (long long)v25);
v16 = v15;
v26[2] = v22;
v26[3] = v15;
v20 = js_promise_then(a1, v13, v12, a3, a4, a5, a6, v18, v19, a9, a10, v17, (long long)v26);
JS_FreeValue(a1, v20, v21);
JS_FreeValue(a1, a2, -3LL);
JS_FreeValue(a1, v24, v23);
JS_FreeValue(a1, v22, v16);
return JS_FreeValue(a1, v13, v12);
}
return result;
}
|
js_execute_async_module:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RSI + 0x68]
MOV RDX,qword ptr [R14 + 0x70]
AND qword ptr [RSP],0x0
PUSH 0x3
POP R8
XOR ECX,ECX
XOR R9D,R9D
CALL 0x0012fc9c
MOV R12,RDX
CMP R12D,0x6
JNZ 0x0013c8ba
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013c8ba:
INC dword ptr [R14]
LEA R13,[RSP + 0x30]
MOV qword ptr [R13],R14
MOV qword ptr [R13 + 0x8],-0x3
LEA RSI,[0x13ca8f]
PUSH 0x1
POP R8
MOV RDI,RBX
XOR EDX,EDX
XOR ECX,ECX
MOV R9,R13
MOV R15,RAX
CALL 0x0011b3ba
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x20],RDX
LEA RBP,[RSP + 0x40]
MOV qword ptr [RBP],RAX
MOV qword ptr [RBP + 0x8],RDX
LEA RSI,[0x13cbf6]
MOV RDI,RBX
XOR EDX,EDX
XOR ECX,ECX
PUSH 0x1
POP R8
MOV R9,R13
CALL 0x0011b3ba
MOV qword ptr [RSP + 0x18],RAX
MOV R13,RDX
MOV qword ptr [RBP + 0x10],RAX
MOV qword ptr [RBP + 0x18],RDX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
MOV R8,RBP
CALL 0x0013b993
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011801e
PUSH -0x3
POP RDX
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,R13
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0011801e
|
void js_execute_async_module(int8 param_1,int *param_2)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
int1 auVar6 [16];
int *local_68;
int8 local_60;
int1 local_58 [16];
int1 local_48 [16];
auVar6 = js_async_function_call
(param_1,*(int8 *)(param_2 + 0x1a),*(int8 *)(param_2 + 0x1c),0,3,0,
0);
if (auVar6._8_4_ == 6) {
return;
}
*param_2 = *param_2 + 1;
local_60 = 0xfffffffffffffffd;
local_68 = param_2;
local_58 = JS_NewCFunctionData(param_1,js_async_module_execution_fulfilled,0,0,1,&local_68);
uVar4 = local_58._8_8_;
uVar1 = local_58._0_8_;
local_48 = JS_NewCFunctionData(param_1,js_async_module_execution_rejected,0,0,1,&local_68);
uVar5 = local_48._8_8_;
uVar2 = local_48._0_8_;
uVar3 = js_promise_then(param_1,auVar6._0_8_,auVar6._8_8_);
JS_FreeValue(param_1,uVar3);
JS_FreeValue(param_1,param_2,0xfffffffffffffffd);
JS_FreeValue(param_1,uVar1,uVar4);
JS_FreeValue(param_1,uVar2,uVar5);
JS_FreeValue(param_1,auVar6._0_8_,auVar6._8_8_);
return;
}
|
|
19,715
|
mju_normalize
|
aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_util_blas.c
|
mjtNum mju_normalize(mjtNum* res, int n) {
mjtNum norm = (mjtNum)mju_sqrt(mju_dot(res, res, n));
mjtNum normInv;
if (norm < mjMINVAL) {
res[0] = 1;
for (int i=1; i < n; i++) {
res[i] = 0;
}
} else {
normInv = 1/norm;
for (int i=0; i < n; i++) {
res[i] *= normInv;
}
}
return norm;
}
|
O0
|
c
|
mju_normalize:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
callq 0x496c0
callq 0x49370
vmovsd %xmm0, 0x10(%rsp)
vmovsd 0x24151d(%rip), %xmm0 # 0x517b30
vucomisd 0x10(%rsp), %xmm0
jbe 0x2d6660
movq 0x20(%rsp), %rax
vmovsd 0x241530(%rip), %xmm0 # 0x517b58
vmovsd %xmm0, (%rax)
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x2d665e
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
vxorps %xmm0, %xmm0, %xmm0
vmovsd %xmm0, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2d6634
jmp 0x2d66aa
vmovsd 0x2414f0(%rip), %xmm0 # 0x517b58
vdivsd 0x10(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x8(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x2d66a8
vmovsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rax
movslq (%rsp), %rcx
vmulsd (%rax,%rcx,8), %xmm0, %xmm0
vmovsd %xmm0, (%rax,%rcx,8)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x2d667b
jmp 0x2d66aa
vmovsd 0x10(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
|
mju_normalize:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_C], esi
mov rdi, [rsp+28h+var_8]
mov rsi, [rsp+28h+var_8]
mov edx, [rsp+28h+var_C]
call _mju_dot
call _sqrt
vmovsd [rsp+28h+var_18], xmm0
vmovsd xmm0, cs:qword_517B30
vucomisd xmm0, [rsp+28h+var_18]
jbe short loc_2D6660
mov rax, [rsp+28h+var_8]
vmovsd xmm0, cs:qword_517B58
vmovsd qword ptr [rax], xmm0
mov [rsp+28h+var_24], 1
loc_2D6634:
mov eax, [rsp+28h+var_24]
cmp eax, [rsp+28h+var_C]
jge short loc_2D665E
mov rax, [rsp+28h+var_8]
movsxd rcx, [rsp+28h+var_24]
vxorps xmm0, xmm0, xmm0
vmovsd qword ptr [rax+rcx*8], xmm0
mov eax, [rsp+28h+var_24]
add eax, 1
mov [rsp+28h+var_24], eax
jmp short loc_2D6634
loc_2D665E:
jmp short loc_2D66AA
loc_2D6660:
vmovsd xmm0, cs:qword_517B58
vdivsd xmm0, xmm0, [rsp+28h+var_18]
vmovsd [rsp+28h+var_20], xmm0
mov [rsp+28h+var_28], 0
loc_2D667B:
mov eax, [rsp+28h+var_28]
cmp eax, [rsp+28h+var_C]
jge short loc_2D66A8
vmovsd xmm0, [rsp+28h+var_20]
mov rax, [rsp+28h+var_8]
movsxd rcx, [rsp+28h+var_28]
vmulsd xmm0, xmm0, qword ptr [rax+rcx*8]
vmovsd qword ptr [rax+rcx*8], xmm0
mov eax, [rsp+28h+var_28]
add eax, 1
mov [rsp+28h+var_28], eax
jmp short loc_2D667B
loc_2D66A8:
jmp short $+2
loc_2D66AA:
vmovsd xmm0, [rsp+28h+var_18]
add rsp, 28h
retn
|
__int128 __usercall mju_normalize@<xmm0>(long long a1@<rdi>, int a2@<esi>, __m128 _XMM0@<xmm0>)
{
char v4; // cf
char v5; // zf
__int128 result; // xmm0
int i; // [rsp+0h] [rbp-28h]
int j; // [rsp+4h] [rbp-24h]
*(double *)_XMM0.m128_u64 = mju_dot(a1, a1, (unsigned int)a2);
*(double *)_XMM0.m128_u64 = sqrt(*(double *)_XMM0.m128_u64);
__asm
{
vmovsd [rsp+28h+var_18], xmm0
vmovsd xmm0, cs:qword_517B30
vucomisd xmm0, [rsp+28h+var_18]
}
if ( v4 | v5 )
{
__asm
{
vmovsd xmm0, cs:qword_517B58
vdivsd xmm0, xmm0, [rsp+28h+var_18]
vmovsd [rsp+28h+var_20], xmm0
}
for ( i = 0; i < a2; ++i )
{
__asm { vmovsd xmm0, [rsp+28h+var_20] }
_RAX = a1;
_RCX = i;
__asm
{
vmulsd xmm0, xmm0, qword ptr [rax+rcx*8]
vmovsd qword ptr [rax+rcx*8], xmm0
}
}
}
else
{
_RAX = a1;
__asm
{
vmovsd xmm0, cs:qword_517B58
vmovsd qword ptr [rax], xmm0
}
for ( j = 1; j < a2; ++j )
{
_RAX = a1;
_RCX = j;
__asm
{
vxorps xmm0, xmm0, xmm0
vmovsd qword ptr [rax+rcx*8], xmm0
}
}
}
__asm { vmovsd xmm0, [rsp+28h+var_18] }
return result;
}
| |||
19,716
|
mju_normalize
|
aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_util_blas.c
|
mjtNum mju_normalize(mjtNum* res, int n) {
mjtNum norm = (mjtNum)mju_sqrt(mju_dot(res, res, n));
mjtNum normInv;
if (norm < mjMINVAL) {
res[0] = 1;
for (int i=1; i < n; i++) {
res[i] = 0;
}
} else {
normInv = 1/norm;
for (int i=0; i < n; i++) {
res[i] *= normInv;
}
}
return norm;
}
|
O3
|
c
|
mju_normalize:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq %rdi, %rsi
movl %ebx, %edx
callq 0x2d500
vxorpd %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jb 0x9bd2a
vsqrtsd %xmm0, %xmm0, %xmm0
jmp 0x9bd2f
callq 0x2d200
vmovsd 0x120e71(%rip), %xmm1 # 0x1bcba8
vucomisd %xmm0, %xmm1
jbe 0x9bd79
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%r14)
cmpl $0x2, %ebx
jl 0x9be29
addq $0x8, %r14
decl %ebx
shlq $0x3, %rbx
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
vmovsd %xmm0, (%rsp)
callq 0x2d300
vmovsd (%rsp), %xmm0
jmp 0x9be29
testl %ebx, %ebx
jle 0x9be29
vmovsd 0x120e47(%rip), %xmm1 # 0x1bcbd0
vdivsd %xmm0, %xmm1, %xmm2
movl %ebx, %eax
addl $0x3, %ebx
andl $-0x4, %ebx
decq %rax
vmovq %rax, %xmm1
vpshufd $0x44, %xmm1, %xmm1 # xmm1 = xmm1[0,1,0,1]
vinsertf128 $0x1, %xmm1, %ymm1, %ymm5
vmovddup %xmm2, %xmm1 # xmm1 = xmm2[0,0]
vinsertf128 $0x1, %xmm1, %ymm1, %ymm8
xorl %eax, %eax
vmovaps 0x121944(%rip), %ymm1 # 0x1bd700
vextractf128 $0x1, %ymm5, %xmm3
vmovddup 0x120dd6(%rip), %xmm2 # xmm2 = mem[0,0]
vxorps %xmm2, %xmm3, %xmm3
vpcmpeqd %xmm4, %xmm4, %xmm4
vxorps %xmm2, %xmm5, %xmm5
vmovq %rax, %xmm6
vpshufd $0x44, %xmm6, %xmm6 # xmm6 = xmm6[0,1,0,1]
vinsertf128 $0x1, %xmm6, %ymm6, %ymm6
vorps %ymm1, %ymm6, %ymm6
vextractf128 $0x1, %ymm6, %xmm7
vxorps %xmm2, %xmm7, %xmm7
vpcmpgtq %xmm3, %xmm7, %xmm7
vpxor %xmm4, %xmm7, %xmm7
vxorps %xmm2, %xmm6, %xmm6
vpcmpgtq %xmm5, %xmm6, %xmm6
vpxor %xmm4, %xmm6, %xmm6
vinsertf128 $0x1, %xmm7, %ymm6, %ymm6
vmaskmovpd (%r14,%rax,8), %ymm6, %ymm7
vmulpd %ymm7, %ymm8, %ymm7
vmaskmovpd %ymm7, %ymm6, (%r14,%rax,8)
addq $0x4, %rax
cmpq %rax, %rbx
jne 0x9bdd6
addq $0x8, %rsp
popq %rbx
popq %r14
vzeroupper
retq
|
mju_normalize:
push r14
push rbx
push rax
mov ebx, esi
mov r14, rdi
mov rsi, rdi
mov edx, ebx
call _mju_dot
vxorpd xmm1, xmm1, xmm1
vucomisd xmm0, xmm1
jb short loc_9BD2A
vsqrtsd xmm0, xmm0, xmm0
jmp short loc_9BD2F
loc_9BD2A:
call _sqrt
loc_9BD2F:
vmovsd xmm1, cs:qword_1BCBA8
vucomisd xmm1, xmm0
jbe short loc_9BD79
mov rax, 3FF0000000000000h
mov [r14], rax
cmp ebx, 2
jl loc_9BE29
add r14, 8
dec ebx
shl rbx, 3
mov rdi, r14
xor esi, esi
mov rdx, rbx
vmovsd [rsp+18h+var_18], xmm0
call _memset
vmovsd xmm0, [rsp+18h+var_18]
jmp loc_9BE29
loc_9BD79:
test ebx, ebx
jle loc_9BE29
vmovsd xmm1, cs:qword_1BCBD0
vdivsd xmm2, xmm1, xmm0
mov eax, ebx
add ebx, 3
and ebx, 0FFFFFFFCh
dec rax
vmovq xmm1, rax
vpshufd xmm1, xmm1, 44h ; 'D'
vinsertf128 ymm5, ymm1, xmm1, 1
vmovddup xmm1, xmm2
vinsertf128 ymm8, ymm1, xmm1, 1
xor eax, eax
vmovaps ymm1, cs:ymmword_1BD700
vextractf128 xmm3, ymm5, 1
vmovddup xmm2, cs:qword_1BCBA0
vxorps xmm3, xmm3, xmm2
vpcmpeqd xmm4, xmm4, xmm4
vxorps xmm5, xmm5, xmm2
loc_9BDD6:
vmovq xmm6, rax
vpshufd xmm6, xmm6, 44h ; 'D'
vinsertf128 ymm6, ymm6, xmm6, 1
vorps ymm6, ymm6, ymm1
vextractf128 xmm7, ymm6, 1
vxorps xmm7, xmm7, xmm2
vpcmpgtq xmm7, xmm7, xmm3
vpxor xmm7, xmm7, xmm4
vxorps xmm6, xmm6, xmm2
vpcmpgtq xmm6, xmm6, xmm5
vpxor xmm6, xmm6, xmm4
vinsertf128 ymm6, ymm6, xmm7, 1
vmaskmovpd ymm7, ymm6, ymmword ptr [r14+rax*8]
vmulpd ymm7, ymm8, ymm7
vmaskmovpd ymmword ptr [r14+rax*8], ymm6, ymm7
add rax, 4
cmp rbx, rax
jnz short loc_9BDD6
loc_9BE29:
add rsp, 8
pop rbx
pop r14
vzeroupper
retn
|
void mju_normalize(_QWORD *a1, int a2, __m128 _XMM0, __m128 _XMM1)
{
char v7; // cf
char v8; // zf
_R14 = a1;
*(double *)_XMM0.m128_u64 = mju_dot(a1, a1, (unsigned int)a2);
__asm
{
vxorpd xmm1, xmm1, xmm1
vucomisd xmm0, xmm1
}
if ( v7 )
*(double *)_XMM0.m128_u64 = sqrt(*(double *)_XMM0.m128_u64);
else
__asm { vsqrtsd xmm0, xmm0, xmm0 }
__asm
{
vmovsd xmm1, cs:qword_1BCBA8
vucomisd xmm1, xmm0
}
if ( v7 | v8 )
{
if ( a2 > 0 )
{
__asm
{
vmovsd xmm1, cs:qword_1BCBD0
vdivsd xmm2, xmm1, xmm0
}
_RAX = (unsigned int)a2 - 1LL;
__asm
{
vmovq xmm1, rax
vpshufd xmm1, xmm1, 44h ; 'D'
vinsertf128 ymm5, ymm1, xmm1, 1
vmovddup xmm1, xmm2
vinsertf128 ymm8, ymm1, xmm1, 1
}
_RAX = 0LL;
__asm
{
vmovaps ymm1, cs:ymmword_1BD700
vextractf128 xmm3, ymm5, 1
vmovddup xmm2, cs:qword_1BCBA0
vxorps xmm3, xmm3, xmm2
vpcmpeqd xmm4, xmm4, xmm4
vxorps xmm5, xmm5, xmm2
}
do
{
__asm
{
vmovq xmm6, rax
vpshufd xmm6, xmm6, 44h ; 'D'
vinsertf128 ymm6, ymm6, xmm6, 1
vorps ymm6, ymm6, ymm1
vextractf128 xmm7, ymm6, 1
vxorps xmm7, xmm7, xmm2
vpcmpgtq xmm7, xmm7, xmm3
vpxor xmm7, xmm7, xmm4
vxorps xmm6, xmm6, xmm2
vpcmpgtq xmm6, xmm6, xmm5
vpxor xmm6, xmm6, xmm4
vinsertf128 ymm6, ymm6, xmm7, 1
vmaskmovpd ymm7, ymm6, ymmword ptr [r14+rax*8]
vmulpd ymm7, ymm8, ymm7
vmaskmovpd ymmword ptr [r14+rax*8], ymm6, ymm7
}
_RAX += 4LL;
}
while ( ((a2 + 3) & 0xFFFFFFFC) != _RAX );
}
}
else
{
*a1 = 0x3FF0000000000000LL;
if ( a2 >= 2 )
{
__asm { vmovsd [rsp+18h+var_18], xmm0 }
memset(a1 + 1, 0LL, 8LL * (unsigned int)(a2 - 1));
__asm { vmovsd xmm0, [rsp+18h+var_18] }
}
}
__asm { vzeroupper }
}
|
mju_normalize:
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
MOV RSI,RDI
MOV EDX,EBX
CALL 0x0012d500
VXORPD XMM1,XMM1,XMM1
VUCOMISD XMM0,XMM1
JC 0x0019bd2a
VSQRTSD XMM0,XMM0,XMM0
JMP 0x0019bd2f
LAB_0019bd2a:
CALL 0x0012d200
LAB_0019bd2f:
VMOVSD XMM1,qword ptr [0x002bcba8]
VUCOMISD XMM1,XMM0
JBE 0x0019bd79
MOV RAX,0x3ff0000000000000
MOV qword ptr [R14],RAX
CMP EBX,0x2
JL 0x0019be29
ADD R14,0x8
DEC EBX
SHL RBX,0x3
MOV RDI,R14
XOR ESI,ESI
MOV RDX,RBX
VMOVSD qword ptr [RSP],XMM0
CALL 0x0012d300
VMOVSD XMM0,qword ptr [RSP]
JMP 0x0019be29
LAB_0019bd79:
TEST EBX,EBX
JLE 0x0019be29
VMOVSD XMM1,qword ptr [0x002bcbd0]
VDIVSD XMM2,XMM1,XMM0
MOV EAX,EBX
ADD EBX,0x3
AND EBX,0xfffffffc
DEC RAX
VMOVQ XMM1,RAX
VPSHUFD XMM1,XMM1,0x44
VINSERTF128 YMM5,YMM1,XMM1,0x1
VMOVDDUP XMM1,XMM2
VINSERTF128 YMM8,YMM1,XMM1,0x1
XOR EAX,EAX
VMOVAPS YMM1,ymmword ptr [0x002bd700]
VEXTRACTF128 XMM3,YMM5,0x1
VMOVDDUP XMM2,qword ptr [0x002bcba0]
VXORPS XMM3,XMM3,XMM2
VPCMPEQD XMM4,XMM4,XMM4
VXORPS XMM5,XMM5,XMM2
LAB_0019bdd6:
VMOVQ XMM6,RAX
VPSHUFD XMM6,XMM6,0x44
VINSERTF128 YMM6,YMM6,XMM6,0x1
VORPS YMM6,YMM6,YMM1
VEXTRACTF128 XMM7,YMM6,0x1
VXORPS XMM7,XMM7,XMM2
VPCMPGTQ XMM7,XMM7,XMM3
VPXOR XMM7,XMM7,XMM4
VXORPS XMM6,XMM6,XMM2
VPCMPGTQ XMM6,XMM6,XMM5
VPXOR XMM6,XMM6,XMM4
VINSERTF128 YMM6,YMM6,XMM7,0x1
VMASKMOVPD YMM7,YMM6,ymmword ptr [R14 + RAX*0x8]
VMULPD YMM7,YMM8,YMM7
VMASKMOVPD ymmword ptr [R14 + RAX*0x8],YMM6,YMM7
ADD RAX,0x4
CMP RBX,RAX
JNZ 0x0019bdd6
LAB_0019be29:
ADD RSP,0x8
POP RBX
POP R14
VZEROUPPER
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void mju_normalize(int8 *param_1,uint param_2)
{
uint uVar1;
uint uVar2;
int1 auVar3 [32];
ulong uVar4;
int1 auVar5 [64];
int1 auVar6 [16];
double dVar7;
int1 auVar8 [16];
int1 auVar9 [16];
int1 in_ZMM4 [64];
int1 auVar10 [16];
int1 auVar11 [16];
int1 auVar12 [16];
int1 auVar13 [32];
int1 auVar14 [32];
int1 auVar15 [16];
int1 auVar16 [32];
int1 extraout_var [56];
auVar9 = in_ZMM4._0_16_;
auVar5._0_8_ = (double)mju_dot(param_1,param_1,param_2);
auVar5._8_56_ = extraout_var;
if (auVar5._0_8_ < 0.0) {
dVar7 = sqrt(auVar5._0_8_);
}
else {
auVar6 = vsqrtsd_avx(auVar5._0_16_,auVar5._0_16_);
dVar7 = auVar6._0_8_;
}
auVar3 = _DAT_002bd700;
uVar2 = DAT_002bcba0._4_4_;
uVar1 = (uint)DAT_002bcba0;
if (DAT_002bcba8 <= dVar7) {
if (0 < (int)param_2) {
dVar7 = DAT_002bcbd0 / dVar7;
auVar6._8_8_ = 0;
auVar6._0_8_ = (ulong)param_2 - 1;
auVar6 = vpshufd_avx(auVar6,0x44);
uVar4 = 0;
auVar8._0_4_ = auVar6._0_4_ ^ (uint)DAT_002bcba0;
auVar8._4_4_ = auVar6._4_4_ ^ DAT_002bcba0._4_4_;
auVar8._8_4_ = auVar6._8_4_ ^ (uint)DAT_002bcba0;
auVar8._12_4_ = auVar6._12_4_ ^ DAT_002bcba0._4_4_;
auVar9 = vpcmpeqd_avx(auVar9,auVar9);
auVar10._0_4_ = auVar6._0_4_ ^ (uint)DAT_002bcba0;
auVar10._4_4_ = auVar6._4_4_ ^ DAT_002bcba0._4_4_;
auVar10._8_4_ = auVar6._8_4_ ^ (uint)DAT_002bcba0;
auVar10._12_4_ = auVar6._12_4_ ^ DAT_002bcba0._4_4_;
do {
auVar11._8_8_ = 0;
auVar11._0_8_ = uVar4;
auVar6 = vpshufd_avx(auVar11,0x44);
auVar13._16_16_ = auVar6;
auVar13._0_16_ = auVar6;
auVar13 = vorps_avx(auVar13,auVar3);
auVar15._0_4_ = auVar13._16_4_ ^ uVar1;
auVar15._4_4_ = auVar13._20_4_ ^ uVar2;
auVar15._8_4_ = auVar13._24_4_ ^ uVar1;
auVar15._12_4_ = auVar13._28_4_ ^ uVar2;
auVar6 = vpcmpgtq_avx(auVar15,auVar8);
auVar12._0_4_ = auVar13._0_4_ ^ uVar1;
auVar12._4_4_ = auVar13._4_4_ ^ uVar2;
auVar12._8_4_ = auVar13._8_4_ ^ uVar1;
auVar12._12_4_ = auVar13._12_4_ ^ uVar2;
auVar11 = vpcmpgtq_avx(auVar12,auVar10);
auVar14._16_16_ = auVar6 ^ auVar9;
auVar14._0_16_ = auVar11 ^ auVar9;
auVar13 = vmaskmovpd_avx(auVar14,*(int1 (*) [32])(param_1 + uVar4));
auVar16._0_8_ = dVar7 * auVar13._0_8_;
auVar16._8_8_ = dVar7 * auVar13._8_8_;
auVar16._16_8_ = dVar7 * auVar13._16_8_;
auVar16._24_8_ = dVar7 * auVar13._24_8_;
auVar13 = vmaskmovpd_avx(auVar14,auVar16);
*(int1 (*) [32])(param_1 + uVar4) = auVar13;
uVar4 = uVar4 + 4;
} while ((param_2 + 3 & 0xfffffffc) != uVar4);
}
}
else {
*param_1 = 0x3ff0000000000000;
if (1 < (int)param_2) {
memset(param_1 + 1,0,(ulong)(param_2 - 1) << 3);
}
}
return;
}
|
|
19,717
|
fs_get_cache_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
llama.cpp/common/common.cpp
|
std::string fs_get_cache_file(const std::string & filename) {
GGML_ASSERT(filename.find(DIRECTORY_SEPARATOR) == std::string::npos);
std::string cache_directory = fs_get_cache_directory();
const bool success = fs_create_directory_with_parents(cache_directory);
if (!success) {
throw std::runtime_error("failed to create cache directory: " + cache_directory);
}
return cache_directory + filename;
}
|
O3
|
cpp
|
fs_get_cache_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2f, %esi
xorl %edx, %edx
callq 0x21240
cmpq $-0x1, %rax
jne 0xf877d
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf8350
movq %r15, %rdi
callq 0xf8252
testb %al, %al
je 0xf879e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x27f6f
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf876f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2c281(%rip), %rdi # 0x124a05
leaq 0x21738(%rip), %rdx # 0x119ec3
leaq 0x2c44b(%rip), %rcx # 0x124bdd
movl $0x353, %esi # imm = 0x353
xorl %eax, %eax
callq 0x20e70
movl $0x10, %edi
callq 0x20650
movq %rax, %rbx
leaq 0x2c463(%rip), %rsi # 0x124c15
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x285e7
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x20480
xorl %ebp, %ebp
movq 0x6a7e6(%rip), %rsi # 0x162fc0
movq 0x6a79f(%rip), %rdx # 0x162f80
movq %rbx, %rdi
callq 0x20a60
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf8807
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x20180
testb %bpl, %bpl
jne 0xf8811
jmp 0xf881e
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f00
jmp 0xf881e
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf8839
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
movq %r14, %rdi
callq 0x20b00
|
_Z17fs_get_cache_fileRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp; int
push r15; int
push r14; __int64
push rbx; int
sub rsp, 48h
mov r14, rsi
mov rbx, rdi
mov rdi, rsi
mov esi, 2Fh ; '/'
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_F877D
lea r15, [rsp+68h+var_60]
mov rdi, r15; int
call _Z22fs_get_cache_directoryB5cxx11v; fs_get_cache_directory(void)
mov rdi, r15
call _Z32fs_create_directory_with_parentsRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; fs_create_directory_with_parents(std::string const&)
test al, al
jz short loc_F879E
lea rsi, [rsp+68h+var_60]
mov rdi, rbx
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_SA_; std::operator+<char>(std::string const&,std::string const&)
lea rax, [rsp+68h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F876F
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F876F:
mov rax, rbx
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_F877D:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFilenameFindDi; "filename.find(DIRECTORY_SEPARATOR) == s"...
mov esi, 353h
xor eax, eax
call _ggml_abort
loc_F879E:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aFailedToCreate; "failed to create cache directory: "
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
lea rsi, [rsp+68h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+68h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F8807
mov rsi, [rsp+68h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F8807:
test bpl, bpl
jnz short loc_F8811
jmp short loc_F881E
mov r14, rax
loc_F8811:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_F881E
mov r14, rax
loc_F881E:
lea rax, [rsp+68h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F8839
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F8839:
mov rdi, r14
call __Unwind_Resume
|
_QWORD * fs_get_cache_file(_QWORD *a1, _QWORD *a2)
{
void *exception; // rbx
int v4[4]; // [rsp+8h] [rbp-60h] BYREF
long long v5; // [rsp+18h] [rbp-50h] BYREF
_BYTE v6[16]; // [rsp+28h] [rbp-40h] BYREF
if ( std::string::find(a2, 47LL, 0LL) != -1 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",
851LL,
"GGML_ASSERT(%s) failed",
"filename.find(DIRECTORY_SEPARATOR) == std::string::npos");
LABEL_7:
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v6, (long long)"failed to create cache directory: ", v4);
std::runtime_error::runtime_error(exception, v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
fs_get_cache_directory[abi:cxx11](v4);
if ( !(unsigned __int8)fs_create_directory_with_parents(v4) )
goto LABEL_7;
std::operator+<char>(a1, v4, a2);
if ( *(long long **)v4 != &v5 )
operator delete(*(void **)v4, v5 + 1);
return a1;
}
|
fs_get_cache_file:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
MOV ESI,0x2f
XOR EDX,EDX
CALL 0x00121240
CMP RAX,-0x1
JNZ 0x001f877d
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x001f8350
LAB_001f8738:
MOV RDI,R15
CALL 0x001f8252
TEST AL,AL
JZ 0x001f879e
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
MOV RDX,R14
CALL 0x00127f6f
LAB_001f8754:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001f876f
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00120180
LAB_001f876f:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001f877d:
LEA RDI,[0x224a05]
LEA RDX,[0x219ec3]
LEA RCX,[0x224bdd]
MOV ESI,0x353
XOR EAX,EAX
CALL 0x00120e70
LAB_001f879e:
MOV EDI,0x10
CALL 0x00120650
MOV RBX,RAX
LAB_001f87ab:
LEA RSI,[0x224c15]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x001285e7
MOV BPL,0x1
LAB_001f87c4:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00120480
XOR EBP,EBP
MOV RSI,qword ptr [0x00262fc0]
MOV RDX,qword ptr [0x00262f80]
MOV RDI,RBX
CALL 0x00120a60
|
/* fs_get_cache_file(std::__cxx11::string const&) */
string * fs_get_cache_file(string *param_1)
{
char cVar1;
long lVar2;
runtime_error *this;
char in_SIL;
long *local_60 [2];
long local_50 [2];
string local_40 [32];
lVar2 = std::__cxx11::string::find(in_SIL,0x2f);
if (lVar2 != -1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",0x353,
"GGML_ASSERT(%s) failed","filename.find(DIRECTORY_SEPARATOR) == std::string::npos");
}
fs_get_cache_directory_abi_cxx11_();
/* try { // try from 001f8738 to 001f8753 has its CatchHandler @ 001f881b */
cVar1 = fs_create_directory_with_parents((string *)local_60);
if (cVar1 != '\0') {
std::operator+(param_1,(string *)local_60);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
return param_1;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001f87ab to 001f87c0 has its CatchHandler @ 001f880e */
std::operator+((char *)local_40,(string *)"failed to create cache directory: ");
/* try { // try from 001f87c4 to 001f87e8 has its CatchHandler @ 001f87e9 */
std::runtime_error::runtime_error(this,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00262fc0,PTR__runtime_error_00262f80);
}
|
|
19,718
|
nglog::RawLog(nglog::LogSeverity, char const*, int, char const*, ...)
|
ng-log[P]ng-log/src/raw_logging.cc
|
void RawLog(LogSeverity severity, const char* file, int line,
const char* format, ...) {
if (!(FLAGS_logtostdout || FLAGS_logtostderr ||
severity >= FLAGS_stderrthreshold || FLAGS_alsologtostderr ||
!IsLoggingInitialized())) {
return; // this stderr log message is suppressed
}
// We do not have any any option other that string streams to obtain the
// thread identifier as the corresponding value is not convertible to an
// integer. Use a statically allocated buffer to avoid dynamic memory
// allocations.
StaticStringBuf<kLogBufSize> sbuf;
std::ostream oss(&sbuf);
oss << std::setw(5) << std::this_thread::get_id();
// can't call localtime_r here: it can allocate
char buffer[kLogBufSize];
char* buf = buffer;
size_t size = sizeof(buffer);
// NOTE: this format should match the specification in base/logging.h
DoRawLog(&buf, &size, "%c00000000 00:00:00.000000 %s %s:%d] RAW: ",
GetLogSeverityName(severity)[0], sbuf.data(),
const_basename(const_cast<char*>(file)), line);
// Record the position and size of the buffer after the prefix
const char* msg_start = buf;
const size_t msg_size = size;
va_list ap;
va_start(ap, format);
bool no_chop = VADoRawLog(&buf, &size, format, ap);
va_end(ap);
if (no_chop) {
DoRawLog(&buf, &size, "\n");
} else {
DoRawLog(&buf, &size, "RAW_LOG ERROR: The Message was too long!\n");
}
// We make a raw syscall to write directly to the stderr file descriptor,
// avoiding FILE buffering (to avoid invoking malloc()), and bypassing
// libc (to side-step any libc interception).
// We write just once to avoid races with other invocations of RawLog.
safe_write(fileno(stderr), buffer, strlen(buffer));
if (severity == NGLOG_FATAL) {
std::call_once(crashed, [file, line, msg_start, msg_size] {
crash_reason.filename = file;
crash_reason.line_number = line;
memcpy(crash_buf, msg_start, msg_size); // Don't include prefix
crash_reason.message = crash_buf;
#ifdef HAVE_STACKTRACE
crash_reason.depth =
GetStackTrace(crash_reason.stack, ARRAYSIZE(crash_reason.stack), 1);
#else
crash_reason.depth = 0;
#endif
SetCrashReason(&crash_reason);
});
LogMessage::Fail(); // abort()
}
}
|
O3
|
cpp
|
nglog::RawLog(nglog::LogSeverity, char const*, int, char const*, ...):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x19e8, %rsp # imm = 0x19E8
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, 0x28(%rsp)
movl %edi, 0xc(%rsp)
testb %al, %al
je 0x1f048
movaps %xmm0, 0x1b0(%rsp)
movaps %xmm1, 0x1c0(%rsp)
movaps %xmm2, 0x1d0(%rsp)
movaps %xmm3, 0x1e0(%rsp)
movaps %xmm4, 0x1f0(%rsp)
movaps %xmm5, 0x200(%rsp)
movaps %xmm6, 0x210(%rsp)
movaps %xmm7, 0x220(%rsp)
movq %r8, 0x1a0(%rsp)
movq %r9, 0x1a8(%rsp)
leaq 0x10933(%rip), %rax # 0x2f992
cmpb $0x0, (%rax)
je 0x1f10c
movq 0xfed1(%rip), %rbx # 0x2ef40
addq $0x10, %rbx
leaq 0x270(%rsp), %r14
movq %rbx, -0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, -0x30(%r14)
movups %xmm0, -0x20(%r14)
movups %xmm0, -0x10(%r14)
movq %r14, %rdi
callq 0x7a40
leaq 0xfb68(%rip), %rax # 0x2ec08
movq %rax, -0x38(%r14)
leaq 0x278(%rsp), %r13
leaq 0xe30(%rsp), %rax
movq %r13, -0x18(%r13)
movq %r13, -0x20(%r13)
movq %rax, -0x10(%r13)
movq %r13, -0x38(%r13)
movq %r13, -0x30(%r13)
movq %rax, -0x28(%r13)
leaq 0x70(%rsp), %rdi
leaq 0x238(%rsp), %rsi
callq 0x71c0
movq 0x70(%rsp), %rax
movq -0x18(%rax), %rax
movq $0x5, 0x80(%rsp,%rax)
callq 0x7460
testq %rax, %rax
je 0x1f151
leaq 0x70(%rsp), %rdi
movq %rax, %rsi
callq 0x7360
jmp 0x1f167
leaq 0x10877(%rip), %rax # 0x2f98a
cmpb $0x0, (%rax)
jne 0x1f068
leaq 0x10875(%rip), %rax # 0x2f998
movl 0xc(%rsp), %ecx
cmpl %ecx, (%rax)
jle 0x1f068
leaq 0x10856(%rip), %rax # 0x2f98c
cmpb $0x0, (%rax)
jne 0x1f068
callq 0x20dcc
testb %al, %al
je 0x1f068
jmp 0x1f2d1
leaq 0x43e5(%rip), %rsi # 0x2353d
leaq 0x70(%rsp), %rdi
movl $0x24, %edx
callq 0x7600
leaq 0xe30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0xbb8, 0x10(%rsp) # imm = 0xBB8
movl 0xc(%rsp), %edi
callq 0x934c
movsbl (%rax), %ebp
movq 0x260(%rsp), %rax
cmpq 0x258(%rsp), %rax
je 0x1f1c2
movq 0x268(%rsp), %rcx
cmpq %rcx, %rax
je 0x1f1c2
cmpb $0x0, -0x1(%rax)
je 0x1f1c2
cmpq %rcx, %rax
jae 0x1f2e3
movb $0x0, (%rax)
incq 0x260(%rsp)
movq 0x28(%rsp), %rdi
callq 0x20dd9
movl %r12d, 0x24(%rsp)
movl %r12d, (%rsp)
leaq 0x4961(%rip), %rdx # 0x23b3d
leaq 0x18(%rsp), %r14
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %ecx
movq %r13, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x1f35b
movq (%r14), %r13
movq (%r12), %rbp
leaq 0x180(%rsp), %rax
leaq 0x30(%rsp), %rcx
movq %rax, 0x10(%rcx)
leaq 0x1a20(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000020, %rax # imm = 0x3000000020
movq %rax, (%rcx)
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x7300
leaq 0x4927(%rip), %rdx # 0x23b68
testl %eax, %eax
js 0x1f263
movl %eax, %eax
movq %rbp, %rcx
subq %rax, %rcx
jb 0x1f263
movq %rcx, 0x10(%rsp)
addq %r13, %rax
movq %rax, 0x18(%rsp)
leaq 0x3871(%rip), %rdx # 0x22ad4
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
xorl %eax, %eax
callq 0x1f35b
movq 0xfd15(%rip), %rax # 0x2ef90
movq (%rax), %rdi
callq 0x7580
movl %eax, %r14d
leaq 0xe30(%rsp), %r12
movq %r12, %rdi
callq 0x71f0
movl $0x1, %edi
movl %r14d, %esi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x7080
cmpl $0x3, 0xc(%rsp)
je 0x1f2f8
leaq 0x78(%rsp), %rdi
callq 0x7170
movq %rbx, 0x238(%rsp)
leaq 0x270(%rsp), %rdi
callq 0x77a0
addq $0x19e8, %rsp # imm = 0x19E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x238(%rsp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x68(%rax)
jmp 0x1f1c2
leaq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, (%rdi)
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rdi)
movq %r13, 0x10(%rdi)
movq %rbp, 0x18(%rdi)
callq 0x1f401
callq 0xa9f0
movq %rax, %rdi
callq 0x1032b
jmp 0x1f331
jmp 0x1f331
jmp 0x1f331
movq %rax, %r14
jmp 0x1f33e
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0x7170
movq %rbx, 0x238(%rsp)
leaq 0x270(%rsp), %rdi
callq 0x77a0
movq %r14, %rdi
callq 0x7970
|
_ZN5nglog6RawLogENS_11LogSeverityEPKciS2_z:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 19E8h
mov r15, rcx
mov r12d, edx
mov [rsp+1A18h+var_19F0], rsi
mov [rsp+1A18h+var_1A0C], edi
test al, al
jz short loc_1F048
movaps [rsp+1A18h+var_1868], xmm0
movaps [rsp+1A18h+var_1858], xmm1
movaps [rsp+1A18h+var_1848], xmm2
movaps [rsp+1A18h+var_1838], xmm3
movaps [rsp+1A18h+var_1828], xmm4
movaps [rsp+1A18h+var_1818], xmm5
movaps [rsp+1A18h+var_1808], xmm6
movaps [rsp+1A18h+var_17F8], xmm7
loc_1F048:
mov [rsp+1A18h+var_1878], r8
mov [rsp+1A18h+var_1870], r9
lea rax, _ZN3fLB17FLAGS_logtostdoutE; fLB::FLAGS_logtostdout
cmp byte ptr [rax], 0
jz loc_1F10C
loc_1F068:
mov rbx, cs:_ZTVSt15basic_streambufIcSt11char_traitsIcEE_ptr
add rbx, 10h
lea r14, [rsp+1A18h+var_17A8]
mov [r14-38h], rbx
xorps xmm0, xmm0
movups xmmword ptr [r14-30h], xmm0
movups xmmword ptr [r14-20h], xmm0
movups xmmword ptr [r14-10h], xmm0
mov rdi, r14; this
call __ZNSt6localeC1Ev; std::locale::locale(void)
lea rax, off_2EC08
mov [r14-38h], rax
lea r13, [rsp+1A18h+var_17A0]
lea rax, [rsp+1A18h+var_BE8]
mov [r13-18h], r13
mov [r13-20h], r13
mov [r13-10h], rax
mov [r13-38h], r13
mov [r13-30h], r13
mov [r13-28h], rax
lea rdi, [rsp+1A18h+var_19A8]
lea rsi, [rsp+1A18h+var_17E0]
call __ZNSoC1EPSt15basic_streambufIcSt11char_traitsIcEE; std::ostream::ostream(std::streambuf *)
mov rax, [rsp+1A18h+var_19A8]
mov rax, [rax-18h]
mov [rsp+rax+1A18h+var_1998], 5
call _pthread_self
test rax, rax
jz short loc_1F151
lea rdi, [rsp+1A18h+var_19A8]; this
mov rsi, rax
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
jmp short loc_1F167
loc_1F10C:
lea rax, _ZN3fLB17FLAGS_logtostderrE; fLB::FLAGS_logtostderr
cmp byte ptr [rax], 0
jnz loc_1F068
lea rax, _ZN3fLI21FLAGS_stderrthresholdE; fLI::FLAGS_stderrthreshold
mov ecx, [rsp+1A18h+var_1A0C]
cmp [rax], ecx
jle loc_1F068
lea rax, _ZN3fLB21FLAGS_alsologtostderrE; fLB::FLAGS_alsologtostderr
cmp byte ptr [rax], 0
jnz loc_1F068
call _ZN5nglog20IsLoggingInitializedEv; nglog::IsLoggingInitialized(void)
test al, al
jz loc_1F068
jmp loc_1F2D1
loc_1F151:
lea rsi, aThreadIdOfANon; "thread::id of a non-executing thread"
lea rdi, [rsp+1A18h+var_19A8]
mov edx, 24h ; '$'
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_1F167:
lea rax, [rsp+1A18h+var_BE8]
mov [rsp+1A18h+var_1A00], rax
mov [rsp+1A18h+var_1A08], 0BB8h
mov edi, [rsp+1A18h+var_1A0C]
call _ZN5nglog18GetLogSeverityNameENS_11LogSeverityE; nglog::GetLogSeverityName(nglog::LogSeverity)
movsx ebp, byte ptr [rax]
mov rax, [rsp+1A18h+var_17B8]
cmp rax, [rsp+1A18h+var_17C0]
jz short loc_1F1C2
mov rcx, [rsp+1A18h+var_17B0]
cmp rax, rcx
jz short loc_1F1C2
cmp byte ptr [rax-1], 0
jz short loc_1F1C2
cmp rax, rcx
jnb loc_1F2E3
mov byte ptr [rax], 0
inc [rsp+1A18h+var_17B8]
loc_1F1C2:
mov rdi, [rsp+1A18h+var_19F0]; this
call _ZN5nglog5tools14const_basenameEPKc; nglog::tools::const_basename(char const*)
mov [rsp+1A18h+var_19F4], r12d
mov [rsp+1A18h+var_1A18], r12d
lea rdx, aC0000000000000; "%c00000000 00:00:00.000000 %s %s:%d] RA"...
lea r14, [rsp+1A18h+var_1A00]
lea r12, [rsp+1A18h+var_1A08]
mov rdi, r14; this
mov rsi, r12; char **
mov ecx, ebp; char *
mov r8, r13
mov r9, rax
xor eax, eax
call _ZN5nglogL8DoRawLogEPPcPmPKcz; nglog::DoRawLog(char **,ulong *,char const*,...)
mov r13, [r14]
mov rbp, [r12]
lea rax, [rsp+1A18h+var_1898]
lea rcx, [rsp+1A18h+var_19E8]
mov [rcx+10h], rax
lea rax, [rsp+1A18h+arg_0]
mov [rcx+8], rax
mov rax, 3000000020h
mov [rcx], rax
mov rdi, r13
mov rsi, rbp
mov rdx, r15
call _vsnprintf
lea rdx, aRawLogErrorThe; "RAW_LOG ERROR: The Message was too long"...
test eax, eax
js short loc_1F263
mov eax, eax
mov rcx, rbp
sub rcx, rax; char *
jb short loc_1F263
mov [rsp+1A18h+var_1A08], rcx
add rax, r13
mov [rsp+1A18h+var_1A00], rax
lea rdx, asc_22AD3+1; unsigned __int64 *
loc_1F263:
lea rdi, [rsp+1A18h+var_1A00]; this
lea rsi, [rsp+1A18h+var_1A08]; char **
xor eax, eax
call _ZN5nglogL8DoRawLogEPPcPmPKcz; nglog::DoRawLog(char **,ulong *,char const*,...)
mov rax, cs:stderr_ptr
mov rdi, [rax]
call _fileno
mov r14d, eax
lea r12, [rsp+1A18h+var_BE8]
mov rdi, r12
call _strlen
mov edi, 1
mov esi, r14d
mov rdx, r12
mov rcx, rax
xor eax, eax
call _syscall
cmp [rsp+1A18h+var_1A0C], 3
jz short loc_1F2F8
lea rdi, [rsp+1A18h+var_19A0]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov [rsp+1A18h+var_17E0], rbx
lea rdi, [rsp+1A18h+var_17A8]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
loc_1F2D1:
add rsp, 19E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1F2E3:
lea rdi, [rsp+1A18h+var_17E0]
mov rax, [rdi]
xor esi, esi
call qword ptr [rax+68h]
jmp loc_1F1C2
loc_1F2F8:
lea rdi, [rsp+1A18h+var_19C8]; this
mov rax, [rsp+1A18h+var_19F0]
mov [rdi], rax
mov eax, [rsp+1A18h+var_19F4]
mov [rdi+8], eax
mov [rdi+10h], r13
mov [rdi+18h], rbp
call _ZSt9call_onceIZN5nglog6RawLogENS0_11LogSeverityEPKciS3_zE3$_0JEEvRSt9once_flagOT_DpOT0_; std::call_once<nglog::RawLog(nglog::LogSeverity,char const*,int,char const*,...)::$_0>(std::once_flag &,nglog::RawLog(nglog::LogSeverity,char const*,int,char const*,...)::$_0 &&)
call _ZN5nglog10LogMessage4FailEv; nglog::LogMessage::Fail(void)
mov rdi, rax
call __clang_call_terminate
jmp short loc_1F331
jmp short loc_1F331
jmp short loc_1F331
mov r14, rax
jmp short loc_1F33E
loc_1F331:
mov r14, rax
lea rdi, [rsp+1A18h+var_19A0]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
loc_1F33E:
mov [rsp+1A18h+var_17E0], rbx
lea rdi, [rsp+1A18h+var_17A8]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rdi, r14
call __Unwind_Resume
|
void nglog::RawLog(
nglog *a1,
nglog::tools *a2,
int a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
long long v17; // rax
const char *v18; // rsi
unsigned int v19; // ebp
long long v20; // rax
_BYTE *v21; // r13
char *v22; // rbp
unsigned int v23; // eax
const char *v24; // rcx
char *v25; // rdx
unsigned int v26; // r14d
long long v27; // rax
char *v28; // [rsp+10h] [rbp-1A08h] BYREF
_BYTE *v29; // [rsp+18h] [rbp-1A00h] BYREF
int v30; // [rsp+24h] [rbp-19F4h]
nglog::tools *v31; // [rsp+28h] [rbp-19F0h]
_QWORD v32[4]; // [rsp+30h] [rbp-19E8h] BYREF
nglog::tools *v33; // [rsp+50h] [rbp-19C8h] BYREF
int v34; // [rsp+58h] [rbp-19C0h]
_BYTE *v35; // [rsp+60h] [rbp-19B8h]
char *v36; // [rsp+68h] [rbp-19B0h]
long long v37; // [rsp+70h] [rbp-19A8h] BYREF
_BYTE v38[264]; // [rsp+78h] [rbp-19A0h] BYREF
char v39; // [rsp+180h] [rbp-1898h] BYREF
long long v40; // [rsp+1A0h] [rbp-1878h]
long long v41; // [rsp+1A8h] [rbp-1870h]
__m128 v42; // [rsp+1B0h] [rbp-1868h]
__m128 v43; // [rsp+1C0h] [rbp-1858h]
__m128 v44; // [rsp+1D0h] [rbp-1848h]
__m128 v45; // [rsp+1E0h] [rbp-1838h]
__m128 v46; // [rsp+1F0h] [rbp-1828h]
__m128 v47; // [rsp+200h] [rbp-1818h]
__m128 v48; // [rsp+210h] [rbp-1808h]
__m128 v49; // [rsp+220h] [rbp-17F8h]
_QWORD v50[4]; // [rsp+238h] [rbp-17E0h] BYREF
_BYTE *v51; // [rsp+258h] [rbp-17C0h]
_BYTE *v52; // [rsp+260h] [rbp-17B8h]
_BYTE *v53; // [rsp+268h] [rbp-17B0h]
char v54[8]; // [rsp+270h] [rbp-17A8h] BYREF
_BYTE v55[3000]; // [rsp+278h] [rbp-17A0h] BYREF
_BYTE v56[3048]; // [rsp+E30h] [rbp-BE8h] BYREF
v42 = a7;
v43 = a8;
v44 = a9;
v45 = a10;
v46 = a11;
v47 = a12;
v48 = a13;
v49 = a14;
v31 = a2;
v40 = a5;
v41 = a6;
if ( fLB::FLAGS_logtostdout
|| fLB::FLAGS_logtostderr
|| fLI::FLAGS_stderrthreshold <= (int)a1
|| fLB::FLAGS_alsologtostderr
|| !(unsigned __int8)nglog::IsLoggingInitialized(a1) )
{
std::locale::locale((std::locale *)v54);
v50[0] = &off_2EC08;
v52 = v55;
v51 = v55;
v53 = v56;
v50[1] = v55;
v50[2] = v55;
v50[3] = v56;
std::ostream::ostream(&v37, v50);
*(_QWORD *)&v38[*(_QWORD *)(v37 - 24) + 8] = 5LL;
v17 = pthread_self();
if ( v17 )
{
v18 = (const char *)v17;
std::ostream::_M_insert<unsigned long>(&v37);
}
else
{
v18 = "thread::id of a non-executing thread";
std::__ostream_insert<char,std::char_traits<char>>(&v37, "thread::id of a non-executing thread", 36LL);
}
v29 = v56;
v28 = (_BYTE *)(&stru_BB0 + 8);
v19 = *nglog::GetLogSeverityName((int)a1);
if ( v52 != v51 && v52 != v53 && *(v52 - 1) )
{
if ( v52 >= v53 )
{
v18 = 0LL;
(*(void ( **)(_QWORD *, _QWORD))(v50[0] + 104LL))(v50, 0LL);
}
else
{
*v52++ = 0;
}
}
v20 = nglog::tools::const_basename(v31, v18);
v30 = a3;
nglog::DoRawLog(
(nglog *)&v29,
&v28,
(unsigned long long *)"%c00000000 00:00:00.000000 %s %s:%d] RAW: ",
(const char *)v19,
v55,
v20,
a3);
v21 = v29;
v22 = v28;
v32[2] = &v39;
v32[1] = &a15;
v32[0] = 0x3000000020LL;
v23 = vsnprintf(v29, v28, a4, v32);
v25 = "RAW_LOG ERROR: The Message was too long!\n";
if ( (v23 & 0x80000000) == 0 )
{
v24 = &v22[-v23];
if ( (unsigned long long)v22 >= v23 )
{
v28 = &v22[-v23];
v29 = &v21[v23];
v25 = "\n";
}
}
nglog::DoRawLog((nglog *)&v29, &v28, (unsigned long long *)v25, v24);
v26 = fileno(stderr);
v27 = strlen(v56);
syscall(1LL, v26, v56, v27);
if ( (_DWORD)a1 == 3 )
{
v33 = v31;
v34 = v30;
v35 = v21;
v36 = v22;
std::call_once<nglog::RawLog(nglog::LogSeverity,char const*,int,char const*,...)::$_0>();
nglog::LogMessage::Fail((nglog::LogMessage *)&v33);
}
std::ios_base::~ios_base((std::ios_base *)v38);
v50[0] = (char *)&`vtable for'std::streambuf + 16;
std::locale::~locale((std::locale *)v54);
}
}
|
RawLog:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x19e8
MOV R15,RCX
MOV R12D,EDX
MOV qword ptr [RSP + 0x28],RSI
MOV dword ptr [RSP + 0xc],EDI
TEST AL,AL
JZ 0x0011f048
MOVAPS xmmword ptr [RSP + 0x1b0],XMM0
MOVAPS xmmword ptr [RSP + 0x1c0],XMM1
MOVAPS xmmword ptr [RSP + 0x1d0],XMM2
MOVAPS xmmword ptr [RSP + 0x1e0],XMM3
MOVAPS xmmword ptr [RSP + 0x1f0],XMM4
MOVAPS xmmword ptr [RSP + 0x200],XMM5
MOVAPS xmmword ptr [RSP + 0x210],XMM6
MOVAPS xmmword ptr [RSP + 0x220],XMM7
LAB_0011f048:
MOV qword ptr [RSP + 0x1a0],R8
MOV qword ptr [RSP + 0x1a8],R9
LEA RAX,[0x12f992]
CMP byte ptr [RAX],0x0
JZ 0x0011f10c
LAB_0011f068:
MOV RBX,qword ptr [0x0012ef40]
ADD RBX,0x10
LEA R14,[RSP + 0x270]
MOV qword ptr [R14 + -0x38],RBX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + -0x30],XMM0
MOVUPS xmmword ptr [R14 + -0x20],XMM0
MOVUPS xmmword ptr [R14 + -0x10],XMM0
MOV RDI,R14
CALL 0x00107a40
LEA RAX,[0x12ec08]
MOV qword ptr [R14 + -0x38],RAX
LEA R13,[RSP + 0x278]
LEA RAX,[RSP + 0xe30]
MOV qword ptr [R13 + -0x18],R13
MOV qword ptr [R13 + -0x20],R13
MOV qword ptr [R13 + -0x10],RAX
MOV qword ptr [R13 + -0x38],R13
MOV qword ptr [R13 + -0x30],R13
MOV qword ptr [R13 + -0x28],RAX
LAB_0011f0cc:
LEA RDI,[RSP + 0x70]
LEA RSI,[RSP + 0x238]
CALL 0x001071c0
MOV RAX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RAX + -0x18]
MOV qword ptr [RSP + RAX*0x1 + 0x80],0x5
CALL 0x00107460
TEST RAX,RAX
JZ 0x0011f151
LAB_0011f0fd:
LEA RDI,[RSP + 0x70]
MOV RSI,RAX
CALL 0x00107360
LAB_0011f10a:
JMP 0x0011f167
LAB_0011f10c:
LEA RAX,[0x12f98a]
CMP byte ptr [RAX],0x0
JNZ 0x0011f068
LEA RAX,[0x12f998]
MOV ECX,dword ptr [RSP + 0xc]
CMP dword ptr [RAX],ECX
JLE 0x0011f068
LEA RAX,[0x12f98c]
CMP byte ptr [RAX],0x0
JNZ 0x0011f068
CALL 0x00120dcc
TEST AL,AL
JZ 0x0011f068
JMP 0x0011f2d1
LAB_0011f151:
LEA RSI,[0x12353d]
LEA RDI,[RSP + 0x70]
MOV EDX,0x24
CALL 0x00107600
LAB_0011f167:
LEA RAX,[RSP + 0xe30]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x10],0xbb8
LAB_0011f17d:
MOV EDI,dword ptr [RSP + 0xc]
CALL 0x0010934c
MOVSX EBP,byte ptr [RAX]
MOV RAX,qword ptr [RSP + 0x260]
CMP RAX,qword ptr [RSP + 0x258]
JZ 0x0011f1c2
MOV RCX,qword ptr [RSP + 0x268]
CMP RAX,RCX
JZ 0x0011f1c2
CMP byte ptr [RAX + -0x1],0x0
JZ 0x0011f1c2
CMP RAX,RCX
JNC 0x0011f2e3
MOV byte ptr [RAX],0x0
INC qword ptr [RSP + 0x260]
LAB_0011f1c2:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00120dd9
MOV dword ptr [RSP + 0x24],R12D
MOV dword ptr [RSP],R12D
LEA RDX,[0x123b3d]
LEA R14,[RSP + 0x18]
LEA R12,[RSP + 0x10]
MOV RDI,R14
MOV RSI,R12
MOV ECX,EBP
MOV R8,R13
MOV R9,RAX
XOR EAX,EAX
CALL 0x0011f35b
MOV R13,qword ptr [R14]
MOV RBP,qword ptr [R12]
LEA RAX,[RSP + 0x180]
LEA RCX,[RSP + 0x30]
MOV qword ptr [RCX + 0x10],RAX
LEA RAX,[RSP + 0x1a20]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,0x3000000020
MOV qword ptr [RCX],RAX
MOV RDI,R13
MOV RSI,RBP
MOV RDX,R15
CALL 0x00107300
LEA RDX,[0x123b68]
TEST EAX,EAX
JS 0x0011f263
MOV EAX,EAX
MOV RCX,RBP
SUB RCX,RAX
JC 0x0011f263
MOV qword ptr [RSP + 0x10],RCX
ADD RAX,R13
MOV qword ptr [RSP + 0x18],RAX
LEA RDX,[0x122ad4]
LAB_0011f263:
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0x10]
XOR EAX,EAX
CALL 0x0011f35b
MOV RAX,qword ptr [0x0012ef90]
MOV RDI,qword ptr [RAX]
CALL 0x00107580
MOV R14D,EAX
LEA R12,[RSP + 0xe30]
MOV RDI,R12
CALL 0x001071f0
MOV EDI,0x1
MOV ESI,R14D
MOV RDX,R12
MOV RCX,RAX
XOR EAX,EAX
CALL 0x00107080
CMP dword ptr [RSP + 0xc],0x3
JZ 0x0011f2f8
LEA RDI,[RSP + 0x78]
CALL 0x00107170
MOV qword ptr [RSP + 0x238],RBX
LEA RDI,[RSP + 0x270]
CALL 0x001077a0
LAB_0011f2d1:
ADD RSP,0x19e8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011f2e3:
LEA RDI,[RSP + 0x238]
MOV RAX,qword ptr [RDI]
LAB_0011f2ee:
XOR ESI,ESI
CALL qword ptr [RAX + 0x68]
JMP 0x0011f1c2
LAB_0011f2f8:
LEA RDI,[RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RDI],RAX
MOV EAX,dword ptr [RSP + 0x24]
MOV dword ptr [RDI + 0x8],EAX
MOV qword ptr [RDI + 0x10],R13
MOV qword ptr [RDI + 0x18],RBP
LAB_0011f314:
CALL 0x0011f401
LAB_0011f319:
CALL 0x0010a9f0
LAB_0011f31e:
MOV RDI,RAX
CALL 0x0011032b
|
/* nglog::RawLog(nglog::LogSeverity, char const*, int, char const*, ...) */
void nglog::RawLog(int4 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int param_9,char *param_10,int4 param_11,char *param_12,int8 param_13,
int8 param_14,...)
{
ulong uVar1;
char in_AL;
char cVar2;
uint uVar3;
pthread_t pVar4;
char *pcVar5;
int8 uVar6;
ulong uVar7;
size_t sVar8;
char *pcVar9;
int **ppuVar10;
__0 *p_Var11;
ulong local_1a08;
char *local_1a00;
int4 local_19f4;
char *local_19f0;
int8 local_19e8;
int1 *local_19e0;
int1 *local_19d8;
char *local_19c8;
int4 local_19c0;
char *local_19b8;
ulong local_19b0;
long local_19a8;
ios_base local_19a0 [8];
int8 auStack_1998 [32];
int1 local_1898 [32];
int8 local_1878;
int8 local_1870;
int4 local_1868;
int8 local_1858;
int8 local_1848;
int8 local_1838;
int8 local_1828;
int8 local_1818;
int8 local_1808;
int8 local_17f8;
int **local_17e0;
char *local_17d8;
char *pcStack_17d0;
char *local_17c8;
char *pcStack_17c0;
char *local_17b8;
char *pcStack_17b0;
locale local_17a8 [8];
char local_17a0 [3000];
char local_be8 [3000];
if (in_AL != '\0') {
local_1868 = param_1;
local_1858 = param_2;
local_1848 = param_3;
local_1838 = param_4;
local_1828 = param_5;
local_1818 = param_6;
local_1808 = param_7;
local_17f8 = param_8;
}
local_19f0 = param_10;
local_1878 = param_13;
local_1870 = param_14;
if ((((fLB::FLAGS_logtostdout != '\0') || (fLB::FLAGS_logtostderr != '\0')) ||
(fLI::FLAGS_stderrthreshold <= param_9)) ||
((fLB::FLAGS_alsologtostderr != '\0' || (cVar2 = IsLoggingInitialized(), cVar2 == '\0')))) {
ppuVar10 = (int **)(PTR_vtable_0012ef40 + 0x10);
local_17d8 = (char *)0x0;
pcStack_17d0 = (char *)0x0;
local_17c8 = (char *)0x0;
pcStack_17c0 = (char *)0x0;
local_17b8 = (char *)0x0;
pcStack_17b0 = (char *)0x0;
local_17e0 = ppuVar10;
std::locale::locale(local_17a8);
local_17e0 = &PTR__streambuf_0012ec08;
local_17c8 = local_be8;
/* try { // try from 0011f0cc to 0011f0dd has its CatchHandler @ 0011f32c */
local_17d8 = local_17a0;
pcStack_17d0 = local_17a0;
pcStack_17c0 = local_17a0;
local_17b8 = local_17a0;
pcStack_17b0 = local_17c8;
std::ostream::ostream((ostream *)&local_19a8,(streambuf *)&local_17e0);
*(int8 *)((long)auStack_1998 + *(long *)(local_19a8 + -0x18)) = 5;
pVar4 = pthread_self();
if (pVar4 == 0) {
/* try { // try from 0011f151 to 0011f166 has its CatchHandler @ 0011f32a */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)&local_19a8,"thread::id of a non-executing thread",0x24);
}
else {
/* try { // try from 0011f0fd to 0011f109 has its CatchHandler @ 0011f32a */
std::ostream::_M_insert<unsigned_long>((ulong)&local_19a8);
}
local_1a00 = local_be8;
local_1a08 = 3000;
/* try { // try from 0011f17d to 0011f1cb has its CatchHandler @ 0011f331 */
pcVar5 = (char *)GetLogSeverityName(param_9);
cVar2 = *pcVar5;
if (((local_17b8 != pcStack_17c0) && (local_17b8 != pcStack_17b0)) && (local_17b8[-1] != '\0'))
{
if (local_17b8 < pcStack_17b0) {
*local_17b8 = '\0';
local_17b8 = local_17b8 + 1;
}
else {
/* try { // try from 0011f2ee to 0011f2f2 has its CatchHandler @ 0011f31e */
(*(code *)local_17e0[0xd])(&local_17e0,0);
}
}
uVar6 = tools::const_basename(local_19f0);
local_19f4 = param_11;
DoRawLog(&local_1a00,&local_1a08,"%c00000000 00:00:00.000000 %s %s:%d] RAW: ",
(ulong)(uint)(int)cVar2,local_17a0,uVar6,param_11);
pcVar5 = local_1a00;
uVar1 = local_1a08;
local_19d8 = local_1898;
local_19e0 = &stack0x00000008;
local_19e8 = 0x3000000020;
uVar3 = vsnprintf(local_1a00,local_1a08,param_12,&local_19e8);
pcVar9 = "RAW_LOG ERROR: The Message was too long!\n";
if (-1 < (int)uVar3) {
uVar7 = (ulong)uVar3;
if (uVar7 <= uVar1) {
local_1a00 = pcVar5 + uVar7;
pcVar9 = "\n";
local_1a08 = uVar1 - uVar7;
}
}
DoRawLog(&local_1a00,&local_1a08,pcVar9);
uVar3 = fileno(*(FILE **)PTR_stderr_0012ef90);
sVar8 = strlen(local_be8);
p_Var11 = (__0 *)(ulong)uVar3;
syscall(1,p_Var11,local_be8,sVar8);
if (param_9 == 3) {
local_19c8 = local_19f0;
local_19c0 = local_19f4;
local_19b8 = pcVar5;
local_19b0 = uVar1;
/* try { // try from 0011f314 to 0011f318 has its CatchHandler @ 0011f328 */
std::call_once<nglog::RawLog(nglog::LogSeverity,char_const*,int,char_const*,___)::__0>
((once_flag *)&local_19c8,p_Var11);
/* try { // try from 0011f319 to 0011f31d has its CatchHandler @ 0011f326 */
uVar6 = LogMessage::Fail();
/* catch(type#1 @ 00000000) { ... } // from try @ 0011f2ee with catch @ 0011f31e
*/
/* WARNING: Subroutine does not return */
__clang_call_terminate(uVar6);
}
std::ios_base::~ios_base(local_19a0);
local_17e0 = ppuVar10;
std::locale::~locale(local_17a8);
}
return;
}
|
|
19,719
|
get_all_kv_cache_types[abi:cxx11]()
|
monkey531[P]llama/common/arg.cpp
|
static std::string get_all_kv_cache_types() {
std::ostringstream msg;
for (const auto & type : kv_cache_types) {
msg << ggml_type_name(type) << (&type == &kv_cache_types.back() ? "" : ", ");
}
return msg.str();
}
|
O0
|
cpp
|
get_all_kv_cache_types[abi:cxx11]():
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1d0(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5f120
leaq 0x1f7b43(%rip), %rax # 0x2b4030
movq %rax, 0x50(%rsp)
leaq 0x1f7b37(%rip), %rdi # 0x2b4030
callq 0xf6e40
movq %rax, 0x48(%rsp)
leaq 0x1f7b26(%rip), %rdi # 0x2b4030
callq 0xf6e70
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xf6ea0
testb $0x1, %al
jne 0xbc52c
jmp 0xbc5cc
leaq 0x48(%rsp), %rdi
callq 0xf6ee0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %edi
callq 0x5f400
movq %rax, 0x10(%rsp)
jmp 0xbc54e
movq 0x10(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x5ea60
movq %rax, 0x8(%rsp)
jmp 0xbc564
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x1f7abc(%rip), %rdi # 0x2b4030
callq 0xf6ef0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq (%rsp), %rax
subq %rcx, %rax
leaq 0x15fbdf(%rip), %rax # 0x21c16e
leaq 0x162c24(%rip), %rsi # 0x21f1ba
cmoveq %rax, %rsi
callq 0x5ea60
jmp 0xbc5a1
jmp 0xbc5a3
leaq 0x48(%rsp), %rdi
callq 0xf6f30
jmp 0xbc514
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5f020
jmp 0xbc5f4
movq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x5f4b0
jmp 0xbc5dd
leaq 0x58(%rsp), %rdi
callq 0x5f020
movq 0x20(%rsp), %rax
addq $0x1d8, %rsp # imm = 0x1D8
retq
movq 0x30(%rsp), %rdi
callq 0x5ebf0
nop
|
_ZL22get_all_kv_cache_typesB5cxx11v:
sub rsp, 1D8h
mov [rsp+1D8h+var_1C0], rdi
mov rax, rdi
mov [rsp+1D8h+var_1B8], rax
mov [rsp+1D8h+var_8], rdi
lea rdi, [rsp+1D8h+var_180]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rax, _ZL14kv_cache_types; kv_cache_types
mov [rsp+1D8h+var_188], rax
lea rdi, _ZL14kv_cache_types; kv_cache_types
call _ZNKSt6vectorI9ggml_typeSaIS0_EE5beginEv; std::vector<ggml_type>::begin(void)
mov [rsp+1D8h+var_190], rax
lea rdi, _ZL14kv_cache_types; kv_cache_types
call _ZNKSt6vectorI9ggml_typeSaIS0_EE3endEv; std::vector<ggml_type>::end(void)
mov [rsp+1D8h+var_198], rax
loc_BC514:
lea rdi, [rsp+1D8h+var_190]
lea rsi, [rsp+1D8h+var_198]
call _ZN9__gnu_cxxneIPK9ggml_typeSt6vectorIS1_SaIS1_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<ggml_type const*,std::vector<ggml_type>>(__gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>> const&,__gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>> const&)
test al, 1
jnz short loc_BC52C
jmp loc_BC5CC
loc_BC52C:
lea rdi, [rsp+1D8h+var_190]
call _ZNK9__gnu_cxx17__normal_iteratorIPK9ggml_typeSt6vectorIS1_SaIS1_EEEdeEv; __gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>>::operator*(void)
mov [rsp+1D8h+var_1A0], rax
mov rax, [rsp+1D8h+var_1A0]
mov edi, [rax]
call _ggml_type_name
mov [rsp+1D8h+var_1C8], rax
jmp short $+2
loc_BC54E:
mov rsi, [rsp+1D8h+var_1C8]
lea rdi, [rsp+1D8h+var_180]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+1D8h+var_1D0], rax
jmp short $+2
loc_BC564:
mov rax, [rsp+1D8h+var_1A0]
mov [rsp+1D8h+var_1D8], rax
lea rdi, _ZL14kv_cache_types; kv_cache_types
call _ZNKSt6vectorI9ggml_typeSaIS0_EE4backEv; std::vector<ggml_type>::back(void)
mov rdi, [rsp+1D8h+var_1D0]
mov rcx, rax
mov rax, [rsp+1D8h+var_1D8]
sub rax, rcx
lea rax, aExampleSpecifi+27h; ""
lea rsi, aZuD+6; ", "
cmovz rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_BC5A1:
jmp short $+2
loc_BC5A3:
lea rdi, [rsp+1D8h+var_190]
call _ZN9__gnu_cxx17__normal_iteratorIPK9ggml_typeSt6vectorIS1_SaIS1_EEEppEv; __gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>>::operator++(void)
jmp loc_BC514
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_50]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
jmp short loc_BC5F4
loc_BC5CC:
mov rdi, [rsp+1D8h+var_1C0]
lea rsi, [rsp+1D8h+var_180]
call __ZNKSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEE3strEv; std::ostringstream::str(void)
jmp short $+2
loc_BC5DD:
lea rdi, [rsp+1D8h+var_180]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rax, [rsp+1D8h+var_1B8]
add rsp, 1D8h
retn
loc_BC5F4:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
|
long long get_all_kv_cache_types[abi:cxx11](long long a1)
{
long long v1; // rdi
char *v2; // rsi
long long v4; // [rsp+10h] [rbp-1C8h]
unsigned int *v7; // [rsp+38h] [rbp-1A0h]
long long v8; // [rsp+40h] [rbp-198h] BYREF
_QWORD v9[2]; // [rsp+48h] [rbp-190h] BYREF
_BYTE v10[376]; // [rsp+58h] [rbp-180h] BYREF
long long v11; // [rsp+1D0h] [rbp-8h]
v11 = a1;
std::ostringstream::basic_ostringstream(v10);
v9[1] = &kv_cache_types;
v9[0] = std::vector<ggml_type>::begin(&kv_cache_types);
v8 = std::vector<ggml_type>::end(&kv_cache_types);
while ( (__gnu_cxx::operator!=<ggml_type const*,std::vector<ggml_type>>(v9, &v8) & 1) != 0 )
{
v7 = (unsigned int *)__gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>>::operator*(v9);
v4 = ggml_type_name(*v7);
v1 = std::operator<<<std::char_traits<char>>(v10, v4);
v2 = ", ";
if ( v7 == (unsigned int *)std::vector<ggml_type>::back(&kv_cache_types) )
v2 = "";
std::operator<<<std::char_traits<char>>(v1, v2);
__gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>>::operator++(v9);
}
std::ostringstream::str(a1, v10);
std::ostringstream::~ostringstream(v10);
return a1;
}
|
get_all_kv_cache_types[abi:cxx11]:
SUB RSP,0x1d8
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x1d0],RDI
LEA RDI,[RSP + 0x58]
CALL 0x0015f120
LEA RAX,[0x3b4030]
MOV qword ptr [RSP + 0x50],RAX
LEA RDI,[0x3b4030]
CALL 0x001f6e40
MOV qword ptr [RSP + 0x48],RAX
LEA RDI,[0x3b4030]
CALL 0x001f6e70
MOV qword ptr [RSP + 0x40],RAX
LAB_001bc514:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x40]
CALL 0x001f6ea0
TEST AL,0x1
JNZ 0x001bc52c
JMP 0x001bc5cc
LAB_001bc52c:
LEA RDI,[RSP + 0x48]
CALL 0x001f6ee0
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV EDI,dword ptr [RAX]
LAB_001bc542:
CALL 0x0015f400
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001bc54e
LAB_001bc54e:
MOV RSI,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x58]
CALL 0x0015ea60
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001bc564
LAB_001bc564:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP],RAX
LEA RDI,[0x3b4030]
CALL 0x001f6ef0
MOV RDI,qword ptr [RSP + 0x8]
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
SUB RAX,RCX
LEA RAX,[0x31c16e]
LEA RSI,[0x31f1ba]
CMOVZ RSI,RAX
CALL 0x0015ea60
JMP 0x001bc5a1
LAB_001bc5a1:
JMP 0x001bc5a3
LAB_001bc5a3:
LEA RDI,[RSP + 0x48]
CALL 0x001f6f30
JMP 0x001bc514
LAB_001bc5cc:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[RSP + 0x58]
CALL 0x0015f4b0
LAB_001bc5db:
JMP 0x001bc5dd
LAB_001bc5dd:
LEA RDI,[RSP + 0x58]
CALL 0x0015f020
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x1d8
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* get_all_kv_cache_types[abi:cxx11]() */
int8 get_all_kv_cache_types_abi_cxx11_(void)
{
bool bVar1;
int4 *puVar2;
char *pcVar3;
ostream *poVar4;
int4 *puVar5;
int8 in_RDI;
int8 local_198;
int8 local_190;
int1 *local_188;
ostringstream local_180 [384];
std::__cxx11::ostringstream::ostringstream(local_180);
local_188 = kv_cache_types;
local_190 = std::vector<ggml_type,std::allocator<ggml_type>>::begin
((vector<ggml_type,std::allocator<ggml_type>> *)kv_cache_types);
local_198 = std::vector<ggml_type,std::allocator<ggml_type>>::end
((vector<ggml_type,std::allocator<ggml_type>> *)kv_cache_types);
while( true ) {
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_190,(__normal_iterator *)&local_198);
if (!bVar1) break;
puVar2 = (int4 *)
__gnu_cxx::
__normal_iterator<ggml_type_const*,std::vector<ggml_type,std::allocator<ggml_type>>>::
operator*((__normal_iterator<ggml_type_const*,std::vector<ggml_type,std::allocator<ggml_type>>>
*)&local_190);
/* try { // try from 001bc542 to 001bc5da has its CatchHandler @ 001bc5b2 */
pcVar3 = (char *)ggml_type_name(*puVar2);
poVar4 = std::operator<<((ostream *)local_180,pcVar3);
puVar5 = (int4 *)
std::vector<ggml_type,std::allocator<ggml_type>>::back
((vector<ggml_type,std::allocator<ggml_type>> *)kv_cache_types);
pcVar3 = ", ";
if (puVar2 == puVar5) {
pcVar3 = "";
}
std::operator<<(poVar4,pcVar3);
__gnu_cxx::__normal_iterator<ggml_type_const*,std::vector<ggml_type,std::allocator<ggml_type>>>
::operator++((__normal_iterator<ggml_type_const*,std::vector<ggml_type,std::allocator<ggml_type>>>
*)&local_190);
}
std::__cxx11::ostringstream::str();
std::__cxx11::ostringstream::~ostringstream(local_180);
return in_RDI;
}
|
|
19,720
|
close_cached_file
|
eloqsql/mysys/mf_cache.c
|
void close_cached_file(IO_CACHE *cache)
{
DBUG_ENTER("close_cached_file");
if (my_b_inited(cache))
{
File file=cache->file;
cache->file= -1; /* Don't flush data */
(void) end_io_cache(cache);
if (file >= 0)
{
(void) my_close(file,MYF(0));
#ifdef CANT_DELETE_OPEN_FILES
if (cache->file_name)
{
(void) my_delete(cache->file_name, MYF(MY_WME));
my_free(cache->file_name);
}
#endif
}
}
DBUG_VOID_RETURN;
}
|
O3
|
c
|
close_cached_file:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0x20(%rdi)
je 0x641d1
movl 0xd4(%rdi), %ebx
movl $0xffffffff, 0xd4(%rdi) # imm = 0xFFFFFFFF
callq 0x50f4f
testl %ebx, %ebx
js 0x641d1
movl %ebx, %edi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5c5f5
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
close_cached_file:
push rbp
mov rbp, rsp
push rbx
push rax
cmp qword ptr [rdi+20h], 0
jz short loc_641D1
mov ebx, [rdi+0D4h]
mov dword ptr [rdi+0D4h], 0FFFFFFFFh
call end_io_cache
test ebx, ebx
js short loc_641D1
mov edi, ebx
xor esi, esi
add rsp, 8
pop rbx
pop rbp
jmp my_close
loc_641D1:
add rsp, 8
pop rbx
pop rbp
retn
|
long long close_cached_file(long long a1)
{
int v1; // ebx
long long result; // rax
if ( *(_QWORD *)(a1 + 32) )
{
v1 = *(_DWORD *)(a1 + 212);
*(_DWORD *)(a1 + 212) = -1;
result = end_io_cache(a1);
if ( v1 >= 0 )
return my_close((unsigned int)v1, 0);
}
return result;
}
|
close_cached_file:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
CMP qword ptr [RDI + 0x20],0x0
JZ 0x001641d1
MOV EBX,dword ptr [RDI + 0xd4]
MOV dword ptr [RDI + 0xd4],0xffffffff
CALL 0x00150f4f
TEST EBX,EBX
JS 0x001641d1
MOV EDI,EBX
XOR ESI,ESI
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0015c5f5
LAB_001641d1:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void close_cached_file(long param_1)
{
int iVar1;
if (*(long *)(param_1 + 0x20) != 0) {
iVar1 = *(int *)(param_1 + 0xd4);
*(int4 *)(param_1 + 0xd4) = 0xffffffff;
end_io_cache();
if (-1 < iVar1) {
my_close(iVar1,0);
return;
}
}
return;
}
|
|
19,721
|
minja::VariableExpr::~VariableExpr()
|
monkey531[P]llama/common/minja.hpp
|
VariableExpr(const Location & location, const std::string& n)
: Expression(location), name(n) {}
|
O1
|
cpp
|
minja::VariableExpr::~VariableExpr():
pushq %rbx
movq %rdi, %rbx
leaq 0x9516f(%rip), %rax # 0x13bdb0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0xa6c60
movq (%rax), %rsi
incq %rsi
callq 0x1b8f0
leaq 0x94741(%rip), %rax # 0x13b3a8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa6c7d
popq %rbx
jmp 0x7ae1c
popq %rbx
retq
nop
|
_ZN5minja12VariableExprD2Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja12VariableExprE; `vtable for'minja::VariableExpr
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+20h]; void *
lea rax, [rbx+30h]
cmp rdi, rax
jz short loc_A6C60
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A6C60:
lea rax, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_A6C7D
pop rbx
jmp _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A6C7D:
pop rbx
retn
|
void minja::VariableExpr::~VariableExpr(minja::VariableExpr *this)
{
char *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::VariableExpr + 2;
v2 = (char *)*((_QWORD *)this + 4);
if ( v2 != (char *)this + 48 )
operator delete(v2, *((_QWORD *)this + 6) + 1LL);
*(_QWORD *)this = &`vtable for'minja::Expression + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
}
|
~VariableExpr:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x23bdb0]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x20]
LEA RAX,[RBX + 0x30]
CMP RDI,RAX
JZ 0x001a6c60
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0011b8f0
LAB_001a6c60:
LEA RAX,[0x23b3a8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x001a6c7d
POP RBX
JMP 0x0017ae1c
LAB_001a6c7d:
POP RBX
RET
|
/* minja::VariableExpr::~VariableExpr() */
void __thiscall minja::VariableExpr::~VariableExpr(VariableExpr *this)
{
*(int ***)this = &PTR_do_evaluate_0023bdc0;
if (*(VariableExpr **)(this + 0x20) != this + 0x30) {
operator_delete(*(VariableExpr **)(this + 0x20),*(long *)(this + 0x30) + 1);
}
*(int ***)this = &PTR___cxa_pure_virtual_0023b3b8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10) !=
(_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 + 0x10));
return;
}
return;
}
|
|
19,722
|
mbr_join_square
|
eloqsql/storage/myisam/rt_split.c
|
static double mbr_join_square(const double *a, const double *b, int n_dim)
{
const double *end = a + n_dim * 2;
double square = 1.0;
do
{
square *=
((a[1] < b[1]) ? b[1] : a[1]) - ((a[0] > b[0]) ? b[0] : a[0]);
a += 2;
b += 2;
}while (a != end);
/* Check if not finite (i.e. infinity or NaN) */
if (!isfinite(square))
square = DBL_MAX;
return square;
}
|
O0
|
c
|
mbr_join_square:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movsd 0x89ff2(%rip), %xmm0 # 0x15f860
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd589b
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0xd58a9
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0xd58d4
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0xd58e1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
subsd %xmm1, %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0xd5873
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0xd5957
movsd 0x89f26(%rip), %xmm0 # 0x15f878
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
popq %rbp
retq
nop
|
mbr_join_square_0:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov ecx, [rbp+var_14]
shl ecx, 1
movsxd rcx, ecx
shl rcx, 3
add rax, rcx
mov [rbp+var_20], rax
movsd xmm0, cs:qword_15F860
movsd [rbp+var_28], xmm0
loc_D5873:
mov rax, [rbp+var_8]
movsd xmm1, qword ptr [rax+8]
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax+8]
ucomisd xmm0, xmm1
jbe short loc_D589B
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax+8]
movsd [rbp+var_30], xmm0
jmp short loc_D58A9
loc_D589B:
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax+8]
movsd [rbp+var_30], xmm0
loc_D58A9:
movsd xmm0, [rbp+var_30]
movsd [rbp+var_38], xmm0
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax]
mov rax, [rbp+var_10]
ucomisd xmm0, qword ptr [rax]
jbe short loc_D58D4
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax]
movsd [rbp+var_40], xmm0
jmp short loc_D58E1
loc_D58D4:
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax]
movsd [rbp+var_40], xmm0
loc_D58E1:
movsd xmm0, [rbp+var_38]
movsd xmm1, [rbp+var_40]
subsd xmm0, xmm1
mulsd xmm0, [rbp+var_28]
movsd [rbp+var_28], xmm0
mov rax, [rbp+var_8]
add rax, 10h
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
add rax, 10h
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
cmp rax, [rbp+var_20]
jnz loc_D5873
movsd xmm0, [rbp+var_28]
movq rax, xmm0
mov rcx, 7FFFFFFFFFFFFFFFh
and rax, rcx
mov rcx, 7FF0000000000000h
sub rax, rcx
setl al
test al, 1
jnz short loc_D5957
movsd xmm0, cs:qword_15F878
movsd [rbp+var_28], xmm0
loc_D5957:
movsd xmm0, [rbp+var_28]
pop rbp
retn
|
double mbr_join_square_0(double *a1, double *a2, int a3)
{
double v4; // [rsp+0h] [rbp-40h]
double v5; // [rsp+10h] [rbp-30h]
double v6; // [rsp+18h] [rbp-28h]
double *v8; // [rsp+38h] [rbp-8h]
v8 = a1;
v6 = 1.0;
do
{
if ( a2[1] <= v8[1] )
v5 = v8[1];
else
v5 = a2[1];
if ( *v8 <= *a2 )
v4 = *v8;
else
v4 = *a2;
v6 = (v5 - v4) * v6;
v8 += 2;
a2 += 2;
}
while ( v8 != &a1[2 * a3] );
if ( (*(_QWORD *)&v6 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
return 1.797693134862316e308;
return v6;
}
|
mbr_join_square:
PUSH RBP
MOV RBP,RSP
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 ECX,dword ptr [RBP + -0x14]
SHL ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOVSD XMM0,qword ptr [0x0025f860]
MOVSD qword ptr [RBP + -0x28],XMM0
LAB_001d5873:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM1,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX + 0x8]
UCOMISD XMM0,XMM1
JBE 0x001d589b
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOVSD qword ptr [RBP + -0x30],XMM0
JMP 0x001d58a9
LAB_001d589b:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOVSD qword ptr [RBP + -0x30],XMM0
LAB_001d58a9:
MOVSD XMM0,qword ptr [RBP + -0x30]
MOVSD qword ptr [RBP + -0x38],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
UCOMISD XMM0,qword ptr [RAX]
JBE 0x001d58d4
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x40],XMM0
JMP 0x001d58e1
LAB_001d58d4:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x40],XMM0
LAB_001d58e1:
MOVSD XMM0,qword ptr [RBP + -0x38]
MOVSD XMM1,qword ptr [RBP + -0x40]
SUBSD XMM0,XMM1
MULSD XMM0,qword ptr [RBP + -0x28]
MOVSD qword ptr [RBP + -0x28],XMM0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x10
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x10
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x001d5873
MOVSD XMM0,qword ptr [RBP + -0x28]
MOVQ RAX,XMM0
MOV RCX,0x7fffffffffffffff
AND RAX,RCX
MOV RCX,0x7ff0000000000000
SUB RAX,RCX
SETL AL
TEST AL,0x1
JNZ 0x001d5957
MOVSD XMM0,qword ptr [0x0025f878]
MOVSD qword ptr [RBP + -0x28],XMM0
LAB_001d5957:
MOVSD XMM0,qword ptr [RBP + -0x28]
POP RBP
RET
|
double mbr_join_square(double *param_1,double *param_2,int param_3)
{
double local_48;
double local_38;
double local_30;
double *local_18;
double *local_10;
local_30 = DAT_0025f860;
local_18 = param_2;
local_10 = param_1;
do {
if (local_18[1] <= local_10[1]) {
local_38 = local_10[1];
}
else {
local_38 = local_18[1];
}
if (*local_10 < *local_18 || *local_10 == *local_18) {
local_48 = *local_10;
}
else {
local_48 = *local_18;
}
local_30 = (local_38 - local_48) * local_30;
local_10 = local_10 + 2;
local_18 = local_18 + 2;
} while (local_10 != param_1 + (param_3 << 1));
if (0x7fefffffffffffff < (ulong)ABS(local_30)) {
local_30 = DAT_0025f878;
}
return local_30;
}
|
|
19,723
|
google::protobuf::RepeatedFieldRef<google::protobuf::Message, void>::RepeatedFieldRef(google::protobuf::Message const&, google::protobuf::FieldDescriptor const*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/reflection.h
|
RepeatedFieldRef(const Message& message, const FieldDescriptor* field) {
const Reflection* reflection = message.GetReflection();
data_ = reflection->RepeatedFieldData(
const_cast<Message*>(&message), field,
internal::RefTypeTraits<T>::cpp_type,
internal::RefTypeTraits<T>::GetMessageFieldDescriptor());
accessor_ = reflection->RepeatedFieldAccessor(field);
default_instance_ =
reflection->GetMessageFactory()->GetPrototype(field->message_type());
}
|
O3
|
c
|
google::protobuf::RepeatedFieldRef<google::protobuf::Message, void>::RepeatedFieldRef(google::protobuf::Message const&, google::protobuf::FieldDescriptor const*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x80(%rax)
movq %rdx, %r12
movq %rdx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0xa, %ecx
xorl %r8d, %r8d
callq 0x95054
movq %rax, (%rbx)
movq %r12, %rdi
movq %r14, %rsi
callq 0x9f5da
movq %rax, 0x8(%rbx)
movq %r12, %rdi
callq 0x9504e
movq %rax, %r15
movq %r14, %rdi
callq 0xc0cee
movq (%r15), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
_ZN6google8protobuf16RepeatedFieldRefINS0_7MessageEvEC2ERKS2_PKNS0_15FieldDescriptorE:
push r15
push r14
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rax, [rsi]
mov rdi, rsi
call qword ptr [rax+80h]
mov r12, rdx
mov rdi, rdx
mov rsi, r15
mov rdx, r14
mov ecx, 0Ah
xor r8d, r8d
call _ZNK6google8protobuf10Reflection17RepeatedFieldDataEPNS0_7MessageEPKNS0_15FieldDescriptorENS4_7CppTypeEPKNS0_10DescriptorE; google::protobuf::Reflection::RepeatedFieldData(google::protobuf::Message *,google::protobuf::FieldDescriptor const*,google::protobuf::FieldDescriptor::CppType,google::protobuf::Descriptor const*)
mov [rbx], rax
mov rdi, r12; this
mov rsi, r14; google::protobuf::FieldDescriptor *
call _ZNK6google8protobuf10Reflection21RepeatedFieldAccessorEPKNS0_15FieldDescriptorE; google::protobuf::Reflection::RepeatedFieldAccessor(google::protobuf::FieldDescriptor const*)
mov [rbx+8], rax
mov rdi, r12; this
call _ZNK6google8protobuf10Reflection17GetMessageFactoryEv; google::protobuf::Reflection::GetMessageFactory(void)
mov r15, rax
mov rdi, r14; this
call _ZNK6google8protobuf15FieldDescriptor12message_typeEv; google::protobuf::FieldDescriptor::message_type(void)
mov rcx, [r15]
mov rdi, r15
mov rsi, rax
call qword ptr [rcx+10h]
mov [rbx+10h], rax
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long google::protobuf::RepeatedFieldRef<google::protobuf::Message,void>::RepeatedFieldRef(
long long *a1,
long long a2,
const google::protobuf::FieldDescriptor *a3)
{
long long v4; // rdx
google::protobuf::Reflection *v5; // r12
long long MessageFactory; // r15
long long v7; // rax
long long result; // rax
(*(void ( **)(long long))(*(_QWORD *)a2 + 128LL))(a2);
v5 = (google::protobuf::Reflection *)v4;
*a1 = google::protobuf::Reflection::RepeatedFieldData(v4, a2, (long long)a3, 10, 0LL);
a1[1] = (long long)google::protobuf::Reflection::RepeatedFieldAccessor(v5, a3);
MessageFactory = google::protobuf::Reflection::GetMessageFactory(v5);
v7 = google::protobuf::FieldDescriptor::message_type(a3);
result = (*(long long ( **)(long long, long long))(*(_QWORD *)MessageFactory + 16LL))(MessageFactory, v7);
a1[2] = result;
return result;
}
|
RepeatedFieldRef:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI]
MOV RDI,RSI
CALL qword ptr [RAX + 0x80]
MOV R12,RDX
MOV RDI,RDX
MOV RSI,R15
MOV RDX,R14
MOV ECX,0xa
XOR R8D,R8D
CALL 0x00195054
MOV qword ptr [RBX],RAX
MOV RDI,R12
MOV RSI,R14
CALL 0x0019f5da
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,R12
CALL 0x0019504e
MOV R15,RAX
MOV RDI,R14
CALL 0x001c0cee
MOV RCX,qword ptr [R15]
MOV RDI,R15
MOV RSI,RAX
CALL qword ptr [RCX + 0x10]
MOV qword ptr [RBX + 0x10],RAX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* google::protobuf::RepeatedFieldRef<google::protobuf::Message,
void>::RepeatedFieldRef(google::protobuf::Message const&, google::protobuf::FieldDescriptor
const*) */
void __thiscall
google::protobuf::RepeatedFieldRef<google::protobuf::Message,void>::RepeatedFieldRef
(RepeatedFieldRef<google::protobuf::Message,void> *this,Message *param_1,
FieldDescriptor *param_2)
{
int8 uVar1;
long *plVar2;
Reflection *this_00;
(**(code **)(*(long *)param_1 + 0x80))(param_1);
uVar1 = Reflection::RepeatedFieldData(this_00,param_1,param_2,10,0);
*(int8 *)this = uVar1;
uVar1 = Reflection::RepeatedFieldAccessor(this_00,param_2);
*(int8 *)(this + 8) = uVar1;
plVar2 = (long *)Reflection::GetMessageFactory(this_00);
uVar1 = FieldDescriptor::message_type(param_2);
uVar1 = (**(code **)(*plVar2 + 0x10))(plVar2,uVar1);
*(int8 *)(this + 0x10) = uVar1;
return;
}
|
|
19,724
|
mysql_stmt_fetch_column
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
int STDCALL mysql_stmt_fetch_column(MYSQL_STMT *stmt, MYSQL_BIND *bind, unsigned int column, unsigned long offset)
{
if (stmt->state < MYSQL_STMT_USER_FETCHING || column >= stmt->field_count ||
stmt->state == MYSQL_STMT_FETCH_DONE) {
SET_CLIENT_STMT_ERROR(stmt, CR_NO_DATA, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (!stmt->bind[column].u.row_ptr)
{
/* we set row_ptr only for columns which contain data, so this must be a NULL column */
if (bind[0].is_null)
*bind[0].is_null= 1;
}
else
{
unsigned char *save_ptr;
if (bind[0].length)
*bind[0].length= *stmt->bind[column].length;
else
bind[0].length= &stmt->bind[column].length_value;
if (bind[0].is_null)
*bind[0].is_null= 0;
else
bind[0].is_null= &bind[0].is_null_value;
if (!bind[0].error)
bind[0].error= &bind[0].error_value;
*bind[0].error= 0;
bind[0].offset= offset;
save_ptr= stmt->bind[column].u.row_ptr;
mysql_ps_fetch_functions[stmt->fields[column].type].func(&bind[0], &stmt->fields[column], &stmt->bind[column].u.row_ptr);
stmt->bind[column].u.row_ptr= save_ptr;
}
return(0);
}
|
O0
|
c
|
mysql_stmt_fetch_column:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, 0x50(%rax)
jb 0x4d997
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jae 0x4d997
movq -0x10(%rbp), %rax
cmpl $0x6, 0x50(%rax)
jne 0x4da0b
jmp 0x4d999
movq -0x10(%rbp), %rax
movl $0x803, 0x108(%rax) # imm = 0x803
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x1e5c77(%rip), %rax # 0x233630
movq (%rax), %rsi
movl $0x5, %edx
callq 0x36140
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x1e5c5d(%rip), %rax # 0x233640
movq 0x198(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x36140
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4db75
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x20(%rax)
jne 0x4da3f
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4da3a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x1, (%rax)
jmp 0x4db6e
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4da6d
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
jmp 0x4da8a
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rcx
movl -0x1c(%rbp), %eax
imulq $0x70, %rax, %rax
addq %rax, %rcx
addq $0x50, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4daa2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
jmp 0x4dab2
movq -0x18(%rbp), %rcx
addq $0x67, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x4dacd
movq -0x18(%rbp), %rcx
addq $0x64, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movl 0x70(%rax), %eax
movl %eax, %ecx
leaq 0x39dcb4(%rip), %rax # 0x3eb7d0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rsi
movl -0x1c(%rbp), %ecx
shlq $0x7, %rcx
addq %rcx, %rsi
movq -0x10(%rbp), %rcx
movq 0x78(%rcx), %rdx
movl -0x1c(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rdx
addq $0x20, %rdx
callq *%rax
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movl -0x1c(%rbp), %edx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
|
mysql_stmt_fetch_column:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 5
jb short loc_4D997
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp eax, [rcx+60h]
jnb short loc_4D997
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 6
jnz short loc_4DA0B
loc_4D997:
jmp short $+2
loc_4D999:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 803h
mov rdi, [rbp+var_10]
add rdi, 30Dh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+312h], 0
mov rdi, [rbp+var_10]
add rdi, 10Ch
lea rax, client_errors
mov rsi, [rax+198h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_4], 1
jmp loc_4DB75
loc_4DA0B:
mov rax, [rbp+var_10]
mov rax, [rax+78h]
mov ecx, [rbp+var_1C]
imul rcx, 70h ; 'p'
add rax, rcx
cmp qword ptr [rax+20h], 0
jnz short loc_4DA3F
mov rax, [rbp+var_18]
cmp qword ptr [rax+8], 0
jz short loc_4DA3A
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov byte ptr [rax], 1
loc_4DA3A:
jmp loc_4DB6E
loc_4DA3F:
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jz short loc_4DA6D
mov rax, [rbp+var_10]
mov rax, [rax+78h]
mov ecx, [rbp+var_1C]
imul rcx, 70h ; 'p'
add rax, rcx
mov rax, [rax]
mov rcx, [rax]
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rax], rcx
jmp short loc_4DA8A
loc_4DA6D:
mov rax, [rbp+var_10]
mov rcx, [rax+78h]
mov eax, [rbp+var_1C]
imul rax, 70h ; 'p'
add rcx, rax
add rcx, 50h ; 'P'
mov rax, [rbp+var_18]
mov [rax], rcx
loc_4DA8A:
mov rax, [rbp+var_18]
cmp qword ptr [rax+8], 0
jz short loc_4DAA2
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov byte ptr [rax], 0
jmp short loc_4DAB2
loc_4DAA2:
mov rcx, [rbp+var_18]
add rcx, 67h ; 'g'
mov rax, [rbp+var_18]
mov [rax+8], rcx
loc_4DAB2:
mov rax, [rbp+var_18]
cmp qword ptr [rax+18h], 0
jnz short loc_4DACD
mov rcx, [rbp+var_18]
add rcx, 64h ; 'd'
mov rax, [rbp+var_18]
mov [rax+18h], rcx
loc_4DACD:
mov rax, [rbp+var_18]
mov rax, [rax+18h]
mov byte ptr [rax], 0
mov rcx, [rbp+var_28]
mov rax, [rbp+var_18]
mov [rax+48h], rcx
mov rax, [rbp+var_10]
mov rax, [rax+78h]
mov ecx, [rbp+var_1C]
imul rcx, 70h ; 'p'
add rax, rcx
mov rax, [rax+20h]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov ecx, [rbp+var_1C]
shl rcx, 7
add rax, rcx
mov eax, [rax+70h]
mov ecx, eax
lea rax, mysql_ps_fetch_functions
imul rcx, 18h
add rax, rcx
mov rax, [rax]
mov rdi, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rsi, [rcx+58h]
mov ecx, [rbp+var_1C]
shl rcx, 7
add rsi, rcx
mov rcx, [rbp+var_10]
mov rdx, [rcx+78h]
mov ecx, [rbp+var_1C]
imul rcx, 70h ; 'p'
add rdx, rcx
add rdx, 20h ; ' '
call rax
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov rax, [rax+78h]
mov edx, [rbp+var_1C]
imul rdx, 70h ; 'p'
add rax, rdx
mov [rax+20h], rcx
loc_4DB6E:
mov [rbp+var_4], 0
loc_4DB75:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long mysql_stmt_fetch_column(long long a1, long long a2, unsigned int a3, long long a4)
{
long long v5; // [rsp+0h] [rbp-30h]
if ( *(_DWORD *)(a1 + 80) < 5u || a3 >= *(_DWORD *)(a1 + 96) || *(_DWORD *)(a1 + 80) == 6 )
{
*(_DWORD *)(a1 + 264) = 2051;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, client_errors[51], 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
else
{
if ( *(_QWORD *)(112LL * a3 + *(_QWORD *)(a1 + 120) + 32) )
{
if ( *(_QWORD *)a2 )
**(_QWORD **)a2 = **(_QWORD **)(112LL * a3 + *(_QWORD *)(a1 + 120));
else
*(_QWORD *)a2 = 112LL * a3 + *(_QWORD *)(a1 + 120) + 80;
if ( *(_QWORD *)(a2 + 8) )
**(_BYTE **)(a2 + 8) = 0;
else
*(_QWORD *)(a2 + 8) = a2 + 103;
if ( !*(_QWORD *)(a2 + 24) )
*(_QWORD *)(a2 + 24) = a2 + 100;
**(_BYTE **)(a2 + 24) = 0;
*(_QWORD *)(a2 + 72) = a4;
v5 = *(_QWORD *)(112LL * a3 + *(_QWORD *)(a1 + 120) + 32);
(*(void ( **)(long long, unsigned long long, long long))&mysql_ps_fetch_functions[6
* *(unsigned int *)(((unsigned long long)a3 << 7) + *(_QWORD *)(a1 + 88) + 112)])(
a2,
((unsigned long long)a3 << 7) + *(_QWORD *)(a1 + 88),
112LL * a3 + *(_QWORD *)(a1 + 120) + 32);
*(_QWORD *)(112LL * a3 + *(_QWORD *)(a1 + 120) + 32) = v5;
}
else if ( *(_QWORD *)(a2 + 8) )
{
**(_BYTE **)(a2 + 8) = 1;
}
return 0;
}
}
|
mysql_stmt_fetch_column:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x5
JC 0x0014d997
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x60]
JNC 0x0014d997
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x6
JNZ 0x0014da0b
LAB_0014d997:
JMP 0x0014d999
LAB_0014d999:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x803
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x333630]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00136140
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x333640]
MOV RSI,qword ptr [RAX + 0x198]
MOV EDX,0x200
CALL 0x00136140
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014db75
LAB_0014da0b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x78]
MOV ECX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0x70
ADD RAX,RCX
CMP qword ptr [RAX + 0x20],0x0
JNZ 0x0014da3f
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x0014da3a
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV byte ptr [RAX],0x1
LAB_0014da3a:
JMP 0x0014db6e
LAB_0014da3f:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX],0x0
JZ 0x0014da6d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x78]
MOV ECX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],RCX
JMP 0x0014da8a
LAB_0014da6d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x78]
MOV EAX,dword ptr [RBP + -0x1c]
IMUL RAX,RAX,0x70
ADD RCX,RAX
ADD RCX,0x50
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
LAB_0014da8a:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x0014daa2
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV byte ptr [RAX],0x0
JMP 0x0014dab2
LAB_0014daa2:
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x67
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x8],RCX
LAB_0014dab2:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x18],0x0
JNZ 0x0014dacd
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x64
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x18],RCX
LAB_0014dacd:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x18]
MOV byte ptr [RAX],0x0
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x48],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x78]
MOV ECX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV ECX,dword ptr [RBP + -0x1c]
SHL RCX,0x7
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x70]
MOV ECX,EAX
LEA RAX,[0x4eb7d0]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX + 0x58]
MOV ECX,dword ptr [RBP + -0x1c]
SHL RCX,0x7
ADD RSI,RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX + 0x78]
MOV ECX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0x70
ADD RDX,RCX
ADD RDX,0x20
CALL RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x78]
MOV EDX,dword ptr [RBP + -0x1c]
IMUL RDX,RDX,0x70
ADD RAX,RDX
MOV qword ptr [RAX + 0x20],RCX
LAB_0014db6e:
MOV dword ptr [RBP + -0x4],0x0
LAB_0014db75:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 mysql_stmt_fetch_column(long param_1,long *param_2,uint param_3,long param_4)
{
int8 uVar1;
int4 local_c;
if (((*(uint *)(param_1 + 0x50) < 5) || (*(uint *)(param_1 + 0x60) <= param_3)) ||
(*(int *)(param_1 + 0x50) == 6)) {
*(int4 *)(param_1 + 0x108) = 0x803;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_DAT_003337d8,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
local_c = 1;
}
else {
if (*(long *)(*(long *)(param_1 + 0x78) + (ulong)param_3 * 0x70 + 0x20) == 0) {
if (param_2[1] != 0) {
*(int1 *)param_2[1] = 1;
}
}
else {
if (*param_2 == 0) {
*param_2 = *(long *)(param_1 + 0x78) + (ulong)param_3 * 0x70 + 0x50;
}
else {
*(int8 *)*param_2 =
**(int8 **)(*(long *)(param_1 + 0x78) + (ulong)param_3 * 0x70);
}
if (param_2[1] == 0) {
param_2[1] = (long)param_2 + 0x67;
}
else {
*(int1 *)param_2[1] = 0;
}
if (param_2[3] == 0) {
param_2[3] = (long)param_2 + 100;
}
*(int1 *)param_2[3] = 0;
param_2[9] = param_4;
uVar1 = *(int8 *)(*(long *)(param_1 + 0x78) + (ulong)param_3 * 0x70 + 0x20);
(*(code *)(&mysql_ps_fetch_functions)
[(ulong)*(uint *)(*(long *)(param_1 + 0x58) + (ulong)param_3 * 0x80 + 0x70) * 3])
(param_2,*(long *)(param_1 + 0x58) + (ulong)param_3 * 0x80,
*(long *)(param_1 + 0x78) + (ulong)param_3 * 0x70 + 0x20);
*(int8 *)(*(long *)(param_1 + 0x78) + (ulong)param_3 * 0x70 + 0x20) = uVar1;
}
local_c = 0;
}
return local_c;
}
|
|
19,725
|
alaya::Worker::Worker(unsigned int, unsigned int, alaya::TaskQueue*, std::atomic<unsigned long>*, std::atomic<unsigned long>*, unsigned int)
|
AlayaLite/include/executor/worker.hpp
|
Worker(WorkerID worker_id, CpuID cpu_id, TaskQueue *task_queue,
std::atomic<size_t> *total_task_cnt, std::atomic<size_t> *total_finish_cnt,
uint32_t local_task_cnt = 4)
: id_(worker_id),
cpu_id_(cpu_id),
task_queue_(task_queue),
local_task_cnt_(local_task_cnt),
local_tasks_(std::vector<std::coroutine_handle<>>(local_task_cnt)),
total_task_cnt_(total_task_cnt),
total_finish_cnt_(total_finish_cnt) {}
|
O0
|
cpp
|
alaya::Worker::Worker(unsigned int, unsigned int, alaya::TaskQueue*, std::atomic<unsigned long>*, std::atomic<unsigned long>*, unsigned int):
subq $0x68, %rsp
movl 0x70(%rsp), %eax
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movl %edx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x73790
movq 0x8(%rsp), %rdi
movl 0x5c(%rsp), %eax
movl %eax, 0x10(%rdi)
movl 0x58(%rsp), %eax
movl %eax, 0x14(%rdi)
movb $0x1, 0x18(%rdi)
addq $0x20, %rdi
movq %rdi, (%rsp)
callq 0x4e600
movq 0x8(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
movl 0x70(%rsp), %eax
movq %rax, 0x18(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x737a0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x737b0
jmp 0x73723
leaq 0x3f(%rsp), %rdi
callq 0x73830
movq 0x8(%rsp), %rax
movl 0x70(%rsp), %ecx
movl %ecx, 0x40(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x50(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x58(%rax)
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x73830
movq (%rsp), %rdi
callq 0x1eb00
movq 0x8(%rsp), %rdi
callq 0x73840
movq 0x30(%rsp), %rdi
callq 0x15dd0
nop
|
_ZN5alaya6WorkerC2EjjPNS_9TaskQueueEPSt6atomicImES5_j:
sub rsp, 68h
mov eax, dword ptr [rsp+68h+arg_0]
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_C], esi
mov [rsp+68h+var_10], edx
mov [rsp+68h+var_18], rcx
mov [rsp+68h+var_20], r8
mov [rsp+68h+var_28], r9
mov rdi, [rsp+68h+var_8]
mov [rsp+68h+var_60], rdi
call _ZNSt23enable_shared_from_thisIN5alaya6WorkerEEC2Ev; std::enable_shared_from_this<alaya::Worker>::enable_shared_from_this(void)
mov rdi, [rsp+68h+var_60]
mov eax, [rsp+68h+var_C]
mov [rdi+10h], eax
mov eax, [rsp+68h+var_10]
mov [rdi+14h], eax
mov byte ptr [rdi+18h], 1
add rdi, 20h ; ' '; this
mov [rsp+68h+var_68], rdi
call _ZNSt6threadC2Ev; std::thread::thread(void)
mov rax, [rsp+68h+var_60]
add rax, 28h ; '('
mov [rsp+68h+var_58], rax
mov eax, dword ptr [rsp+68h+arg_0]
mov [rsp+68h+var_50], rax
lea rdi, [rsp+68h+var_29]
mov [rsp+68h+var_48], rdi
call _ZNSaINSt7__n486116coroutine_handleIvEEEC2Ev; std::allocator<std::__n4861::coroutine_handle<void>>::allocator(void)
mov rdi, [rsp+68h+var_58]
mov rsi, [rsp+68h+var_50]
mov rdx, [rsp+68h+var_48]
call _ZNSt6vectorINSt7__n486116coroutine_handleIvEESaIS2_EEC2EmRKS3_; std::vector<std::__n4861::coroutine_handle<void>>::vector(ulong,std::allocator<std::__n4861::coroutine_handle<void>> const&)
jmp short $+2
loc_73723:
lea rdi, [rsp+68h+var_29]
call _ZNSaINSt7__n486116coroutine_handleIvEEED2Ev; std::allocator<std::__n4861::coroutine_handle<void>>::~allocator()
mov rax, [rsp+68h+var_60]
mov ecx, dword ptr [rsp+68h+arg_0]
mov [rax+40h], ecx
mov rcx, [rsp+68h+var_18]
mov [rax+48h], rcx
mov rcx, [rsp+68h+var_20]
mov [rax+50h], rcx
mov rcx, [rsp+68h+var_28]
mov [rax+58h], rcx
add rsp, 68h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_37]
call _ZNSaINSt7__n486116coroutine_handleIvEEED2Ev; std::allocator<std::__n4861::coroutine_handle<void>>::~allocator()
mov rdi, [rsp+0]; this
call _ZNSt6threadD2Ev; std::thread::~thread()
mov rdi, [rsp+arg_0]
call _ZNSt23enable_shared_from_thisIN5alaya6WorkerEED2Ev; std::enable_shared_from_this<alaya::Worker>::~enable_shared_from_this()
mov rdi, [rsp+arg_28]
call __Unwind_Resume
|
long long alaya::Worker::Worker(long long a1, int a2, int a3, long long a4, long long a5, long long a6, int a7)
{
int v7; // ecx
int v8; // r8d
int v9; // r9d
long long result; // rax
long long v11; // [rsp+8h] [rbp-60h]
char v12; // [rsp+3Fh] [rbp-29h] BYREF
long long v13; // [rsp+40h] [rbp-28h]
long long v14; // [rsp+48h] [rbp-20h]
long long v15; // [rsp+50h] [rbp-18h]
int v16; // [rsp+58h] [rbp-10h]
int v17; // [rsp+5Ch] [rbp-Ch]
long long v18; // [rsp+60h] [rbp-8h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v13 = a6;
std::enable_shared_from_this<alaya::Worker>::enable_shared_from_this();
*(_DWORD *)(a1 + 16) = a2;
*(_DWORD *)(a1 + 20) = v16;
*(_BYTE *)(a1 + 24) = 1;
std::thread::thread((std::thread *)(a1 + 32));
std::allocator<std::__n4861::coroutine_handle<void>>::allocator();
std::vector<std::__n4861::coroutine_handle<void>>::vector(
a1 + 40,
a7,
(unsigned int)&v12,
v7,
v8,
v9,
a1 + 32,
a1,
a1 + 40);
std::allocator<std::__n4861::coroutine_handle<void>>::~allocator(&v12);
result = v11;
*(_DWORD *)(v11 + 64) = a7;
*(_QWORD *)(v11 + 72) = v15;
*(_QWORD *)(v11 + 80) = v14;
*(_QWORD *)(v11 + 88) = v13;
return result;
}
|
Worker:
SUB RSP,0x68
MOV EAX,dword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x60],RDI
MOV dword ptr [RSP + 0x5c],ESI
MOV dword ptr [RSP + 0x58],EDX
MOV qword ptr [RSP + 0x50],RCX
MOV qword ptr [RSP + 0x48],R8
MOV qword ptr [RSP + 0x40],R9
MOV RDI,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00173790
MOV RDI,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0x5c]
MOV dword ptr [RDI + 0x10],EAX
MOV EAX,dword ptr [RSP + 0x58]
MOV dword ptr [RDI + 0x14],EAX
MOV byte ptr [RDI + 0x18],0x1
ADD RDI,0x20
MOV qword ptr [RSP],RDI
CALL 0x0014e600
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x28
MOV qword ptr [RSP + 0x10],RAX
MOV EAX,dword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x18],RAX
LEA RDI,[RSP + 0x3f]
MOV qword ptr [RSP + 0x20],RDI
CALL 0x001737a0
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
LAB_0017371c:
CALL 0x001737b0
LAB_00173721:
JMP 0x00173723
LAB_00173723:
LEA RDI,[RSP + 0x3f]
CALL 0x00173830
MOV RAX,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RSP + 0x70]
MOV dword ptr [RAX + 0x40],ECX
MOV RCX,qword ptr [RSP + 0x50]
MOV qword ptr [RAX + 0x48],RCX
MOV RCX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x50],RCX
MOV RCX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX + 0x58],RCX
ADD RSP,0x68
RET
|
/* alaya::Worker::Worker(unsigned int, unsigned int, alaya::TaskQueue*, std::atomic<unsigned long>*,
std::atomic<unsigned long>*, unsigned int) */
void __thiscall
alaya::Worker::Worker
(Worker *this,uint param_1,uint param_2,TaskQueue *param_3,atomic *param_4,atomic *param_5
,uint param_6)
{
allocator<std::__n4861::coroutine_handle<void>> local_29;
atomic *local_28;
atomic *local_20;
TaskQueue *local_18;
uint local_10;
uint local_c;
Worker *local_8;
local_28 = param_5;
local_20 = param_4;
local_18 = param_3;
local_10 = param_2;
local_c = param_1;
local_8 = this;
std::enable_shared_from_this<alaya::Worker>::enable_shared_from_this
((enable_shared_from_this<alaya::Worker> *)this);
*(uint *)(this + 0x10) = local_c;
*(uint *)(this + 0x14) = local_10;
this[0x18] = (Worker)0x1;
std::thread::thread((thread *)(this + 0x20));
std::allocator<std::__n4861::coroutine_handle<void>>::allocator(&local_29);
/* try { // try from 0017371c to 00173720 has its CatchHandler @ 00173759 */
std::
vector<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>>
::vector((vector<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>>
*)(this + 0x28),(ulong)param_6,(allocator *)&local_29);
std::allocator<std::__n4861::coroutine_handle<void>>::~allocator(&local_29);
*(uint *)(this + 0x40) = param_6;
*(TaskQueue **)(this + 0x48) = local_18;
*(atomic **)(this + 0x50) = local_20;
*(atomic **)(this + 0x58) = local_28;
return;
}
|
|
19,726
|
alaya::Worker::Worker(unsigned int, unsigned int, alaya::TaskQueue*, std::atomic<unsigned long>*, std::atomic<unsigned long>*, unsigned int)
|
AlayaLite/include/executor/worker.hpp
|
Worker(WorkerID worker_id, CpuID cpu_id, TaskQueue *task_queue,
std::atomic<size_t> *total_task_cnt, std::atomic<size_t> *total_finish_cnt,
uint32_t local_task_cnt = 4)
: id_(worker_id),
cpu_id_(cpu_id),
task_queue_(task_queue),
local_task_cnt_(local_task_cnt),
local_tasks_(std::vector<std::coroutine_handle<>>(local_task_cnt)),
total_task_cnt_(total_task_cnt),
total_finish_cnt_(total_finish_cnt) {}
|
O3
|
cpp
|
alaya::Worker::Worker(unsigned int, unsigned int, alaya::TaskQueue*, std::atomic<unsigned long>*, std::atomic<unsigned long>*, unsigned int):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdi, %rbx
movl 0x40(%rsp), %r13d
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl %esi, 0x10(%rdi)
movl %edx, 0x14(%rdi)
movb $0x1, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
addq $0x28, %rdi
leaq 0xf(%rsp), %rdx
movq %r13, %rsi
callq 0x2beda
movl %r13d, 0x40(%rbx)
movq %r12, 0x48(%rbx)
movq %r15, 0x50(%rbx)
movq %r14, 0x58(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpq $0x0, 0x20(%rbx)
jne 0x2bed5
movq %rax, %r14
movq %rbx, %rdi
callq 0x2bf48
movq %r14, %rdi
callq 0x11760
callq 0x11d60
|
_ZN5alaya6WorkerC2EjjPNS_9TaskQueueEPSt6atomicImES5_j:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r14, r9
mov r15, r8
mov r12, rcx
mov rbx, rdi
mov r13d, [rsp+38h+arg_0]
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov [rdi+10h], esi
mov [rdi+14h], edx
mov byte ptr [rdi+18h], 1
mov qword ptr [rdi+20h], 0
add rdi, 28h ; '('
lea rdx, [rsp+38h+var_29]
mov rsi, r13
call _ZNSt6vectorINSt7__n486116coroutine_handleIvEESaIS2_EEC2EmRKS3_; std::vector<std::__n4861::coroutine_handle<void>>::vector(ulong,std::allocator<std::__n4861::coroutine_handle<void>> const&)
mov [rbx+40h], r13d
mov [rbx+48h], r12
mov [rbx+50h], r15
mov [rbx+58h], r14
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
cmp qword ptr [rbx+20h], 0
jnz short loc_2BED5
mov r14, rax
mov rdi, rbx
call _ZNSt23enable_shared_from_thisIN5alaya6WorkerEED2Ev; std::enable_shared_from_this<alaya::Worker>::~enable_shared_from_this()
mov rdi, r14
call __Unwind_Resume
loc_2BED5:
call __ZSt9terminatev; std::terminate(void)
|
long long alaya::Worker::Worker(
long long a1,
int a2,
int a3,
long long a4,
long long a5,
long long a6,
unsigned int a7)
{
long long result; // rax
_BYTE v11[41]; // [rsp+Fh] [rbp-29h] BYREF
*(_OWORD *)a1 = 0LL;
*(_DWORD *)(a1 + 16) = a2;
*(_DWORD *)(a1 + 20) = a3;
*(_BYTE *)(a1 + 24) = 1;
*(_QWORD *)(a1 + 32) = 0LL;
result = std::vector<std::__n4861::coroutine_handle<void>>::vector(a1 + 40, a7, v11);
*(_DWORD *)(a1 + 64) = a7;
*(_QWORD *)(a1 + 72) = a4;
*(_QWORD *)(a1 + 80) = a5;
*(_QWORD *)(a1 + 88) = a6;
return result;
}
|
Worker:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R14,R9
MOV R15,R8
MOV R12,RCX
MOV RBX,RDI
MOV R13D,dword ptr [RSP + 0x40]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV dword ptr [RDI + 0x10],ESI
MOV dword ptr [RDI + 0x14],EDX
MOV byte ptr [RDI + 0x18],0x1
MOV qword ptr [RDI + 0x20],0x0
ADD RDI,0x28
LAB_0012be90:
LEA RDX,[RSP + 0xf]
MOV RSI,R13
CALL 0x0012beda
LAB_0012be9d:
MOV dword ptr [RBX + 0x40],R13D
MOV qword ptr [RBX + 0x48],R12
MOV qword ptr [RBX + 0x50],R15
MOV qword ptr [RBX + 0x58],R14
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* alaya::Worker::Worker(unsigned int, unsigned int, alaya::TaskQueue*, std::atomic<unsigned long>*,
std::atomic<unsigned long>*, unsigned int) */
void __thiscall
alaya::Worker::Worker
(Worker *this,uint param_1,uint param_2,TaskQueue *param_3,atomic *param_4,atomic *param_5
,uint param_6)
{
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(uint *)(this + 0x10) = param_1;
*(uint *)(this + 0x14) = param_2;
this[0x18] = (Worker)0x1;
*(int8 *)(this + 0x20) = 0;
/* try { // try from 0012be90 to 0012be9c has its CatchHandler @ 0012bebb */
std::
vector<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>>
::vector((ulong)(this + 0x28),(allocator *)(ulong)param_6);
*(uint *)(this + 0x40) = param_6;
*(TaskQueue **)(this + 0x48) = param_3;
*(atomic **)(this + 0x50) = param_4;
*(atomic **)(this + 0x58) = param_5;
return;
}
|
|
19,727
|
common_sampler_print[abi:cxx11](common_sampler const*)
|
monkey531[P]llama/common/sampling.cpp
|
std::string common_sampler_print(const struct common_sampler * gsmpl) {
std::string result = "logits ";
for (int i = 0; i < llama_sampler_chain_n(gsmpl->chain); i++) {
const auto * smpl = llama_sampler_chain_get(gsmpl->chain, i);
result += std::string("-> ") + llama_sampler_name(smpl) + " ";
}
return result;
}
|
O2
|
cpp
|
common_sampler_print[abi:cxx11](common_sampler const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
leaq 0x1a1c5(%rip), %rsi # 0xb1c2e
leaq 0x58(%rsp), %r15
movq %rdi, 0x10(%rsp)
movq %r15, %rdx
callq 0x26f76
xorl %ebp, %ebp
leaq 0x18(%rsp), %r13
leaq 0x38(%rsp), %r12
movq 0x140(%r14), %rdi
callq 0x23f80
cmpl %eax, %ebp
jge 0x97b10
movq 0x140(%r14), %rdi
movl %ebp, %esi
callq 0x239e0
movq %rax, %rbx
movq %r13, %rdi
leaq 0x208c2(%rip), %rsi # 0xb8374
leaq 0xf(%rsp), %rdx
callq 0x26f76
movq %rbx, %rdi
callq 0x23360
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x37d98
movq %r15, %rdi
movq %r12, %rsi
leaq 0x1a96e(%rip), %rdx # 0xb244d
callq 0x37d98
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x24140
movq %r15, %rdi
callq 0x241d8
movq %r12, %rdi
callq 0x241d8
movq %r13, %rdi
callq 0x241d8
incl %ebp
jmp 0x97a87
movq 0x10(%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x97b46
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x241d8
jmp 0x97b38
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x241d8
jmp 0x97b4e
jmp 0x97b46
movq %rax, %r14
jmp 0x97b58
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x241d8
movq 0x10(%rsp), %rdi
callq 0x241d8
movq %r14, %rdi
callq 0x23fa0
|
_Z20common_sampler_printB5cxx11PK14common_sampler:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r14, rsi
lea rsi, aLogits+2; "logits "
lea r15, [rsp+0A8h+var_50]
mov [rsp+0A8h+var_98], rdi
mov rdx, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
xor ebp, ebp
lea r13, [rsp+0A8h+var_90]
lea r12, [rsp+0A8h+var_70]
loc_97A87:
mov rdi, [r14+140h]
call _llama_sampler_chain_n
cmp ebp, eax
jge short loc_97B10
mov rdi, [r14+140h]
mov esi, ebp
call _llama_sampler_chain_get
mov rbx, rax
mov rdi, r13
lea rsi, asc_B8374; "-> "
lea rdx, [rsp+0A8h+var_99]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, rbx
call _llama_sampler_name
mov rdi, r12
mov rsi, r13
mov rdx, rax
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov rdi, r15
mov rsi, r12
lea rdx, aForMessageInMe+144h; " "
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov rdi, [rsp+0A8h+var_98]
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_; std::string::append(std::string const&)
mov rdi, r15; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r13; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
inc ebp
jmp loc_97A87
loc_97B10:
mov rax, [rsp+0A8h+var_98]
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_97B46
mov r14, rax
lea rdi, [rsp+arg_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_97B38
mov r14, rax
loc_97B38:
lea rdi, [rsp+arg_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_97B4E
jmp short $+2
loc_97B46:
mov r14, rax
jmp short loc_97B58
mov r14, rax
loc_97B4E:
lea rdi, [rsp+arg_10]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_97B58:
mov rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
|
_QWORD * common_sampler_print[abi:cxx11](_QWORD *a1, long long a2)
{
int i; // ebp
long long v3; // rbx
long long v4; // rax
_QWORD v6[4]; // [rsp+18h] [rbp-90h] BYREF
_BYTE v7[32]; // [rsp+38h] [rbp-70h] BYREF
_BYTE v8[80]; // [rsp+58h] [rbp-50h] BYREF
std::string::basic_string<std::allocator<char>>(a1, (long long)"logits ");
for ( i = 0; i < (int)llama_sampler_chain_n(*(_QWORD *)(a2 + 320)); ++i )
{
v3 = llama_sampler_chain_get(*(_QWORD *)(a2 + 320), (unsigned int)i);
std::string::basic_string<std::allocator<char>>(v6, (long long)"-> ");
v4 = llama_sampler_name(v3);
std::operator+<char>((long long)v7, (long long)v6, v4);
std::operator+<char>((long long)v8, (long long)v7, (long long)" ");
std::string::append(a1, v8);
std::string::~string(v8);
std::string::~string(v7);
std::string::~string(v6);
}
return a1;
}
|
common_sampler_print[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R14,RSI
LEA RSI,[0x1b1c2e]
LEA R15,[RSP + 0x58]
MOV qword ptr [RSP + 0x10],RDI
MOV RDX,R15
CALL 0x00126f76
XOR EBP,EBP
LEA R13,[RSP + 0x18]
LEA R12,[RSP + 0x38]
LAB_00197a87:
MOV RDI,qword ptr [R14 + 0x140]
LAB_00197a8e:
CALL 0x00123f80
CMP EBP,EAX
JGE 0x00197b10
MOV RDI,qword ptr [R14 + 0x140]
LAB_00197a9e:
MOV ESI,EBP
CALL 0x001239e0
LAB_00197aa5:
MOV RBX,RAX
MOV RDI,R13
LEA RSI,[0x1b8374]
LEA RDX,[RSP + 0xf]
CALL 0x00126f76
LAB_00197abc:
MOV RDI,RBX
CALL 0x00123360
MOV RDI,R12
MOV RSI,R13
MOV RDX,RAX
CALL 0x00137d98
LAB_00197ad2:
MOV RDI,R15
MOV RSI,R12
LEA RDX,[0x1b244d]
CALL 0x00137d98
LAB_00197ae4:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,R15
CALL 0x00124140
LAB_00197af1:
MOV RDI,R15
CALL 0x001241d8
MOV RDI,R12
CALL 0x001241d8
MOV RDI,R13
CALL 0x001241d8
INC EBP
JMP 0x00197a87
LAB_00197b10:
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* common_sampler_print[abi:cxx11](common_sampler const*) */
common_sampler * common_sampler_print_abi_cxx11_(common_sampler *param_1)
{
int iVar1;
int8 uVar2;
int iVar3;
long in_RSI;
allocator local_99;
common_sampler *local_98;
string local_90 [32];
string local_70 [32];
string local_50 [32];
local_98 = param_1;
std::__cxx11::string::string<std::allocator<char>>
((string *)param_1,"logits ",(allocator *)local_50);
iVar3 = 0;
while( true ) {
/* try { // try from 00197a8e to 00197a92 has its CatchHandler @ 00197b46 */
iVar1 = llama_sampler_chain_n(*(int8 *)(in_RSI + 0x140));
if (iVar1 <= iVar3) break;
/* try { // try from 00197a9e to 00197aa4 has its CatchHandler @ 00197b24 */
uVar2 = llama_sampler_chain_get(*(int8 *)(in_RSI + 0x140),iVar3);
/* try { // try from 00197aa5 to 00197abb has its CatchHandler @ 00197b44 */
std::__cxx11::string::string<std::allocator<char>>(local_90,"-> ",&local_99);
/* try { // try from 00197abc to 00197ad1 has its CatchHandler @ 00197b4b */
llama_sampler_name(uVar2);
std::operator+(local_70,(char *)local_90);
/* try { // try from 00197ad2 to 00197ae3 has its CatchHandler @ 00197b35 */
std::operator+(local_50,(char *)local_70);
/* try { // try from 00197ae4 to 00197af0 has its CatchHandler @ 00197b26 */
std::__cxx11::string::append((string *)local_98);
std::__cxx11::string::~string(local_50);
std::__cxx11::string::~string(local_70);
std::__cxx11::string::~string(local_90);
iVar3 = iVar3 + 1;
}
return local_98;
}
|
|
19,728
|
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>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
hkr04[P]cpp-mcp/common/json.hpp
|
bool key(string_t& val)
{
BasicJsonType k = BasicJsonType(val);
// check callback for key
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later
if (keep && ref_stack.back())
{
object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
}
return true;
}
|
O1
|
cpp
|
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>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x199f8
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x4, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x18723
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
movl %eax, %ebp
leaq 0x48(%rbx), %rdi
movzbl %al, %esi
callq 0x17e8a
testb %bpl, %bpl
je 0x1870e
movq 0x10(%rbx), %rax
cmpq $0x0, -0x8(%rax)
je 0x1870e
leaq 0xa8(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x7852
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x19a3e
movb (%rax), %cl
leaq 0x20(%rsp), %rdi
movb (%rdi), %dl
movb %dl, (%rax)
movb %cl, (%rdi)
movq 0x8(%rax), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
movq %rax, 0x70(%rbx)
callq 0x7a32
leaq 0x10(%rsp), %rdi
callq 0x7a32
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x5170
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7a32
jmp 0x1873a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7a32
movq %rbx, %rdi
callq 0x5740
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyERSB_:
push rbp
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
lea rdi, [rsp+48h+var_38]
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_
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+48h+var_3C], eax
mov [rsp+48h+var_3D], 4
cmp qword ptr [rbx+90h], 0
jz loc_18723
lea rdi, [rbx+80h]
lea rsi, [rsp+48h+var_3C]
lea rdx, [rsp+48h+var_3D]
lea rcx, [rsp+48h+var_38]
loc_1869F:
call qword ptr [rbx+98h]
mov ebp, eax
lea rdi, [rbx+48h]
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
test bpl, bpl
jz short loc_1870E
mov rax, [rbx+10h]
cmp qword ptr [rax-8], 0
jz short loc_1870E
lea rsi, [rbx+0A8h]
lea rdi, [rsp+48h+var_28]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rdi, [rax+8]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEixERSH_; 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>>>>::operator[](std::string const&)
mov cl, [rax]
lea rdi, [rsp+48h+var_28]
mov dl, [rdi]
mov [rax], dl
mov [rdi], cl
mov rcx, [rax+8]
mov rdx, [rdi+8]
mov [rax+8], rdx
mov [rdi+8], rcx
mov [rbx+70h], rax
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_1870E:
lea rdi, [rsp+48h+var_38]
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 al, 1
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_18723:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov rbx, rax
lea rdi, [rsp+48h+var_28]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_1873A
mov rbx, rax
loc_1873A:
lea rdi, [rsp+48h+var_38]
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
|
char 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>>::key(
long long a1,
long long a2)
{
unsigned __int8 v2; // bp
long long v3; // rax
char v4; // cl
long long v5; // rcx
char v7; // [rsp+Bh] [rbp-3Dh] BYREF
int v8; // [rsp+Ch] [rbp-3Ch] BYREF
_BYTE v9[16]; // [rsp+10h] [rbp-38h] BYREF
_BYTE v10[8]; // [rsp+20h] [rbp-28h] BYREF
long long v11; // [rsp+28h] [rbp-20h]
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(v9);
v8 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v7 = 4;
if ( !*(_QWORD *)(a1 + 144) )
std::__throw_bad_function_call();
v2 = (*(long long ( **)(long long, int *, char *, _BYTE *))(a1 + 152))(a1 + 128, &v8, &v7, v9);
std::vector<bool>::push_back(a1 + 72, v2);
if ( v2 && *(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(long long)v10,
(unsigned __int8 *)(a1 + 168));
v3 = 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>>>>::operator[](
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) + 8LL),
a2);
v4 = *(_BYTE *)v3;
*(_BYTE *)v3 = v10[0];
v10[0] = v4;
v5 = *(_QWORD *)(v3 + 8);
*(_QWORD *)(v3 + 8) = v11;
v11 = v5;
*(_QWORD *)(a1 + 112) = v3;
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(v10);
}
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(v9);
return 1;
}
|
key:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RSP + 0x10]
CALL 0x001199f8
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],0x4
CMP qword ptr [RBX + 0x90],0x0
JZ 0x00118723
LEA RDI,[RBX + 0x80]
LAB_00118690:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
MOV EBP,EAX
LEA RDI,[RBX + 0x48]
MOVZX ESI,AL
CALL 0x00117e8a
TEST BPL,BPL
JZ 0x0011870e
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RAX + -0x8],0x0
JZ 0x0011870e
LEA RSI,[RBX + 0xa8]
LEA RDI,[RSP + 0x20]
CALL 0x00107852
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
LAB_001186e0:
MOV RSI,R14
CALL 0x00119a3e
MOV CL,byte ptr [RAX]
LEA RDI,[RSP + 0x20]
MOV DL,byte ptr [RDI]
MOV byte ptr [RAX],DL
MOV byte ptr [RDI],CL
MOV RCX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RDI + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RDI + 0x8],RCX
MOV qword ptr [RBX + 0x70],RAX
CALL 0x00107a32
LAB_0011870e:
LEA RDI,[RSP + 0x10]
CALL 0x00107a32
MOV AL,0x1
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_00118723:
CALL 0x00105170
LAB_00118728:
MOV RBX,RAX
LEA RDI,[RSP + 0x20]
CALL 0x00107a32
JMP 0x0011873a
LAB_0011873a:
LEA RDI,[RSP + 0x10]
CALL 0x00107a32
MOV RDI,RBX
CALL 0x00105740
|
/* 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> >::key(std::__cxx11::string&) */
int8 __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>>
::key(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)
{
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>
bVar1;
bool bVar2;
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>
*pbVar3;
int8 uVar4;
int1 local_3d;
int4 local_3c;
data local_38 [16];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_28 [8];
int8 local_20;
_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_38);
local_3c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_3d = 4;
if (*(long *)(this + 0x90) != 0) {
/* try { // try from 00118690 to 001186d3 has its CatchHandler @ 00118737 */
bVar2 = (bool)(**(code **)(this + 0x98))(this + 0x80,&local_3c,&local_3d,local_38);
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x48),bVar2);
if ((bVar2 != false) && (*(long *)(*(long *)(this + 0x10) + -8) != 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>
::basic_json(local_28,(basic_json *)(this + 0xa8));
/* try { // try from 001186e0 to 001186e7 has its CatchHandler @ 00118728 */
pbVar3 = (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>
*)ordered_map<std::__cxx11::string,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::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::operator[](*(ordered_map<std::__cxx11::string,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::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(*(long *)(*(long *)(this + 0x10) + -8) + 8),param_1);
bVar1 = *pbVar3;
*pbVar3 = local_28[0];
uVar4 = *(int8 *)(pbVar3 + 8);
*(int8 *)(pbVar3 + 8) = local_20;
*(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) = pbVar3;
local_28[0] = bVar1;
local_20 = uVar4;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_28);
}
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);
return 1;
}
/* try { // try from 00118723 to 00118727 has its CatchHandler @ 00118737 */
uVar4 = std::__throw_bad_function_call();
/* catch() { ... } // from try @ 001186e0 with catch @ 00118728 */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_28);
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);
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar4);
}
|
|
19,729
|
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>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
hkr04[P]cpp-mcp/common/json.hpp
|
bool key(string_t& val)
{
BasicJsonType k = BasicJsonType(val);
// check callback for key
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later
if (keep && ref_stack.back())
{
object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
}
return true;
}
|
O3
|
cpp
|
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>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1935c
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x4, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x18041
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
movl %eax, %ebp
leaq 0x48(%rbx), %rdi
movzbl %al, %esi
callq 0x17792
testb %bpl, %bpl
je 0x1802c
movq 0x10(%rbx), %rax
cmpq $0x0, -0x8(%rax)
je 0x1802c
leaq 0xa8(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x7786
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x193a2
movb (%rax), %cl
leaq 0x20(%rsp), %rdi
movb (%rdi), %dl
movb %dl, (%rax)
movb %cl, (%rdi)
movq 0x8(%rax), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
movq %rax, 0x70(%rbx)
callq 0x795c
leaq 0x10(%rsp), %rdi
callq 0x795c
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x5170
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x795c
jmp 0x18058
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x795c
movq %rbx, %rdi
callq 0x5740
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyERSB_:
push rbp
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
lea rdi, [rsp+48h+var_38]
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_
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+48h+var_3C], eax
mov [rsp+48h+var_3D], 4
cmp qword ptr [rbx+90h], 0
jz loc_18041
lea rdi, [rbx+80h]
lea rsi, [rsp+48h+var_3C]
lea rdx, [rsp+48h+var_3D]
lea rcx, [rsp+48h+var_38]
call qword ptr [rbx+98h]
mov ebp, eax
lea rdi, [rbx+48h]
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
test bpl, bpl
jz short loc_1802C
mov rax, [rbx+10h]
cmp qword ptr [rax-8], 0
jz short loc_1802C
lea rsi, [rbx+0A8h]
lea rdi, [rsp+48h+var_28]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rdi, [rax+8]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEixERSH_; 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>>>>::operator[](std::string const&)
mov cl, [rax]
lea rdi, [rsp+48h+var_28]
mov dl, [rdi]
mov [rax], dl
mov [rdi], cl
mov rcx, [rax+8]
mov rdx, [rdi+8]
mov [rax+8], rdx
mov [rdi+8], rcx
mov [rbx+70h], rax
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_1802C:
lea rdi, [rsp+48h+var_38]
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 al, 1
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_18041:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov rbx, rax
lea rdi, [rsp+48h+var_28]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_18058
mov rbx, rax
loc_18058:
lea rdi, [rsp+48h+var_38]
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
|
char 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>>::key(
long long a1,
long long a2)
{
unsigned __int8 v2; // bp
long long v3; // rax
char v4; // cl
long long v5; // rcx
char v7; // [rsp+Bh] [rbp-3Dh] BYREF
int v8; // [rsp+Ch] [rbp-3Ch] BYREF
_BYTE v9[16]; // [rsp+10h] [rbp-38h] BYREF
_BYTE v10[8]; // [rsp+20h] [rbp-28h] BYREF
long long v11; // [rsp+28h] [rbp-20h]
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(v9);
v8 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v7 = 4;
if ( !*(_QWORD *)(a1 + 144) )
std::__throw_bad_function_call();
v2 = (*(long long ( **)(long long, int *, char *, _BYTE *))(a1 + 152))(a1 + 128, &v8, &v7, v9);
std::vector<bool>::push_back(a1 + 72, v2);
if ( v2 && *(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(long long)v10,
(unsigned __int8 *)(a1 + 168));
v3 = 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>>>>::operator[](
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) + 8LL),
a2);
v4 = *(_BYTE *)v3;
*(_BYTE *)v3 = v10[0];
v10[0] = v4;
v5 = *(_QWORD *)(v3 + 8);
*(_QWORD *)(v3 + 8) = v11;
v11 = v5;
*(_QWORD *)(a1 + 112) = v3;
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(v10);
}
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(v9);
return 1;
}
|
key:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RSP + 0x10]
CALL 0x0011935c
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],0x4
CMP qword ptr [RBX + 0x90],0x0
JZ 0x00118041
LEA RDI,[RBX + 0x80]
LAB_00117fae:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
MOV EBP,EAX
LEA RDI,[RBX + 0x48]
MOVZX ESI,AL
CALL 0x00117792
TEST BPL,BPL
JZ 0x0011802c
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RAX + -0x8],0x0
JZ 0x0011802c
LEA RSI,[RBX + 0xa8]
LEA RDI,[RSP + 0x20]
CALL 0x00107786
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
LAB_00117ffe:
MOV RSI,R14
CALL 0x001193a2
MOV CL,byte ptr [RAX]
LEA RDI,[RSP + 0x20]
MOV DL,byte ptr [RDI]
MOV byte ptr [RAX],DL
MOV byte ptr [RDI],CL
MOV RCX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RDI + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RDI + 0x8],RCX
MOV qword ptr [RBX + 0x70],RAX
CALL 0x0010795c
LAB_0011802c:
LEA RDI,[RSP + 0x10]
CALL 0x0010795c
MOV AL,0x1
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_00118041:
CALL 0x00105170
LAB_00118046:
MOV RBX,RAX
LEA RDI,[RSP + 0x20]
CALL 0x0010795c
JMP 0x00118058
LAB_00118058:
LEA RDI,[RSP + 0x10]
CALL 0x0010795c
MOV RDI,RBX
CALL 0x00105740
|
/* 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> >::key(std::__cxx11::string&) */
int8 __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>>
::key(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)
{
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>
bVar1;
bool bVar2;
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>
*pbVar3;
int8 uVar4;
int1 local_3d;
int4 local_3c;
data local_38 [16];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_28 [8];
int8 local_20;
_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_38);
local_3c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_3d = 4;
if (*(long *)(this + 0x90) != 0) {
/* try { // try from 00117fae to 00117ff1 has its CatchHandler @ 00118055 */
bVar2 = (bool)(**(code **)(this + 0x98))(this + 0x80,&local_3c,&local_3d,local_38);
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x48),bVar2);
if ((bVar2 != false) && (*(long *)(*(long *)(this + 0x10) + -8) != 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>
::basic_json(local_28,(basic_json *)(this + 0xa8));
/* try { // try from 00117ffe to 00118005 has its CatchHandler @ 00118046 */
pbVar3 = (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>
*)ordered_map<std::__cxx11::string,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::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::operator[](*(ordered_map<std::__cxx11::string,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::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(*(long *)(*(long *)(this + 0x10) + -8) + 8),param_1);
bVar1 = *pbVar3;
*pbVar3 = local_28[0];
uVar4 = *(int8 *)(pbVar3 + 8);
*(int8 *)(pbVar3 + 8) = local_20;
*(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) = pbVar3;
local_28[0] = bVar1;
local_20 = uVar4;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_28);
}
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);
return 1;
}
/* try { // try from 00118041 to 00118045 has its CatchHandler @ 00118055 */
uVar4 = std::__throw_bad_function_call();
/* catch() { ... } // from try @ 00117ffe with catch @ 00118046 */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_28);
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);
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar4);
}
|
|
19,730
|
decltype(auto) coro::sync_wait<coro::detail::when_all_ready_awaitable<std::tuple<coro::detail::when_all_task<double&&>, coro::detail::when_all_task<unsigned long&&>>>, std::tuple<coro::detail::when_all_task<double&&>, coro::detail::when_all_task<unsigned long&&>>&&>(coro::detail::when_all_ready_awaitable<std::tuple<coro::detail::when_all_task<double&&>, coro::detail::when_all_task<unsigned long&&>>>&&)
|
AlayaLite/build_O3/_deps/libcoro-src/include/coro/sync_wait.hpp
|
auto sync_wait(awaitable_type&& a) -> decltype(auto)
{
detail::sync_wait_event e{};
auto task = detail::make_sync_wait_task(std::forward<awaitable_type>(a));
task.promise().start(e);
e.wait();
if constexpr (std::is_void_v<return_type>)
{
task.promise().result();
return;
}
else if constexpr (std::is_reference_v<return_type>)
{
return task.promise().result();
}
else if constexpr (std::is_move_assignable_v<return_type>)
{
// issue-242
// For non-trivial types (or possibly types that don't fit in a register)
// the compiler will end up calling the ~return_type() when the promise
// is destructed at the end of sync_wait(). This causes the return_type
// object to also be destructed causing the final return/move from
// sync_wait() to be a 'use after free' bug. To work around this the result
// must be moved off the promise object before the promise is destructed.
// Other solutions could be heap allocating the return_type but that has
// other downsides, for now it is determined that a double move is an
// acceptable solution to work around this bug.
auto result = std::move(task).promise().result();
return result;
}
else
{
return task.promise().result();
}
}
|
O3
|
cpp
|
decltype(auto) coro::sync_wait<coro::detail::when_all_ready_awaitable<std::tuple<coro::detail::when_all_task<double&&>, coro::detail::when_all_task<unsigned long&&>>>, std::tuple<coro::detail::when_all_task<double&&>, coro::detail::when_all_task<unsigned long&&>>&&>(coro::detail::when_all_ready_awaitable<std::tuple<coro::detail::when_all_task<double&&>, coro::detail::when_all_task<unsigned long&&>>>&&):
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x40cc
leaq -0x3b9(%rip), %rax # 0x2e53
leaq 0x70(%rsp), %rbx
movq %rax, -0x10(%rbx)
leaq -0x30e(%rip), %rax # 0x2f0e
movq %rax, -0x8(%rbx)
movq %r14, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movb $0x0, 0x38(%rbx)
movq %r15, (%rbx)
leaq 0x60(%rsp), %rdi
callq 0x2e53
movq %rsp, %rdi
callq 0x4150
movq %rbx, %rdi
callq 0x3780
movq %rax, %r14
movq %rbx, %rdi
callq 0x3820
leaq 0x28(%rsp), %rdi
callq 0x2280
movq %r14, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3820
leaq 0x28(%rsp), %rdi
callq 0x2280
movq %r14, %rdi
callq 0x2270
|
_ZN4coro9sync_waitITkNS_8concepts9awaitableENS_6detail24when_all_ready_awaitableISt5tupleIJNS2_13when_all_taskIOdEENS5_IOmEEEEEEOSA_EEDcOT_:
push r15
push r14
push rbx
sub rsp, 0B0h
mov r14, rdi
mov r15, rsp
mov rdi, r15; this
xor esi, esi; bool
call _ZN4coro6detail15sync_wait_eventC2Eb; coro::detail::sync_wait_event::sync_wait_event(bool)
lea rax, _ZN4coro6detailL19make_sync_wait_taskITkNS_8concepts9awaitableENS0_24when_all_ready_awaitableISt5tupleIJNS0_13when_all_taskIOdEENS5_IOmEEEEEEOSA_EENS0_14sync_wait_taskIT0_EEOT__resume
lea rbx, [rsp+0C8h+var_58]
mov [rbx-10h], rax
lea rax, _ZN4coro6detailL19make_sync_wait_taskITkNS_8concepts9awaitableENS0_24when_all_ready_awaitableISt5tupleIJNS0_13when_all_taskIOdEENS5_IOmEEEEEEOSA_EENS0_14sync_wait_taskIT0_EEOT__cleanup
mov [rbx-8], rax
mov [rbx+30h], r14
xorps xmm0, xmm0
movups xmmword ptr [rbx+8], xmm0
mov qword ptr [rbx+18h], 0
mov byte ptr [rbx+38h], 0
mov [rbx], r15
lea rdi, [rsp+0C8h+var_68]
call _ZN4coro6detailL19make_sync_wait_taskITkNS_8concepts9awaitableENS0_24when_all_ready_awaitableISt5tupleIJNS0_13when_all_taskIOdEENS5_IOmEEEEEEOSA_EENS0_14sync_wait_taskIT0_EEOT__resume
mov rdi, rsp; this
call _ZN4coro6detail15sync_wait_event4waitEv; coro::detail::sync_wait_event::wait(void)
mov rdi, rbx
call _ZNR4coro6detail22sync_wait_task_promiseIOSt5tupleIJNS0_13when_all_taskIOdEENS3_IOmEEEEE6resultEv; coro::detail::sync_wait_task_promise<std::tuple<coro::detail::when_all_task<double &&>,coro::detail::when_all_task<ulong &&>> &&>::result(void)
mov r14, rax
mov rdi, rbx
call _ZN4coro6detail22sync_wait_task_promiseIOSt5tupleIJNS0_13when_all_taskIOdEENS3_IOmEEEEED2Ev; coro::detail::sync_wait_task_promise<std::tuple<coro::detail::when_all_task<double &&>,coro::detail::when_all_task<ulong &&>> &&>::~sync_wait_task_promise()
lea rdi, [rsp+0C8h+var_A0]; this
call __ZNSt18condition_variableD1Ev; std::condition_variable::~condition_variable()
mov rax, r14
add rsp, 0B0h
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, rbx
call _ZN4coro6detail22sync_wait_task_promiseIOSt5tupleIJNS0_13when_all_taskIOdEENS3_IOmEEEEED2Ev; coro::detail::sync_wait_task_promise<std::tuple<coro::detail::when_all_task<double &&>,coro::detail::when_all_task<ulong &&>> &&>::~sync_wait_task_promise()
lea rdi, [rsp+arg_20]; this
call __ZNSt18condition_variableD1Ev; std::condition_variable::~condition_variable()
mov rdi, r14
call __Unwind_Resume
|
long long ZN4coro9sync_waitITkNS_8concepts9awaitableENS_6detail24when_all_ready_awaitableISt5tupleIJNS2_13when_all_taskIOdEENS5_IOmEEEEEEOSA_EEDcOT_(
long long a1)
{
long long v1; // r14
_BYTE v3[40]; // [rsp+0h] [rbp-C8h] BYREF
_BYTE v4[56]; // [rsp+28h] [rbp-A0h] BYREF
_QWORD v5[2]; // [rsp+60h] [rbp-68h] BYREF
_BYTE *v6; // [rsp+70h] [rbp-58h] BYREF
__int128 v7; // [rsp+78h] [rbp-50h]
long long v8; // [rsp+88h] [rbp-40h]
long long v9; // [rsp+A0h] [rbp-28h]
char v10; // [rsp+A8h] [rbp-20h]
coro::detail::sync_wait_event::sync_wait_event((coro::detail::sync_wait_event *)v3, 0);
v5[0] = ZN4coro6detailL19make_sync_wait_taskITkNS_8concepts9awaitableENS0_24when_all_ready_awaitableISt5tupleIJNS0_13when_all_taskIOdEENS5_IOmEEEEEEOSA_EENS0_14sync_wait_taskIT0_EEOT__resume;
v5[1] = ZN4coro6detailL19make_sync_wait_taskITkNS_8concepts9awaitableENS0_24when_all_ready_awaitableISt5tupleIJNS0_13when_all_taskIOdEENS5_IOmEEEEEEOSA_EENS0_14sync_wait_taskIT0_EEOT__cleanup;
v9 = a1;
v7 = 0LL;
v8 = 0LL;
v10 = 0;
v6 = v3;
ZN4coro6detailL19make_sync_wait_taskITkNS_8concepts9awaitableENS0_24when_all_ready_awaitableISt5tupleIJNS0_13when_all_taskIOdEENS5_IOmEEEEEEOSA_EENS0_14sync_wait_taskIT0_EEOT__resume((long long)v5);
coro::detail::sync_wait_event::wait((coro::detail::sync_wait_event *)v3);
v1 = coro::detail::sync_wait_task_promise<std::tuple<coro::detail::when_all_task<double &&>,coro::detail::when_all_task<unsigned long &&>> &&>::result(&v6);
coro::detail::sync_wait_task_promise<std::tuple<coro::detail::when_all_task<double &&>,coro::detail::when_all_task<unsigned long &&>> &&>::~sync_wait_task_promise(&v6);
std::condition_variable::~condition_variable((std::condition_variable *)v4);
return v1;
}
|
_ZN4coro9sync_waitITkNS_8concepts9awaitableENS_6detail24when_all_ready_awaitableISt5tupleIJNS2_13when_all_taskIOdEENS5_IOmEEEEEEOSA_EEDcOT_:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xb0
MOV R14,RDI
MOV R15,RSP
MOV RDI,R15
XOR ESI,ESI
CALL 0x001040cc
LEA RAX,[0x102e53]
LEA RBX,[RSP + 0x70]
MOV qword ptr [RBX + -0x10],RAX
LEA RAX,[0x102f0e]
MOV qword ptr [RBX + -0x8],RAX
MOV qword ptr [RBX + 0x30],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x8],XMM0
MOV qword ptr [RBX + 0x18],0x0
MOV byte ptr [RBX + 0x38],0x0
MOV qword ptr [RBX],R15
LAB_0010323a:
LEA RDI,[RSP + 0x60]
CALL 0x00102e53
MOV RDI,RSP
CALL 0x00104150
MOV RDI,RBX
CALL 0x00103780
LAB_00103254:
MOV R14,RAX
MOV RDI,RBX
CALL 0x00103820
LEA RDI,[RSP + 0x28]
CALL 0x00102280
MOV RAX,R14
ADD RSP,0xb0
POP RBX
POP R14
POP R15
RET
|
int8
_ZN4coro9sync_waitITkNS_8concepts9awaitableENS_6detail24when_all_ready_awaitableISt5tupleIJNS2_13when_all_taskIOdEENS5_IOmEEEEEEOSA_EEDcOT_
(int8 param_1)
{
int8 uVar1;
sync_wait_event asStack_c8 [40];
condition_variable local_a0 [56];
code *local_68;
code *local_60;
int1 *local_58;
int8 local_50;
int8 uStack_48;
int8 local_40;
int8 local_28;
int1 local_20;
coro::detail::sync_wait_event::sync_wait_event(asStack_c8,false);
local_68 =
_ZN4coro6detailL19make_sync_wait_taskITkNS_8concepts9awaitableENS0_24when_all_ready_awaitableISt5tupleIJNS0_13when_all_taskIOdEENS5_IOmEEEEEEOSA_EENS0_14sync_wait_taskIT0_EEOT__resume
;
local_60 =
_ZN4coro6detailL19make_sync_wait_taskITkNS_8concepts9awaitableENS0_24when_all_ready_awaitableISt5tupleIJNS0_13when_all_taskIOdEENS5_IOmEEEEEEOSA_EENS0_14sync_wait_taskIT0_EEOT__cleanup
;
local_50 = 0;
uStack_48 = 0;
local_40 = 0;
local_20 = 0;
/* try { // try from 0010323a to 00103253 has its CatchHandler @ 00103279 */
local_58 = asStack_c8;
local_28 = param_1;
_ZN4coro6detailL19make_sync_wait_taskITkNS_8concepts9awaitableENS0_24when_all_ready_awaitableISt5tupleIJNS0_13when_all_taskIOdEENS5_IOmEEEEEEOSA_EENS0_14sync_wait_taskIT0_EEOT__resume
(&local_68);
coro::detail::sync_wait_event::wait(asStack_c8);
uVar1 = coro::detail::
sync_wait_task_promise<std::tuple<coro::detail::when_all_task<double&&>,coro::detail::when_all_task<unsigned_long&&>>&&>
::result((sync_wait_task_promise<std::tuple<coro::detail::when_all_task<double&&>,coro::detail::when_all_task<unsigned_long&&>>&&>
*)&local_58);
coro::detail::
sync_wait_task_promise<std::tuple<coro::detail::when_all_task<double&&>,coro::detail::when_all_task<unsigned_long&&>>&&>
::~sync_wait_task_promise
((sync_wait_task_promise<std::tuple<coro::detail::when_all_task<double&&>,coro::detail::when_all_task<unsigned_long&&>>&&>
*)&local_58);
std::condition_variable::~condition_variable(local_a0);
return uVar1;
}
|
|
19,731
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>)
|
monkey531[P]llama/common/json.hpp
|
basic_json& operator=(basic_json other) noexcept (
std::is_nothrow_move_constructible<value_t>::value&&
std::is_nothrow_move_assignable<value_t>::value&&
std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value&&
std::is_nothrow_move_assignable<json_base_class_t>::value
)
{
// check that passed value is valid
other.assert_invariant();
using std::swap;
swap(m_data.m_type, other.m_data.m_type);
swap(m_data.m_value, other.m_data.m_value);
json_base_class_t::operator=(std::move(other));
set_parents();
assert_invariant();
return *this;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x3ecbc
movb (%r14), %al
movb (%rbx), %cl
movb %cl, (%r14)
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x3ecbc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rdi, rsi
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 al, [r14]
mov cl, [rbx]
mov [r14], cl
mov [rbx], al
mov rax, [r14+8]
mov rcx, [rbx+8]
mov [r14+8], rcx
mov [rbx+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
|
char * 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 *a2)
{
char v2; // al
long long v3; // rax
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(
a2,
1LL);
v2 = *a1;
*a1 = *a2;
*a2 = v2;
v3 = *((_QWORD *)a1 + 1);
*((_QWORD *)a1 + 1) = *((_QWORD *)a2 + 1);
*((_QWORD *)a2 + 1) = v3;
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(
a1,
1LL);
return a1;
}
|
operator=:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,RSI
MOV ESI,0x1
CALL 0x0013ecbc
MOV AL,byte ptr [R14]
MOV CL,byte ptr [RBX]
MOV byte ptr [R14],CL
MOV byte ptr [RBX],AL
MOV RAX,qword ptr [R14 + 0x8]
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [R14 + 0x8],RCX
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013ecbc
MOV RAX,R14
ADD RSP,0x8
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>::TEMPNAMEPLACEHOLDERVALUE(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>) */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
* __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::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,basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_2)
{
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>
bVar1;
int8 uVar2;
assert_invariant(SUB81(param_2,0));
bVar1 = *this;
*this = *param_2;
*param_2 = bVar1;
uVar2 = *(int8 *)(this + 8);
*(int8 *)(this + 8) = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = uVar2;
assert_invariant(SUB81(this,0));
return this;
}
|
|
19,732
|
my_uni_ucs2
|
eloqsql/strings/ctype-ucs2.c
|
static int my_uni_ucs2(CHARSET_INFO *cs __attribute__((unused)) ,
my_wc_t wc, uchar *r, uchar *e)
{
if ( r+2 > e )
return MY_CS_TOOSMALL2;
if (wc > 0xFFFF) /* UCS2 does not support characters outside BMP */
return MY_CS_ILUNI;
r[0]= (uchar) (wc >> 8);
r[1]= (uchar) (wc & 0xFF);
return 2;
}
|
O0
|
c
|
my_uni_ucs2:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x6c6bb
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x6c6f8
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
jbe 0x6c6ce
movl $0x0, -0x4(%rbp)
jmp 0x6c6f8
movq -0x18(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
|
my_uni_ucs2:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_6C6BB
mov [rbp+var_4], 0FFFFFF9Ah
jmp short loc_6C6F8
loc_6C6BB:
cmp [rbp+var_18], 0FFFFh
jbe short loc_6C6CE
mov [rbp+var_4], 0
jmp short loc_6C6F8
loc_6C6CE:
mov rax, [rbp+var_18]
shr rax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov rax, [rbp+var_18]
and rax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
loc_6C6F8:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_uni_ucs2(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
if ( a2 <= 0xFFFF )
{
*a3 = BYTE1(a2);
a3[1] = a2;
return 2;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-102;
}
}
|
my_uni_ucs2:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0016c6bb
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0016c6f8
LAB_0016c6bb:
CMP qword ptr [RBP + -0x18],0xffff
JBE 0x0016c6ce
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016c6f8
LAB_0016c6ce:
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
LAB_0016c6f8:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_uni_ucs2(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
int4 local_c;
if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else if (param_2 < 0x10000) {
*param_3 = (char)(param_2 >> 8);
param_3[1] = (char)param_2;
local_c = 2;
}
else {
local_c = 0;
}
return local_c;
}
|
|
19,733
|
CacheHierarchy::CacheHierarchy()
|
DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MainMulCache.cpp
|
CacheHierarchy() {
memory = new MemoryManager();
auto l1policy = MultiLevelCacheConfig::getL1Policy();
auto l2policy = MultiLevelCacheConfig::getL2Policy();
auto l3policy = MultiLevelCacheConfig::getL3Policy();
l3cache = new Cache(memory, l3policy, nullptr);
l2cache = new Cache(memory, l2policy, l3cache);
l1cache = new Cache(memory, l1policy, l2cache);
memory->setCache(l1cache);
}
|
O3
|
cpp
|
CacheHierarchy::CacheHierarchy():
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movl $0x2008, %edi # imm = 0x2008
callq 0x21c0
movq %rax, %r14
movq %rax, %rdi
callq 0x2d20
movq %r14, (%rbx)
movl $0x68, %edi
callq 0x21c0
movq %rax, %r15
movaps 0x27d1(%rip), %xmm0 # 0x5010
movaps %xmm0, 0x60(%rsp)
movabsq $0x6400000014, %rax # imm = 0x6400000014
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3644
movq %r15, 0x18(%rbx)
movl $0x68, %edi
callq 0x21c0
movq %rax, %r14
movq (%rbx), %rsi
movaps 0x2792(%rip), %xmm0 # 0x5020
movaps %xmm0, 0x40(%rsp)
movabsq $0x1400000008, %rax # imm = 0x1400000008
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rdx
callq 0x3644
movq %r14, 0x10(%rbx)
movl $0x68, %edi
callq 0x21c0
movq %rax, %r15
movq (%rbx), %rsi
movaps 0x2755(%rip), %xmm0 # 0x5030
movaps %xmm0, 0x20(%rsp)
movabsq $0x800000001, %rax # imm = 0x800000001
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rdx
callq 0x3644
movq %r15, 0x8(%rbx)
movq (%rbx), %rdi
movq %r15, %rsi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x363a
jmp 0x292c
jmp 0x2934
movq %rax, %rbx
movq %r15, %r14
jmp 0x2937
movq %rax, %rbx
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22d0
nop
|
_ZN14CacheHierarchyC2Ev:
push r15
push r14
push rbx
sub rsp, 80h
mov rbx, rdi
mov edi, 2008h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rdi, rax; this
call _ZN13MemoryManagerC2Ev; MemoryManager::MemoryManager(void)
mov [rbx], r14
mov edi, 68h ; 'h'; unsigned __int64
call __Znwm; operator new(ulong)
mov r15, rax
movaps xmm0, cs:xmmword_5010
movaps [rsp+98h+var_38], xmm0
mov rax, 6400000014h
mov [rsp+98h+var_28], rax
mov rax, [rsp+98h+var_28]
mov [rsp+98h+var_88], rax; __int64
movaps xmm0, [rsp+98h+var_38]
movups [rsp+98h+var_98], xmm0; __int128
mov rdi, r15; this
mov rsi, r14
xor edx, edx
call _ZN5CacheC2EP13MemoryManagerNS_6PolicyEPS_; Cache::Cache(MemoryManager *,Cache::Policy,Cache*)
mov [rbx+18h], r15
mov edi, 68h ; 'h'; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rsi, [rbx]
movaps xmm0, cs:xmmword_5020
movaps [rsp+98h+var_58], xmm0
mov rax, 1400000008h
mov [rsp+98h+var_48], rax
mov rax, [rsp+98h+var_48]
mov [rsp+98h+var_88], rax; __int64
movaps xmm0, [rsp+98h+var_58]
movups [rsp+98h+var_98], xmm0; __int128
mov rdi, r14; this
mov rdx, r15
call _ZN5CacheC2EP13MemoryManagerNS_6PolicyEPS_; Cache::Cache(MemoryManager *,Cache::Policy,Cache*)
mov [rbx+10h], r14
mov edi, 68h ; 'h'; unsigned __int64
call __Znwm; operator new(ulong)
mov r15, rax
mov rsi, [rbx]
movaps xmm0, cs:xmmword_5030
movaps [rsp+98h+var_78], xmm0
mov rax, 800000001h
mov [rsp+98h+var_68], rax
mov rax, [rsp+98h+var_68]
mov [rsp+98h+var_88], rax; __int64
movaps xmm0, [rsp+98h+var_78]
movups [rsp+98h+var_98], xmm0; __int128
mov rdi, r15; this
mov rdx, r14
call _ZN5CacheC2EP13MemoryManagerNS_6PolicyEPS_; Cache::Cache(MemoryManager *,Cache::Policy,Cache*)
mov [rbx+8], r15
mov rdi, [rbx]
mov rsi, r15
add rsp, 80h
pop rbx
pop r14
pop r15
jmp _ZN13MemoryManager8setCacheEP5Cache; MemoryManager::setCache(Cache *)
jmp short loc_292C
jmp short loc_2934
loc_292C:
mov rbx, rax
mov r14, r15
jmp short loc_2937
loc_2934:
mov rbx, rax
loc_2937:
mov rdi, r14; void *
call __ZdlPv; operator delete(void *)
mov rdi, rbx
call __Unwind_Resume
|
void CacheHierarchy::CacheHierarchy(CacheHierarchy *this)
{
MemoryManager *v1; // r14
Cache *v2; // r15
Cache *v3; // r14
Cache *v4; // r15
v1 = (MemoryManager *)operator new(0x2008uLL);
MemoryManager::MemoryManager(v1);
*(_QWORD *)this = v1;
v2 = (Cache *)operator new(0x68uLL);
Cache::Cache(v2, xmmword_5010, 0x6400000014LL);
*((_QWORD *)this + 3) = v2;
v3 = (Cache *)operator new(0x68uLL);
Cache::Cache(v3, xmmword_5020, 0x1400000008LL);
*((_QWORD *)this + 2) = v3;
v4 = (Cache *)operator new(0x68uLL);
Cache::Cache(v4, xmmword_5030, 0x800000001LL);
*((_QWORD *)this + 1) = v4;
MemoryManager::setCache(*(MemoryManager **)this, v4);
}
|
CacheHierarchy:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x80
MOV RBX,RDI
MOV EDI,0x2008
CALL 0x001021c0
MOV R14,RAX
LAB_00102820:
MOV RDI,RAX
CALL 0x00102d20
LAB_00102828:
MOV qword ptr [RBX],R14
MOV EDI,0x68
CALL 0x001021c0
MOV R15,RAX
MOVAPS XMM0,xmmword ptr [0x00105010]
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOV RAX,0x6400000014
MOV qword ptr [RSP + 0x70],RAX
LAB_00102853:
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x10],RAX
MOVAPS XMM0,xmmword ptr [RSP + 0x60]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R15
MOV RSI,R14
XOR EDX,EDX
CALL 0x00103644
LAB_00102873:
MOV qword ptr [RBX + 0x18],R15
MOV EDI,0x68
CALL 0x001021c0
MOV R14,RAX
MOV RSI,qword ptr [RBX]
MOVAPS XMM0,xmmword ptr [0x00105020]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOV RAX,0x1400000008
MOV qword ptr [RSP + 0x50],RAX
LAB_001028a2:
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x10],RAX
MOVAPS XMM0,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R14
MOV RDX,R15
CALL 0x00103644
LAB_001028c0:
MOV qword ptr [RBX + 0x10],R14
MOV EDI,0x68
CALL 0x001021c0
MOV R15,RAX
MOV RSI,qword ptr [RBX]
MOVAPS XMM0,xmmword ptr [0x00105030]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV RAX,0x800000001
MOV qword ptr [RSP + 0x30],RAX
LAB_001028ef:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R15
MOV RDX,R14
CALL 0x00103644
LAB_0010290d:
MOV qword ptr [RBX + 0x8],R15
MOV RDI,qword ptr [RBX]
MOV RSI,R15
ADD RSP,0x80
POP RBX
POP R14
POP R15
JMP 0x0010363a
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* CacheHierarchy::CacheHierarchy() */
void __thiscall CacheHierarchy::CacheHierarchy(CacheHierarchy *this)
{
MemoryManager *this_00;
Cache *pCVar1;
Cache *pCVar2;
this_00 = (MemoryManager *)operator_new(0x2008);
/* try { // try from 00102820 to 00102827 has its CatchHandler @ 00102934 */
MemoryManager::MemoryManager(this_00);
*(MemoryManager **)this = this_00;
pCVar1 = (Cache *)operator_new(0x68);
/* try { // try from 00102853 to 00102872 has its CatchHandler @ 0010292c */
Cache::Cache(pCVar1,this_00,0);
*(Cache **)(this + 0x18) = pCVar1;
pCVar2 = (Cache *)operator_new(0x68);
/* try { // try from 001028a2 to 001028bf has its CatchHandler @ 0010292a */
Cache::Cache(pCVar2,*(int8 *)this,pCVar1);
*(Cache **)(this + 0x10) = pCVar2;
pCVar1 = (Cache *)operator_new(0x68);
/* try { // try from 001028ef to 0010290c has its CatchHandler @ 00102928 */
Cache::Cache(pCVar1,*(int8 *)this,pCVar2);
*(Cache **)(this + 8) = pCVar1;
MemoryManager::setCache(*(MemoryManager **)this,pCVar1);
return;
}
|
|
19,734
|
Catch::Clara::Detail::ParserRefImpl<Catch::Clara::Opt>::ParserRefImpl(std::shared_ptr<Catch::Clara::Detail::BoundRef> const&)
|
AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.hpp
|
explicit ParserRefImpl( std::shared_ptr<BoundRef> const& ref ):
m_ref( ref ) {}
|
O3
|
cpp
|
Catch::Clara::Detail::ParserRefImpl<Catch::Clara::Opt>::ParserRefImpl(std::shared_ptr<Catch::Clara::Detail::BoundRef> const&):
leaq 0xb8e07(%rip), %rax # 0x1305e0
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rdi)
testq %rax, %rax
je 0x77810
movq 0xba776(%rip), %rcx # 0x131f78
cmpb $0x0, (%rcx)
je 0x7780c
incl 0x8(%rax)
jmp 0x77810
lock
incl 0x8(%rax)
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
retq
nop
|
_ZN5Catch5Clara6Detail13ParserRefImplINS0_3OptEEC2ERKSt10shared_ptrINS1_8BoundRefEE:
lea rax, _ZTVN5Catch5Clara6Detail13ParserRefImplINS0_3OptEEE; `vtable for'Catch::Clara::Detail::ParserRefImpl<Catch::Clara::Opt>
add rax, 10h
mov [rdi], rax
mov dword ptr [rdi+8], 0
mov rax, [rsi]
mov [rdi+10h], rax
mov rax, [rsi+8]
mov [rdi+18h], rax
test rax, rax
jz short loc_77810
mov rcx, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rcx], 0
jz short loc_7780C
inc dword ptr [rax+8]
jmp short loc_77810
loc_7780C:
lock inc dword ptr [rax+8]
loc_77810:
lea rax, [rdi+30h]
mov [rdi+20h], rax
xor eax, eax
mov [rdi+28h], rax
mov [rdi+30h], al
lea rcx, [rdi+50h]
mov [rdi+40h], rcx
mov [rdi+48h], rax
mov [rdi+50h], al
retn
|
long long Catch::Clara::Detail::ParserRefImpl<Catch::Clara::Opt>::ParserRefImpl(long long a1, _QWORD *a2)
{
long long v2; // rax
long long result; // rax
*(_QWORD *)a1 = &`vtable for'Catch::Clara::Detail::ParserRefImpl<Catch::Clara::Opt> + 2;
*(_DWORD *)(a1 + 8) = 0;
*(_QWORD *)(a1 + 16) = *a2;
v2 = a2[1];
*(_QWORD *)(a1 + 24) = v2;
if ( v2 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v2 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v2 + 8));
}
*(_QWORD *)(a1 + 32) = a1 + 48;
result = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
*(_BYTE *)(a1 + 48) = 0;
*(_QWORD *)(a1 + 64) = a1 + 80;
*(_QWORD *)(a1 + 72) = 0LL;
*(_BYTE *)(a1 + 80) = 0;
return result;
}
|
ParserRefImpl:
LEA RAX,[0x2305e0]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV dword ptr [RDI + 0x8],0x0
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x18],RAX
TEST RAX,RAX
JZ 0x00177810
MOV RCX,qword ptr [0x00231f78]
CMP byte ptr [RCX],0x0
JZ 0x0017780c
INC dword ptr [RAX + 0x8]
JMP 0x00177810
LAB_0017780c:
INC.LOCK dword ptr [RAX + 0x8]
LAB_00177810:
LEA RAX,[RDI + 0x30]
MOV qword ptr [RDI + 0x20],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x28],RAX
MOV byte ptr [RDI + 0x30],AL
LEA RCX,[RDI + 0x50]
MOV qword ptr [RDI + 0x40],RCX
MOV qword ptr [RDI + 0x48],RAX
MOV byte ptr [RDI + 0x50],AL
RET
|
/* Catch::Clara::Detail::ParserRefImpl<Catch::Clara::Opt>::ParserRefImpl(std::shared_ptr<Catch::Clara::Detail::BoundRef>
const&) */
void __thiscall
Catch::Clara::Detail::ParserRefImpl<Catch::Clara::Opt>::ParserRefImpl
(ParserRefImpl<Catch::Clara::Opt> *this,shared_ptr *param_1)
{
long lVar1;
*(int ***)this = &PTR__ParserRefImpl_002305f0;
*(int4 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x18) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_00231f78 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(ParserRefImpl<Catch::Clara::Opt> **)(this + 0x20) = this + 0x30;
*(int8 *)(this + 0x28) = 0;
this[0x30] = (ParserRefImpl<Catch::Clara::Opt>)0x0;
*(ParserRefImpl<Catch::Clara::Opt> **)(this + 0x40) = this + 0x50;
*(int8 *)(this + 0x48) = 0;
this[0x50] = (ParserRefImpl<Catch::Clara::Opt>)0x0;
return;
}
|
|
19,735
|
my_hash_sort_utf8mb3_nopad
|
eloqsql/strings/ctype-utf8.c
|
static void my_hash_sort_utf8mb3_nopad(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
int res;
const uchar *e= s+slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((s < e) && (res=my_utf8mb3_uni(cs,&wc, (uchar *)s, (uchar*)e))>0 )
{
my_tosort_unicode(uni_plane, &wc, cs->state);
MY_HASH_ADD_16(m1, m2, wc);
s+= res;
}
*nr1= m1;
*nr2= m2;
}
|
O0
|
c
|
my_hash_sort_utf8mb3_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0xe621a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0xe4070
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0xe6226
jmp 0xe62c7
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
leaq -0x30(%rbp), %rsi
callq 0xe4e20
jmp 0xe623c
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
andq $0xff, %rcx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0xe6278
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x8, %rcx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0xe62b1
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0xe61ea
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_hash_sort_utf8mb3_nopad:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_58], rax
loc_E61EA:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_59], al
jnb short loc_E621A
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_utf8mb3_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_59], al
loc_E621A:
mov al, [rbp+var_59]
test al, 1
jnz short loc_E6226
jmp loc_E62C7
loc_E6226:
mov rdi, [rbp+var_48]
mov rax, [rbp+var_8]
mov edx, [rax+0Ch]
lea rsi, [rbp+var_30]
call my_tosort_unicode
jmp short $+2
loc_E623C:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
and rcx, 0FFh
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_E6278:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
shr rcx, 8
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_E62B1:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp loc_E61EA
loc_E62C7:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_58]
mov rax, [rbp+var_28]
mov [rax], rcx
add rsp, 60h
pop rbp
retn
|
_QWORD * my_hash_sort_utf8mb3_nopad(
long long a1,
unsigned long long a2,
long long a3,
unsigned long long *a4,
_QWORD *a5,
long long a6)
{
_QWORD *result; // rax
bool v7; // [rsp+7h] [rbp-59h]
long long v8; // [rsp+8h] [rbp-58h]
long long v9; // [rsp+8h] [rbp-58h]
unsigned long long v10; // [rsp+10h] [rbp-50h]
long long v11; // [rsp+10h] [rbp-50h]
_QWORD *v12; // [rsp+18h] [rbp-48h]
unsigned long long v13; // [rsp+20h] [rbp-40h]
int v14; // [rsp+2Ch] [rbp-34h]
unsigned long long v15; // [rsp+30h] [rbp-30h] BYREF
_QWORD *v16; // [rsp+38h] [rbp-28h]
unsigned long long *v17; // [rsp+40h] [rbp-20h]
long long v18; // [rsp+48h] [rbp-18h]
unsigned long long v19; // [rsp+50h] [rbp-10h]
long long v20; // [rsp+58h] [rbp-8h]
v20 = a1;
v19 = a2;
v18 = a3;
v17 = a4;
v16 = a5;
v13 = a3 + a2;
v12 = *(_QWORD **)(a1 + 120);
v10 = *a4;
v8 = *a5;
while ( 1 )
{
v7 = 0;
if ( v19 < v13 )
{
v14 = my_utf8mb3_uni(v20, (long long)&v15, v19, v13, (long long)a5, a6);
v7 = v14 > 0;
}
if ( !v7 )
break;
my_tosort_unicode(v12, &v15, *(_DWORD *)(v20 + 12));
v11 = v10 ^ ((v10 << 8) + (unsigned __int8)v15 * (v8 + (v10 & 0x3F)));
v9 = v8 + 3;
v10 = v11 ^ ((v11 << 8) + (v15 >> 8) * (v9 + (v11 & 0x3F)));
v8 = v9 + 3;
v19 += v14;
}
*v17 = v10;
result = v16;
*v16 = v8;
return result;
}
|
my_hash_sort_utf8mb3_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
LAB_001e61ea:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x59],AL
JNC 0x001e621a
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x001e4070
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x59],AL
LAB_001e621a:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x001e6226
JMP 0x001e62c7
LAB_001e6226:
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RAX + 0xc]
LEA RSI,[RBP + -0x30]
CALL 0x001e4e20
JMP 0x001e623c
LAB_001e623c:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
AND RCX,0xff
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001e6278
LAB_001e6278:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x8
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001e62b1
LAB_001e62b1:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001e61ea
LAB_001e62c7:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
ADD RSP,0x60
POP RBP
RET
|
void my_hash_sort_utf8mb3_nopad
(long param_1,ulong param_2,long param_3,ulong *param_4,long *param_5)
{
int8 uVar1;
bool bVar2;
long local_60;
ulong local_58;
int local_3c;
ulong local_38;
long *local_30;
ulong *local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_58 = *param_4;
local_60 = *param_5;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_utf8mb3_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_tosort_unicode(uVar1,&local_38,*(int4 *)(local_10 + 0xc));
local_58 = ((local_58 & 0x3f) + local_60) * (local_38 & 0xff) + local_58 * 0x100 ^ local_58;
local_58 = ((local_58 & 0x3f) + local_60 + 3) * (local_38 >> 8) + local_58 * 0x100 ^ local_58;
local_60 = local_60 + 6;
local_18 = local_18 + (long)local_3c;
}
*local_28 = local_58;
*local_30 = local_60;
return;
}
|
|
19,736
|
JS_ThrowInternalError
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue __attribute__((format(printf, 2, 3))) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...)
{
JSValue val;
va_list ap;
va_start(ap, fmt);
val = JS_ThrowError(ctx, JS_INTERNAL_ERROR, fmt, ap);
va_end(ap);
return val;
}
|
O0
|
c
|
JS_ThrowInternalError:
subq $0x108, %rsp # imm = 0x108
testb %al, %al
je 0x3380c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movq %rsp, %rax
movq %rax, 0xd0(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl $0x30, 0xc4(%rsp)
movl $0x10, 0xc0(%rsp)
movq 0xe8(%rsp), %rdi
movq 0xe0(%rsp), %rdx
movl $0x6, %esi
leaq 0xc0(%rsp), %rcx
callq 0x33430
movq %rax, 0xb0(%rsp)
movq %rdx, 0xb8(%rsp)
movups 0xb0(%rsp), %xmm0
movaps %xmm0, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq 0xf8(%rsp), %rdx
addq $0x108, %rsp # imm = 0x108
retq
nopl (%rax,%rax)
|
JS_ThrowInternalError:
sub rsp, 108h
test al, al
jz short loc_3380C
movaps [rsp+108h+var_D8], xmm0
movaps [rsp+108h+var_C8], xmm1
movaps [rsp+108h+var_B8], xmm2
movaps [rsp+108h+var_A8], xmm3
movaps [rsp+108h+var_98], xmm4
movaps [rsp+108h+var_88], xmm5
movaps [rsp+108h+var_78], xmm6
movaps [rsp+108h+var_68], xmm7
loc_3380C:
mov [rsp+108h+var_E0], r9
mov [rsp+108h+var_E8], r8
mov [rsp+108h+var_F0], rcx
mov [rsp+108h+var_F8], rdx
mov [rsp+108h+var_20], rdi
mov [rsp+108h+var_28], rsi
mov rax, rsp
mov [rsp+108h+var_38], rax
lea rax, [rsp+108h+arg_0]
mov [rsp+108h+var_40], rax
mov [rsp+108h+var_44], 30h ; '0'
mov [rsp+108h+var_48], 10h
mov rdi, [rsp+108h+var_20]
mov rdx, [rsp+108h+var_28]
mov esi, 6
lea rcx, [rsp+108h+var_48]
call JS_ThrowError
mov qword ptr [rsp+108h+var_58], rax
mov qword ptr [rsp+108h+var_58+8], rdx
movups xmm0, [rsp+108h+var_58]
movaps [rsp+108h+var_18], xmm0
mov rax, qword ptr [rsp+108h+var_18]
mov rdx, qword ptr [rsp+108h+var_18+8]
add rsp, 108h
retn
|
long long JS_ThrowInternalError(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
_QWORD v16[6]; // [rsp+0h] [rbp-108h] BYREF
__m128 v17; // [rsp+30h] [rbp-D8h]
__m128 v18; // [rsp+40h] [rbp-C8h]
__m128 v19; // [rsp+50h] [rbp-B8h]
__m128 v20; // [rsp+60h] [rbp-A8h]
__m128 v21; // [rsp+70h] [rbp-98h]
__m128 v22; // [rsp+80h] [rbp-88h]
__m128 v23; // [rsp+90h] [rbp-78h]
__m128 v24; // [rsp+A0h] [rbp-68h]
_DWORD v25[2]; // [rsp+C0h] [rbp-48h] BYREF
char *v26; // [rsp+C8h] [rbp-40h]
_QWORD *v27; // [rsp+D0h] [rbp-38h]
long long v28; // [rsp+E0h] [rbp-28h]
long long v29; // [rsp+E8h] [rbp-20h]
v17 = a7;
v18 = a8;
v19 = a9;
v20 = a10;
v21 = a11;
v22 = a12;
v23 = a13;
v24 = a14;
v16[5] = a6;
v16[4] = a5;
v16[3] = a4;
v16[2] = a3;
v29 = a1;
v28 = a2;
v27 = v16;
v26 = &a15;
v25[1] = 48;
v25[0] = 16;
return JS_ThrowError(a1, 6u, a2, (long long)v25);
}
|
JS_ThrowInternalError:
SUB RSP,0x108
TEST AL,AL
JZ 0x0013380c
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM1
MOVAPS xmmword ptr [RSP + 0x50],XMM2
MOVAPS xmmword ptr [RSP + 0x60],XMM3
MOVAPS xmmword ptr [RSP + 0x70],XMM4
MOVAPS xmmword ptr [RSP + 0x80],XMM5
MOVAPS xmmword ptr [RSP + 0x90],XMM6
MOVAPS xmmword ptr [RSP + 0xa0],XMM7
LAB_0013380c:
MOV qword ptr [RSP + 0x28],R9
MOV qword ptr [RSP + 0x20],R8
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0xe8],RDI
MOV qword ptr [RSP + 0xe0],RSI
MOV RAX,RSP
MOV qword ptr [RSP + 0xd0],RAX
LEA RAX,[RSP + 0x110]
MOV qword ptr [RSP + 0xc8],RAX
MOV dword ptr [RSP + 0xc4],0x30
MOV dword ptr [RSP + 0xc0],0x10
MOV RDI,qword ptr [RSP + 0xe8]
MOV RDX,qword ptr [RSP + 0xe0]
MOV ESI,0x6
LEA RCX,[RSP + 0xc0]
CALL 0x00133430
MOV qword ptr [RSP + 0xb0],RAX
MOV qword ptr [RSP + 0xb8],RDX
MOVUPS XMM0,xmmword ptr [RSP + 0xb0]
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
MOV RAX,qword ptr [RSP + 0xf0]
MOV RDX,qword ptr [RSP + 0xf8]
ADD RSP,0x108
RET
|
int1 [16]
JS_ThrowInternalError
(int4 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)
{
int1 auVar1 [16];
char in_AL;
int1 auStack_108 [16];
int8 local_f8;
int8 local_f0;
int8 local_e8;
int8 local_e0;
int4 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int4 local_48;
int4 local_44;
int1 *local_40;
int1 *local_38;
int8 local_28;
int8 local_20;
local_38 = auStack_108;
if (in_AL != '\0') {
local_d8 = param_1;
local_c8 = param_2;
local_b8 = param_3;
local_a8 = param_4;
local_98 = param_5;
local_88 = param_6;
local_78 = param_7;
local_68 = param_8;
}
local_40 = &stack0x00000008;
local_44 = 0x30;
local_48 = 0x10;
local_f8 = param_11;
local_f0 = param_12;
local_e8 = param_13;
local_e0 = param_14;
local_28 = param_10;
local_20 = param_9;
auVar1 = JS_ThrowError(param_9,6,param_10,&local_48);
return auVar1;
}
|
|
19,737
|
JS_ThrowInternalError
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue __attribute__((format(printf, 2, 3))) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...)
{
JSValue val;
va_list ap;
va_start(ap, fmt);
val = JS_ThrowError(ctx, JS_INTERNAL_ERROR, fmt, ap);
va_end(ap);
return val;
}
|
O2
|
c
|
JS_ThrowInternalError:
subq $0xd8, %rsp
movq %rsi, %r10
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2037b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
pushq $0x6
popq %rsi
movq %r10, %rdx
callq 0x20101
pushq $0x6
popq %rdx
xorl %eax, %eax
addq $0xd8, %rsp
retq
|
JS_ThrowInternalError:
sub rsp, 0D8h
mov r10, rsi
lea rsi, [rsp+0D8h+var_B8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_2037B
movaps [rsp+0D8h+var_88], xmm0
movaps [rsp+0D8h+var_78], xmm1
movaps [rsp+0D8h+var_68], xmm2
movaps [rsp+0D8h+var_58], xmm3
movaps [rsp+0D8h+var_48], xmm4
movaps [rsp+0D8h+var_38], xmm5
movaps [rsp+0D8h+var_28], xmm6
movaps [rsp+0D8h+var_18], xmm7
loc_2037B:
mov rcx, rsp
mov [rcx+10h], rsi
lea rax, [rsp+0D8h+arg_0]
mov [rcx+8], rax
mov rax, 3000000010h
mov [rcx], rax
push 6
pop rsi
mov rdx, r10
call JS_ThrowError
push 6
pop rdx
xor eax, eax
add rsp, 0D8h
retn
|
long long JS_ThrowInternalError(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
_QWORD v16[4]; // [rsp+0h] [rbp-D8h] BYREF
char v17; // [rsp+20h] [rbp-B8h] BYREF
long long v18; // [rsp+30h] [rbp-A8h]
long long v19; // [rsp+38h] [rbp-A0h]
long long v20; // [rsp+40h] [rbp-98h]
long long v21; // [rsp+48h] [rbp-90h]
__m128 v22; // [rsp+50h] [rbp-88h]
__m128 v23; // [rsp+60h] [rbp-78h]
__m128 v24; // [rsp+70h] [rbp-68h]
__m128 v25; // [rsp+80h] [rbp-58h]
__m128 v26; // [rsp+90h] [rbp-48h]
__m128 v27; // [rsp+A0h] [rbp-38h]
__m128 v28; // [rsp+B0h] [rbp-28h]
__m128 v29; // [rsp+C0h] [rbp-18h]
v22 = a7;
v23 = a8;
v24 = a9;
v25 = a10;
v26 = a11;
v27 = a12;
v28 = a13;
v29 = a14;
v18 = a3;
v19 = a4;
v20 = a5;
v21 = a6;
v16[2] = &v17;
v16[1] = &a15;
v16[0] = 0x3000000010LL;
JS_ThrowError(a1, 6LL, a2, (long long)v16);
return 0LL;
}
|
JS_ThrowInternalError:
SUB RSP,0xd8
MOV R10,RSI
LEA RSI,[RSP + 0x20]
MOV qword ptr [RSI + 0x10],RDX
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x0012037b
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_0012037b:
MOV RCX,RSP
MOV qword ptr [RCX + 0x10],RSI
LEA RAX,[RSP + 0xe0]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [RCX],RAX
PUSH 0x6
POP RSI
MOV RDX,R10
CALL 0x00120101
PUSH 0x6
POP RDX
XOR EAX,EAX
ADD RSP,0xd8
RET
|
int1 [16] JS_ThrowInternalError(int8 param_1,int8 param_2)
{
JS_ThrowError(param_1,6,param_2);
return ZEXT816(6) << 0x40;
}
|
|
19,738
|
ha_maria::open(char const*, int, unsigned int)
|
eloqsql/storage/maria/ha_maria.cc
|
int ha_maria::open(const char *name, int mode, uint test_if_locked)
{
uint i;
#ifdef NOT_USED
/*
If the user wants to have memory mapped data files, add an
open_flag. Do not memory map temporary tables because they are
expected to be inserted and thus extended a lot. Memory mapping is
efficient for files that keep their size, but very inefficient for
growing files. Using an open_flag instead of calling ma_extra(...
HA_EXTRA_MMAP ...) after maxs_open() has the advantage that the
mapping is not repeated for every open, but just done on the initial
open, when the MyISAM share is created. Every time the server
requires to open a new instance of a table it calls this method. We
will always supply HA_OPEN_MMAP for a permanent table. However, the
Maria storage engine will ignore this flag if this is a secondary
open of a table that is in use by other threads already (if the
Maria share exists already).
*/
if (!(test_if_locked & HA_OPEN_TMP_TABLE) && opt_maria_use_mmap)
test_if_locked|= HA_OPEN_MMAP;
#endif
if (maria_recover_options & HA_RECOVER_ANY)
{
/* user asked to trigger a repair if table was not properly closed */
test_if_locked|= HA_OPEN_ABORT_IF_CRASHED;
}
if (aria_readonly)
test_if_locked|= HA_OPEN_IGNORE_MOVED_STATE;
if (!(file= maria_open(name, mode, test_if_locked | HA_OPEN_FROM_SQL_LAYER,
s3_open_args())))
{
if (my_errno == HA_ERR_OLD_FILE)
{
push_warning(current_thd, Sql_condition::WARN_LEVEL_NOTE,
ER_CRASHED_ON_USAGE,
zerofill_error_msg);
}
return (my_errno ? my_errno : -1);
}
if (aria_readonly)
file->s->options|= HA_OPTION_READ_ONLY_DATA;
file->s->chst_invalidator= query_cache_invalidate_by_MyISAM_filename_ref;
/* Set external_ref, mainly for temporary tables */
file->external_ref= (void*) table; // For ma_killed()
if (test_if_locked & (HA_OPEN_IGNORE_IF_LOCKED | HA_OPEN_TMP_TABLE))
maria_extra(file, HA_EXTRA_NO_WAIT_LOCK, 0);
info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED))
maria_extra(file, HA_EXTRA_WAIT_LOCK, 0);
if ((data_file_type= file->s->data_file_type) != STATIC_RECORD)
int_table_flags |= HA_REC_NOT_IN_SEQ;
if (!file->s->base.born_transactional)
{
/*
INSERT DELAYED cannot work with transactional tables (because it cannot
stand up to "when client gets ok the data is safe on disk": the record
may not even be inserted). In the future, we could enable it back (as a
client doing INSERT DELAYED knows the specificities; but we then should
make sure to regularly commit in the delayed_insert thread).
*/
int_table_flags|= HA_CAN_INSERT_DELAYED | HA_NO_TRANSACTIONS;
}
else
int_table_flags|= HA_CRASH_SAFE;
if (file->s->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD))
int_table_flags |= HA_HAS_NEW_CHECKSUM;
/*
We can only do online backup on transactional tables with checksum.
Checksums are needed to avoid half writes.
*/
if (file->s->options & HA_OPTION_PAGE_CHECKSUM &&
file->s->base.born_transactional)
int_table_flags |= HA_CAN_ONLINE_BACKUPS;
/*
For static size rows, tell MariaDB that we will access all bytes
in the record when writing it. This signals MariaDB to initialize
the full row to ensure we don't get any errors from valgrind and
that all bytes in the row is properly reset.
*/
if (file->s->data_file_type == STATIC_RECORD &&
(file->s->has_varchar_fields || file->s->has_null_fields))
int_table_flags|= HA_RECORD_MUST_BE_CLEAN_ON_WRITE;
for (i= 0; i < table->s->keys; i++)
{
plugin_ref parser= table->key_info[i].parser;
if (table->key_info[i].flags & HA_USES_PARSER)
file->s->keyinfo[i].parser=
(struct st_mysql_ftparser *)plugin_decl(parser)->info;
table->key_info[i].block_size= file->s->keyinfo[i].block_length;
}
my_errno= 0;
/* Count statistics of usage for newly open normal files */
if (file->s->reopen == 1 && ! (test_if_locked & HA_OPEN_TMP_TABLE))
{
if (file->s->delay_key_write)
feature_files_opened_with_delayed_keys++;
}
return my_errno;
}
|
O0
|
cpp
|
ha_maria::open(char const*, int, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0xebf133(%rip), %rax # 0x1d01e18
andq $0xf, %rax
cmpq $0x0, %rax
je 0xe42cf8
movl -0x20(%rbp), %eax
orl $0x10, %eax
movl %eax, -0x20(%rbp)
leaq 0xebe9f3(%rip), %rax # 0x1d016f2
cmpb $0x0, (%rax)
je 0xe42d0f
movl -0x20(%rbp), %eax
orl $0x40000000, %eax # imm = 0x40000000
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x20(%rbp), %eax
orl $0x40, %eax
movl %eax, -0x3c(%rbp)
movq (%rdi), %rax
callq *0x680(%rax)
movq -0x48(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x3c(%rbp), %edx
movq %rax, %rcx
callq 0xe6f570
movq -0x38(%rbp), %rcx
movq %rax, 0x4e8(%rcx)
cmpq $0x0, %rax
jne 0xe42da9
callq 0x12ca030
cmpl $0x84, (%rax)
jne 0xe42d7e
callq 0x7cc1e0
movq %rax, %rdi
movq 0xcad80e(%rip), %rcx # 0x1af0580
xorl %esi, %esi
movl $0x4aa, %edx # imm = 0x4AA
callq 0x8ab370
callq 0x12ca030
cmpl $0x0, (%rax)
je 0xe42d94
callq 0x12ca030
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0xe42d9e
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %eax, -0x4c(%rbp)
jmp 0xe42d9e
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe4312e
leaq 0xebe942(%rip), %rax # 0x1d016f2
cmpb $0x0, (%rax)
je 0xe42dd8
movq -0x38(%rbp), %rax
movq 0x4e8(%rax), %rax
movq (%rax), %rax
movq 0x720(%rax), %rcx
orq $0x10000, %rcx # imm = 0x10000
movq %rcx, 0x720(%rax)
movq -0x38(%rbp), %rax
movq 0x4e8(%rax), %rcx
movq (%rcx), %rcx
leaq -0x5cd7fd(%rip), %rdx # 0x8755f0
movq %rdx, 0x6f8(%rcx)
movq 0x10(%rax), %rcx
movq 0x4e8(%rax), %rax
movq %rcx, 0x370(%rax)
movl -0x20(%rbp), %eax
andl $0x6, %eax
cmpl $0x0, %eax
je 0xe42e2a
movq -0x38(%rbp), %rax
movq 0x4e8(%rax), %rdi
movl $0xd, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xe78ea0
movq -0x38(%rbp), %rdi
movl $0x1a, %esi
callq 0xe43140
movl -0x20(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xe42e5c
movq -0x38(%rbp), %rax
movq 0x4e8(%rax), %rdi
movl $0xc, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xe78ea0
movq -0x38(%rbp), %rcx
movq 0x4e8(%rcx), %rax
movq (%rax), %rax
movl 0x7d0(%rax), %eax
movl %eax, 0x510(%rcx)
cmpl $0x0, %eax
je 0xe42e91
movq -0x38(%rbp), %rax
movq 0x4f0(%rax), %rcx
orq $0x8, %rcx
movq %rcx, 0x4f0(%rax)
movq -0x38(%rbp), %rax
movq 0x4e8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0x44c(%rax)
jne 0xe42ec3
movq -0x38(%rbp), %rax
movq 0x4f0(%rax), %rcx
orq $0x4001, %rcx # imm = 0x4001
movq %rcx, 0x4f0(%rax)
jmp 0xe42edf
movq -0x38(%rbp), %rax
movabsq $0x400000000000000, %rcx # imm = 0x400000000000000
orq 0x4f0(%rax), %rcx
movq %rcx, 0x4f0(%rax)
movq -0x38(%rbp), %rax
movq 0x4e8(%rax), %rax
movq (%rax), %rax
movq 0x720(%rax), %rax
andq $0x24, %rax
cmpq $0x0, %rax
je 0xe42f1a
movq -0x38(%rbp), %rax
movabsq $0x4000000000, %rcx # imm = 0x4000000000
orq 0x4f0(%rax), %rcx
movq %rcx, 0x4f0(%rax)
movq -0x38(%rbp), %rax
movq 0x4e8(%rax), %rax
movq (%rax), %rax
movq 0x720(%rax), %rax
andq $0x800, %rax # imm = 0x800
cmpq $0x0, %rax
je 0xe42f6e
movq -0x38(%rbp), %rax
movq 0x4e8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0x44c(%rax)
je 0xe42f6e
movq -0x38(%rbp), %rax
movabsq $0x100000000000000, %rcx # imm = 0x100000000000000
orq 0x4f0(%rax), %rcx
movq %rcx, 0x4f0(%rax)
movq -0x38(%rbp), %rax
movq 0x4e8(%rax), %rax
movq (%rax), %rax
cmpl $0x0, 0x7d0(%rax)
jne 0xe42fcf
movq -0x38(%rbp), %rax
movq 0x4e8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0x7dc(%rax)
jne 0xe42fb3
movq -0x38(%rbp), %rax
movq 0x4e8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0x7db(%rax)
je 0xe42fcf
movq -0x38(%rbp), %rax
movabsq $0x20000000000, %rcx # imm = 0x20000000000
orq 0x4f0(%rax), %rcx
movq %rcx, 0x4f0(%rax)
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %eax
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
cmpl 0x3a0(%rcx), %eax
jae 0xe430c3
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movq 0xa8(%rcx), %rcx
movl -0x24(%rbp), %edx
imulq $0xc0, %rdx, %rdx
addq %rdx, %rcx
movq 0x60(%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq 0xa8(%rax), %rax
movl -0x24(%rbp), %ecx
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
andq $0x4000, %rax # imm = 0x4000
cmpq $0x0, %rax
je 0xe43071
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq 0x4e8(%rax), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0x24(%rbp), %edx
imulq $0x118, %rdx, %rdx # imm = 0x118
addq %rdx, %rax
movq %rcx, 0xd0(%rax)
movq -0x38(%rbp), %rax
movq 0x4e8(%rax), %rcx
movq (%rcx), %rcx
movq 0x570(%rcx), %rcx
movl -0x24(%rbp), %edx
imulq $0x118, %rdx, %rdx # imm = 0x118
addq %rdx, %rcx
movzwl 0xa6(%rcx), %ecx
movq 0x10(%rax), %rax
movq 0xa8(%rax), %rax
movl -0x24(%rbp), %edx
imulq $0xc0, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x50(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xe42fd6
callq 0x12ca030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movl $0x0, (%rcx)
movq 0x4e8(%rax), %rax
movq (%rax), %rax
cmpl $0x1, 0x7a8(%rax)
jne 0xe43124
movl -0x20(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0xe43124
movq -0x38(%rbp), %rax
movq 0x4e8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0x7e5(%rax)
je 0xe43122
leaq 0xe850cf(%rip), %rax # 0x1cc81e0
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0xe850c1(%rip), %rax # 0x1cc81e0
movq %rcx, (%rax)
jmp 0xe43124
callq 0x12ca030
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_ZN8ha_maria4openEPKcij:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_20], ecx
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rax, cs:maria_recover_options
and rax, 0Fh
cmp rax, 0
jz short loc_E42CF8
mov eax, [rbp+var_20]
or eax, 10h
mov [rbp+var_20], eax
loc_E42CF8:
lea rax, aria_readonly
cmp byte ptr [rax], 0
jz short loc_E42D0F
mov eax, [rbp+var_20]
or eax, 40000000h
mov [rbp+var_20], eax
loc_E42D0F:
mov rdi, [rbp+var_38]
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
mov eax, [rbp+var_1C]
mov [rbp+var_40], eax
mov eax, [rbp+var_20]
or eax, 40h
mov [rbp+var_3C], eax
mov rax, [rdi]
call qword ptr [rax+680h]
mov rdi, [rbp+var_48]
mov esi, [rbp+var_40]
mov edx, [rbp+var_3C]
mov rcx, rax
call maria_open
mov rcx, [rbp+var_38]
mov [rcx+4E8h], rax
cmp rax, 0
jnz short loc_E42DA9
call _my_thread_var
cmp dword ptr [rax], 84h
jnz short loc_E42D7E
call _current_thd
mov rdi, rax
mov rcx, cs:zerofill_error_msg
xor esi, esi
mov edx, 4AAh
call _Z12push_warningP3THDN21Sql_state_errno_level18enum_warning_levelEjPKc; push_warning(THD *,Sql_state_errno_level::enum_warning_level,uint,char const*)
loc_E42D7E:
call _my_thread_var
cmp dword ptr [rax], 0
jz short loc_E42D94
call _my_thread_var
mov eax, [rax]
mov [rbp+var_4C], eax
jmp short loc_E42D9E
loc_E42D94:
mov eax, 0FFFFFFFFh
mov [rbp+var_4C], eax
jmp short $+2
loc_E42D9E:
mov eax, [rbp+var_4C]
mov [rbp+var_4], eax
jmp loc_E4312E
loc_E42DA9:
lea rax, aria_readonly
cmp byte ptr [rax], 0
jz short loc_E42DD8
mov rax, [rbp+var_38]
mov rax, [rax+4E8h]
mov rax, [rax]
mov rcx, [rax+720h]
or rcx, 10000h
mov [rax+720h], rcx
loc_E42DD8:
mov rax, [rbp+var_38]
mov rcx, [rax+4E8h]
mov rcx, [rcx]
lea rdx, query_cache_invalidate_by_MyISAM_filename
mov [rcx+6F8h], rdx
mov rcx, [rax+10h]
mov rax, [rax+4E8h]
mov [rax+370h], rcx
mov eax, [rbp+var_20]
and eax, 6
cmp eax, 0
jz short loc_E42E2A
mov rax, [rbp+var_38]
mov rdi, [rax+4E8h]
mov esi, 0Dh
xor eax, eax
mov edx, eax
call maria_extra
loc_E42E2A:
mov rdi, [rbp+var_38]; this
mov esi, 1Ah; unsigned int
call _ZN8ha_maria4infoEj; ha_maria::info(uint)
mov eax, [rbp+var_20]
and eax, 1
cmp eax, 0
jnz short loc_E42E5C
mov rax, [rbp+var_38]
mov rdi, [rax+4E8h]
mov esi, 0Ch
xor eax, eax
mov edx, eax
call maria_extra
loc_E42E5C:
mov rcx, [rbp+var_38]
mov rax, [rcx+4E8h]
mov rax, [rax]
mov eax, [rax+7D0h]
mov [rcx+510h], eax
cmp eax, 0
jz short loc_E42E91
mov rax, [rbp+var_38]
mov rcx, [rax+4F0h]
or rcx, 8
mov [rax+4F0h], rcx
loc_E42E91:
mov rax, [rbp+var_38]
mov rax, [rax+4E8h]
mov rax, [rax]
cmp byte ptr [rax+44Ch], 0
jnz short loc_E42EC3
mov rax, [rbp+var_38]
mov rcx, [rax+4F0h]
or rcx, 4001h
mov [rax+4F0h], rcx
jmp short loc_E42EDF
loc_E42EC3:
mov rax, [rbp+var_38]
mov rcx, 400000000000000h
or rcx, [rax+4F0h]
mov [rax+4F0h], rcx
loc_E42EDF:
mov rax, [rbp+var_38]
mov rax, [rax+4E8h]
mov rax, [rax]
mov rax, [rax+720h]
and rax, 24h
cmp rax, 0
jz short loc_E42F1A
mov rax, [rbp+var_38]
mov rcx, 4000000000h
or rcx, [rax+4F0h]
mov [rax+4F0h], rcx
loc_E42F1A:
mov rax, [rbp+var_38]
mov rax, [rax+4E8h]
mov rax, [rax]
mov rax, [rax+720h]
and rax, 800h
cmp rax, 0
jz short loc_E42F6E
mov rax, [rbp+var_38]
mov rax, [rax+4E8h]
mov rax, [rax]
cmp byte ptr [rax+44Ch], 0
jz short loc_E42F6E
mov rax, [rbp+var_38]
mov rcx, 100000000000000h
or rcx, [rax+4F0h]
mov [rax+4F0h], rcx
loc_E42F6E:
mov rax, [rbp+var_38]
mov rax, [rax+4E8h]
mov rax, [rax]
cmp dword ptr [rax+7D0h], 0
jnz short loc_E42FCF
mov rax, [rbp+var_38]
mov rax, [rax+4E8h]
mov rax, [rax]
cmp byte ptr [rax+7DCh], 0
jnz short loc_E42FB3
mov rax, [rbp+var_38]
mov rax, [rax+4E8h]
mov rax, [rax]
cmp byte ptr [rax+7DBh], 0
jz short loc_E42FCF
loc_E42FB3:
mov rax, [rbp+var_38]
mov rcx, 20000000000h
or rcx, [rax+4F0h]
mov [rax+4F0h], rcx
loc_E42FCF:
mov [rbp+var_24], 0
loc_E42FD6:
mov rcx, [rbp+var_38]
mov eax, [rbp+var_24]
mov rcx, [rcx+10h]
mov rcx, [rcx]
cmp eax, [rcx+3A0h]
jnb loc_E430C3
mov rax, [rbp+var_38]
mov rcx, [rax+10h]
mov rcx, [rcx+0A8h]
mov edx, [rbp+var_24]
imul rdx, 0C0h
add rcx, rdx
mov rcx, [rcx+60h]
mov [rbp+var_30], rcx
mov rax, [rax+10h]
mov rax, [rax+0A8h]
mov ecx, [rbp+var_24]
imul rcx, 0C0h
add rax, rcx
mov rax, [rax+8]
and rax, 4000h
cmp rax, 0
jz short loc_E43071
mov rax, [rbp+var_38]
mov rcx, [rbp+var_30]
mov rcx, [rcx+10h]
mov rcx, [rcx+8]
mov rax, [rax+4E8h]
mov rax, [rax]
mov rax, [rax+570h]
mov edx, [rbp+var_24]
imul rdx, 118h
add rax, rdx
mov [rax+0D0h], rcx
loc_E43071:
mov rax, [rbp+var_38]
mov rcx, [rax+4E8h]
mov rcx, [rcx]
mov rcx, [rcx+570h]
mov edx, [rbp+var_24]
imul rdx, 118h
add rcx, rdx
movzx ecx, word ptr [rcx+0A6h]
mov rax, [rax+10h]
mov rax, [rax+0A8h]
mov edx, [rbp+var_24]
imul rdx, 0C0h
add rax, rdx
mov [rax+50h], ecx
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp loc_E42FD6
loc_E430C3:
call _my_thread_var
mov rcx, rax
mov rax, [rbp+var_38]
mov dword ptr [rcx], 0
mov rax, [rax+4E8h]
mov rax, [rax]
cmp dword ptr [rax+7A8h], 1
jnz short loc_E43124
mov eax, [rbp+var_20]
and eax, 4
cmp eax, 0
jnz short loc_E43124
mov rax, [rbp+var_38]
mov rax, [rax+4E8h]
mov rax, [rax]
cmp byte ptr [rax+7E5h], 0
jz short loc_E43122
lea rax, feature_files_opened_with_delayed_keys
mov rcx, [rax]
add rcx, 1
lea rax, feature_files_opened_with_delayed_keys
mov [rax], rcx
loc_E43122:
jmp short $+2
loc_E43124:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_4], eax
loc_E4312E:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long ha_maria::open(ha_maria *this, THD *a2, unsigned int a3, int a4)
{
long long v4; // rax
THD *v5; // rdi
const char *v6; // rsi
long long v7; // rax
long long v8; // rdx
ha_maria *v9; // rdi
const char *v10; // rsi
int v11; // eax
long long v12; // rcx
unsigned int i; // [rsp+2Ch] [rbp-24h]
int v17; // [rsp+30h] [rbp-20h]
v17 = a4;
if ( (maria_recover_options & 0xF) != 0 )
v17 = a4 | 0x10;
if ( aria_readonly )
v17 |= 0x40000000u;
v4 = (*(long long ( **)(ha_maria *))(*(_QWORD *)this + 1664LL))(this);
v5 = a2;
v6 = (const char *)a3;
v7 = maria_open(a2, a3, v17 | 0x40u, v4);
*((_QWORD *)this + 157) = v7;
if ( v7 )
{
if ( aria_readonly )
*(_QWORD *)(**((_QWORD **)this + 157) + 1824LL) |= 0x10000uLL;
*(_QWORD *)(**((_QWORD **)this + 157) + 1784LL) = query_cache_invalidate_by_MyISAM_filename;
*(_QWORD *)(*((_QWORD *)this + 157) + 880LL) = *((_QWORD *)this + 2);
if ( (v17 & 6) != 0 )
maria_extra(*((_QWORD *)this + 157), 13LL, 0LL);
v9 = this;
v10 = (_BYTE *)(&off_18 + 2);
ha_maria::info(this, 0x1Au);
if ( (v17 & 1) == 0 )
{
v9 = (ha_maria *)*((_QWORD *)this + 157);
v10 = byte_9 + 3;
maria_extra(v9, 12LL, 0LL);
}
v11 = *(_DWORD *)(**((_QWORD **)this + 157) + 2000LL);
*((_DWORD *)this + 324) = v11;
if ( v11 )
*((_QWORD *)this + 158) |= 8uLL;
if ( *(_BYTE *)(**((_QWORD **)this + 157) + 1100LL) )
v12 = *((_QWORD *)this + 158) | 0x400000000000000LL;
else
v12 = *((_QWORD *)this + 158) | 0x4001LL;
*((_QWORD *)this + 158) = v12;
if ( (*(_QWORD *)(**((_QWORD **)this + 157) + 1824LL) & 0x24LL) != 0 )
*((_QWORD *)this + 158) |= 0x4000000000uLL;
if ( (*(_QWORD *)(**((_QWORD **)this + 157) + 1824LL) & 0x800LL) != 0
&& *(_BYTE *)(**((_QWORD **)this + 157) + 1100LL) )
{
*((_QWORD *)this + 158) |= 0x100000000000000uLL;
}
if ( !*(_DWORD *)(**((_QWORD **)this + 157) + 2000LL)
&& (*(_BYTE *)(**((_QWORD **)this + 157) + 2012LL) || *(_BYTE *)(**((_QWORD **)this + 157) + 2011LL)) )
{
*((_QWORD *)this + 158) |= 0x20000000000uLL;
}
for ( i = 0; i < *(_DWORD *)(**((_QWORD **)this + 2) + 928LL); ++i )
{
if ( (*(_QWORD *)(192LL * i + *(_QWORD *)(*((_QWORD *)this + 2) + 168LL) + 8) & 0x4000LL) != 0 )
*(_QWORD *)(280LL * i + *(_QWORD *)(**((_QWORD **)this + 157) + 1392LL) + 208) = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(192LL * i + *(_QWORD *)(*((_QWORD *)this + 2) + 168LL) + 96) + 16LL) + 8LL);
*(_DWORD *)(192LL * i + *(_QWORD *)(*((_QWORD *)this + 2) + 168LL) + 80) = *(unsigned __int16 *)(280LL * i + *(_QWORD *)(**((_QWORD **)this + 157) + 1392LL) + 166);
}
*(_DWORD *)my_thread_var(v9, v10) = 0;
if ( *(_DWORD *)(**((_QWORD **)this + 157) + 1960LL) == 1
&& (v17 & 4) == 0
&& *(_BYTE *)(**((_QWORD **)this + 157) + 2021LL) )
{
++feature_files_opened_with_delayed_keys;
}
return *(unsigned int *)my_thread_var(v9, v10);
}
else
{
if ( *(_DWORD *)my_thread_var(a2, (const char *)a3) == 132 )
{
v5 = (THD *)current_thd(a2, a3, v8);
v6 = 0LL;
push_warning(v5, 0, 0x4AAu, (long long)zerofill_error_msg);
}
if ( *(_DWORD *)my_thread_var(v5, v6) )
return *(unsigned int *)my_thread_var(v5, v6);
else
return (unsigned int)-1;
}
}
|
set_encrypted_writer:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xe55670]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
POP RBP
RET
|
/* Log_event_writer::set_encrypted_writer() */
void __thiscall Log_event_writer::set_encrypted_writer(Log_event_writer *this)
{
*(code **)this = encrypt_and_write;
*(int8 *)(this + 8) = 0;
return;
}
|
|
19,739
|
llama_sampler_mirostat_v2_clone(llama_sampler const*)
|
monkey531[P]llama/src/llama-sampling.cpp
|
static struct llama_sampler * llama_sampler_mirostat_v2_clone(const struct llama_sampler * smpl) {
const auto * ctx = (const llama_sampler_mirostat_v2 *) smpl->ctx;
auto * result = llama_sampler_init_mirostat_v2(ctx->seed, ctx->tau, ctx->eta);
// copy the state
{
auto * result_ctx = (llama_sampler_mirostat_v2 *) result->ctx;
result_ctx->mu = ctx->mu;
result_ctx->rng = ctx->rng;
}
return result;
}
|
O3
|
cpp
|
llama_sampler_mirostat_v2_clone(llama_sampler const*):
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
movl (%rbx), %edi
movss 0x8(%rbx), %xmm0
movss 0xc(%rbx), %xmm1
callq 0x6ac00
movq %rax, %r14
movq 0x8(%rax), %rdi
movss 0x10(%rbx), %xmm0
movss %xmm0, 0x10(%rdi)
addq $0x18, %rbx
addq $0x18, %rdi
movl $0x1388, %edx # imm = 0x1388
movq %rbx, %rsi
callq 0x67420
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_ZL31llama_sampler_mirostat_v2_clonePK13llama_sampler:
push r14
push rbx
push rax
mov rbx, [rdi+8]
mov edi, [rbx]
movss xmm0, dword ptr [rbx+8]
movss xmm1, dword ptr [rbx+0Ch]
call _llama_sampler_init_mirostat_v2
mov r14, rax
mov rdi, [rax+8]
movss xmm0, dword ptr [rbx+10h]
movss dword ptr [rdi+10h], xmm0
add rbx, 18h
add rdi, 18h
mov edx, 1388h
mov rsi, rbx
call _memcpy
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
|
_QWORD * llama_sampler_mirostat_v2_clone(long long a1)
{
float *v1; // rbx
_QWORD *inited; // r14
long long v3; // rdi
v1 = *(float **)(a1 + 8);
inited = llama_sampler_init_mirostat_v2(
(std::chrono::_V2::system_clock *)*(unsigned int *)v1,
COERCE_DOUBLE((unsigned long long)*((_DWORD *)v1 + 2)),
v1[3]);
v3 = inited[1];
*(float *)(v3 + 16) = v1[4];
memcpy(v3 + 24, v1 + 6, 5000LL);
return inited;
}
|
llama_sampler_mirostat_v2_clone:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,qword ptr [RDI + 0x8]
MOV EDI,dword ptr [RBX]
MOVSS XMM0,dword ptr [RBX + 0x8]
MOVSS XMM1,dword ptr [RBX + 0xc]
CALL 0x0016ac00
MOV R14,RAX
MOV RDI,qword ptr [RAX + 0x8]
MOVSS XMM0,dword ptr [RBX + 0x10]
MOVSS dword ptr [RDI + 0x10],XMM0
ADD RBX,0x18
ADD RDI,0x18
MOV EDX,0x1388
MOV RSI,RBX
CALL 0x00167420
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* llama_sampler_mirostat_v2_clone(llama_sampler const*) */
long llama_sampler_mirostat_v2_clone(llama_sampler *param_1)
{
int4 *puVar1;
long lVar2;
long lVar3;
puVar1 = *(int4 **)(param_1 + 8);
lVar3 = llama_sampler_init_mirostat_v2(puVar1[2],puVar1[3],*puVar1);
lVar2 = *(long *)(lVar3 + 8);
*(int4 *)(lVar2 + 0x10) = puVar1[4];
memcpy((void *)(lVar2 + 0x18),puVar1 + 6,5000);
return lVar3;
}
|
|
19,740
|
my_utf16_uni
|
eloqsql/strings/ctype-ucs2.c
|
int
my_utf16_uni(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
return my_mb_wc_utf16_quick(pwc, s, e);
}
|
O3
|
c
|
my_utf16_uni:
pushq %rbp
movq %rsp, %rbp
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x68f60
movzbl (%rdx), %edi
movl %edi, %r9d
andl $-0x4, %r9d
xorl %eax, %eax
cmpl $0xdc, %r9d
je 0x68f60
cmpl $0xd8, %r9d
jne 0x68f4d
leaq 0x4(%rdx), %r9
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rcx, %r9
ja 0x68f60
movzbl (%r8), %ecx
movl %ecx, %r8d
andl $-0x4, %r8d
movl $0x0, %eax
cmpl $0xdc, %r8d
jne 0x68f60
shll $0x12, %edi
shll $0x8, %ecx
orl %edi, %ecx
movzbl 0x1(%rdx), %eax
shll $0xa, %eax
movzbl 0x3(%rdx), %edx
andl $0xc0300, %ecx # imm = 0xC0300
orl %edx, %ecx
addl %eax, %ecx
addl $0x10000, %ecx # imm = 0x10000
movl $0x4, %eax
jmp 0x68f5b
shll $0x8, %edi
movzbl 0x1(%rdx), %ecx
orl %edi, %ecx
movl $0x2, %eax
movl %ecx, %ecx
movq %rcx, (%rsi)
popq %rbp
retq
|
my_utf16_uni:
push rbp
mov rbp, rsp
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja loc_68F60
movzx edi, byte ptr [rdx]
mov r9d, edi
and r9d, 0FFFFFFFCh
xor eax, eax
cmp r9d, 0DCh
jz short loc_68F60
cmp r9d, 0D8h
jnz short loc_68F4D
lea r9, [rdx+4]
mov eax, 0FFFFFF98h
cmp r9, rcx
ja short loc_68F60
movzx ecx, byte ptr [r8]
mov r8d, ecx
and r8d, 0FFFFFFFCh
mov eax, 0
cmp r8d, 0DCh
jnz short loc_68F60
shl edi, 12h
shl ecx, 8
or ecx, edi
movzx eax, byte ptr [rdx+1]
shl eax, 0Ah
movzx edx, byte ptr [rdx+3]
and ecx, 0C0300h
or ecx, edx
add ecx, eax
add ecx, 10000h
mov eax, 4
jmp short loc_68F5B
loc_68F4D:
shl edi, 8
movzx ecx, byte ptr [rdx+1]
or ecx, edi
mov eax, 2
loc_68F5B:
mov ecx, ecx
mov [rsi], rcx
loc_68F60:
pop rbp
retn
|
long long my_utf16_uni(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
_BYTE *v4; // r8
long long result; // rax
int v6; // edi
int v7; // r9d
unsigned int v8; // ecx
v4 = a3 + 2;
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = *a3;
v7 = v6 & 0xFC;
result = 0LL;
if ( v7 != 220 )
{
if ( v7 != 216 )
{
v8 = (v6 << 8) | a3[1];
result = 2LL;
goto LABEL_8;
}
result = 4294967192LL;
if ( (unsigned long long)(a3 + 4) <= a4 )
{
result = 0LL;
if ( (*v4 & 0xFC) == 0xDC )
{
v8 = (a3[1] << 10) + (a3[3] | ((v6 << 18) | ((unsigned __int8)*v4 << 8)) & 0xC0300) + 0x10000;
result = 4LL;
LABEL_8:
*a2 = v8;
}
}
}
}
return result;
}
|
my_utf16_uni:
PUSH RBP
MOV RBP,RSP
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x00168f60
MOVZX EDI,byte ptr [RDX]
MOV R9D,EDI
AND R9D,0xfffffffc
XOR EAX,EAX
CMP R9D,0xdc
JZ 0x00168f60
CMP R9D,0xd8
JNZ 0x00168f4d
LEA R9,[RDX + 0x4]
MOV EAX,0xffffff98
CMP R9,RCX
JA 0x00168f60
MOVZX ECX,byte ptr [R8]
MOV R8D,ECX
AND R8D,0xfffffffc
MOV EAX,0x0
CMP R8D,0xdc
JNZ 0x00168f60
SHL EDI,0x12
SHL ECX,0x8
OR ECX,EDI
MOVZX EAX,byte ptr [RDX + 0x1]
SHL EAX,0xa
MOVZX EDX,byte ptr [RDX + 0x3]
AND ECX,0xc0300
OR ECX,EDX
ADD ECX,EAX
ADD ECX,0x10000
MOV EAX,0x4
JMP 0x00168f5b
LAB_00168f4d:
SHL EDI,0x8
MOVZX ECX,byte ptr [RDX + 0x1]
OR ECX,EDI
MOV EAX,0x2
LAB_00168f5b:
MOV ECX,ECX
MOV qword ptr [RSI],RCX
LAB_00168f60:
POP RBP
RET
|
int8 my_utf16_uni(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
byte bVar2;
int8 uVar3;
uint uVar4;
uVar3 = 0xffffff9a;
if (param_3 + 2 <= param_4) {
bVar1 = *param_3;
uVar3 = 0;
if ((bVar1 & 0xfc) != 0xdc) {
if ((bVar1 & 0xfc) == 0xd8) {
if (param_4 < param_3 + 4) {
return 0xffffff98;
}
bVar2 = param_3[2];
if ((bVar2 & 0xfc) != 0xdc) {
return 0;
}
uVar4 = (((uint)bVar2 << 8 | (uint)bVar1 << 0x12) & 0xc0300 | (uint)param_3[3]) +
(uint)param_3[1] * 0x400 + 0x10000;
uVar3 = 4;
}
else {
uVar4 = (uint)CONCAT11(bVar1,param_3[1]);
uVar3 = 2;
}
*param_2 = (ulong)uVar4;
}
}
return uVar3;
}
|
|
19,741
|
ps_fetch_datetime
|
eloqsql/libmariadb/libmariadb/ma_stmt_codec.c
|
static
void ps_fetch_datetime(MYSQL_BIND *r_param, const MYSQL_FIELD * field,
unsigned char **row)
{
MYSQL_TIME *t= (MYSQL_TIME *)r_param->buffer;
unsigned int len= net_field_length(row);
switch (r_param->buffer_type) {
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
convert_to_datetime(t, row, len, field->type);
break;
case MYSQL_TYPE_DATE:
convert_to_datetime(t, row, len, field->type);
break;
case MYSQL_TYPE_TIME:
convert_to_datetime(t, row, len, field->type);
t->year= t->day= t->month= 0;
break;
case MYSQL_TYPE_YEAR:
{
MYSQL_TIME tm;
convert_to_datetime(&tm, row, len, field->type);
shortstore(r_param->buffer, tm.year);
break;
}
default:
{
char dtbuffer[60];
MYSQL_TIME tm;
size_t length;
convert_to_datetime(&tm, row, len, field->type);
switch(field->type) {
case MYSQL_TYPE_DATE:
length= sprintf(dtbuffer, "%04u-%02u-%02u", tm.year, tm.month, tm.day);
break;
case MYSQL_TYPE_TIME:
length= sprintf(dtbuffer, "%s%02u:%02u:%02u", (tm.neg ? "-" : ""), tm.hour, tm.minute, tm.second);
if (field->decimals && field->decimals <= 6)
{
char ms[8];
sprintf(ms, ".%06lu", tm.second_part);
if (field->decimals < 6)
ms[field->decimals + 1]= 0;
length+= strlen(ms);
strcat(dtbuffer, ms);
}
break;
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
length= sprintf(dtbuffer, "%04u-%02u-%02u %02u:%02u:%02u", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second);
if (field->decimals && field->decimals <= 6)
{
char ms[8];
sprintf(ms, ".%06lu", tm.second_part);
if (field->decimals < 6)
ms[field->decimals + 1]= 0;
length+= strlen(ms);
strcat(dtbuffer, ms);
}
break;
default:
dtbuffer[0]= 0;
length= 0;
break;
}
convert_froma_string(r_param, dtbuffer, length);
break;
}
}
(*row) += len;
}
|
O3
|
c
|
ps_fetch_datetime:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rdi), %r13
movq %rdx, %rdi
callq 0x158cd
movq %rax, %r14
movl 0x60(%r15), %eax
addl $-0x7, %eax
cmpl $0x6, %eax
ja 0x240d8
leaq 0x140d1(%rip), %rcx # 0x38188
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x70(%r12), %ecx
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x24cad
jmp 0x242d7
movl 0x70(%r12), %r13d
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %r13d, %ecx
callq 0x24cad
addl $-0x7, %r13d
cmpl $0x5, %r13d
ja 0x242c1
leaq 0x1409d(%rip), %rax # 0x381a4
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl -0xa0(%rbp), %r8d
movl -0x9c(%rbp), %r9d
movl -0x98(%rbp), %eax
movq %rax, -0xa8(%rbp)
movl -0x94(%rbp), %r11d
movl -0x90(%rbp), %r13d
movl -0x8c(%rbp), %r10d
leaq 0x10ccb(%rip), %rcx # 0x34e12
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movl $0x1, %esi
xorl %eax, %eax
pushq %r10
pushq %r13
pushq %r11
pushq -0xa8(%rbp)
callq 0x132a0
addq $0x20, %rsp
jmp 0x24215
movl 0x70(%r12), %ecx
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x24cad
movl $0x0, 0x8(%r13)
movq $0x0, (%r13)
jmp 0x242d7
movl 0x70(%r12), %ecx
leaq -0x70(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x24cad
movl (%r12), %eax
movq 0x10(%r15), %rcx
movb %al, (%rcx)
movq 0x10(%r15), %rcx
movb %ah, 0x1(%rcx)
jmp 0x242d7
cmpb $0x0, -0x80(%rbp)
leaq 0x1046e(%rip), %rax # 0x3463f
leaq 0x10307(%rip), %r8 # 0x344df
cmoveq %rax, %r8
movl -0x94(%rbp), %r9d
movl -0x90(%rbp), %r10d
movl -0x8c(%rbp), %r11d
leaq 0x10c02(%rip), %rcx # 0x34dfa
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movl $0x1, %esi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x132a0
addq $0x10, %rsp
movslq %eax, %r13
movl 0x68(%r12), %eax
decl %eax
cmpl $0x5, %eax
ja 0x242c8
movq -0x88(%rbp), %r8
leaq 0x10bd5(%rip), %rcx # 0x34e0b
leaq -0x78(%rbp), %rdi
movl $0x8, %edx
movl $0x1, %esi
xorl %eax, %eax
callq 0x132a0
movl 0x68(%r12), %eax
cmpq $0x5, %rax
ja 0x2425f
leaq -0x78(%rbp), %rcx
movb $0x0, 0x1(%rax,%rcx)
leaq -0x78(%rbp), %r12
movq %r12, %rdi
callq 0x131c0
addq %rax, %r13
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movq %r12, %rsi
callq 0x13450
jmp 0x242c8
movl -0xa0(%rbp), %r8d
movl -0x9c(%rbp), %r9d
movl -0x98(%rbp), %r10d
subq $0x8, %rsp
leaq 0x10b4a(%rip), %rcx # 0x34deb
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movl $0x1, %esi
xorl %eax, %eax
pushq %r10
callq 0x132a0
addq $0x10, %rsp
movslq %eax, %r13
jmp 0x242c8
movb $0x0, -0x70(%rbp)
xorl %r13d, %r13d
leaq -0x70(%rbp), %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0x247dd
movl %r14d, %eax
addq %rax, (%rbx)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x242fe
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
|
ps_fetch_datetime:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov rbx, rdx
mov r12, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r13, [rdi+10h]
mov rdi, rdx
call net_field_length
mov r14, rax
mov eax, [r15+60h]
add eax, 0FFFFFFF9h; switch 7 cases
cmp eax, 6
ja short def_240BE; jumptable 00000000000240BE default case, cases 8,9
lea rcx, jpt_240BE
movsxd rax, ds:(jpt_240BE - 38188h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_240C0:
mov ecx, [r12+70h]; jumptable 00000000000240BE cases 7,10,12
mov rdi, r13
mov rsi, rbx
mov edx, r14d
call convert_to_datetime
jmp loc_242D7
def_240BE:
mov r13d, [r12+70h]; jumptable 00000000000240BE default case, cases 8,9
lea rdi, [rbp+var_A0]
mov rsi, rbx
mov edx, r14d
mov ecx, r13d
call convert_to_datetime
add r13d, 0FFFFFFF9h; switch 6 cases
cmp r13d, 5
ja def_2410E; jumptable 000000000002410E default case, cases 8,9
lea rax, jpt_2410E
movsxd rcx, ds:(jpt_2410E - 381A4h)[rax+r13*4]
add rcx, rax
jmp rcx; switch jump
loc_24110:
mov r8d, [rbp+var_A0]; jumptable 000000000002410E cases 7,12
mov r9d, [rbp+var_9C]
mov eax, [rbp+var_98]
mov [rbp+var_A8], rax
mov r11d, [rbp+var_94]
mov r13d, [rbp+var_90]
mov r10d, [rbp+var_8C]
lea rcx, a04u02u02u02u02; "%04u-%02u-%02u %02u:%02u:%02u"
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov esi, 1
xor eax, eax
push r10
push r13
push r11
push [rbp+var_A8]
call ___sprintf_chk
add rsp, 20h
jmp loc_24215
loc_24171:
mov ecx, [r12+70h]; jumptable 00000000000240BE case 11
mov rdi, r13
mov rsi, rbx
mov edx, r14d
call convert_to_datetime
mov dword ptr [r13+8], 0
mov qword ptr [r13+0], 0
jmp loc_242D7
loc_24199:
mov ecx, [r12+70h]; jumptable 00000000000240BE case 13
lea r12, [rbp+var_70]
mov rdi, r12
mov rsi, rbx
mov edx, r14d
call convert_to_datetime
mov eax, [r12]
mov rcx, [r15+10h]
mov [rcx], al
mov rcx, [r15+10h]
mov [rcx+1], ah
jmp loc_242D7
loc_241C6:
cmp [rbp+var_80], 0; jumptable 000000000002410E case 11
lea rax, aExecuteTestWit+29h; ""
lea r8, asc_344CC+13h; "-"
cmovz r8, rax
mov r9d, [rbp+var_94]
mov r10d, [rbp+var_90]
mov r11d, [rbp+var_8C]
lea rcx, aS02u02u02u; "%s%02u:%02u:%02u"
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov esi, 1
xor eax, eax
push r11
push r10
call ___sprintf_chk
add rsp, 10h
loc_24215:
movsxd r13, eax
mov eax, [r12+68h]
dec eax
cmp eax, 5
ja loc_242C8
mov r8, [rbp+var_88]
lea rcx, a06lu; ".%06lu"
lea rdi, [rbp+var_78]
mov edx, 8
mov esi, 1
xor eax, eax
call ___sprintf_chk
mov eax, [r12+68h]
cmp rax, 5
ja short loc_2425F
lea rcx, [rbp+var_78]
mov byte ptr [rax+rcx+1], 0
loc_2425F:
lea r12, [rbp+var_78]
mov rdi, r12
call _strlen
add r13, rax
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov rsi, r12
call ___strcat_chk
jmp short loc_242C8
loc_24281:
mov r8d, [rbp+var_A0]; jumptable 000000000002410E case 10
mov r9d, [rbp+var_9C]
mov r10d, [rbp+var_98]
sub rsp, 8
lea rcx, a04u02u02u; "%04u-%02u-%02u"
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov esi, 1
xor eax, eax
push r10
call ___sprintf_chk
add rsp, 10h
movsxd r13, eax
jmp short loc_242C8
def_2410E:
mov [rbp+var_70], 0; jumptable 000000000002410E default case, cases 8,9
xor r13d, r13d
loc_242C8:
lea rsi, [rbp+var_70]
mov rdi, r15
mov rdx, r13
call convert_froma_string
loc_242D7:
mov eax, r14d
add [rbx], rax
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_242FE
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_242FE:
call ___stack_chk_fail
|
unsigned long long ps_fetch_datetime(long long a1, long long a2, unsigned __int8 **a3)
{
long long v4; // r13
unsigned int v5; // r14d
unsigned int v6; // r13d
int v7; // eax
char v8; // ah
const char *v9; // r8
long long v10; // r13
unsigned long long v11; // rax
int v13; // [rsp+10h] [rbp-A0h] BYREF
int v14; // [rsp+14h] [rbp-9Ch]
int v15; // [rsp+18h] [rbp-98h]
int v16; // [rsp+1Ch] [rbp-94h]
int v17; // [rsp+20h] [rbp-90h]
int v18; // [rsp+24h] [rbp-8Ch]
long long v19; // [rsp+28h] [rbp-88h]
char v20; // [rsp+30h] [rbp-80h]
_BYTE v21[8]; // [rsp+38h] [rbp-78h] BYREF
_BYTE v22[64]; // [rsp+40h] [rbp-70h] BYREF
unsigned long long v23; // [rsp+80h] [rbp-30h]
v23 = __readfsqword(0x28u);
v4 = *(_QWORD *)(a1 + 16);
v5 = net_field_length(a3);
switch ( *(_DWORD *)(a1 + 96) )
{
case 7:
case 0xA:
case 0xC:
convert_to_datetime(v4, a3, v5, *(unsigned int *)(a2 + 112));
break;
case 0xB:
convert_to_datetime(v4, a3, v5, *(unsigned int *)(a2 + 112));
*(_DWORD *)(v4 + 8) = 0;
*(_QWORD *)v4 = 0LL;
break;
case 0xD:
convert_to_datetime(v22, a3, v5, *(unsigned int *)(a2 + 112));
v8 = v22[1];
**(_BYTE **)(a1 + 16) = v22[0];
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 1LL) = v8;
break;
default:
v6 = *(_DWORD *)(a2 + 112);
convert_to_datetime(&v13, a3, v5, v6);
switch ( v6 )
{
case 7u:
case 0xCu:
v7 = __sprintf_chk(v22, 1LL, 60LL, "%04u-%02u-%02u %02u:%02u:%02u", v13, v14, v15, v16, v17, v18);
goto LABEL_10;
case 0xAu:
v10 = (int)__sprintf_chk(v22, 1LL, 60LL, "%04u-%02u-%02u", v13, v14, v15);
break;
case 0xBu:
v9 = "-";
if ( !v20 )
v9 = "";
v7 = __sprintf_chk(v22, 1LL, 60LL, "%s%02u:%02u:%02u", v9, v16, v17, v18);
LABEL_10:
v10 = v7;
if ( (unsigned int)(*(_DWORD *)(a2 + 104) - 1) <= 5 )
{
__sprintf_chk(v21, 1LL, 8LL, ".%06lu", v19);
v11 = *(unsigned int *)(a2 + 104);
if ( v11 <= 5 )
v21[v11 + 1] = 0;
v10 += strlen(v21);
__strcat_chk(v22, v21, 60LL);
}
break;
default:
v22[0] = 0;
v10 = 0LL;
break;
}
convert_froma_string(a1, v22, v10);
break;
}
*a3 += v5;
return __readfsqword(0x28u);
}
|
ps_fetch_datetime:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV RBX,RDX
MOV R12,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R13,qword ptr [RDI + 0x10]
MOV RDI,RDX
CALL 0x001158cd
MOV R14,RAX
MOV EAX,dword ptr [R15 + 0x60]
ADD EAX,-0x7
CMP EAX,0x6
JA 0x001240d8
LEA RCX,[0x138188]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_7:
MOV ECX,dword ptr [R12 + 0x70]
MOV RDI,R13
MOV RSI,RBX
MOV EDX,R14D
CALL 0x00124cad
JMP 0x001242d7
caseD_8:
MOV R13D,dword ptr [R12 + 0x70]
LEA RDI,[RBP + -0xa0]
MOV RSI,RBX
MOV EDX,R14D
MOV ECX,R13D
CALL 0x00124cad
ADD R13D,-0x7
CMP R13D,0x5
JA 0x001242c1
LEA RAX,[0x1381a4]
MOVSXD RCX,dword ptr [RAX + R13*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_7:
MOV R8D,dword ptr [RBP + -0xa0]
MOV R9D,dword ptr [RBP + -0x9c]
MOV EAX,dword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0xa8],RAX
MOV R11D,dword ptr [RBP + -0x94]
MOV R13D,dword ptr [RBP + -0x90]
MOV R10D,dword ptr [RBP + -0x8c]
LEA RCX,[0x134e12]
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV ESI,0x1
XOR EAX,EAX
PUSH R10
PUSH R13
PUSH R11
PUSH qword ptr [RBP + -0xa8]
CALL 0x001132a0
ADD RSP,0x20
JMP 0x00124215
caseD_b:
MOV ECX,dword ptr [R12 + 0x70]
MOV RDI,R13
MOV RSI,RBX
MOV EDX,R14D
CALL 0x00124cad
MOV dword ptr [R13 + 0x8],0x0
MOV qword ptr [R13],0x0
JMP 0x001242d7
caseD_d:
MOV ECX,dword ptr [R12 + 0x70]
LEA R12,[RBP + -0x70]
MOV RDI,R12
MOV RSI,RBX
MOV EDX,R14D
CALL 0x00124cad
MOV EAX,dword ptr [R12]
MOV RCX,qword ptr [R15 + 0x10]
MOV byte ptr [RCX],AL
MOV RCX,qword ptr [R15 + 0x10]
MOV byte ptr [RCX + 0x1],AH
JMP 0x001242d7
caseD_b:
CMP byte ptr [RBP + -0x80],0x0
LEA RAX,[0x13463f]
LEA R8,[0x1344df]
CMOVZ R8,RAX
MOV R9D,dword ptr [RBP + -0x94]
MOV R10D,dword ptr [RBP + -0x90]
MOV R11D,dword ptr [RBP + -0x8c]
LEA RCX,[0x134dfa]
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV ESI,0x1
XOR EAX,EAX
PUSH R11
PUSH R10
CALL 0x001132a0
ADD RSP,0x10
LAB_00124215:
MOVSXD R13,EAX
MOV EAX,dword ptr [R12 + 0x68]
DEC EAX
CMP EAX,0x5
JA 0x001242c8
MOV R8,qword ptr [RBP + -0x88]
LEA RCX,[0x134e0b]
LEA RDI,[RBP + -0x78]
MOV EDX,0x8
MOV ESI,0x1
XOR EAX,EAX
CALL 0x001132a0
MOV EAX,dword ptr [R12 + 0x68]
CMP RAX,0x5
JA 0x0012425f
LEA RCX,[RBP + -0x78]
MOV byte ptr [RAX + RCX*0x1 + 0x1],0x0
LAB_0012425f:
LEA R12,[RBP + -0x78]
MOV RDI,R12
CALL 0x001131c0
ADD R13,RAX
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV RSI,R12
CALL 0x00113450
JMP 0x001242c8
caseD_a:
MOV R8D,dword ptr [RBP + -0xa0]
MOV R9D,dword ptr [RBP + -0x9c]
MOV R10D,dword ptr [RBP + -0x98]
SUB RSP,0x8
LEA RCX,[0x134deb]
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV ESI,0x1
XOR EAX,EAX
PUSH R10
CALL 0x001132a0
ADD RSP,0x10
MOVSXD R13,EAX
JMP 0x001242c8
caseD_8:
MOV byte ptr [RBP + -0x70],0x0
XOR R13D,R13D
LAB_001242c8:
LEA RSI,[RBP + -0x70]
MOV RDI,R15
MOV RDX,R13
CALL 0x001247dd
LAB_001242d7:
MOV EAX,R14D
ADD qword ptr [RBX],RAX
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001242fe
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001242fe:
CALL 0x00113500
|
void ps_fetch_datetime(long param_1,long param_2,long *param_3)
{
int4 uVar1;
int8 *puVar2;
uint uVar3;
int iVar4;
size_t sVar5;
char *pcVar6;
long lVar7;
long in_FS_OFFSET;
int4 local_a8;
int4 local_a4;
int4 local_a0;
int4 local_9c;
int4 local_98;
int4 local_94;
int8 local_90;
char local_88;
char local_80;
int1 auStack_7f [7];
uint local_78 [16];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
puVar2 = *(int8 **)(param_1 + 0x10);
uVar3 = net_field_length(param_3);
switch(*(int4 *)(param_1 + 0x60)) {
case 7:
case 10:
case 0xc:
convert_to_datetime(puVar2,param_3,uVar3,*(int4 *)(param_2 + 0x70));
break;
default:
uVar1 = *(int4 *)(param_2 + 0x70);
convert_to_datetime(&local_a8,param_3,uVar3,uVar1);
switch(uVar1) {
case 7:
case 0xc:
iVar4 = __sprintf_chk(local_78,1,0x3c,"%04u-%02u-%02u %02u:%02u:%02u",local_a8,local_a4,
local_a0,local_9c,local_98,local_94);
goto LAB_00124215;
default:
local_78[0] = local_78[0] & 0xffffff00;
lVar7 = 0;
break;
case 10:
iVar4 = __sprintf_chk(local_78,1,0x3c,"%04u-%02u-%02u",local_a8,local_a4,local_a0);
lVar7 = (long)iVar4;
break;
case 0xb:
pcVar6 = "-";
if (local_88 == '\0') {
pcVar6 = "";
}
iVar4 = __sprintf_chk(local_78,1,0x3c,"%s%02u:%02u:%02u",pcVar6,local_9c,local_98,local_94);
LAB_00124215:
lVar7 = (long)iVar4;
if (*(int *)(param_2 + 0x68) - 1U < 6) {
__sprintf_chk(&local_80,1,8,".%06lu",local_90);
if ((ulong)*(uint *)(param_2 + 0x68) < 6) {
auStack_7f[*(uint *)(param_2 + 0x68)] = 0;
}
sVar5 = strlen(&local_80);
lVar7 = lVar7 + sVar5;
__strcat_chk(local_78,&local_80,0x3c);
}
}
convert_froma_string(param_1,local_78,lVar7);
break;
case 0xb:
convert_to_datetime(puVar2,param_3,uVar3,*(int4 *)(param_2 + 0x70));
*(int4 *)(puVar2 + 1) = 0;
*puVar2 = 0;
break;
case 0xd:
convert_to_datetime(local_78,param_3,uVar3,*(int4 *)(param_2 + 0x70));
**(int1 **)(param_1 + 0x10) = (char)local_78[0];
*(char *)(*(long *)(param_1 + 0x10) + 1) = (char)(local_78[0] >> 8);
}
*param_3 = *param_3 + (ulong)uVar3;
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
19,742
|
js_resolve_export_throw_error
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_resolve_export_throw_error(JSContext *ctx,
JSResolveResultEnum res,
JSModuleDef *m, JSAtom export_name)
{
char buf1[ATOM_GET_STR_BUF_SIZE];
char buf2[ATOM_GET_STR_BUF_SIZE];
switch(res) {
case JS_RESOLVE_RES_EXCEPTION:
break;
default:
case JS_RESOLVE_RES_NOT_FOUND:
JS_ThrowSyntaxError(ctx, "Could not find export '%s' in module '%s'",
JS_AtomGetStr(ctx, buf1, sizeof(buf1), export_name),
JS_AtomGetStr(ctx, buf2, sizeof(buf2), m->module_name));
break;
case JS_RESOLVE_RES_CIRCULAR:
JS_ThrowSyntaxError(ctx, "circular reference when looking for export '%s' in module '%s'",
JS_AtomGetStr(ctx, buf1, sizeof(buf1), export_name),
JS_AtomGetStr(ctx, buf2, sizeof(buf2), m->module_name));
break;
case JS_RESOLVE_RES_AMBIGUOUS:
JS_ThrowSyntaxError(ctx, "export '%s' in module '%s' is ambiguous",
JS_AtomGetStr(ctx, buf1, sizeof(buf1), export_name),
JS_AtomGetStr(ctx, buf2, sizeof(buf2), m->module_name));
break;
}
}
|
O1
|
c
|
js_resolve_export_throw_error:
cmpl $-0x1, %esi
je 0x43869
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x3, %esi
je 0x43815
cmpl $0x2, %esi
jne 0x4381e
leaq 0x5bf68(%rip), %r15 # 0x9f77b
jmp 0x43825
leaq 0x5bf9e(%rip), %r15 # 0x9f7ba
jmp 0x43825
leaq 0x5bf2c(%rip), %r15 # 0x9f751
movq 0x18(%rbx), %rdi
leaq 0x40(%rsp), %rsi
movl %ecx, %edx
callq 0x221f0
movq %rax, %r12
movl 0x4(%r14), %edx
movq 0x18(%rbx), %rdi
movq %rsp, %rsi
callq 0x221f0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x224d1
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
js_resolve_export_throw_error:
cmp esi, 0FFFFFFFFh
jz short locret_43869
push r15
push r14
push r12
push rbx
sub rsp, 88h
mov r14, rdx
mov rbx, rdi
cmp esi, 3
jz short loc_43815
cmp esi, 2
jnz short loc_4381E
lea r15, aCircularRefere_0; "circular reference when looking for exp"...
jmp short loc_43825
loc_43815:
lea r15, aExportSInModul; "export '%s' in module '%s' is ambiguous"
jmp short loc_43825
loc_4381E:
lea r15, aCouldNotFindEx; "Could not find export '%s' in module '%"...
loc_43825:
mov rdi, [rbx+18h]
lea rsi, [rsp+0A8h+var_68]
mov edx, ecx
call JS_AtomGetStrRT
mov r12, rax
mov edx, [r14+4]
mov rdi, [rbx+18h]
mov rsi, rsp
call JS_AtomGetStrRT
mov rdi, rbx
mov rsi, r15
mov rdx, r12
mov rcx, rax
xor eax, eax
call JS_ThrowSyntaxError
add rsp, 88h
pop rbx
pop r12
pop r14
pop r15
locret_43869:
retn
|
void js_resolve_export_throw_error(
long long a1,
int a2,
long long a3,
int a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
const char *v13; // r15
unsigned long long StrRT; // r12
unsigned long long v15; // rax
long long v16; // r8
long long v17; // r9
__m128 v18; // xmm4
__m128 v19; // xmm5
char v20; // [rsp-40h] [rbp-A8h] BYREF
char v21[104]; // [rsp+0h] [rbp-68h] BYREF
if ( a2 != -1 )
{
if ( a2 == 3 )
{
v13 = "export '%s' in module '%s' is ambiguous";
}
else if ( a2 == 2 )
{
v13 = "circular reference when looking for export '%s' in module '%s'";
}
else
{
v13 = "Could not find export '%s' in module '%s'";
}
StrRT = JS_AtomGetStrRT(*(_QWORD *)(a1 + 24), v21, a4);
v15 = JS_AtomGetStrRT(*(_QWORD *)(a1 + 24), &v20, *(_DWORD *)(a3 + 4));
JS_ThrowSyntaxError(a1, (long long)v13, StrRT, v15, v16, v17, a5, a6, a7, a8, v18, v19, a11, a12, v20);
}
}
| |||
19,743
|
js_resolve_export_throw_error
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_resolve_export_throw_error(JSContext *ctx,
JSResolveResultEnum res,
JSModuleDef *m, JSAtom export_name)
{
char buf1[ATOM_GET_STR_BUF_SIZE];
char buf2[ATOM_GET_STR_BUF_SIZE];
switch(res) {
case JS_RESOLVE_RES_EXCEPTION:
break;
default:
case JS_RESOLVE_RES_NOT_FOUND:
JS_ThrowSyntaxError(ctx, "Could not find export '%s' in module '%s'",
JS_AtomGetStr(ctx, buf1, sizeof(buf1), export_name),
JS_AtomGetStr(ctx, buf2, sizeof(buf2), m->module_name));
break;
case JS_RESOLVE_RES_CIRCULAR:
JS_ThrowSyntaxError(ctx, "circular reference when looking for export '%s' in module '%s'",
JS_AtomGetStr(ctx, buf1, sizeof(buf1), export_name),
JS_AtomGetStr(ctx, buf2, sizeof(buf2), m->module_name));
break;
case JS_RESOLVE_RES_AMBIGUOUS:
JS_ThrowSyntaxError(ctx, "export '%s' in module '%s' is ambiguous",
JS_AtomGetStr(ctx, buf1, sizeof(buf1), export_name),
JS_AtomGetStr(ctx, buf2, sizeof(buf2), m->module_name));
break;
}
}
|
O2
|
c
|
js_resolve_export_throw_error:
cmpl $-0x1, %esi
je 0x3b421
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x3, %esi
je 0x3b3cf
cmpl $0x2, %esi
jne 0x3b3d8
leaq 0x4b2fe(%rip), %r15 # 0x866cb
jmp 0x3b3df
leaq 0x4b334(%rip), %r15 # 0x8670a
jmp 0x3b3df
leaq 0x4b2c2(%rip), %r15 # 0x866a1
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
movl %ecx, %edx
callq 0x2f335
movq %rax, %r12
movl 0x4(%r14), %edx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2f335
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1c5bb
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
js_resolve_export_throw_error:
cmp esi, 0FFFFFFFFh
jz short locret_3B421
push r15
push r14
push r12
push rbx
sub rsp, 88h
mov r14, rdx
mov rbx, rdi
cmp esi, 3
jz short loc_3B3CF
cmp esi, 2
jnz short loc_3B3D8
lea r15, aCircularRefere_0; "circular reference when looking for exp"...
jmp short loc_3B3DF
loc_3B3CF:
lea r15, aExportSInModul; "export '%s' in module '%s' is ambiguous"
jmp short loc_3B3DF
loc_3B3D8:
lea r15, aCouldNotFindEx; "Could not find export '%s' in module '%"...
loc_3B3DF:
lea rsi, [rsp+0A8h+var_68]
mov rdi, rbx
mov edx, ecx
call JS_AtomGetStr
mov r12, rax
mov edx, [r14+4]
mov rsi, rsp
mov rdi, rbx
call JS_AtomGetStr
mov rdi, rbx
mov rsi, r15
mov rdx, r12
mov rcx, rax
xor eax, eax
call JS_ThrowSyntaxError
add rsp, 88h
pop rbx
pop r12
pop r14
pop r15
locret_3B421:
retn
|
void js_resolve_export_throw_error(
long long a1,
int a2,
long long a3,
int a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
const char *v13; // r15
long long Str; // r12
long long v15; // rax
long long v16; // r8
long long v17; // r9
__m128 v18; // xmm4
__m128 v19; // xmm5
char v20; // [rsp-40h] [rbp-A8h] BYREF
char v21[104]; // [rsp+0h] [rbp-68h] BYREF
if ( a2 != -1 )
{
if ( a2 == 3 )
{
v13 = "export '%s' in module '%s' is ambiguous";
}
else if ( a2 == 2 )
{
v13 = "circular reference when looking for export '%s' in module '%s'";
}
else
{
v13 = "Could not find export '%s' in module '%s'";
}
Str = JS_AtomGetStr(a1, v21, a4);
v15 = JS_AtomGetStr(a1, &v20, *(_DWORD *)(a3 + 4));
JS_ThrowSyntaxError(a1, (long long)v13, Str, v15, v16, v17, a5, a6, a7, a8, v18, v19, a11, a12, v20);
}
}
|
js_resolve_export_throw_error:
CMP ESI,-0x1
JZ 0x0013b421
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RDX
MOV RBX,RDI
CMP ESI,0x3
JZ 0x0013b3cf
CMP ESI,0x2
JNZ 0x0013b3d8
LEA R15,[0x1866cb]
JMP 0x0013b3df
LAB_0013b3cf:
LEA R15,[0x18670a]
JMP 0x0013b3df
LAB_0013b3d8:
LEA R15,[0x1866a1]
LAB_0013b3df:
LEA RSI,[RSP + 0x40]
MOV RDI,RBX
MOV EDX,ECX
CALL 0x0012f335
MOV R12,RAX
MOV EDX,dword ptr [R14 + 0x4]
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0012f335
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
MOV RCX,RAX
XOR EAX,EAX
CALL 0x0011c5bb
ADD RSP,0x88
POP RBX
POP R12
POP R14
POP R15
LAB_0013b421:
RET
|
void js_resolve_export_throw_error(int8 param_1,int param_2,long param_3,int4 param_4)
{
int8 uVar1;
int8 uVar2;
char *pcVar3;
int1 auStack_a8 [64];
int1 local_68 [72];
if (param_2 != -1) {
if (param_2 == 3) {
pcVar3 = "export \'%s\' in module \'%s\' is ambiguous";
}
else if (param_2 == 2) {
pcVar3 = "circular reference when looking for export \'%s\' in module \'%s\'";
}
else {
pcVar3 = "Could not find export \'%s\' in module \'%s\'";
}
uVar1 = JS_AtomGetStr(param_1,local_68,param_4);
uVar2 = JS_AtomGetStr(param_1,auStack_a8,*(int4 *)(param_3 + 4));
JS_ThrowSyntaxError(param_1,pcVar3,uVar1,uVar2);
}
return;
}
|
|
19,744
|
JS_EvalThis
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_EvalInternal(JSContext *ctx, JSValue this_obj,
const char *input, size_t input_len,
const char *filename, int flags, int scope_idx)
{
if (unlikely(!ctx->eval_internal)) {
return JS_ThrowTypeError(ctx, "eval is not supported");
}
return ctx->eval_internal(ctx, this_obj, input, input_len, filename,
flags, scope_idx);
}
|
O1
|
c
|
JS_EvalThis:
pushq %rbx
movq 0x1f8(%rdi), %r10
testq %r10, %r10
je 0x3095f
movl %r8d, %eax
movq %rcx, %r9
movq %rdx, %r8
movq %rsi, %rcx
movq 0x1a0(%rdi), %rsi
movq 0x1a8(%rdi), %rdx
pushq $-0x1
pushq %rax
callq *%r10
addq $0x10, %rsp
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
leaq 0x6d7bd(%rip), %rsi # 0x9e123
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x21953
movl $0x6, %edx
jmp 0x3095a
|
JS_Eval:
push rbx
mov r10, [rdi+1F8h]
test r10, r10
jz short loc_3095F
mov eax, r8d
mov r9, rcx
mov r8, rdx
mov rcx, rsi
mov rsi, [rdi+1A0h]
mov rdx, [rdi+1A8h]
push 0FFFFFFFFFFFFFFFFh
push rax
call r10
add rsp, 10h
mov rbx, rax
loc_3095A:
mov rax, rbx
pop rbx
retn
loc_3095F:
lea rsi, aEvalIsNotSuppo; "eval is not supported"
xor ebx, ebx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
jmp short loc_3095A
|
long long JS_Eval(
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long ( *v14)(_QWORD *, _QWORD, _QWORD, long long, long long, long long, _QWORD, long long); // r10
long long v15; // rbx
char v17; // [rsp+0h] [rbp-8h]
v14 = (long long ( *)(_QWORD *, _QWORD, _QWORD, long long, long long, long long, _QWORD, long long))a1[63];
if ( v14 )
return v14(a1, a1[52], a1[53], a2, a3, a4, (unsigned int)a5, -1LL);
v15 = 0LL;
JS_ThrowTypeError(
(long long)a1,
(long long)"eval is not supported",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v17);
return v15;
}
|
JS_Eval:
PUSH RBX
MOV R10,qword ptr [RDI + 0x1f8]
TEST R10,R10
JZ 0x0013095f
MOV EAX,R8D
MOV R9,RCX
MOV R8,RDX
MOV RCX,RSI
MOV RSI,qword ptr [RDI + 0x1a0]
MOV RDX,qword ptr [RDI + 0x1a8]
PUSH -0x1
PUSH RAX
CALL R10
ADD RSP,0x10
MOV RBX,RAX
LAB_0013095a:
MOV RAX,RBX
POP RBX
RET
LAB_0013095f:
LEA RSI,[0x19e123]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x00121953
MOV EDX,0x6
JMP 0x0013095a
|
int8
JS_Eval(long param_1,int8 param_2,int8 param_3,int8 param_4,int4 param_5)
{
int8 uVar1;
if (*(code **)(param_1 + 0x1f8) == (code *)0x0) {
uVar1 = 0;
JS_ThrowTypeError(param_1,"eval is not supported");
}
else {
uVar1 = (**(code **)(param_1 + 0x1f8))
(param_1,*(int8 *)(param_1 + 0x1a0),*(int8 *)(param_1 + 0x1a8),
param_2,param_3,param_4,param_5,0xffffffffffffffff);
}
return uVar1;
}
|
|
19,745
|
JS_EvalThis
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_EvalInternal(JSContext *ctx, JSValue this_obj,
const char *input, size_t input_len,
const char *filename, int flags, int scope_idx)
{
if (unlikely(!ctx->eval_internal)) {
return JS_ThrowTypeError(ctx, "eval is not supported");
}
return ctx->eval_internal(ctx, this_obj, input, input_len, filename,
flags, scope_idx);
}
|
O3
|
c
|
JS_EvalThis:
pushq %rbx
movq 0x1f8(%rdi), %r10
testq %r10, %r10
je 0x31a0f
movl %r8d, %eax
movq %rcx, %r9
movq %rdx, %r8
movq %rsi, %rcx
movq 0x1a0(%rdi), %rsi
movq 0x1a8(%rdi), %rdx
pushq $-0x1
pushq %rax
callq *%r10
addq $0x10, %rsp
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
leaq 0x6f6dd(%rip), %rsi # 0xa10f3
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2214f
movl $0x6, %edx
jmp 0x31a0a
|
JS_Eval:
push rbx
mov r10, [rdi+1F8h]
test r10, r10
jz short loc_31A0F
mov eax, r8d
mov r9, rcx
mov r8, rdx
mov rcx, rsi
mov rsi, [rdi+1A0h]
mov rdx, [rdi+1A8h]
push 0FFFFFFFFFFFFFFFFh
push rax
call r10
add rsp, 10h
mov rbx, rax
loc_31A0A:
mov rax, rbx
pop rbx
retn
loc_31A0F:
lea rsi, aEvalIsNotSuppo; "eval is not supported"
xor ebx, ebx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
jmp short loc_31A0A
|
long long JS_Eval(
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long ( *v14)(_QWORD *, _QWORD, _QWORD, long long, long long, long long, _QWORD, long long); // r10
long long v15; // rbx
char v17; // [rsp+0h] [rbp-8h]
v14 = (long long ( *)(_QWORD *, _QWORD, _QWORD, long long, long long, long long, _QWORD, long long))a1[63];
if ( v14 )
return v14(a1, a1[52], a1[53], a2, a3, a4, (unsigned int)a5, -1LL);
v15 = 0LL;
JS_ThrowTypeError(
(long long)a1,
(long long)"eval is not supported",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v17);
return v15;
}
|
JS_Eval:
PUSH RBX
MOV R10,qword ptr [RDI + 0x1f8]
TEST R10,R10
JZ 0x00131a0f
MOV EAX,R8D
MOV R9,RCX
MOV R8,RDX
MOV RCX,RSI
MOV RSI,qword ptr [RDI + 0x1a0]
MOV RDX,qword ptr [RDI + 0x1a8]
PUSH -0x1
PUSH RAX
CALL R10
ADD RSP,0x10
MOV RBX,RAX
LAB_00131a0a:
MOV RAX,RBX
POP RBX
RET
LAB_00131a0f:
LEA RSI,[0x1a10f3]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x0012214f
MOV EDX,0x6
JMP 0x00131a0a
|
int8
JS_Eval(long param_1,int8 param_2,int8 param_3,int8 param_4,int4 param_5)
{
int8 uVar1;
if (*(code **)(param_1 + 0x1f8) == (code *)0x0) {
uVar1 = 0;
JS_ThrowTypeError(param_1,"eval is not supported");
}
else {
uVar1 = (**(code **)(param_1 + 0x1f8))
(param_1,*(int8 *)(param_1 + 0x1a0),*(int8 *)(param_1 + 0x1a8),
param_2,param_3,param_4,param_5,0xffffffffffffffff);
}
return uVar1;
}
|
|
19,746
|
register_thread_class(char const*, unsigned int, int)
|
eloqsql/storage/perfschema/pfs_instr_class.cc
|
PFS_thread_key register_thread_class(const char *name, uint name_length,
int flags)
{
/* See comments in register_mutex_class */
uint32 index;
PFS_thread_class *entry;
for (index= 0; index < thread_class_max; index++)
{
entry= &thread_class_array[index];
if ((entry->m_name_length == name_length) &&
(strncmp(entry->m_name, name, name_length) == 0))
return (index + 1);
}
index= PFS_atomic::add_u32(&thread_class_dirty_count, 1);
if (index < thread_class_max)
{
entry= &thread_class_array[index];
assert(name_length <= PFS_MAX_INFO_NAME_LENGTH);
strncpy(entry->m_name, name, name_length);
entry->m_name_length= name_length;
entry->m_enabled= true;
PFS_atomic::add_u32(&thread_class_allocated_count, 1);
return (index + 1);
}
if (pfs_enabled)
thread_class_lost++;
return 0;
}
|
O3
|
cpp
|
register_thread_class(char const*, unsigned int, int):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, -0x30(%rbp)
movq 0x3976db(%rip), %r13 # 0x3cd0b0
movl %esi, %r15d
testq %r13, %r13
je 0x35a20
movq 0x397f64(%rip), %r14 # 0x3cd948
movl $0x1, %r12d
xorl %eax, %eax
leaq (%rax,%rax,2), %rdi
shlq $0x6, %rdi
cmpl %ebx, 0x90(%r14,%rdi)
jne 0x35a15
addq %r14, %rdi
addq $0x10, %rdi
movq -0x30(%rbp), %rsi
movq %r15, %rdx
callq 0x26170
testl %eax, %eax
je 0x35a8c
movl %r12d, %eax
incl %r12d
cmpq %rax, %r13
ja 0x359ec
movl $0x1, %r14d
lock
xaddl %r14d, 0x397f15(%rip) # 0x3cd944
cmpq %r14, 0x39767a(%rip) # 0x3cd0b0
jbe 0x35a79
movq 0x397f09(%rip), %rax # 0x3cd948
leaq (%r14,%r14,2), %rcx
shlq $0x6, %rcx
leaq (%rax,%rcx), %r12
addq $0x10, %r12
movq %r12, %rdi
movq -0x30(%rbp), %rsi
movq %r15, %rdx
callq 0x261a0
movl %ebx, 0x80(%r12)
movb $0x1, -0x10(%r12)
lock
incl 0x397ecd(%rip) # 0x3cd940
leal 0x1(%r14), %r12d
jmp 0x35a8c
xorl %r12d, %r12d
cmpb $0x0, 0x2e159d(%rip) # 0x317020
je 0x35a8c
incq 0x39762c(%rip) # 0x3cd0b8
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_Z21register_thread_classPKcji:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, esi
mov [rbp+var_30], rdi
mov r13, cs:thread_class_max
mov r15d, esi
test r13, r13
jz short loc_35A20
mov r14, cs:_ZL18thread_class_array; thread_class_array
mov r12d, 1
xor eax, eax
loc_359EC:
lea rdi, [rax+rax*2]
shl rdi, 6
cmp [r14+rdi+90h], ebx
jnz short loc_35A15
add rdi, r14
add rdi, 10h
mov rsi, [rbp+var_30]
mov rdx, r15
call _strncmp
test eax, eax
jz short loc_35A8C
loc_35A15:
mov eax, r12d
inc r12d
cmp r13, rax
ja short loc_359EC
loc_35A20:
mov r14d, 1
lock xadd cs:_ZL24thread_class_dirty_count, r14d; thread_class_dirty_count
cmp cs:thread_class_max, r14
jbe short loc_35A79
mov rax, cs:_ZL18thread_class_array; thread_class_array
lea rcx, [r14+r14*2]
shl rcx, 6
lea r12, [rax+rcx]
add r12, 10h
mov rdi, r12
mov rsi, [rbp+var_30]
mov rdx, r15
call _strncpy
mov [r12+80h], ebx
mov byte ptr [r12-10h], 1
lock inc cs:_ZL28thread_class_allocated_count; thread_class_allocated_count
lea r12d, [r14+1]
jmp short loc_35A8C
loc_35A79:
xor r12d, r12d
cmp cs:pfs_enabled, 0
jz short loc_35A8C
inc cs:thread_class_lost
loc_35A8C:
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long register_thread_class(const char *a1, unsigned int a2)
{
unsigned long long v2; // r13
long long v3; // r14
unsigned int v4; // r12d
unsigned long long v5; // rax
unsigned long long v6; // r14
long long v7; // r12
v2 = thread_class_max;
if ( thread_class_max )
{
v3 = thread_class_array;
v4 = 1;
v5 = 0LL;
while ( *(_DWORD *)(v3 + 192 * v5 + 144) != a2 || (unsigned int)strncmp(v3 + 192 * v5 + 16, a1, a2) )
{
v5 = v4++;
if ( v2 <= v5 )
goto LABEL_6;
}
}
else
{
LABEL_6:
v6 = (unsigned int)_InterlockedExchangeAdd(&thread_class_dirty_count, 1u);
if ( thread_class_max <= v6 )
{
v4 = 0;
if ( pfs_enabled )
++thread_class_lost;
}
else
{
v7 = thread_class_array + 192 * v6 + 16;
strncpy(v7, a1, a2);
*(_DWORD *)(v7 + 128) = a2;
*(_BYTE *)(v7 - 16) = 1;
_InterlockedIncrement(&thread_class_allocated_count);
return (unsigned int)(v6 + 1);
}
}
return v4;
}
|
register_thread_class:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV qword ptr [RBP + -0x30],RDI
MOV R13,qword ptr [0x004cd0b0]
MOV R15D,ESI
TEST R13,R13
JZ 0x00135a20
MOV R14,qword ptr [0x004cd948]
MOV R12D,0x1
XOR EAX,EAX
LAB_001359ec:
LEA RDI,[RAX + RAX*0x2]
SHL RDI,0x6
CMP dword ptr [R14 + RDI*0x1 + 0x90],EBX
JNZ 0x00135a15
ADD RDI,R14
ADD RDI,0x10
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,R15
CALL 0x00126170
TEST EAX,EAX
JZ 0x00135a8c
LAB_00135a15:
MOV EAX,R12D
INC R12D
CMP R13,RAX
JA 0x001359ec
LAB_00135a20:
MOV R14D,0x1
XADD.LOCK dword ptr [0x004cd944],R14D
CMP qword ptr [0x004cd0b0],R14
JBE 0x00135a79
MOV RAX,qword ptr [0x004cd948]
LEA RCX,[R14 + R14*0x2]
SHL RCX,0x6
LEA R12,[RAX + RCX*0x1]
ADD R12,0x10
MOV RDI,R12
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,R15
CALL 0x001261a0
MOV dword ptr [R12 + 0x80],EBX
MOV byte ptr [R12 + -0x10],0x1
INC.LOCK dword ptr [0x004cd940]
LEA R12D,[R14 + 0x1]
JMP 0x00135a8c
LAB_00135a79:
XOR R12D,R12D
CMP byte ptr [0x00417020],0x0
JZ 0x00135a8c
INC qword ptr [0x004cd0b8]
LAB_00135a8c:
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* register_thread_class(char const*, unsigned int, int) */
ulong register_thread_class(char *param_1,uint param_2,int param_3)
{
int1 *puVar1;
bool bVar2;
uint uVar3;
long lVar4;
int iVar5;
ulong uVar6;
ulong uVar7;
ulong uVar8;
lVar4 = thread_class_array;
uVar8 = thread_class_max;
if (thread_class_max != 0) {
uVar6 = 0;
uVar7 = 1;
do {
if ((*(uint *)(lVar4 + 0x90 + uVar6 * 0xc0) == param_2) &&
(iVar5 = strncmp((char *)(uVar6 * 0xc0 + lVar4 + 0x10),param_1,(ulong)param_2), iVar5 == 0)
) {
return uVar7;
}
bVar2 = uVar7 < uVar8;
uVar6 = uVar7;
uVar7 = (ulong)((int)uVar7 + 1);
} while (bVar2);
}
uVar3 = thread_class_dirty_count;
LOCK();
iVar5 = thread_class_dirty_count + 1;
UNLOCK();
if (thread_class_dirty_count < thread_class_max) {
puVar1 = (int1 *)(thread_class_array + (ulong)thread_class_dirty_count * 0xc0);
thread_class_dirty_count = iVar5;
strncpy(puVar1 + 0x10,param_1,(ulong)param_2);
*(uint *)(puVar1 + 0x90) = param_2;
*puVar1 = 1;
LOCK();
thread_class_allocated_count = thread_class_allocated_count + 1;
UNLOCK();
uVar8 = (ulong)(uVar3 + 1);
}
else {
uVar8 = 0;
thread_class_dirty_count = iVar5;
if (pfs_enabled != '\0') {
thread_class_lost = thread_class_lost + 1;
}
}
return uVar8;
}
|
|
19,747
|
minja::Value::contains(minja::Value const&) const
|
monkey531[P]llama/common/minja.hpp
|
bool contains(const Value & value) const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (array_) {
for (const auto& item : *array_) {
if (item.to_bool() && item == value) return true;
}
return false;
} else if (object_) {
if (!value.is_hashable()) throw std::runtime_error("Unashable type: " + value.dump());
return object_->find(value.primitive_) != object_->end();
} else {
throw std::runtime_error("contains can only be called on arrays and objects: " + dump());
}
}
|
O2
|
cpp
|
minja::Value::contains(minja::Value const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x6f26a
testb %al, %al
jne 0x79035
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x78ff5
movq (%rax), %rbx
movq 0x8(%rax), %r15
cmpq %r15, %rbx
setne %bpl
je 0x79028
movq %rbx, %rdi
callq 0x6e9d8
testb %al, %al
je 0x78fef
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79f86
testb %al, %al
jne 0x79028
addq $0x50, %rbx
jmp 0x78fcb
cmpq $0x0, 0x20(%r15)
je 0x79065
movq %r14, %rdi
callq 0x6ec70
testb %al, %al
je 0x790c2
movq 0x20(%r15), %rdi
addq $0x40, %r14
movq %r14, %rsi
callq 0x76f30
movq 0x20(%r15), %rcx
cmpq 0x8(%rcx), %rax
setne %bpl
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x24470
movq %rax, %rbx
leaq 0x46da7(%rip), %rsi # 0xbfdee
movq %rax, %rdi
callq 0x24330
movq 0x92f9a(%rip), %rsi # 0x10bff0
movq 0x92efb(%rip), %rdx # 0x10bf58
movq %rbx, %rdi
callq 0x24f80
pushq $0x10
popq %rdi
callq 0x24470
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x6ec80
leaq 0x47817(%rip), %rsi # 0xc08a0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x64496
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x24e90
xorl %ebp, %ebp
movq 0x92f3f(%rip), %rsi # 0x10bff0
movq 0x92ea0(%rip), %rdx # 0x10bf58
movq %rbx, %rdi
callq 0x24f80
jmp 0x7911d
pushq $0x10
popq %rdi
callq 0x24470
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x6ec80
leaq 0x4730a(%rip), %rsi # 0xc03f0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x64496
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x24e90
xorl %ebp, %ebp
movq 0x92ee2(%rip), %rsi # 0x10bff0
movq 0x92e43(%rip), %rdx # 0x10bf58
movq %rbx, %rdi
callq 0x24f80
jmp 0x79121
jmp 0x79130
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x25298
jmp 0x79136
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x25298
testb %bpl, %bpl
jne 0x7914e
jmp 0x79156
jmp 0x7914b
jmp 0x7914b
movq %rax, %r14
movq %rbx, %rdi
callq 0x246a0
movq %r14, %rdi
callq 0x25010
|
_ZNK5minja5Value8containsERKS0_:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov r14, rsi
mov r15, rdi
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jnz short loc_79035
mov rax, [r15+10h]
test rax, rax
jz short loc_78FF5
mov rbx, [rax]
mov r15, [rax+8]
loc_78FCB:
cmp rbx, r15
setnz bpl
jz short loc_79028
mov rdi, rbx; this
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
test al, al
jz short loc_78FEF
mov rdi, rbx
mov rsi, r14
call _ZNK5minja5ValueeqERKS0_; minja::Value::operator==(minja::Value const&)
test al, al
jnz short loc_79028
loc_78FEF:
add rbx, 50h ; 'P'
jmp short loc_78FCB
loc_78FF5:
cmp qword ptr [r15+20h], 0
jz short loc_79065
mov rdi, r14; this
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, al
jz loc_790C2
mov rdi, [r15+20h]
add r14, 40h ; '@'
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE4findERSJ_; 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>>>::find(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rcx, [r15+20h]
cmp rax, [rcx+8]
setnz bpl
loc_79028:
mov eax, ebp
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_79035:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_79065:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_60]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r15
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aContainsCanOnl; "contains can only be called on arrays a"...
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_7911D
loc_790C2:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_60]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_7911D:
jmp short loc_79121
jmp short loc_79130
loc_79121:
mov r14, rax
lea rdi, [rsp+68h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_79136
loc_79130:
mov r14, rax
mov bpl, 1
loc_79136:
lea rdi, [rsp+68h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7914E
jmp short loc_79156
jmp short loc_7914B
jmp short $+2
loc_7914B:
mov r14, rax
loc_7914E:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_79156:
mov rdi, r14
call __Unwind_Resume
|
long long minja::Value::contains(unsigned __int8 ***this, const minja::Value *a2, __m128d a3)
{
unsigned int v3; // ebp
unsigned __int8 **v4; // rax
minja::Value *v5; // rbx
minja::Value *v6; // r15
std::runtime_error *exception; // rbx
void *v9; // rbx
void *v10; // rbx
_BYTE v11[32]; // [rsp+8h] [rbp-60h] BYREF
_BYTE v12[64]; // [rsp+28h] [rbp-40h] BYREF
if ( minja::Value::is_null((minja::Value *)this) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v4 = this[2];
if ( v4 )
{
v5 = (minja::Value *)*v4;
v6 = (minja::Value *)v4[1];
while ( 1 )
{
LOBYTE(v3) = v5 != v6;
if ( v5 == v6 || (unsigned __int8)minja::Value::to_bool(v5) && (unsigned __int8)minja::Value::operator==(v5, a2) )
break;
v5 = (minja::Value *)((char *)v5 + 80);
}
}
else
{
if ( !this[4] )
{
v9 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v11, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v12, (long long)"contains can only be called on arrays and objects: ", (long long)v11);
std::runtime_error::runtime_error(v9, v12);
__cxa_throw(
v9,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !minja::Value::is_primitive(a2) )
{
v10 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v11, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v12, (long long)"Unashable type: ", (long long)v11);
std::runtime_error::runtime_error(v10, v12);
__cxa_throw(
v10,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
LOBYTE(v3) = 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>>>::find(
this[4],
(unsigned __int8 *)a2 + 64,
a3) != this[4][1];
}
return v3;
}
|
contains:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
MOV R15,RDI
CALL 0x0016f26a
TEST AL,AL
JNZ 0x00179035
MOV RAX,qword ptr [R15 + 0x10]
TEST RAX,RAX
JZ 0x00178ff5
MOV RBX,qword ptr [RAX]
MOV R15,qword ptr [RAX + 0x8]
LAB_00178fcb:
CMP RBX,R15
SETNZ BPL
JZ 0x00179028
MOV RDI,RBX
CALL 0x0016e9d8
TEST AL,AL
JZ 0x00178fef
MOV RDI,RBX
MOV RSI,R14
CALL 0x00179f86
TEST AL,AL
JNZ 0x00179028
LAB_00178fef:
ADD RBX,0x50
JMP 0x00178fcb
LAB_00178ff5:
CMP qword ptr [R15 + 0x20],0x0
JZ 0x00179065
MOV RDI,R14
CALL 0x0016ec70
TEST AL,AL
JZ 0x001790c2
MOV RDI,qword ptr [R15 + 0x20]
ADD R14,0x40
MOV RSI,R14
CALL 0x00176f30
MOV RCX,qword ptr [R15 + 0x20]
CMP RAX,qword ptr [RCX + 0x8]
SETNZ BPL
LAB_00179028:
MOV EAX,EBP
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00179035:
PUSH 0x10
POP RDI
CALL 0x00124470
MOV RBX,RAX
LAB_00179040:
LEA RSI,[0x1bfdee]
MOV RDI,RAX
CALL 0x00124330
LAB_0017904f:
MOV RSI,qword ptr [0x0020bff0]
MOV RDX,qword ptr [0x0020bf58]
MOV RDI,RBX
CALL 0x00124f80
LAB_00179065:
PUSH 0x10
POP RDI
CALL 0x00124470
MOV RBX,RAX
LAB_00179070:
LEA RDI,[RSP + 0x8]
PUSH -0x1
POP RDX
MOV RSI,R15
XOR ECX,ECX
CALL 0x0016ec80
LAB_00179082:
LEA RSI,[0x1c08a0]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00164496
MOV BPL,0x1
LAB_0017909b:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00124e90
XOR EBP,EBP
MOV RSI,qword ptr [0x0020bff0]
MOV RDX,qword ptr [0x0020bf58]
MOV RDI,RBX
CALL 0x00124f80
LAB_001790c2:
PUSH 0x10
POP RDI
CALL 0x00124470
MOV RBX,RAX
LAB_001790cd:
LEA RDI,[RSP + 0x8]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x0016ec80
LAB_001790df:
LEA RSI,[0x1c03f0]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00164496
MOV BPL,0x1
LAB_001790f8:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00124e90
XOR EBP,EBP
MOV RSI,qword ptr [0x0020bff0]
MOV RDX,qword ptr [0x0020bf58]
MOV RDI,RBX
CALL 0x00124f80
|
/* minja::Value::contains(minja::Value const&) const */
ulong __thiscall minja::Value::contains(Value *this,Value *param_1)
{
int8 *puVar1;
Value *pVVar2;
char cVar3;
long lVar4;
runtime_error *prVar5;
Value *this_00;
ulong unaff_RBP;
int1 local_60 [32];
string local_40 [32];
cVar3 = is_null(this);
if (cVar3 != '\0') {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00179040 to 0017904e has its CatchHandler @ 0017914b */
std::runtime_error::runtime_error(prVar5,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_0020bff0,PTR__runtime_error_0020bf58);
}
puVar1 = *(int8 **)(this + 0x10);
if (puVar1 == (int8 *)0x0) {
if (*(long *)(this + 0x20) == 0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00179070 to 00179081 has its CatchHandler @ 00179149 */
dump_abi_cxx11_((int)local_60,SUB81(this,0));
/* try { // try from 00179082 to 00179097 has its CatchHandler @ 00179130 */
std::operator+((char *)local_40,
(string *)"contains can only be called on arrays and objects: ");
/* try { // try from 0017909b to 001790bf has its CatchHandler @ 00179121 */
std::runtime_error::runtime_error(prVar5,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_0020bff0,PTR__runtime_error_0020bf58);
}
cVar3 = is_primitive(param_1);
if (cVar3 == '\0') {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001790cd to 001790de has its CatchHandler @ 00179147 */
dump_abi_cxx11_((int)local_60,SUB81(param_1,0));
/* try { // try from 001790df to 001790f4 has its CatchHandler @ 0017911f */
std::operator+((char *)local_40,(string *)"Unashable type: ");
/* try { // try from 001790f8 to 0017911c has its CatchHandler @ 0017911d */
std::runtime_error::runtime_error(prVar5,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_0020bff0,PTR__runtime_error_0020bf58);
}
lVar4 = 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>>>
::find(*(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
**)(this + 0x20),param_1 + 0x40);
unaff_RBP = CONCAT71((int7)(unaff_RBP >> 8),lVar4 != *(long *)(*(long *)(this + 0x20) + 8));
}
else {
pVVar2 = (Value *)puVar1[1];
for (this_00 = (Value *)*puVar1; unaff_RBP = CONCAT71((int7)(unaff_RBP >> 8),this_00 != pVVar2),
this_00 != pVVar2; this_00 = this_00 + 0x50) {
cVar3 = to_bool(this_00);
if (cVar3 != '\0') {
cVar3 = operator==(this_00,param_1);
if (cVar3 != '\0') break;
}
}
}
return unaff_RBP & 0xffffffff;
}
|
|
19,748
|
plutovg_state_copy
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-canvas.c
|
static void plutovg_state_copy(plutovg_state_t* state, const plutovg_state_t* source)
{
state->paint = plutovg_paint_reference(source->paint);
state->font_face = plutovg_font_face_reference(source->font_face);
state->color = source->color;
state->matrix = source->matrix;
state->stroke.style = source->stroke.style;
state->stroke.dash.offset = source->stroke.dash.offset;
plutovg_array_clear(state->stroke.dash.array);
plutovg_array_append(state->stroke.dash.array, source->stroke.dash.array);
plutovg_span_buffer_copy(&state->clip_spans, &source->clip_spans);
state->winding = source->winding;
state->op = source->op;
state->font_size = source->font_size;
state->opacity = source->opacity;
state->clipping = source->clipping;
}
|
O0
|
c
|
plutovg_state_copy:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xed50
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x62a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x40(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movss 0x48(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x48(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x3c75
movq -0x10(%rbp), %rax
cmpl $0x0, 0x58(%rax)
jle 0x3c75
jmp 0x3baa
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x58(%rcx), %eax
movq -0x8(%rbp), %rcx
cmpl 0x5c(%rcx), %eax
jle 0x3c32
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x58(%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
jne 0x3be6
movl $0x8, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3bf0
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3c08
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
jmp 0x3bf6
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movslq -0x18(%rbp), %rsi
shlq $0x2, %rsi
callq 0x3200
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x5c(%rax)
jmp 0x3c34
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x58(%rax), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x58(%rax), %rdx
shlq $0x2, %rdx
callq 0x3190
movq -0x10(%rbp), %rax
movl 0x58(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x58(%rax), %ecx
movl %ecx, 0x58(%rax)
jmp 0x3c77
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0x12fa0
movq -0x10(%rbp), %rax
movl 0x80(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x80(%rax)
movq -0x10(%rbp), %rax
movl 0x84(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x84(%rax)
movq -0x10(%rbp), %rax
movss 0x88(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x88(%rax)
movq -0x10(%rbp), %rax
movss 0x8c(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x8c(%rax)
movq -0x10(%rbp), %rax
movb 0x90(%rax), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x90(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
plutovg_state_copy:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rdi, [rax]
call plutovg_paint_reference
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rdi, [rax+8]
call plutovg_font_face_reference
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+8], rcx
mov rax, [rbp+var_8]
mov rcx, [rbp+var_10]
mov rdx, [rcx+10h]
mov [rax+10h], rdx
mov rcx, [rcx+18h]
mov [rax+18h], rcx
mov rax, [rbp+var_8]
mov rcx, [rbp+var_10]
mov rdx, [rcx+20h]
mov [rax+20h], rdx
mov rdx, [rcx+28h]
mov [rax+28h], rdx
mov rcx, [rcx+30h]
mov [rax+30h], rcx
mov rax, [rbp+var_8]
mov rcx, [rbp+var_10]
mov rdx, [rcx+38h]
mov [rax+38h], rdx
mov rcx, [rcx+40h]
mov [rax+40h], rcx
mov rax, [rbp+var_10]
movss xmm0, dword ptr [rax+48h]
mov rax, [rbp+var_8]
movss dword ptr [rax+48h], xmm0
mov rax, [rbp+var_8]
mov dword ptr [rax+58h], 0
mov rax, [rbp+var_10]
cmp qword ptr [rax+50h], 0
jz loc_3C75
mov rax, [rbp+var_10]
cmp dword ptr [rax+58h], 0
jle loc_3C75
jmp short $+2
loc_3BAA:
mov rax, [rbp+var_8]
mov eax, [rax+58h]
mov rcx, [rbp+var_10]
add eax, [rcx+58h]
mov rcx, [rbp+var_8]
cmp eax, [rcx+5Ch]
jle short loc_3C32
mov rax, [rbp+var_8]
mov eax, [rax+58h]
mov rcx, [rbp+var_10]
add eax, [rcx+58h]
mov [rbp+var_14], eax
mov rax, [rbp+var_8]
cmp dword ptr [rax+5Ch], 0
jnz short loc_3BE6
mov eax, 8
mov [rbp+var_1C], eax
jmp short loc_3BF0
loc_3BE6:
mov rax, [rbp+var_8]
mov eax, [rax+5Ch]
mov [rbp+var_1C], eax
loc_3BF0:
mov eax, [rbp+var_1C]
mov [rbp+var_18], eax
loc_3BF6:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_14]
jge short loc_3C08
mov eax, [rbp+var_18]
shl eax, 1
mov [rbp+var_18], eax
jmp short loc_3BF6
loc_3C08:
mov rax, [rbp+var_8]
mov rdi, [rax+50h]
movsxd rsi, [rbp+var_18]
shl rsi, 2
call _realloc
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+50h], rcx
mov ecx, [rbp+var_18]
mov rax, [rbp+var_8]
mov [rax+5Ch], ecx
loc_3C32:
jmp short $+2
loc_3C34:
mov rax, [rbp+var_8]
mov rdi, [rax+50h]
mov rax, [rbp+var_8]
movsxd rax, dword ptr [rax+58h]
shl rax, 2
add rdi, rax
mov rax, [rbp+var_10]
mov rsi, [rax+50h]
mov rax, [rbp+var_10]
movsxd rdx, dword ptr [rax+58h]
shl rdx, 2
call _memcpy
mov rax, [rbp+var_10]
mov ecx, [rax+58h]
mov rax, [rbp+var_8]
add ecx, [rax+58h]
mov [rax+58h], ecx
loc_3C75:
jmp short $+2
loc_3C77:
mov rdi, [rbp+var_8]
add rdi, 60h ; '`'
mov rsi, [rbp+var_10]
add rsi, 60h ; '`'
call plutovg_span_buffer_copy
mov rax, [rbp+var_10]
mov ecx, [rax+80h]
mov rax, [rbp+var_8]
mov [rax+80h], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+84h]
mov rax, [rbp+var_8]
mov [rax+84h], ecx
mov rax, [rbp+var_10]
movss xmm0, dword ptr [rax+88h]
mov rax, [rbp+var_8]
movss dword ptr [rax+88h], xmm0
mov rax, [rbp+var_10]
movss xmm0, dword ptr [rax+8Ch]
mov rax, [rbp+var_8]
movss dword ptr [rax+8Ch], xmm0
mov rax, [rbp+var_10]
mov cl, [rax+90h]
mov rax, [rbp+var_8]
and cl, 1
mov [rax+90h], cl
add rsp, 20h
pop rbp
retn
|
long long plutovg_state_copy(long long a1, long long a2)
{
long long result; // rax
int v3; // [rsp+4h] [rbp-1Ch]
int i; // [rsp+8h] [rbp-18h]
*(_QWORD *)a1 = plutovg_paint_reference(*(_QWORD *)a2);
*(_QWORD *)(a1 + 8) = plutovg_font_face_reference(*(_QWORD *)(a2 + 8));
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a2 + 16);
*(_QWORD *)(a1 + 24) = *(_QWORD *)(a2 + 24);
*(_QWORD *)(a1 + 32) = *(_QWORD *)(a2 + 32);
*(_QWORD *)(a1 + 40) = *(_QWORD *)(a2 + 40);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a2 + 48);
*(_QWORD *)(a1 + 56) = *(_QWORD *)(a2 + 56);
*(_QWORD *)(a1 + 64) = *(_QWORD *)(a2 + 64);
*(_DWORD *)(a1 + 72) = *(_DWORD *)(a2 + 72);
*(_DWORD *)(a1 + 88) = 0;
if ( *(_QWORD *)(a2 + 80) && *(int *)(a2 + 88) > 0 )
{
if ( *(_DWORD *)(a2 + 88) + *(_DWORD *)(a1 + 88) > *(_DWORD *)(a1 + 92) )
{
if ( *(_DWORD *)(a1 + 92) )
v3 = *(_DWORD *)(a1 + 92);
else
v3 = 8;
for ( i = v3; i < *(_DWORD *)(a2 + 88) + *(_DWORD *)(a1 + 88); i *= 2 )
;
*(_QWORD *)(a1 + 80) = realloc(*(_QWORD *)(a1 + 80), 4LL * i);
*(_DWORD *)(a1 + 92) = i;
}
memcpy(4LL * *(int *)(a1 + 88) + *(_QWORD *)(a1 + 80), *(_QWORD *)(a2 + 80), 4LL * *(int *)(a2 + 88));
*(_DWORD *)(a1 + 88) += *(_DWORD *)(a2 + 88);
}
plutovg_span_buffer_copy(a1 + 96, a2 + 96);
*(_DWORD *)(a1 + 128) = *(_DWORD *)(a2 + 128);
*(_DWORD *)(a1 + 132) = *(_DWORD *)(a2 + 132);
*(_DWORD *)(a1 + 136) = *(_DWORD *)(a2 + 136);
*(_DWORD *)(a1 + 140) = *(_DWORD *)(a2 + 140);
result = a1;
*(_BYTE *)(a1 + 144) = *(_BYTE *)(a2 + 144) & 1;
return result;
}
|
plutovg_state_copy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x0010ed50
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001062a0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX + 0x10]
MOV qword ptr [RAX + 0x10],RDX
MOV RCX,qword ptr [RCX + 0x18]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX + 0x20]
MOV qword ptr [RAX + 0x20],RDX
MOV RDX,qword ptr [RCX + 0x28]
MOV qword ptr [RAX + 0x28],RDX
MOV RCX,qword ptr [RCX + 0x30]
MOV qword ptr [RAX + 0x30],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX + 0x38]
MOV qword ptr [RAX + 0x38],RDX
MOV RCX,qword ptr [RCX + 0x40]
MOV qword ptr [RAX + 0x40],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOVSS XMM0,dword ptr [RAX + 0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOVSS dword ptr [RAX + 0x48],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x58],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x50],0x0
JZ 0x00103c75
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x58],0x0
JLE 0x00103c75
JMP 0x00103baa
LAB_00103baa:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x58]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x5c]
JLE 0x00103c32
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x58]
MOV dword ptr [RBP + -0x14],EAX
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x5c],0x0
JNZ 0x00103be6
MOV EAX,0x8
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00103bf0
LAB_00103be6:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x5c]
MOV dword ptr [RBP + -0x1c],EAX
LAB_00103bf0:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x18],EAX
LAB_00103bf6:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x14]
JGE 0x00103c08
MOV EAX,dword ptr [RBP + -0x18]
SHL EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
JMP 0x00103bf6
LAB_00103c08:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x50]
MOVSXD RSI,dword ptr [RBP + -0x18]
SHL RSI,0x2
CALL 0x00103200
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x50],RCX
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x5c],ECX
LAB_00103c32:
JMP 0x00103c34
LAB_00103c34:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RAX,dword ptr [RAX + 0x58]
SHL RAX,0x2
ADD RDI,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RAX + 0x58]
SHL RDX,0x2
CALL 0x00103190
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x58]
MOV RAX,qword ptr [RBP + -0x8]
ADD ECX,dword ptr [RAX + 0x58]
MOV dword ptr [RAX + 0x58],ECX
LAB_00103c75:
JMP 0x00103c77
LAB_00103c77:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x60
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x60
CALL 0x00112fa0
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x80]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x80],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x84]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x84],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOVSS XMM0,dword ptr [RAX + 0x88]
MOV RAX,qword ptr [RBP + -0x8]
MOVSS dword ptr [RAX + 0x88],XMM0
MOV RAX,qword ptr [RBP + -0x10]
MOVSS XMM0,dword ptr [RAX + 0x8c]
MOV RAX,qword ptr [RBP + -0x8]
MOVSS dword ptr [RAX + 0x8c],XMM0
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX + 0x90]
MOV RAX,qword ptr [RBP + -0x8]
AND CL,0x1
MOV byte ptr [RAX + 0x90],CL
ADD RSP,0x20
POP RBP
RET
|
void plutovg_state_copy(int8 *param_1,int8 *param_2)
{
int8 uVar1;
void *pvVar2;
int local_24;
int local_20;
uVar1 = plutovg_paint_reference(*param_2);
*param_1 = uVar1;
uVar1 = plutovg_font_face_reference(param_2[1]);
param_1[1] = uVar1;
param_1[2] = param_2[2];
param_1[3] = param_2[3];
param_1[4] = param_2[4];
param_1[5] = param_2[5];
param_1[6] = param_2[6];
param_1[7] = param_2[7];
param_1[8] = param_2[8];
*(int4 *)(param_1 + 9) = *(int4 *)(param_2 + 9);
*(int4 *)(param_1 + 0xb) = 0;
if ((param_2[10] != 0) && (0 < *(int *)(param_2 + 0xb))) {
if (*(int *)((long)param_1 + 0x5c) < *(int *)(param_1 + 0xb) + *(int *)(param_2 + 0xb)) {
if (*(int *)((long)param_1 + 0x5c) == 0) {
local_24 = 8;
}
else {
local_24 = *(int *)((long)param_1 + 0x5c);
}
for (local_20 = local_24; local_20 < *(int *)(param_1 + 0xb) + *(int *)(param_2 + 0xb);
local_20 = local_20 << 1) {
}
pvVar2 = realloc((void *)param_1[10],(long)local_20 << 2);
param_1[10] = pvVar2;
*(int *)((long)param_1 + 0x5c) = local_20;
}
memcpy((void *)(param_1[10] + (long)*(int *)(param_1 + 0xb) * 4),(void *)param_2[10],
(long)*(int *)(param_2 + 0xb) << 2);
*(int *)(param_1 + 0xb) = *(int *)(param_2 + 0xb) + *(int *)(param_1 + 0xb);
}
plutovg_span_buffer_copy(param_1 + 0xc,param_2 + 0xc);
*(int4 *)(param_1 + 0x10) = *(int4 *)(param_2 + 0x10);
*(int4 *)((long)param_1 + 0x84) = *(int4 *)((long)param_2 + 0x84);
*(int4 *)(param_1 + 0x11) = *(int4 *)(param_2 + 0x11);
*(int4 *)((long)param_1 + 0x8c) = *(int4 *)((long)param_2 + 0x8c);
*(byte *)(param_1 + 0x12) = *(byte *)(param_2 + 0x12) & 1;
return;
}
|
|
19,749
|
dequantize_row_q4_0
|
llama.cpp/ggml/src/ggml-quants.c
|
void dequantize_row_q4_0(const block_q4_0 * GGML_RESTRICT x, float * GGML_RESTRICT y, int64_t k) {
static const int qk = QK4_0;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
for (int j = 0; j < qk/2; ++j) {
const int x0 = (x[i].qs[j] & 0x0F) - 8;
const int x1 = (x[i].qs[j] >> 4) - 8;
y[i*qk + j + 0 ] = x0*d;
y[i*qk + j + qk/2] = x1*d;
}
}
}
|
O3
|
c
|
dequantize_row_q4_0:
leaq 0x1f(%rdx), %rax
testq %rdx, %rdx
cmovnsq %rdx, %rax
sarq $0x5, %rax
testl %eax, %eax
jle 0x2c7ce
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
leaq 0x2(%rdi), %rcx
addq $0x40, %rsi
xorl %edx, %edx
movq 0x3d858(%rip), %r8 # 0x69fa8
pxor %xmm0, %xmm0
movdqa 0x21ec4(%rip), %xmm1 # 0x4e620
movdqa 0x21ecc(%rip), %xmm2 # 0x4e630
leaq (%rdx,%rdx,8), %r9
movzwl (%rdi,%r9,2), %r9d
movss (%r8,%r9,4), %xmm3
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
xorl %r9d, %r9d
movd (%rcx,%r9), %xmm4
punpcklbw %xmm0, %xmm4 # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1],xmm4[2],xmm0[2],xmm4[3],xmm0[3],xmm4[4],xmm0[4],xmm4[5],xmm0[5],xmm4[6],xmm0[6],xmm4[7],xmm0[7]
punpcklwd %xmm0, %xmm4 # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1],xmm4[2],xmm0[2],xmm4[3],xmm0[3]
movdqa %xmm4, %xmm5
pand %xmm1, %xmm5
paddd %xmm2, %xmm5
psrld $0x4, %xmm4
paddd %xmm2, %xmm4
cvtdq2ps %xmm5, %xmm5
mulps %xmm3, %xmm5
movups %xmm5, -0x40(%rsi,%r9,4)
cvtdq2ps %xmm4, %xmm4
mulps %xmm3, %xmm4
movups %xmm4, (%rsi,%r9,4)
addq $0x4, %r9
cmpq $0x10, %r9
jne 0x2c77a
incq %rdx
addq $0x12, %rcx
subq $-0x80, %rsi
cmpq %rax, %rdx
jne 0x2c764
retq
|
dequantize_row_q4_0:
lea rax, [rdx+1Fh]
test rdx, rdx
cmovns rax, rdx
sar rax, 5
test eax, eax
jle locret_2C7CE
and eax, 7FFFFFFFh
lea rcx, [rdi+2]
add rsi, 40h ; '@'
xor edx, edx
mov r8, cs:ggml_table_f32_f16_ptr
pxor xmm0, xmm0
movdqa xmm1, cs:xmmword_4E620
movdqa xmm2, cs:xmmword_4E630
loc_2C764:
lea r9, [rdx+rdx*8]
movzx r9d, word ptr [rdi+r9*2]
movss xmm3, dword ptr [r8+r9*4]
shufps xmm3, xmm3, 0
xor r9d, r9d
loc_2C77A:
movd xmm4, dword ptr [rcx+r9]
punpcklbw xmm4, xmm0
punpcklwd xmm4, xmm0
movdqa xmm5, xmm4
pand xmm5, xmm1
paddd xmm5, xmm2
psrld xmm4, 4
paddd xmm4, xmm2
cvtdq2ps xmm5, xmm5
mulps xmm5, xmm3
movups xmmword ptr [rsi+r9*4-40h], xmm5
cvtdq2ps xmm4, xmm4
mulps xmm4, xmm3
movups xmmword ptr [rsi+r9*4], xmm4
add r9, 4
cmp r9, 10h
jnz short loc_2C77A
inc rdx
add rcx, 12h
sub rsi, 0FFFFFFFFFFFFFF80h
cmp rdx, rax
jnz short loc_2C764
locret_2C7CE:
retn
|
long long dequantize_row_q4_0(long long a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rcx
long long v5; // rsi
long long v6; // rdx
__m128i si128; // xmm1
__m128i v8; // xmm2
__m128 v9; // xmm3
__m128 v10; // xmm3
long long i; // r9
__m128i v12; // xmm4
result = a3 / 32;
if ( (int)(a3 / 32) > 0 )
{
result = (a3 / 32) & 0x7FFFFFFF;
v4 = a1 + 2;
v5 = a2 + 64;
v6 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_4E620);
v8 = _mm_load_si128((const __m128i *)&xmmword_4E630);
do
{
v9 = (__m128)LODWORD(ggml_table_f32_f16[*(unsigned __int16 *)(a1 + 18 * v6)]);
v10 = _mm_shuffle_ps(v9, v9, 0);
for ( i = 0LL; i != 16; i += 4LL )
{
v12 = _mm_unpacklo_epi16(_mm_unpacklo_epi8(_mm_cvtsi32_si128(*(_DWORD *)(v4 + i)), (__m128i)0LL), (__m128i)0LL);
*(__m128 *)(v5 + 4 * i - 64) = _mm_mul_ps(_mm_cvtepi32_ps(_mm_add_epi32(_mm_and_si128(v12, si128), v8)), v10);
*(__m128 *)(v5 + 4 * i) = _mm_mul_ps(_mm_cvtepi32_ps(_mm_add_epi32(_mm_srli_epi32(v12, 4u), v8)), v10);
}
++v6;
v4 += 18LL;
v5 += 128LL;
}
while ( v6 != result );
}
return result;
}
|
dequantize_row_q4_0:
LEA RAX,[RDX + 0x1f]
TEST RDX,RDX
CMOVNS RAX,RDX
SAR RAX,0x5
TEST EAX,EAX
JLE 0x0012c7ce
AND EAX,0x7fffffff
LEA RCX,[RDI + 0x2]
ADD RSI,0x40
XOR EDX,EDX
MOV R8,qword ptr [0x00169fa8]
PXOR XMM0,XMM0
MOVDQA XMM1,xmmword ptr [0x0014e620]
MOVDQA XMM2,xmmword ptr [0x0014e630]
LAB_0012c764:
LEA R9,[RDX + RDX*0x8]
MOVZX R9D,word ptr [RDI + R9*0x2]
MOVSS XMM3,dword ptr [R8 + R9*0x4]
SHUFPS XMM3,XMM3,0x0
XOR R9D,R9D
LAB_0012c77a:
MOVD XMM4,dword ptr [RCX + R9*0x1]
PUNPCKLBW XMM4,XMM0
PUNPCKLWD XMM4,XMM0
MOVDQA XMM5,XMM4
PAND XMM5,XMM1
PADDD XMM5,XMM2
PSRLD XMM4,0x4
PADDD XMM4,XMM2
CVTDQ2PS XMM5,XMM5
MULPS XMM5,XMM3
MOVUPS xmmword ptr [RSI + R9*0x4 + -0x40],XMM5
CVTDQ2PS XMM4,XMM4
MULPS XMM4,XMM3
MOVUPS xmmword ptr [RSI + R9*0x4],XMM4
ADD R9,0x4
CMP R9,0x10
JNZ 0x0012c77a
INC RDX
ADD RCX,0x12
SUB RSI,-0x80
CMP RDX,RAX
JNZ 0x0012c764
LAB_0012c7ce:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void dequantize_row_q4_0(long param_1,long param_2,long param_3)
{
float *pfVar1;
float fVar2;
int4 uVar3;
int1 auVar4 [13];
int1 auVar5 [13];
int1 auVar6 [13];
ulong uVar7;
int1 auVar8 [13];
int1 auVar9 [16];
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int *puVar14;
uint uVar15;
long lVar16;
ulong uVar17;
long lVar18;
byte bVar20;
int1 auVar19 [16];
int1 auVar21 [16];
puVar14 = PTR_ggml_table_f32_f16_00169fa8;
iVar13 = _UNK_0014e63c;
iVar12 = _UNK_0014e638;
iVar11 = _UNK_0014e634;
iVar10 = _DAT_0014e630;
auVar9 = _DAT_0014e620;
lVar16 = param_3 + 0x1f;
if (-1 < param_3) {
lVar16 = param_3;
}
uVar15 = (uint)(lVar16 >> 5);
if (0 < (int)uVar15) {
lVar16 = param_1 + 2;
param_2 = param_2 + 0x40;
uVar17 = 0;
do {
fVar2 = *(float *)(puVar14 + (ulong)*(ushort *)(param_1 + uVar17 * 0x12) * 4);
lVar18 = 0;
do {
uVar3 = *(int4 *)(lVar16 + lVar18);
bVar20 = (byte)((uint)uVar3 >> 0x18);
uVar7 = (ulong)(ushort)uVar3 & 0xffffffffffff00ff;
auVar4._8_4_ = 0;
auVar4._0_8_ = uVar7;
auVar4[0xc] = bVar20;
auVar5[8] = (char)((uint)uVar3 >> 0x10);
auVar5._0_8_ = uVar7;
auVar5[9] = 0;
auVar5._10_3_ = auVar4._10_3_;
auVar8._5_8_ = 0;
auVar8._0_5_ = auVar5._8_5_;
auVar19._0_4_ = (uint)uVar7;
auVar6[4] = (char)((uint)uVar3 >> 8);
auVar6._0_4_ = auVar19._0_4_;
auVar6[5] = 0;
auVar6._6_7_ = SUB137(auVar8 << 0x40,6);
auVar19._4_9_ = auVar6._4_9_;
auVar19._13_3_ = 0;
auVar21 = auVar19 & auVar9;
pfVar1 = (float *)(param_2 + -0x40 + lVar18 * 4);
*pfVar1 = (float)(auVar21._0_4_ + iVar10) * fVar2;
pfVar1[1] = (float)(auVar21._4_4_ + iVar11) * fVar2;
pfVar1[2] = (float)(auVar21._8_4_ + iVar12) * fVar2;
pfVar1[3] = (float)(auVar21._12_4_ + iVar13) * fVar2;
pfVar1 = (float *)(param_2 + lVar18 * 4);
*pfVar1 = (float)(int)((auVar19._0_4_ >> 4) + iVar10) * fVar2;
pfVar1[1] = (float)(int)((auVar6._4_4_ >> 4) + iVar11) * fVar2;
pfVar1[2] = (float)(int)((auVar5._8_4_ >> 4) + iVar12) * fVar2;
pfVar1[3] = (float)(int)((uint)(bVar20 >> 4) + iVar13) * fVar2;
lVar18 = lVar18 + 4;
} while (lVar18 != 0x10);
uVar17 = uVar17 + 1;
lVar16 = lVar16 + 0x12;
param_2 = param_2 + 0x80;
} while (uVar17 != (uVar15 & 0x7fffffff));
}
return;
}
|
|
19,750
|
translog_walk_filenames
|
eloqsql/storage/maria/ma_loghandler.c
|
my_bool translog_walk_filenames(const char *directory,
my_bool (*callback)(const char *,
const char *))
{
MY_DIR *dirp;
uint i;
my_bool rc= FALSE;
/* Finds and removes transaction log files */
if (!(dirp = my_dir(directory, MYF(MY_DONT_SORT))))
return FALSE;
for (i= 0; i < dirp->number_of_files; i++)
{
char *file= dirp->dir_entry[i].name;
if (strncmp(file, "aria_log.", 10) == 0 &&
file[10] >= '0' && file[10] <= '9' &&
file[11] >= '0' && file[11] <= '9' &&
file[12] >= '0' && file[12] <= '9' &&
file[13] >= '0' && file[13] <= '9' &&
file[14] >= '0' && file[14] <= '9' &&
file[15] >= '0' && file[15] <= '9' &&
file[16] >= '0' && file[16] <= '9' &&
file[17] >= '0' && file[17] <= '9' &&
file[18] == '\0' && (*callback)(directory, file))
{
rc= TRUE;
break;
}
}
my_dirend(dirp);
return rc;
}
|
O3
|
c
|
translog_walk_filenames:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %esi, %esi
callq 0xa06a1
testq %rax, %rax
je 0x4a105
movq %rax, %rbx
movl 0x8(%rax), %r12d
testl %r12d, %r12d
je 0x4a0fa
movq %r15, -0x30(%rbp)
movq %r14, -0x38(%rbp)
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r14), %r13
movl $0xa, %edx
movq %r13, %rdi
leaq 0x9110a(%rip), %rsi # 0xdb17f
callq 0x291d0
testl %eax, %eax
jne 0x4a0e7
movb 0xa(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x4a0e7
movb 0xb(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x4a0e7
movb 0xc(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x4a0e7
movb 0xd(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x4a0e7
movb 0xe(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x4a0e7
movb 0xf(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x4a0e7
movb 0x10(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x4a0e7
movb 0x11(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x4a0e7
cmpb $0x0, 0x12(%r13)
jne 0x4a0e7
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq *-0x38(%rbp)
testb %al, %al
jne 0x4a117
movl 0x8(%rbx), %r12d
incq %r15
movl %r12d, %eax
addq $0x10, %r14
cmpq %rax, %r15
jb 0x4a05f
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0xa0670
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r12b
jmp 0x4a0fd
|
translog_walk_filenames:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rsi
mov r15, rdi
xor r12d, r12d
xor esi, esi
call my_dir
test rax, rax
jz loc_4A105
mov rbx, rax
mov r12d, [rax+8]
test r12d, r12d
jz loc_4A0FA
mov [rbp+var_30], r15
mov [rbp+var_38], r14
xor r14d, r14d
xor r15d, r15d
loc_4A05F:
mov rax, [rbx]
mov r13, [rax+r14]
mov edx, 0Ah
mov rdi, r13
lea rsi, aAriaLog; "aria_log."
call _strncmp
test eax, eax
jnz short loc_4A0E7
mov al, [r13+0Ah]
add al, 0D0h
cmp al, 9
ja short loc_4A0E7
mov al, [r13+0Bh]
add al, 0D0h
cmp al, 9
ja short loc_4A0E7
mov al, [r13+0Ch]
add al, 0D0h
cmp al, 9
ja short loc_4A0E7
mov al, [r13+0Dh]
add al, 0D0h
cmp al, 9
ja short loc_4A0E7
mov al, [r13+0Eh]
add al, 0D0h
cmp al, 9
ja short loc_4A0E7
mov al, [r13+0Fh]
add al, 0D0h
cmp al, 9
ja short loc_4A0E7
mov al, [r13+10h]
add al, 0D0h
cmp al, 9
ja short loc_4A0E7
mov al, [r13+11h]
add al, 0D0h
cmp al, 9
ja short loc_4A0E7
cmp byte ptr [r13+12h], 0
jnz short loc_4A0E7
mov rdi, [rbp+var_30]
mov rsi, r13
call [rbp+var_38]
test al, al
jnz short loc_4A117
mov r12d, [rbx+8]
loc_4A0E7:
inc r15
mov eax, r12d
add r14, 10h
cmp r15, rax
jb loc_4A05F
loc_4A0FA:
xor r12d, r12d
loc_4A0FD:
mov rdi, rbx
call my_dirend
loc_4A105:
mov eax, r12d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4A117:
mov r12b, 1
jmp short loc_4A0FD
|
long long translog_walk_filenames(long long a1, unsigned __int8 ( *a2)(long long, _BYTE *))
{
unsigned int v2; // r12d
long long v3; // rax
long long v4; // rbx
long long v5; // r14
unsigned long long v6; // r15
_BYTE *v7; // r13
v2 = 0;
v3 = my_dir(a1, 0LL);
if ( !v3 )
return v2;
v4 = v3;
v2 = *(_DWORD *)(v3 + 8);
if ( !v2 )
{
LABEL_17:
v2 = 0;
goto LABEL_18;
}
v5 = 0LL;
v6 = 0LL;
while ( 1 )
{
v7 = *(_BYTE **)(*(_QWORD *)v4 + v5);
if ( (unsigned int)strncmp(v7, "aria_log.", 10LL)
|| (unsigned __int8)(v7[10] - 48) > 9u
|| (unsigned __int8)(v7[11] - 48) > 9u
|| (unsigned __int8)(v7[12] - 48) > 9u
|| (unsigned __int8)(v7[13] - 48) > 9u
|| (unsigned __int8)(v7[14] - 48) > 9u
|| (unsigned __int8)(v7[15] - 48) > 9u
|| (unsigned __int8)(v7[16] - 48) > 9u
|| (unsigned __int8)(v7[17] - 48) > 9u
|| v7[18] )
{
goto LABEL_16;
}
if ( a2(a1, v7) )
break;
v2 = *(_DWORD *)(v4 + 8);
LABEL_16:
++v6;
v5 += 16LL;
if ( v6 >= v2 )
goto LABEL_17;
}
LOBYTE(v2) = 1;
LABEL_18:
my_dirend(v4);
return v2;
}
|
translog_walk_filenames:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV R15,RDI
XOR R12D,R12D
XOR ESI,ESI
CALL 0x001a06a1
TEST RAX,RAX
JZ 0x0014a105
MOV RBX,RAX
MOV R12D,dword ptr [RAX + 0x8]
TEST R12D,R12D
JZ 0x0014a0fa
MOV qword ptr [RBP + -0x30],R15
MOV qword ptr [RBP + -0x38],R14
XOR R14D,R14D
XOR R15D,R15D
LAB_0014a05f:
MOV RAX,qword ptr [RBX]
MOV R13,qword ptr [RAX + R14*0x1]
MOV EDX,0xa
MOV RDI,R13
LEA RSI,[0x1db17f]
CALL 0x001291d0
TEST EAX,EAX
JNZ 0x0014a0e7
MOV AL,byte ptr [R13 + 0xa]
ADD AL,0xd0
CMP AL,0x9
JA 0x0014a0e7
MOV AL,byte ptr [R13 + 0xb]
ADD AL,0xd0
CMP AL,0x9
JA 0x0014a0e7
MOV AL,byte ptr [R13 + 0xc]
ADD AL,0xd0
CMP AL,0x9
JA 0x0014a0e7
MOV AL,byte ptr [R13 + 0xd]
ADD AL,0xd0
CMP AL,0x9
JA 0x0014a0e7
MOV AL,byte ptr [R13 + 0xe]
ADD AL,0xd0
CMP AL,0x9
JA 0x0014a0e7
MOV AL,byte ptr [R13 + 0xf]
ADD AL,0xd0
CMP AL,0x9
JA 0x0014a0e7
MOV AL,byte ptr [R13 + 0x10]
ADD AL,0xd0
CMP AL,0x9
JA 0x0014a0e7
MOV AL,byte ptr [R13 + 0x11]
ADD AL,0xd0
CMP AL,0x9
JA 0x0014a0e7
CMP byte ptr [R13 + 0x12],0x0
JNZ 0x0014a0e7
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R13
CALL qword ptr [RBP + -0x38]
TEST AL,AL
JNZ 0x0014a117
MOV R12D,dword ptr [RBX + 0x8]
LAB_0014a0e7:
INC R15
MOV EAX,R12D
ADD R14,0x10
CMP R15,RAX
JC 0x0014a05f
LAB_0014a0fa:
XOR R12D,R12D
LAB_0014a0fd:
MOV RDI,RBX
CALL 0x001a0670
LAB_0014a105:
MOV EAX,R12D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014a117:
MOV R12B,0x1
JMP 0x0014a0fd
|
int8 translog_walk_filenames(int8 param_1,code *param_2)
{
char *__s1;
char cVar1;
int iVar2;
long *plVar3;
ulong uVar4;
int8 uVar5;
long lVar6;
ulong uVar7;
uVar5 = 0;
plVar3 = (long *)my_dir(param_1,0);
if (plVar3 != (long *)0x0) {
uVar4 = (ulong)*(uint *)(plVar3 + 1);
if (*(uint *)(plVar3 + 1) != 0) {
lVar6 = 0;
uVar7 = 0;
do {
__s1 = *(char **)(*plVar3 + lVar6);
iVar2 = strncmp(__s1,"aria_log.",10);
if ((((((iVar2 == 0) && ((byte)(__s1[10] - 0x30U) < 10)) && ((byte)(__s1[0xb] - 0x30U) < 10)
) && (((byte)(__s1[0xc] - 0x30U) < 10 && ((byte)(__s1[0xd] - 0x30U) < 10)))) &&
(((byte)(__s1[0xe] - 0x30U) < 10 &&
(((byte)(__s1[0xf] - 0x30U) < 10 && ((byte)(__s1[0x10] - 0x30U) < 10)))))) &&
(((byte)(__s1[0x11] - 0x30U) < 10 && (__s1[0x12] == '\0')))) {
cVar1 = (*param_2)(param_1,__s1);
if (cVar1 != '\0') {
uVar5 = CONCAT71((int7)(uVar4 >> 8),1);
goto LAB_0014a0fd;
}
uVar4 = (ulong)*(uint *)(plVar3 + 1);
}
uVar7 = uVar7 + 1;
lVar6 = lVar6 + 0x10;
} while (uVar7 < uVar4);
}
uVar5 = 0;
LAB_0014a0fd:
my_dirend(plVar3);
}
return uVar5;
}
|
|
19,751
|
minja::Value::operator+(minja::Value const&) const
|
monkey531[P]llama/common/minja.hpp
|
Value operator+(const Value& rhs) const {
if (is_string() || rhs.is_string()) {
return to_str() + rhs.to_str();
} else if (is_number_integer() && rhs.is_number_integer()) {
return get<int64_t>() + rhs.get<int64_t>();
} else if (is_array() && rhs.is_array()) {
auto res = Value::array();
for (const auto& item : *array_) res.push_back(item);
for (const auto& item : *rhs.array_) res.push_back(item);
return res;
} else {
return get<double>() + rhs.get<double>();
}
}
|
O2
|
cpp
|
minja::Value::operator+(minja::Value const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb 0x40(%rsi), %al
cmpb $0x3, %al
je 0x52a11
movb 0x40(%r14), %cl
cmpb $0x3, %cl
jne 0x52a7c
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0x5292e
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x5292e
leaq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x28b59
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4085e
leaq 0x10(%rsp), %rdi
callq 0x20d88
leaq 0x48(%rsp), %rdi
callq 0x20d88
leaq 0x68(%rsp), %rdi
callq 0x20d88
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addb $-0x5, %al
addb $-0x5, %cl
orb %al, %cl
cmpb $0x1, %cl
ja 0x52ab0
movq %r15, %rdi
callq 0x3cd9c
movq %rax, %r15
movq %r14, %rdi
callq 0x3cd9c
addq %r15, %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3ce52
jmp 0x52a6a
cmpq $0x0, 0x10(%r15)
je 0x52b03
cmpq $0x0, 0x10(%r14)
je 0x52b03
xorpd %xmm0, %xmm0
leaq 0x30(%rsp), %rsi
movapd %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x4b7a4
leaq 0x30(%rsp), %rdi
callq 0x4afb6
movq 0x10(%r15), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0x52b35
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b810
addq $0x50, %r15
jmp 0x52aed
movq %r15, %rdi
callq 0x3ce70
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x3ce70
addsd 0x8(%rsp), %xmm0
leaq 0x10(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x3cf26
jmp 0x52a6a
movq 0x10(%r14), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x52a6a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b810
addq $0x50, %r14
jmp 0x52b40
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x4afb6
jmp 0x52ba3
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20d88
jmp 0x52b7b
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x20d88
jmp 0x52b8a
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x20d88
jmp 0x52ba3
jmp 0x52b98
movq %rax, %r14
movq %rbx, %rdi
callq 0x3cc92
movq %r14, %rdi
callq 0x20b90
nop
|
_ZNK5minja5ValueplERKS0_:
push r15
push r14
push r12
push rbx
sub rsp, 88h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov al, [rsi+40h]
cmp al, 3
jz short loc_52A11
mov cl, [r14+40h]
cmp cl, 3
jnz short loc_52A7C
loc_52A11:
lea rdi, [rsp+0A8h+var_40]; this
mov rsi, r15; minja::Value *
call _ZNK5minja5Value6to_strB5cxx11Ev; minja::Value::to_str(void)
lea rdi, [rsp+0A8h+var_60]; this
mov rsi, r14; minja::Value *
call _ZNK5minja5Value6to_strB5cxx11Ev; minja::Value::to_str(void)
lea rdi, [rsp+0A8h+var_98]
lea rsi, [rsp+0A8h+var_40]
lea rdx, [rsp+0A8h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rsi, [rsp+0A8h+var_98]
mov rdi, rbx
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
lea rdi, [rsp+0A8h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_52A6A:
mov rax, rbx
add rsp, 88h
pop rbx
pop r12
pop r14
pop r15
retn
loc_52A7C:
add al, 0FBh
add cl, 0FBh
or cl, al
cmp cl, 1
ja short loc_52AB0
mov rdi, r15
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov r15, rax
mov rdi, r14
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
add rax, r15
lea rsi, [rsp+0A8h+var_98]; __int64 *
mov [rsi], rax
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKl; minja::Value::Value(long const&)
jmp short loc_52A6A
loc_52AB0:
cmp qword ptr [r15+10h], 0
jz short loc_52B03
cmp qword ptr [r14+10h], 0
jz short loc_52B03
xorpd xmm0, xmm0
lea rsi, [rsp+0A8h+var_78]
movapd xmmword ptr [rsi], xmm0
and qword ptr [rsi+10h], 0
mov rdi, rbx
call _ZN5minja5Value5arrayESt6vectorIS0_SaIS0_EE; minja::Value::array(std::vector<minja::Value>)
lea rdi, [rsp+0A8h+var_78]
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
mov rax, [r15+10h]
mov r15, [rax]
mov r12, [rax+8]
loc_52AED:
cmp r15, r12
jz short loc_52B35
mov rdi, rbx; this
mov rsi, r15; minja::Value *
call _ZN5minja5Value9push_backERKS0_; minja::Value::push_back(minja::Value const&)
add r15, 50h ; 'P'
jmp short loc_52AED
loc_52B03:
mov rdi, r15
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+0A8h+var_A0], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
addsd xmm0, [rsp+0A8h+var_A0]
lea rsi, [rsp+0A8h+var_98]; double *
movsd qword ptr [rsi], xmm0
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKd; minja::Value::Value(double const&)
jmp loc_52A6A
loc_52B35:
mov rax, [r14+10h]
mov r14, [rax]
mov r15, [rax+8]
loc_52B40:
cmp r14, r15
jz loc_52A6A
mov rdi, rbx; this
mov rsi, r14; minja::Value *
call _ZN5minja5Value9push_backERKS0_; minja::Value::push_back(minja::Value const&)
add r14, 50h ; 'P'
jmp short loc_52B40
mov r14, rax
lea rdi, [rsp+arg_28]
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
jmp short loc_52BA3
mov r14, rax
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_52B7B
mov r14, rax
loc_52B7B:
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_52B8A
mov r14, rax
loc_52B8A:
lea rdi, [rsp+arg_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_52BA3
jmp short $+2
loc_52B98:
mov r14, rax
mov rdi, rbx; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_52BA3:
mov rdi, r14
call __Unwind_Resume
|
minja::Value * minja::Value::operator+(
minja::Value *this,
minja::Value *a2,
const minja::Value ***a3,
double a4)
{
char v5; // al
char v6; // cl
long long v8; // r15
const minja::Value **v9; // rax
const minja::Value *v10; // r15
const minja::Value *v11; // r12
const minja::Value **v12; // rax
const minja::Value *v13; // r14
const minja::Value *v14; // r15
long long v15[4]; // [rsp+10h] [rbp-98h] BYREF
__int128 v16; // [rsp+30h] [rbp-78h] BYREF
long long v17; // [rsp+40h] [rbp-68h]
_QWORD v18[4]; // [rsp+48h] [rbp-60h] BYREF
_QWORD v19[8]; // [rsp+68h] [rbp-40h] BYREF
v5 = *((_BYTE *)a2 + 64);
if ( v5 == 3 || (v6 = *((_BYTE *)a3 + 64), v6 == 3) )
{
minja::Value::to_str[abi:cxx11]((std::__cxx11 *)v19, a2, a4);
minja::Value::to_str[abi:cxx11]((std::__cxx11 *)v18, (minja::Value *)a3, a4);
std::operator+<char>((long long)v15, v19, v18);
minja::Value::Value(this);
std::string::~string(v15);
std::string::~string(v18);
std::string::~string(v19);
}
else if ( (unsigned __int8)((v5 - 5) | (v6 - 5)) > 1u )
{
if ( *((_QWORD *)a2 + 2) && a3[2] )
{
v16 = 0LL;
v17 = 0LL;
minja::Value::array((long long)this, (long long *)&v16);
std::vector<minja::Value>::~vector((long long)&v16);
v9 = (const minja::Value **)*((_QWORD *)a2 + 2);
v10 = *v9;
v11 = v9[1];
while ( v10 != v11 )
{
minja::Value::push_back(this, v10);
v10 = (const minja::Value *)((char *)v10 + 80);
}
v12 = a3[2];
v13 = *v12;
v14 = v12[1];
while ( v13 != v14 )
{
minja::Value::push_back(this, v13);
v13 = (const minja::Value *)((char *)v13 + 80);
}
}
else
{
minja::Value::get<double>(a2);
minja::Value::get<double>((minja::Value *)a3);
*(double *)v15 = a4 + a4;
minja::Value::Value(this, (const double *)v15);
}
}
else
{
v8 = minja::Value::get<long>(a2);
v15[0] = v8 + minja::Value::get<long>((minja::Value *)a3);
minja::Value::Value(this, v15);
}
return this;
}
|
operator+:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV AL,byte ptr [RSI + 0x40]
CMP AL,0x3
JZ 0x00152a11
MOV CL,byte ptr [R14 + 0x40]
CMP CL,0x3
JNZ 0x00152a7c
LAB_00152a11:
LEA RDI,[RSP + 0x68]
MOV RSI,R15
CALL 0x0015292e
LAB_00152a1e:
LEA RDI,[RSP + 0x48]
MOV RSI,R14
CALL 0x0015292e
LAB_00152a2b:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x68]
LEA RDX,[RSP + 0x48]
CALL 0x00128b59
LAB_00152a3f:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x0014085e
LAB_00152a4c:
LEA RDI,[RSP + 0x10]
CALL 0x00120d88
LEA RDI,[RSP + 0x48]
CALL 0x00120d88
LEA RDI,[RSP + 0x68]
CALL 0x00120d88
LAB_00152a6a:
MOV RAX,RBX
ADD RSP,0x88
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00152a7c:
ADD AL,0xfb
ADD CL,0xfb
OR CL,AL
CMP CL,0x1
JA 0x00152ab0
MOV RDI,R15
CALL 0x0013cd9c
MOV R15,RAX
MOV RDI,R14
CALL 0x0013cd9c
ADD RAX,R15
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],RAX
MOV RDI,RBX
CALL 0x0013ce52
JMP 0x00152a6a
LAB_00152ab0:
CMP qword ptr [R15 + 0x10],0x0
JZ 0x00152b03
CMP qword ptr [R14 + 0x10],0x0
JZ 0x00152b03
XORPD XMM0,XMM0
LEA RSI,[RSP + 0x30]
MOVAPD xmmword ptr [RSI],XMM0
AND qword ptr [RSI + 0x10],0x0
LAB_00152ad0:
MOV RDI,RBX
CALL 0x0014b7a4
LEA RDI,[RSP + 0x30]
CALL 0x0014afb6
MOV RAX,qword ptr [R15 + 0x10]
MOV R15,qword ptr [RAX]
MOV R12,qword ptr [RAX + 0x8]
LAB_00152aed:
CMP R15,R12
JZ 0x00152b35
LAB_00152af2:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0014b810
LAB_00152afd:
ADD R15,0x50
JMP 0x00152aed
LAB_00152b03:
MOV RDI,R15
CALL 0x0013ce70
MOVSD qword ptr [RSP + 0x8],XMM0
MOV RDI,R14
CALL 0x0013ce70
ADDSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x10]
MOVSD qword ptr [RSI],XMM0
MOV RDI,RBX
CALL 0x0013cf26
JMP 0x00152a6a
LAB_00152b35:
MOV RAX,qword ptr [R14 + 0x10]
MOV R14,qword ptr [RAX]
MOV R15,qword ptr [RAX + 0x8]
LAB_00152b40:
CMP R14,R15
JZ 0x00152a6a
LAB_00152b49:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0014b810
LAB_00152b54:
ADD R14,0x50
JMP 0x00152b40
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
Value * __thiscall minja::Value::operator+(Value *this,Value *param_1)
{
Value *pVVar1;
long lVar2;
long lVar3;
Value *in_RDX;
Value *pVVar4;
double dVar5;
double local_98 [4];
int8 local_78;
int8 uStack_70;
int8 local_68;
string local_60 [32];
string local_40 [32];
if ((param_1[0x40] == (Value)0x3) || (in_RDX[0x40] == (Value)0x3)) {
to_str_abi_cxx11_();
/* try { // try from 00152a1e to 00152a2a has its CatchHandler @ 00152b87 */
to_str_abi_cxx11_();
/* try { // try from 00152a2b to 00152a3e has its CatchHandler @ 00152b78 */
std::operator+((string *)local_98,local_40);
/* try { // try from 00152a3f to 00152a4b has its CatchHandler @ 00152b69 */
Value(this,(string *)local_98);
std::__cxx11::string::~string((string *)local_98);
std::__cxx11::string::~string(local_60);
std::__cxx11::string::~string(local_40);
}
else if ((byte)((char)in_RDX[0x40] - 5U | (char)param_1[0x40] - 5U) < 2) {
lVar2 = get<long>(param_1);
lVar3 = get<long>(in_RDX);
local_98[0] = (double)(lVar3 + lVar2);
Value(this,(long *)local_98);
}
else if ((*(long *)(param_1 + 0x10) == 0) || (*(long *)(in_RDX + 0x10) == 0)) {
dVar5 = get<double>(param_1);
local_98[0] = get<double>(in_RDX);
local_98[0] = local_98[0] + dVar5;
Value(this,local_98);
}
else {
local_78 = 0;
uStack_70 = 0;
local_68 = 0;
/* try { // try from 00152ad0 to 00152ad7 has its CatchHandler @ 00152b5a */
array(this);
std::vector<minja::Value,std::allocator<minja::Value>>::~vector
((vector<minja::Value,std::allocator<minja::Value>> *)&local_78);
pVVar1 = (Value *)(*(int8 **)(param_1 + 0x10))[1];
for (pVVar4 = (Value *)**(int8 **)(param_1 + 0x10); pVVar4 != pVVar1;
pVVar4 = pVVar4 + 0x50) {
/* try { // try from 00152af2 to 00152afc has its CatchHandler @ 00152b98 */
push_back(this,pVVar4);
}
pVVar1 = (Value *)(*(int8 **)(in_RDX + 0x10))[1];
for (pVVar4 = (Value *)**(int8 **)(in_RDX + 0x10); pVVar4 != pVVar1;
pVVar4 = pVVar4 + 0x50) {
/* try { // try from 00152b49 to 00152b53 has its CatchHandler @ 00152b96 */
push_back(this,pVVar4);
}
}
return this;
}
|
|
19,752
|
fn_same
|
eloqsql/mysys/mf_same.c
|
char * fn_same(char *to, const char *name, int flag)
{
char dev[FN_REFLEN];
const char *ext;
size_t dev_length;
DBUG_ENTER("fn_same");
DBUG_PRINT("enter",("to: %s name: %s flag: %d",to,name,flag));
if ((ext=strrchr(name+dirname_part(dev, name, &dev_length),FN_EXTCHAR)) == 0)
ext="";
DBUG_RETURN(fn_format(to,to,dev,ext,flag));
}
|
O0
|
c
|
fn_same:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
movl %edx, -0x224(%rbp)
jmp 0x10314e
movq -0x220(%rbp), %rax
movq %rax, -0x240(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
leaq -0x238(%rbp), %rdx
callq 0xdf3e0
movq -0x240(%rbp), %rdi
addq %rax, %rdi
movl $0x2e, %esi
callq 0x2a700
movq %rax, -0x230(%rbp)
cmpq $0x0, %rax
jne 0x1031a5
leaq 0x54901(%rip), %rax # 0x157a9f
movq %rax, -0x230(%rbp)
jmp 0x1031a7
movq -0x218(%rbp), %rdi
movq -0x218(%rbp), %rsi
leaq -0x210(%rbp), %rdx
movq -0x230(%rbp), %rcx
movl -0x224(%rbp), %r8d
callq 0xdf500
movq %rax, -0x248(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1031f8
movq -0x248(%rbp), %rax
addq $0x250, %rsp # imm = 0x250
popq %rbp
retq
callq 0x2a250
nopl (%rax)
|
fn_same:
push rbp
mov rbp, rsp
sub rsp, 250h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
mov [rbp+var_224], edx
jmp short $+2
loc_10314E:
mov rax, [rbp+var_220]
mov [rbp+var_240], rax
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
lea rdx, [rbp+var_238]
call dirname_part
mov rdi, [rbp+var_240]
add rdi, rax
mov esi, 2Eh ; '.'
call _strrchr
mov [rbp+var_230], rax
cmp rax, 0
jnz short loc_1031A5
lea rax, asc_157A9B+4; ""
mov [rbp+var_230], rax
loc_1031A5:
jmp short $+2
loc_1031A7:
mov rdi, [rbp+var_218]
mov rsi, [rbp+var_218]
lea rdx, [rbp+var_210]
mov rcx, [rbp+var_230]
mov r8d, [rbp+var_224]
call fn_format
mov [rbp+var_248], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_1031F8
mov rax, [rbp+var_248]
add rsp, 250h
pop rbp
retn
loc_1031F8:
call ___stack_chk_fail
|
_BYTE * fn_same(_BYTE *a1, _BYTE *a2, int a3)
{
long long v3; // rax
long long v5; // [rsp+18h] [rbp-238h] BYREF
char *v6; // [rsp+20h] [rbp-230h]
int v7; // [rsp+2Ch] [rbp-224h]
_BYTE *v8; // [rsp+30h] [rbp-220h]
_BYTE *v9; // [rsp+38h] [rbp-218h]
_BYTE v10[520]; // [rsp+40h] [rbp-210h] BYREF
unsigned long long v11; // [rsp+248h] [rbp-8h]
v11 = __readfsqword(0x28u);
v9 = a1;
v8 = a2;
v7 = a3;
v3 = dirname_part((long long)v10, a2, &v5);
v6 = (char *)strrchr(&a2[v3], 46LL);
if ( !v6 )
v6 = "";
return fn_format(v9, v9, (long long)v10, v6, v7);
}
| |||
19,753
|
fn_same
|
eloqsql/mysys/mf_same.c
|
char * fn_same(char *to, const char *name, int flag)
{
char dev[FN_REFLEN];
const char *ext;
size_t dev_length;
DBUG_ENTER("fn_same");
DBUG_PRINT("enter",("to: %s name: %s flag: %d",to,name,flag));
if ((ext=strrchr(name+dirname_part(dev, name, &dev_length),FN_EXTCHAR)) == 0)
ext="";
DBUG_RETURN(fn_format(to,to,dev,ext,flag));
}
|
O3
|
c
|
fn_same:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
leaq -0x230(%rbp), %r12
leaq -0x238(%rbp), %rdx
movq %r12, %rdi
callq 0x94789
addq %rax, %r14
movq %r14, %rdi
movl $0x2e, %esi
callq 0x29750
testq %rax, %rax
leaq 0x36d60(%rip), %rcx # 0xdfa83
cmovneq %rax, %rcx
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebx, %r8d
callq 0x94834
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0xa8d57
addq $0x220, %rsp # imm = 0x220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29250
|
fn_same:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 220h
mov ebx, edx
mov r14, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
lea r12, [rbp+var_230]
lea rdx, [rbp+var_238]
mov rdi, r12
call dirname_part
add r14, rax
mov rdi, r14
mov esi, 2Eh ; '.'
call _strrchr
test rax, rax
lea rcx, asc_DFA7F+4; ""
cmovnz rcx, rax
mov rdi, r15
mov rsi, r15
mov rdx, r12
mov r8d, ebx
call fn_format
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_A8D57
add rsp, 220h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_A8D57:
call ___stack_chk_fail
|
_BYTE * fn_same(_BYTE *a1, _BYTE *a2, __int16 a3)
{
long long v4; // rax
long long v5; // rax
char *v6; // rcx
long long v8; // [rsp+8h] [rbp-238h] BYREF
_BYTE v9[520]; // [rsp+10h] [rbp-230h] BYREF
unsigned long long v10; // [rsp+218h] [rbp-28h]
v10 = __readfsqword(0x28u);
v4 = dirname_part((long long)v9, a2, &v8);
v5 = strrchr(&a2[v4], 46LL);
v6 = "";
if ( v5 )
v6 = (char *)v5;
return fn_format(a1, a1, (long long)v9, v6, a3);
}
|
fn_same:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x220
MOV EBX,EDX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
LEA R12,[RBP + -0x230]
LEA RDX,[RBP + -0x238]
MOV RDI,R12
CALL 0x00194789
ADD R14,RAX
MOV RDI,R14
MOV ESI,0x2e
CALL 0x00129750
TEST RAX,RAX
LEA RCX,[0x1dfa83]
CMOVNZ RCX,RAX
MOV RDI,R15
MOV RSI,R15
MOV RDX,R12
MOV R8D,EBX
CALL 0x00194834
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x001a8d57
ADD RSP,0x220
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001a8d57:
CALL 0x00129250
|
void fn_same(int8 param_1,long param_2,int4 param_3)
{
long lVar1;
char *pcVar2;
char *pcVar3;
long in_FS_OFFSET;
int1 local_240 [8];
int1 local_238 [520];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = dirname_part(local_238,param_2,local_240);
pcVar2 = strrchr((char *)(param_2 + lVar1),0x2e);
pcVar3 = "";
if (pcVar2 != (char *)0x0) {
pcVar3 = pcVar2;
}
fn_format(param_1,param_1,local_238,pcVar3,param_3);
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
19,754
|
js_bound_function_mark
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_bound_function_mark(JSRuntime *rt, JSValue val,
JS_MarkFunc *mark_func)
{
JSObject *p = JS_VALUE_GET_OBJ(val);
JSBoundFunction *bf = p->u.bound_function;
int i;
JS_MarkValue(rt, bf->func_obj, mark_func);
JS_MarkValue(rt, bf->this_val, mark_func);
for(i = 0; i < bf->argc; i++)
JS_MarkValue(rt, bf->argv[i], mark_func);
}
|
O0
|
c
|
js_bound_function_mark:
subq $0x38, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x29920
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x29920
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x5a135
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
addq $0x28, %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x18(%rsp), %rcx
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x29920
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x5a0ef
addq $0x38, %rsp
retq
nopw (%rax,%rax)
|
js_bound_function_mark:
sub rsp, 38h
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_8], rdx
mov [rsp+38h+var_18], rdi
mov [rsp+38h+var_20], rcx
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_28], rax
mov rax, [rsp+38h+var_28]
mov rax, [rax+30h]
mov [rsp+38h+var_30], rax
mov rdi, [rsp+38h+var_18]
mov rax, [rsp+38h+var_30]
mov rcx, [rsp+38h+var_20]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_MarkValue
mov rdi, [rsp+38h+var_18]
mov rax, [rsp+38h+var_30]
mov rcx, [rsp+38h+var_20]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
call JS_MarkValue
mov [rsp+38h+var_34], 0
loc_5A0EF:
mov eax, [rsp+38h+var_34]
mov rcx, [rsp+38h+var_30]
cmp eax, [rcx+20h]
jge short loc_5A135
mov rdi, [rsp+38h+var_18]
mov rax, [rsp+38h+var_30]
add rax, 28h ; '('
movsxd rcx, [rsp+38h+var_34]
shl rcx, 4
add rax, rcx
mov rcx, [rsp+38h+var_20]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_MarkValue
mov eax, [rsp+38h+var_34]
add eax, 1
mov [rsp+38h+var_34], eax
jmp short loc_5A0EF
loc_5A135:
add rsp, 38h
retn
|
long long js_bound_function_mark(
long long a1,
long long a2,
long long a3,
long long ( *a4)(long long, long long))
{
long long result; // rax
unsigned int i; // [rsp+4h] [rbp-34h]
long long v6; // [rsp+8h] [rbp-30h]
v6 = *(_QWORD *)(a2 + 48);
JS_MarkValue(a1, *(_QWORD *)v6, *(_QWORD *)(v6 + 8), a4);
JS_MarkValue(a1, *(_QWORD *)(v6 + 16), *(_QWORD *)(v6 + 24), a4);
for ( i = 0; ; ++i )
{
result = i;
if ( (signed int)i >= *(_DWORD *)(v6 + 32) )
break;
JS_MarkValue(a1, *(_QWORD *)(16LL * (int)i + v6 + 40), *(_QWORD *)(16LL * (int)i + v6 + 40 + 8), a4);
}
return result;
}
|
js_bound_function_mark:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RCX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00129920
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x00129920
MOV dword ptr [RSP + 0x4],0x0
LAB_0015a0ef:
MOV EAX,dword ptr [RSP + 0x4]
MOV RCX,qword ptr [RSP + 0x8]
CMP EAX,dword ptr [RCX + 0x20]
JGE 0x0015a135
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x28
MOVSXD RCX,dword ptr [RSP + 0x4]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00129920
MOV EAX,dword ptr [RSP + 0x4]
ADD EAX,0x1
MOV dword ptr [RSP + 0x4],EAX
JMP 0x0015a0ef
LAB_0015a135:
ADD RSP,0x38
RET
|
void js_bound_function_mark(int8 param_1,long param_2,int8 param_3,int8 param_4)
{
int8 *puVar1;
int local_34;
puVar1 = *(int8 **)(param_2 + 0x30);
JS_MarkValue(param_1,*puVar1,puVar1[1],param_4);
JS_MarkValue(param_1,puVar1[2],puVar1[3],param_4);
for (local_34 = 0; local_34 < *(int *)(puVar1 + 4); local_34 = local_34 + 1) {
JS_MarkValue(param_1,puVar1[(long)local_34 * 2 + 5],(puVar1 + (long)local_34 * 2 + 5)[1],param_4
);
}
return;
}
|
|
19,755
|
js_bound_function_mark
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_bound_function_mark(JSRuntime *rt, JSValue val,
JS_MarkFunc *mark_func)
{
JSObject *p = JS_VALUE_GET_OBJ(val);
JSBoundFunction *bf = p->u.bound_function;
int i;
JS_MarkValue(rt, bf->func_obj, mark_func);
JS_MarkValue(rt, bf->this_val, mark_func);
for(i = 0; i < bf->argc; i++)
JS_MarkValue(rt, bf->argv[i], mark_func);
}
|
O1
|
c
|
js_bound_function_mark:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movl $0xfffffffe, %r15d # imm = 0xFFFFFFFE
movq 0x30(%rsi), %r12
movsd (%r12), %xmm0
movl 0x8(%r12), %eax
movsd %xmm0, (%rsp)
andl $-0x2, %eax
cmpl %r15d, %eax
jne 0x39e42
movq (%rsp), %rsi
movq %r14, %rdi
callq *%rbx
movsd 0x10(%r12), %xmm0
movl 0x18(%r12), %eax
movsd %xmm0, (%rsp)
andl $-0x2, %eax
cmpl %r15d, %eax
jne 0x39e64
movq (%rsp), %rsi
movq %r14, %rdi
callq *%rbx
cmpl $0x0, 0x20(%r12)
jle 0x39ea4
leaq 0x30(%r12), %r13
xorl %ebp, %ebp
movsd -0x8(%r13), %xmm0
movl (%r13), %eax
movsd %xmm0, (%rsp)
andl $-0x2, %eax
cmpl %r15d, %eax
jne 0x39e93
movq (%rsp), %rsi
movq %r14, %rdi
callq *%rbx
incq %rbp
movslq 0x20(%r12), %rax
addq $0x10, %r13
cmpq %rax, %rbp
jl 0x39e73
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_bound_function_mark:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdi
mov r15d, 0FFFFFFFEh
mov r12, [rsi+30h]
movsd xmm0, qword ptr [r12]
mov eax, [r12+8]
movsd [rsp+38h+var_38], xmm0
and eax, 0FFFFFFFEh
cmp eax, r15d
jnz short loc_39E42
mov rsi, [rsp+38h+var_38]
mov rdi, r14
call rbx
loc_39E42:
movsd xmm0, qword ptr [r12+10h]
mov eax, [r12+18h]
movsd [rsp+38h+var_38], xmm0
and eax, 0FFFFFFFEh
cmp eax, r15d
jnz short loc_39E64
mov rsi, [rsp+38h+var_38]
mov rdi, r14
call rbx
loc_39E64:
cmp dword ptr [r12+20h], 0
jle short loc_39EA4
lea r13, [r12+30h]
xor ebp, ebp
loc_39E73:
movsd xmm0, qword ptr [r13-8]
mov eax, [r13+0]
movsd [rsp+38h+var_38], xmm0
and eax, 0FFFFFFFEh
cmp eax, r15d
jnz short loc_39E93
mov rsi, [rsp+38h+var_38]
mov rdi, r14
call rbx
loc_39E93:
inc rbp
movsxd rax, dword ptr [r12+20h]
add r13, 10h
cmp rbp, rax
jl short loc_39E73
loc_39EA4:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long js_bound_function_mark(long long a1, long long a2, long long a3, void ( *a4)(long long, _QWORD))
{
long long v5; // r12
long long result; // rax
_DWORD *v7; // r13
long long v8; // rbp
v5 = *(_QWORD *)(a2 + 48);
if ( (*(_DWORD *)(v5 + 8) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)v5);
result = *(_DWORD *)(v5 + 24) & 0xFFFFFFFE;
if ( (_DWORD)result == -2 )
result = ((long long ( *)(long long, _QWORD))a4)(a1, *(_QWORD *)(v5 + 16));
if ( *(int *)(v5 + 32) > 0 )
{
v7 = (_DWORD *)(v5 + 48);
v8 = 0LL;
do
{
if ( (*v7 & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *((_QWORD *)v7 - 1));
++v8;
result = *(int *)(v5 + 32);
v7 += 4;
}
while ( v8 < result );
}
return result;
}
|
js_bound_function_mark:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDI
MOV R15D,0xfffffffe
MOV R12,qword ptr [RSI + 0x30]
MOVSD XMM0,qword ptr [R12]
MOV EAX,dword ptr [R12 + 0x8]
MOVSD qword ptr [RSP],XMM0
AND EAX,0xfffffffe
CMP EAX,R15D
JNZ 0x00139e42
MOV RSI,qword ptr [RSP]
MOV RDI,R14
CALL RBX
LAB_00139e42:
MOVSD XMM0,qword ptr [R12 + 0x10]
MOV EAX,dword ptr [R12 + 0x18]
MOVSD qword ptr [RSP],XMM0
AND EAX,0xfffffffe
CMP EAX,R15D
JNZ 0x00139e64
MOV RSI,qword ptr [RSP]
MOV RDI,R14
CALL RBX
LAB_00139e64:
CMP dword ptr [R12 + 0x20],0x0
JLE 0x00139ea4
LEA R13,[R12 + 0x30]
XOR EBP,EBP
LAB_00139e73:
MOVSD XMM0,qword ptr [R13 + -0x8]
MOV EAX,dword ptr [R13]
MOVSD qword ptr [RSP],XMM0
AND EAX,0xfffffffe
CMP EAX,R15D
JNZ 0x00139e93
MOV RSI,qword ptr [RSP]
MOV RDI,R14
CALL RBX
LAB_00139e93:
INC RBP
MOVSXD RAX,dword ptr [R12 + 0x20]
ADD R13,0x10
CMP RBP,RAX
JL 0x00139e73
LAB_00139ea4:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void js_bound_function_mark(int8 param_1,long param_2,int8 param_3,code *param_4)
{
int8 *puVar1;
long lVar2;
uint *puVar3;
puVar1 = *(int8 **)(param_2 + 0x30);
if ((*(uint *)(puVar1 + 1) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*puVar1);
}
if ((*(uint *)(puVar1 + 3) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,puVar1[2]);
}
if (0 < *(int *)(puVar1 + 4)) {
puVar3 = (uint *)(puVar1 + 6);
lVar2 = 0;
do {
if ((*puVar3 & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*(int8 *)(puVar3 + -2));
}
lVar2 = lVar2 + 1;
puVar3 = puVar3 + 4;
} while (lVar2 < *(int *)(puVar1 + 4));
}
return;
}
|
|
19,756
|
ecp_safe_invert_jac
|
msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/ecp.c
|
static int ecp_safe_invert_jac(const mbedtls_ecp_group *grp,
mbedtls_ecp_point *Q,
unsigned char inv)
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
unsigned char nonzero;
mbedtls_mpi mQY;
mbedtls_mpi_init(&mQY);
/* Use the fact that -Q.Y mod P = P - Q.Y unless Q.Y == 0 */
MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&mQY, &grp->P, &Q->Y));
nonzero = mbedtls_mpi_cmp_int(&Q->Y, 0) != 0;
MBEDTLS_MPI_CHK(mbedtls_mpi_safe_cond_assign(&Q->Y, &mQY, inv & nonzero));
cleanup:
mbedtls_mpi_free(&mQY);
return ret;
}
|
O3
|
c
|
ecp_safe_invert_jac:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x7defc
addq $0x8, %r14
addq $0x18, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7f45e
movl %eax, %r14d
testl %eax, %eax
jne 0x874e5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7f149
andb $0x1, %bpl
testl %eax, %eax
movzbl %bpl, %ecx
cmovel %eax, %ecx
movzbl %cl, %edx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8281f
movl %eax, %r14d
movq %rsp, %rdi
callq 0x7df0a
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
ecp_safe_invert_jac:
push rbp
push r15
push r14
push rbx
sub rsp, 18h
mov ebp, edx
mov rbx, rsi
mov r14, rdi
mov r15, rsp
mov rdi, r15
call mbedtls_mpi_init
add r14, 8
add rbx, 18h
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call mbedtls_mpi_sub_mpi
mov r14d, eax
test eax, eax
jnz short loc_874E5
mov rdi, rbx
xor esi, esi
call mbedtls_mpi_cmp_int
and bpl, 1
test eax, eax
movzx ecx, bpl
cmovz ecx, eax
movzx edx, cl
mov rsi, rsp
mov rdi, rbx
call mbedtls_mpi_safe_cond_assign
mov r14d, eax
loc_874E5:
mov rdi, rsp
call mbedtls_mpi_free
mov eax, r14d
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long ecp_safe_invert_jac(long long a1, long long a2, char a3)
{
_QWORD *v4; // rbx
unsigned int v5; // r14d
int v6; // eax
unsigned __int8 v7; // cl
int v9[14]; // [rsp+0h] [rbp-38h] BYREF
mbedtls_mpi_init((long long)v9);
v4 = (_QWORD *)(a2 + 24);
v5 = mbedtls_mpi_sub_mpi(v9, (int *)(a1 + 8), (_DWORD *)(a2 + 24));
if ( !v5 )
{
v6 = mbedtls_mpi_cmp_int(v4, 0LL);
v7 = a3 & 1;
if ( !v6 )
v7 = 0;
v5 = mbedtls_mpi_safe_cond_assign((long long)v4, (long long)v9, v7);
}
mbedtls_mpi_free((long long)v9);
return v5;
}
|
ecp_safe_invert_jac:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV EBP,EDX
MOV RBX,RSI
MOV R14,RDI
MOV R15,RSP
MOV RDI,R15
CALL 0x0017defc
ADD R14,0x8
ADD RBX,0x18
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0017f45e
MOV R14D,EAX
TEST EAX,EAX
JNZ 0x001874e5
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0017f149
AND BPL,0x1
TEST EAX,EAX
MOVZX ECX,BPL
CMOVZ ECX,EAX
MOVZX EDX,CL
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0018281f
MOV R14D,EAX
LAB_001874e5:
MOV RDI,RSP
CALL 0x0017df0a
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
|
int ecp_safe_invert_jac(long param_1,long param_2,byte param_3)
{
int iVar1;
int1 auStack_38 [24];
mbedtls_mpi_init(auStack_38);
param_2 = param_2 + 0x18;
iVar1 = mbedtls_mpi_sub_mpi(auStack_38,param_1 + 8,param_2);
if (iVar1 == 0) {
iVar1 = mbedtls_mpi_cmp_int(param_2,0);
param_3 = param_3 & 1;
if (iVar1 == 0) {
param_3 = 0;
}
iVar1 = mbedtls_mpi_safe_cond_assign(param_2,auStack_38,param_3);
}
mbedtls_mpi_free(auStack_38);
return iVar1;
}
|
|
19,757
|
my_is_symlink
|
eloqsql/mysys/my_symlink.c
|
int my_is_symlink(const char *filename __attribute__((unused)))
{
#if defined (HAVE_LSTAT) && defined (S_ISLNK)
struct stat stat_buff;
if (lstat(filename, &stat_buff))
return 0;
MSAN_STAT_WORKAROUND(&stat_buff);
return !!S_ISLNK(stat_buff.st_mode);
#elif defined (_WIN32)
DWORD dwAttr = GetFileAttributes(filename);
return (dwAttr != INVALID_FILE_ATTRIBUTES) &&
(dwAttr & FILE_ATTRIBUTE_REPARSE_POINT);
#else /* No symlinks */
return 0;
#endif
}
|
O3
|
c
|
my_is_symlink:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x98, %rsp
leaq -0x98(%rbp), %rbx
movq %rbx, %rsi
callq 0x24420
movl 0x18(%rbx), %edx
andl $0xf000, %edx # imm = 0xF000
xorl $0xa000, %edx # imm = 0xA000
xorl %ecx, %ecx
orl %eax, %edx
sete %cl
movl %ecx, %eax
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
|
my_is_symlink:
push rbp
mov rbp, rsp
push rbx
sub rsp, 98h
lea rbx, [rbp+var_98]
mov rsi, rbx
call _lstat64
mov edx, [rbx+18h]
and edx, 0F000h
xor edx, 0A000h
xor ecx, ecx
or edx, eax
setz cl
mov eax, ecx
add rsp, 98h
pop rbx
pop rbp
retn
|
_BOOL8 my_is_symlink(long long a1)
{
int v1; // eax
_BYTE v3[24]; // [rsp+8h] [rbp-98h] BYREF
__int16 v4; // [rsp+20h] [rbp-80h]
v1 = lstat64(a1, v3);
return (v1 | v4 & 0xF000 ^ 0xA000) == 0;
}
|
my_is_symlink:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x98
LEA RBX,[RBP + -0x98]
MOV RSI,RBX
CALL 0x00124420
MOV EDX,dword ptr [RBX + 0x18]
AND EDX,0xf000
XOR EDX,0xa000
XOR ECX,ECX
OR EDX,EAX
SETZ CL
MOV EAX,ECX
ADD RSP,0x98
POP RBX
POP RBP
RET
|
bool my_is_symlink(char *param_1)
{
int iVar1;
stat64 local_a0;
iVar1 = lstat64(param_1,&local_a0);
return (local_a0.st_mode & 0xf000) == 0xa000 && iVar1 == 0;
}
|
|
19,758
|
vemit_tap
|
eloqsql/libmariadb/unittest/mytap/tap.c
|
static void
vemit_tap(int pass, char const *fmt, va_list ap)
{
fprintf(tapout, "%sok %d%s",
pass ? "" : "not ",
++g_test.last,
(fmt && *fmt) ? " - " : "");
if (fmt && *fmt)
vfprintf(tapout, fmt, ap);
}
|
O3
|
c
|
vemit_tap:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %eax
movq 0x31ca4(%rip), %r15 # 0x46fb0
movq (%r15), %rdi
testl %eax, %eax
leaq 0x1f52e(%rip), %rcx # 0x34846
leaq 0x1f2c0(%rip), %rax # 0x345df
cmovneq %rax, %rcx
movl 0x33c0e(%rip), %r8d # 0x48f38
incl %r8d
movl %r8d, 0x33c04(%rip) # 0x48f38
testq %rsi, %rsi
je 0x15383
movq %rdx, %rbx
movq %rsi, %r14
cmpb $0x0, (%rsi)
leaq 0x1f502(%rip), %r9 # 0x3484b
cmoveq %rax, %r9
leaq 0x1f4e8(%rip), %rdx # 0x3483c
movl $0x1, %esi
xorl %eax, %eax
callq 0x13740
cmpb $0x0, (%r14)
je 0x153a7
movq (%r15), %rdi
movl $0x1, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13150
leaq 0x1f4b2(%rip), %rdx # 0x3483c
leaq 0x1f24e(%rip), %r9 # 0x345df
movl $0x1, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13740
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
vemit_tap:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov eax, edi
mov r15, cs:stdout_ptr
mov rdi, [r15]
test eax, eax
lea rcx, aNot; "not "
lea rax, aExecuteTestWit+29h; ""
cmovnz rcx, rax
mov r8d, cs:dword_48F38
inc r8d
mov cs:dword_48F38, r8d
test rsi, rsi
jz short loc_15383
mov rbx, rdx
mov r14, rsi
cmp byte ptr [rsi], 0
lea r9, asc_3484B; " - "
cmovz r9, rax
lea rdx, aSokDS; "%sok %d%s"
mov esi, 1
xor eax, eax
call ___fprintf_chk
cmp byte ptr [r14], 0
jz short loc_153A7
mov rdi, [r15]
mov esi, 1
mov rdx, r14
mov rcx, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp ___vfprintf_chk
loc_15383:
lea rdx, aSokDS; "%sok %d%s"
lea r9, aExecuteTestWit+29h; ""
mov esi, 1
xor eax, eax
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp ___fprintf_chk
loc_153A7:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long vemit_tap(int a1, _BYTE *a2, long long a3)
{
const char *v3; // rcx
int v4; // r8d
const char *v6; // r9
long long result; // rax
v3 = "not ";
if ( a1 )
v3 = "";
v4 = ++dword_48F38;
if ( !a2 )
return __fprintf_chk(stdout, 1LL, "%sok %d%s", v3, v4, "");
v6 = " - ";
if ( !*a2 )
v6 = "";
result = __fprintf_chk(stdout, 1LL, "%sok %d%s", v3, v4, v6);
if ( *a2 )
return __vfprintf_chk(stdout, 1LL, a2, a3);
return result;
}
|
vemit_tap:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EAX,EDI
MOV R15,qword ptr [0x00146fb0]
MOV RDI,qword ptr [R15]
TEST EAX,EAX
LEA RCX,[0x134846]
LEA RAX,[0x1345df]
CMOVNZ RCX,RAX
MOV R8D,dword ptr [0x00148f38]
INC R8D
MOV dword ptr [0x00148f38],R8D
TEST RSI,RSI
JZ 0x00115383
MOV RBX,RDX
MOV R14,RSI
CMP byte ptr [RSI],0x0
LEA R9,[0x13484b]
CMOVZ R9,RAX
LEA RDX,[0x13483c]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00113740
CMP byte ptr [R14],0x0
JZ 0x001153a7
MOV RDI,qword ptr [R15]
MOV ESI,0x1
MOV RDX,R14
MOV RCX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00113150
LAB_00115383:
LEA RDX,[0x13483c]
LEA R9,[0x1345df]
MOV ESI,0x1
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00113740
LAB_001153a7:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void vemit_tap(int param_1,char *param_2,int8 param_3)
{
int *puVar1;
char *pcVar2;
char *pcVar3;
puVar1 = PTR_stdout_00146fb0;
pcVar2 = "not ";
if (param_1 != 0) {
pcVar2 = "";
}
DAT_00148f38 = DAT_00148f38 + 1;
if (param_2 == (char *)0x0) {
__fprintf_chk(*(int8 *)PTR_stdout_00146fb0,1,"%sok %d%s",pcVar2,DAT_00148f38,"");
return;
}
pcVar3 = " - ";
if (*param_2 == '\0') {
pcVar3 = "";
}
__fprintf_chk(*(int8 *)PTR_stdout_00146fb0,1,"%sok %d%s",pcVar2,DAT_00148f38,pcVar3);
if (*param_2 != '\0') {
__vfprintf_chk(*(int8 *)puVar1,1,param_2,param_3);
return;
}
return;
}
|
|
19,759
|
mysql_stmt_send_long_data_start
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
int STDCALL
mysql_stmt_send_long_data_start(my_bool *ret, MYSQL_STMT *stmt,
unsigned int param_number,
const char *data, unsigned long length)
{
MK_ASYNC_START_BODY(
mysql_stmt_send_long_data,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
parms.param_number= param_number;
parms.data= data;
parms.length= length;
},
TRUE,
r_my_bool,
/* If stmt->mysql==NULL then we will not block so can call directly. */
if (!stmt->mysql)
{
*ret= mysql_stmt_send_long_data(stmt, param_number, data, length);
return 0;
})
}
|
O0
|
c
|
mysql_stmt_send_long_data_start:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x426fe
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x30ad0
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x42822
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
leaq 0xe6(%rip), %rsi # 0x42830
leaq -0x60(%rbp), %rdx
callq 0x43990
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x40(%rbp), %rax
movb $0x0, 0x14(%rax)
cmpl $0x0, -0x34(%rbp)
jle 0x42782
movq -0x40(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x42822
cmpl $0x0, -0x34(%rbp)
jge 0x4280e
jmp 0x4278e
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 0x229ca(%rip), %rax # 0x65180
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x29c(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x97, %rdi
leaq 0x229a8(%rip), %rax # 0x65190
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x296(%rax)
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
jmp 0x4281b
movq -0x40(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
mysql_stmt_send_long_data_start:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jnz short loc_426FE
mov rdi, [rbp+var_18]
mov esi, [rbp+var_1C]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
call mysql_stmt_send_long_data
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov [rbp+var_4], 0
jmp loc_42822
loc_426FE:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
mov [rbp+var_60], rax
mov eax, [rbp+var_1C]
mov [rbp+var_58], eax
mov rax, [rbp+var_28]
mov [rbp+var_50], rax
mov rax, [rbp+var_30]
mov [rbp+var_48], rax
mov rax, [rbp+var_40]
mov byte ptr [rax+14h], 1
mov rdi, [rbp+var_40]
add rdi, 38h ; '8'
lea rsi, mysql_stmt_send_long_data_start_internal
lea rdx, [rbp+var_60]
call my_context_spawn
mov [rbp+var_34], eax
mov rax, [rbp+var_40]
mov byte ptr [rax+15h], 0
mov rax, [rbp+var_40]
mov byte ptr [rax+14h], 0
cmp [rbp+var_34], 0
jle short loc_42782
mov rax, [rbp+var_40]
mov byte ptr [rax+15h], 1
mov rax, [rbp+var_40]
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_42822
loc_42782:
cmp [rbp+var_34], 0
jge loc_4280E
jmp short $+2
loc_4278E:
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 byte ptr [rax], 1
jmp short loc_4281B
loc_4280E:
mov rax, [rbp+var_40]
mov cl, [rax+8]
mov rax, [rbp+var_10]
mov [rax], cl
loc_4281B:
mov [rbp+var_4], 0
loc_42822:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
|
long long mysql_stmt_send_long_data_start(char *a1, long long a2, unsigned int a3, long long a4, long long a5)
{
long long v6; // [rsp+0h] [rbp-60h] BYREF
unsigned int v7; // [rsp+8h] [rbp-58h]
long long v8; // [rsp+10h] [rbp-50h]
long long v9; // [rsp+18h] [rbp-48h]
_BYTE *v10; // [rsp+20h] [rbp-40h]
int v11; // [rsp+2Ch] [rbp-34h]
long long v12; // [rsp+30h] [rbp-30h]
long long v13; // [rsp+38h] [rbp-28h]
unsigned int v14; // [rsp+44h] [rbp-1Ch]
long long v15; // [rsp+48h] [rbp-18h]
char *v16; // [rsp+50h] [rbp-10h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12 = a5;
if ( *(_QWORD *)(a2 + 56) )
{
v10 = *(_BYTE **)(*(_QWORD *)(*(_QWORD *)(v15 + 56) + 1152LL) + 40LL);
v6 = v15;
v7 = v14;
v8 = v13;
v9 = v12;
v10[20] = 1;
v11 = my_context_spawn(v10 + 56, mysql_stmt_send_long_data_start_internal, &v6);
v10[21] = 0;
v10[20] = 0;
if ( v11 <= 0 )
{
if ( v11 >= 0 )
{
*v16 = v10[8];
}
else
{
*(_DWORD *)(*(_QWORD *)(v15 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(v15 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(v15 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(v15 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(v15 + 56) + 662LL) = 0;
*v16 = 1;
}
return 0;
}
else
{
v10[21] = 1;
return *(unsigned int *)v10;
}
}
else
{
*v16 = mysql_stmt_send_long_data(v15, v14, v13, v12);
return 0;
}
}
|
mysql_stmt_send_long_data_start:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JNZ 0x001426fe
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x1c]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x00130ad0
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00142822
LAB_001426fe:
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 + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x58],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x14],0x1
MOV RDI,qword ptr [RBP + -0x40]
ADD RDI,0x38
LEA RSI,[0x142830]
LEA RDX,[RBP + -0x60]
CALL 0x00143990
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x15],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x14],0x0
CMP dword ptr [RBP + -0x34],0x0
JLE 0x00142782
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x15],0x1
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00142822
LAB_00142782:
CMP dword ptr [RBP + -0x34],0x0
JGE 0x0014280e
JMP 0x0014278e
LAB_0014278e:
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,[0x165180]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
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,[0x165190]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
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 byte ptr [RAX],0x1
JMP 0x0014281b
LAB_0014280e:
MOV RAX,qword ptr [RBP + -0x40]
MOV CL,byte ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
LAB_0014281b:
MOV dword ptr [RBP + -0x4],0x0
LAB_00142822:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int4
mysql_stmt_send_long_data_start
(int1 *param_1,long param_2,int4 param_3,int8 param_4,int8 param_5
)
{
int1 uVar1;
long local_68;
int4 local_60;
int8 local_58;
int8 local_50;
int4 *local_48;
int local_3c;
int8 local_38;
int8 local_30;
int4 local_24;
long local_20;
int1 *local_18;
int4 local_c;
local_38 = param_5;
local_30 = param_4;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
if (*(long *)(param_2 + 0x38) == 0) {
uVar1 = mysql_stmt_send_long_data(param_2,param_3,param_4,param_5);
*local_18 = uVar1;
local_c = 0;
}
else {
local_48 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(local_48 + 5) = 1;
local_68 = param_2;
local_60 = param_3;
local_58 = param_4;
local_50 = param_5;
local_3c = my_context_spawn(local_48 + 0xe,mysql_stmt_send_long_data_start_internal,&local_68);
*(int1 *)((long)local_48 + 0x15) = 0;
*(int1 *)(local_48 + 5) = 0;
if (local_3c < 1) {
if (local_3c < 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_001651d0,
0x1ff);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x296) = 0;
*local_18 = 1;
}
else {
*local_18 = *(int1 *)(local_48 + 2);
}
local_c = 0;
}
else {
*(int1 *)((long)local_48 + 0x15) = 1;
local_c = *local_48;
}
}
return local_c;
}
|
|
19,760
|
PFS_account::aggregate_transactions(PFS_user*, PFS_host*)
|
eloqsql/storage/perfschema/pfs_account.cc
|
void PFS_account::aggregate_transactions(PFS_user *safe_user, PFS_host *safe_host)
{
if (read_instr_class_transactions_stats() == NULL)
return;
if (likely(safe_user != NULL && safe_host != NULL))
{
/*
Aggregate EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- EVENTS_TRANSACTIONS_SUMMARY_BY_USER_BY_EVENT_NAME
- EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME
in parallel.
*/
aggregate_all_transactions(write_instr_class_transactions_stats(),
safe_user->write_instr_class_transactions_stats(),
safe_host->write_instr_class_transactions_stats());
return;
}
if (safe_user != NULL)
{
/*
Aggregate EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- EVENTS_TRANSACTIONS_SUMMARY_BY_USER_BY_EVENT_NAME
- EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME
in parallel.
*/
aggregate_all_transactions(write_instr_class_transactions_stats(),
safe_user->write_instr_class_transactions_stats(),
&global_transaction_stat);
return;
}
if (safe_host != NULL)
{
/*
Aggregate EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME
*/
aggregate_all_transactions(write_instr_class_transactions_stats(),
safe_host->write_instr_class_transactions_stats());
return;
}
/*
Aggregate EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME
*/
aggregate_all_transactions(write_instr_class_transactions_stats(),
&global_transaction_stat);
return;
}
|
O0
|
cpp
|
PFS_account::aggregate_transactions(PFS_user*, PFS_host*):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x36bb0
cmpq $0x0, %rax
jne 0x57dfc
jmp 0x57eca
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
je 0x57e13
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x57e55
movq -0x20(%rbp), %rdi
callq 0x36bf0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36bf0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36bf0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x3a420
jmp 0x57eca
cmpq $0x0, -0x10(%rbp)
je 0x57e87
movq -0x20(%rbp), %rdi
callq 0x36bf0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36bf0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
leaq 0x3b6f00(%rip), %rdx # 0x40ed80
callq 0x3a420
jmp 0x57eca
cmpq $0x0, -0x18(%rbp)
je 0x57eb2
movq -0x20(%rbp), %rdi
callq 0x36bf0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36bf0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x3a3e0
jmp 0x57eca
movq -0x20(%rbp), %rdi
callq 0x36bf0
movq %rax, %rdi
leaq 0x3b6ebb(%rip), %rsi # 0x40ed80
callq 0x3a3e0
addq $0x50, %rsp
popq %rbp
retq
|
_ZN11PFS_account22aggregate_transactionsEP8PFS_userP8PFS_host:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_8]; this
mov [rbp+var_20], rdi
call _ZNK20PFS_connection_slice35read_instr_class_transactions_statsEv; PFS_connection_slice::read_instr_class_transactions_stats(void)
cmp rax, 0
jnz short loc_57DFC
jmp loc_57ECA
loc_57DFC:
xor eax, eax
cmp [rbp+var_10], 0
mov [rbp+var_21], al
jz short loc_57E13
cmp [rbp+var_18], 0
setnz al
mov [rbp+var_21], al
loc_57E13:
mov al, [rbp+var_21]
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_57E55
mov rdi, [rbp+var_20]; this
call _ZN20PFS_connection_slice36write_instr_class_transactions_statsEv; PFS_connection_slice::write_instr_class_transactions_stats(void)
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]; this
call _ZN20PFS_connection_slice36write_instr_class_transactions_statsEv; PFS_connection_slice::write_instr_class_transactions_stats(void)
mov [rbp+var_30], rax
mov rdi, [rbp+var_18]; this
call _ZN20PFS_connection_slice36write_instr_class_transactions_statsEv; PFS_connection_slice::write_instr_class_transactions_stats(void)
mov rdi, [rbp+var_38]; PFS_transaction_stat *
mov rsi, [rbp+var_30]; PFS_transaction_stat *
mov rdx, rax; PFS_transaction_stat *
call _Z26aggregate_all_transactionsP20PFS_transaction_statS0_S0_; aggregate_all_transactions(PFS_transaction_stat *,PFS_transaction_stat *,PFS_transaction_stat *)
jmp short loc_57ECA
loc_57E55:
cmp [rbp+var_10], 0
jz short loc_57E87
mov rdi, [rbp+var_20]; this
call _ZN20PFS_connection_slice36write_instr_class_transactions_statsEv; PFS_connection_slice::write_instr_class_transactions_stats(void)
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]; this
call _ZN20PFS_connection_slice36write_instr_class_transactions_statsEv; PFS_connection_slice::write_instr_class_transactions_stats(void)
mov rdi, [rbp+var_40]; PFS_transaction_stat *
mov rsi, rax; PFS_transaction_stat *
lea rdx, global_transaction_stat; PFS_transaction_stat *
call _Z26aggregate_all_transactionsP20PFS_transaction_statS0_S0_; aggregate_all_transactions(PFS_transaction_stat *,PFS_transaction_stat *,PFS_transaction_stat *)
jmp short loc_57ECA
loc_57E87:
cmp [rbp+var_18], 0
jz short loc_57EB2
mov rdi, [rbp+var_20]; this
call _ZN20PFS_connection_slice36write_instr_class_transactions_statsEv; PFS_connection_slice::write_instr_class_transactions_stats(void)
mov [rbp+var_48], rax
mov rdi, [rbp+var_18]; this
call _ZN20PFS_connection_slice36write_instr_class_transactions_statsEv; PFS_connection_slice::write_instr_class_transactions_stats(void)
mov rdi, [rbp+var_48]; PFS_transaction_stat *
mov rsi, rax; PFS_transaction_stat *
call _Z26aggregate_all_transactionsP20PFS_transaction_statS0_; aggregate_all_transactions(PFS_transaction_stat *,PFS_transaction_stat *)
jmp short loc_57ECA
loc_57EB2:
mov rdi, [rbp+var_20]; this
call _ZN20PFS_connection_slice36write_instr_class_transactions_statsEv; PFS_connection_slice::write_instr_class_transactions_stats(void)
mov rdi, rax; PFS_transaction_stat *
lea rsi, global_transaction_stat; PFS_transaction_stat *
call _Z26aggregate_all_transactionsP20PFS_transaction_statS0_; aggregate_all_transactions(PFS_transaction_stat *,PFS_transaction_stat *)
loc_57ECA:
add rsp, 50h
pop rbp
retn
|
PFS_transaction_stat * PFS_account::aggregate_transactions(PFS_account *this, PFS_user *a2, PFS_host *a3)
{
PFS_transaction_stat *result; // rax
PFS_transaction_stat *v4; // rax
PFS_transaction_stat *v5; // rax
PFS_transaction_stat *v6; // rax
PFS_transaction_stat *v7; // rax
PFS_transaction_stat *v8; // [rsp+8h] [rbp-48h]
PFS_transaction_stat *v9; // [rsp+10h] [rbp-40h]
PFS_transaction_stat *v10; // [rsp+18h] [rbp-38h]
PFS_transaction_stat *v11; // [rsp+20h] [rbp-30h]
bool v12; // [rsp+2Fh] [rbp-21h]
result = (PFS_transaction_stat *)PFS_connection_slice::read_instr_class_transactions_stats(this);
if ( result )
{
v12 = 0;
if ( a2 )
v12 = a3 != 0LL;
if ( v12 )
{
v10 = (PFS_transaction_stat *)PFS_connection_slice::write_instr_class_transactions_stats(this);
v11 = (PFS_transaction_stat *)PFS_connection_slice::write_instr_class_transactions_stats(a2);
v4 = (PFS_transaction_stat *)PFS_connection_slice::write_instr_class_transactions_stats(a3);
return aggregate_all_transactions(v10, v11, v4);
}
else if ( a2 )
{
v9 = (PFS_transaction_stat *)PFS_connection_slice::write_instr_class_transactions_stats(this);
v5 = (PFS_transaction_stat *)PFS_connection_slice::write_instr_class_transactions_stats(a2);
return aggregate_all_transactions(v9, v5, (PFS_transaction_stat *)&global_transaction_stat);
}
else if ( a3 )
{
v8 = (PFS_transaction_stat *)PFS_connection_slice::write_instr_class_transactions_stats(this);
v6 = (PFS_transaction_stat *)PFS_connection_slice::write_instr_class_transactions_stats(a3);
return aggregate_all_transactions(v8, v6);
}
else
{
v7 = (PFS_transaction_stat *)PFS_connection_slice::write_instr_class_transactions_stats(this);
return aggregate_all_transactions(v7, (PFS_transaction_stat *)&global_transaction_stat);
}
}
return result;
}
|
aggregate_transactions:
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 RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RDI
CALL 0x00136bb0
CMP RAX,0x0
JNZ 0x00157dfc
JMP 0x00157eca
LAB_00157dfc:
XOR EAX,EAX
CMP qword ptr [RBP + -0x10],0x0
MOV byte ptr [RBP + -0x21],AL
JZ 0x00157e13
CMP qword ptr [RBP + -0x18],0x0
SETNZ AL
MOV byte ptr [RBP + -0x21],AL
LAB_00157e13:
MOV AL,byte ptr [RBP + -0x21]
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00157e55
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00136bf0
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00136bf0
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00136bf0
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,RAX
CALL 0x0013a420
JMP 0x00157eca
LAB_00157e55:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00157e87
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00136bf0
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00136bf0
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,RAX
LEA RDX,[0x50ed80]
CALL 0x0013a420
JMP 0x00157eca
LAB_00157e87:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00157eb2
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00136bf0
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00136bf0
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,RAX
CALL 0x0013a3e0
JMP 0x00157eca
LAB_00157eb2:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00136bf0
MOV RDI,RAX
LEA RSI,[0x50ed80]
CALL 0x0013a3e0
LAB_00157eca:
ADD RSP,0x50
POP RBP
RET
|
/* PFS_account::aggregate_transactions(PFS_user*, PFS_host*) */
void __thiscall
PFS_account::aggregate_transactions(PFS_account *this,PFS_user *param_1,PFS_host *param_2)
{
long lVar1;
PFS_transaction_stat *pPVar2;
PFS_transaction_stat *pPVar3;
PFS_transaction_stat *pPVar4;
lVar1 = PFS_connection_slice::read_instr_class_transactions_stats((PFS_connection_slice *)this);
if (lVar1 != 0) {
if (param_1 == (PFS_user *)0x0 || param_2 == (PFS_host *)0x0) {
if (param_1 == (PFS_user *)0x0) {
if (param_2 == (PFS_host *)0x0) {
pPVar2 = (PFS_transaction_stat *)
PFS_connection_slice::write_instr_class_transactions_stats
((PFS_connection_slice *)this);
aggregate_all_transactions(pPVar2,(PFS_transaction_stat *)global_transaction_stat);
}
else {
pPVar2 = (PFS_transaction_stat *)
PFS_connection_slice::write_instr_class_transactions_stats
((PFS_connection_slice *)this);
pPVar3 = (PFS_transaction_stat *)
PFS_connection_slice::write_instr_class_transactions_stats
((PFS_connection_slice *)param_2);
aggregate_all_transactions(pPVar2,pPVar3);
}
}
else {
pPVar2 = (PFS_transaction_stat *)
PFS_connection_slice::write_instr_class_transactions_stats
((PFS_connection_slice *)this);
pPVar3 = (PFS_transaction_stat *)
PFS_connection_slice::write_instr_class_transactions_stats
((PFS_connection_slice *)param_1);
aggregate_all_transactions(pPVar2,pPVar3,(PFS_transaction_stat *)global_transaction_stat);
}
}
else {
pPVar2 = (PFS_transaction_stat *)
PFS_connection_slice::write_instr_class_transactions_stats
((PFS_connection_slice *)this);
pPVar3 = (PFS_transaction_stat *)
PFS_connection_slice::write_instr_class_transactions_stats
((PFS_connection_slice *)param_1);
pPVar4 = (PFS_transaction_stat *)
PFS_connection_slice::write_instr_class_transactions_stats
((PFS_connection_slice *)param_2);
aggregate_all_transactions(pPVar2,pPVar3,pPVar4);
}
}
return;
}
|
|
19,761
|
std::hash<minja::Value>::operator()(minja::Value const&) const
|
monkey531[P]llama/common/minja.hpp
|
size_t operator()(const minja::Value & v) const {
if (!v.is_hashable())
throw std::runtime_error("Unsupported type for hashing: " + v.dump());
return std::hash<json>()(v.get<json>());
}
|
O3
|
cpp
|
std::hash<minja::Value>::operator()(minja::Value const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
cmpq $0x0, 0x10(%rsi)
jne 0xb1b2a
cmpq $0x0, 0x20(%r14)
jne 0xb1b2a
cmpq $0x0, 0x30(%r14)
jne 0xb1b2a
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb1c12
movq %rbx, %rdi
callq 0xb212f
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x58f20
movq %r14, %rdi
callq 0x5e40e
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x1a450
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x86c10
leaq 0x3f7ae(%rip), %rsi # 0xf1300
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x793a5
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1ae20
xorl %ebp, %ebp
movq 0x7a47a(%rip), %rsi # 0x12bff0
movq 0x7a3e3(%rip), %rdx # 0x12bf60
movq %rbx, %rdi
callq 0x1af10
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1ba3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a8e0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1bbe
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a8e0
testb %bpl, %bpl
jne 0xb1be8
jmp 0xb1c0a
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1be8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a8e0
jmp 0xb1be8
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a690
jmp 0xb1c0a
movq %rax, %r14
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f20
movq %rbx, %rdi
callq 0x5e40e
movq %r14, %rdi
callq 0x1af90
|
_ZNKSt4hashIN5minja5ValueEEclERKS1_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rsi
cmp qword ptr [rsi+10h], 0
jnz short loc_B1B2A
cmp qword ptr [r14+20h], 0
jnz short loc_B1B2A
cmp qword ptr [r14+30h], 0
jnz short loc_B1B2A
mov rbx, rsp
mov rdi, rbx
mov rsi, r14
call _ZNK5minja5Value3getIN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEET_v; minja::Value::get<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>>(void)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_; nlohmann::json_abi_v3_11_3::detail::hash<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> const&)
mov rbx, rax
mov r14, rsp
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 rax, rbx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_B1B2A:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+58h+var_38]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnsupportedTyp; "Unsupported type for hashing: "
mov rdi, rsp
lea rdx, [rsp+58h+var_38]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B1BA3
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B1BA3:
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B1BBE
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B1BBE:
test bpl, bpl
jnz short loc_B1BE8
jmp short loc_B1C0A
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B1BE8
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_B1BE8
mov r14, rax
loc_B1BE8:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_B1C0A
mov r14, rax
mov rbx, rsp
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_B1C0A:
mov rdi, r14
call __Unwind_Resume
|
long long std::hash<minja::Value>::operator()(long long a1, _QWORD *a2)
{
long long v2; // rbx
void *exception; // rbx
char v5[16]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v6[16]; // [rsp+20h] [rbp-38h] BYREF
if ( a2[2] || a2[4] || a2[6] )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v6, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v5, (long long)"Unsupported type for hashing: ", (long long)v6);
std::runtime_error::runtime_error(exception, v5);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Value::get<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>>(
v5,
a2);
v2 = nlohmann::json_abi_v3_11_3::detail::hash<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>>(v5);
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(v5);
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(v5);
return v2;
}
|
operator():
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
CMP qword ptr [RSI + 0x10],0x0
JNZ 0x001b1b2a
CMP qword ptr [R14 + 0x20],0x0
JNZ 0x001b1b2a
CMP qword ptr [R14 + 0x30],0x0
JNZ 0x001b1b2a
MOV RBX,RSP
MOV RDI,RBX
MOV RSI,R14
CALL 0x001b1c12
LAB_001b1afe:
MOV RDI,RBX
CALL 0x001b212f
LAB_001b1b06:
MOV RBX,RAX
MOV R14,RSP
MOV RDI,R14
XOR ESI,ESI
CALL 0x00158f20
MOV RDI,R14
CALL 0x0015e40e
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001b1b2a:
MOV EDI,0x10
CALL 0x0011a450
MOV RBX,RAX
LAB_001b1b37:
LEA RDI,[RSP + 0x20]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x00186c10
LAB_001b1b4b:
LEA RSI,[0x1f1300]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x001793a5
MOV BPL,0x1
LAB_001b1b62:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0011ae20
XOR EBP,EBP
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,RBX
CALL 0x0011af10
|
/* std::hash<minja::Value>::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
ulong __thiscall std::hash<minja::Value>::operator()(hash<minja::Value> *this,Value *param_1)
{
ulong uVar1;
runtime_error *this_00;
basic_json abStack_58 [32];
int1 local_38 [32];
if (((*(long *)(param_1 + 0x10) == 0) && (*(long *)(param_1 + 0x20) == 0)) &&
(*(long *)(param_1 + 0x30) == 0)) {
minja::Value::
get<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>>
();
/* try { // try from 001b1afe to 001b1b05 has its CatchHandler @ 001b1bf2 */
uVar1 = nlohmann::json_abi_v3_11_3::detail::
hash<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>>
(abStack_58);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(abStack_58,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)abStack_58);
return uVar1;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001b1b37 to 001b1b4a has its CatchHandler @ 001b1be5 */
minja::Value::dump_abi_cxx11_((int)local_38,SUB81(param_1,0));
/* try { // try from 001b1b4b to 001b1b5e has its CatchHandler @ 001b1bc5 */
operator+((char *)abStack_58,(string *)"Unsupported type for hashing: ");
/* try { // try from 001b1b62 to 001b1b84 has its CatchHandler @ 001b1b85 */
std::runtime_error::runtime_error(this_00,(string *)abStack_58);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
|
|
19,762
|
ftb_check_phrase_internal
|
eloqsql/storage/myisam/ft_boolean_search.c
|
static int ftb_check_phrase_internal(MYSQL_FTPARSER_PARAM *param,
const char *document, int len)
{
FT_WORD word;
MY_FTB_PHRASE_PARAM *phrase_param= param->mysql_ftparam;
const uchar *docend= (uchar*) document + len;
while (ft_simple_get_word(phrase_param->cs, (uchar**) &document, docend,
&word, FALSE))
{
param->mysql_add_word(param, (char*) word.pos, (int)word.len, 0);
if (phrase_param->match)
break;
}
return 0;
}
|
O3
|
c
|
ftb_check_phrase_internal:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x48(%rbp), %r14
movq %rsi, (%r14)
movq 0x18(%rdi), %r13
movslq %edx, %r15
addq %rsi, %r15
leaq -0x40(%rbp), %r12
movq 0x10(%r13), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x739d9
testb %al, %al
je 0x7296f
movq -0x40(%rbp), %rsi
movl -0x30(%rbp), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq *0x8(%rbx)
cmpl $0x0, 0x20(%r13)
je 0x72940
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
ftb_check_phrase_internal:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
lea r14, [rbp+var_48]
mov [r14], rsi
mov r13, [rdi+18h]
movsxd r15, edx
add r15, rsi
lea r12, [rbp+var_40]
loc_72940:
mov rdi, [r13+10h]
mov rsi, r14
mov rdx, r15
mov rcx, r12
xor r8d, r8d
call ft_simple_get_word
test al, al
jz short loc_7296F
mov rsi, [rbp+var_40]
mov edx, [rbp+var_30]
mov rdi, rbx
xor ecx, ecx
call qword ptr [rbx+8]
cmp dword ptr [r13+20h], 0
jz short loc_72940
loc_7296F:
xor eax, eax
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ftb_check_phrase_internal(long long a1, long long a2, int a3)
{
long long v3; // r13
long long v4; // r15
long long v6; // [rsp+8h] [rbp-48h] BYREF
long long v7; // [rsp+10h] [rbp-40h] BYREF
unsigned int v8; // [rsp+20h] [rbp-30h]
v6 = a2;
v3 = *(_QWORD *)(a1 + 24);
v4 = a2 + a3;
do
{
if ( !(unsigned __int8)ft_simple_get_word(*(_QWORD *)(v3 + 16), &v6, v4, &v7, 0LL) )
break;
(*(void ( **)(long long, long long, _QWORD, _QWORD))(a1 + 8))(a1, v7, v8, 0LL);
}
while ( !*(_DWORD *)(v3 + 32) );
return 0LL;
}
|
ftb_check_phrase_internal:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RBP + -0x48]
MOV qword ptr [R14],RSI
MOV R13,qword ptr [RDI + 0x18]
MOVSXD R15,EDX
ADD R15,RSI
LEA R12,[RBP + -0x40]
LAB_00172940:
MOV RDI,qword ptr [R13 + 0x10]
MOV RSI,R14
MOV RDX,R15
MOV RCX,R12
XOR R8D,R8D
CALL 0x001739d9
TEST AL,AL
JZ 0x0017296f
MOV RSI,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x30]
MOV RDI,RBX
XOR ECX,ECX
CALL qword ptr [RBX + 0x8]
CMP dword ptr [R13 + 0x20],0x0
JZ 0x00172940
LAB_0017296f:
XOR EAX,EAX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 ftb_check_phrase_internal(long param_1,long param_2,int param_3)
{
long lVar1;
char cVar2;
long local_50;
int8 local_48 [2];
int4 local_38;
lVar1 = *(long *)(param_1 + 0x18);
local_50 = param_2;
do {
cVar2 = ft_simple_get_word(*(int8 *)(lVar1 + 0x10),&local_50,param_3 + param_2,local_48,0)
;
if (cVar2 == '\0') {
return 0;
}
(**(code **)(param_1 + 8))(param_1,local_48[0],local_38,0);
} while (*(int *)(lVar1 + 0x20) == 0);
return 0;
}
|
|
19,763
|
minja::SubscriptExpr::SubscriptExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&)
|
monkey531[P]llama/common/minja.hpp
|
Expression(const Location & location) : location(location) {}
|
O3
|
cpp
|
minja::SubscriptExpr::SubscriptExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&):
leaq 0x84c5d(%rip), %rax # 0xdc288
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x5765c
movq 0x8694b(%rip), %r8 # 0xddf98
cmpb $0x0, (%r8)
je 0x57658
incl 0x8(%rax)
jmp 0x5765c
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rdi)
leaq 0x85275(%rip), %rax # 0xdc8e0
addq $0x10, %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movups (%rdx), %xmm0
movq %rax, 0x8(%rdx)
movups %xmm0, 0x20(%rdi)
movq %rax, (%rdx)
movups (%rcx), %xmm0
movups %xmm0, 0x30(%rdi)
movq 0x10(%rcx), %rdx
movq %rdx, 0x40(%rdi)
movq %rax, 0x10(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movups 0x18(%rcx), %xmm1
movups %xmm1, 0x48(%rdi)
movq 0x28(%rcx), %rdx
movq %rdx, 0x58(%rdi)
movq %rax, 0x28(%rcx)
movups %xmm0, 0x18(%rcx)
retq
|
_ZN5minja8CallExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEEONS_19ArgumentsExpressionE:
lea rax, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add rax, 10h
mov [rdi], rax
mov rax, [rsi]
mov [rdi+8], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
test rax, rax
jz short loc_5765C
mov r8, cs:__libc_single_threaded_ptr
cmp byte ptr [r8], 0
jz short loc_57658
inc dword ptr [rax+8]
jmp short loc_5765C
loc_57658:
lock inc dword ptr [rax+8]
loc_5765C:
mov rax, [rsi+10h]
mov [rdi+18h], rax
lea rax, _ZTVN5minja8CallExprE; `vtable for'minja::CallExpr
add rax, 10h
mov [rdi], rax
xor eax, eax
mov [rdi+28h], rax
movups xmm0, xmmword ptr [rdx]
mov [rdx+8], rax
movups xmmword ptr [rdi+20h], xmm0
mov [rdx], rax
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdi+30h], xmm0
mov rdx, [rcx+10h]
mov [rdi+40h], rdx
mov [rcx+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [rcx], xmm0
movups xmm1, xmmword ptr [rcx+18h]
movups xmmword ptr [rdi+48h], xmm1
mov rdx, [rcx+28h]
mov [rdi+58h], rdx
mov [rcx+28h], rax
movups xmmword ptr [rcx+18h], xmm0
retn
|
long long minja::CallExpr::CallExpr(long long a1, _QWORD *a2, __int128 *a3, long long a4)
{
long long v4; // rax
long long result; // rax
__int128 v6; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::Expression + 2;
*(_QWORD *)(a1 + 8) = *a2;
v4 = a2[1];
*(_QWORD *)(a1 + 16) = v4;
if ( v4 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v4 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v4 + 8));
}
*(_QWORD *)(a1 + 24) = a2[2];
*(_QWORD *)a1 = &`vtable for'minja::CallExpr + 2;
result = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
v6 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v6;
*(_QWORD *)a3 = 0LL;
*(_OWORD *)(a1 + 48) = *(_OWORD *)a4;
*(_QWORD *)(a1 + 64) = *(_QWORD *)(a4 + 16);
*(_QWORD *)(a4 + 16) = 0LL;
*(_OWORD *)a4 = 0LL;
*(_OWORD *)(a1 + 72) = *(_OWORD *)(a4 + 24);
*(_QWORD *)(a1 + 88) = *(_QWORD *)(a4 + 40);
*(_QWORD *)(a4 + 40) = 0LL;
*(_OWORD *)(a4 + 24) = 0LL;
return result;
}
|
CallExpr:
LEA RAX,[0x1dc288]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
TEST RAX,RAX
JZ 0x0015765c
MOV R8,qword ptr [0x001ddf98]
CMP byte ptr [R8],0x0
JZ 0x00157658
INC dword ptr [RAX + 0x8]
JMP 0x0015765c
LAB_00157658:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0015765c:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x18],RAX
LEA RAX,[0x1dc8e0]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x28],RAX
MOVUPS XMM0,xmmword ptr [RDX]
MOV qword ptr [RDX + 0x8],RAX
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOV qword ptr [RDX],RAX
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOV RDX,qword ptr [RCX + 0x10]
MOV qword ptr [RDI + 0x40],RDX
MOV qword ptr [RCX + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RCX],XMM0
MOVUPS XMM1,xmmword ptr [RCX + 0x18]
MOVUPS xmmword ptr [RDI + 0x48],XMM1
MOV RDX,qword ptr [RCX + 0x28]
MOV qword ptr [RDI + 0x58],RDX
MOV qword ptr [RCX + 0x28],RAX
MOVUPS xmmword ptr [RCX + 0x18],XMM0
RET
|
/* minja::CallExpr::CallExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&,
minja::ArgumentsExpression&&) */
void __thiscall
minja::CallExpr::CallExpr
(CallExpr *this,Location *param_1,shared_ptr *param_2,ArgumentsExpression *param_3)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR___cxa_pure_virtual_001dc298;
*(int8 *)(this + 8) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x10) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001ddf98 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x10);
*(int ***)this = &PTR_do_evaluate_001dc8f0;
*(int8 *)(this + 0x28) = 0;
uVar2 = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar2;
*(int8 *)param_2 = 0;
uVar2 = *(int8 *)(param_3 + 8);
*(int8 *)(this + 0x30) = *(int8 *)param_3;
*(int8 *)(this + 0x38) = uVar2;
*(int8 *)(this + 0x40) = *(int8 *)(param_3 + 0x10);
*(int8 *)(param_3 + 0x10) = 0;
*(int8 *)param_3 = 0;
*(int8 *)(param_3 + 8) = 0;
uVar2 = *(int8 *)(param_3 + 0x20);
*(int8 *)(this + 0x48) = *(int8 *)(param_3 + 0x18);
*(int8 *)(this + 0x50) = uVar2;
*(int8 *)(this + 0x58) = *(int8 *)(param_3 + 0x28);
*(int8 *)(param_3 + 0x28) = 0;
*(int8 *)(param_3 + 0x18) = 0;
*(int8 *)(param_3 + 0x20) = 0;
return;
}
|
|
19,764
|
freeze_size
|
eloqsql/mysys/array.c
|
void freeze_size(DYNAMIC_ARRAY *array)
{
uint elements;
/*
Do nothing if we are using a static buffer
*/
if (array->malloc_flags & MY_INIT_BUFFER_USED)
return;
elements= MY_MAX(array->elements, 1);
if (array->buffer && array->max_element > elements)
{
array->buffer=(uchar*) my_realloc(array->m_psi_key, array->buffer,
elements * array->size_of_element,
MYF(MY_WME | array->malloc_flags));
array->max_element= elements;
}
}
|
O0
|
c
|
freeze_size:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
andq $0x100, %rax # imm = 0x100
cmpq $0x0, %rax
je 0x6ec42
jmp 0x6ecc0
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jbe 0x6ec58
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x6ec62
movl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6ec62
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6ecc0
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0xc(%rbp), %eax
jbe 0x6ecc0
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
orq $0x10, %rcx
callq 0x7d3b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
freeze_size:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+20h]
and rax, 100h
cmp rax, 0
jz short loc_6EC42
jmp short loc_6ECC0
loc_6EC42:
mov rax, [rbp+var_8]
cmp dword ptr [rax+8], 1
jbe short loc_6EC58
mov rax, [rbp+var_8]
mov eax, [rax+8]
mov [rbp+var_10], eax
jmp short loc_6EC62
loc_6EC58:
mov eax, 1
mov [rbp+var_10], eax
jmp short $+2
loc_6EC62:
mov eax, [rbp+var_10]
mov [rbp+var_C], eax
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz short loc_6ECC0
mov rax, [rbp+var_8]
mov eax, [rax+0Ch]
cmp eax, [rbp+var_C]
jbe short loc_6ECC0
mov rax, [rbp+var_8]
mov edi, [rax+18h]
mov rax, [rbp+var_8]
mov rsi, [rax]
mov eax, [rbp+var_C]
mov rcx, [rbp+var_8]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
or rcx, 10h
call my_realloc
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax], rcx
mov ecx, [rbp+var_C]
mov rax, [rbp+var_8]
mov [rax+0Ch], ecx
loc_6ECC0:
add rsp, 10h
pop rbp
retn
|
long long freeze_size(long long a1)
{
long long result; // rax
unsigned int v2; // [rsp+0h] [rbp-10h]
result = *(_QWORD *)(a1 + 32) & 0x100LL;
if ( !result )
{
if ( *(_DWORD *)(a1 + 8) <= 1u )
v2 = 1;
else
v2 = *(_DWORD *)(a1 + 8);
result = a1;
if ( *(_QWORD *)a1 )
{
result = *(unsigned int *)(a1 + 12);
if ( (unsigned int)result > v2 )
{
*(_QWORD *)a1 = my_realloc(
*(unsigned int *)(a1 + 24),
*(_QWORD *)a1,
*(_DWORD *)(a1 + 20) * v2,
*(_QWORD *)(a1 + 32) | 0x10LL);
result = a1;
*(_DWORD *)(a1 + 12) = v2;
}
}
}
return result;
}
|
freeze_size:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x20]
AND RAX,0x100
CMP RAX,0x0
JZ 0x0016ec42
JMP 0x0016ecc0
LAB_0016ec42:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x8],0x1
JBE 0x0016ec58
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0016ec62
LAB_0016ec58:
MOV EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0016ec62
LAB_0016ec62:
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0xc],EAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX],0x0
JZ 0x0016ecc0
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xc]
CMP EAX,dword ptr [RBP + -0xc]
JBE 0x0016ecc0
MOV RAX,qword ptr [RBP + -0x8]
MOV EDI,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
OR RCX,0x10
CALL 0x0017d3b0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xc],ECX
LAB_0016ecc0:
ADD RSP,0x10
POP RBP
RET
|
void freeze_size(long *param_1)
{
long lVar1;
uint local_18;
if ((param_1[4] & 0x100U) == 0) {
if (*(uint *)(param_1 + 1) < 2) {
local_18 = 1;
}
else {
local_18 = *(uint *)(param_1 + 1);
}
if ((*param_1 != 0) && (local_18 < *(uint *)((long)param_1 + 0xc))) {
lVar1 = my_realloc((int)param_1[3],*param_1,local_18 * *(int *)((long)param_1 + 0x14),
param_1[4] | 0x10);
*param_1 = lVar1;
*(uint *)((long)param_1 + 0xc) = local_18;
}
}
return;
}
|
|
19,765
|
freeze_size
|
eloqsql/mysys/array.c
|
void freeze_size(DYNAMIC_ARRAY *array)
{
uint elements;
/*
Do nothing if we are using a static buffer
*/
if (array->malloc_flags & MY_INIT_BUFFER_USED)
return;
elements= MY_MAX(array->elements, 1);
if (array->buffer && array->max_element > elements)
{
array->buffer=(uchar*) my_realloc(array->m_psi_key, array->buffer,
elements * array->size_of_element,
MYF(MY_WME | array->malloc_flags));
array->max_element= elements;
}
}
|
O3
|
c
|
freeze_size:
movq 0x20(%rdi), %rcx
btl $0x8, %ecx
jb 0x58d50
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
cmpl $0x1, %r14d
adcl $0x0, %r14d
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x58d4c
cmpl %r14d, 0xc(%rbx)
jbe 0x58d4c
movl 0x18(%rbx), %edi
movl 0x14(%rbx), %edx
imull %r14d, %edx
orq $0x10, %rcx
callq 0x60e48
movq %rax, (%rbx)
movl %r14d, 0xc(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
|
freeze_size:
mov rcx, [rdi+20h]
bt ecx, 8
jb short locret_58D50
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
mov r14d, [rdi+8]
cmp r14d, 1
adc r14d, 0
mov rsi, [rdi]
test rsi, rsi
jz short loc_58D4C
cmp [rbx+0Ch], r14d
jbe short loc_58D4C
mov edi, [rbx+18h]
mov edx, [rbx+14h]
imul edx, r14d
or rcx, 10h
call my_realloc
mov [rbx], rax
mov [rbx+0Ch], r14d
loc_58D4C:
pop rbx
pop r14
pop rbp
locret_58D50:
retn
|
void freeze_size(long long a1)
{
long long v1; // rcx
unsigned int v2; // r14d
v1 = *(_QWORD *)(a1 + 32);
if ( (v1 & 0x100) == 0 )
{
v2 = (*(_DWORD *)(a1 + 8) == 0) + *(_DWORD *)(a1 + 8);
if ( *(_QWORD *)a1 )
{
if ( *(_DWORD *)(a1 + 12) > v2 )
{
*(_QWORD *)a1 = my_realloc(*(unsigned int *)(a1 + 24), *(_QWORD *)a1, v2 * *(_DWORD *)(a1 + 20), v1 | 0x10);
*(_DWORD *)(a1 + 12) = v2;
}
}
}
}
|
freeze_size:
MOV RCX,qword ptr [RDI + 0x20]
BT ECX,0x8
JC 0x00158d50
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV R14D,dword ptr [RDI + 0x8]
CMP R14D,0x1
ADC R14D,0x0
MOV RSI,qword ptr [RDI]
TEST RSI,RSI
JZ 0x00158d4c
CMP dword ptr [RBX + 0xc],R14D
JBE 0x00158d4c
MOV EDI,dword ptr [RBX + 0x18]
MOV EDX,dword ptr [RBX + 0x14]
IMUL EDX,R14D
OR RCX,0x10
CALL 0x00160e48
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0xc],R14D
LAB_00158d4c:
POP RBX
POP R14
POP RBP
LAB_00158d50:
RET
|
void freeze_size(long *param_1)
{
long lVar1;
uint uVar2;
if (((uint)param_1[4] >> 8 & 1) == 0) {
uVar2 = (int)param_1[1] + (uint)((int)param_1[1] == 0);
if ((*param_1 != 0) && (uVar2 < *(uint *)((long)param_1 + 0xc))) {
lVar1 = my_realloc((int)param_1[3],*param_1,*(int *)((long)param_1 + 0x14) * uVar2,
param_1[4] | 0x10);
*param_1 = lVar1;
*(uint *)((long)param_1 + 0xc) = uVar2;
}
}
return;
}
|
|
19,766
|
qdevtools::PropertyConnection::qt_metacall(QMetaObject::Call, int, void**)
|
HuaiminNotSleepYet[P]QDevTools/build_O2/QDevTools_autogen/EWIEGA46WW/moc_qdevtools.cpp
|
int qdevtools::PropertyConnection::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 2)
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 2)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 2;
}
return _id;
}
|
O2
|
cpp
|
qdevtools::PropertyConnection::qt_metacall(QMetaObject::Call, int, void**):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %esi, %ebp
movq %rdi, %r14
callq 0xf860
movl %eax, %ebx
testl %eax, %eax
js 0x103fb
cmpl $0x7, %ebp
je 0x103ec
testl %ebp, %ebp
jne 0x103fb
cmpl $0x1, %ebx
ja 0x103f8
movq %r14, %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x10346
jmp 0x103f8
cmpl $0x1, %ebx
ja 0x103f8
movq (%r15), %rax
andq $0x0, (%rax)
addl $-0x2, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
_ZN9qdevtools18PropertyConnection11qt_metacallEN11QMetaObject4CallEiPPv:
push rbp
push r15
push r14
push rbx
push rax
mov r15, rcx
mov ebp, esi
mov r14, rdi
call __ZN7QObject11qt_metacallEN11QMetaObject4CallEiPPv; QObject::qt_metacall(QMetaObject::Call,int,void **)
mov ebx, eax
test eax, eax
js short loc_103FB
cmp ebp, 7
jz short loc_103EC
test ebp, ebp
jnz short loc_103FB
cmp ebx, 1
ja short loc_103F8
mov rdi, r14
xor esi, esi
mov edx, ebx
call _ZN9qdevtools18PropertyConnection18qt_static_metacallEP7QObjectN11QMetaObject4CallEiPPv; qdevtools::PropertyConnection::qt_static_metacall(QObject *,QMetaObject::Call,int,void **)
jmp short loc_103F8
loc_103EC:
cmp ebx, 1
ja short loc_103F8
mov rax, [r15]
and qword ptr [rax], 0
loc_103F8:
add ebx, 0FFFFFFFEh
loc_103FB:
mov eax, ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long qdevtools::PropertyConnection::qt_metacall(
qdevtools::PropertyConnection *a1,
int a2,
long long a3,
_QWORD **a4)
{
int v5; // eax
unsigned int v6; // ebx
v5 = QObject::qt_metacall(a1);
v6 = v5;
if ( v5 >= 0 )
{
if ( a2 == 7 )
{
if ( (unsigned int)v5 <= 1 )
**a4 = 0LL;
goto LABEL_8;
}
if ( !a2 )
{
if ( (unsigned int)v5 <= 1 )
qdevtools::PropertyConnection::qt_static_metacall(a1, 0, v5);
LABEL_8:
v6 -= 2;
}
}
return v6;
}
|
qt_metacall:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R15,RCX
MOV EBP,ESI
MOV R14,RDI
CALL 0x0010f860
MOV EBX,EAX
TEST EAX,EAX
JS 0x001103fb
CMP EBP,0x7
JZ 0x001103ec
TEST EBP,EBP
JNZ 0x001103fb
CMP EBX,0x1
JA 0x001103f8
MOV RDI,R14
XOR ESI,ESI
MOV EDX,EBX
CALL 0x00110346
JMP 0x001103f8
LAB_001103ec:
CMP EBX,0x1
JA 0x001103f8
MOV RAX,qword ptr [R15]
AND qword ptr [RAX],0x0
LAB_001103f8:
ADD EBX,-0x2
LAB_001103fb:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* qdevtools::PropertyConnection::qt_metacall(QMetaObject::Call, int, void**) */
uint __thiscall
qdevtools::PropertyConnection::qt_metacall
(PropertyConnection *this,int param_2,int8 param_3,int8 *param_4)
{
uint uVar1;
uVar1 = QObject::qt_metacall();
if (-1 < (int)uVar1) {
if (param_2 == 7) {
if (uVar1 < 2) {
*(int8 *)*param_4 = 0;
}
}
else {
if (param_2 != 0) {
return uVar1;
}
if (uVar1 < 2) {
qt_static_metacall(this,0,uVar1);
}
}
uVar1 = uVar1 - 2;
}
return uVar1;
}
|
|
19,767
|
char const* google::protobuf::internal::WireFormatParser<google::protobuf::internal::UnknownFieldLiteParserHelper>(google::protobuf::internal::UnknownFieldLiteParserHelper&, char const*, google::protobuf::internal::ParseContext*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/parse_context.h
|
PROTOBUF_NODISCARD const char* WireFormatParser(T& field_parser,
const char* ptr,
ParseContext* ctx) {
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ReadTag(ptr, &tag);
GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
if (tag == 0 || (tag & 7) == 4) {
ctx->SetLastTag(tag);
return ptr;
}
ptr = FieldParser(tag, field_parser, ptr, ctx);
GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
}
return ptr;
}
|
O0
|
c
|
char const* google::protobuf::internal::WireFormatParser<google::protobuf::internal::UnknownFieldLiteParserHelper>(google::protobuf::internal::UnknownFieldLiteParserHelper&, char const*, google::protobuf::internal::ParseContext*):
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x154570
xorb $-0x1, %al
testb $0x1, %al
jne 0x1e7ccd
jmp 0x1e7d5a
movq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rsi
xorl %edx, %edx
callq 0x1545a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1e7cf6
movq $0x0, 0x20(%rsp)
jmp 0x1e7d64
cmpl $0x0, 0x4(%rsp)
je 0x1e7d09
movl 0x4(%rsp), %eax
andl $0x7, %eax
cmpl $0x4, %eax
jne 0x1e7d23
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x154730
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1e7d64
movl 0x4(%rsp), %eax
movl %eax, %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x1e7d70
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1e7d55
movq $0x0, 0x20(%rsp)
jmp 0x1e7d64
jmp 0x1e7cb3
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
|
_ZN6google8protobuf8internal16WireFormatParserINS1_24UnknownFieldParserHelperEEEPKcRT_S5_PNS1_12ParseContextE:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov [rsp+28h+var_20], rdx
loc_1E7CB3:
mov rdi, [rsp+28h+var_20]; this
lea rsi, [rsp+28h+var_18]; char **
call _ZN6google8protobuf8internal12ParseContext4DoneEPPKc; google::protobuf::internal::ParseContext::Done(char const**)
xor al, 0FFh
test al, 1
jnz short loc_1E7CCD
jmp loc_1E7D5A
loc_1E7CCD:
mov rdi, [rsp+28h+var_18]; this
lea rsi, [rsp+28h+var_24]; char *
xor edx, edx; unsigned int *
call _ZN6google8protobuf8internal7ReadTagEPKcPjj; google::protobuf::internal::ReadTag(char const*,uint *,uint)
mov [rsp+28h+var_18], rax
cmp [rsp+28h+var_18], 0
jnz short loc_1E7CF6
mov [rsp+28h+var_8], 0
jmp short loc_1E7D64
loc_1E7CF6:
cmp dword ptr [rsp+28h+var_24], 0
jz short loc_1E7D09
mov eax, dword ptr [rsp+28h+var_24]
and eax, 7
cmp eax, 4
jnz short loc_1E7D23
loc_1E7D09:
mov rdi, [rsp+28h+var_20]; this
mov esi, dword ptr [rsp+28h+var_24]; unsigned int
call _ZN6google8protobuf8internal18EpsCopyInputStream10SetLastTagEj; google::protobuf::internal::EpsCopyInputStream::SetLastTag(uint)
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_8], rax
jmp short loc_1E7D64
loc_1E7D23:
mov eax, dword ptr [rsp+28h+var_24]
mov edi, eax
mov rsi, [rsp+28h+var_10]
mov rdx, [rsp+28h+var_18]
mov rcx, [rsp+28h+var_20]
call _ZN6google8protobuf8internal11FieldParserINS1_24UnknownFieldParserHelperEEEPKcmRT_S5_PNS1_12ParseContextE; google::protobuf::internal::FieldParser<google::protobuf::internal::UnknownFieldParserHelper>(ulong,google::protobuf::internal::UnknownFieldParserHelper &,char const*,google::protobuf::internal::ParseContext *)
mov [rsp+28h+var_18], rax
cmp [rsp+28h+var_18], 0
jnz short loc_1E7D55
mov [rsp+28h+var_8], 0
jmp short loc_1E7D64
loc_1E7D55:
jmp loc_1E7CB3
loc_1E7D5A:
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_8], rax
loc_1E7D64:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
| ||||
19,768
|
char const* google::protobuf::internal::WireFormatParser<google::protobuf::internal::UnknownFieldLiteParserHelper>(google::protobuf::internal::UnknownFieldLiteParserHelper&, char const*, google::protobuf::internal::ParseContext*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/parse_context.h
|
PROTOBUF_NODISCARD const char* WireFormatParser(T& field_parser,
const char* ptr,
ParseContext* ctx) {
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ReadTag(ptr, &tag);
GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
if (tag == 0 || (tag & 7) == 4) {
ctx->SetLastTag(tag);
return ptr;
}
ptr = FieldParser(tag, field_parser, ptr, ctx);
GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
}
return ptr;
}
|
O3
|
c
|
char const* google::protobuf::internal::WireFormatParser<google::protobuf::internal::UnknownFieldLiteParserHelper>(google::protobuf::internal::UnknownFieldLiteParserHelper&, char const*, google::protobuf::internal::ParseContext*):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
movl 0x5c(%rbx), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7347e
movq 0x8(%rsp), %rdi
testb %al, %al
jne 0xa38f2
movzbl (%rdi), %edx
leaq 0x1(%rdi), %rax
testb %dl, %dl
jns 0xa38ae
movzbl (%rax), %eax
movl %eax, %ecx
shll $0x7, %ecx
addl %ecx, %edx
addl $-0x80, %edx
testb %al, %al
js 0xa38dd
addq $0x2, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
testl %edx, %edx
je 0xa38f7
movl %edx, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
je 0xa38f7
movl %edx, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0xa3906
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0xa3874
jmp 0xa38ee
movl %edx, %esi
callq 0x7ce8e
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0xa38b3
xorl %eax, %eax
jmp 0xa38fc
movq %rdi, %rax
jmp 0xa38fc
decl %edx
movl %edx, 0x50(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
_ZN6google8protobuf8internal16WireFormatParserINS1_24UnknownFieldParserHelperEEEPKcRT_S5_PNS1_12ParseContextE:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rdx
mov r14, rdi
lea r15, [rsp+28h+var_20]
mov [r15], rsi
loc_A3874:
mov edx, [rbx+5Ch]; int
mov rdi, rbx; this
mov rsi, r15; char **
call _ZN6google8protobuf8internal18EpsCopyInputStream13DoneWithCheckEPPKci; google::protobuf::internal::EpsCopyInputStream::DoneWithCheck(char const**,int)
mov rdi, [rsp+28h+var_20]; this
test al, al
jnz short loc_A38F2
movzx edx, byte ptr [rdi]
lea rax, [rdi+1]
test dl, dl
jns short loc_A38AE
movzx eax, byte ptr [rax]
mov ecx, eax
shl ecx, 7
add edx, ecx
add edx, 0FFFFFF80h; unsigned int
test al, al
js short loc_A38DD
add rdi, 2
mov rax, rdi
loc_A38AE:
mov [rsp+28h+var_20], rax
loc_A38B3:
test edx, edx
jz short loc_A38F7
mov ecx, edx
and ecx, 7
cmp ecx, 4
jz short loc_A38F7
mov edi, edx
mov rsi, r14
mov rdx, rax
mov rcx, rbx
call _ZN6google8protobuf8internal11FieldParserINS1_24UnknownFieldParserHelperEEEPKcmRT_S5_PNS1_12ParseContextE; google::protobuf::internal::FieldParser<google::protobuf::internal::UnknownFieldParserHelper>(ulong,google::protobuf::internal::UnknownFieldParserHelper &,char const*,google::protobuf::internal::ParseContext *)
mov [rsp+28h+var_20], rax
test rax, rax
jnz short loc_A3874
jmp short loc_A38EE
loc_A38DD:
mov esi, edx; char *
call _ZN6google8protobuf8internal15ReadTagFallbackEPKcj; google::protobuf::internal::ReadTagFallback(char const*,uint)
mov [rsp+28h+var_20], rax
test rax, rax
jnz short loc_A38B3
loc_A38EE:
xor eax, eax
jmp short loc_A38FC
loc_A38F2:
mov rax, rdi
jmp short loc_A38FC
loc_A38F7:
dec edx
mov [rbx+50h], edx
loc_A38FC:
add rsp, 10h
pop rbx
pop r14
pop r15
retn
|
google::protobuf::internal * google::protobuf::internal::WireFormatParser<google::protobuf::internal::UnknownFieldParserHelper>(
long long a1,
google::protobuf::internal *a2,
google::protobuf::internal::EpsCopyInputStream *a3)
{
long long v4; // r8
unsigned int v5; // edx
google::protobuf::internal *result; // rax
int v7; // eax
google::protobuf::internal *v8; // [rsp+8h] [rbp-20h] BYREF
v8 = a2;
while ( 1 )
{
if ( google::protobuf::internal::EpsCopyInputStream::DoneWithCheck(a3, (const char **)&v8, *((_DWORD *)a3 + 23)) )
return v8;
v5 = *(unsigned __int8 *)v8;
result = (google::protobuf::internal *)((char *)v8 + 1);
if ( (v5 & 0x80u) == 0 )
goto LABEL_6;
v7 = *(unsigned __int8 *)result;
v5 = (v7 << 7) + v5 - 128;
if ( (v7 & 0x80u) == 0 )
{
result = (google::protobuf::internal *)((char *)v8 + 2);
LABEL_6:
v8 = result;
goto LABEL_7;
}
result = (google::protobuf::internal *)google::protobuf::internal::ReadTagFallback(v8, (const char *)v5);
v8 = result;
if ( !result )
return 0LL;
LABEL_7:
if ( !v5 || (v5 & 7) == 4 )
break;
v8 = (google::protobuf::internal *)google::protobuf::internal::FieldParser<google::protobuf::internal::UnknownFieldParserHelper>(
v5,
a1,
result,
a3,
v4);
if ( !v8 )
return 0LL;
}
*((_DWORD *)a3 + 20) = v5 - 1;
return result;
}
|
WireFormatParser<google::protobuf::internal::UnknownFieldParserHelper>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDX
MOV R14,RDI
LEA R15,[RSP + 0x8]
MOV qword ptr [R15],RSI
LAB_001a3874:
MOV EDX,dword ptr [RBX + 0x5c]
MOV RDI,RBX
MOV RSI,R15
CALL 0x0017347e
MOV RDI,qword ptr [RSP + 0x8]
TEST AL,AL
JNZ 0x001a38f2
MOVZX EDX,byte ptr [RDI]
LEA RAX,[RDI + 0x1]
TEST DL,DL
JNS 0x001a38ae
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
SHL ECX,0x7
ADD EDX,ECX
ADD EDX,-0x80
TEST AL,AL
JS 0x001a38dd
ADD RDI,0x2
MOV RAX,RDI
LAB_001a38ae:
MOV qword ptr [RSP + 0x8],RAX
LAB_001a38b3:
TEST EDX,EDX
JZ 0x001a38f7
MOV ECX,EDX
AND ECX,0x7
CMP ECX,0x4
JZ 0x001a38f7
MOV EDI,EDX
MOV RSI,R14
MOV RDX,RAX
MOV RCX,RBX
CALL 0x001a3906
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JNZ 0x001a3874
JMP 0x001a38ee
LAB_001a38dd:
MOV ESI,EDX
CALL 0x0017ce8e
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JNZ 0x001a38b3
LAB_001a38ee:
XOR EAX,EAX
JMP 0x001a38fc
LAB_001a38f2:
MOV RAX,RDI
JMP 0x001a38fc
LAB_001a38f7:
DEC EDX
MOV dword ptr [RBX + 0x50],EDX
LAB_001a38fc:
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* char const*
google::protobuf::internal::WireFormatParser<google::protobuf::internal::UnknownFieldParserHelper>(google::protobuf::internal::UnknownFieldParserHelper&,
char const*, google::protobuf::internal::ParseContext*) */
char * google::protobuf::internal::
WireFormatParser<google::protobuf::internal::UnknownFieldParserHelper>
(UnknownFieldParserHelper *param_1,char *param_2,ParseContext *param_3)
{
byte bVar1;
byte bVar2;
char cVar3;
uint uVar4;
int1 auVar5 [12];
byte *local_20;
local_20 = (byte *)param_2;
while( true ) {
cVar3 = EpsCopyInputStream::DoneWithCheck
((EpsCopyInputStream *)param_3,(char **)&local_20,*(int *)(param_3 + 0x5c));
if (cVar3 != '\0') {
return (char *)local_20;
}
bVar1 = *local_20;
auVar5[8] = bVar1;
auVar5._0_8_ = local_20 + 1;
auVar5._9_3_ = 0;
if ((char)bVar1 < '\0') {
bVar2 = local_20[1];
uVar4 = ((uint)bVar1 + (uint)bVar2 * 0x80) - 0x80;
if ((char)bVar2 < '\0') {
auVar5 = ReadTagFallback((char *)local_20,uVar4);
if (auVar5._0_8_ == 0) {
return (char *)0x0;
}
}
else {
auVar5._8_4_ = uVar4;
auVar5._0_8_ = local_20 + 2;
}
}
uVar4 = auVar5._8_4_;
local_20 = auVar5._0_8_;
if ((uVar4 == 0) || ((uVar4 & 7) == 4)) break;
local_20 = (byte *)FieldParser<google::protobuf::internal::UnknownFieldParserHelper>
((ulong)uVar4,param_1,(char *)local_20,param_3);
if (local_20 == (byte *)0x0) {
return (char *)0x0;
}
}
*(uint *)(param_3 + 0x50) = uVar4 - 1;
return (char *)local_20;
}
|
|
19,769
|
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>::emplace_back<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>&)
|
monkey531[P]llama/common/./json.hpp
|
reference emplace_back(Args&& ... args)
{
// emplace_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
}
// transform null object into an array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value = value_t::array;
assert_invariant();
}
// add element to array (perfect forwarding)
const auto old_capacity = m_data.m_value.array->capacity();
m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
return set_parent(m_data.m_value.array->back(), old_capacity);
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::emplace_back<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>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0xe52f4
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x1a8d0
movq %rax, %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
jmp 0xe52fd
cmpl $0x2, %eax
jne 0xe531a
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xe5438
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
addq $-0x10, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1a440
movq %rax, %rbx
movq %r14, %rdi
callq 0x5f708
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x121aa(%rip), %rsi # 0xf74e8
leaq 0x10(%rsp), %rdi
callq 0xe53b0
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x137, %esi # imm = 0x137
movq %r14, %rcx
callq 0x5f4b0
xorl %ebp, %ebp
leaq 0x44bef(%rip), %rsi # 0x129f58
leaq -0x89a32(%rip), %rdx # 0x5b93e
movq %rbx, %rdi
callq 0x1af30
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe5396
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a900
testb %bpl, %bpl
jne 0xe53a0
jmp 0xe53a8
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a680
movq %r14, %rdi
callq 0x1afc0
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12emplace_backIJRSD_EEESF_DpOT_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_E52F4
mov byte ptr [r14], 2
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
jmp short loc_E52FD
loc_E52F4:
cmp eax, 2
jnz short loc_E531A
mov rdi, [r14+8]
loc_E52FD:
mov rsi, rbx
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJRSD_EEESH_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, [r14+8]
mov rax, [rax+8]
add rax, 0FFFFFFFFFFFFFFF0h
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_E531A:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseEmpla; "cannot use emplace_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA32_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(char const(&)[32],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 137h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E5396
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E5396:
test bpl, bpl
jnz short loc_E53A0
jmp short loc_E53A8
mov r14, rax
loc_E53A0:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_E53A8:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::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>&>(
long long a1,
long long a2)
{
long long v3; // rdi
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v6[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 )
{
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(
v6,
"cannot use emplace_back() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
311,
v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v3 = *(_QWORD *)(a1 + 8);
}
else
{
*(_BYTE *)a1 = 2;
v3 = operator new(0x18uLL);
*(_OWORD *)v3 = 0LL;
*(_QWORD *)(v3 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v3;
}
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>&>(
v3,
a2);
return *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) - 16LL;
}
|
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>&>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x001e52f4
MOV byte ptr [R14],0x2
MOV EDI,0x18
CALL 0x0011a8d0
MOV RDI,RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
JMP 0x001e52fd
LAB_001e52f4:
CMP EAX,0x2
JNZ 0x001e531a
MOV RDI,qword ptr [R14 + 0x8]
LAB_001e52fd:
MOV RSI,RBX
CALL 0x001e5438
MOV RAX,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,-0x10
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001e531a:
MOV EDI,0x20
CALL 0x0011a440
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015f708
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001e5337:
LEA RSI,[0x1f74e8]
LEA RDI,[RSP + 0x10]
CALL 0x001e53b0
MOV BPL,0x1
LAB_001e534b:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x137
MOV RCX,R14
CALL 0x0015f4b0
XOR EBP,EBP
LEA RSI,[0x229f58]
LEA RDX,[0x15b93e]
MOV RDI,RBX
CALL 0x0011af30
|
/* 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>::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>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&) */
basic_json * __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>
::
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>&>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json *param_1)
{
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*this_00;
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
this_00 = (vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)operator_new(0x18);
*(int8 *)this_00 = 0;
*(int8 *)(this_00 + 8) = 0;
*(int8 *)(this_00 + 0x10) = 0;
*(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>>>
**)(this + 8) = this_00;
}
else {
if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 001e5337 to 001e5347 has its CatchHandler @ 001e539d */
detail::concat<std::__cxx11::string,char_const(&)[32],char_const*>
(local_38,"cannot use emplace_back() with ",&local_40);
/* try { // try from 001e534b to 001e5377 has its CatchHandler @ 001e5378 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x137,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
this_00 = *(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>>>
**)(this + 8);
}
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>&>
(this_00,param_1);
return (basic_json *)(*(long *)(*(long *)(this + 8) + 8) + -0x10);
}
|
|
19,770
|
lf_pinbox_init
|
eloqsql/mysys/lf_alloc-pin.c
|
void lf_pinbox_init(LF_PINBOX *pinbox, uint free_ptr_offset,
lf_pinbox_free_func *free_func, void *free_func_arg)
{
DBUG_ASSERT(free_ptr_offset % sizeof(void *) == 0);
lf_dynarray_init(&pinbox->pinarray, sizeof(LF_PINS));
pinbox->pinstack_top_ver= 0;
pinbox->pins_in_array= 0;
pinbox->free_ptr_offset= free_ptr_offset;
pinbox->free_func= free_func;
pinbox->free_func_arg= free_func_arg;
}
|
O0
|
c
|
lf_pinbox_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0xfc0f9
movq -0x8(%rbp), %rdi
movl $0x78, %esi
callq 0xfcc80
movq -0x8(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
lf_pinbox_init:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
jmp short $+2
loc_FC0F9:
mov rdi, [rbp+var_8]
mov esi, 78h ; 'x'
call lf_dynarray_init
mov rax, [rbp+var_8]
mov dword ptr [rax+3Ch], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+40h], 0
mov ecx, [rbp+var_C]
mov rax, [rbp+var_8]
mov [rax+38h], ecx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
mov [rax+28h], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_8]
mov [rax+30h], rcx
add rsp, 20h
pop rbp
retn
|
long long lf_pinbox_init(long long a1, int a2, long long a3, long long a4)
{
long long result; // rax
lf_dynarray_init(a1, 120LL);
*(_DWORD *)(a1 + 60) = 0;
*(_DWORD *)(a1 + 64) = 0;
*(_DWORD *)(a1 + 56) = a2;
*(_QWORD *)(a1 + 40) = a3;
result = a1;
*(_QWORD *)(a1 + 48) = a4;
return result;
}
|
lf_pinbox_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
JMP 0x001fc0f9
LAB_001fc0f9:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x78
CALL 0x001fcc80
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x3c],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x40],0x0
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x38],ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x28],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x30],RCX
ADD RSP,0x20
POP RBP
RET
|
void lf_pinbox_init(long param_1,int4 param_2,int8 param_3,int8 param_4)
{
lf_dynarray_init(param_1,0x78);
*(int4 *)(param_1 + 0x3c) = 0;
*(int4 *)(param_1 + 0x40) = 0;
*(int4 *)(param_1 + 0x38) = param_2;
*(int8 *)(param_1 + 0x28) = param_3;
*(int8 *)(param_1 + 0x30) = param_4;
return;
}
|
|
19,771
|
my_like_range_czech
|
eloqsql/strings/ctype-czech.c
|
static my_bool my_like_range_czech(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)
{
#ifdef EXAMPLE
uchar value;
const char *end=ptr+ptr_length;
char *min_org=min_str;
char *min_end=min_str+res_length;
for (; ptr != end && min_str != min_end ; ptr++)
{
if (*ptr == w_one) /* '_' in SQL */
{ break; }
if (*ptr == w_many) /* '%' in SQL */
{ break; }
if (*ptr == escape && ptr+1 != end)
{ ptr++; } /* Skip escape */
value = CZ_SORT_TABLE[0][(int) (uchar) *ptr];
if (value == 0) /* Ignore in the first pass */
{ continue; }
if (value <= 2) /* End of pass or end of string */
{ break; }
if (value == 255) /* Double char too compicated */
{ break; }
*min_str++= *max_str++ = *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; /* Because of key compression */
*max_str++ = max_sort_char;
}
return 0;
#else
return 1;
#endif
}
|
O0
|
c
|
my_like_range_czech:
pushq %rbp
movq %rsp, %rbp
movl %r8d, -0x50(%rbp)
movl %ecx, %eax
movl -0x50(%rbp), %ecx
movl %eax, -0x4c(%rbp)
movq %rdx, %rax
movl -0x4c(%rbp), %edx
movq %rax, -0x48(%rbp)
movq %rsi, %rax
movq -0x48(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq %rdi, %r8
movq -0x40(%rbp), %rdi
movb %r9b, %al
movq 0x30(%rbp), %r9
movq 0x28(%rbp), %r9
movq 0x20(%rbp), %r9
movq 0x18(%rbp), %r9
movq 0x10(%rbp), %r9
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %dl, -0x19(%rbp)
movb %cl, -0x1a(%rbp)
movb %al, -0x1b(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rbp), %rax
addq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x51(%rbp)
je 0x6f045
movq 0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x6f051
jmp 0x6f115
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6f065
jmp 0x6f115
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x1b(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6f079
jmp 0x6f115
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6f0a2
movq -0x10(%rbp), %rax
addq $0x1, %rax
cmpq -0x28(%rbp), %rax
je 0x6f0a2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq 0x19d5d7(%rip), %rax # 0x20c680
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x1c(%rbp)
movzbl -0x1c(%rbp), %eax
cmpl $0x0, %eax
jne 0x6f0c4
jmp 0x6f104
movzbl -0x1c(%rbp), %eax
cmpl $0x2, %eax
jg 0x6f0cf
jmp 0x6f115
movzbl -0x1c(%rbp), %eax
cmpl $0xff, %eax
jne 0x6f0dc
jmp 0x6f115
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq 0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rbp)
movb %cl, (%rax)
movq 0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6f028
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x6f138
movq 0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rax, %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6f143
movq 0x10(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rbp), %rcx
movq 0x30(%rbp), %rax
movq %rcx, (%rax)
movq 0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x6f17e
movq 0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rbp)
movb $0x20, (%rax)
movq 0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rbp)
movb $0x39, (%rax)
jmp 0x6f14e
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
my_like_range_czech:
push rbp
mov rbp, rsp
mov [rbp+var_50], r8d
mov eax, ecx
mov ecx, [rbp+var_50]
mov [rbp+var_4C], eax
mov rax, rdx
mov edx, [rbp+var_4C]
mov [rbp+var_48], rax
mov rax, rsi
mov rsi, [rbp+var_48]
mov [rbp+var_40], rax
mov r8, rdi
mov rdi, [rbp+var_40]
mov al, r9b
mov r9, [rbp+arg_20]
mov r9, [rbp+arg_18]
mov r9, [rbp+arg_10]
mov r9, [rbp+arg_8]
mov r9, [rbp+arg_0]
mov [rbp+var_8], r8
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_19], dl
mov [rbp+var_1A], cl
mov [rbp+var_1B], al
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_28], rax
mov rax, [rbp+arg_8]
mov [rbp+var_30], rax
mov rax, [rbp+arg_8]
add rax, [rbp+arg_0]
mov [rbp+var_38], rax
loc_6F028:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_28]
mov [rbp+var_51], al
jz short loc_6F045
mov rax, [rbp+arg_8]
cmp rax, [rbp+var_38]
setnz al
mov [rbp+var_51], al
loc_6F045:
mov al, [rbp+var_51]
test al, 1
jnz short loc_6F051
jmp loc_6F115
loc_6F051:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_1A]
cmp eax, ecx
jnz short loc_6F065
jmp loc_6F115
loc_6F065:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_1B]
cmp eax, ecx
jnz short loc_6F079
jmp loc_6F115
loc_6F079:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_19]
cmp eax, ecx
jnz short loc_6F0A2
mov rax, [rbp+var_10]
add rax, 1
cmp rax, [rbp+var_28]
jz short loc_6F0A2
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
loc_6F0A2:
mov rax, cs:CZ_SORT_TABLE
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
movsxd rcx, ecx
mov al, [rax+rcx]
mov [rbp+var_1C], al
movzx eax, [rbp+var_1C]
cmp eax, 0
jnz short loc_6F0C4
jmp short loc_6F104
loc_6F0C4:
movzx eax, [rbp+var_1C]
cmp eax, 2
jg short loc_6F0CF
jmp short loc_6F115
loc_6F0CF:
movzx eax, [rbp+var_1C]
cmp eax, 0FFh
jnz short loc_6F0DC
jmp short loc_6F115
loc_6F0DC:
mov rax, [rbp+var_10]
mov cl, [rax]
mov rax, [rbp+arg_10]
mov rdx, rax
add rdx, 1
mov [rbp+arg_10], rdx
mov [rax], cl
mov rax, [rbp+arg_8]
mov rdx, rax
add rdx, 1
mov [rbp+arg_8], rdx
mov [rax], cl
loc_6F104:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp loc_6F028
loc_6F115:
mov rax, [rbp+var_8]
mov eax, [rax+0Ch]
and eax, 10h
cmp eax, 0
jz short loc_6F138
mov rcx, [rbp+arg_8]
mov rax, [rbp+var_30]
sub rcx, rax
mov rax, [rbp+arg_18]
mov [rax], rcx
jmp short loc_6F143
loc_6F138:
mov rcx, [rbp+arg_0]
mov rax, [rbp+arg_18]
mov [rax], rcx
loc_6F143:
mov rcx, [rbp+arg_0]
mov rax, [rbp+arg_20]
mov [rax], rcx
loc_6F14E:
mov rax, [rbp+arg_8]
cmp rax, [rbp+var_38]
jz short loc_6F17E
mov rax, [rbp+arg_8]
mov rcx, rax
add rcx, 1
mov [rbp+arg_8], rcx
mov byte ptr [rax], 20h ; ' '
mov rax, [rbp+arg_10]
mov rcx, rax
add rcx, 1
mov [rbp+arg_10], rcx
mov byte ptr [rax], 39h ; '9'
jmp short loc_6F14E
loc_6F17E:
xor eax, eax
pop rbp
retn
|
long long my_like_range_czech(
long long a1,
unsigned __int8 *a2,
long long a3,
char a4,
char a5,
char a6,
long long a7,
unsigned __int8 *a8,
unsigned __int8 *a9,
_QWORD *a10,
_QWORD *a11)
{
unsigned __int8 v11; // cl
unsigned __int8 *v12; // rax
unsigned __int8 *v13; // rax
unsigned __int8 *v14; // rax
unsigned __int8 *v15; // rax
bool v17; // [rsp+1h] [rbp-51h]
unsigned __int8 *v18; // [rsp+1Ah] [rbp-38h]
long long v19; // [rsp+22h] [rbp-30h]
char *v20; // [rsp+2Ah] [rbp-28h]
unsigned __int8 v21; // [rsp+36h] [rbp-1Ch]
unsigned __int8 *v23; // [rsp+42h] [rbp-10h]
v23 = a2;
v20 = (char *)&a2[a3];
v19 = (long long)a8;
v18 = &a8[a7];
while ( 1 )
{
v17 = 0;
if ( v23 != (unsigned __int8 *)v20 )
v17 = a8 != v18;
if ( !v17 || (char)*v23 == a5 || (char)*v23 == a6 )
break;
if ( (char)*v23 == a4 && v23 + 1 != (unsigned __int8 *)v20 )
++v23;
v21 = byte_10C8C7[*v23];
if ( v21 )
{
if ( v21 <= 2u || v21 == 255 )
break;
v11 = *v23;
v12 = a9++;
*v12 = *v23;
v13 = a8++;
*v13 = v11;
}
++v23;
}
if ( (*(_DWORD *)(a1 + 12) & 0x10) != 0 )
*a10 = &a8[-v19];
else
*a10 = a7;
*a11 = a7;
while ( a8 != v18 )
{
v14 = a8++;
*v14 = 32;
v15 = a9++;
*v15 = 57;
}
return 0LL;
}
|
my_like_range_czech:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x50],R8D
MOV EAX,ECX
MOV ECX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,RDX
MOV EDX,dword ptr [RBP + -0x4c]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,RSI
MOV RSI,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x40],RAX
MOV R8,RDI
MOV RDI,qword ptr [RBP + -0x40]
MOV AL,R9B
MOV R9,qword ptr [RBP + 0x30]
MOV R9,qword ptr [RBP + 0x28]
MOV R9,qword ptr [RBP + 0x20]
MOV R9,qword ptr [RBP + 0x18]
MOV R9,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],R8
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV byte ptr [RBP + -0x19],DL
MOV byte ptr [RBP + -0x1a],CL
MOV byte ptr [RBP + -0x1b],AL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + 0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + 0x18]
ADD RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x38],RAX
LAB_0016f028:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x51],AL
JZ 0x0016f045
MOV RAX,qword ptr [RBP + 0x18]
CMP RAX,qword ptr [RBP + -0x38]
SETNZ AL
MOV byte ptr [RBP + -0x51],AL
LAB_0016f045:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x0016f051
JMP 0x0016f115
LAB_0016f051:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x1a]
CMP EAX,ECX
JNZ 0x0016f065
JMP 0x0016f115
LAB_0016f065:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x1b]
CMP EAX,ECX
JNZ 0x0016f079
JMP 0x0016f115
LAB_0016f079:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x19]
CMP EAX,ECX
JNZ 0x0016f0a2
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x28]
JZ 0x0016f0a2
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_0016f0a2:
MOV RAX,qword ptr [0x0030c680]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOVSXD RCX,ECX
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x1c],AL
MOVZX EAX,byte ptr [RBP + -0x1c]
CMP EAX,0x0
JNZ 0x0016f0c4
JMP 0x0016f104
LAB_0016f0c4:
MOVZX EAX,byte ptr [RBP + -0x1c]
CMP EAX,0x2
JG 0x0016f0cf
JMP 0x0016f115
LAB_0016f0cf:
MOVZX EAX,byte ptr [RBP + -0x1c]
CMP EAX,0xff
JNZ 0x0016f0dc
JMP 0x0016f115
LAB_0016f0dc:
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + 0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + 0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + 0x18]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + 0x18],RDX
MOV byte ptr [RAX],CL
LAB_0016f104:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0016f028
LAB_0016f115:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x10
CMP EAX,0x0
JZ 0x0016f138
MOV RCX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + -0x30]
SUB RCX,RAX
MOV RAX,qword ptr [RBP + 0x28]
MOV qword ptr [RAX],RCX
JMP 0x0016f143
LAB_0016f138:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + 0x28]
MOV qword ptr [RAX],RCX
LAB_0016f143:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + 0x30]
MOV qword ptr [RAX],RCX
LAB_0016f14e:
MOV RAX,qword ptr [RBP + 0x18]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x0016f17e
MOV RAX,qword ptr [RBP + 0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + 0x18],RCX
MOV byte ptr [RAX],0x20
MOV RAX,qword ptr [RBP + 0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + 0x20],RCX
MOV byte ptr [RAX],0x39
JMP 0x0016f14e
LAB_0016f17e:
XOR EAX,EAX
POP RBP
RET
|
int8
my_like_range_czech(long param_1,byte *param_2,long param_3,byte param_4,byte param_5,byte param_6,
long param_7,byte *param_8,byte *param_9,long *param_10,long *param_11)
{
byte bVar1;
byte *pbVar2;
byte *pbVar3;
byte *local_18;
pbVar2 = param_8;
pbVar3 = param_8 + param_7;
for (local_18 = param_2;
((local_18 != param_2 + param_3 && param_8 != pbVar3 && (*local_18 != param_5)) &&
(*local_18 != param_6)); local_18 = local_18 + 1) {
if ((*local_18 == param_4) && (local_18 + 1 != param_2 + param_3)) {
local_18 = local_18 + 1;
}
bVar1 = CZ_SORT_TABLE[(int)(uint)*local_18];
if (bVar1 != 0) {
if ((bVar1 < 3) || (bVar1 == 0xff)) break;
bVar1 = *local_18;
*param_9 = bVar1;
*param_8 = bVar1;
param_8 = param_8 + 1;
param_9 = param_9 + 1;
}
}
if ((*(uint *)(param_1 + 0xc) & 0x10) == 0) {
*param_10 = param_7;
}
else {
*param_10 = (long)param_8 - (long)pbVar2;
}
*param_11 = param_7;
while (param_8 != pbVar3) {
*param_8 = 0x20;
*param_9 = 0x39;
param_8 = param_8 + 1;
param_9 = param_9 + 1;
}
return 0;
}
|
|
19,772
|
POINTonE2_from_Jacobian
|
corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/e2.c
|
static void POINTonE2_from_Jacobian(POINTonE2 *out, const POINTonE2 *in)
{
vec384x Z, ZZ;
limb_t inf = vec_is_zero(in->Z, sizeof(in->Z));
reciprocal_fp2(Z, in->Z); /* 1/Z */
sqr_fp2(ZZ, Z);
mul_fp2(out->X, in->X, ZZ); /* X = X/Z^2 */
mul_fp2(ZZ, ZZ, Z);
mul_fp2(out->Y, in->Y, ZZ); /* Y = Y/Z^3 */
vec_select(out->Z, in->Z, BLS12_381_G2.Z,
sizeof(BLS12_381_G2.Z), inf); /* Z = inf ? 0 : 1 */
}
|
O3
|
c
|
POINTonE2_from_Jacobian:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movl $0xc0, %eax
leaq (%rsi,%rax), %r14
movq %r14, -0x30(%rbp)
movl $0x60, %esi
movq %r14, %rdi
callq 0x70940
movq %rax, %r15
leaq -0x90(%rbp), %rdi
movq %r14, %rsi
callq 0x62697
leaq 0x30a7f(%rip), %r14 # 0x8cca0
leaq -0xf0(%rbp), %r13
movabsq $-0x760c000300030003, %rcx # imm = 0x89F3FFFCFFFCFFFD
movq %r13, %rdi
leaq -0x90(%rbp), %rsi
movq %r14, %rdx
callq 0x73ce0
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
movabsq $-0x760c000300030003, %r8 # imm = 0x89F3FFFCFFFCFFFD
callq 0x73ba0
movq %r13, %rdi
movq %r13, %rsi
leaq -0x90(%rbp), %rdx
movq %r14, %rcx
movabsq $-0x760c000300030003, %r8 # imm = 0x89F3FFFCFFFCFFFD
callq 0x73ba0
leaq 0x60(%rbx), %rdi
addq $0x60, %r12
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
movabsq $-0x760c000300030003, %r8 # imm = 0x89F3FFFCFFFCFFFD
callq 0x73ba0
movl $0xc0, %eax
addq %rax, %rbx
leaq 0x307b3(%rip), %rdx # 0x8ca60
addq %rax, %rdx
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movq %r15, %rcx
callq 0x70320
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
POINTonE2_from_Jacobian:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov r12, rsi
mov rbx, rdi
mov eax, 0C0h
lea r14, [rsi+rax]
mov [rbp+var_30], r14
mov esi, 60h ; '`'
mov rdi, r14
call vec_is_zero_16x
mov r15, rax
lea rdi, [rbp+var_90]
mov rsi, r14
call reciprocal_fp2
lea r14, BLS12_381_P
lea r13, [rbp+var_F0]
mov rcx, 89F3FFFCFFFCFFFDh
mov rdi, r13
lea rsi, [rbp+var_90]
mov rdx, r14
call sqr_mont_384x
mov rdi, rbx
mov rsi, r12
mov rdx, r13
mov rcx, r14
mov r8, 89F3FFFCFFFCFFFDh
call mul_mont_384x
mov rdi, r13
mov rsi, r13
lea rdx, [rbp+var_90]
mov rcx, r14
mov r8, 89F3FFFCFFFCFFFDh
call mul_mont_384x
lea rdi, [rbx+60h]
add r12, 60h ; '`'
mov rsi, r12
mov rdx, r13
mov rcx, r14
mov r8, 89F3FFFCFFFCFFFDh
call mul_mont_384x
mov eax, 0C0h
add rbx, rax
lea rdx, BLS12_381_G2
add rdx, rax
mov rdi, rbx
mov rsi, [rbp+var_30]
mov rcx, r15
call vec_select_96
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long POINTonE2_from_Jacobian(long long a1, long long a2)
{
long long is_zero_16x; // r15
_BYTE v4[96]; // [rsp+0h] [rbp-F0h] BYREF
_BYTE v5[96]; // [rsp+60h] [rbp-90h] BYREF
long long v6; // [rsp+C0h] [rbp-30h]
v6 = a2 + 192;
is_zero_16x = vec_is_zero_16x(a2 + 192, 96LL);
reciprocal_fp2(v5, a2 + 192);
sqr_mont_384x(v4, v5, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384x(a1, a2, v4, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384x(v4, v4, v5, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384x(a1 + 96, a2 + 96, v4, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
return vec_select_96(a1 + 192, v6, (char *)&BLS12_381_G2 + 192, is_zero_16x);
}
|
POINTonE2_from_Jacobian:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV R12,RSI
MOV RBX,RDI
MOV EAX,0xc0
LEA R14,[RSI + RAX*0x1]
MOV qword ptr [RBP + -0x30],R14
MOV ESI,0x60
MOV RDI,R14
CALL 0x00170940
MOV R15,RAX
LEA RDI,[RBP + -0x90]
MOV RSI,R14
CALL 0x00162697
LEA R14,[0x18cca0]
LEA R13,[RBP + -0xf0]
MOV RCX,-0x760c000300030003
MOV RDI,R13
LEA RSI,[RBP + -0x90]
MOV RDX,R14
CALL 0x00173ce0
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R13
MOV RCX,R14
MOV R8,-0x760c000300030003
CALL 0x00173ba0
MOV RDI,R13
MOV RSI,R13
LEA RDX,[RBP + -0x90]
MOV RCX,R14
MOV R8,-0x760c000300030003
CALL 0x00173ba0
LEA RDI,[RBX + 0x60]
ADD R12,0x60
MOV RSI,R12
MOV RDX,R13
MOV RCX,R14
MOV R8,-0x760c000300030003
CALL 0x00173ba0
MOV EAX,0xc0
ADD RBX,RAX
LEA RDX,[0x18ca60]
ADD RDX,RAX
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x30]
MOV RCX,R15
CALL 0x00170320
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void POINTonE2_from_Jacobian(long param_1,long param_2)
{
long lVar1;
int8 uVar2;
int1 local_f8 [96];
int1 local_98 [96];
long local_38;
lVar1 = param_2 + 0xc0;
local_38 = lVar1;
uVar2 = vec_is_zero_16x(lVar1,0x60);
reciprocal_fp2(local_98,lVar1);
sqr_mont_384x(local_f8,local_98,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384x(param_1,param_2,local_f8,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384x(local_f8,local_f8,local_98,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384x(param_1 + 0x60,param_2 + 0x60,local_f8,BLS12_381_P,0x89f3fffcfffcfffd);
vec_select_96(param_1 + 0xc0,local_38,0x18cb20,uVar2);
return;
}
|
|
19,773
|
ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>)::$_0::operator()(std::shared_ptr<ftxui::ComponentBase>) const
|
Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/component/renderer.cpp
|
ComponentDecorator Renderer(ElementDecorator decorator) { // NOLINT
return [decorator](Component component) { // NOLINT
return Renderer(component, [component, decorator] {
return component->Render() | decorator;
});
};
}
|
O0
|
cpp
|
ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>)::$_0::operator()(std::shared_ptr<ftxui::ComponentBase>) const:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0xa0(%rbp)
movq %rsi, %rax
movq -0xa0(%rbp), %rsi
movq %rdi, -0xb0(%rbp)
movq %rdi, %rcx
movq %rcx, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20070
movq -0xa0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x20070
movq -0x90(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x4cbd0
jmp 0x60a86
leaq -0x48(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x60b40
jmp 0x60a95
movq -0xb0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x5ec10
jmp 0x60aab
leaq -0x48(%rbp), %rdi
callq 0x201e0
leaq -0x78(%rbp), %rdi
callq 0x60be0
leaq -0x28(%rbp), %rdi
callq 0x201c0
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x201c0
jmp 0x60b25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x60b1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x201e0
leaq -0x78(%rbp), %rdi
callq 0x60be0
leaq -0x28(%rbp), %rdi
callq 0x201c0
movq -0x80(%rbp), %rdi
callq 0xda90
nopw (%rax,%rax)
|
_ZZN5ftxui8RendererESt8functionIFSt10shared_ptrINS_4NodeEES3_EEENK3$_0clES1_INS_13ComponentBaseEE:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_A0], rdx
mov rax, rsi
mov rsi, [rbp+var_A0]
mov [rbp+var_B0], rdi
mov rcx, rdi
mov [rbp+var_A8], rcx
mov [rbp+var_8], rdi
mov [rbp+var_10], rax
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_90], rax
lea rdi, [rbp+var_28]
call _ZNSt10shared_ptrIN5ftxui13ComponentBaseEEC2ERKS2_; std::shared_ptr<ftxui::ComponentBase>::shared_ptr(std::shared_ptr<ftxui::ComponentBase> const&)
mov rsi, [rbp+var_A0]
lea rdi, [rbp+var_78]
mov [rbp+var_98], rdi
call _ZNSt10shared_ptrIN5ftxui13ComponentBaseEEC2ERKS2_; std::shared_ptr<ftxui::ComponentBase>::shared_ptr(std::shared_ptr<ftxui::ComponentBase> const&)
mov rsi, [rbp+var_90]
lea rdi, [rbp+var_68]
call _ZNSt8functionIFSt10shared_ptrIN5ftxui4NodeEES3_EEC2ERKS5_; std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>::function(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)> const&)
jmp short $+2
loc_60A86:
lea rdi, [rbp+var_48]
lea rsi, [rbp+var_78]
call _ZNSt8functionIFSt10shared_ptrIN5ftxui4NodeEEvEEC2IZZNS1_8RendererES_IFS3_S3_EEENK3$_0clES0_INS1_13ComponentBaseEEEUlvE_vEEOT_; std::function<std::shared_ptr<ftxui::Node> ()(void)>::function<ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)::$_0::operator() const(std::shared_ptr<ftxui::ComponentBase>)::{lambda(void)#1},void>(ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)::$_0::operator() const(std::shared_ptr<ftxui::ComponentBase>)::{lambda(void)#1} &&)
jmp short $+2
loc_60A95:
mov rdi, [rbp+var_B0]
lea rsi, [rbp+var_28]
lea rdx, [rbp+var_48]
call _ZN5ftxui8RendererESt10shared_ptrINS_13ComponentBaseEESt8functionIFS0_INS_4NodeEEvEE; ftxui::Renderer(std::shared_ptr<ftxui::ComponentBase>,std::function<std::shared_ptr<ftxui::Node> ()(void)>)
jmp short $+2
loc_60AAB:
lea rdi, [rbp+var_48]
call _ZNSt8functionIFSt10shared_ptrIN5ftxui4NodeEEvEED2Ev; std::function<std::shared_ptr<ftxui::Node> ()(void)>::~function()
lea rdi, [rbp+var_78]
call _ZZZN5ftxui8RendererESt8functionIFSt10shared_ptrINS_4NodeEES3_EEENK3$_0clES1_INS_13ComponentBaseEEENUlvE_D2Ev; ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)::$_0::operator() const(std::shared_ptr<ftxui::ComponentBase>)::{lambda(void)#1}::~()
lea rdi, [rbp+var_28]
call _ZNSt10shared_ptrIN5ftxui13ComponentBaseEED2Ev; std::shared_ptr<ftxui::ComponentBase>::~shared_ptr()
mov rax, [rbp+var_A8]
add rsp, 0B0h
pop rbp
retn
mov rdi, [rbp+var_98]
mov rcx, rax
mov eax, edx
mov [rbp+var_80], rcx
mov [rbp+var_84], eax
call _ZNSt10shared_ptrIN5ftxui13ComponentBaseEED2Ev; std::shared_ptr<ftxui::ComponentBase>::~shared_ptr()
jmp short loc_60B25
mov rcx, rax
mov eax, edx
mov [rbp+var_80], rcx
mov [rbp+var_84], eax
jmp short loc_60B1C
mov rcx, rax
mov eax, edx
mov [rbp+var_80], rcx
mov [rbp+var_84], eax
lea rdi, [rbp+var_48]
call _ZNSt8functionIFSt10shared_ptrIN5ftxui4NodeEEvEED2Ev; std::function<std::shared_ptr<ftxui::Node> ()(void)>::~function()
loc_60B1C:
lea rdi, [rbp+var_78]
call _ZZZN5ftxui8RendererESt8functionIFSt10shared_ptrINS_4NodeEES3_EEENK3$_0clES1_INS_13ComponentBaseEEENUlvE_D2Ev; ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)::$_0::operator() const(std::shared_ptr<ftxui::ComponentBase>)::{lambda(void)#1}::~()
loc_60B25:
lea rdi, [rbp+var_28]
call _ZNSt10shared_ptrIN5ftxui13ComponentBaseEED2Ev; std::shared_ptr<ftxui::ComponentBase>::~shared_ptr()
mov rdi, [rbp+var_80]
call __Unwind_Resume
|
long long ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)::$_0::operator()(
long long a1,
long long a2,
long long a3)
{
_BYTE v5[16]; // [rsp+38h] [rbp-78h] BYREF
_BYTE v6[32]; // [rsp+48h] [rbp-68h] BYREF
_BYTE v7[32]; // [rsp+68h] [rbp-48h] BYREF
_BYTE v8[16]; // [rsp+88h] [rbp-28h] BYREF
long long v9; // [rsp+98h] [rbp-18h]
long long v10; // [rsp+A0h] [rbp-10h]
long long v11; // [rsp+A8h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
std::shared_ptr<ftxui::ComponentBase>::shared_ptr((long long)v8, a3);
std::shared_ptr<ftxui::ComponentBase>::shared_ptr((long long)v5, a3);
std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>::function((std::_Function_base *)v6, a2);
std::function<std::shared_ptr<ftxui::Node> ()(void)>::function<ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)::$_0::operator() const(std::shared_ptr<ftxui::ComponentBase>)::{lambda(void)#1},void>(
v7,
v5);
ftxui::Renderer(a1, (long long)v8, (long long)v7);
std::function<std::shared_ptr<ftxui::Node> ()(void)>::~function((std::_Function_base *)v7);
ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)::$_0::operator() const(std::shared_ptr<ftxui::ComponentBase>)::{lambda(void)#1}::~(v5);
std::shared_ptr<ftxui::ComponentBase>::~shared_ptr((long long)v8);
return a1;
}
|
operator():
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0xa0],RDX
MOV RAX,RSI
MOV RSI,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0xb0],RDI
MOV RCX,RDI
MOV qword ptr [RBP + -0xa8],RCX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x90],RAX
LEA RDI,[RBP + -0x28]
CALL 0x00120070
MOV RSI,qword ptr [RBP + -0xa0]
LEA RDI,[RBP + -0x78]
MOV qword ptr [RBP + -0x98],RDI
CALL 0x00120070
MOV RSI,qword ptr [RBP + -0x90]
LEA RDI,[RBP + -0x68]
LAB_00160a7f:
CALL 0x0014cbd0
JMP 0x00160a86
LAB_00160a86:
LEA RDI,[RBP + -0x48]
LEA RSI,[RBP + -0x78]
CALL 0x00160b40
JMP 0x00160a95
LAB_00160a95:
MOV RDI,qword ptr [RBP + -0xb0]
LEA RSI,[RBP + -0x28]
LEA RDX,[RBP + -0x48]
CALL 0x0015ec10
LAB_00160aa9:
JMP 0x00160aab
LAB_00160aab:
LEA RDI,[RBP + -0x48]
CALL 0x001201e0
LEA RDI,[RBP + -0x78]
CALL 0x00160be0
LEA RDI,[RBP + -0x28]
CALL 0x001201c0
MOV RAX,qword ptr [RBP + -0xa8]
ADD RSP,0xb0
POP RBP
RET
|
/* ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node>
(std::shared_ptr<ftxui::Node>)>)::$_0::TEMPNAMEPLACEHOLDERVALUE(std::shared_ptr<ftxui::ComponentBase>)
const */
__0 * __thiscall
ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node>(std::shared_ptr<ftxui::Node>)>)::$_0::
operator()(__0 *this,function *param_2,shared_ptr *param_3)
{
shared_ptr<ftxui::ComponentBase> local_80 [16];
function<std::shared_ptr<ftxui::Node>(std::shared_ptr<ftxui::Node>)> local_70 [32];
function<std::shared_ptr<ftxui::Node>()> local_50 [32];
shared_ptr<ftxui::ComponentBase> local_30 [16];
shared_ptr *local_20;
function *local_18;
__0 *local_10;
local_20 = param_3;
local_18 = param_2;
local_10 = this;
std::shared_ptr<ftxui::ComponentBase>::shared_ptr(local_30,param_3);
std::shared_ptr<ftxui::ComponentBase>::shared_ptr(local_80,param_3);
/* try { // try from 00160a7f to 00160a83 has its CatchHandler @ 00160ad6 */
std::function<std::shared_ptr<ftxui::Node>(std::shared_ptr<ftxui::Node>)>::function
(local_70,param_2);
/* try { // try from 00160a86 to 00160a92 has its CatchHandler @ 00160af3 */
std::function<std::shared_ptr<ftxui::Node>()>::operator()(local_50,(_lambda___1_ *)local_80);
/* try { // try from 00160a95 to 00160aa8 has its CatchHandler @ 00160b04 */
Renderer((ftxui *)this,local_30,local_50);
std::function<std::shared_ptr<ftxui::Node>()>::~function(local_50);
const::{lambda()#1}::~__0((_lambda___1_ *)local_80);
std::shared_ptr<ftxui::ComponentBase>::~shared_ptr(local_30);
return this;
}
|
|
19,774
|
OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::Build()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/patchTreeBuilder.cpp
|
const PatchTree *
PatchTreeBuilder::Build() {
identifyPatches();
initializePatches();
if (_patchTree->_useDoublePrecision) {
initializeStencilMatrix<double>();
} else {
initializeStencilMatrix<float>();
}
initializeQuadTree();
return _patchTree;
}
|
O0
|
cpp
|
OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::Build():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xcac70
movq -0x10(%rbp), %rdi
callq 0xd5580
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x1961b0
movq -0x10(%rbp), %rdi
callq 0xd2d30
jmp 0x1961b9
movq -0x10(%rbp), %rdi
callq 0xd0f40
movq -0x10(%rbp), %rdi
callq 0xcf9a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
|
_ZN10OpenSubdiv6v3_6_03Bfr16PatchTreeBuilder5BuildEv:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
mov [rbp+var_10], rdi
call __ZN10OpenSubdiv6v3_6_03Bfr16PatchTreeBuilder15identifyPatchesEv; OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::identifyPatches(void)
mov rdi, [rbp+var_10]; this
call __ZN10OpenSubdiv6v3_6_03Bfr16PatchTreeBuilder17initializePatchesEv; OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::initializePatches(void)
mov rax, [rbp+var_10]
mov rax, [rax]
mov al, [rax]
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_1961B0
mov rdi, [rbp+var_10]
call __ZN10OpenSubdiv6v3_6_03Bfr16PatchTreeBuilder23initializeStencilMatrixIdEEvv; OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::initializeStencilMatrix<double>(void)
jmp short loc_1961B9
loc_1961B0:
mov rdi, [rbp+var_10]
call __ZN10OpenSubdiv6v3_6_03Bfr16PatchTreeBuilder23initializeStencilMatrixIfEEvv; OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::initializeStencilMatrix<float>(void)
loc_1961B9:
mov rdi, [rbp+var_10]; this
call __ZN10OpenSubdiv6v3_6_03Bfr16PatchTreeBuilder18initializeQuadTreeEv; OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::initializeQuadTree(void)
mov rax, [rbp+var_10]
mov rax, [rax]
add rsp, 10h
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::Build(OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder *this)
{
OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::identifyPatches(this);
OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::initializePatches(this);
if ( (**(_BYTE **)this & 1) != 0 )
OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::initializeStencilMatrix<double>(this);
else
OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::initializeStencilMatrix<float>(this);
OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::initializeQuadTree(this);
return *(_QWORD *)this;
}
| |||
19,775
|
OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::Build()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/patchTreeBuilder.cpp
|
const PatchTree *
PatchTreeBuilder::Build() {
identifyPatches();
initializePatches();
if (_patchTree->_useDoublePrecision) {
initializeStencilMatrix<double>();
} else {
initializeStencilMatrix<float>();
}
initializeQuadTree();
return _patchTree;
}
|
O3
|
cpp
|
OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::Build():
pushq %rbx
movq %rdi, %rbx
callq 0x399a0
movq %rbx, %rdi
callq 0x3bc70
movq (%rbx), %rax
testb $0x1, (%rax)
jne 0x90675
movq %rbx, %rdi
callq 0x3ad60
jmp 0x9067d
movq %rbx, %rdi
callq 0x3b360
movq (%rbx), %rdi
callq 0x3a430
movq (%rbx), %rax
popq %rbx
retq
|
_ZN10OpenSubdiv6v3_6_03Bfr16PatchTreeBuilder5BuildEv:
push rbx; int
mov rbx, rdi
call __ZN10OpenSubdiv6v3_6_03Bfr16PatchTreeBuilder15identifyPatchesEv; OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::identifyPatches(void)
mov rdi, rbx; this
call __ZN10OpenSubdiv6v3_6_03Bfr16PatchTreeBuilder17initializePatchesEv; OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::initializePatches(void)
mov rax, [rbx]
test byte ptr [rax], 1
jnz short loc_90675
mov rdi, rbx; int
call __ZN10OpenSubdiv6v3_6_03Bfr16PatchTreeBuilder23initializeStencilMatrixIfEEvv; OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::initializeStencilMatrix<float>(void)
jmp short loc_9067D
loc_90675:
mov rdi, rbx; int
call __ZN10OpenSubdiv6v3_6_03Bfr16PatchTreeBuilder23initializeStencilMatrixIdEEvv; OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::initializeStencilMatrix<double>(void)
loc_9067D:
mov rdi, [rbx]; this
call __ZN10OpenSubdiv6v3_6_03Bfr9PatchTree13buildQuadtreeEv; OpenSubdiv::v3_6_0::Bfr::PatchTree::buildQuadtree(void)
mov rax, [rbx]
pop rbx
retn
|
Build:
PUSH RBX
MOV RBX,RDI
CALL 0x001399a0
MOV RDI,RBX
CALL 0x0013bc70
MOV RAX,qword ptr [RBX]
TEST byte ptr [RAX],0x1
JNZ 0x00190675
MOV RDI,RBX
CALL 0x0013ad60
JMP 0x0019067d
LAB_00190675:
MOV RDI,RBX
CALL 0x0013b360
LAB_0019067d:
MOV RDI,qword ptr [RBX]
CALL 0x0013a430
MOV RAX,qword ptr [RBX]
POP RBX
RET
|
/* OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::Build() */
int8 __thiscall OpenSubdiv::v3_6_0::Bfr::PatchTreeBuilder::Build(PatchTreeBuilder *this)
{
identifyPatches(this);
initializePatches(this);
if ((**(byte **)this & 1) == 0) {
initializeStencilMatrix<float>(this);
}
else {
initializeStencilMatrix<double>(this);
}
PatchTree::buildQuadtree(*(PatchTree **)this);
return *(int8 *)this;
}
|
||
19,776
|
dirname_part
|
eloqsql/mysys/mf_dirname.c
|
size_t dirname_part(char *to, const char *name, size_t *to_res_length)
{
size_t length;
DBUG_ENTER("dirname_part");
DBUG_PRINT("enter",("'%s'",name));
length=dirname_length(name);
*to_res_length= (size_t) (convert_dirname(to, name, name+length) - to);
DBUG_RETURN(length);
}
|
O0
|
c
|
dirname_part:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0xb6206
movq -0x10(%rbp), %rdi
callq 0xb6170
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq -0x20(%rbp), %rdx
callq 0xb6250
movq %rax, %rcx
movq -0x8(%rbp), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
dirname_part:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
jmp short $+2
loc_B6206:
mov rdi, [rbp+var_10]
call dirname_length
mov [rbp+var_20], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
add rdx, [rbp+var_20]
call convert_dirname
mov rcx, rax
mov rax, [rbp+var_8]
sub rcx, rax
mov rax, [rbp+var_18]
mov [rax], rcx
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
|
long long dirname_part(long long a1, _BYTE *a2, _QWORD *a3)
{
long long v4; // [rsp+10h] [rbp-20h]
v4 = dirname_length(a2);
*a3 = convert_dirname(a1, a2, &a2[v4]) - a1;
return v4;
}
|
dirname_part:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x001b6206
LAB_001b6206:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001b6170
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RBP + -0x20]
CALL 0x001b6250
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
SUB RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
long dirname_part(long param_1,long param_2,long *param_3)
{
long lVar1;
long lVar2;
lVar1 = dirname_length(param_2);
lVar2 = convert_dirname(param_1,param_2,param_2 + lVar1);
*param_3 = lVar2 - param_1;
return lVar1;
}
|
|
19,777
|
ma_checkpoint_end
|
eloqsql/storage/maria/ma_checkpoint.c
|
void ma_checkpoint_end(void)
{
DBUG_ENTER("ma_checkpoint_end");
/*
Some intentional crash methods, usually triggered by
SET MARIA_CHECKPOINT_INTERVAL=X
*/
DBUG_EXECUTE_IF("maria_flush_bitmap",
{
DBUG_PRINT("maria_flush_bitmap", ("now"));
flush_all_tables(2);
});
DBUG_EXECUTE_IF("maria_flush_whole_page_cache",
{
DBUG_PRINT("maria_flush_whole_page_cache", ("now"));
flush_all_tables(0);
});
DBUG_EXECUTE_IF("maria_flush_whole_log",
{
DBUG_PRINT("maria_flush_whole_log", ("now"));
translog_flush(translog_get_horizon());
});
/*
Note that for WAL reasons, maria_flush_states requires
maria_flush_whole_log.
*/
DBUG_EXECUTE_IF("maria_flush_states",
{
DBUG_PRINT("maria_flush_states", ("now"));
flush_all_tables(1);
});
DBUG_EXECUTE_IF("maria_crash",
{ DBUG_PRINT("maria_crash", ("now")); DBUG_SUICIDE(); });
if (checkpoint_control.inited)
{
ma_service_thread_control_end(&checkpoint_control);
my_free(dfiles);
my_free(kfiles);
dfiles= kfiles= NULL;
}
DBUG_VOID_RETURN;
}
|
O0
|
c
|
ma_checkpoint_end:
pushq %rbp
movq %rsp, %rbp
jmp 0xb9936
jmp 0xb9938
jmp 0xb993a
jmp 0xb993c
jmp 0xb993e
jmp 0xb9940
jmp 0xb9942
jmp 0xb9944
jmp 0xb9946
jmp 0xb9948
cmpb $0x0, 0x2463da(%rip) # 0x2ffd29
je 0xb998b
leaq 0x2463c8(%rip), %rdi # 0x2ffd20
callq 0xc3210
movq 0xc2300c(%rip), %rdi # 0xcdc970
callq 0x126ac0
movq 0xc23008(%rip), %rdi # 0xcdc978
callq 0x126ac0
movq $0x0, 0xc22ff8(%rip) # 0xcdc978
movq $0x0, 0xc22fe5(%rip) # 0xcdc970
jmp 0xb998d
jmp 0xb998f
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_checkpoint_end:
push rbp
mov rbp, rsp
jmp short $+2
loc_B9936:
jmp short $+2
loc_B9938:
jmp short $+2
loc_B993A:
jmp short $+2
loc_B993C:
jmp short $+2
loc_B993E:
jmp short $+2
loc_B9940:
jmp short $+2
loc_B9942:
jmp short $+2
loc_B9944:
jmp short $+2
loc_B9946:
jmp short $+2
loc_B9948:
cmp cs:byte_2FFD29, 0
jz short loc_B998B
lea rdi, checkpoint_control
call ma_service_thread_control_end
mov rdi, cs:dfiles
call my_free
mov rdi, cs:kfiles
call my_free
mov cs:kfiles, 0
mov cs:dfiles, 0
loc_B998B:
jmp short $+2
loc_B998D:
jmp short $+2
loc_B998F:
pop rbp
retn
|
long long ma_checkpoint_end()
{
long long result; // rax
if ( byte_2FFD29 )
{
ma_service_thread_control_end(&checkpoint_control);
my_free(dfiles);
result = my_free(kfiles);
kfiles = 0LL;
dfiles = 0LL;
}
return result;
}
|
ma_checkpoint_end:
PUSH RBP
MOV RBP,RSP
JMP 0x001b9936
LAB_001b9936:
JMP 0x001b9938
LAB_001b9938:
JMP 0x001b993a
LAB_001b993a:
JMP 0x001b993c
LAB_001b993c:
JMP 0x001b993e
LAB_001b993e:
JMP 0x001b9940
LAB_001b9940:
JMP 0x001b9942
LAB_001b9942:
JMP 0x001b9944
LAB_001b9944:
JMP 0x001b9946
LAB_001b9946:
JMP 0x001b9948
LAB_001b9948:
CMP byte ptr [0x003ffd29],0x0
JZ 0x001b998b
LEA RDI,[0x3ffd20]
CALL 0x001c3210
MOV RDI,qword ptr [0x00ddc970]
CALL 0x00226ac0
MOV RDI,qword ptr [0x00ddc978]
CALL 0x00226ac0
MOV qword ptr [0x00ddc978],0x0
MOV qword ptr [0x00ddc970],0x0
LAB_001b998b:
JMP 0x001b998d
LAB_001b998d:
JMP 0x001b998f
LAB_001b998f:
POP RBP
RET
|
void ma_checkpoint_end(void)
{
if (checkpoint_control[9] != '\0') {
ma_service_thread_control_end(checkpoint_control);
my_free(dfiles);
my_free(kfiles);
kfiles = 0;
dfiles = 0;
}
return;
}
|
|
19,778
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::next_byte_in_range(std::initializer_list<int>)
|
llama.cpp/common/json.hpp
|
bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{
JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
{
add(current);
}
else
{
error_message = "invalid string: ill-formed UTF-8 byte";
return false;
}
}
return true;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::next_byte_in_range(std::initializer_list<int>):
pushq %rbx
subq $0x10, %rsp
cmpq $0x6, %rdx
ja 0x8844d
movl $0x54, %eax
btq %rdx, %rax
jae 0x8844d
leaq 0xf(%rsp), %rbx
movq %rbx, %rcx
callq 0x22eb6
movb (%rbx), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
leaq 0x935a6(%rip), %rdi # 0x11b9fa
leaq 0x935da(%rip), %rdx # 0x11ba35
leaq 0x942f2(%rip), %rcx # 0x11c754
movl $0x1da8, %esi # imm = 0x1DA8
xorl %eax, %eax
callq 0x21fc0
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE18next_byte_in_rangeESt16initializer_listIiE:
push rbx
sub rsp, 10h
cmp rdx, 6
ja short loc_8844D
mov eax, 54h ; 'T'
bt rax, rdx
jnb short loc_8844D
lea rbx, [rsp+18h+var_9]
mov rcx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE18next_byte_in_rangeESt16initializer_listIiE_cold_1; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::next_byte_in_range(std::initializer_list<int>) [clone]
mov al, [rbx]
and al, 1
add rsp, 10h
pop rbx
retn
loc_8844D:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRangesSize2Ran; "ranges.size() == 2 || ranges.size() == "...
mov esi, 1DA8h
xor eax, eax
call _ggml_abort
|
char nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::next_byte_in_range(
__m128i *a1,
__int32 *a2,
unsigned long long a3)
{
long long v3; // rax
long long v5; // rdx
long long v6; // rcx
char v7[9]; // [rsp+Fh] [rbp-9h] BYREF
if ( a3 <= 6 && (v3 = 84LL, _bittest64(&v3, a3)) )
{
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::next_byte_in_range(
a1,
a2,
a3,
v7);
return v7[0] & 1;
}
else
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7592LL,
"GGML_ASSERT(%s) failed",
"ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6");
return 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>>::json_sax_dom_callback_parser(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7592LL,
v5,
v6);
}
}
|
next_byte_in_range:
PUSH RBX
SUB RSP,0x10
CMP RDX,0x6
JA 0x0018844d
MOV EAX,0x54
BT RAX,RDX
JNC 0x0018844d
LEA RBX,[RSP + 0xf]
MOV RCX,RBX
CALL 0x00122eb6
MOV AL,byte ptr [RBX]
AND AL,0x1
ADD RSP,0x10
POP RBX
RET
LAB_0018844d:
LEA RDI,[0x21b9fa]
LEA RDX,[0x21ba35]
LEA RCX,[0x21c754]
MOV ESI,0x1da8
XOR EAX,EAX
CALL 0x00121fc0
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::next_byte_in_range(std::initializer_list<int>) */
ulong nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::next_byte_in_range(int8 param_1,int8 param_2,ulong param_3)
{
int8 uVar1;
int1 local_9;
if ((param_3 < 7) && ((0x54UL >> (param_3 & 0x3f) & 1) != 0)) {
uVar1 = next_byte_in_range();
return CONCAT71((int7)((ulong)uVar1 >> 8),local_9) & 0xffffffffffffff01;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x1da8,
"GGML_ASSERT(%s) failed",
"ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6");
}
|
|
19,779
|
WaveCrop
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raudio.c
|
void WaveCrop(Wave *wave, int initFrame, int finalFrame)
{
if ((initFrame >= 0) && (initFrame < finalFrame) && ((unsigned int)finalFrame <= wave->frameCount))
{
int frameCount = finalFrame - initFrame;
void *data = RL_MALLOC(frameCount*wave->channels*wave->sampleSize/8);
memcpy(data, (unsigned char *)wave->data + (initFrame*wave->channels*wave->sampleSize/8), frameCount*wave->channels*wave->sampleSize/8);
RL_FREE(wave->data);
wave->data = data;
wave->frameCount = (unsigned int)frameCount;
}
else TRACELOG(LOG_WARNING, "WAVE: Crop range out of bounds");
}
|
O0
|
c
|
WaveCrop:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x7bbfd
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x7bbfd
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
ja 0x7bbfd
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0xc(%rcx), %eax
movq -0x8(%rbp), %rcx
imull 0x8(%rcx), %eax
shrl $0x3, %eax
movl %eax, %eax
movl %eax, %edi
callq 0xa6e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0xc(%rcx), %eax
movq -0x8(%rbp), %rcx
imull 0x8(%rcx), %eax
shrl $0x3, %eax
movl %eax, %eax
addq %rax, %rsi
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0xc(%rcx), %eax
movq -0x8(%rbp), %rcx
imull 0x8(%rcx), %eax
shrl $0x3, %eax
movl %eax, %eax
movl %eax, %edx
callq 0xa400
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa640
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0x7bc10
movl $0x4, %edi
leaq 0x12ef39(%rip), %rsi # 0x1aab42
movb $0x0, %al
callq 0x182c40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
WaveCrop:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
cmp [rbp+var_C], 0
jl loc_7BBFD
mov eax, [rbp+var_C]
cmp eax, [rbp+var_10]
jge loc_7BBFD
mov eax, [rbp+var_10]
mov rcx, [rbp+var_8]
cmp eax, [rcx]
ja loc_7BBFD
mov eax, [rbp+var_10]
sub eax, [rbp+var_C]
mov [rbp+var_14], eax
mov eax, [rbp+var_14]
mov rcx, [rbp+var_8]
imul eax, [rcx+0Ch]
mov rcx, [rbp+var_8]
imul eax, [rcx+8]
shr eax, 3
mov eax, eax
mov edi, eax
call _malloc
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
mov rax, [rbp+var_8]
mov rsi, [rax+10h]
mov eax, [rbp+var_C]
mov rcx, [rbp+var_8]
imul eax, [rcx+0Ch]
mov rcx, [rbp+var_8]
imul eax, [rcx+8]
shr eax, 3
mov eax, eax
add rsi, rax
mov eax, [rbp+var_14]
mov rcx, [rbp+var_8]
imul eax, [rcx+0Ch]
mov rcx, [rbp+var_8]
imul eax, [rcx+8]
shr eax, 3
mov eax, eax
mov edx, eax
call _memcpy
mov rax, [rbp+var_8]
mov rdi, [rax+10h]
call _free
mov rcx, [rbp+var_20]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_8]
mov [rax], ecx
jmp short loc_7BC10
loc_7BBFD:
mov edi, 4
lea rsi, aWaveCropRangeO; "WAVE: Crop range out of bounds"
mov al, 0
call TraceLog
loc_7BC10:
add rsp, 20h
pop rbp
retn
|
long long WaveCrop(long long a1, int a2, int a3, int a4, int a5, int a6)
{
long long result; // rax
long long v7; // [rsp+0h] [rbp-20h]
if ( a2 < 0 )
return TraceLog(4, (unsigned int)"WAVE: Crop range out of bounds", a3, a4, a5, a6);
if ( a2 >= a3 )
return TraceLog(4, (unsigned int)"WAVE: Crop range out of bounds", a3, a4, a5, a6);
a4 = a1;
if ( (unsigned int)a3 > *(_DWORD *)a1 )
return TraceLog(4, (unsigned int)"WAVE: Crop range out of bounds", a3, a4, a5, a6);
v7 = malloc((unsigned int)(*(_DWORD *)(a1 + 8) * *(_DWORD *)(a1 + 12) * (a3 - a2)) >> 3);
memcpy(
v7,
((unsigned int)(*(_DWORD *)(a1 + 8) * *(_DWORD *)(a1 + 12) * a2) >> 3) + *(_QWORD *)(a1 + 16),
(unsigned int)(*(_DWORD *)(a1 + 8) * *(_DWORD *)(a1 + 12) * (a3 - a2)) >> 3);
free(*(_QWORD *)(a1 + 16));
*(_QWORD *)(a1 + 16) = v7;
result = a1;
*(_DWORD *)a1 = a3 - a2;
return result;
}
|
WaveCrop:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
CMP dword ptr [RBP + -0xc],0x0
JL 0x0017bbfd
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x10]
JGE 0x0017bbfd
MOV EAX,dword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX]
JA 0x0017bbfd
MOV EAX,dword ptr [RBP + -0x10]
SUB EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0xc]
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x8]
SHR EAX,0x3
MOV EAX,EAX
MOV EDI,EAX
CALL 0x0010a6e0
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0x10]
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0xc]
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x8]
SHR EAX,0x3
MOV EAX,EAX
ADD RSI,RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0xc]
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x8]
SHR EAX,0x3
MOV EAX,EAX
MOV EDX,EAX
CALL 0x0010a400
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x0010a640
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],ECX
JMP 0x0017bc10
LAB_0017bbfd:
MOV EDI,0x4
LEA RSI,[0x2aab42]
MOV AL,0x0
CALL 0x00282c40
LAB_0017bc10:
ADD RSP,0x20
POP RBP
RET
|
void WaveCrop(uint *param_1,int param_2,uint param_3)
{
void *__dest;
if (((param_2 < 0) || ((int)param_3 <= param_2)) || (*param_1 < param_3)) {
TraceLog(4,"WAVE: Crop range out of bounds");
}
else {
param_3 = param_3 - param_2;
__dest = malloc((ulong)(param_3 * param_1[3] * param_1[2] >> 3));
memcpy(__dest,(void *)(*(long *)(param_1 + 4) + (ulong)(param_2 * param_1[3] * param_1[2] >> 3))
,(ulong)(param_3 * param_1[3] * param_1[2] >> 3));
free(*(void **)(param_1 + 4));
*(void **)(param_1 + 4) = __dest;
*param_1 = param_3;
}
return;
}
|
|
19,780
|
WaveCrop
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raudio.c
|
void WaveCrop(Wave *wave, int initFrame, int finalFrame)
{
if ((initFrame >= 0) && (initFrame < finalFrame) && ((unsigned int)finalFrame <= wave->frameCount))
{
int frameCount = finalFrame - initFrame;
void *data = RL_MALLOC(frameCount*wave->channels*wave->sampleSize/8);
memcpy(data, (unsigned char *)wave->data + (initFrame*wave->channels*wave->sampleSize/8), frameCount*wave->channels*wave->sampleSize/8);
RL_FREE(wave->data);
wave->data = data;
wave->frameCount = (unsigned int)frameCount;
}
else TRACELOG(LOG_WARNING, "WAVE: Crop range out of bounds");
}
|
O2
|
c
|
WaveCrop:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
sets %al
movl %edx, %r12d
subl %esi, %r12d
setle %cl
orb %al, %cl
jne 0x3bbb2
movq %rdi, %rbx
cmpl %edx, (%rdi)
jae 0x3bbd1
leaq 0x806d1(%rip), %rsi # 0xbc28a
pushq $0x4
popq %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa128b
movl %esi, %ebp
movl 0x8(%rbx), %r14d
imull 0xc(%rbx), %r14d
movl %r14d, %r15d
imull %r12d, %r15d
shrl $0x3, %r15d
movq %r15, %rdi
callq 0x96e0
movq 0x10(%rbx), %r13
imull %ebp, %r14d
shrl $0x3, %r14d
addq %r13, %r14
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x9400
movq %r13, %rdi
callq 0x9640
movq %rbp, 0x10(%rbx)
movl %r12d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
WaveCrop:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
test esi, esi
sets al
mov r12d, edx
sub r12d, esi
setle cl
or cl, al
jnz short loc_3BBB2
mov rbx, rdi
cmp [rdi], edx
jnb short loc_3BBD1
loc_3BBB2:
lea rsi, aWaveCropRangeO; "WAVE: Crop range out of bounds"
push 4
pop rdi
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp TraceLog
loc_3BBD1:
mov ebp, esi
mov r14d, [rbx+8]
imul r14d, [rbx+0Ch]
mov r15d, r14d
imul r15d, r12d
shr r15d, 3
mov rdi, r15
call _malloc
mov r13, [rbx+10h]
imul r14d, ebp
shr r14d, 3
add r14, r13
mov rbp, rax
mov rdi, rax
mov rsi, r14
mov rdx, r15
call _memcpy
mov rdi, r13
call _free
mov [rbx+10h], rbp
mov [rbx], r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long WaveCrop(long long a1, int a2, unsigned int a3, long long a4, int a5, int a6)
{
unsigned int v6; // r12d
long long result; // rax
int v8; // r14d
unsigned int v9; // r15d
long long v10; // rax
long long v11; // r13
long long v12; // rbp
v6 = a3 - a2;
if ( a2 < 0 || (int)a3 <= a2 || *(_DWORD *)a1 < a3 )
return TraceLog(
4,
(unsigned int)"WAVE: Crop range out of bounds",
a3,
(a2 < 0) | (unsigned __int8)((int)a3 <= a2),
a5,
a6);
v8 = *(_DWORD *)(a1 + 12) * *(_DWORD *)(a1 + 8);
v9 = (v6 * v8) >> 3;
v10 = malloc(v9);
v11 = *(_QWORD *)(a1 + 16);
v12 = v10;
memcpy(v10, v11 + ((unsigned int)(a2 * v8) >> 3), v9);
result = free(v11);
*(_QWORD *)(a1 + 16) = v12;
*(_DWORD *)a1 = v6;
return result;
}
|
WaveCrop:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
TEST ESI,ESI
SETS AL
MOV R12D,EDX
SUB R12D,ESI
SETLE CL
OR CL,AL
JNZ 0x0013bbb2
MOV RBX,RDI
CMP dword ptr [RDI],EDX
JNC 0x0013bbd1
LAB_0013bbb2:
LEA RSI,[0x1bc28a]
PUSH 0x4
POP RDI
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001a128b
LAB_0013bbd1:
MOV EBP,ESI
MOV R14D,dword ptr [RBX + 0x8]
IMUL R14D,dword ptr [RBX + 0xc]
MOV R15D,R14D
IMUL R15D,R12D
SHR R15D,0x3
MOV RDI,R15
CALL 0x001096e0
MOV R13,qword ptr [RBX + 0x10]
IMUL R14D,EBP
SHR R14D,0x3
ADD R14,R13
MOV RBP,RAX
MOV RDI,RAX
MOV RSI,R14
MOV RDX,R15
CALL 0x00109400
MOV RDI,R13
CALL 0x00109640
MOV qword ptr [RBX + 0x10],RBP
MOV dword ptr [RBX],R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void WaveCrop(uint *param_1,int param_2,uint param_3)
{
uint uVar1;
uint uVar2;
void *__ptr;
void *__dest;
uint uVar3;
ulong __size;
uVar3 = param_3 - param_2;
if (((uVar3 != 0 && param_2 <= (int)param_3) && -1 < param_2) && (param_3 <= *param_1)) {
uVar1 = param_1[2];
uVar2 = param_1[3];
__size = (ulong)(uVar1 * uVar2 * uVar3 >> 3);
__dest = malloc(__size);
__ptr = *(void **)(param_1 + 4);
memcpy(__dest,(void *)((ulong)(uVar1 * uVar2 * param_2 >> 3) + (long)__ptr),__size);
free(__ptr);
*(void **)(param_1 + 4) = __dest;
*param_1 = uVar3;
return;
}
TraceLog(4,"WAVE: Crop range out of bounds");
return;
}
|
|
19,781
|
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>::contains<char const (&) [6], 0>(char const (&) [6]) const
|
monkey531[P]llama/common/json.hpp
|
constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
}
|
O1
|
cpp
|
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>::contains<char const (&) [6], 0>(char const (&) [6]) const:
cmpb $0x1, (%rdi)
jne 0xc7c8e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movq (%r12), %r15
movq 0x8(%r12), %rax
cmpq %rax, %r15
je 0xc7c94
movq %rsi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b250
testl %eax, %eax
je 0xc7c91
addq $0x30, %r15
movq 0x8(%r12), %rax
cmpq %rax, %r15
jne 0xc7c6f
jmp 0xc7c94
xorl %eax, %eax
retq
movq %r15, %rax
movq 0x8(%rbx), %rcx
cmpq 0x8(%rcx), %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA6_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_C7C8E
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
mov r12, [rdi+8]
mov r15, [r12]
mov rax, [r12+8]
cmp r15, rax
jz short loc_C7C94
mov r14, rsi
loc_C7C6F:
mov rdi, r15
mov rsi, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_C7C91
add r15, 30h ; '0'
mov rax, [r12+8]
cmp r15, rax
jnz short loc_C7C6F
jmp short loc_C7C94
loc_C7C8E:
xor eax, eax
retn
loc_C7C91:
mov rax, r15
loc_C7C94:
mov rcx, [rbx+8]
cmp rax, [rcx+8]
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA6_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // r15
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
v4 = v2[1];
if ( *v2 != v4 )
{
while ( (unsigned int)std::string::compare(v3, a2) )
{
v3 += 48LL;
v4 = v2[1];
if ( v3 == v4 )
return v4 != *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
v4 = v3;
}
return v4 != *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA6_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x001c7c8e
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV R15,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
CMP R15,RAX
JZ 0x001c7c94
MOV R14,RSI
LAB_001c7c6f:
MOV RDI,R15
MOV RSI,R14
CALL 0x0011b250
TEST EAX,EAX
JZ 0x001c7c91
ADD R15,0x30
MOV RAX,qword ptr [R12 + 0x8]
CMP R15,RAX
JNZ 0x001c7c6f
JMP 0x001c7c94
LAB_001c7c8e:
XOR EAX,EAX
RET
LAB_001c7c91:
MOV RAX,R15
LAB_001c7c94:
MOV RCX,qword ptr [RBX + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA6_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)plVar1[1];
pcVar4 = (char *)*plVar1;
if ((char *)*plVar1 != pcVar3) {
do {
pcVar3 = pcVar4;
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar4 = pcVar3 + 0x30;
pcVar3 = (char *)plVar1[1];
} while (pcVar4 != pcVar3);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != *(char **)(*(long *)(param_1 + 8) + 8));
}
|
|
19,782
|
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>::contains<char const (&) [6], 0>(char const (&) [6]) const
|
monkey531[P]llama/common/json.hpp
|
constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
}
|
O3
|
cpp
|
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>::contains<char const (&) [6], 0>(char const (&) [6]) const:
cmpb $0x1, (%rdi)
jne 0xc94bf
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%r12), %rbx
cmpq 0x8(%r12), %rbx
je 0xc94c2
movq %rsi, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b250
testl %eax, %eax
je 0xc94b2
addq $0x30, %rbx
cmpq 0x8(%r12), %rbx
jne 0xc9498
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
jmp 0xc94c5
xorl %eax, %eax
retq
movq %rbx, %rax
cmpq %rbx, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA17_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_C94BF
push r15
push r14
push r12
push rbx
push rax
mov r14, rdi
mov r12, [rdi+8]
mov rbx, [r12]
cmp rbx, [r12+8]
jz short loc_C94C2
mov r15, rsi
loc_C9498:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_C94B2
add rbx, 30h ; '0'
cmp rbx, [r12+8]
jnz short loc_C9498
loc_C94B2:
mov rax, rbx
mov rcx, [r14+8]
mov rbx, [rcx+8]
jmp short loc_C94C5
loc_C94BF:
xor eax, eax
retn
loc_C94C2:
mov rax, rbx
loc_C94C5:
cmp rax, rbx
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA17_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
if ( *v2 == v2[1] )
{
v4 = *v2;
}
else
{
do
{
if ( !(unsigned int)std::string::compare(v3, a2) )
break;
v3 += 48LL;
}
while ( v3 != v2[1] );
v4 = v3;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
return v4 != v3;
}
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA17_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x001c94bf
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [R12]
CMP RBX,qword ptr [R12 + 0x8]
JZ 0x001c94c2
MOV R15,RSI
LAB_001c9498:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011b250
TEST EAX,EAX
JZ 0x001c94b2
ADD RBX,0x30
CMP RBX,qword ptr [R12 + 0x8]
JNZ 0x001c9498
LAB_001c94b2:
MOV RAX,RBX
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
JMP 0x001c94c5
LAB_001c94bf:
XOR EAX,EAX
RET
LAB_001c94c2:
MOV RAX,RBX
LAB_001c94c5:
CMP RAX,RBX
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA17_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)*plVar1;
pcVar4 = pcVar3;
if (pcVar3 != (char *)plVar1[1]) {
do {
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar3 = pcVar3 + 0x30;
} while (pcVar3 != (char *)plVar1[1]);
pcVar4 = *(char **)(*(long *)(param_1 + 8) + 8);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != pcVar4);
}
|
|
19,783
|
mysql_fetch_row_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_fetch_row_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_fetch_row,
(parms->result),
parms->result->handle,
MYSQL_ROW,
r_ptr)
}
|
O0
|
c
|
mysql_fetch_row_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x78(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7a910
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
mysql_fetch_row_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+78h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
call mysql_fetch_row
mov [rbp+var_18], rax
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+8], rcx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
|
long long mysql_fetch_row_start_internal(long long *a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-20h]
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(*a1 + 120) + 1152LL) + 40LL);
*(_QWORD *)(v2 + 8) = mysql_fetch_row(*a1);
result = v2;
*(_DWORD *)v2 = 0;
return result;
}
|
mysql_fetch_row_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x0017a910
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_fetch_row_start_internal(long *param_1)
{
int4 *puVar1;
int8 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x78) + 0x480) + 0x28);
uVar2 = mysql_fetch_row(*param_1);
*(int8 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
|
|
19,784
|
aggregate_all_transactions(PFS_transaction_stat*, PFS_transaction_stat*, PFS_transaction_stat*)
|
eloqsql/storage/perfschema/pfs_instr.cc
|
void aggregate_all_transactions(PFS_transaction_stat *from_array,
PFS_transaction_stat *to_array_1,
PFS_transaction_stat *to_array_2)
{
assert(from_array != NULL);
assert(to_array_1 != NULL);
assert(to_array_2 != NULL);
if (from_array->count() > 0)
{
to_array_1->aggregate(from_array);
to_array_2->aggregate(from_array);
from_array->reset();
}
}
|
O3
|
cpp
|
aggregate_all_transactions(PFS_transaction_stat*, PFS_transaction_stat*, PFS_transaction_stat*):
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movq 0x20(%rdi), %rax
movq %rax, %r8
addq %rcx, %r8
je 0x37d38
testq %rcx, %rcx
je 0x37c52
addq %rcx, (%rsi)
movq 0x8(%rdi), %rax
addq %rax, 0x8(%rsi)
movq 0x10(%rdi), %rax
cmpq %rax, 0x10(%rsi)
ja 0x37d3a
movq 0x18(%rdi), %rax
cmpq %rax, 0x18(%rsi)
jb 0x37d43
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x37c7f
addq %rax, 0x20(%rsi)
movq 0x28(%rdi), %rax
addq %rax, 0x28(%rsi)
movq 0x30(%rdi), %rax
cmpq %rax, 0x30(%rsi)
ja 0x37d4c
movq 0x38(%rdi), %rax
cmpq %rax, 0x38(%rsi)
jb 0x37d55
movq 0x40(%rdi), %rax
addq %rax, 0x40(%rsi)
movq 0x48(%rdi), %rax
addq %rax, 0x48(%rsi)
movq 0x50(%rdi), %rax
addq %rax, 0x50(%rsi)
movq (%rdi), %rax
testq %rax, %rax
je 0x37cc6
addq %rax, (%rdx)
movq 0x8(%rdi), %rax
addq %rax, 0x8(%rdx)
movq 0x10(%rdi), %rax
cmpq %rax, 0x10(%rdx)
ja 0x37d5e
movq 0x18(%rdi), %rax
cmpq %rax, 0x18(%rdx)
jb 0x37d67
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x37cf7
addq %rax, 0x20(%rdx)
movq 0x28(%rdi), %rax
addq %rax, 0x28(%rdx)
movq 0x30(%rdi), %rax
cmpq %rax, 0x30(%rdx)
ja 0x37d70
movq 0x38(%rdi), %rax
cmpq %rax, 0x38(%rdx)
jb 0x37d79
movq 0x40(%rdi), %rax
addq %rax, 0x40(%rdx)
movq 0x48(%rdi), %rax
addq %rax, 0x48(%rdx)
movq 0x50(%rdi), %rax
addq %rax, 0x50(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $-0x1, %rax
movq %rax, 0x10(%rdi)
movups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
popq %rbp
retq
movq %rax, 0x10(%rsi)
jmp 0x37c40
movq %rax, 0x18(%rsi)
jmp 0x37c4e
movq %rax, 0x30(%rsi)
jmp 0x37c71
movq %rax, 0x38(%rsi)
jmp 0x37c7f
movq %rax, 0x10(%rdx)
jmp 0x37cb8
movq %rax, 0x18(%rdx)
jmp 0x37cc6
movq %rax, 0x30(%rdx)
jmp 0x37ce9
movq %rax, 0x38(%rdx)
jmp 0x37cf7
|
_Z26aggregate_all_transactionsP20PFS_transaction_statS0_S0_:
push rbp
mov rbp, rsp
mov rcx, [rdi]
mov rax, [rdi+20h]
mov r8, rax
add r8, rcx
jz loc_37D38
test rcx, rcx
jz short loc_37C52
add [rsi], rcx
mov rax, [rdi+8]
add [rsi+8], rax
mov rax, [rdi+10h]
cmp [rsi+10h], rax
ja loc_37D3A
loc_37C40:
mov rax, [rdi+18h]
cmp [rsi+18h], rax
jb loc_37D43
loc_37C4E:
mov rax, [rdi+20h]
loc_37C52:
test rax, rax
jz short loc_37C7F
add [rsi+20h], rax
mov rax, [rdi+28h]
add [rsi+28h], rax
mov rax, [rdi+30h]
cmp [rsi+30h], rax
ja loc_37D4C
loc_37C71:
mov rax, [rdi+38h]
cmp [rsi+38h], rax
jb loc_37D55
loc_37C7F:
mov rax, [rdi+40h]
add [rsi+40h], rax
mov rax, [rdi+48h]
add [rsi+48h], rax
mov rax, [rdi+50h]
add [rsi+50h], rax
mov rax, [rdi]
test rax, rax
jz short loc_37CC6
add [rdx], rax
mov rax, [rdi+8]
add [rdx+8], rax
mov rax, [rdi+10h]
cmp [rdx+10h], rax
ja loc_37D5E
loc_37CB8:
mov rax, [rdi+18h]
cmp [rdx+18h], rax
jb loc_37D67
loc_37CC6:
mov rax, [rdi+20h]
test rax, rax
jz short loc_37CF7
add [rdx+20h], rax
mov rax, [rdi+28h]
add [rdx+28h], rax
mov rax, [rdi+30h]
cmp [rdx+30h], rax
ja loc_37D70
loc_37CE9:
mov rax, [rdi+38h]
cmp [rdx+38h], rax
jb loc_37D79
loc_37CF7:
mov rax, [rdi+40h]
add [rdx+40h], rax
mov rax, [rdi+48h]
add [rdx+48h], rax
mov rax, [rdi+50h]
add [rdx+50h], rax
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov rax, 0FFFFFFFFFFFFFFFFh
mov [rdi+10h], rax
movups xmmword ptr [rdi+18h], xmm0
mov qword ptr [rdi+28h], 0
mov [rdi+30h], rax
movups xmmword ptr [rdi+38h], xmm0
movups xmmword ptr [rdi+48h], xmm0
loc_37D38:
pop rbp
retn
loc_37D3A:
mov [rsi+10h], rax
jmp loc_37C40
loc_37D43:
mov [rsi+18h], rax
jmp loc_37C4E
loc_37D4C:
mov [rsi+30h], rax
jmp loc_37C71
loc_37D55:
mov [rsi+38h], rax
jmp loc_37C7F
loc_37D5E:
mov [rdx+10h], rax
jmp loc_37CB8
loc_37D67:
mov [rdx+18h], rax
jmp loc_37CC6
loc_37D70:
mov [rdx+30h], rax
jmp loc_37CE9
loc_37D79:
mov [rdx+38h], rax
jmp loc_37CF7
|
long long aggregate_all_transactions(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
long long v3; // rcx
long long result; // rax
unsigned long long v5; // rax
unsigned long long v6; // rax
unsigned long long v7; // rax
unsigned long long v8; // rax
unsigned long long v9; // rax
unsigned long long v10; // rax
long long v11; // rax
unsigned long long v12; // rax
unsigned long long v13; // rax
v3 = *a1;
result = a1[4];
if ( *a1 + result )
{
if ( v3 )
{
*a2 += v3;
a2[1] += a1[1];
v5 = a1[2];
if ( a2[2] > v5 )
a2[2] = v5;
v6 = a1[3];
if ( a2[3] < v6 )
a2[3] = v6;
result = a1[4];
}
if ( result )
{
a2[4] += result;
a2[5] += a1[5];
v7 = a1[6];
if ( a2[6] > v7 )
a2[6] = v7;
v8 = a1[7];
if ( a2[7] < v8 )
a2[7] = v8;
}
a2[8] += a1[8];
a2[9] += a1[9];
a2[10] += a1[10];
if ( *a1 )
{
*a3 += *a1;
a3[1] += a1[1];
v9 = a1[2];
if ( a3[2] > v9 )
a3[2] = v9;
v10 = a1[3];
if ( a3[3] < v10 )
a3[3] = v10;
}
v11 = a1[4];
if ( v11 )
{
a3[4] += v11;
a3[5] += a1[5];
v12 = a1[6];
if ( a3[6] > v12 )
a3[6] = v12;
v13 = a1[7];
if ( a3[7] < v13 )
a3[7] = v13;
}
a3[8] += a1[8];
a3[9] += a1[9];
a3[10] += a1[10];
*(_OWORD *)a1 = 0LL;
result = -1LL;
a1[2] = -1LL;
*(_OWORD *)(a1 + 3) = 0LL;
a1[5] = 0LL;
a1[6] = -1LL;
*(_OWORD *)(a1 + 7) = 0LL;
*(_OWORD *)(a1 + 9) = 0LL;
}
return result;
}
|
aggregate_all_transactions:
PUSH RBP
MOV RBP,RSP
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x20]
MOV R8,RAX
ADD R8,RCX
JZ 0x00137d38
TEST RCX,RCX
JZ 0x00137c52
ADD qword ptr [RSI],RCX
MOV RAX,qword ptr [RDI + 0x8]
ADD qword ptr [RSI + 0x8],RAX
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RSI + 0x10],RAX
JA 0x00137d3a
LAB_00137c40:
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RSI + 0x18],RAX
JC 0x00137d43
LAB_00137c4e:
MOV RAX,qword ptr [RDI + 0x20]
LAB_00137c52:
TEST RAX,RAX
JZ 0x00137c7f
ADD qword ptr [RSI + 0x20],RAX
MOV RAX,qword ptr [RDI + 0x28]
ADD qword ptr [RSI + 0x28],RAX
MOV RAX,qword ptr [RDI + 0x30]
CMP qword ptr [RSI + 0x30],RAX
JA 0x00137d4c
LAB_00137c71:
MOV RAX,qword ptr [RDI + 0x38]
CMP qword ptr [RSI + 0x38],RAX
JC 0x00137d55
LAB_00137c7f:
MOV RAX,qword ptr [RDI + 0x40]
ADD qword ptr [RSI + 0x40],RAX
MOV RAX,qword ptr [RDI + 0x48]
ADD qword ptr [RSI + 0x48],RAX
MOV RAX,qword ptr [RDI + 0x50]
ADD qword ptr [RSI + 0x50],RAX
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x00137cc6
ADD qword ptr [RDX],RAX
MOV RAX,qword ptr [RDI + 0x8]
ADD qword ptr [RDX + 0x8],RAX
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RDX + 0x10],RAX
JA 0x00137d5e
LAB_00137cb8:
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RDX + 0x18],RAX
JC 0x00137d67
LAB_00137cc6:
MOV RAX,qword ptr [RDI + 0x20]
TEST RAX,RAX
JZ 0x00137cf7
ADD qword ptr [RDX + 0x20],RAX
MOV RAX,qword ptr [RDI + 0x28]
ADD qword ptr [RDX + 0x28],RAX
MOV RAX,qword ptr [RDI + 0x30]
CMP qword ptr [RDX + 0x30],RAX
JA 0x00137d70
LAB_00137ce9:
MOV RAX,qword ptr [RDI + 0x38]
CMP qword ptr [RDX + 0x38],RAX
JC 0x00137d79
LAB_00137cf7:
MOV RAX,qword ptr [RDI + 0x40]
ADD qword ptr [RDX + 0x40],RAX
MOV RAX,qword ptr [RDI + 0x48]
ADD qword ptr [RDX + 0x48],RAX
MOV RAX,qword ptr [RDI + 0x50]
ADD qword ptr [RDX + 0x50],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV RAX,-0x1
MOV qword ptr [RDI + 0x10],RAX
MOVUPS xmmword ptr [RDI + 0x18],XMM0
MOV qword ptr [RDI + 0x28],0x0
MOV qword ptr [RDI + 0x30],RAX
MOVUPS xmmword ptr [RDI + 0x38],XMM0
MOVUPS xmmword ptr [RDI + 0x48],XMM0
LAB_00137d38:
POP RBP
RET
LAB_00137d3a:
MOV qword ptr [RSI + 0x10],RAX
JMP 0x00137c40
LAB_00137d43:
MOV qword ptr [RSI + 0x18],RAX
JMP 0x00137c4e
LAB_00137d4c:
MOV qword ptr [RSI + 0x30],RAX
JMP 0x00137c71
LAB_00137d55:
MOV qword ptr [RSI + 0x38],RAX
JMP 0x00137c7f
LAB_00137d5e:
MOV qword ptr [RDX + 0x10],RAX
JMP 0x00137cb8
LAB_00137d67:
MOV qword ptr [RDX + 0x18],RAX
JMP 0x00137cc6
LAB_00137d70:
MOV qword ptr [RDX + 0x30],RAX
JMP 0x00137ce9
LAB_00137d79:
MOV qword ptr [RDX + 0x38],RAX
JMP 0x00137cf7
|
/* aggregate_all_transactions(PFS_transaction_stat*, PFS_transaction_stat*, PFS_transaction_stat*)
*/
void aggregate_all_transactions
(PFS_transaction_stat *param_1,PFS_transaction_stat *param_2,
PFS_transaction_stat *param_3)
{
long lVar1;
long lVar2;
lVar1 = *(long *)param_1;
lVar2 = *(long *)(param_1 + 0x20);
if (lVar2 + lVar1 != 0) {
if (lVar1 != 0) {
*(long *)param_2 = *(long *)param_2 + lVar1;
*(long *)(param_2 + 8) = *(long *)(param_2 + 8) + *(long *)(param_1 + 8);
if (*(ulong *)(param_1 + 0x10) < *(ulong *)(param_2 + 0x10)) {
*(ulong *)(param_2 + 0x10) = *(ulong *)(param_1 + 0x10);
}
if (*(ulong *)(param_2 + 0x18) < *(ulong *)(param_1 + 0x18)) {
*(ulong *)(param_2 + 0x18) = *(ulong *)(param_1 + 0x18);
}
lVar2 = *(long *)(param_1 + 0x20);
}
if (lVar2 != 0) {
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + lVar2;
*(long *)(param_2 + 0x28) = *(long *)(param_2 + 0x28) + *(long *)(param_1 + 0x28);
if (*(ulong *)(param_1 + 0x30) < *(ulong *)(param_2 + 0x30)) {
*(ulong *)(param_2 + 0x30) = *(ulong *)(param_1 + 0x30);
}
if (*(ulong *)(param_2 + 0x38) < *(ulong *)(param_1 + 0x38)) {
*(ulong *)(param_2 + 0x38) = *(ulong *)(param_1 + 0x38);
}
}
*(long *)(param_2 + 0x40) = *(long *)(param_2 + 0x40) + *(long *)(param_1 + 0x40);
*(long *)(param_2 + 0x48) = *(long *)(param_2 + 0x48) + *(long *)(param_1 + 0x48);
*(long *)(param_2 + 0x50) = *(long *)(param_2 + 0x50) + *(long *)(param_1 + 0x50);
if (*(long *)param_1 != 0) {
*(long *)param_3 = *(long *)param_3 + *(long *)param_1;
*(long *)(param_3 + 8) = *(long *)(param_3 + 8) + *(long *)(param_1 + 8);
if (*(ulong *)(param_1 + 0x10) < *(ulong *)(param_3 + 0x10)) {
*(ulong *)(param_3 + 0x10) = *(ulong *)(param_1 + 0x10);
}
if (*(ulong *)(param_3 + 0x18) < *(ulong *)(param_1 + 0x18)) {
*(ulong *)(param_3 + 0x18) = *(ulong *)(param_1 + 0x18);
}
}
if (*(long *)(param_1 + 0x20) != 0) {
*(long *)(param_3 + 0x20) = *(long *)(param_3 + 0x20) + *(long *)(param_1 + 0x20);
*(long *)(param_3 + 0x28) = *(long *)(param_3 + 0x28) + *(long *)(param_1 + 0x28);
if (*(ulong *)(param_1 + 0x30) < *(ulong *)(param_3 + 0x30)) {
*(ulong *)(param_3 + 0x30) = *(ulong *)(param_1 + 0x30);
}
if (*(ulong *)(param_3 + 0x38) < *(ulong *)(param_1 + 0x38)) {
*(ulong *)(param_3 + 0x38) = *(ulong *)(param_1 + 0x38);
}
}
*(long *)(param_3 + 0x40) = *(long *)(param_3 + 0x40) + *(long *)(param_1 + 0x40);
*(long *)(param_3 + 0x48) = *(long *)(param_3 + 0x48) + *(long *)(param_1 + 0x48);
*(long *)(param_3 + 0x50) = *(long *)(param_3 + 0x50) + *(long *)(param_1 + 0x50);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0xffffffffffffffff;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x30) = 0xffffffffffffffff;
*(int8 *)(param_1 + 0x38) = 0;
*(int8 *)(param_1 + 0x40) = 0;
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)(param_1 + 0x50) = 0;
}
return;
}
|
|
19,785
|
OpenSubdiv::v3_6_0::Tmr::TopologyMap::WriteSubdivisionPlansDigraphs(_IO_FILE*, char const*, bool) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/topologyMap.cpp
|
void
TopologyMap::WriteSubdivisionPlansDigraphs(
FILE * fout, char const * title, bool showIndices) const {
// write-lock here
fprintf(fout, "digraph TopologyMap {\n");
if (title) {
fprintf(fout, " label = \"%s\";\n", title);
fprintf(fout, " labelloc = \"t\";\n");
}
for (int planIndex = 0; planIndex < GetNumSubdivisionPlans(); ++planIndex) {
if (SubdivisionPlan const* plan = GetSubdivisionPlan(planIndex))
plan->WriteTreeDigraph(fout, planIndex, showIndices, /*isSubgraph*/ true);
}
fprintf(fout, "}\n");
}
|
O0
|
cpp
|
OpenSubdiv::v3_6_0::Tmr::TopologyMap::WriteSubdivisionPlansDigraphs(_IO_FILE*, char const*, bool) const:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1b572(%rip), %rsi # 0x1ff9c0
movb $0x0, %al
callq 0xd1ea0
cmpq $0x0, -0x18(%rbp)
je 0x1e4484
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x1b56c(%rip), %rsi # 0x1ff9d7
movb $0x0, %al
callq 0xd1ea0
movq -0x10(%rbp), %rdi
leaq 0x1b56b(%rip), %rsi # 0x1ff9e8
movb $0x0, %al
callq 0xd1ea0
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0xcd870
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x1e44e5
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0xced10
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1e44d8
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %edx
movb -0x19(%rbp), %al
movl $0x1, %r8d
andb $0x1, %al
movzbl %al, %ecx
callq 0xca710
jmp 0x1e44da
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1e448b
movq -0x10(%rbp), %rdi
leaq 0x17a0b(%rip), %rsi # 0x1fbefb
movb $0x0, %al
callq 0xd1ea0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
|
_ZNK10OpenSubdiv6v3_6_03Tmr11TopologyMap29WriteSubdivisionPlansDigraphsEP8_IO_FILEPKcb:
push rbp
mov rbp, rsp
sub rsp, 40h
mov al, cl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
and al, 1
mov [rbp+var_19], al
mov rax, [rbp+var_8]
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
lea rsi, aDigraphTopolog; "digraph TopologyMap {\n"
mov al, 0
call _fprintf
cmp [rbp+var_18], 0
jz short loc_1E4484
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rsi, aLabelS; " label = \"%s\";\n"
mov al, 0
call _fprintf
mov rdi, [rbp+var_10]
lea rsi, aLabellocT; " labelloc = \"t\";\n"
mov al, 0
call _fprintf
loc_1E4484:
mov [rbp+var_20], 0
loc_1E448B:
mov rdi, [rbp+var_30]; this
mov eax, [rbp+var_20]
mov [rbp+var_34], eax
call __ZNK10OpenSubdiv6v3_6_03Tmr11TopologyMap22GetNumSubdivisionPlansEv; OpenSubdiv::v3_6_0::Tmr::TopologyMap::GetNumSubdivisionPlans(void)
mov ecx, eax
mov eax, [rbp+var_34]
cmp eax, ecx
jge short loc_1E44E5
mov rdi, [rbp+var_30]; this
mov esi, [rbp+var_20]; int
call __ZNK10OpenSubdiv6v3_6_03Tmr11TopologyMap18GetSubdivisionPlanEi; OpenSubdiv::v3_6_0::Tmr::TopologyMap::GetSubdivisionPlan(int)
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jz short loc_1E44D8
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_20]
mov al, [rbp+var_19]
mov r8d, 1
and al, 1
movzx ecx, al
call __ZNK10OpenSubdiv6v3_6_03Tmr15SubdivisionPlan16WriteTreeDigraphEP8_IO_FILEibb; OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan::WriteTreeDigraph(_IO_FILE *,int,bool,bool)
loc_1E44D8:
jmp short $+2
loc_1E44DA:
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp short loc_1E448B
loc_1E44E5:
mov rdi, [rbp+var_10]
lea rsi, asc_1FBEFA+1; "}\n"
mov al, 0
call _fprintf
add rsp, 40h
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Tmr::TopologyMap::WriteSubdivisionPlansDigraphs(
OpenSubdiv::v3_6_0::Tmr::TopologyMap *a1,
long long a2,
const char *a3,
char a4,
double a5)
{
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan *SubdivisionPlan; // [rsp+18h] [rbp-28h]
int i; // [rsp+20h] [rbp-20h]
char v8; // [rsp+27h] [rbp-19h]
v8 = a4 & 1;
fprintf(a2, "digraph TopologyMap {\n");
if ( a3 )
{
fprintf(a2, " label = \"%s\";\n", a3);
fprintf(a2, " labelloc = \"t\";\n");
}
for ( i = 0; i < (int)OpenSubdiv::v3_6_0::Tmr::TopologyMap::GetNumSubdivisionPlans(a1); ++i )
{
SubdivisionPlan = (OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan *)OpenSubdiv::v3_6_0::Tmr::TopologyMap::GetSubdivisionPlan(
a1,
i);
if ( SubdivisionPlan )
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan::WriteTreeDigraph(SubdivisionPlan, a2, i, v8 & 1, 1, a5);
}
return fprintf(a2, "}\n");
}
|
__niter_wrap<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ValueTag*>:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ValueTag*
std::__niter_wrap<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ValueTag*>(OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ValueTag*
const&, OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ValueTag*) */
ValueTag *
std::__niter_wrap<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ValueTag*>
(ValueTag **param_1,ValueTag *param_2)
{
return param_2;
}
|
|
19,786
|
nglog::posix_strerror_r(int, char*, unsigned long)
|
ng-log[P]ng-log/src/logging.cc
|
NGLOG_NO_EXPORT
int posix_strerror_r(int err, char* buf, size_t len) {
// Sanity check input parameters
if (buf == nullptr || len <= 0) {
errno = EINVAL;
return -1;
}
// Reset buf and errno, and try calling whatever version of strerror_r()
// is implemented by glibc
buf[0] = '\000';
int old_errno = errno;
errno = 0;
char* rc = reinterpret_cast<char*>(strerror_r(err, buf, len));
// Both versions set errno on failure
if (errno) {
// Should already be there, but better safe than sorry
buf[0] = '\000';
return -1;
}
errno = old_errno;
// POSIX is vague about whether the string will be terminated, although
// is indirectly implies that typically ERANGE will be returned, instead
// of truncating the string. This is different from the GNU implementation.
// We play it safe by always terminating the string explicitly.
buf[len - 1] = '\000';
// If the function succeeded, we can use its exit code to determine the
// semantics implemented by glibc
if (!rc) {
return 0;
} else {
// GNU semantics detected
if (rc == buf) {
return 0;
} else {
buf[0] = '\000';
#if defined(NGLOG_OS_MACOSX) || defined(NGLOG_OS_FREEBSD) || \
defined(NGLOG_OS_OPENBSD)
if (reinterpret_cast<intptr_t>(rc) < sys_nerr) {
// This means an error on MacOSX or FreeBSD.
return -1;
}
#endif
strncat(buf, rc, len - 1);
return 0;
}
}
}
|
O2
|
cpp
|
nglog::posix_strerror_r(int, char*, unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
setne %al
testq %rdx, %rdx
setne %cl
testb %cl, %al
jne 0xe42a
callq 0x8050
movl $0x16, (%rax)
jmp 0xe45a
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movb $0x0, (%rsi)
callq 0x8050
movq %rax, %r15
movl (%rax), %r12d
andl $0x0, (%rax)
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8110
cmpl $0x0, (%r15)
je 0xe468
movb $0x0, (%r14)
pushq $-0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r12d, (%r15)
movb $0x0, -0x1(%r14,%rbx)
testq %rax, %rax
sete %cl
cmpq %r14, %rax
sete %dl
xorl %ebp, %ebp
orb %cl, %dl
jne 0xe45d
decq %rbx
movb $0x0, (%r14)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x83b0
jmp 0xe45d
|
_ZN5nglog16posix_strerror_rEiPcm:
push rbp
push r15
push r14
push r12
push rbx
test rsi, rsi
setnz al
test rdx, rdx
setnz cl
test al, cl
jnz short loc_E42A
call ___errno_location
mov dword ptr [rax], 16h
jmp short loc_E45A
loc_E42A:
mov rbx, rdx
mov r14, rsi
mov ebp, edi
mov byte ptr [rsi], 0
call ___errno_location
mov r15, rax
mov r12d, [rax]
and dword ptr [rax], 0
mov edi, ebp
mov rsi, r14
mov rdx, rbx
call _strerror_r
cmp dword ptr [r15], 0
jz short loc_E468
mov byte ptr [r14], 0
loc_E45A:
push 0FFFFFFFFFFFFFFFFh
pop rbp
loc_E45D:
mov eax, ebp
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_E468:
mov [r15], r12d
mov byte ptr [r14+rbx-1], 0
test rax, rax
setz cl
cmp rax, r14
setz dl
xor ebp, ebp
or dl, cl
jnz short loc_E45D
dec rbx
mov byte ptr [r14], 0
mov rdi, r14
mov rsi, rax
mov rdx, rbx
call _strncat
jmp short loc_E45D
|
long long nglog::posix_strerror_r(nglog *this, _BYTE *a2, char *a3)
{
int *v4; // r15
int v5; // r12d
long long v6; // rax
unsigned int v7; // ebp
if ( a3 == 0LL || a2 == 0LL )
{
*(_DWORD *)__errno_location(this) = 22;
return (unsigned int)-1;
}
*a2 = 0;
v4 = (int *)((long long (*)(void))__errno_location)();
v5 = *v4;
*v4 = 0;
v6 = strerror_r((unsigned int)this, a2, a3);
if ( *v4 )
{
*a2 = 0;
return (unsigned int)-1;
}
*v4 = v5;
a3[(_QWORD)a2 - 1] = 0;
v7 = 0;
if ( v6 != 0 && v6 != (_QWORD)a2 )
{
*a2 = 0;
strncat(a2, v6, a3 - 1);
}
return v7;
}
|
posix_strerror_r:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
TEST RSI,RSI
SETNZ AL
TEST RDX,RDX
SETNZ CL
TEST AL,CL
JNZ 0x0010e42a
CALL 0x00108050
MOV dword ptr [RAX],0x16
JMP 0x0010e45a
LAB_0010e42a:
MOV RBX,RDX
MOV R14,RSI
MOV EBP,EDI
MOV byte ptr [RSI],0x0
CALL 0x00108050
MOV R15,RAX
MOV R12D,dword ptr [RAX]
AND dword ptr [RAX],0x0
MOV EDI,EBP
MOV RSI,R14
MOV RDX,RBX
CALL 0x00108110
CMP dword ptr [R15],0x0
JZ 0x0010e468
MOV byte ptr [R14],0x0
LAB_0010e45a:
PUSH -0x1
POP RBP
LAB_0010e45d:
MOV EAX,EBP
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0010e468:
MOV dword ptr [R15],R12D
MOV byte ptr [R14 + RBX*0x1 + -0x1],0x0
TEST RAX,RAX
SETZ CL
CMP RAX,R14
SETZ DL
XOR EBP,EBP
OR DL,CL
JNZ 0x0010e45d
DEC RBX
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV RSI,RAX
MOV RDX,RBX
CALL 0x001083b0
JMP 0x0010e45d
|
/* nglog::posix_strerror_r(int, char*, unsigned long) */
int4 nglog::posix_strerror_r(int param_1,char *param_2,ulong param_3)
{
int iVar1;
int *piVar2;
char *__src;
if (param_2 == (char *)0x0 || param_3 == 0) {
piVar2 = __errno_location();
*piVar2 = 0x16;
}
else {
*param_2 = '\0';
piVar2 = __errno_location();
iVar1 = *piVar2;
*piVar2 = 0;
__src = strerror_r(param_1,param_2,param_3);
if (*piVar2 == 0) {
*piVar2 = iVar1;
param_2[param_3 - 1] = '\0';
if (__src == param_2 || __src == (char *)0x0) {
return 0;
}
*param_2 = '\0';
strncat(param_2,__src,param_3 - 1);
return 0;
}
*param_2 = '\0';
}
return 0xffffffff;
}
|
|
19,787
|
nglog::posix_strerror_r(int, char*, unsigned long)
|
ng-log[P]ng-log/src/logging.cc
|
NGLOG_NO_EXPORT
int posix_strerror_r(int err, char* buf, size_t len) {
// Sanity check input parameters
if (buf == nullptr || len <= 0) {
errno = EINVAL;
return -1;
}
// Reset buf and errno, and try calling whatever version of strerror_r()
// is implemented by glibc
buf[0] = '\000';
int old_errno = errno;
errno = 0;
char* rc = reinterpret_cast<char*>(strerror_r(err, buf, len));
// Both versions set errno on failure
if (errno) {
// Should already be there, but better safe than sorry
buf[0] = '\000';
return -1;
}
errno = old_errno;
// POSIX is vague about whether the string will be terminated, although
// is indirectly implies that typically ERANGE will be returned, instead
// of truncating the string. This is different from the GNU implementation.
// We play it safe by always terminating the string explicitly.
buf[len - 1] = '\000';
// If the function succeeded, we can use its exit code to determine the
// semantics implemented by glibc
if (!rc) {
return 0;
} else {
// GNU semantics detected
if (rc == buf) {
return 0;
} else {
buf[0] = '\000';
#if defined(NGLOG_OS_MACOSX) || defined(NGLOG_OS_FREEBSD) || \
defined(NGLOG_OS_OPENBSD)
if (reinterpret_cast<intptr_t>(rc) < sys_nerr) {
// This means an error on MacOSX or FreeBSD.
return -1;
}
#endif
strncat(buf, rc, len - 1);
return 0;
}
}
}
|
O3
|
cpp
|
nglog::posix_strerror_r(int, char*, unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
setne %al
testq %rdx, %rdx
setne %cl
testb %cl, %al
jne 0xedc5
callq 0x7050
movl $0x16, (%rax)
jmp 0xedf8
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movb $0x0, (%rsi)
callq 0x7050
movq %rax, %r15
movl (%rax), %r12d
movl $0x0, (%rax)
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x70e0
cmpl $0x0, (%r15)
je 0xee08
movb $0x0, (%r14)
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r12d, (%r15)
movb $0x0, -0x1(%r14,%rbx)
testq %rax, %rax
sete %cl
cmpq %r14, %rax
sete %dl
xorl %ebp, %ebp
orb %cl, %dl
jne 0xedfd
decq %rbx
movb $0x0, (%r14)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x7340
jmp 0xedfd
|
_ZN5nglog16posix_strerror_rEiPcm:
push rbp
push r15
push r14
push r12
push rbx
test rsi, rsi
setnz al
test rdx, rdx
setnz cl
test al, cl
jnz short loc_EDC5
call ___errno_location
mov dword ptr [rax], 16h
jmp short loc_EDF8
loc_EDC5:
mov rbx, rdx
mov r14, rsi
mov ebp, edi
mov byte ptr [rsi], 0
call ___errno_location
mov r15, rax
mov r12d, [rax]
mov dword ptr [rax], 0
mov edi, ebp
mov rsi, r14
mov rdx, rbx
call _strerror_r
cmp dword ptr [r15], 0
jz short loc_EE08
mov byte ptr [r14], 0
loc_EDF8:
mov ebp, 0FFFFFFFFh
loc_EDFD:
mov eax, ebp
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_EE08:
mov [r15], r12d
mov byte ptr [r14+rbx-1], 0
test rax, rax
setz cl
cmp rax, r14
setz dl
xor ebp, ebp
or dl, cl
jnz short loc_EDFD
dec rbx
mov byte ptr [r14], 0
mov rdi, r14
mov rsi, rax
mov rdx, rbx
call _strncat
jmp short loc_EDFD
|
long long nglog::posix_strerror_r(nglog *this, _BYTE *a2, char *a3)
{
int *v4; // r15
int v5; // r12d
long long v6; // rax
unsigned int v7; // ebp
if ( a3 == 0LL || a2 == 0LL )
{
*(_DWORD *)__errno_location(this) = 22;
return (unsigned int)-1;
}
*a2 = 0;
v4 = (int *)((long long (*)(void))__errno_location)();
v5 = *v4;
*v4 = 0;
v6 = strerror_r((unsigned int)this, a2, a3);
if ( *v4 )
{
*a2 = 0;
return (unsigned int)-1;
}
*v4 = v5;
a3[(_QWORD)a2 - 1] = 0;
v7 = 0;
if ( v6 != 0 && v6 != (_QWORD)a2 )
{
*a2 = 0;
strncat(a2, v6, a3 - 1);
}
return v7;
}
|
posix_strerror_r:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
TEST RSI,RSI
SETNZ AL
TEST RDX,RDX
SETNZ CL
TEST AL,CL
JNZ 0x0010edc5
CALL 0x00107050
MOV dword ptr [RAX],0x16
JMP 0x0010edf8
LAB_0010edc5:
MOV RBX,RDX
MOV R14,RSI
MOV EBP,EDI
MOV byte ptr [RSI],0x0
CALL 0x00107050
MOV R15,RAX
MOV R12D,dword ptr [RAX]
MOV dword ptr [RAX],0x0
MOV EDI,EBP
MOV RSI,R14
MOV RDX,RBX
CALL 0x001070e0
CMP dword ptr [R15],0x0
JZ 0x0010ee08
MOV byte ptr [R14],0x0
LAB_0010edf8:
MOV EBP,0xffffffff
LAB_0010edfd:
MOV EAX,EBP
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0010ee08:
MOV dword ptr [R15],R12D
MOV byte ptr [R14 + RBX*0x1 + -0x1],0x0
TEST RAX,RAX
SETZ CL
CMP RAX,R14
SETZ DL
XOR EBP,EBP
OR DL,CL
JNZ 0x0010edfd
DEC RBX
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV RSI,RAX
MOV RDX,RBX
CALL 0x00107340
JMP 0x0010edfd
|
/* nglog::posix_strerror_r(int, char*, unsigned long) */
int8 nglog::posix_strerror_r(int param_1,char *param_2,ulong param_3)
{
int iVar1;
int *piVar2;
char *__src;
if (param_2 == (char *)0x0 || param_3 == 0) {
piVar2 = __errno_location();
*piVar2 = 0x16;
}
else {
*param_2 = '\0';
piVar2 = __errno_location();
iVar1 = *piVar2;
*piVar2 = 0;
__src = strerror_r(param_1,param_2,param_3);
if (*piVar2 == 0) {
*piVar2 = iVar1;
param_2[param_3 - 1] = '\0';
if (__src == param_2 || __src == (char *)0x0) {
return 0;
}
*param_2 = '\0';
strncat(param_2,__src,param_3 - 1);
return 0;
}
*param_2 = '\0';
}
return 0xffffffff;
}
|
|
19,788
|
ft_stroke_border_get_counts
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-stroker.c
|
static PVG_FT_Error ft_stroke_border_get_counts(PVG_FT_StrokeBorder border,
PVG_FT_UInt* anum_points,
PVG_FT_UInt* anum_contours)
{
PVG_FT_Error error = 0;
PVG_FT_UInt num_points = 0;
PVG_FT_UInt num_contours = 0;
PVG_FT_UInt count = border->num_points;
PVG_FT_Vector* point = border->points;
PVG_FT_Byte* tags = border->tags;
PVG_FT_Int in_contour = 0;
for (; count > 0; count--, num_points++, point++, tags++) {
if (tags[0] & PVG_FT_STROKE_TAG_BEGIN) {
if (in_contour != 0) goto Fail;
in_contour = 1;
} else if (in_contour == 0)
goto Fail;
if (tags[0] & PVG_FT_STROKE_TAG_END) {
in_contour = 0;
num_contours++;
}
}
if (in_contour != 0) goto Fail;
border->valid = TRUE;
Exit:
*anum_points = num_points;
*anum_contours = num_contours;
return error;
Fail:
num_points = 0;
num_contours = 0;
goto Exit;
}
|
O2
|
c
|
ft_stroke_border_get_counts:
pushq %rbx
movl (%rdi), %eax
movq 0x10(%rdi), %r8
xorl %r9d, %r9d
xorl %ecx, %ecx
xorl %r10d, %r10d
cmpl %r9d, %eax
je 0x36ea1
movzbl (%r8,%r9), %r11d
testb $0x4, %r11b
sete %bl
testl %r10d, %r10d
sete %r10b
cmpb %r10b, %bl
je 0x36ea6
xorl %r10d, %r10d
andl $0x8, %r11d
sete %r10b
shrl $0x3, %r11d
addl %r11d, %ecx
incq %r9
jmp 0x36e6d
testl %r10d, %r10d
je 0x36eb0
xorl %eax, %eax
xorl %ecx, %ecx
movl %eax, (%rsi)
movl %ecx, (%rdx)
popq %rbx
retq
movb $0x1, 0x20(%rdi)
jmp 0x36eaa
|
ft_stroke_border_get_counts:
push rbx
mov eax, [rdi]
mov r8, [rdi+10h]
xor r9d, r9d
xor ecx, ecx
xor r10d, r10d
loc_36E6D:
cmp eax, r9d
jz short loc_36EA1
movzx r11d, byte ptr [r8+r9]
test r11b, 4
setz bl
test r10d, r10d
setz r10b
cmp bl, r10b
jz short loc_36EA6
xor r10d, r10d
and r11d, 8
setz r10b
shr r11d, 3
add ecx, r11d
inc r9
jmp short loc_36E6D
loc_36EA1:
test r10d, r10d
jz short loc_36EB0
loc_36EA6:
xor eax, eax
xor ecx, ecx
loc_36EAA:
mov [rsi], eax
mov [rdx], ecx
pop rbx
retn
loc_36EB0:
mov byte ptr [rdi+20h], 1
jmp short loc_36EAA
|
long long ft_stroke_border_get_counts(unsigned int *a1, _DWORD *a2, _DWORD *a3)
{
long long result; // rax
long long v4; // r9
int v5; // ecx
BOOL v6; // r10d
char v7; // r11
unsigned int v8; // r11d
result = *a1;
v4 = 0LL;
v5 = 0;
v6 = 0;
while ( (_DWORD)result != (_DWORD)v4 )
{
v7 = *(_BYTE *)(*((_QWORD *)a1 + 2) + v4);
if ( ((v7 & 4) == 0) == !v6 )
goto LABEL_6;
v8 = v7 & 8;
v6 = v8 == 0;
v5 += v8 >> 3;
++v4;
}
if ( v6 )
{
LABEL_6:
result = 0LL;
v5 = 0;
goto LABEL_7;
}
*((_BYTE *)a1 + 32) = 1;
LABEL_7:
*a2 = result;
*a3 = v5;
return result;
}
|
ft_stroke_border_get_counts:
PUSH RBX
MOV EAX,dword ptr [RDI]
MOV R8,qword ptr [RDI + 0x10]
XOR R9D,R9D
XOR ECX,ECX
XOR R10D,R10D
LAB_00136e6d:
CMP EAX,R9D
JZ 0x00136ea1
MOVZX R11D,byte ptr [R8 + R9*0x1]
TEST R11B,0x4
SETZ BL
TEST R10D,R10D
SETZ R10B
CMP BL,R10B
JZ 0x00136ea6
XOR R10D,R10D
AND R11D,0x8
SETZ R10B
SHR R11D,0x3
ADD ECX,R11D
INC R9
JMP 0x00136e6d
LAB_00136ea1:
TEST R10D,R10D
JZ 0x00136eb0
LAB_00136ea6:
XOR EAX,EAX
XOR ECX,ECX
LAB_00136eaa:
MOV dword ptr [RSI],EAX
MOV dword ptr [RDX],ECX
POP RBX
RET
LAB_00136eb0:
MOV byte ptr [RDI + 0x20],0x1
JMP 0x00136eaa
|
void ft_stroke_border_get_counts(int *param_1,int *param_2,int *param_3)
{
byte bVar1;
int iVar2;
int iVar3;
long lVar4;
bool bVar5;
iVar2 = *param_1;
iVar3 = 0;
bVar5 = false;
for (lVar4 = 0; iVar2 != (int)lVar4; lVar4 = lVar4 + 1) {
bVar1 = *(byte *)(*(long *)(param_1 + 4) + lVar4);
if (((bVar1 & 4) == 0) == !bVar5) goto LAB_00136ea6;
bVar5 = (bVar1 & 8) == 0;
iVar3 = iVar3 + ((bVar1 & 8) >> 3);
}
if (bVar5) {
LAB_00136ea6:
iVar2 = 0;
iVar3 = 0;
}
else {
*(int1 *)(param_1 + 8) = 1;
}
*param_2 = iVar2;
*param_3 = iVar3;
return;
}
|
|
19,789
|
ft_stroke_border_get_counts
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-stroker.c
|
static PVG_FT_Error ft_stroke_border_get_counts(PVG_FT_StrokeBorder border,
PVG_FT_UInt* anum_points,
PVG_FT_UInt* anum_contours)
{
PVG_FT_Error error = 0;
PVG_FT_UInt num_points = 0;
PVG_FT_UInt num_contours = 0;
PVG_FT_UInt count = border->num_points;
PVG_FT_Vector* point = border->points;
PVG_FT_Byte* tags = border->tags;
PVG_FT_Int in_contour = 0;
for (; count > 0; count--, num_points++, point++, tags++) {
if (tags[0] & PVG_FT_STROKE_TAG_BEGIN) {
if (in_contour != 0) goto Fail;
in_contour = 1;
} else if (in_contour == 0)
goto Fail;
if (tags[0] & PVG_FT_STROKE_TAG_END) {
in_contour = 0;
num_contours++;
}
}
if (in_contour != 0) goto Fail;
border->valid = TRUE;
Exit:
*anum_points = num_points;
*anum_contours = num_contours;
return error;
Fail:
num_points = 0;
num_contours = 0;
goto Exit;
}
|
O3
|
c
|
ft_stroke_border_get_counts:
pushq %rbp
pushq %rbx
movl (%rdi), %eax
testq %rax, %rax
je 0x3e73b
movq 0x10(%rdi), %r9
xorl %ecx, %ecx
xorl %r10d, %r10d
xorl %ebx, %ebx
xorl %r8d, %r8d
movzbl (%r9,%r10), %r11d
testb $0x4, %r11b
sete %bpl
testl %ebx, %ebx
sete %bl
cmpb %bl, %bpl
je 0x3e749
xorl %ebx, %ebx
andl $0x8, %r11d
sete %bl
movl %r11d, %ebp
shrl $0x3, %ebp
addl %ebp, %r8d
incq %r10
cmpl %r10d, %eax
jne 0x3e6fd
movl $0x0, %r9d
testb %r11b, %r11b
jne 0x3e73e
jmp 0x3e74c
xorl %r8d, %r8d
movb $0x1, 0x20(%rdi)
movl %eax, %ecx
movl %r8d, %r9d
jmp 0x3e74c
xorl %r9d, %r9d
movl %ecx, (%rsi)
movl %r9d, (%rdx)
popq %rbx
popq %rbp
retq
|
ft_stroke_border_get_counts:
push rbp
push rbx
mov eax, [rdi]
test rax, rax
jz short loc_3E73B
mov r9, [rdi+10h]
xor ecx, ecx
xor r10d, r10d
xor ebx, ebx
xor r8d, r8d
loc_3E6FD:
movzx r11d, byte ptr [r9+r10]
test r11b, 4
setz bpl
test ebx, ebx
setz bl
cmp bpl, bl
jz short loc_3E749
xor ebx, ebx
and r11d, 8
setz bl
mov ebp, r11d
shr ebp, 3
add r8d, ebp
inc r10
cmp eax, r10d
jnz short loc_3E6FD
mov r9d, 0
test r11b, r11b
jnz short loc_3E73E
jmp short loc_3E74C
loc_3E73B:
xor r8d, r8d
loc_3E73E:
mov byte ptr [rdi+20h], 1
mov ecx, eax
mov r9d, r8d
jmp short loc_3E74C
loc_3E749:
xor r9d, r9d
loc_3E74C:
mov [rsi], ecx
mov [rdx], r9d
pop rbx
pop rbp
retn
|
long long ft_stroke_border_get_counts(unsigned int *a1, _DWORD *a2, _DWORD *a3)
{
long long result; // rax
int v4; // ecx
long long v5; // r10
BOOL v6; // ebx
int v7; // r8d
char v8; // r11
unsigned int v9; // r11d
int v10; // r9d
result = *a1;
if ( *a1 )
{
v4 = 0;
v5 = 0LL;
v6 = 0;
v7 = 0;
do
{
v8 = *(_BYTE *)(*((_QWORD *)a1 + 2) + v5);
if ( ((v8 & 4) == 0) == !v6 )
{
v10 = 0;
goto LABEL_10;
}
v9 = v8 & 8;
v6 = v9 == 0;
v7 += v9 >> 3;
++v5;
}
while ( (_DWORD)result != (_DWORD)v5 );
v10 = 0;
if ( (_BYTE)v9 )
goto LABEL_8;
}
else
{
v7 = 0;
LABEL_8:
*((_BYTE *)a1 + 32) = 1;
v4 = result;
v10 = v7;
}
LABEL_10:
*a2 = v4;
*a3 = v10;
return result;
}
|
ft_stroke_border_get_counts:
PUSH RBP
PUSH RBX
MOV EAX,dword ptr [RDI]
TEST RAX,RAX
JZ 0x0013e73b
MOV R9,qword ptr [RDI + 0x10]
XOR ECX,ECX
XOR R10D,R10D
XOR EBX,EBX
XOR R8D,R8D
LAB_0013e6fd:
MOVZX R11D,byte ptr [R9 + R10*0x1]
TEST R11B,0x4
SETZ BPL
TEST EBX,EBX
SETZ BL
CMP BPL,BL
JZ 0x0013e749
XOR EBX,EBX
AND R11D,0x8
SETZ BL
MOV EBP,R11D
SHR EBP,0x3
ADD R8D,EBP
INC R10
CMP EAX,R10D
JNZ 0x0013e6fd
MOV R9D,0x0
TEST R11B,R11B
JNZ 0x0013e73e
JMP 0x0013e74c
LAB_0013e73b:
XOR R8D,R8D
LAB_0013e73e:
MOV byte ptr [RDI + 0x20],0x1
MOV ECX,EAX
MOV R9D,R8D
JMP 0x0013e74c
LAB_0013e749:
XOR R9D,R9D
LAB_0013e74c:
MOV dword ptr [RSI],ECX
MOV dword ptr [RDX],R9D
POP RBX
POP RBP
RET
|
void ft_stroke_border_get_counts(int *param_1,int *param_2,int *param_3)
{
byte bVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
long lVar6;
bool bVar7;
iVar2 = *param_1;
if (iVar2 == 0) {
iVar4 = 0;
}
else {
iVar3 = 0;
lVar6 = 0;
bVar7 = false;
iVar4 = 0;
do {
bVar1 = *(byte *)(*(long *)(param_1 + 4) + lVar6);
if (((bVar1 & 4) == 0) == !bVar7) {
iVar5 = 0;
goto LAB_0013e74c;
}
bVar7 = (bVar1 & 8) == 0;
iVar4 = iVar4 + ((bVar1 & 8) >> 3);
lVar6 = lVar6 + 1;
} while (iVar2 != (int)lVar6);
iVar5 = 0;
if ((char)(bVar1 & 8) == '\0') goto LAB_0013e74c;
}
*(int1 *)(param_1 + 8) = 1;
iVar3 = iVar2;
iVar5 = iVar4;
LAB_0013e74c:
*param_2 = iVar3;
*param_3 = iVar5;
return;
}
|
|
19,790
|
common_embd_similarity_cos(float const*, float const*, int)
|
monkey531[P]llama/common/common.cpp
|
float common_embd_similarity_cos(const float * embd1, const float * embd2, int n){
double sum = 0.0;
double sum1 = 0.0;
double sum2 = 0.0;
for (int i = 0; i < n; i++) {
sum += embd1[i] * embd2[i];
sum1 += embd1[i] * embd1[i];
sum2 += embd2[i] * embd2[i];
}
// Handle the case where one or both vectors are zero vectors
if (sum1 == 0.0 || sum2 == 0.0) {
if (sum1 == 0.0 && sum2 == 0.0) {
return 1.0f; // two zero vectors are similar
}
return 0.0f;
}
return sum / (sqrt(sum1) * sqrt(sum2));
}
|
O1
|
cpp
|
common_embd_similarity_cos(float const*, float const*, int):
xorpd %xmm1, %xmm1
testl %edx, %edx
jle 0x7d0db
movl %edx, %eax
xorpd %xmm0, %xmm0
xorpd %xmm5, %xmm5
xorl %ecx, %ecx
movss (%rdi,%rcx,4), %xmm2
movss (%rsi,%rcx,4), %xmm3
movaps %xmm2, %xmm4
mulss %xmm3, %xmm4
cvtss2sd %xmm4, %xmm4
unpcklps %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
mulps %xmm2, %xmm2
cvtps2pd %xmm2, %xmm2
addsd %xmm4, %xmm5
addpd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x7d0ab
jmp 0x7d0e3
xorpd %xmm0, %xmm0
xorpd %xmm5, %xmm5
subq $0x28, %rsp
ucomisd %xmm1, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2 # xmm2 = xmm2[1],xmm0[1]
jne 0x7d0f7
jnp 0x7d118
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x7d103
jnp 0x7d118
ucomisd %xmm1, %xmm0
movsd %xmm5, 0x8(%rsp)
jb 0x7d142
xorps %xmm3, %xmm3
sqrtsd %xmm0, %xmm3
jmp 0x7d157
xorpd %xmm1, %xmm1
cmpeqpd %xmm1, %xmm2
cmpeqpd %xmm0, %xmm1
andpd %xmm2, %xmm1
movd %xmm1, %eax
testb $0x1, %al
jne 0x7d138
xorpd %xmm0, %xmm0
jmp 0x7d194
movss 0x7004c(%rip), %xmm0 # 0xed18c
jmp 0x7d194
movapd %xmm2, 0x10(%rsp)
callq 0x1b730
movapd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jb 0x7d16a
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x7d17f
movapd %xmm2, %xmm0
movsd %xmm3, 0x10(%rsp)
callq 0x1b730
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm3
divsd %xmm3, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
addq $0x28, %rsp
retq
nop
|
_Z26common_embd_similarity_cosPKfS0_i:
xorpd xmm1, xmm1
test edx, edx
jle short loc_7D0DB
mov eax, edx
xorpd xmm0, xmm0
xorpd xmm5, xmm5
xor ecx, ecx
loc_7D0AB:
movss xmm2, dword ptr [rdi+rcx*4]
movss xmm3, dword ptr [rsi+rcx*4]
movaps xmm4, xmm2
mulss xmm4, xmm3
cvtss2sd xmm4, xmm4
unpcklps xmm2, xmm3
mulps xmm2, xmm2
cvtps2pd xmm2, xmm2
addsd xmm5, xmm4
addpd xmm0, xmm2
inc rcx
cmp rax, rcx
jnz short loc_7D0AB
jmp short loc_7D0E3
loc_7D0DB:
xorpd xmm0, xmm0
xorpd xmm5, xmm5
loc_7D0E3:
sub rsp, 28h
ucomisd xmm0, xmm1
movapd xmm2, xmm0
unpckhpd xmm2, xmm0
jnz short loc_7D0F7
jnp short loc_7D118
loc_7D0F7:
xorpd xmm1, xmm1
ucomisd xmm2, xmm1
jnz short loc_7D103
jnp short loc_7D118
loc_7D103:
ucomisd xmm0, xmm1
movsd [rsp+28h+var_20], xmm5
jb short loc_7D142
xorps xmm3, xmm3
sqrtsd xmm3, xmm0
jmp short loc_7D157
loc_7D118:
xorpd xmm1, xmm1
cmpeqpd xmm2, xmm1
cmpeqpd xmm1, xmm0
andpd xmm1, xmm2
movd eax, xmm1
test al, 1
jnz short loc_7D138
xorpd xmm0, xmm0
jmp short loc_7D194
loc_7D138:
movss xmm0, cs:dword_ED18C
jmp short loc_7D194
loc_7D142:
movapd [rsp+28h+var_18], xmm2
call _sqrt
movapd xmm2, [rsp+28h+var_18]
movapd xmm3, xmm0
loc_7D157:
xorpd xmm0, xmm0
ucomisd xmm2, xmm0
jb short loc_7D16A
xorps xmm0, xmm0
sqrtsd xmm0, xmm2
jmp short loc_7D17F
loc_7D16A:
movapd xmm0, xmm2
movsd qword ptr [rsp+28h+var_18], xmm3
call _sqrt
movsd xmm3, qword ptr [rsp+28h+var_18]
loc_7D17F:
movsd xmm1, [rsp+28h+var_20]
mulsd xmm3, xmm0
divsd xmm1, xmm3
xorps xmm0, xmm0
cvtsd2ss xmm0, xmm1
loc_7D194:
add rsp, 28h
retn
|
float common_embd_similarity_cos(const float *a1, const float *a2, int a3)
{
__m128d v3; // xmm0
double v4; // xmm5_8
long long i; // rcx
__m128 v6; // xmm3
__m128 v7; // xmm2
__m128d v8; // xmm2
double v9; // xmm3_8
double v11; // xmm0_8
double v12; // [rsp+0h] [rbp-20h]
if ( a3 <= 0 )
{
v3 = 0LL;
v4 = 0.0;
}
else
{
v3 = 0LL;
v4 = 0.0;
for ( i = 0LL; i != a3; ++i )
{
v6 = (__m128)LODWORD(a2[i]);
v7 = _mm_unpacklo_ps((__m128)LODWORD(a1[i]), v6);
v4 = v4 + (float)(a1[i] * v6.m128_f32[0]);
v3 = _mm_add_pd(v3, _mm_cvtps_pd(_mm_mul_ps(v7, v7)));
}
}
v8 = _mm_unpackhi_pd(v3, v3);
if ( v3.m128d_f64[0] == 0.0 || v8.m128d_f64[0] == 0.0 )
{
if ( (_mm_cvtsi128_si32((__m128i)_mm_and_pd(_mm_cmpeq_pd((__m128d)0LL, v3), _mm_cmpeq_pd(v8, (__m128d)0LL))) & 1) != 0 )
return 1.0;
else
return 0.0;
}
else
{
v12 = v4;
if ( v3.m128d_f64[0] < 0.0 )
v9 = sqrt(v3.m128d_f64[0]);
else
v9 = sqrt(v3.m128d_f64[0]);
if ( v8.m128d_f64[0] < 0.0 )
v11 = sqrt(v8.m128d_f64[0]);
else
v11 = sqrt(v8.m128d_f64[0]);
return v12 / (v9 * v11);
}
}
|
common_embd_similarity_cos:
XORPD XMM1,XMM1
TEST EDX,EDX
JLE 0x0017d0db
MOV EAX,EDX
XORPD XMM0,XMM0
XORPD XMM5,XMM5
XOR ECX,ECX
LAB_0017d0ab:
MOVSS XMM2,dword ptr [RDI + RCX*0x4]
MOVSS XMM3,dword ptr [RSI + RCX*0x4]
MOVAPS XMM4,XMM2
MULSS XMM4,XMM3
CVTSS2SD XMM4,XMM4
UNPCKLPS XMM2,XMM3
MULPS XMM2,XMM2
CVTPS2PD XMM2,XMM2
ADDSD XMM5,XMM4
ADDPD XMM0,XMM2
INC RCX
CMP RAX,RCX
JNZ 0x0017d0ab
JMP 0x0017d0e3
LAB_0017d0db:
XORPD XMM0,XMM0
XORPD XMM5,XMM5
LAB_0017d0e3:
SUB RSP,0x28
UCOMISD XMM0,XMM1
MOVAPD XMM2,XMM0
UNPCKHPD XMM2,XMM0
JNZ 0x0017d0f7
JNP 0x0017d118
LAB_0017d0f7:
XORPD XMM1,XMM1
UCOMISD XMM2,XMM1
JNZ 0x0017d103
JNP 0x0017d118
LAB_0017d103:
UCOMISD XMM0,XMM1
MOVSD qword ptr [RSP + 0x8],XMM5
JC 0x0017d142
XORPS XMM3,XMM3
SQRTSD XMM3,XMM0
JMP 0x0017d157
LAB_0017d118:
XORPD XMM1,XMM1
CMPEQPD XMM2,XMM1
CMPEQPD XMM1,XMM0
ANDPD XMM1,XMM2
MOVD EAX,XMM1
TEST AL,0x1
JNZ 0x0017d138
XORPD XMM0,XMM0
JMP 0x0017d194
LAB_0017d138:
MOVSS XMM0,dword ptr [0x001ed18c]
JMP 0x0017d194
LAB_0017d142:
MOVAPD xmmword ptr [RSP + 0x10],XMM2
CALL 0x0011b730
MOVAPD XMM2,xmmword ptr [RSP + 0x10]
MOVAPD XMM3,XMM0
LAB_0017d157:
XORPD XMM0,XMM0
UCOMISD XMM2,XMM0
JC 0x0017d16a
XORPS XMM0,XMM0
SQRTSD XMM0,XMM2
JMP 0x0017d17f
LAB_0017d16a:
MOVAPD XMM0,XMM2
MOVSD qword ptr [RSP + 0x10],XMM3
CALL 0x0011b730
MOVSD XMM3,qword ptr [RSP + 0x10]
LAB_0017d17f:
MOVSD XMM1,qword ptr [RSP + 0x8]
MULSD XMM3,XMM0
DIVSD XMM1,XMM3
XORPS XMM0,XMM0
CVTSD2SS XMM0,XMM1
LAB_0017d194:
ADD RSP,0x28
RET
|
/* common_embd_similarity_cos(float const*, float const*, int) */
float common_embd_similarity_cos(float *param_1,float *param_2,int param_3)
{
float fVar1;
ulong uVar2;
float fVar3;
double dVar4;
double dVar5;
double dVar6;
if (param_3 < 1) {
dVar4 = 0.0;
dVar5 = 0.0;
dVar6 = 0.0;
}
else {
dVar4 = 0.0;
dVar5 = 0.0;
dVar6 = 0.0;
uVar2 = 0;
do {
fVar3 = param_1[uVar2];
fVar1 = param_2[uVar2];
dVar6 = dVar6 + (double)(fVar3 * fVar1);
dVar4 = dVar4 + (double)(fVar3 * fVar3);
dVar5 = dVar5 + (double)(fVar1 * fVar1);
uVar2 = uVar2 + 1;
} while ((uint)param_3 != uVar2);
}
if (((dVar4 == 0.0) && (!NAN(dVar4))) || ((dVar5 == 0.0 && (!NAN(dVar5))))) {
fVar3 = DAT_001ed18c;
if (dVar4 != 0.0 || dVar5 != 0.0) {
fVar3 = 0.0;
}
}
else {
if (dVar4 < 0.0) {
dVar4 = sqrt(dVar4);
}
else {
dVar4 = SQRT(dVar4);
}
if (dVar5 < 0.0) {
dVar5 = sqrt(dVar5);
}
else {
dVar5 = SQRT(dVar5);
}
fVar3 = (float)(dVar6 / (dVar4 * dVar5));
}
return fVar3;
}
|
|
19,791
|
ma_tls_set_error
|
eloqsql/libmariadb/libmariadb/secure/openssl.c
|
static void ma_tls_set_error(MYSQL *mysql)
{
ulong ssl_errno= ERR_get_error();
char ssl_error[MAX_SSL_ERR_LEN];
const char *ssl_error_reason;
MARIADB_PVIO *pvio= mysql->net.pvio;
int save_errno= errno;
if (ssl_errno && (ssl_error_reason= ERR_reason_error_string(ssl_errno)))
{
pvio->set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
0, ssl_error_reason);
return;
}
strerror_r(save_errno, ssl_error, MAX_SSL_ERR_LEN);
pvio->set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN, "TLS/SSL error: %s (%d)",
ssl_error, save_errno);
return;
}
|
O3
|
c
|
ma_tls_set_error:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
callq 0x135f0
movq %rax, %r15
movq (%rbx), %r12
callq 0x13060
movl (%rax), %r14d
testq %r15, %r15
je 0x2863c
movq %r15, %rdi
callq 0x13800
testq %rax, %rax
je 0x2863c
movq 0x50(%r12), %r9
leaq 0x204b4(%rip), %rcx # 0x48ac0
movq (%rcx), %rdx
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0x28695
movq %rbx, %rdi
movl $0x7ea, %esi # imm = 0x7EA
xorl %ecx, %ecx
movq %rax, %r8
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%r9
leaq -0x90(%rbp), %r15
movl $0x64, %edx
movl %r14d, %edi
movq %r15, %rsi
callq 0x131e0
leaq 0x20466(%rip), %rax # 0x48ac0
movq (%rax), %rdx
leaq 0xca03(%rip), %rcx # 0x35067
movq %rbx, %rdi
movl $0x7ea, %esi # imm = 0x7EA
movq %r15, %r8
movl %r14d, %r9d
xorl %eax, %eax
callq *0x50(%r12)
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x28695
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
|
ma_tls_set_error:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 70h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
call _ERR_get_error
mov r15, rax
mov r12, [rbx]
call ___errno_location
mov r14d, [rax]
test r15, r15
jz short loc_2863C
mov rdi, r15
call _ERR_reason_error_string
test rax, rax
jz short loc_2863C
mov r9, [r12+50h]
lea rcx, SQLSTATE_UNKNOWN
mov rdx, [rcx]
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_28695
mov rdi, rbx
mov esi, 7EAh
xor ecx, ecx
mov r8, rax
xor eax, eax
add rsp, 70h
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp r9
loc_2863C:
lea r15, [rbp+var_90]
mov edx, 64h ; 'd'
mov edi, r14d
mov rsi, r15
call ___xpg_strerror_r
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rcx, aTlsSslErrorSD; "TLS/SSL error: %s (%d)"
mov rdi, rbx
mov esi, 7EAh
mov r8, r15
mov r9d, r14d
xor eax, eax
call qword ptr [r12+50h]
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_28695
add rsp, 70h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_28695:
call ___stack_chk_fail
|
long long ma_tls_set_error(long long *a1)
{
long long error; // r15
long long v2; // r12
unsigned int v3; // r14d
long long v4; // rax
char v6[104]; // [rsp+0h] [rbp-90h] BYREF
unsigned long long v7; // [rsp+68h] [rbp-28h]
v7 = __readfsqword(0x28u);
error = ERR_get_error();
v2 = *a1;
v3 = *(_DWORD *)__errno_location(a1);
if ( error )
{
v4 = ERR_reason_error_string(error);
if ( v4 )
return (*(long long ( **)(long long *, long long, char *, _QWORD, long long))(v2 + 80))(
a1,
2026LL,
SQLSTATE_UNKNOWN,
0LL,
v4);
}
__xpg_strerror_r(v3, v6, 100LL);
(*(void (**)(long long *, long long, char *, const char *, ...))(v2 + 80))(
a1,
2026LL,
SQLSTATE_UNKNOWN,
"TLS/SSL error: %s (%d)",
v6,
v3);
return __readfsqword(0x28u);
}
|
ma_tls_set_error:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x70
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
CALL 0x001135f0
MOV R15,RAX
MOV R12,qword ptr [RBX]
CALL 0x00113060
MOV R14D,dword ptr [RAX]
TEST R15,R15
JZ 0x0012863c
MOV RDI,R15
CALL 0x00113800
TEST RAX,RAX
JZ 0x0012863c
MOV R9,qword ptr [R12 + 0x50]
LEA RCX,[0x148ac0]
MOV RDX,qword ptr [RCX]
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x00128695
MOV RDI,RBX
MOV ESI,0x7ea
XOR ECX,ECX
MOV R8,RAX
XOR EAX,EAX
ADD RSP,0x70
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP R9
LAB_0012863c:
LEA R15,[RBP + -0x90]
MOV EDX,0x64
MOV EDI,R14D
MOV RSI,R15
CALL 0x001131e0
LEA RAX,[0x148ac0]
MOV RDX,qword ptr [RAX]
LEA RCX,[0x135067]
MOV RDI,RBX
MOV ESI,0x7ea
MOV R8,R15
MOV R9D,R14D
XOR EAX,EAX
CALL qword ptr [R12 + 0x50]
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x00128695
ADD RSP,0x70
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00128695:
CALL 0x00113500
|
void ma_tls_set_error(long *param_1)
{
int iVar1;
long lVar2;
code *UNRECOVERED_JUMPTABLE;
ulong e;
int *piVar3;
char *pcVar4;
long in_FS_OFFSET;
int1 local_98 [104];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
e = ERR_get_error();
lVar2 = *param_1;
piVar3 = __errno_location();
iVar1 = *piVar3;
if (e != 0) {
pcVar4 = ERR_reason_error_string(e);
if (pcVar4 != (char *)0x0) {
UNRECOVERED_JUMPTABLE = *(code **)(lVar2 + 0x50);
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
/* WARNING: Could not recover jumptable at 0x00128639. Too many branches */
/* WARNING: Treating indirect jump as call */
(*UNRECOVERED_JUMPTABLE)(param_1,0x7ea,SQLSTATE_UNKNOWN,0,pcVar4,UNRECOVERED_JUMPTABLE);
return;
}
goto LAB_00128695;
}
}
__xpg_strerror_r(iVar1,local_98,100);
(**(code **)(lVar2 + 0x50))
(param_1,0x7ea,SQLSTATE_UNKNOWN,"TLS/SSL error: %s (%d)",local_98,iVar1);
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return;
}
LAB_00128695:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
19,792
|
ggml_vec_dot_f16_unroll
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
inline static void ggml_vec_dot_f16_unroll(const int n, const int xs, float * restrict s, void * restrict xv, ggml_fp16_t * restrict y) {
ggml_float sumf[GGML_VEC_DOT_UNROLL] = { 0.0 };
ggml_fp16_t * restrict x[GGML_VEC_DOT_UNROLL];
for (int i = 0; i < GGML_VEC_DOT_UNROLL; ++i) {
x[i] = (ggml_fp16_t *) ((char *) xv + i*xs);
}
#if defined(GGML_SIMD)
const int np = (n & ~(GGML_F16_STEP - 1));
GGML_F16_VEC sum[GGML_VEC_DOT_UNROLL][GGML_F16_ARR] = { { GGML_F16_VEC_ZERO } };
GGML_F16_VEC ax[GGML_F16_ARR];
GGML_F16_VEC ay[GGML_F16_ARR];
for (int i = 0; i < np; i += GGML_F16_STEP) {
for (int j = 0; j < GGML_F16_ARR; j++) {
ay[j] = GGML_F16_VEC_LOAD(y + i + j*GGML_F16_EPR, j);
for (int k = 0; k < GGML_VEC_DOT_UNROLL; ++k) {
ax[j] = GGML_F16_VEC_LOAD(x[k] + i + j*GGML_F16_EPR, j);
sum[k][j] = GGML_F16_VEC_FMA(sum[k][j], ax[j], ay[j]);
}
}
}
// reduce sum0..sum3 to sum0
for (int k = 0; k < GGML_VEC_DOT_UNROLL; ++k) {
GGML_F16_VEC_REDUCE(sumf[k], sum[k]);
}
// leftovers
for (int i = np; i < n; ++i) {
for (int j = 0; j < GGML_VEC_DOT_UNROLL; ++j) {
sumf[j] += (ggml_float)(GGML_FP16_TO_FP32(x[j][i])*GGML_FP16_TO_FP32(y[i]));
}
}
#else
for (int i = 0; i < n; ++i) {
for (int j = 0; j < GGML_VEC_DOT_UNROLL; ++j) {
sumf[j] += (ggml_float)(GGML_FP16_TO_FP32(x[j][i])*GGML_FP16_TO_FP32(y[i]));
}
}
#endif
for (int i = 0; i < GGML_VEC_DOT_UNROLL; ++i) {
s[i] = sumf[i];
}
}
|
O2
|
c
|
ggml_vec_dot_f16_unroll:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x140, %rsp # imm = 0x140
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
movslq %esi, %rax
movq %rcx, 0x10(%rsp)
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl %edi, %eax
andl $-0x20, %eax
cltq
vxorps %xmm0, %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
vmovaps %ymm0, 0xe0(%rcx)
vmovaps %ymm0, 0xc0(%rcx)
vmovaps %ymm0, 0xa0(%rcx)
vmovaps %ymm0, 0x80(%rcx)
vmovaps %ymm0, 0x60(%rcx)
vmovaps %ymm0, 0x40(%rcx)
vmovaps %ymm0, 0x20(%rcx)
vmovaps %ymm0, (%rcx)
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x8e914
leaq (%r8,%rsi,2), %r9
leaq (%rsi,%rsi), %r10
movq %rcx, %r11
xorl %ebx, %ebx
cmpq $0x4, %rbx
je 0x8e90e
leaq (,%rbx,8), %r14
movq %rbx, %r15
shlq $0x4, %r15
vcvtph2ps (%r9,%r15), %ymm0
movq %r11, %r15
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0x8e905
movq 0x10(%rsp,%r12,8), %r13
addq %r10, %r13
vcvtph2ps (%r13,%r14,2), %ymm1
vfmadd213ps (%r15), %ymm0, %ymm1 # ymm1 = (ymm0 * ymm1) + mem
vmovaps %ymm1, (%r15)
incq %r12
subq $-0x80, %r15
jmp 0x8e8dd
incq %rbx
addq $0x20, %r11
jmp 0x8e8bc
addq $0x20, %rsi
jmp 0x8e8aa
leaq 0x60(%rsp), %rcx
xorl %esi, %esi
pushq $-0x40
popq %r9
cmpq $0x2, %rsi
je 0x8e986
movq %r9, %r10
testq %r10, %r10
je 0x8e946
vmovaps (%rcx,%r10), %ymm0
vaddps 0x40(%rcx,%r10), %ymm0, %ymm0
vmovaps %ymm0, (%rcx,%r10)
addq $0x20, %r10
jmp 0x8e928
movq %rsi, %r10
shlq $0x7, %r10
vmovaps 0x20(%rsp,%r10), %ymm0
vaddps 0x40(%rsp,%r10), %ymm0, %ymm0
vextractf128 $0x1, %ymm0, %xmm1
vaddps %xmm1, %xmm0, %xmm1
vhaddps %xmm1, %xmm1, %xmm1
vmovaps %ymm0, 0x20(%rsp,%r10)
vhaddps %xmm1, %xmm1, %xmm0
vcvtss2sd %xmm0, %xmm0, %xmm0
vmovsd %xmm0, (%rsp,%rsi,8)
incq %rsi
subq $-0x80, %rcx
jmp 0x8e91f
movslq %edi, %rcx
leaq 0xce900(%rip), %rsi # 0x15d290
cmpq %rcx, %rax
jge 0x8e9cf
movzwl (%r8,%rax,2), %edi
vmovss (%rsi,%rdi,4), %xmm0
xorl %edi, %edi
cmpq $0x2, %rdi
je 0x8e9ca
movq 0x10(%rsp,%rdi,8), %r9
movzwl (%r9,%rax,2), %r9d
vmulss (%rsi,%r9,4), %xmm0, %xmm1
vcvtss2sd %xmm1, %xmm1, %xmm1
vaddsd (%rsp,%rdi,8), %xmm1, %xmm1
vmovsd %xmm1, (%rsp,%rdi,8)
incq %rdi
jmp 0x8e9a1
incq %rax
jmp 0x8e990
xorl %eax, %eax
cmpq $0x2, %rax
je 0x8e9e6
vcvtsd2ss (%rsp,%rax,8), %xmm2, %xmm0
vmovss %xmm0, (%rdx,%rax,4)
incq %rax
jmp 0x8e9d1
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
|
ggml_vec_dot_f16_unroll:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
and rsp, 0FFFFFFFFFFFFFFE0h
sub rsp, 140h
vxorps xmm0, xmm0, xmm0
vmovaps [rsp+168h+var_168], xmm0
movsxd rax, esi
mov [rsp+168h+var_158], rcx
add rax, rcx
mov [rsp+168h+var_150], rax
mov eax, edi
and eax, 0FFFFFFE0h
cdqe
vxorps xmm0, xmm0, xmm0
lea rcx, [rsp+168h+var_148]
vmovaps ymmword ptr [rcx+0E0h], ymm0
vmovaps ymmword ptr [rcx+0C0h], ymm0
vmovaps ymmword ptr [rcx+0A0h], ymm0
vmovaps ymmword ptr [rcx+80h], ymm0
vmovaps ymmword ptr [rcx+60h], ymm0
vmovaps ymmword ptr [rcx+40h], ymm0
vmovaps ymmword ptr [rcx+20h], ymm0
vmovaps ymmword ptr [rcx], ymm0
xor esi, esi
loc_8E8AA:
cmp rsi, rax
jge short loc_8E914
lea r9, [r8+rsi*2]
lea r10, [rsi+rsi]
mov r11, rcx
xor ebx, ebx
loc_8E8BC:
cmp rbx, 4
jz short loc_8E90E
lea r14, ds:0[rbx*8]
mov r15, rbx
shl r15, 4
vcvtph2ps ymm0, xmmword ptr [r9+r15]
mov r15, r11
xor r12d, r12d
loc_8E8DD:
cmp r12, 2
jz short loc_8E905
mov r13, [rsp+r12*8+168h+var_158]
add r13, r10
vcvtph2ps ymm1, xmmword ptr [r13+r14*2+0]
vfmadd213ps ymm1, ymm0, ymmword ptr [r15]
vmovaps ymmword ptr [r15], ymm1
inc r12
sub r15, 0FFFFFFFFFFFFFF80h
jmp short loc_8E8DD
loc_8E905:
inc rbx
add r11, 20h ; ' '
jmp short loc_8E8BC
loc_8E90E:
add rsi, 20h ; ' '
jmp short loc_8E8AA
loc_8E914:
lea rcx, [rsp+168h+var_108]
xor esi, esi
push 0FFFFFFFFFFFFFFC0h
pop r9
loc_8E91F:
cmp rsi, 2
jz short loc_8E986
mov r10, r9
loc_8E928:
test r10, r10
jz short loc_8E946
vmovaps ymm0, ymmword ptr [rcx+r10]
vaddps ymm0, ymm0, ymmword ptr [rcx+r10+40h]
vmovaps ymmword ptr [rcx+r10], ymm0
add r10, 20h ; ' '
jmp short loc_8E928
loc_8E946:
mov r10, rsi
shl r10, 7
vmovaps ymm0, [rsp+r10+168h+var_148]
vaddps ymm0, ymm0, [rsp+r10+168h+var_128]
vextractf128 xmm1, ymm0, 1
vaddps xmm1, xmm0, xmm1
vhaddps xmm1, xmm1, xmm1
vmovaps [rsp+r10+168h+var_148], ymm0
vhaddps xmm0, xmm1, xmm1
vcvtss2sd xmm0, xmm0, xmm0
vmovsd qword ptr [rsp+rsi*8+168h+var_168], xmm0
inc rsi
sub rcx, 0FFFFFFFFFFFFFF80h
jmp short loc_8E91F
loc_8E986:
movsxd rcx, edi
lea rsi, ggml_table_f32_f16
loc_8E990:
cmp rax, rcx
jge short loc_8E9CF
movzx edi, word ptr [r8+rax*2]
vmovss xmm0, dword ptr [rsi+rdi*4]
xor edi, edi
loc_8E9A1:
cmp rdi, 2
jz short loc_8E9CA
mov r9, [rsp+rdi*8+168h+var_158]
movzx r9d, word ptr [r9+rax*2]
vmulss xmm1, xmm0, dword ptr [rsi+r9*4]
vcvtss2sd xmm1, xmm1, xmm1
vaddsd xmm1, xmm1, qword ptr [rsp+rdi*8+168h+var_168]
vmovsd qword ptr [rsp+rdi*8+168h+var_168], xmm1
inc rdi
jmp short loc_8E9A1
loc_8E9CA:
inc rax
jmp short loc_8E990
loc_8E9CF:
xor eax, eax
loc_8E9D1:
cmp rax, 2
jz short loc_8E9E6
vcvtsd2ss xmm0, xmm2, qword ptr [rsp+rax*8+168h+var_168]
vmovss dword ptr [rdx+rax*4], xmm0
inc rax
jmp short loc_8E9D1
loc_8E9E6:
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
vzeroupper
retn
|
long long ggml_vec_dot_f16_unroll(
int a1,
int a2,
long long _RDX,
long long a4,
long long a5,
__m128 _XMM0,
double a7,
__m128 _XMM2)
{
long long v10; // rax
long long i; // rsi
__m256 *v15; // r11
long long j; // rbx
long long k; // r12
long long v37; // rcx
long long result; // rax
_QWORD v48[2]; // [rsp+10h] [rbp-158h]
__m256 v49; // [rsp+20h] [rbp-148h] BYREF
char v50; // [rsp+60h] [rbp-108h] BYREF
__asm
{
vxorps xmm0, xmm0, xmm0
vmovaps [rsp+168h+var_168], xmm0
}
v48[0] = a4;
v48[1] = a4 + a2;
v10 = (int)(a1 & 0xFFFFFFE0);
__asm { vxorps xmm0, xmm0, xmm0 }
_RCX = &v49;
__asm
{
vmovaps ymmword ptr [rcx+0E0h], ymm0
vmovaps ymmword ptr [rcx+0C0h], ymm0
vmovaps ymmword ptr [rcx+0A0h], ymm0
vmovaps ymmword ptr [rcx+80h], ymm0
vmovaps ymmword ptr [rcx+60h], ymm0
vmovaps ymmword ptr [rcx+40h], ymm0
vmovaps ymmword ptr [rcx+20h], ymm0
vmovaps ymmword ptr [rcx], ymm0
}
for ( i = 0LL; i < v10; i += 32LL )
{
_R9 = a5 + 2 * i;
v15 = &v49;
for ( j = 0LL; j != 4; ++j )
{
_R14 = 8 * j;
_R15 = 16 * j;
__asm { vcvtph2ps ymm0, xmmword ptr [r9+r15] }
_R15 = v15;
for ( k = 0LL; k != 2; ++k )
{
_R13 = 2 * i + v48[k];
__asm
{
vcvtph2ps ymm1, xmmword ptr [r13+r14*2+0]
vfmadd213ps ymm1, ymm0, ymmword ptr [r15]
vmovaps ymmword ptr [r15], ymm1
}
_R15 += 4;
}
++v15;
}
}
_RCX = &v50;
for ( _RSI = 0LL; _RSI != 2; ++_RSI )
{
for ( _R10 = -64LL; _R10; _R10 += 32LL )
{
__asm
{
vmovaps ymm0, ymmword ptr [rcx+r10]
vaddps ymm0, ymm0, ymmword ptr [rcx+r10+40h]
vmovaps ymmword ptr [rcx+r10], ymm0
}
}
_R10 = _RSI << 7;
__asm
{
vmovaps ymm0, [rsp+r10+168h+var_148]
vaddps ymm0, ymm0, [rsp+r10+168h+var_128]
vextractf128 xmm1, ymm0, 1
vaddps xmm1, xmm0, xmm1
vhaddps xmm1, xmm1, xmm1
vmovaps [rsp+r10+168h+var_148], ymm0
vhaddps xmm0, xmm1, xmm1
vcvtss2sd xmm0, xmm0, xmm0
vmovsd qword ptr [rsp+rsi*8+168h+var_168], xmm0
}
_RCX += 128;
}
v37 = a1;
_RSI = &ggml_table_f32_f16;
while ( v10 < v37 )
{
_RDI = *(unsigned __int16 *)(a5 + 2 * v10);
__asm { vmovss xmm0, dword ptr [rsi+rdi*4] }
for ( _RDI = 0LL; _RDI != 2; ++_RDI )
{
__asm
{
vmulss xmm1, xmm0, dword ptr [rsi+r9*4]
vcvtss2sd xmm1, xmm1, xmm1
vaddsd xmm1, xmm1, qword ptr [rsp+rdi*8+168h+var_168]
vmovsd qword ptr [rsp+rdi*8+168h+var_168], xmm1
}
}
++v10;
}
for ( result = 0LL; result != 2; ++result )
{
__asm
{
vcvtsd2ss xmm0, xmm2, qword ptr [rsp+rax*8+168h+var_168]
vmovss dword ptr [rdx+rax*4], xmm0
}
}
__asm { vzeroupper }
return result;
}
|
ggml_vec_dot_f16_unroll:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
AND RSP,-0x20
SUB RSP,0x140
VXORPS XMM0,XMM0,XMM0
VMOVAPS xmmword ptr [RSP],XMM0
MOVSXD RAX,ESI
MOV qword ptr [RSP + 0x10],RCX
ADD RAX,RCX
MOV qword ptr [RSP + 0x18],RAX
MOV EAX,EDI
AND EAX,0xffffffe0
CDQE
VXORPS XMM0,XMM0,XMM0
LEA RCX,[RSP + 0x20]
VMOVAPS ymmword ptr [RCX + 0xe0],YMM0
VMOVAPS ymmword ptr [RCX + 0xc0],YMM0
VMOVAPS ymmword ptr [RCX + 0xa0],YMM0
VMOVAPS ymmword ptr [RCX + 0x80],YMM0
VMOVAPS ymmword ptr [RCX + 0x60],YMM0
VMOVAPS ymmword ptr [RCX + 0x40],YMM0
VMOVAPS ymmword ptr [RCX + 0x20],YMM0
VMOVAPS ymmword ptr [RCX],YMM0
XOR ESI,ESI
LAB_0018e8aa:
CMP RSI,RAX
JGE 0x0018e914
LEA R9,[R8 + RSI*0x2]
LEA R10,[RSI + RSI*0x1]
MOV R11,RCX
XOR EBX,EBX
LAB_0018e8bc:
CMP RBX,0x4
JZ 0x0018e90e
LEA R14,[RBX*0x8]
MOV R15,RBX
SHL R15,0x4
VCVTPH2PS YMM0,xmmword ptr [R9 + R15*0x1]
MOV R15,R11
XOR R12D,R12D
LAB_0018e8dd:
CMP R12,0x2
JZ 0x0018e905
MOV R13,qword ptr [RSP + R12*0x8 + 0x10]
ADD R13,R10
VCVTPH2PS YMM1,xmmword ptr [R13 + R14*0x2]
VFMADD213PS YMM1,YMM0,ymmword ptr [R15]
VMOVAPS ymmword ptr [R15],YMM1
INC R12
SUB R15,-0x80
JMP 0x0018e8dd
LAB_0018e905:
INC RBX
ADD R11,0x20
JMP 0x0018e8bc
LAB_0018e90e:
ADD RSI,0x20
JMP 0x0018e8aa
LAB_0018e914:
LEA RCX,[RSP + 0x60]
XOR ESI,ESI
PUSH -0x40
POP R9
LAB_0018e91f:
CMP RSI,0x2
JZ 0x0018e986
MOV R10,R9
LAB_0018e928:
TEST R10,R10
JZ 0x0018e946
VMOVAPS YMM0,ymmword ptr [RCX + R10*0x1]
VADDPS YMM0,YMM0,ymmword ptr [RCX + R10*0x1 + 0x40]
VMOVAPS ymmword ptr [RCX + R10*0x1],YMM0
ADD R10,0x20
JMP 0x0018e928
LAB_0018e946:
MOV R10,RSI
SHL R10,0x7
VMOVAPS YMM0,ymmword ptr [RSP + R10*0x1 + 0x20]
VADDPS YMM0,YMM0,ymmword ptr [RSP + R10*0x1 + 0x40]
VEXTRACTF128 XMM1,YMM0,0x1
VADDPS XMM1,XMM0,XMM1
VHADDPS XMM1,XMM1,XMM1
VMOVAPS ymmword ptr [RSP + R10*0x1 + 0x20],YMM0
VHADDPS XMM0,XMM1,XMM1
VCVTSS2SD XMM0,XMM0,XMM0
VMOVSD qword ptr [RSP + RSI*0x8],XMM0
INC RSI
SUB RCX,-0x80
JMP 0x0018e91f
LAB_0018e986:
MOVSXD RCX,EDI
LEA RSI,[0x25d290]
LAB_0018e990:
CMP RAX,RCX
JGE 0x0018e9cf
MOVZX EDI,word ptr [R8 + RAX*0x2]
VMOVSS XMM0,dword ptr [RSI + RDI*0x4]
XOR EDI,EDI
LAB_0018e9a1:
CMP RDI,0x2
JZ 0x0018e9ca
MOV R9,qword ptr [RSP + RDI*0x8 + 0x10]
MOVZX R9D,word ptr [R9 + RAX*0x2]
VMULSS XMM1,XMM0,dword ptr [RSI + R9*0x4]
VCVTSS2SD XMM1,XMM1,XMM1
VADDSD XMM1,XMM1,qword ptr [RSP + RDI*0x8]
VMOVSD qword ptr [RSP + RDI*0x8],XMM1
INC RDI
JMP 0x0018e9a1
LAB_0018e9ca:
INC RAX
JMP 0x0018e990
LAB_0018e9cf:
XOR EAX,EAX
LAB_0018e9d1:
CMP RAX,0x2
JZ 0x0018e9e6
VCVTSD2SS XMM0,XMM2,qword ptr [RSP + RAX*0x8]
VMOVSS dword ptr [RDX + RAX*0x4],XMM0
INC RAX
JMP 0x0018e9d1
LAB_0018e9e6:
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
VZEROUPPER
RET
|
void ggml_vec_dot_f16_unroll(uint param_1,int param_2,long param_3,long param_4,long param_5)
{
float *pfVar1;
float *pfVar2;
float *pfVar3;
float fVar4;
int1 auVar5 [32];
float fVar6;
float fVar7;
float fVar8;
float fVar9;
float fVar10;
float fVar11;
float fVar12;
float fVar13;
float fVar14;
float fVar15;
float fVar16;
float fVar17;
float fVar18;
long lVar19;
int1 *puVar20;
long lVar21;
long lVar22;
int1 (*pauVar23) [32];
long lVar24;
int1 (*pauVar25) [32];
int1 auVar26 [32];
int1 auVar27 [16];
double local_180 [2];
long local_170 [2];
int1 local_160 [4];
float afStack_15c [7];
int1 local_140 [4];
float afStack_13c [7];
int1 local_120 [32];
int1 local_100 [32];
int1 local_e0 [32];
int1 local_c0 [32];
int1 local_a0 [32];
int1 local_80 [32];
local_180[0] = 0.0;
local_180[1] = 0.0;
local_170[0] = param_4;
local_170[1] = param_2 + param_4;
lVar19 = (long)(int)(param_1 & 0xffffffe0);
local_80 = ZEXT432(0) << 0x40;
local_a0 = ZEXT432(0) << 0x40;
local_c0 = ZEXT432(0) << 0x40;
local_e0 = local_c0;
local_100 = local_c0;
local_120 = local_c0;
_local_140 = ZEXT432(0) << 0x40;
_local_160 = ZEXT432(0) << 0x40;
for (lVar22 = 0; lVar22 < lVar19; lVar22 = lVar22 + 0x20) {
pauVar23 = (int1 (*) [32])local_160;
for (lVar21 = 0; lVar21 != 4; lVar21 = lVar21 + 1) {
auVar26 = vcvtph2ps_f16c(*(int1 (*) [16])(param_5 + lVar22 * 2 + lVar21 * 0x10));
pauVar25 = pauVar23;
for (lVar24 = 0; lVar24 != 2; lVar24 = lVar24 + 1) {
auVar5 = vcvtph2ps_f16c(*(int1 (*) [16])
(local_170[lVar24] + lVar22 * 2 + lVar21 * 0x10));
auVar27 = vfmadd213ps_fma(auVar5,auVar26,*pauVar25);
*pauVar25 = ZEXT1632(auVar27);
pauVar25 = pauVar25 + 4;
}
pauVar23 = pauVar23 + 1;
}
}
puVar20 = local_120;
for (lVar22 = 0; lVar21 = -0x40, lVar22 != 2; lVar22 = lVar22 + 1) {
for (; lVar21 != 0; lVar21 = lVar21 + 0x20) {
pfVar1 = (float *)(puVar20 + lVar21);
fVar4 = pfVar1[1];
fVar6 = pfVar1[2];
fVar7 = pfVar1[3];
fVar8 = pfVar1[4];
fVar9 = pfVar1[5];
fVar10 = pfVar1[6];
fVar11 = pfVar1[7];
pfVar3 = (float *)(puVar20 + lVar21 + 0x40);
fVar12 = pfVar3[1];
fVar13 = pfVar3[2];
fVar14 = pfVar3[3];
fVar15 = pfVar3[4];
fVar16 = pfVar3[5];
fVar17 = pfVar3[6];
fVar18 = pfVar3[7];
pfVar2 = (float *)(puVar20 + lVar21);
*pfVar2 = *pfVar1 + *pfVar3;
pfVar2[1] = fVar4 + fVar12;
pfVar2[2] = fVar6 + fVar13;
pfVar2[3] = fVar7 + fVar14;
pfVar2[4] = fVar8 + fVar15;
pfVar2[5] = fVar9 + fVar16;
pfVar2[6] = fVar10 + fVar17;
pfVar2[7] = fVar11 + fVar18;
}
lVar21 = lVar22 * 0x80;
auVar26._0_4_ = *(float *)(local_160 + lVar21) + *(float *)(local_140 + lVar21);
auVar26._4_4_ = *(float *)(local_160 + lVar21 + 4) + *(float *)(local_140 + lVar21 + 4);
auVar26._8_4_ = *(float *)(local_160 + lVar21 + 8) + *(float *)(local_140 + lVar21 + 8);
auVar26._12_4_ = *(float *)(local_160 + lVar21 + 0xc) + *(float *)(local_140 + lVar21 + 0xc);
auVar26._16_4_ = *(float *)(local_160 + lVar21 + 0x10) + *(float *)(local_140 + lVar21 + 0x10);
auVar26._20_4_ = *(float *)(local_140 + lVar21 + -0xc) + *(float *)(local_120 + lVar21 + -0xc);
auVar26._24_4_ = *(float *)(local_140 + lVar21 + -8) + *(float *)(local_120 + lVar21 + -8);
auVar26._28_4_ = *(float *)(local_140 + lVar21 + -4) + *(float *)(local_120 + lVar21 + -4);
auVar27._0_4_ = auVar26._0_4_ + auVar26._16_4_;
auVar27._4_4_ = auVar26._4_4_ + auVar26._20_4_;
auVar27._8_4_ = auVar26._8_4_ + auVar26._24_4_;
auVar27._12_4_ = auVar26._12_4_ + auVar26._28_4_;
auVar27 = vhaddps_avx(auVar27,auVar27);
*(int1 (*) [32])(local_160 + lVar21) = auVar26;
auVar27 = vhaddps_avx(auVar27,auVar27);
local_180[lVar22] = (double)auVar27._0_4_;
puVar20 = puVar20 + 0x80;
}
for (; lVar19 < (int)param_1; lVar19 = lVar19 + 1) {
fVar4 = (float)(&ggml_table_f32_f16)[*(ushort *)(param_5 + lVar19 * 2)];
for (lVar22 = 0; lVar22 != 2; lVar22 = lVar22 + 1) {
local_180[lVar22] =
(double)(fVar4 * (float)(&ggml_table_f32_f16)
[*(ushort *)(local_170[lVar22] + lVar19 * 2)]) +
local_180[lVar22];
}
}
for (lVar19 = 0; lVar19 != 2; lVar19 = lVar19 + 1) {
*(float *)(param_3 + lVar19 * 4) = (float)local_180[lVar19];
}
return;
}
|
|
19,793
|
ggml_easy::string_replace_all(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
ngxson[P]ggml-easy/ggml-easy.h
|
void string_replace_all(std::string & s, const std::string & search, const std::string & replace) {
if (search.empty()) {
return;
}
std::string builder;
builder.reserve(s.length());
size_t pos = 0;
size_t last_pos = 0;
while ((pos = s.find(search, last_pos)) != std::string::npos) {
builder.append(s, last_pos, pos - last_pos);
builder.append(replace);
last_pos = pos + search.length();
}
builder.append(s, last_pos, std::string::npos);
s = std::move(builder);
}
|
O0
|
c
|
ggml_easy::string_replace_all(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x8590
testb $0x1, %al
jne 0x9923
jmp 0x9928
jmp 0x9a24
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x84a0
movq 0x60(%rsp), %rdi
callq 0x84f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x8520
jmp 0x9950
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x86b0
movq %rax, 0x18(%rsp)
cmpq $-0x1, %rax
je 0x99ee
movq 0x60(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
subq %rdx, %rcx
leaq 0x30(%rsp), %rdi
callq 0x8490
jmp 0x999f
movq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x8690
jmp 0x99b0
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
callq 0x84f0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x9962
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x8260
jmp 0x9a29
movq 0x60(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq $-0x1, %rcx
callq 0x8490
jmp 0x9a0b
movq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x8430
leaq 0x30(%rsp), %rdi
callq 0x8260
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x8620
nopw %cs:(%rax,%rax)
|
_ZN9ggml_easy18string_replace_allERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_S8_:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
mov [rsp+68h+var_18], rdx
mov rdi, [rsp+68h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_9923
jmp short loc_9928
loc_9923:
jmp loc_9A24
loc_9928:
lea rdi, [rsp+68h+var_38]
mov [rsp+68h+var_60], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rdi, [rsp+68h+var_8]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
mov rdi, [rsp+68h+var_60]
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
jmp short $+2
loc_9950:
mov [rsp+68h+var_50], 0
mov [rsp+68h+var_58], 0
loc_9962:
mov rdi, [rsp+68h+var_8]
mov rsi, [rsp+68h+var_10]
mov rdx, [rsp+68h+var_58]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findERKS4_m; std::string::find(std::string const&,ulong)
mov [rsp+68h+var_50], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_99EE
mov rsi, [rsp+68h+var_8]
mov rdx, [rsp+68h+var_58]
mov rcx, [rsp+68h+var_50]
sub rcx, rdx
lea rdi, [rsp+68h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_mm; std::string::append(std::string const&,ulong,ulong)
jmp short $+2
loc_999F:
mov rsi, [rsp+68h+var_18]
lea rdi, [rsp+68h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_; std::string::append(std::string const&)
jmp short $+2
loc_99B0:
mov rax, [rsp+68h+var_50]
mov [rsp+68h+var_68], rax
mov rdi, [rsp+68h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
mov rcx, rax
mov rax, [rsp+68h+var_68]
add rax, rcx
mov [rsp+68h+var_58], rax
jmp short loc_9962
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_28]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_9A29
loc_99EE:
mov rsi, [rsp+68h+var_8]
mov rdx, [rsp+68h+var_58]
lea rdi, [rsp+68h+var_38]
mov rcx, 0FFFFFFFFFFFFFFFFh
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_mm; std::string::append(std::string const&,ulong,ulong)
jmp short $+2
loc_9A0B:
mov rdi, [rsp+68h+var_8]
lea rsi, [rsp+68h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
lea rdi, [rsp+68h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_9A24:
add rsp, 68h
retn
loc_9A29:
mov rdi, [rsp+arg_20]
call __Unwind_Resume
|
long long ggml_easy::string_replace_all(long long a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rax
long long i; // rax
long long v6; // [rsp+10h] [rbp-58h]
long long v7; // [rsp+18h] [rbp-50h]
_BYTE v8[32]; // [rsp+30h] [rbp-38h] BYREF
long long v9; // [rsp+50h] [rbp-18h]
long long v10; // [rsp+58h] [rbp-10h]
long long v11; // [rsp+60h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
result = std::string::empty(a2);
if ( (result & 1) == 0 )
{
std::string::basic_string(v8);
v4 = std::string::length(v11);
std::string::reserve(v8, v4);
v6 = 0LL;
for ( i = std::string::find(v11, v10, 0LL); ; i = std::string::find(v11, v10, v6) )
{
v7 = i;
if ( i == -1 )
break;
std::string::append(v8, v11, v6, i - v6);
std::string::append(v8, v9);
v6 = std::string::length(v10) + v7;
}
std::string::append(v8, v11, v6, -1LL);
std::string::operator=(v11, v8);
return std::string::~string(v8);
}
return result;
}
|
string_replace_all:
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDI
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x50],RDX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x00108590
TEST AL,0x1
JNZ 0x00109923
JMP 0x00109928
LAB_00109923:
JMP 0x00109a24
LAB_00109928:
LEA RDI,[RSP + 0x30]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x001084a0
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x001084f0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
LAB_00109949:
CALL 0x00108520
JMP 0x00109950
LAB_00109950:
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x10],0x0
LAB_00109962:
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x001086b0
MOV qword ptr [RSP + 0x18],RAX
CMP RAX,-0x1
JZ 0x001099ee
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
SUB RCX,RDX
LEA RDI,[RSP + 0x30]
CALL 0x00108490
JMP 0x0010999f
LAB_0010999f:
MOV RSI,qword ptr [RSP + 0x50]
LEA RDI,[RSP + 0x30]
CALL 0x00108690
JMP 0x001099b0
LAB_001099b0:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x001084f0
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
ADD RAX,RCX
MOV qword ptr [RSP + 0x10],RAX
JMP 0x00109962
LAB_001099ee:
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x30]
MOV RCX,-0x1
CALL 0x00108490
LAB_00109a09:
JMP 0x00109a0b
LAB_00109a0b:
MOV RDI,qword ptr [RSP + 0x60]
LEA RSI,[RSP + 0x30]
CALL 0x00108430
LEA RDI,[RSP + 0x30]
CALL 0x00108260
LAB_00109a24:
ADD RSP,0x68
RET
|
/* ggml_easy::string_replace_all(std::__cxx11::string&, std::__cxx11::string const&,
std::__cxx11::string const&) */
void ggml_easy::string_replace_all(string *param_1,string *param_2,string *param_3)
{
ulong uVar1;
long lVar2;
long lVar3;
ulong local_58;
string local_38 [32];
string *local_18;
string *local_10;
string *local_8;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
uVar1 = std::__cxx11::string::empty();
if ((uVar1 & 1) == 0) {
std::__cxx11::string::string(local_38);
std::__cxx11::string::length();
/* try { // try from 00109949 to 00109a08 has its CatchHandler @ 001099d4 */
std::__cxx11::string::reserve((ulong)local_38);
local_58 = 0;
while (lVar2 = std::__cxx11::string::find(local_8,(ulong)local_10), lVar2 != -1) {
std::__cxx11::string::append(local_38,(ulong)local_8,local_58);
std::__cxx11::string::append(local_38);
lVar3 = std::__cxx11::string::length();
local_58 = lVar2 + lVar3;
}
std::__cxx11::string::append(local_38,(ulong)local_8,local_58);
std::__cxx11::string::operator=(local_8,local_38);
std::__cxx11::string::~string(local_38);
}
return;
}
|
|
19,794
|
my_strntoul_8bit
|
eloqsql/strings/ctype-simple.c
|
ulong my_strntoul_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register uint32 cutoff;
register uint cutlim;
register uint32 i;
register const char *s;
const char *save, *e;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for( ; s<e && my_isspace(cs, *s); s++);
if (s==e)
{
goto noconv;
}
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = ((uint32)~0L) / (uint32) base;
cutlim = (uint) (((uint32)~0L) % (uint32) base);
overflow = 0;
i = 0;
for ( ; s != e; ++s)
{
register uchar c= *s;
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (uint32) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (overflow)
{
err[0]= ERANGE;
return (~(uint32) 0);
}
return (negative ? -((long) i) : (long) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
}
|
O3
|
c
|
my_strntoul_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x0, (%r9)
leaq (%rsi,%rdx), %r11
movq %rsi, %r10
testq %rdx, %rdx
jle 0xb5460
movq 0x40(%rdi), %rax
movq %rsi, %r10
movzbl (%r10), %edx
testb $0x8, 0x1(%rax,%rdx)
je 0xb5460
incq %r10
cmpq %r11, %r10
jb 0xb544d
cmpq %r11, %r10
je 0xb553e
movb (%r10), %dil
leal -0x2b(%rdi), %eax
andb $-0x3, %al
cmpb $0x1, %al
adcq $0x0, %r10
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl %ecx
xorl %r15d, %r15d
cmpq %r11, %r10
je 0xb551b
movq %rdi, -0x30(%rbp)
movq %r10, %rbx
xorl %r13d, %r13d
movl %r13d, %r14d
movl %r15d, %r12d
movb (%rbx), %r15b
leal -0x30(%r15), %edi
cmpb $0xa, %dil
jb 0xb54ca
leal -0x41(%r15), %edi
cmpb $0x19, %dil
ja 0xb54b9
addb $-0x37, %r15b
jmp 0xb54c7
leal -0x61(%r15), %edi
cmpb $0x19, %dil
ja 0xb5509
addb $-0x57, %r15b
movl %r15d, %edi
movzbl %dil, %edi
cmpl %ecx, %edi
jge 0xb5509
movl $0x1, %r15d
cmpl %eax, %r14d
jbe 0xb54e2
movl %r14d, %r13d
jmp 0xb54f8
jne 0xb54eb
movl %eax, %r13d
cmpl %edi, %edx
jb 0xb54f8
imull %ecx, %r14d
addl %edi, %r14d
movl %r14d, %r13d
movl %r12d, %r15d
incq %rbx
cmpq %r11, %rbx
jne 0xb5496
movl %r13d, %r14d
movq %r11, %rbx
movl %r15d, %r12d
testl %r12d, %r12d
sete %al
movl %r14d, %r15d
movq %rbx, %r11
movq -0x30(%rbp), %rdi
jmp 0xb551d
movb $0x1, %al
cmpq %r10, %r11
je 0xb553e
testq %r8, %r8
je 0xb552a
movq %r11, (%r8)
testb %al, %al
je 0xb5551
movq %r15, %rax
negq %rax
cmpb $0x2d, %dil
cmovneq %r15, %rax
jmp 0xb555d
movl $0x21, (%r9)
testq %r8, %r8
je 0xb554d
movq %rsi, (%r8)
xorl %eax, %eax
jmp 0xb555d
movl $0x22, (%r9)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strntoul_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov dword ptr [r9], 0
lea r11, [rsi+rdx]
mov r10, rsi
test rdx, rdx
jle short loc_B5460
mov rax, [rdi+40h]
mov r10, rsi
loc_B544D:
movzx edx, byte ptr [r10]
test byte ptr [rax+rdx+1], 8
jz short loc_B5460
inc r10
cmp r10, r11
jb short loc_B544D
loc_B5460:
cmp r10, r11
jz loc_B553E
mov dil, [r10]
lea eax, [rdi-2Bh]
and al, 0FDh
cmp al, 1
adc r10, 0
mov eax, 0FFFFFFFFh
xor edx, edx
div ecx
xor r15d, r15d
cmp r10, r11
jz loc_B551B
mov [rbp+var_30], rdi
mov rbx, r10
xor r13d, r13d
loc_B5496:
mov r14d, r13d
mov r12d, r15d
mov r15b, [rbx]
lea edi, [r15-30h]
cmp dil, 0Ah
jb short loc_B54CA
lea edi, [r15-41h]
cmp dil, 19h
ja short loc_B54B9
add r15b, 0C9h
jmp short loc_B54C7
loc_B54B9:
lea edi, [r15-61h]
cmp dil, 19h
ja short loc_B5509
add r15b, 0A9h
loc_B54C7:
mov edi, r15d
loc_B54CA:
movzx edi, dil
cmp edi, ecx
jge short loc_B5509
mov r15d, 1
cmp r14d, eax
jbe short loc_B54E2
mov r13d, r14d
jmp short loc_B54F8
loc_B54E2:
jnz short loc_B54EB
mov r13d, eax
cmp edx, edi
jb short loc_B54F8
loc_B54EB:
imul r14d, ecx
add r14d, edi
mov r13d, r14d
mov r15d, r12d
loc_B54F8:
inc rbx
cmp rbx, r11
jnz short loc_B5496
mov r14d, r13d
mov rbx, r11
mov r12d, r15d
loc_B5509:
test r12d, r12d
setz al
mov r15d, r14d
mov r11, rbx
mov rdi, [rbp+var_30]
jmp short loc_B551D
loc_B551B:
mov al, 1
loc_B551D:
cmp r11, r10
jz short loc_B553E
test r8, r8
jz short loc_B552A
mov [r8], r11
loc_B552A:
test al, al
jz short loc_B5551
mov rax, r15
neg rax
cmp dil, 2Dh ; '-'
cmovnz rax, r15
jmp short loc_B555D
loc_B553E:
mov dword ptr [r9], 21h ; '!'
test r8, r8
jz short loc_B554D
mov [r8], rsi
loc_B554D:
xor eax, eax
jmp short loc_B555D
loc_B5551:
mov dword ptr [r9], 22h ; '"'
mov eax, 0FFFFFFFFh
loc_B555D:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_strntoul_8bit(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned int a4,
unsigned __int8 **a5,
_DWORD *a6)
{
unsigned __int8 *v6; // r11
unsigned __int8 *v7; // r10
unsigned __int8 v8; // di
unsigned __int8 *v9; // r10
unsigned int v10; // eax
long long v11; // r15
unsigned __int8 *v12; // rbx
unsigned int v13; // r13d
unsigned int v14; // r14d
int v15; // r12d
unsigned __int8 v16; // r15
unsigned __int8 v17; // di
unsigned __int8 v18; // r15
bool v19; // al
long long result; // rax
unsigned __int8 v21; // [rsp+0h] [rbp-30h]
*a6 = 0;
v6 = &a2[a3];
v7 = a2;
if ( a3 > 0 )
{
v7 = a2;
do
{
if ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v7 + 1LL) & 8) == 0 )
break;
++v7;
}
while ( v7 < v6 );
}
if ( v7 == v6 )
goto LABEL_30;
v8 = *v7;
v9 = &v7[((*v7 - 43) & 0xFD) == 0];
v10 = 0xFFFFFFFF / a4;
v11 = 0LL;
if ( v9 == v6 )
{
v19 = 1;
}
else
{
v21 = v8;
v12 = v9;
v13 = 0;
while ( 1 )
{
v14 = v13;
v15 = v11;
v16 = *v12;
v17 = *v12 - 48;
if ( v17 >= 0xAu )
{
if ( (unsigned __int8)(v16 - 65) > 0x19u )
{
if ( (unsigned __int8)(v16 - 97) > 0x19u )
break;
v18 = v16 - 87;
}
else
{
v18 = v16 - 55;
}
v17 = v18;
}
if ( v17 >= (int)a4 )
break;
LODWORD(v11) = 1;
if ( v13 <= v10 )
{
if ( v13 != v10 || (v13 = 0xFFFFFFFF / a4, 0xFFFFFFFF % a4 >= v17) )
{
v13 = v17 + a4 * v14;
LODWORD(v11) = v15;
}
}
if ( ++v12 == v6 )
{
v14 = v13;
v12 = &a2[a3];
v15 = v11;
break;
}
}
v19 = v15 == 0;
v11 = v14;
v6 = v12;
v8 = v21;
}
if ( v6 == v9 )
{
LABEL_30:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v6;
if ( v19 )
{
result = -v11;
if ( v8 != 45 )
return v11;
}
else
{
*a6 = 34;
return 0xFFFFFFFFLL;
}
}
return result;
}
|
my_strntoul_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV dword ptr [R9],0x0
LEA R11,[RSI + RDX*0x1]
MOV R10,RSI
TEST RDX,RDX
JLE 0x001b5460
MOV RAX,qword ptr [RDI + 0x40]
MOV R10,RSI
LAB_001b544d:
MOVZX EDX,byte ptr [R10]
TEST byte ptr [RAX + RDX*0x1 + 0x1],0x8
JZ 0x001b5460
INC R10
CMP R10,R11
JC 0x001b544d
LAB_001b5460:
CMP R10,R11
JZ 0x001b553e
MOV DIL,byte ptr [R10]
LEA EAX,[RDI + -0x2b]
AND AL,0xfd
CMP AL,0x1
ADC R10,0x0
MOV EAX,0xffffffff
XOR EDX,EDX
DIV ECX
XOR R15D,R15D
CMP R10,R11
JZ 0x001b551b
MOV qword ptr [RBP + -0x30],RDI
MOV RBX,R10
XOR R13D,R13D
LAB_001b5496:
MOV R14D,R13D
MOV R12D,R15D
MOV R15B,byte ptr [RBX]
LEA EDI,[R15 + -0x30]
CMP DIL,0xa
JC 0x001b54ca
LEA EDI,[R15 + -0x41]
CMP DIL,0x19
JA 0x001b54b9
ADD R15B,0xc9
JMP 0x001b54c7
LAB_001b54b9:
LEA EDI,[R15 + -0x61]
CMP DIL,0x19
JA 0x001b5509
ADD R15B,0xa9
LAB_001b54c7:
MOV EDI,R15D
LAB_001b54ca:
MOVZX EDI,DIL
CMP EDI,ECX
JGE 0x001b5509
MOV R15D,0x1
CMP R14D,EAX
JBE 0x001b54e2
MOV R13D,R14D
JMP 0x001b54f8
LAB_001b54e2:
JNZ 0x001b54eb
MOV R13D,EAX
CMP EDX,EDI
JC 0x001b54f8
LAB_001b54eb:
IMUL R14D,ECX
ADD R14D,EDI
MOV R13D,R14D
MOV R15D,R12D
LAB_001b54f8:
INC RBX
CMP RBX,R11
JNZ 0x001b5496
MOV R14D,R13D
MOV RBX,R11
MOV R12D,R15D
LAB_001b5509:
TEST R12D,R12D
SETZ AL
MOV R15D,R14D
MOV R11,RBX
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x001b551d
LAB_001b551b:
MOV AL,0x1
LAB_001b551d:
CMP R11,R10
JZ 0x001b553e
TEST R8,R8
JZ 0x001b552a
MOV qword ptr [R8],R11
LAB_001b552a:
TEST AL,AL
JZ 0x001b5551
MOV RAX,R15
NEG RAX
CMP DIL,0x2d
CMOVNZ RAX,R15
JMP 0x001b555d
LAB_001b553e:
MOV dword ptr [R9],0x21
TEST R8,R8
JZ 0x001b554d
MOV qword ptr [R8],RSI
LAB_001b554d:
XOR EAX,EAX
JMP 0x001b555d
LAB_001b5551:
MOV dword ptr [R9],0x22
MOV EAX,0xffffffff
LAB_001b555d:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strntoul_8bit(long param_1,byte *param_2,long param_3,uint param_4,ulong *param_5,
int4 *param_6)
{
byte bVar1;
byte bVar2;
uint uVar3;
uint uVar4;
byte *pbVar5;
byte *pbVar6;
byte *pbVar7;
int iVar8;
uint uVar9;
byte bVar10;
ulong uVar11;
ulong uVar12;
bool bVar13;
*param_6 = 0;
pbVar7 = param_2 + param_3;
pbVar6 = param_2;
if (0 < param_3) {
do {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar6) & 8) == 0) break;
pbVar6 = pbVar6 + 1;
} while (pbVar6 < pbVar7);
}
if (pbVar6 != pbVar7) {
bVar1 = *pbVar6;
pbVar6 = pbVar6 + ((bVar1 - 0x2b & 0xfd) == 0);
uVar11 = 0;
if (pbVar6 == pbVar7) {
bVar13 = true;
}
else {
uVar9 = 0;
pbVar5 = pbVar6;
do {
iVar8 = (int)uVar11;
bVar2 = *pbVar5;
bVar10 = bVar2 - 0x30;
if (9 < bVar10) {
if ((byte)(bVar2 + 0xbf) < 0x1a) {
bVar10 = bVar2 - 0x37;
}
else {
if (0x19 < (byte)(bVar2 + 0x9f)) goto LAB_001b5509;
bVar10 = bVar2 + 0xa9;
}
}
if ((int)param_4 <= (int)(uint)bVar10) goto LAB_001b5509;
uVar12 = 1;
uVar4 = (uint)(0xffffffff / (ulong)param_4);
uVar3 = uVar9;
if ((uVar9 <= uVar4) &&
((uVar9 != uVar4 || (uVar3 = uVar4, (uint)bVar10 <= (uint)(0xffffffff % (ulong)param_4)))
)) {
uVar12 = uVar11;
uVar3 = uVar9 * param_4 + (uint)bVar10;
}
uVar9 = uVar3;
pbVar5 = pbVar5 + 1;
uVar11 = uVar12;
} while (pbVar5 != pbVar7);
iVar8 = (int)uVar12;
pbVar5 = pbVar7;
LAB_001b5509:
bVar13 = iVar8 == 0;
uVar11 = (ulong)uVar9;
pbVar7 = pbVar5;
}
if (pbVar7 != pbVar6) {
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)pbVar7;
}
if (bVar13) {
if (bVar1 == 0x2d) {
return -uVar11;
}
return uVar11;
}
*param_6 = 0x22;
return 0xffffffff;
}
}
*param_6 = 0x21;
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)param_2;
}
return 0;
}
|
|
19,795
|
ggml_graph_get_tensor
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
struct ggml_tensor * ggml_graph_get_tensor(struct ggml_cgraph * cgraph, const char * name) {
for (int i = 0; i < cgraph->n_leafs; i++) {
struct ggml_tensor * leaf = cgraph->leafs[i];
if (strcmp(leaf->name, name) == 0) {
return leaf;
}
}
for (int i = 0; i < cgraph->n_nodes; i++) {
struct ggml_tensor * node = cgraph->nodes[i];
if (strcmp(node->name, name) == 0) {
return node;
}
}
return NULL;
}
|
O0
|
c
|
ggml_graph_get_tensor:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x12fa61
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x120, %rdi # imm = 0x120
movq 0x20(%rsp), %rsi
callq 0xbaa0
cmpl $0x0, %eax
jne 0x12fa52
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x12faca
jmp 0x12fa54
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x12fa06
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x12fac1
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
addq $0x120, %rdi # imm = 0x120
movq 0x20(%rsp), %rsi
callq 0xbaa0
cmpl $0x0, %eax
jne 0x12fab2
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x12faca
jmp 0x12fab4
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x12fa69
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
ggml_graph_get_tensor:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_1C], 0
loc_12FA06:
mov eax, [rsp+38h+var_1C]
mov rcx, [rsp+38h+var_10]
cmp eax, [rcx+8]
jge short loc_12FA61
mov rax, [rsp+38h+var_10]
mov rax, [rax+20h]
movsxd rcx, [rsp+38h+var_1C]
mov rax, [rax+rcx*8]
mov [rsp+38h+var_28], rax
mov rdi, [rsp+38h+var_28]
add rdi, 120h
mov rsi, [rsp+38h+var_18]
call _strcmp
cmp eax, 0
jnz short loc_12FA52
mov rax, [rsp+38h+var_28]
mov [rsp+38h+var_8], rax
jmp short loc_12FACA
loc_12FA52:
jmp short $+2
loc_12FA54:
mov eax, [rsp+38h+var_1C]
add eax, 1
mov [rsp+38h+var_1C], eax
jmp short loc_12FA06
loc_12FA61:
mov [rsp+38h+var_2C], 0
loc_12FA69:
mov eax, [rsp+38h+var_2C]
mov rcx, [rsp+38h+var_10]
cmp eax, [rcx+4]
jge short loc_12FAC1
mov rax, [rsp+38h+var_10]
mov rax, [rax+10h]
movsxd rcx, [rsp+38h+var_2C]
mov rax, [rax+rcx*8]
mov [rsp+38h+var_38], rax
mov rdi, [rsp+38h+var_38]
add rdi, 120h
mov rsi, [rsp+38h+var_18]
call _strcmp
cmp eax, 0
jnz short loc_12FAB2
mov rax, [rsp+38h+var_38]
mov [rsp+38h+var_8], rax
jmp short loc_12FACA
loc_12FAB2:
jmp short $+2
loc_12FAB4:
mov eax, [rsp+38h+var_2C]
add eax, 1
mov [rsp+38h+var_2C], eax
jmp short loc_12FA69
loc_12FAC1:
mov [rsp+38h+var_8], 0
loc_12FACA:
mov rax, [rsp+38h+var_8]
add rsp, 38h
retn
|
long long ggml_graph_get_tensor(long long a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-38h]
int j; // [rsp+Ch] [rbp-2Ch]
long long v5; // [rsp+10h] [rbp-28h]
int i; // [rsp+1Ch] [rbp-1Ch]
for ( i = 0; i < *(_DWORD *)(a1 + 8); ++i )
{
v5 = *(_QWORD *)(*(_QWORD *)(a1 + 32) + 8LL * i);
if ( !(unsigned int)strcmp(v5 + 288, a2) )
return v5;
}
for ( j = 0; j < *(_DWORD *)(a1 + 4); ++j )
{
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 16) + 8LL * j);
if ( !(unsigned int)strcmp(v3 + 288, a2) )
return v3;
}
return 0LL;
}
| |||
19,796
|
ggml_graph_get_tensor
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
struct ggml_tensor * ggml_graph_get_tensor(struct ggml_cgraph * cgraph, const char * name) {
for (int i = 0; i < cgraph->n_leafs; i++) {
struct ggml_tensor * leaf = cgraph->leafs[i];
if (strcmp(leaf->name, name) == 0) {
return leaf;
}
}
for (int i = 0; i < cgraph->n_nodes; i++) {
struct ggml_tensor * node = cgraph->nodes[i];
if (strcmp(node->name, name) == 0) {
return node;
}
}
return NULL;
}
|
O1
|
c
|
ggml_graph_get_tensor:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movslq 0x8(%rdi), %r12
testq %r12, %r12
setg %bpl
jle 0x9846d
movq 0x20(%r15), %r13
movq (%r13), %rbx
leaq 0x120(%rbx), %rdi
movq %r14, %rsi
callq 0xa860
testl %eax, %eax
je 0x9846d
movq %r15, (%rsp)
movl $0x1, %ecx
movq %rcx, %rbp
cmpq %rcx, %r12
je 0x98460
movq (%r13,%rbp,8), %r15
leaq 0x120(%r15), %rdi
movq %r14, %rsi
callq 0xa860
leaq 0x1(%rbp), %rcx
testl %eax, %eax
cmoveq %r15, %rbx
jne 0x98438
cmpq %r12, %rbp
setb %bpl
movq (%rsp), %r15
jmp 0x9846d
testb %bpl, %bpl
jne 0x984a7
movslq 0x4(%r15), %r12
testq %r12, %r12
jle 0x984a5
movq 0x10(%r15), %r15
xorl %r13d, %r13d
movq (%r15,%r13,8), %rbp
leaq 0x120(%rbp), %rdi
movq %r14, %rsi
callq 0xa860
testl %eax, %eax
cmoveq %rbp, %rbx
je 0x984a7
incq %r13
cmpq %r13, %r12
jne 0x98482
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
ggml_graph_get_tensor:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov r15, rdi
movsxd r12, dword ptr [rdi+8]
test r12, r12
setnle bpl
jle short loc_9846D
mov r13, [r15+20h]
mov rbx, [r13+0]
lea rdi, [rbx+120h]
mov rsi, r14
call _strcmp
test eax, eax
jz short loc_9846D
mov [rsp+38h+var_38], r15
mov ecx, 1
loc_98438:
mov rbp, rcx
cmp r12, rcx
jz short loc_98460
mov r15, [r13+rbp*8+0]
lea rdi, [r15+120h]
mov rsi, r14
call _strcmp
lea rcx, [rbp+1]
test eax, eax
cmovz rbx, r15
jnz short loc_98438
loc_98460:
cmp rbp, r12
setb bpl
mov r15, [rsp+38h+var_38]
jmp short $+2
loc_9846D:
test bpl, bpl
jnz short loc_984A7
movsxd r12, dword ptr [r15+4]
test r12, r12
jle short loc_984A5
mov r15, [r15+10h]
xor r13d, r13d
loc_98482:
mov rbp, [r15+r13*8]
lea rdi, [rbp+120h]
mov rsi, r14
call _strcmp
test eax, eax
cmovz rbx, rbp
jz short loc_984A7
inc r13
cmp r12, r13
jnz short loc_98482
loc_984A5:
xor ebx, ebx
loc_984A7:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ggml_graph_get_tensor(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // r15
long long v4; // r12
bool v5; // bp
long long *v6; // r13
long long v7; // rcx
unsigned long long v8; // rbp
long long v9; // r15
int v10; // eax
long long v11; // r12
long long v12; // r15
long long v13; // r13
long long v14; // rbp
v3 = a1;
v4 = *(int *)(a1 + 8);
v5 = v4 > 0;
if ( v4 > 0 )
{
v6 = *(long long **)(a1 + 32);
v2 = *v6;
if ( (unsigned int)strcmp(*v6 + 288, a2) )
{
v7 = 1LL;
while ( 1 )
{
v8 = v7;
if ( v4 == v7 )
break;
v9 = v6[v7];
v10 = strcmp(v9 + 288, a2);
v7 = v8 + 1;
if ( !v10 )
{
v2 = v9;
break;
}
}
v5 = v8 < v4;
v3 = a1;
}
}
if ( !v5 )
{
v11 = *(int *)(v3 + 4);
if ( v11 <= 0 )
{
return 0LL;
}
else
{
v12 = *(_QWORD *)(v3 + 16);
v13 = 0LL;
while ( 1 )
{
v14 = *(_QWORD *)(v12 + 8 * v13);
if ( !(unsigned int)strcmp(v14 + 288, a2) )
break;
if ( v11 == ++v13 )
return 0LL;
}
return v14;
}
}
return v2;
}
| |||
19,797
|
ggml_graph_get_tensor
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
struct ggml_tensor * ggml_graph_get_tensor(struct ggml_cgraph * cgraph, const char * name) {
for (int i = 0; i < cgraph->n_leafs; i++) {
struct ggml_tensor * leaf = cgraph->leafs[i];
if (strcmp(leaf->name, name) == 0) {
return leaf;
}
}
for (int i = 0; i < cgraph->n_nodes; i++) {
struct ggml_tensor * node = cgraph->nodes[i];
if (strcmp(node->name, name) == 0) {
return node;
}
}
return NULL;
}
|
O2
|
c
|
ggml_graph_get_tensor:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x72b31
movq 0x20(%r14), %rax
movq (%rax,%r13,8), %r15
leaq 0x120(%r15), %rdi
movq %rbx, %rsi
callq 0xa880
incq %r13
testl %eax, %eax
jne 0x72b0c
jmp 0x72b69
movl 0x4(%r14), %r12d
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x72b66
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %r15
leaq 0x120(%r15), %rdi
movq %rbx, %rsi
callq 0xa880
incq %r13
testl %eax, %eax
jne 0x72b41
jmp 0x72b69
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
ggml_graph_get_tensor:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rsi
mov r14, rdi
mov r12d, [rdi+8]
xor r13d, r13d
test r12d, r12d
cmovle r12d, r13d
loc_72B0C:
cmp r12, r13
jz short loc_72B31
mov rax, [r14+20h]
mov r15, [rax+r13*8]
lea rdi, [r15+120h]
mov rsi, rbx
call _strcmp
inc r13
test eax, eax
jnz short loc_72B0C
jmp short loc_72B69
loc_72B31:
mov r12d, [r14+4]
xor eax, eax
test r12d, r12d
cmovle r12d, eax
xor r13d, r13d
loc_72B41:
cmp r12, r13
jz short loc_72B66
mov rax, [r14+10h]
mov r15, [rax+r13*8]
lea rdi, [r15+120h]
mov rsi, rbx
call _strcmp
inc r13
test eax, eax
jnz short loc_72B41
jmp short loc_72B69
loc_72B66:
xor r15d, r15d
loc_72B69:
mov rax, r15
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long ggml_graph_get_tensor(long long a1, long long a2)
{
long long v2; // r12
long long v3; // r13
long long v4; // r15
long long v5; // r12
long long v6; // r13
v2 = *(unsigned int *)(a1 + 8);
v3 = 0LL;
if ( (int)v2 <= 0 )
v2 = 0LL;
while ( v2 != v3 )
{
v4 = *(_QWORD *)(*(_QWORD *)(a1 + 32) + 8 * v3++);
if ( !(unsigned int)strcmp(v4 + 288, a2) )
return v4;
}
v5 = *(unsigned int *)(a1 + 4);
if ( (int)v5 <= 0 )
v5 = 0LL;
v6 = 0LL;
while ( v5 != v6 )
{
v4 = *(_QWORD *)(*(_QWORD *)(a1 + 16) + 8 * v6++);
if ( !(unsigned int)strcmp(v4 + 288, a2) )
return v4;
}
return 0LL;
}
|
ggml_graph_get_tensor:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV R12D,dword ptr [RDI + 0x8]
XOR R13D,R13D
TEST R12D,R12D
CMOVLE R12D,R13D
LAB_00172b0c:
CMP R12,R13
JZ 0x00172b31
MOV RAX,qword ptr [R14 + 0x20]
MOV R15,qword ptr [RAX + R13*0x8]
LEA RDI,[R15 + 0x120]
MOV RSI,RBX
CALL 0x0010a880
INC R13
TEST EAX,EAX
JNZ 0x00172b0c
JMP 0x00172b69
LAB_00172b31:
MOV R12D,dword ptr [R14 + 0x4]
XOR EAX,EAX
TEST R12D,R12D
CMOVLE R12D,EAX
XOR R13D,R13D
LAB_00172b41:
CMP R12,R13
JZ 0x00172b66
MOV RAX,qword ptr [R14 + 0x10]
MOV R15,qword ptr [RAX + R13*0x8]
LEA RDI,[R15 + 0x120]
MOV RSI,RBX
CALL 0x0010a880
INC R13
TEST EAX,EAX
JNZ 0x00172b41
JMP 0x00172b69
LAB_00172b66:
XOR R15D,R15D
LAB_00172b69:
MOV RAX,R15
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
long ggml_graph_get_tensor(long param_1,char *param_2)
{
long lVar1;
uint uVar2;
int iVar3;
ulong uVar4;
ulong uVar5;
uVar4 = 0;
uVar5 = (ulong)*(uint *)(param_1 + 8);
if ((int)*(uint *)(param_1 + 8) < 1) {
uVar5 = uVar4;
}
do {
if (uVar5 == uVar4) {
uVar2 = *(uint *)(param_1 + 4);
if ((int)*(uint *)(param_1 + 4) < 1) {
uVar2 = 0;
}
uVar5 = 0;
do {
if (uVar2 == uVar5) {
return 0;
}
lVar1 = *(long *)(*(long *)(param_1 + 0x10) + uVar5 * 8);
iVar3 = strcmp((char *)(lVar1 + 0x120),param_2);
uVar5 = uVar5 + 1;
} while (iVar3 != 0);
return lVar1;
}
lVar1 = *(long *)(*(long *)(param_1 + 0x20) + uVar4 * 8);
iVar3 = strcmp((char *)(lVar1 + 0x120),param_2);
uVar4 = uVar4 + 1;
} while (iVar3 != 0);
return lVar1;
}
|
|
19,798
|
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, 0x32931(%rip) # 0x82c20
jne 0x502f6
jmp 0x5039f
movl $0x0, -0x4(%rbp)
cmpl $0x3, -0x4(%rbp)
jge 0x5036b
movslq -0x4(%rbp), %rcx
leaq 0x32982(%rip), %rax # 0x82c90
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5035e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x48(%rax)
je 0x50337
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
callq *0x48(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5034f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x14350
jmp 0x50351
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x50316
jmp 0x50360
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x502fd
leaq 0x3291e(%rip), %rdi # 0x82c90
xorl %esi, %esi
movl $0x40, %edx
callq 0x14260
movb $0x0, 0x3289b(%rip) # 0x82c20
leaq 0x328c4(%rip), %rdi # 0x82c50
xorl %esi, %esi
callq 0x3f420
leaq 0x3288e(%rip), %rdi # 0x82c28
callq 0x14500
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_502F6
jmp loc_5039F
loc_502F6:
mov [rbp+var_4], 0
loc_502FD:
cmp [rbp+var_4], 3
jge short loc_5036B
movsxd rcx, [rbp+var_4]
lea rax, plugin_list
mov rax, [rax+rcx*8]
mov [rbp+var_10], rax
loc_50316:
cmp [rbp+var_10], 0
jz short loc_5035E
mov rax, [rbp+var_10]
mov rax, [rax+10h]
cmp qword ptr [rax+48h], 0
jz short loc_50337
mov rax, [rbp+var_10]
mov rax, [rax+10h]
call qword ptr [rax+48h]
loc_50337:
mov rax, [rbp+var_10]
cmp qword ptr [rax+8], 0
jz short loc_5034F
mov rax, [rbp+var_10]
mov rdi, [rax+8]
call _dlclose
loc_5034F:
jmp short $+2
loc_50351:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_10], rax
jmp short loc_50316
loc_5035E:
jmp short $+2
loc_50360:
mov eax, [rbp+var_4]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_502FD
loc_5036B:
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_5039F:
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 [0x00182c20],0x0
JNZ 0x001502f6
JMP 0x0015039f
LAB_001502f6:
MOV dword ptr [RBP + -0x4],0x0
LAB_001502fd:
CMP dword ptr [RBP + -0x4],0x3
JGE 0x0015036b
MOVSXD RCX,dword ptr [RBP + -0x4]
LEA RAX,[0x182c90]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x10],RAX
LAB_00150316:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0015035e
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
CMP qword ptr [RAX + 0x48],0x0
JZ 0x00150337
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
CALL qword ptr [RAX + 0x48]
LAB_00150337:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x0015034f
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00114350
LAB_0015034f:
JMP 0x00150351
LAB_00150351:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00150316
LAB_0015035e:
JMP 0x00150360
LAB_00150360:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001502fd
LAB_0015036b:
LEA RDI,[0x182c90]
XOR ESI,ESI
MOV EDX,0x40
CALL 0x00114260
MOV byte ptr [0x00182c20],0x0
LEA RDI,[0x182c50]
XOR ESI,ESI
CALL 0x0013f420
LEA RDI,[0x182c28]
CALL 0x00114500
LAB_0015039f:
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;
}
|
|
19,799
|
minja::VariableExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!context->contains(name)) {
return Value();
}
return context->at(name);
}
|
O3
|
cpp
|
minja::VariableExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r12
addq $0x20, %r14
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x8a0b4
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x20(%rax)
movl %eax, %ebp
leaq 0x48(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x586c0
movq %r12, %rdi
callq 0x5dbae
movq -0x8(%r12), %rdi
testq %rdi, %rdi
je 0x984b7
callq 0x6d59a
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x984c6
callq 0x6d59a
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x984d5
callq 0x6d59a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9850b
movq 0x93aa2(%rip), %rax # 0x12bf88
cmpb $0x0, (%rax)
je 0x984f6
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x98500
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x9850b
movq (%rdi), %rax
callq *0x18(%rax)
testb %bpl, %bpl
je 0x985a2
movq (%r15), %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x8a0b4
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x18(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8d702
leaq 0x48(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x586c0
movq %r14, %rdi
callq 0x5dbae
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x98563
callq 0x6d59a
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x98572
callq 0x6d59a
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x98581
callq 0x6d59a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x985f5
movq 0x939f6(%rip), %rax # 0x12bf88
cmpb $0x0, (%rax)
je 0x985e0
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x985ea
leaq 0x40(%rbx), %r14
movq $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movb $0x0, 0x40(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x586c0
movq %r14, %rdi
movl $0x1, %esi
callq 0x586c0
jmp 0x985f5
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x985f5
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x98609
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x86056
movq %rbx, %rdi
callq 0x1afc0
|
_ZNK5minja12VariableExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov r12, [rdx]
add r14, 20h ; ' '
lea r13, [rsp+88h+var_80]
mov rdi, r13
mov rsi, r14
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rax, [r12]
mov rdi, r12
mov rsi, r13
call qword ptr [rax+20h]
mov ebp, eax
lea r12, [rsp+88h+var_40]
mov rdi, r12
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, r12
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, [r12-8]
test rdi, rdi
jz short loc_984B7
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_984B7:
mov rdi, [rsp+88h+var_58]
test rdi, rdi
jz short loc_984C6
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_984C6:
mov rdi, [rsp+88h+var_68]
test rdi, rdi
jz short loc_984D5
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_984D5:
mov rdi, [rsp+88h+var_78]
test rdi, rdi
jz short loc_9850B
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_984F6
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_98500
loc_984F6:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_98500:
cmp eax, 1
jnz short loc_9850B
mov rax, [rdi]
call qword ptr [rax+18h]
loc_9850B:
test bpl, bpl
jz loc_985A2
mov r15, [r15]
lea r12, [rsp+88h+var_80]
mov rdi, r12
mov rsi, r14
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rax, [r15]
mov rdi, r15
mov rsi, r12
call qword ptr [rax+18h]
mov rdi, rbx; this
mov rsi, rax; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
lea r14, [rsp+88h+var_40]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_98563
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_98563:
mov rdi, [rsp+88h+var_58]
test rdi, rdi
jz short loc_98572
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_98572:
mov rdi, [rsp+88h+var_68]
test rdi, rdi
jz short loc_98581
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_98581:
mov rdi, [rsp+88h+var_78]
test rdi, rdi
jz short loc_985F5
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_985E0
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_985EA
loc_985A2:
lea r14, [rbx+40h]
mov qword ptr [rbx+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+30h], xmm0
mov byte ptr [rbx+40h], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_985F5
loc_985E0:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_985EA:
cmp eax, 1
jnz short loc_985F5
mov rax, [rdi]
call qword ptr [rax+18h]
loc_985F5:
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_98609:
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
|
minja::Value * minja::VariableExpr::do_evaluate(minja::Value *this, long long a2, long long *a3)
{
long long v5; // r12
char v6; // bp
long long v7; // rdi
signed __int32 v8; // eax
long long v9; // r15
const minja::Value *v10; // rax
long long v11; // rdi
signed __int32 v12; // eax
_BYTE v14[8]; // [rsp+8h] [rbp-80h] BYREF
long long v15; // [rsp+10h] [rbp-78h]
volatile signed __int32 *v16; // [rsp+20h] [rbp-68h]
volatile signed __int32 *v17; // [rsp+30h] [rbp-58h]
volatile signed __int32 *v18; // [rsp+40h] [rbp-48h]
char v19[64]; // [rsp+48h] [rbp-40h] BYREF
v5 = *a3;
minja::Value::Value((long long)v14, a2 + 32);
v6 = (*(long long ( **)(long long, _BYTE *))(*(_QWORD *)v5 + 32LL))(v5, v14);
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(v19);
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(v19);
if ( v18 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v18);
if ( v17 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v17);
if ( v16 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v16);
v7 = v15;
if ( v15 )
{
if ( _libc_single_threaded )
{
v8 = *(_DWORD *)(v15 + 12);
*(_DWORD *)(v15 + 12) = v8 - 1;
}
else
{
v8 = _InterlockedExchangeAdd((volatile signed __int32 *)(v15 + 12), 0xFFFFFFFF);
}
if ( v8 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v7 + 24LL))(v7, 0LL);
}
if ( v6 )
{
v9 = *a3;
minja::Value::Value((long long)v14, a2 + 32);
v10 = (const minja::Value *)(*(long long ( **)(long long, _BYTE *))(*(_QWORD *)v9 + 24LL))(v9, v14);
minja::Value::Value(this, v10);
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(v19);
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(v19);
if ( v18 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v18);
if ( v17 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v17);
if ( v16 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v16);
v11 = v15;
if ( v15 )
{
if ( _libc_single_threaded )
{
v12 = *(_DWORD *)(v15 + 12);
*(_DWORD *)(v15 + 12) = v12 - 1;
}
else
{
v12 = _InterlockedExchangeAdd((volatile signed __int32 *)(v15 + 12), 0xFFFFFFFF);
}
if ( v12 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v11 + 24LL))(v11, 0LL);
}
}
else
{
*((_QWORD *)this + 9) = 0LL;
*(_OWORD *)this = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_BYTE *)this + 64) = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
}
return this;
}
|
do_evaluate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV R12,qword ptr [RDX]
ADD R14,0x20
LEA R13,[RSP + 0x8]
MOV RDI,R13
MOV RSI,R14
CALL 0x0018a0b4
MOV RAX,qword ptr [R12]
LAB_00198486:
MOV RDI,R12
MOV RSI,R13
CALL qword ptr [RAX + 0x20]
LAB_0019848f:
MOV EBP,EAX
LEA R12,[RSP + 0x48]
MOV RDI,R12
XOR ESI,ESI
CALL 0x001586c0
MOV RDI,R12
CALL 0x0015dbae
MOV RDI,qword ptr [R12 + -0x8]
TEST RDI,RDI
JZ 0x001984b7
CALL 0x0016d59a
LAB_001984b7:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x001984c6
CALL 0x0016d59a
LAB_001984c6:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x001984d5
CALL 0x0016d59a
LAB_001984d5:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0019850b
MOV RAX,qword ptr [0x0022bf88]
CMP byte ptr [RAX],0x0
JZ 0x001984f6
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00198500
LAB_001984f6:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00198500:
CMP EAX,0x1
JNZ 0x0019850b
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0019850b:
TEST BPL,BPL
JZ 0x001985a2
MOV R15,qword ptr [R15]
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R14
CALL 0x0018a0b4
MOV RAX,qword ptr [R15]
LAB_0019852a:
MOV RDI,R15
MOV RSI,R12
CALL qword ptr [RAX + 0x18]
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0018d702
LAB_0019853e:
LEA R14,[RSP + 0x48]
MOV RDI,R14
XOR ESI,ESI
CALL 0x001586c0
MOV RDI,R14
CALL 0x0015dbae
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x00198563
CALL 0x0016d59a
LAB_00198563:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x00198572
CALL 0x0016d59a
LAB_00198572:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x00198581
CALL 0x0016d59a
LAB_00198581:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x001985f5
MOV RAX,qword ptr [0x0022bf88]
CMP byte ptr [RAX],0x0
JZ 0x001985e0
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001985ea
LAB_001985a2:
LEA R14,[RBX + 0x40]
MOV qword ptr [RBX + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV byte ptr [RBX + 0x40],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x001586c0
MOV RDI,R14
MOV ESI,0x1
CALL 0x001586c0
JMP 0x001985f5
LAB_001985e0:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001985ea:
CMP EAX,0x1
JNZ 0x001985f5
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001985f5:
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::VariableExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
shared_ptr * minja::VariableExpr::do_evaluate(shared_ptr *param_1)
{
int *piVar1;
long *plVar2;
char cVar3;
int iVar4;
Value *pVVar5;
int8 *in_RDX;
long in_RSI;
bool bVar6;
Value local_80 [8];
long *local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
data local_40 [16];
plVar2 = (long *)*in_RDX;
Value::Value(local_80,(string *)(in_RSI + 0x20));
/* try { // try from 00198486 to 0019848e has its CatchHandler @ 00198609 */
cVar3 = (**(code **)(*plVar2 + 0x20))(plVar2,local_80);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_0022bf88 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar4 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar4 + -1;
}
if (iVar4 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
if (cVar3 == '\0') {
bVar6 = (bool)((char)param_1 + '@');
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x38) = 0;
param_1[0x40] = (shared_ptr)0x0;
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(bVar6);
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(bVar6);
}
else {
plVar2 = (long *)*in_RDX;
Value::Value(local_80,(string *)(in_RSI + 0x20));
/* try { // try from 0019852a to 0019853d has its CatchHandler @ 00198607 */
pVVar5 = (Value *)(**(code **)(*plVar2 + 0x18))(plVar2,local_80);
Value::Value((Value *)param_1,pVVar5);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_0022bf88 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar4 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar4 + -1;
}
if (iVar4 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
}
return param_1;
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.