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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
17,200
|
lshift
|
eloqsql/libmariadb/libmariadb/ma_dtoa.c
|
static Bigint *lshift(Bigint *b, int k, Stack_alloc *alloc)
{
int i, k1, n, n1;
Bigint *b1;
ULong *x, *x1, *xe, z;
n= k >> 5;
k1= b->k;
n1= n + b->wds + 1;
for (i= b->maxwds; n1 > i; i<<= 1)
k1++;
b1= Balloc(k1, alloc);
x1= b1->p.x;
for (i= 0; i < n; i++)
*x1++= 0;
x= b->p.x;
xe= x + b->wds;
if (k&= 0x1f)
{
k1= 32 - k;
z= 0;
do
{
*x1++= *x << k | z;
z= *x++ >> k1;
}
while (x < xe);
if ((*x1= z))
++n1;
}
else
do
*x1++= *x++;
while (x < xe);
b1->wds= n1 - 1;
Bfree(b, alloc);
return b1;
}
|
O0
|
c
|
lshift:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
sarl $0x5, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
addl 0x14(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x35fdb
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
jmp 0x35fc0
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x36330
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x36025
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl $0x0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x35ffd
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x14(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x360c4
movl $0x20, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl -0xc(%rbp), %ecx
shll %cl, %eax
movl %eax, %ecx
orl -0x4c(%rbp), %ecx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x40(%rbp)
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %eax
movl -0x20(%rbp), %ecx
shrl %cl, %eax
movl %eax, -0x4c(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x36067
movl -0x4c(%rbp), %eax
movq -0x40(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
je 0x360c2
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x360f4
jmp 0x360c6
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x40(%rbp)
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x360c6
jmp 0x360f4
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x35e30
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
lshift:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov eax, [rbp+var_C]
sar eax, 5
mov [rbp+var_24], eax
mov rax, [rbp+var_8]
mov eax, [rax+8]
mov [rbp+var_20], eax
mov eax, [rbp+var_24]
mov rcx, [rbp+var_8]
add eax, [rcx+14h]
add eax, 1
mov [rbp+var_28], eax
mov rax, [rbp+var_8]
mov eax, [rax+0Ch]
mov [rbp+var_1C], eax
loc_35FC0:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_1C]
jle short loc_35FDB
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
mov eax, [rbp+var_1C]
shl eax, 1
mov [rbp+var_1C], eax
jmp short loc_35FC0
loc_35FDB:
mov edi, [rbp+var_20]
mov rsi, [rbp+var_18]
call Balloc
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_40], rax
mov [rbp+var_1C], 0
loc_35FFD:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_24]
jge short loc_36025
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov dword ptr [rax], 0
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_35FFD
loc_36025:
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+14h]
shl rcx, 2
add rax, rcx
mov [rbp+var_48], rax
mov eax, [rbp+var_C]
and eax, 1Fh
mov [rbp+var_C], eax
cmp eax, 0
jz short loc_360C4
mov eax, 20h ; ' '
sub eax, [rbp+var_C]
mov [rbp+var_20], eax
mov [rbp+var_4C], 0
loc_36067:
mov rax, [rbp+var_38]
mov eax, [rax]
mov ecx, [rbp+var_C]
shl eax, cl
mov ecx, eax
or ecx, [rbp+var_4C]
mov rax, [rbp+var_40]
mov rdx, rax
add rdx, 4
mov [rbp+var_40], rdx
mov [rax], ecx
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 4
mov [rbp+var_38], rcx
mov eax, [rax]
mov ecx, [rbp+var_20]
shr eax, cl
mov [rbp+var_4C], eax
mov rax, [rbp+var_38]
cmp rax, [rbp+var_48]
jb short loc_36067
mov eax, [rbp+var_4C]
mov rcx, [rbp+var_40]
mov [rcx], eax
cmp eax, 0
jz short loc_360C2
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_28], eax
loc_360C2:
jmp short loc_360F4
loc_360C4:
jmp short $+2
loc_360C6:
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 4
mov [rbp+var_38], rcx
mov ecx, [rax]
mov rax, [rbp+var_40]
mov rdx, rax
add rdx, 4
mov [rbp+var_40], rdx
mov [rax], ecx
mov rax, [rbp+var_38]
cmp rax, [rbp+var_48]
jb short loc_360C6
jmp short $+2
loc_360F4:
mov ecx, [rbp+var_28]
sub ecx, 1
mov rax, [rbp+var_30]
mov [rax+14h], ecx
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call Bfree
mov rax, [rbp+var_30]
add rsp, 50h
pop rbp
retn
|
long long lshift(unsigned long long a1, int a2, unsigned long long *a3)
{
int *v3; // rax
int *v4; // rax
int *v5; // rax
int *v6; // rax
int v7; // ecx
int *v8; // rax
int v10; // [rsp+4h] [rbp-4Ch]
unsigned long long v11; // [rsp+8h] [rbp-48h]
int *v12; // [rsp+10h] [rbp-40h]
int *v13; // [rsp+18h] [rbp-38h]
long long v14; // [rsp+20h] [rbp-30h]
int v15; // [rsp+28h] [rbp-28h]
unsigned int v16; // [rsp+30h] [rbp-20h]
int i; // [rsp+34h] [rbp-1Ch]
int j; // [rsp+34h] [rbp-1Ch]
char v20; // [rsp+44h] [rbp-Ch]
v16 = *(_DWORD *)(a1 + 8);
v15 = *(_DWORD *)(a1 + 20) + (a2 >> 5) + 1;
for ( i = *(_DWORD *)(a1 + 12); v15 > i; i *= 2 )
++v16;
v14 = Balloc(v16, a3);
v12 = *(int **)v14;
for ( j = 0; j < a2 >> 5; ++j )
{
v3 = v12++;
*v3 = 0;
}
v13 = *(int **)a1;
v11 = 4LL * *(int *)(a1 + 20) + *(_QWORD *)a1;
v20 = a2 & 0x1F;
if ( (a2 & 0x1F) != 0 )
{
v10 = 0;
do
{
v4 = v12++;
*v4 = v10 | (*v13 << v20);
v5 = v13++;
v10 = (unsigned int)*v5 >> (32 - v20);
}
while ( (unsigned long long)v13 < v11 );
*v12 = v10;
if ( v10 )
++v15;
}
else
{
do
{
v6 = v13++;
v7 = *v6;
v8 = v12++;
*v8 = v7;
}
while ( (unsigned long long)v13 < v11 );
}
*(_DWORD *)(v14 + 20) = v15 - 1;
Bfree(a1, a3);
return v14;
}
|
lshift:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV EAX,dword ptr [RBP + -0xc]
SAR EAX,0x5
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x8]
ADD EAX,dword ptr [RCX + 0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x1c],EAX
LAB_00135fc0:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x1c]
JLE 0x00135fdb
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x1c]
SHL EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00135fc0
LAB_00135fdb:
MOV EDI,dword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00136330
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x1c],0x0
LAB_00135ffd:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x24]
JGE 0x00136025
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x40],RCX
MOV dword ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00135ffd
LAB_00136025:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x14]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x1f
MOV dword ptr [RBP + -0xc],EAX
CMP EAX,0x0
JZ 0x001360c4
MOV EAX,0x20
SUB EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x20],EAX
MOV dword ptr [RBP + -0x4c],0x0
LAB_00136067:
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0xc]
SHL EAX,CL
MOV ECX,EAX
OR ECX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x40]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x40],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x38],RCX
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x20]
SHR EAX,CL
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x48]
JC 0x00136067
MOV EAX,dword ptr [RBP + -0x4c]
MOV RCX,qword ptr [RBP + -0x40]
MOV dword ptr [RCX],EAX
CMP EAX,0x0
JZ 0x001360c2
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
LAB_001360c2:
JMP 0x001360f4
LAB_001360c4:
JMP 0x001360c6
LAB_001360c6:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x38],RCX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x40]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x40],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x48]
JC 0x001360c6
JMP 0x001360f4
LAB_001360f4:
MOV ECX,dword ptr [RBP + -0x28]
SUB ECX,0x1
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x14],ECX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00135e30
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x50
POP RBP
RET
|
int8 * lshift(int8 *param_1,uint param_2,int8 param_3)
{
sbyte sVar1;
int iVar2;
int8 *puVar3;
uint *puVar4;
uint *puVar5;
uint *puVar6;
uint local_54;
uint *local_48;
uint *local_40;
int local_30;
int local_28;
int local_24;
local_28 = *(int *)(param_1 + 1);
iVar2 = ((int)param_2 >> 5) + *(int *)((long)param_1 + 0x14);
local_30 = iVar2 + 1;
for (local_24 = *(int *)((long)param_1 + 0xc); local_24 < local_30; local_24 = local_24 << 1) {
local_28 = local_28 + 1;
}
puVar3 = (int8 *)Balloc(local_28,param_3);
local_48 = (uint *)*puVar3;
for (local_24 = 0; local_24 < (int)param_2 >> 5; local_24 = local_24 + 1) {
*local_48 = 0;
local_48 = local_48 + 1;
}
local_40 = (uint *)*param_1;
puVar4 = local_40 + *(int *)((long)param_1 + 0x14);
if ((param_2 & 0x1f) == 0) {
do {
puVar5 = local_40 + 1;
*local_48 = *local_40;
local_48 = local_48 + 1;
local_40 = puVar5;
} while (puVar5 < puVar4);
}
else {
sVar1 = (sbyte)(param_2 & 0x1f);
local_54 = 0;
do {
puVar6 = local_48 + 1;
*local_48 = *local_40 << sVar1 | local_54;
puVar5 = local_40 + 1;
local_54 = *local_40 >> (0x20U - sVar1 & 0x1f);
local_48 = puVar6;
local_40 = puVar5;
} while (puVar5 < puVar4);
*puVar6 = local_54;
if (local_54 != 0) {
local_30 = iVar2 + 2;
}
}
*(int *)((long)puVar3 + 0x14) = local_30 + -1;
Bfree(param_1,param_3);
return puVar3;
}
|
|
17,201
|
init_dynamic_array2
|
eloqsql/mysys/array.c
|
my_bool init_dynamic_array2(PSI_memory_key psi_key, DYNAMIC_ARRAY *array,
uint element_size, void *init_buffer,
uint init_alloc, uint alloc_increment, myf my_flags)
{
DBUG_ENTER("init_dynamic_array2");
if (!alloc_increment)
{
alloc_increment=MY_MAX((8192-MALLOC_OVERHEAD)/element_size,16);
if (init_alloc > 8 && alloc_increment > init_alloc * 2)
alloc_increment=init_alloc*2;
}
array->elements=0;
array->max_element=init_alloc;
array->alloc_increment=alloc_increment;
array->size_of_element=element_size;
array->m_psi_key= psi_key;
array->malloc_flags= my_flags;
DBUG_ASSERT((my_flags & MY_INIT_BUFFER_USED) == 0);
if ((array->buffer= init_buffer))
{
array->malloc_flags|= MY_INIT_BUFFER_USED;
DBUG_RETURN(FALSE);
}
/*
Since the dynamic array is usable even if allocation fails here malloc
should not throw an error
*/
if (init_alloc &&
!(array->buffer= (uchar*) my_malloc(psi_key, element_size*init_alloc,
MYF(my_flags))))
array->max_element=0;
DBUG_RETURN(FALSE);
}
|
O0
|
c
|
init_dynamic_array2:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0xd9e52
movl $0x1ff8, %eax # imm = 0x1FF8
xorl %edx, %edx
divl -0x14(%rbp)
cmpl $0x10, %eax
jbe 0xd9e26
movl $0x1ff8, %eax # imm = 0x1FF8
xorl %edx, %edx
divl -0x14(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xd9e30
movl $0x10, %eax
movl %eax, -0x2c(%rbp)
jmp 0xd9e30
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x8, -0x24(%rbp)
jbe 0xd9e50
movl -0x28(%rbp), %eax
movl -0x24(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jbe 0xd9e50
movl -0x24(%rbp), %eax
shll %eax
movl %eax, -0x28(%rbp)
jmp 0xd9e52
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq 0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0xd9e93
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xd9ebd
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
orq $0x100, %rcx # imm = 0x100
movq %rcx, 0x20(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xd9ef8
cmpl $0x0, -0x24(%rbp)
je 0xd9ef2
movl -0x8(%rbp), %edi
movl -0x14(%rbp), %eax
imull -0x24(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
movq 0x10(%rbp), %rdx
callq 0xf2e30
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xd9ef2
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
jmp 0xd9ef4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
init_dynamic_array2:
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, [rbp+arg_0]
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_28], r9d
cmp [rbp+var_28], 0
jnz short loc_D9E52
mov eax, 1FF8h
xor edx, edx
div [rbp+var_14]
cmp eax, 10h
jbe short loc_D9E26
mov eax, 1FF8h
xor edx, edx
div [rbp+var_14]
mov [rbp+var_2C], eax
jmp short loc_D9E30
loc_D9E26:
mov eax, 10h
mov [rbp+var_2C], eax
jmp short $+2
loc_D9E30:
mov eax, [rbp+var_2C]
mov [rbp+var_28], eax
cmp [rbp+var_24], 8
jbe short loc_D9E50
mov eax, [rbp+var_28]
mov ecx, [rbp+var_24]
shl ecx, 1
cmp eax, ecx
jbe short loc_D9E50
mov eax, [rbp+var_24]
shl eax, 1
mov [rbp+var_28], eax
loc_D9E50:
jmp short $+2
loc_D9E52:
mov rax, [rbp+var_10]
mov dword ptr [rax+8], 0
mov ecx, [rbp+var_24]
mov rax, [rbp+var_10]
mov [rax+0Ch], ecx
mov ecx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax+10h], ecx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov [rax+14h], ecx
mov ecx, [rbp+var_8]
mov rax, [rbp+var_10]
mov [rax+18h], ecx
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_10]
mov [rax+20h], rcx
jmp short $+2
loc_D9E93:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
mov [rcx], rax
cmp rax, 0
jz short loc_D9EBD
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
or rcx, 100h
mov [rax+20h], rcx
mov [rbp+var_1], 0
jmp short loc_D9EF8
loc_D9EBD:
cmp [rbp+var_24], 0
jz short loc_D9EF2
mov edi, [rbp+var_8]
mov eax, [rbp+var_14]
imul eax, [rbp+var_24]
mov eax, eax
mov esi, eax
mov rdx, [rbp+arg_0]
call my_malloc
mov rcx, [rbp+var_10]
mov [rcx], rax
cmp rax, 0
jnz short loc_D9EF2
mov rax, [rbp+var_10]
mov dword ptr [rax+0Ch], 0
loc_D9EF2:
jmp short $+2
loc_D9EF4:
mov [rbp+var_1], 0
loc_D9EF8:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char init_dynamic_array2(
unsigned int a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
int a6,
long long a7)
{
long long v7; // rax
unsigned int v9; // [rsp+4h] [rbp-2Ch]
int v10; // [rsp+8h] [rbp-28h]
v10 = a6;
if ( !a6 )
{
v9 = 0x1FF8 / a3 <= 0x10 ? 16 : 0x1FF8 / a3;
v10 = v9;
if ( a5 > 8 && v9 > 2 * a5 )
v10 = 2 * a5;
}
*(_DWORD *)(a2 + 8) = 0;
*(_DWORD *)(a2 + 12) = a5;
*(_DWORD *)(a2 + 16) = v10;
*(_DWORD *)(a2 + 20) = a3;
*(_DWORD *)(a2 + 24) = a1;
*(_QWORD *)(a2 + 32) = a7;
*(_QWORD *)a2 = a4;
if ( a4 )
{
*(_QWORD *)(a2 + 32) |= 0x100uLL;
}
else if ( a5 )
{
v7 = my_malloc(a1, a5 * a3, a7);
*(_QWORD *)a2 = v7;
if ( !v7 )
*(_DWORD *)(a2 + 12) = 0;
}
return 0;
}
|
init_dynamic_array2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV dword ptr [RBP + -0x28],R9D
CMP dword ptr [RBP + -0x28],0x0
JNZ 0x001d9e52
MOV EAX,0x1ff8
XOR EDX,EDX
DIV dword ptr [RBP + -0x14]
CMP EAX,0x10
JBE 0x001d9e26
MOV EAX,0x1ff8
XOR EDX,EDX
DIV dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001d9e30
LAB_001d9e26:
MOV EAX,0x10
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001d9e30
LAB_001d9e30:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x28],EAX
CMP dword ptr [RBP + -0x24],0x8
JBE 0x001d9e50
MOV EAX,dword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x24]
SHL ECX,0x1
CMP EAX,ECX
JBE 0x001d9e50
MOV EAX,dword ptr [RBP + -0x24]
SHL EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
LAB_001d9e50:
JMP 0x001d9e52
LAB_001d9e52:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x8],0x0
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xc],ECX
MOV ECX,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x10],ECX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x14],ECX
MOV ECX,dword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x18],ECX
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x20],RCX
JMP 0x001d9e93
LAB_001d9e93:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001d9ebd
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
OR RCX,0x100
MOV qword ptr [RAX + 0x20],RCX
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001d9ef8
LAB_001d9ebd:
CMP dword ptr [RBP + -0x24],0x0
JZ 0x001d9ef2
MOV EDI,dword ptr [RBP + -0x8]
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,dword ptr [RBP + -0x24]
MOV EAX,EAX
MOV ESI,EAX
MOV RDX,qword ptr [RBP + 0x10]
CALL 0x001f2e30
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x001d9ef2
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xc],0x0
LAB_001d9ef2:
JMP 0x001d9ef4
LAB_001d9ef4:
MOV byte ptr [RBP + -0x1],0x0
LAB_001d9ef8:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int8
init_dynamic_array2(int4 param_1,long *param_2,uint param_3,long param_4,uint param_5,
uint param_6,long param_7)
{
long lVar1;
uint local_34;
uint local_30;
local_30 = param_6;
if (param_6 == 0) {
if ((uint)(0x1ff8 / (ulong)param_3) < 0x11) {
local_34 = 0x10;
}
else {
local_34 = (uint)(0x1ff8 / (ulong)param_3);
}
local_30 = local_34;
if ((8 < param_5) && (param_5 * 2 < local_34)) {
local_30 = param_5 << 1;
}
}
*(int4 *)(param_2 + 1) = 0;
*(uint *)((long)param_2 + 0xc) = param_5;
*(uint *)(param_2 + 2) = local_30;
*(uint *)((long)param_2 + 0x14) = param_3;
*(int4 *)(param_2 + 3) = param_1;
param_2[4] = param_7;
*param_2 = param_4;
if (param_4 == 0) {
if (param_5 != 0) {
lVar1 = my_malloc(param_1,param_3 * param_5,param_7);
*param_2 = lVar1;
if (lVar1 == 0) {
*(int4 *)((long)param_2 + 0xc) = 0;
}
}
}
else {
param_2[4] = param_2[4] | 0x100;
}
return 0;
}
|
|
17,202
|
init_dynamic_array2
|
eloqsql/mysys/array.c
|
my_bool init_dynamic_array2(PSI_memory_key psi_key, DYNAMIC_ARRAY *array,
uint element_size, void *init_buffer,
uint init_alloc, uint alloc_increment, myf my_flags)
{
DBUG_ENTER("init_dynamic_array2");
if (!alloc_increment)
{
alloc_increment=MY_MAX((8192-MALLOC_OVERHEAD)/element_size,16);
if (init_alloc > 8 && alloc_increment > init_alloc * 2)
alloc_increment=init_alloc*2;
}
array->elements=0;
array->max_element=init_alloc;
array->alloc_increment=alloc_increment;
array->size_of_element=element_size;
array->m_psi_key= psi_key;
array->malloc_flags= my_flags;
DBUG_ASSERT((my_flags & MY_INIT_BUFFER_USED) == 0);
if ((array->buffer= init_buffer))
{
array->malloc_flags|= MY_INIT_BUFFER_USED;
DBUG_RETURN(FALSE);
}
/*
Since the dynamic array is usable even if allocation fails here malloc
should not throw an error
*/
if (init_alloc &&
!(array->buffer= (uchar*) my_malloc(psi_key, element_size*init_alloc,
MYF(my_flags))))
array->max_element=0;
DBUG_RETURN(FALSE);
}
|
O3
|
c
|
init_dynamic_array2:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %r11d
movq %rsi, %rbx
movq 0x10(%rbp), %r10
testl %r9d, %r9d
jne 0x9149b
movl $0x10, %r9d
cmpl $0x1e1, %r11d # imm = 0x1E1
ja 0x9148a
movw $0x1ff8, %ax # imm = 0x1FF8
xorl %edx, %edx
divw %r11w
movzwl %ax, %r9d
cmpl $0x9, %r8d
jb 0x9149b
leal (%r8,%r8), %eax
cmpl %eax, %r9d
cmovael %eax, %r9d
movl $0x0, 0x8(%rbx)
movl %r8d, 0xc(%rbx)
movl %r9d, 0x10(%rbx)
movl %r11d, 0x14(%rbx)
movl %edi, 0x18(%rbx)
movq %r10, 0x20(%rbx)
movq %rcx, (%rbx)
testq %rcx, %rcx
je 0x914d1
orq $0x100, %r10 # imm = 0x100
movq %r10, 0x20(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
testl %r8d, %r8d
je 0x914c8
imull %r11d, %r8d
movq %r8, %rsi
movq %r10, %rdx
callq 0x9f6e1
movq %rax, (%rbx)
testq %rax, %rax
jne 0x914c8
movl $0x0, 0xc(%rbx)
jmp 0x914c8
|
init_dynamic_array2:
push rbp
mov rbp, rsp
push rbx
push rax
mov r11d, edx
mov rbx, rsi
mov r10, [rbp+arg_0]
test r9d, r9d
jnz short loc_9149B
mov r9d, 10h
cmp r11d, 1E1h
ja short loc_9148A
mov ax, 1FF8h
xor edx, edx
div r11w
movzx r9d, ax
loc_9148A:
cmp r8d, 9
jb short loc_9149B
lea eax, [r8+r8]
cmp r9d, eax
cmovnb r9d, eax
loc_9149B:
mov dword ptr [rbx+8], 0
mov [rbx+0Ch], r8d
mov [rbx+10h], r9d
mov [rbx+14h], r11d
mov [rbx+18h], edi
mov [rbx+20h], r10
mov [rbx], rcx
test rcx, rcx
jz short loc_914D1
or r10, 100h
mov [rbx+20h], r10
loc_914C8:
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
loc_914D1:
test r8d, r8d
jz short loc_914C8
imul r8d, r11d
mov rsi, r8
mov rdx, r10
call my_malloc
mov [rbx], rax
test rax, rax
jnz short loc_914C8
mov dword ptr [rbx+0Ch], 0
jmp short loc_914C8
|
long long init_dynamic_array2(
long long a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
unsigned int a6,
long long a7)
{
long long v8; // rax
if ( !a6 )
{
a6 = 16;
if ( a3 <= 0x1E1 )
a6 = 0x1FF8u / (unsigned __int16)a3;
if ( a5 >= 9 && a6 >= 2 * a5 )
a6 = 2 * a5;
}
*(_DWORD *)(a2 + 8) = 0;
*(_DWORD *)(a2 + 12) = a5;
*(_DWORD *)(a2 + 16) = a6;
*(_DWORD *)(a2 + 20) = a3;
*(_DWORD *)(a2 + 24) = a1;
*(_QWORD *)(a2 + 32) = a7;
*(_QWORD *)a2 = a4;
if ( a4 )
{
*(_QWORD *)(a2 + 32) = a7 | 0x100;
}
else if ( a5 )
{
v8 = my_malloc(a1, a3 * a5, a7);
*(_QWORD *)a2 = v8;
if ( !v8 )
*(_DWORD *)(a2 + 12) = 0;
}
return 0LL;
}
|
init_dynamic_array2:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV R11D,EDX
MOV RBX,RSI
MOV R10,qword ptr [RBP + 0x10]
TEST R9D,R9D
JNZ 0x0019149b
MOV R9D,0x10
CMP R11D,0x1e1
JA 0x0019148a
MOV AX,0x1ff8
XOR EDX,EDX
DIV R11W
MOVZX R9D,AX
LAB_0019148a:
CMP R8D,0x9
JC 0x0019149b
LEA EAX,[R8 + R8*0x1]
CMP R9D,EAX
CMOVNC R9D,EAX
LAB_0019149b:
MOV dword ptr [RBX + 0x8],0x0
MOV dword ptr [RBX + 0xc],R8D
MOV dword ptr [RBX + 0x10],R9D
MOV dword ptr [RBX + 0x14],R11D
MOV dword ptr [RBX + 0x18],EDI
MOV qword ptr [RBX + 0x20],R10
MOV qword ptr [RBX],RCX
TEST RCX,RCX
JZ 0x001914d1
OR R10,0x100
MOV qword ptr [RBX + 0x20],R10
LAB_001914c8:
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001914d1:
TEST R8D,R8D
JZ 0x001914c8
IMUL R8D,R11D
MOV RSI,R8
MOV RDX,R10
CALL 0x0019f6e1
MOV qword ptr [RBX],RAX
TEST RAX,RAX
JNZ 0x001914c8
MOV dword ptr [RBX + 0xc],0x0
JMP 0x001914c8
|
int8
init_dynamic_array2(int4 param_1,long *param_2,uint param_3,long param_4,uint param_5,
uint param_6,ulong param_7)
{
long lVar1;
if (param_6 == 0) {
param_6 = 0x10;
if (param_3 < 0x1e2) {
param_6 = 0x1ff8 / (param_3 & 0xffff);
}
if ((8 < param_5) && (param_5 * 2 <= param_6)) {
param_6 = param_5 * 2;
}
}
*(int4 *)(param_2 + 1) = 0;
*(uint *)((long)param_2 + 0xc) = param_5;
*(uint *)(param_2 + 2) = param_6;
*(uint *)((long)param_2 + 0x14) = param_3;
*(int4 *)(param_2 + 3) = param_1;
param_2[4] = param_7;
*param_2 = param_4;
if (param_4 == 0) {
if (param_5 != 0) {
lVar1 = my_malloc(param_1,param_5 * param_3,param_7);
*param_2 = lVar1;
if (lVar1 == 0) {
*(int4 *)((long)param_2 + 0xc) = 0;
}
}
}
else {
param_2[4] = param_7 | 0x100;
}
return 0;
}
|
|
17,203
|
my_strntoull_8bit
|
eloqsql/strings/ctype-simple.c
|
ulonglong my_strntoull_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register ulonglong cutoff;
register uint cutlim;
register ulonglong i;
register const char *s, *e;
const char *save;
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 = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) 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 *= (ulonglong) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (overflow)
{
err[0]= ERANGE;
return (~(ulonglong) 0);
}
return (negative ? -((longlong) i) : (longlong) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
}
|
O3
|
c
|
my_strntoull_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 0xbb521
movq 0x40(%rdi), %rax
movq %rsi, %r10
movzbl (%r10), %edx
testb $0x8, 0x1(%rax,%rdx)
je 0xbb521
incq %r10
cmpq %r11, %r10
jb 0xbb50e
cmpq %r11, %r10
je 0xbb609
movb (%r10), %dil
leal -0x2b(%rdi), %eax
andb $-0x3, %al
cmpb $0x1, %al
adcq $0x0, %r10
movslq %ecx, %rbx
movq $-0x1, %rax
xorl %edx, %edx
movq %rbx, -0x38(%rbp)
divq %rbx
xorl %r12d, %r12d
cmpq %r11, %r10
je 0xbb5e6
movq %rdi, -0x30(%rbp)
movq %r10, %r14
xorl %r15d, %r15d
movq %r15, %rdi
movl %r12d, %r13d
movb (%r14), %r12b
leal -0x30(%r12), %ebx
cmpb $0xa, %bl
jb 0xbb595
leal -0x41(%r12), %ebx
cmpb $0x19, %bl
ja 0xbb584
addb $-0x37, %r12b
jmp 0xbb592
leal -0x61(%r12), %ebx
cmpb $0x19, %bl
ja 0xbb5d4
addb $-0x57, %r12b
movl %r12d, %ebx
movzbl %bl, %ebx
cmpl %ecx, %ebx
jge 0xbb5d4
movl $0x1, %r12d
cmpq %rax, %rdi
jbe 0xbb5ac
movq %rdi, %r15
jmp 0xbb5c3
jne 0xbb5b5
movq %rax, %r15
cmpl %edx, %ebx
ja 0xbb5c3
imulq -0x38(%rbp), %rdi
movl %ebx, %r15d
addq %rdi, %r15
movl %r13d, %r12d
incq %r14
cmpq %r11, %r14
jne 0xbb561
movq %r15, %rdi
movq %r11, %r14
movl %r12d, %r13d
testl %r13d, %r13d
sete %al
movq %rdi, %r12
movq %r14, %r11
movq -0x30(%rbp), %rdi
jmp 0xbb5e8
movb $0x1, %al
cmpq %r10, %r11
je 0xbb609
testq %r8, %r8
je 0xbb5f5
movq %r11, (%r8)
testb %al, %al
je 0xbb61c
movq %r12, %rax
negq %rax
cmpb $0x2d, %dil
cmovneq %r12, %rax
jmp 0xbb62a
movl $0x21, (%r9)
testq %r8, %r8
je 0xbb618
movq %rsi, (%r8)
xorl %eax, %eax
jmp 0xbb62a
movl $0x22, (%r9)
movq $-0x1, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strntoull_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_BB521
mov rax, [rdi+40h]
mov r10, rsi
loc_BB50E:
movzx edx, byte ptr [r10]
test byte ptr [rax+rdx+1], 8
jz short loc_BB521
inc r10
cmp r10, r11
jb short loc_BB50E
loc_BB521:
cmp r10, r11
jz loc_BB609
mov dil, [r10]
lea eax, [rdi-2Bh]
and al, 0FDh
cmp al, 1
adc r10, 0
movsxd rbx, ecx
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
mov [rbp+var_38], rbx
div rbx
xor r12d, r12d
cmp r10, r11
jz loc_BB5E6
mov [rbp+var_30], rdi
mov r14, r10
xor r15d, r15d
loc_BB561:
mov rdi, r15
mov r13d, r12d
mov r12b, [r14]
lea ebx, [r12-30h]
cmp bl, 0Ah
jb short loc_BB595
lea ebx, [r12-41h]
cmp bl, 19h
ja short loc_BB584
add r12b, 0C9h
jmp short loc_BB592
loc_BB584:
lea ebx, [r12-61h]
cmp bl, 19h
ja short loc_BB5D4
add r12b, 0A9h
loc_BB592:
mov ebx, r12d
loc_BB595:
movzx ebx, bl
cmp ebx, ecx
jge short loc_BB5D4
mov r12d, 1
cmp rdi, rax
jbe short loc_BB5AC
mov r15, rdi
jmp short loc_BB5C3
loc_BB5AC:
jnz short loc_BB5B5
mov r15, rax
cmp ebx, edx
ja short loc_BB5C3
loc_BB5B5:
imul rdi, [rbp+var_38]
mov r15d, ebx
add r15, rdi
mov r12d, r13d
loc_BB5C3:
inc r14
cmp r14, r11
jnz short loc_BB561
mov rdi, r15
mov r14, r11
mov r13d, r12d
loc_BB5D4:
test r13d, r13d
setz al
mov r12, rdi
mov r11, r14
mov rdi, [rbp+var_30]
jmp short loc_BB5E8
loc_BB5E6:
mov al, 1
loc_BB5E8:
cmp r11, r10
jz short loc_BB609
test r8, r8
jz short loc_BB5F5
mov [r8], r11
loc_BB5F5:
test al, al
jz short loc_BB61C
mov rax, r12
neg rax
cmp dil, 2Dh ; '-'
cmovnz rax, r12
jmp short loc_BB62A
loc_BB609:
mov dword ptr [r9], 21h ; '!'
test r8, r8
jz short loc_BB618
mov [r8], rsi
loc_BB618:
xor eax, eax
jmp short loc_BB62A
loc_BB61C:
mov dword ptr [r9], 22h ; '"'
mov rax, 0FFFFFFFFFFFFFFFFh
loc_BB62A:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_strntoull_8bit(
long long a1,
unsigned __int8 *a2,
long long a3,
int a4,
unsigned __int8 **a5,
_DWORD *a6)
{
unsigned __int8 *v6; // r11
unsigned __int8 *v7; // r10
unsigned __int8 v8; // di
unsigned __int8 *v9; // r10
unsigned long long v10; // rax
unsigned long long v11; // r12
unsigned __int8 *v12; // r14
unsigned long long v13; // r15
unsigned long long v14; // rdi
int v15; // r13d
unsigned __int8 v16; // r12
unsigned __int8 v17; // bl
unsigned __int8 v18; // r12
bool v19; // al
long long result; // rax
unsigned __int8 v21; // [rsp+8h] [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 = 0xFFFFFFFFFFFFFFFFLL / a4;
v11 = 0LL;
if ( v9 == v6 )
{
v19 = 1;
}
else
{
v21 = v8;
v12 = v9;
v13 = 0LL;
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 >= a4 )
break;
LODWORD(v11) = 1;
if ( v13 <= v10 )
{
if ( v13 != v10 || (v13 = 0xFFFFFFFFFFFFFFFFLL / a4, v17 <= (unsigned int)(0xFFFFFFFFFFFFFFFFLL % a4)) )
{
v13 = a4 * v14 + v17;
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 = -(long long)v11;
if ( v8 != 45 )
return v11;
}
else
{
*a6 = 34;
return -1LL;
}
}
return result;
}
|
my_strntoull_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 0x001bb521
MOV RAX,qword ptr [RDI + 0x40]
MOV R10,RSI
LAB_001bb50e:
MOVZX EDX,byte ptr [R10]
TEST byte ptr [RAX + RDX*0x1 + 0x1],0x8
JZ 0x001bb521
INC R10
CMP R10,R11
JC 0x001bb50e
LAB_001bb521:
CMP R10,R11
JZ 0x001bb609
MOV DIL,byte ptr [R10]
LEA EAX,[RDI + -0x2b]
AND AL,0xfd
CMP AL,0x1
ADC R10,0x0
MOVSXD RBX,ECX
MOV RAX,-0x1
XOR EDX,EDX
MOV qword ptr [RBP + -0x38],RBX
DIV RBX
XOR R12D,R12D
CMP R10,R11
JZ 0x001bb5e6
MOV qword ptr [RBP + -0x30],RDI
MOV R14,R10
XOR R15D,R15D
LAB_001bb561:
MOV RDI,R15
MOV R13D,R12D
MOV R12B,byte ptr [R14]
LEA EBX,[R12 + -0x30]
CMP BL,0xa
JC 0x001bb595
LEA EBX,[R12 + -0x41]
CMP BL,0x19
JA 0x001bb584
ADD R12B,0xc9
JMP 0x001bb592
LAB_001bb584:
LEA EBX,[R12 + -0x61]
CMP BL,0x19
JA 0x001bb5d4
ADD R12B,0xa9
LAB_001bb592:
MOV EBX,R12D
LAB_001bb595:
MOVZX EBX,BL
CMP EBX,ECX
JGE 0x001bb5d4
MOV R12D,0x1
CMP RDI,RAX
JBE 0x001bb5ac
MOV R15,RDI
JMP 0x001bb5c3
LAB_001bb5ac:
JNZ 0x001bb5b5
MOV R15,RAX
CMP EBX,EDX
JA 0x001bb5c3
LAB_001bb5b5:
IMUL RDI,qword ptr [RBP + -0x38]
MOV R15D,EBX
ADD R15,RDI
MOV R12D,R13D
LAB_001bb5c3:
INC R14
CMP R14,R11
JNZ 0x001bb561
MOV RDI,R15
MOV R14,R11
MOV R13D,R12D
LAB_001bb5d4:
TEST R13D,R13D
SETZ AL
MOV R12,RDI
MOV R11,R14
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x001bb5e8
LAB_001bb5e6:
MOV AL,0x1
LAB_001bb5e8:
CMP R11,R10
JZ 0x001bb609
TEST R8,R8
JZ 0x001bb5f5
MOV qword ptr [R8],R11
LAB_001bb5f5:
TEST AL,AL
JZ 0x001bb61c
MOV RAX,R12
NEG RAX
CMP DIL,0x2d
CMOVNZ RAX,R12
JMP 0x001bb62a
LAB_001bb609:
MOV dword ptr [R9],0x21
TEST R8,R8
JZ 0x001bb618
MOV qword ptr [R8],RSI
LAB_001bb618:
XOR EAX,EAX
JMP 0x001bb62a
LAB_001bb61c:
MOV dword ptr [R9],0x22
MOV RAX,-0x1
LAB_001bb62a:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strntoull_8bit(long param_1,byte *param_2,long param_3,int param_4,ulong *param_5,
int4 *param_6)
{
byte bVar1;
byte bVar2;
int1 auVar3 [16];
int1 auVar4 [16];
ulong uVar5;
ulong uVar6;
ulong uVar7;
byte *pbVar8;
byte *pbVar9;
byte bVar10;
ulong uVar11;
ulong uVar12;
int iVar13;
byte *pbVar14;
bool bVar15;
*param_6 = 0;
pbVar9 = param_2 + param_3;
pbVar8 = param_2;
if (0 < param_3) {
do {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar8) & 8) == 0) break;
pbVar8 = pbVar8 + 1;
} while (pbVar8 < pbVar9);
}
if (pbVar8 != pbVar9) {
bVar1 = *pbVar8;
pbVar8 = pbVar8 + ((bVar1 - 0x2b & 0xfd) == 0);
auVar3._8_8_ = 0;
auVar3._0_8_ = (long)param_4;
auVar4 = ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff);
uVar6 = SUB168(auVar4 / auVar3,0);
uVar7 = 0;
if (pbVar8 == pbVar9) {
bVar15 = true;
}
else {
uVar11 = uVar7;
pbVar14 = pbVar8;
uVar7 = 0;
do {
iVar13 = (int)uVar11;
bVar2 = *pbVar14;
bVar10 = bVar2 - 0x30;
if (9 < bVar10) {
if ((byte)(bVar2 + 0xbf) < 0x1a) {
bVar10 = bVar2 - 0x37;
}
else {
if (0x19 < (byte)(bVar2 + 0x9f)) goto LAB_001bb5d4;
bVar10 = bVar2 + 0xa9;
}
}
if (param_4 <= (int)(uint)bVar10) goto LAB_001bb5d4;
uVar12 = 1;
uVar5 = uVar7;
if ((uVar7 <= uVar6) &&
((uVar7 != uVar6 || (uVar5 = uVar6, (uint)bVar10 <= SUB164(auVar4 % auVar3,0))))) {
uVar12 = uVar11;
uVar5 = (ulong)bVar10 + uVar7 * (long)param_4;
}
uVar7 = uVar5;
pbVar14 = pbVar14 + 1;
uVar11 = uVar12;
} while (pbVar14 != pbVar9);
iVar13 = (int)uVar12;
pbVar14 = pbVar9;
LAB_001bb5d4:
pbVar9 = pbVar14;
bVar15 = iVar13 == 0;
}
if (pbVar9 != pbVar8) {
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)pbVar9;
}
if (bVar15) {
if (bVar1 == 0x2d) {
return -uVar7;
}
return uVar7;
}
*param_6 = 0x22;
return 0xffffffffffffffff;
}
}
*param_6 = 0x21;
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)param_2;
}
return 0;
}
|
|
17,204
|
ps_fetch_float
|
eloqsql/libmariadb/libmariadb/ma_stmt_codec.c
|
static
void ps_fetch_float(MYSQL_BIND *r_param, const MYSQL_FIELD * field, unsigned char **row)
{
switch(r_param->buffer_type)
{
case MYSQL_TYPE_FLOAT:
{
float *value= (float *)r_param->buffer;
float4get(*value, *row);
r_param->buffer_length= 4;
*r_param->error= 0;
}
break;
default:
{
float value;
memcpy(&value, *row, sizeof(float));
float4get(value, (char *)*row);
convert_from_float(r_param, field, value, sizeof(float));
}
break;
}
(*row)+= 4;
}
|
O3
|
c
|
ps_fetch_float:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x150, %rsp # imm = 0x150
movq %rdx, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
movl 0x60(%rdi), %r12d
cmpl $0x4, %r12d
jne 0x67b52
movq 0x10(%r14), %rax
movq (%rbx), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq $0x4, 0x40(%r14)
movq 0x18(%r14), %rax
movb $0x0, (%rax)
jmp 0x67e03
movq %rsi, %r15
movq (%rbx), %rax
movss (%rax), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
movaps %xmm1, -0x170(%rbp)
jbe 0x67b79
movaps %xmm1, %xmm0
callq 0x3a930
cvtss2sd %xmm0, %xmm0
jmp 0x67b93
movaps 0x51210(%rip), %xmm0 # 0xb8d90
xorps %xmm1, %xmm0
callq 0x3a930
cvtss2sd %xmm0, %xmm0
xorps 0x5123d(%rip), %xmm0 # 0xb8dd0
decl %r12d
cmpl $0xc, %r12d
ja 0x67c49
movq 0x10(%r14), %rax
leaq 0x5c9b5(%rip), %rcx # 0xc4560
movslq (%rcx,%r12,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
cmpb $0x0, 0x65(%r14)
movaps -0x170(%rbp), %xmm1
cvttss2si %xmm1, %ecx
je 0x67cc7
movzwl %cx, %edx
jmp 0x67cca
cmpb $0x0, 0x65(%r14)
movaps -0x170(%rbp), %xmm1
je 0x67dd9
cvttss2si %xmm1, %rcx
movq %rcx, %rdx
subss 0x50410(%rip), %xmm1 # 0xb8004
cvttss2si %xmm1, %rsi
sarq $0x3f, %rdx
andq %rdx, %rsi
orq %rcx, %rsi
movq %rsi, %xmm2
punpckldq 0x511a0(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x511a8(%rip), %xmm2 # 0xb8dc0
movq %rsi, (%rax)
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1 # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
jmp 0x67de9
cvttss2si -0x170(%rbp), %ecx
movb %cl, (%rax)
cmpb $0x0, 0x65(%r14)
je 0x67cf3
movzbl %cl, %eax
jmp 0x67cf6
movl 0x68(%r15), %edi
cmpl $0x1f, %edi
movaps -0x170(%rbp), %xmm0
jb 0x67d1c
movq 0x40(%r14), %rax
movl $0x12b, %esi # imm = 0x12B
cmpq %rsi, %rax
cmovbq %rax, %rsi
cvtss2sd %xmm0, %xmm0
leaq -0x160(%rbp), %rdx
xorl %edi, %edi
xorl %ecx, %ecx
callq 0x6a7a9
jmp 0x67d2e
cmpb $0x0, 0x65(%r14)
movaps -0x170(%rbp), %xmm1
cvttss2si %xmm1, %ecx
cvttss2si %xmm1, %rdx
cmovnel %edx, %ecx
je 0x67db3
movl %edx, %edx
xorps %xmm1, %xmm1
cvtsi2sd %rdx, %xmm1
jmp 0x67dbb
xorps %xmm0, %xmm0
cvtss2sd -0x170(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x67dfb
movswl %cx, %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
movw %cx, (%rax)
ucomisd %xmm1, %xmm0
setp %al
setne %cl
orb %al, %cl
movq 0x18(%r14), %rax
movb %cl, (%rax)
movq $0x2, 0x40(%r14)
jmp 0x67e03
movsbl %cl, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
setp %al
setne %cl
orb %al, %cl
movq 0x18(%r14), %rax
movb %cl, (%rax)
movq $0x1, 0x40(%r14)
jmp 0x67e03
cvtss2sd %xmm0, %xmm0
leaq -0x160(%rbp), %rsi
xorl %edx, %edx
callq 0x691cc
testb $0x40, 0x64(%r15)
jne 0x67d3a
movq %rax, %r15
jmp 0x67d9f
movq 0x38(%r15), %r15
movq %r15, %rdx
subq %rax, %rdx
setb %cl
cmpq $0x12c, %r15 # imm = 0x12C
setae %sil
orb %cl, %sil
jne 0x67e03
testq %rax, %rax
je 0x67d89
leaq -0x160(%rbp), %rsi
leaq (%rax,%rsi), %rcx
decq %rcx
negq %rax
addq %r15, %rsi
decq %rsi
xorl %edi, %edi
movb (%rcx,%rdi), %r8b
movb %r8b, (%rsi,%rdi)
decq %rdi
cmpq %rdi, %rax
jne 0x67d79
leaq -0x160(%rbp), %rdi
movl $0x12c, %ecx # imm = 0x12C
movl $0x30, %esi
callq 0x3aba0
leaq -0x160(%rbp), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x688c1
jmp 0x67e03
cvttps2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
movl %ecx, (%rax)
ucomisd %xmm1, %xmm0
setp %al
setne %cl
orb %al, %cl
movq 0x18(%r14), %rax
movb %cl, (%rax)
movq $0x4, 0x40(%r14)
jmp 0x67e03
cvttss2si %xmm1, %rcx
movq %rcx, (%rax)
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
ucomisd %xmm1, %xmm0
setp %al
setne %cl
orb %al, %cl
movq 0x18(%r14), %rax
movb %cl, (%rax)
movq $0x8, 0x40(%r14)
addq $0x4, (%rbx)
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x67e26
addq $0x150, %rsp # imm = 0x150
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3a340
|
ps_fetch_float:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 150h
mov rbx, rdx
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
mov r12d, [rdi+60h]
cmp r12d, 4
jnz short loc_67B52
mov rax, [r14+10h]
mov rcx, [rbx]
mov ecx, [rcx]
mov [rax], ecx
mov qword ptr [r14+40h], 4
mov rax, [r14+18h]
mov byte ptr [rax], 0
jmp loc_67E03
loc_67B52:
mov r15, rsi
mov rax, [rbx]
movss xmm1, dword ptr [rax]
xorps xmm0, xmm0
ucomiss xmm1, xmm0
movaps [rbp+var_170], xmm1
jbe short loc_67B79
movaps xmm0, xmm1
call _floorf
cvtss2sd xmm0, xmm0
jmp short loc_67B93
loc_67B79:
movaps xmm0, cs:xmmword_B8D90
xorps xmm0, xmm1
call _floorf
cvtss2sd xmm0, xmm0
xorps xmm0, cs:xmmword_B8DD0
loc_67B93:
dec r12d; switch 13 cases
cmp r12d, 0Ch
ja def_67BB2; jumptable 0000000000067BB2 default case, cases 4,6,7,9-12
mov rax, [r14+10h]
lea rcx, jpt_67BB2
movsxd rdx, ds:(jpt_67BB2 - 0C4560h)[rcx+r12*4]
add rdx, rcx
jmp rdx; switch jump
loc_67BB4:
cmp byte ptr [r14+65h], 0; jumptable 0000000000067BB2 cases 2,13
movaps xmm1, [rbp+var_170]
cvttss2si ecx, xmm1
jz loc_67CC7
movzx edx, cx
jmp loc_67CCA
loc_67BD2:
cmp byte ptr [r14+65h], 0; jumptable 0000000000067BB2 case 8
movaps xmm1, [rbp+var_170]
jz loc_67DD9
cvttss2si rcx, xmm1
mov rdx, rcx
subss xmm1, cs:dword_B8004
cvttss2si rsi, xmm1
sar rdx, 3Fh
and rsi, rdx
or rsi, rcx
movq xmm2, rsi
punpckldq xmm2, cs:xmmword_B8DB0
subpd xmm2, cs:xmmword_B8DC0
mov [rax], rsi
movapd xmm1, xmm2
unpckhpd xmm1, xmm2
addsd xmm1, xmm2
jmp loc_67DE9
loc_67C2C:
cvttss2si ecx, dword ptr [rbp+var_170]; jumptable 0000000000067BB2 case 1
mov [rax], cl
cmp byte ptr [r14+65h], 0
jz loc_67CF3
movzx eax, cl
jmp loc_67CF6
def_67BB2:
mov edi, [r15+68h]; jumptable 0000000000067BB2 default case, cases 4,6,7,9-12
cmp edi, 1Fh
movaps xmm0, [rbp+var_170]
jb loc_67D1C
mov rax, [r14+40h]
mov esi, 12Bh
cmp rax, rsi
cmovb rsi, rax
cvtss2sd xmm0, xmm0
lea rdx, [rbp+var_160]
xor edi, edi
xor ecx, ecx
call ma_gcvt
jmp loc_67D2E
loc_67C86:
cmp byte ptr [r14+65h], 0; jumptable 0000000000067BB2 case 3
movaps xmm1, [rbp+var_170]
cvttss2si ecx, xmm1
cvttss2si rdx, xmm1
cmovnz ecx, edx
jz loc_67DB3
mov edx, edx
xorps xmm1, xmm1
cvtsi2sd xmm1, rdx
jmp loc_67DBB
loc_67CB3:
xorps xmm0, xmm0; jumptable 0000000000067BB2 case 5
cvtss2sd xmm0, dword ptr [rbp+var_170]
movsd qword ptr [rax], xmm0
jmp loc_67DFB
loc_67CC7:
movsx edx, cx
loc_67CCA:
xorps xmm1, xmm1
cvtsi2sd xmm1, edx
mov [rax], cx
ucomisd xmm0, xmm1
setp al
setnz cl
or cl, al
mov rax, [r14+18h]
mov [rax], cl
mov qword ptr [r14+40h], 2
jmp loc_67E03
loc_67CF3:
movsx eax, cl
loc_67CF6:
xorps xmm1, xmm1
cvtsi2sd xmm1, eax
ucomisd xmm0, xmm1
setp al
setnz cl
or cl, al
mov rax, [r14+18h]
mov [rax], cl
mov qword ptr [r14+40h], 1
jmp loc_67E03
loc_67D1C:
cvtss2sd xmm0, xmm0
lea rsi, [rbp+var_160]
xor edx, edx
call ma_fcvt
loc_67D2E:
test byte ptr [r15+64h], 40h
jnz short loc_67D3A
mov r15, rax
jmp short loc_67D9F
loc_67D3A:
mov r15, [r15+38h]
mov rdx, r15
sub rdx, rax
setb cl
cmp r15, 12Ch
setnb sil
or sil, cl
jnz loc_67E03
test rax, rax
jz short loc_67D89
lea rsi, [rbp+var_160]
lea rcx, [rax+rsi]
dec rcx
neg rax
add rsi, r15
dec rsi
xor edi, edi
loc_67D79:
mov r8b, [rcx+rdi]
mov [rsi+rdi], r8b
dec rdi
cmp rax, rdi
jnz short loc_67D79
loc_67D89:
lea rdi, [rbp+var_160]
mov ecx, 12Ch
mov esi, 30h ; '0'
call ___memset_chk
loc_67D9F:
lea rsi, [rbp+var_160]
mov rdi, r14
mov rdx, r15
call convert_froma_string
jmp short loc_67E03
loc_67DB3:
cvttps2dq xmm1, xmm1
cvtdq2pd xmm1, xmm1
loc_67DBB:
mov [rax], ecx
ucomisd xmm0, xmm1
setp al
setnz cl
or cl, al
mov rax, [r14+18h]
mov [rax], cl
mov qword ptr [r14+40h], 4
jmp short loc_67E03
loc_67DD9:
cvttss2si rcx, xmm1
mov [rax], rcx
xorps xmm1, xmm1
cvtsi2sd xmm1, rcx
loc_67DE9:
ucomisd xmm0, xmm1
setp al
setnz cl
or cl, al
mov rax, [r14+18h]
mov [rax], cl
loc_67DFB:
mov qword ptr [r14+40h], 8
loc_67E03:
add qword ptr [rbx], 4
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_67E26
add rsp, 150h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_67E26:
call ___stack_chk_fail
|
unsigned long long ps_fetch_float(long long a1, long long a2, _DWORD **a3)
{
int v5; // r12d
double v7; // xmm1_8
double v8; // xmm0_8
_BYTE *v9; // rax
int v10; // ecx
int v11; // edx
__m128d v12; // xmm2
double v13; // xmm1_8
int v14; // ecx
int v15; // eax
long long v16; // rdi
long long v17; // rsi
unsigned long long v18; // rax
int v19; // ecx
double v20; // xmm1_8
unsigned long long v21; // r15
unsigned long long v22; // rdx
_BYTE *v23; // rcx
long long v24; // rax
long long v25; // rdi
long long v26; // rcx
__m128 v28; // [rsp+0h] [rbp-170h]
_BYTE v29[312]; // [rsp+10h] [rbp-160h] BYREF
unsigned long long v30; // [rsp+148h] [rbp-28h]
v30 = __readfsqword(0x28u);
v5 = *(_DWORD *)(a1 + 96);
if ( v5 == 4 )
{
**(_DWORD **)(a1 + 16) = **a3;
*(_QWORD *)(a1 + 64) = 4LL;
**(_BYTE **)(a1 + 24) = 0;
}
else
{
*(_QWORD *)&v7 = (unsigned int)**a3;
v28 = (__m128)(unsigned int)**a3;
if ( *(float *)&v7 <= 0.0 )
v8 = -floorf(COERCE_DOUBLE(*(_QWORD *)&v7 ^ 0x8000000080000000LL));
else
v8 = floorf(v7);
v9 = *(_BYTE **)(a1 + 16);
switch ( v5 )
{
case 1:
v14 = (int)v28.m128_f32[0];
*v9 = (int)v28.m128_f32[0];
if ( *(_BYTE *)(a1 + 101) )
v15 = (unsigned __int8)v14;
else
v15 = (char)v14;
**(_BYTE **)(a1 + 24) = v8 != (double)v15;
*(_QWORD *)(a1 + 64) = 1LL;
break;
case 2:
case 13:
v10 = (int)v28.m128_f32[0];
if ( *(_BYTE *)(a1 + 101) )
v11 = (unsigned __int16)v10;
else
v11 = (__int16)v10;
*(_WORD *)v9 = v10;
**(_BYTE **)(a1 + 24) = v8 != (double)v11;
*(_QWORD *)(a1 + 64) = 2LL;
break;
case 3:
v19 = (int)v28.m128_f32[0];
if ( *(_BYTE *)(a1 + 101) )
{
v19 = (int)v28.m128_f32[0];
v20 = (double)(int)v28.m128_f32[0];
}
else
{
*(_QWORD *)&v20 = *(_OWORD *)&_mm_cvtepi32_pd(_mm_cvttps_epi32(v28));
}
*(_DWORD *)v9 = v19;
**(_BYTE **)(a1 + 24) = v8 != v20;
*(_QWORD *)(a1 + 64) = 4LL;
break;
case 5:
*(double *)v9 = v28.m128_f32[0];
goto LABEL_37;
case 8:
if ( *(_BYTE *)(a1 + 101) )
{
v12 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32((__m128i)(unsigned int)(int)v28.m128_f32[0], (__m128i)xmmword_B8DB0),
(__m128d)xmmword_B8DC0);
*(_QWORD *)v9 = (unsigned int)(int)v28.m128_f32[0];
v13 = _mm_unpackhi_pd(v12, v12).m128d_f64[0] + v12.m128d_f64[0];
}
else
{
v26 = (unsigned int)(int)v28.m128_f32[0];
*(_QWORD *)v9 = v26;
v13 = (double)(int)v26;
}
**(_BYTE **)(a1 + 24) = v8 != v13;
LABEL_37:
*(_QWORD *)(a1 + 64) = 8LL;
break;
default:
v16 = *(unsigned int *)(a2 + 104);
if ( (unsigned int)v16 < 0x1F )
{
v18 = ma_fcvt(v16, v29, 0LL, v28.m128_f32[0]);
}
else
{
v17 = 299LL;
if ( *(_QWORD *)(a1 + 64) < 0x12BuLL )
v17 = *(_QWORD *)(a1 + 64);
v18 = ma_gcvt(0LL, v17, v29, 0LL, v28.m128_f32[0]);
}
if ( (*(_BYTE *)(a2 + 100) & 0x40) != 0 )
{
v21 = *(_QWORD *)(a2 + 56);
v22 = v21 - v18;
if ( v21 < v18 || v21 >= 0x12C )
break;
if ( v18 )
{
v23 = &v29[v18 - 1];
v24 = -(long long)v18;
v25 = 0LL;
do
{
v29[v21 - 1 + v25] = v23[v25];
--v25;
}
while ( v24 != v25 );
}
__memset_chk(v29, 48LL, v22, 300LL);
}
else
{
v21 = v18;
}
convert_froma_string(a1, v29, v21);
break;
}
}
++*a3;
return __readfsqword(0x28u);
}
|
ps_fetch_float:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x150
MOV RBX,RDX
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV R12D,dword ptr [RDI + 0x60]
CMP R12D,0x4
JNZ 0x00167b52
MOV RAX,qword ptr [R14 + 0x10]
MOV RCX,qword ptr [RBX]
MOV ECX,dword ptr [RCX]
MOV dword ptr [RAX],ECX
MOV qword ptr [R14 + 0x40],0x4
MOV RAX,qword ptr [R14 + 0x18]
MOV byte ptr [RAX],0x0
JMP 0x00167e03
LAB_00167b52:
MOV R15,RSI
MOV RAX,qword ptr [RBX]
MOVSS XMM1,dword ptr [RAX]
XORPS XMM0,XMM0
UCOMISS XMM1,XMM0
MOVAPS xmmword ptr [RBP + -0x170],XMM1
JBE 0x00167b79
MOVAPS XMM0,XMM1
CALL 0x0013a930
CVTSS2SD XMM0,XMM0
JMP 0x00167b93
LAB_00167b79:
MOVAPS XMM0,xmmword ptr [0x001b8d90]
XORPS XMM0,XMM1
CALL 0x0013a930
CVTSS2SD XMM0,XMM0
XORPS XMM0,xmmword ptr [0x001b8dd0]
LAB_00167b93:
DEC R12D
CMP R12D,0xc
JA 0x00167c49
MOV RAX,qword ptr [R14 + 0x10]
LEA RCX,[0x1c4560]
MOVSXD RDX,dword ptr [RCX + R12*0x4]
ADD RDX,RCX
switchD:
JMP RDX
caseD_2:
CMP byte ptr [R14 + 0x65],0x0
MOVAPS XMM1,xmmword ptr [RBP + -0x170]
CVTTSS2SI ECX,XMM1
JZ 0x00167cc7
MOVZX EDX,CX
JMP 0x00167cca
caseD_8:
CMP byte ptr [R14 + 0x65],0x0
MOVAPS XMM1,xmmword ptr [RBP + -0x170]
JZ 0x00167dd9
CVTTSS2SI RCX,XMM1
MOV RDX,RCX
SUBSS XMM1,dword ptr [0x001b8004]
CVTTSS2SI RSI,XMM1
SAR RDX,0x3f
AND RSI,RDX
OR RSI,RCX
MOVQ XMM2,RSI
PUNPCKLDQ XMM2,xmmword ptr [0x001b8db0]
SUBPD XMM2,xmmword ptr [0x001b8dc0]
MOV qword ptr [RAX],RSI
MOVAPD XMM1,XMM2
UNPCKHPD XMM1,XMM2
ADDSD XMM1,XMM2
JMP 0x00167de9
caseD_1:
CVTTSS2SI ECX,dword ptr [RBP + -0x170]
MOV byte ptr [RAX],CL
CMP byte ptr [R14 + 0x65],0x0
JZ 0x00167cf3
MOVZX EAX,CL
JMP 0x00167cf6
caseD_4:
MOV EDI,dword ptr [R15 + 0x68]
CMP EDI,0x1f
MOVAPS XMM0,xmmword ptr [RBP + -0x170]
JC 0x00167d1c
MOV RAX,qword ptr [R14 + 0x40]
MOV ESI,0x12b
CMP RAX,RSI
CMOVC RSI,RAX
CVTSS2SD XMM0,XMM0
LEA RDX,[RBP + -0x160]
XOR EDI,EDI
XOR ECX,ECX
CALL 0x0016a7a9
JMP 0x00167d2e
caseD_3:
CMP byte ptr [R14 + 0x65],0x0
MOVAPS XMM1,xmmword ptr [RBP + -0x170]
CVTTSS2SI ECX,XMM1
CVTTSS2SI RDX,XMM1
CMOVNZ ECX,EDX
JZ 0x00167db3
MOV EDX,EDX
XORPS XMM1,XMM1
CVTSI2SD XMM1,RDX
JMP 0x00167dbb
caseD_5:
XORPS XMM0,XMM0
CVTSS2SD XMM0,dword ptr [RBP + -0x170]
MOVSD qword ptr [RAX],XMM0
JMP 0x00167dfb
LAB_00167cc7:
MOVSX EDX,CX
LAB_00167cca:
XORPS XMM1,XMM1
CVTSI2SD XMM1,EDX
MOV word ptr [RAX],CX
UCOMISD XMM0,XMM1
SETP AL
SETNZ CL
OR CL,AL
MOV RAX,qword ptr [R14 + 0x18]
MOV byte ptr [RAX],CL
MOV qword ptr [R14 + 0x40],0x2
JMP 0x00167e03
LAB_00167cf3:
MOVSX EAX,CL
LAB_00167cf6:
XORPS XMM1,XMM1
CVTSI2SD XMM1,EAX
UCOMISD XMM0,XMM1
SETP AL
SETNZ CL
OR CL,AL
MOV RAX,qword ptr [R14 + 0x18]
MOV byte ptr [RAX],CL
MOV qword ptr [R14 + 0x40],0x1
JMP 0x00167e03
LAB_00167d1c:
CVTSS2SD XMM0,XMM0
LEA RSI,[RBP + -0x160]
XOR EDX,EDX
CALL 0x001691cc
LAB_00167d2e:
TEST byte ptr [R15 + 0x64],0x40
JNZ 0x00167d3a
MOV R15,RAX
JMP 0x00167d9f
LAB_00167d3a:
MOV R15,qword ptr [R15 + 0x38]
MOV RDX,R15
SUB RDX,RAX
SETC CL
CMP R15,0x12c
SETNC SIL
OR SIL,CL
JNZ 0x00167e03
TEST RAX,RAX
JZ 0x00167d89
LEA RSI,[RBP + -0x160]
LEA RCX,[RAX + RSI*0x1]
DEC RCX
NEG RAX
ADD RSI,R15
DEC RSI
XOR EDI,EDI
LAB_00167d79:
MOV R8B,byte ptr [RCX + RDI*0x1]
MOV byte ptr [RSI + RDI*0x1],R8B
DEC RDI
CMP RAX,RDI
JNZ 0x00167d79
LAB_00167d89:
LEA RDI,[RBP + -0x160]
MOV ECX,0x12c
MOV ESI,0x30
CALL 0x0013aba0
LAB_00167d9f:
LEA RSI,[RBP + -0x160]
MOV RDI,R14
MOV RDX,R15
CALL 0x001688c1
JMP 0x00167e03
LAB_00167db3:
CVTTPS2DQ XMM1,XMM1
CVTDQ2PD XMM1,XMM1
LAB_00167dbb:
MOV dword ptr [RAX],ECX
UCOMISD XMM0,XMM1
SETP AL
SETNZ CL
OR CL,AL
MOV RAX,qword ptr [R14 + 0x18]
MOV byte ptr [RAX],CL
MOV qword ptr [R14 + 0x40],0x4
JMP 0x00167e03
LAB_00167dd9:
CVTTSS2SI RCX,XMM1
MOV qword ptr [RAX],RCX
XORPS XMM1,XMM1
CVTSI2SD XMM1,RCX
LAB_00167de9:
UCOMISD XMM0,XMM1
SETP AL
SETNZ CL
OR CL,AL
MOV RAX,qword ptr [R14 + 0x18]
MOV byte ptr [RAX],CL
LAB_00167dfb:
MOV qword ptr [R14 + 0x40],0x8
LAB_00167e03:
ADD qword ptr [RBX],0x4
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x00167e26
ADD RSP,0x150
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00167e26:
CALL 0x0013a340
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ps_fetch_float(long param_1,long param_2,long *param_3)
{
double *pdVar1;
ulong uVar2;
ulong uVar3;
char cVar4;
short sVar5;
int iVar6;
uint uVar7;
double dVar8;
long lVar9;
long in_FS_OFFSET;
float fVar10;
double dVar11;
double dVar12;
int1 auVar13 [16];
double dVar14;
int1 local_178 [16];
int1 local_168 [312];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar6 = *(int *)(param_1 + 0x60);
if (iVar6 == 4) {
**(int4 **)(param_1 + 0x10) = *(int4 *)*param_3;
*(int8 *)(param_1 + 0x40) = 4;
**(int1 **)(param_1 + 0x18) = 0;
goto LAB_00167e03;
}
fVar10 = *(float *)*param_3;
local_178 = ZEXT416((uint)fVar10);
if (fVar10 <= 0.0) {
fVar10 = floorf((float)(_DAT_001b8d90 ^ (uint)fVar10));
dVar11 = (double)CONCAT44((uint)((ulong)(double)fVar10 >> 0x20) ^ _UNK_001b8dd4,
SUB84((double)fVar10,0) ^ _DAT_001b8dd0);
}
else {
fVar10 = floorf(fVar10);
dVar11 = (double)fVar10;
}
if (0xc < iVar6 - 1U) {
switchD_00167bb2_caseD_4:
if (*(uint *)(param_2 + 0x68) < 0x1f) {
uVar3 = ma_fcvt((double)(float)local_178._0_4_,*(uint *)(param_2 + 0x68),local_168,0);
}
else {
uVar3 = 299;
if (*(ulong *)(param_1 + 0x40) < 299) {
uVar3 = *(ulong *)(param_1 + 0x40);
}
uVar3 = ma_gcvt((double)(float)local_178._0_4_,0,uVar3,local_168,0);
}
if ((*(byte *)(param_2 + 100) & 0x40) != 0) {
uVar2 = *(ulong *)(param_2 + 0x38);
if (299 < uVar2 || uVar2 < uVar3) goto LAB_00167e03;
if (uVar3 != 0) {
lVar9 = 0;
do {
local_178[lVar9 + uVar2 + 0xf] = local_178[lVar9 + uVar3 + 0xf];
lVar9 = lVar9 + -1;
} while (-lVar9 != uVar3);
}
__memset_chk(local_168,0x30,uVar2 - uVar3,300);
uVar3 = uVar2;
}
convert_froma_string(param_1,local_168,uVar3);
goto LAB_00167e03;
}
pdVar1 = *(double **)(param_1 + 0x10);
switch(iVar6) {
case 1:
cVar4 = (char)(int)(float)local_178._0_4_;
*(char *)pdVar1 = cVar4;
if (*(char *)(param_1 + 0x65) == '\0') {
uVar7 = (uint)cVar4;
}
else {
uVar7 = (int)(float)local_178._0_4_ & 0xff;
}
*(bool *)*(int8 *)(param_1 + 0x18) = dVar11 != (double)(int)uVar7;
*(int8 *)(param_1 + 0x40) = 1;
break;
case 2:
case 0xd:
sVar5 = (short)(int)(float)local_178._0_4_;
if (*(char *)(param_1 + 0x65) == '\0') {
uVar7 = (uint)sVar5;
}
else {
uVar7 = (int)(float)local_178._0_4_ & 0xffff;
}
*(short *)pdVar1 = sVar5;
*(bool *)*(int8 *)(param_1 + 0x18) = dVar11 != (double)(int)uVar7;
*(int8 *)(param_1 + 0x40) = 2;
break;
case 3:
iVar6 = (int)(float)local_178._0_4_;
if (*(char *)(param_1 + 0x65) == '\0') {
dVar14 = (double)(int)(float)local_178._0_4_;
}
else {
iVar6 = (int)(long)(float)local_178._0_4_;
dVar14 = (double)((long)(float)local_178._0_4_ & 0xffffffff);
}
*(int *)pdVar1 = iVar6;
*(bool *)*(int8 *)(param_1 + 0x18) = dVar11 != dVar14;
*(int8 *)(param_1 + 0x40) = 4;
break;
default:
goto switchD_00167bb2_caseD_4;
case 5:
*pdVar1 = (double)(float)local_178._0_4_;
goto LAB_00167dfb;
case 8:
if (*(char *)(param_1 + 0x65) == '\0') {
*pdVar1 = (double)(long)(float)local_178._0_4_;
dVar14 = (double)(long)(float)local_178._0_4_;
}
else {
dVar8 = (double)((long)((float)local_178._0_4_ - _DAT_001b8004) &
(long)(float)local_178._0_4_ >> 0x3f | (long)(float)local_178._0_4_);
auVar13._8_4_ = (int)((ulong)dVar8 >> 0x20);
auVar13._0_8_ = dVar8;
auVar13._12_4_ = _UNK_001b8db4;
dVar12 = (double)CONCAT44(_DAT_001b8db0,SUB84(dVar8,0)) - _DAT_001b8dc0;
dVar14 = auVar13._8_8_ - _UNK_001b8dc8;
*pdVar1 = dVar8;
dVar14 = dVar14 + dVar12;
}
*(bool *)*(int8 *)(param_1 + 0x18) = dVar11 != dVar14;
LAB_00167dfb:
*(int8 *)(param_1 + 0x40) = 8;
}
LAB_00167e03:
*param_3 = *param_3 + 4;
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
17,205
|
find_line_num
|
bluesky950520[P]quickjs/quickjs.c
|
static int find_line_num(JSContext *ctx, JSFunctionBytecode *b,
uint32_t pc_value, int *col)
{
const uint8_t *p_end, *p;
int new_line_num, new_col_num, line_num, col_num, pc, v, ret;
unsigned int op;
*col = 1;
p = b->pc2line_buf;
if (!p)
goto fail;
p_end = p + b->pc2line_len;
pc = 0;
line_num = b->line_num;
col_num = b->col_num;
while (p < p_end) {
op = *p++;
if (op == 0) {
uint32_t val;
ret = get_leb128(&val, p, p_end);
if (ret < 0)
goto fail;
pc += val;
p += ret;
ret = get_sleb128(&v, p, p_end);
if (ret < 0)
goto fail;
p += ret;
new_line_num = line_num + v;
} else {
op -= PC2LINE_OP_FIRST;
pc += (op / PC2LINE_RANGE);
new_line_num = line_num + (op % PC2LINE_RANGE) + PC2LINE_BASE;
}
ret = get_sleb128(&v, p, p_end);
if (ret < 0)
goto fail;
p += ret;
new_col_num = col_num + v;
if (pc_value < pc)
break;
line_num = new_line_num;
col_num = new_col_num;
}
*col = col_num;
return line_num;
fail:
/* should never happen */
return b->line_num;
}
|
O1
|
c
|
find_line_num:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq %rdx, 0x20(%rsp)
movl $0x1, (%rdx)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x428af
movslq 0x78(%r14), %r15
movl 0x6c(%r14), %ecx
movl 0x70(%r14), %ebp
testq %r15, %r15
jle 0x428b5
movl %esi, %ebx
movq %rcx, 0x18(%rsp)
addq %rax, %r15
movl $0x0, 0xc(%rsp)
leaq 0x1(%rax), %r12
movzbl (%rax), %ecx
testl %ecx, %ecx
jne 0x4283e
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %r15, %r12
jae 0x427ed
addq $0x2, %rax
xorl %ecx, %ecx
xorl %edi, %edi
xorl %esi, %esi
movl %esi, %r8d
movzbl -0x1(%rax), %r9d
movl %r9d, %esi
andl $0x7f, %esi
shll %cl, %esi
orl %r8d, %esi
testb %r9b, %r9b
jns 0x4289b
cmpl $0x3, %edi
ja 0x427ed
incl %edi
addl $0x7, %ecx
leaq 0x1(%rax), %r8
cmpq %r15, %rax
movq %r8, %rax
jb 0x427bb
xorl %esi, %esi
testl %edx, %edx
jns 0x42867
xorl %eax, %eax
testb %al, %al
je 0x428af
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x10cdf
testl %eax, %eax
js 0x428af
cmpl %ebx, 0xc(%rsp)
ja 0x428d1
addl 0x10(%rsp), %ebp
movl %eax, %eax
addq %rax, %r12
movl %r13d, %eax
movq %rax, 0x18(%rsp)
movq %r12, %rax
cmpq %r15, %r12
jb 0x42798
jmp 0x428b8
decl %ecx
movq %rcx, %rax
movl $0xcccccccd, %edx # imm = 0xCCCCCCCD
imulq %rdx, %rax
shrq $0x22, %rax
addl %eax, 0xc(%rsp)
leal (%rax,%rax,4), %eax
subl %eax, %ecx
movq 0x18(%rsp), %rax
leal (%rax,%rcx), %r13d
decl %r13d
jmp 0x427fd
movl %ebx, 0x14(%rsp)
addl %esi, 0xc(%rsp)
movl %edx, %eax
addq %rax, %r12
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x10cdf
testl %eax, %eax
js 0x428a4
movl %eax, %eax
addq %rax, %r12
movl 0x10(%rsp), %r13d
addl 0x18(%rsp), %r13d
movb $0x1, %al
jmp 0x428a6
incl %edi
movl %edi, %edx
jmp 0x427ef
xorl %eax, %eax
movl 0x14(%rsp), %ebx
jmp 0x427f5
movl 0x6c(%r14), %r13d
jmp 0x428bf
movl %ecx, %r13d
movq 0x20(%rsp), %rax
movl %ebp, (%rax)
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rsp), %rax
movl %eax, %r13d
jmp 0x428b8
|
find_line_num:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdi
mov [rsp+58h+var_38], rdx
mov dword ptr [rdx], 1
mov rax, [rdi+80h]
test rax, rax
jz loc_428AF
movsxd r15, dword ptr [r14+78h]
mov ecx, [r14+6Ch]
mov ebp, [r14+70h]
test r15, r15
jle loc_428B5
mov ebx, esi
mov [rsp+58h+var_40], rcx
add r15, rax
mov [rsp+58h+var_4C], 0
loc_42798:
lea r12, [rax+1]
movzx ecx, byte ptr [rax]
test ecx, ecx
jnz loc_4283E
mov edx, 0FFFFFFFFh
cmp r12, r15
jnb short loc_427ED
add rax, 2
xor ecx, ecx
xor edi, edi
xor esi, esi
loc_427BB:
mov r8d, esi
movzx r9d, byte ptr [rax-1]
mov esi, r9d
and esi, 7Fh
shl esi, cl
or esi, r8d
test r9b, r9b
jns loc_4289B
cmp edi, 3
ja short loc_427ED
inc edi
add ecx, 7
lea r8, [rax+1]
cmp rax, r15
mov rax, r8
jb short loc_427BB
loc_427ED:
xor esi, esi
loc_427EF:
test edx, edx
jns short loc_42867
xor eax, eax
loc_427F5:
test al, al
jz loc_428AF
loc_427FD:
lea rdi, [rsp+58h+var_48]
mov rsi, r12
mov rdx, r15
call get_sleb128
test eax, eax
js loc_428AF
cmp [rsp+58h+var_4C], ebx
ja loc_428D1
add ebp, [rsp+58h+var_48]
mov eax, eax
add r12, rax
mov eax, r13d
mov [rsp+58h+var_40], rax
mov rax, r12
cmp r12, r15
jb loc_42798
jmp short loc_428B8
loc_4283E:
dec ecx
mov rax, rcx
mov edx, 0CCCCCCCDh
imul rax, rdx
shr rax, 22h
add [rsp+58h+var_4C], eax
lea eax, [rax+rax*4]
sub ecx, eax
mov rax, [rsp+58h+var_40]
lea r13d, [rax+rcx]
dec r13d
jmp short loc_427FD
loc_42867:
mov [rsp+58h+var_44], ebx
add [rsp+58h+var_4C], esi
mov eax, edx
add r12, rax
lea rdi, [rsp+58h+var_48]
mov rsi, r12
mov rdx, r15
call get_sleb128
test eax, eax
js short loc_428A4
mov eax, eax
add r12, rax
mov r13d, [rsp+58h+var_48]
add r13d, dword ptr [rsp+58h+var_40]
mov al, 1
jmp short loc_428A6
loc_4289B:
inc edi
mov edx, edi
jmp loc_427EF
loc_428A4:
xor eax, eax
loc_428A6:
mov ebx, [rsp+58h+var_44]
jmp loc_427F5
loc_428AF:
mov r13d, [r14+6Ch]
jmp short loc_428BF
loc_428B5:
mov r13d, ecx
loc_428B8:
mov rax, [rsp+58h+var_38]
mov [rax], ebp
loc_428BF:
mov eax, r13d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_428D1:
mov rax, [rsp+58h+var_40]
mov r13d, eax
jmp short loc_428B8
|
long long find_line_num(long long a1, unsigned int a2, _DWORD *a3)
{
unsigned int v3; // r13d
_BYTE *v5; // rax
long long v6; // r15
int v7; // ebp
unsigned long long v9; // r15
unsigned long long v10; // r12
int v11; // edx
_BYTE *v12; // rax
char v13; // cl
unsigned int v14; // edi
int v15; // esi
char v17; // al
int v18; // eax
unsigned int v19; // ecx
int sleb128; // eax
unsigned int v22; // [rsp+Ch] [rbp-4Ch]
int v23; // [rsp+10h] [rbp-48h] BYREF
unsigned int v24; // [rsp+14h] [rbp-44h]
long long v25; // [rsp+18h] [rbp-40h]
_DWORD *v26; // [rsp+20h] [rbp-38h]
v26 = a3;
*a3 = 1;
v5 = *(_BYTE **)(a1 + 128);
if ( v5 )
{
v6 = *(int *)(a1 + 120);
v7 = *(_DWORD *)(a1 + 112);
if ( v6 <= 0 )
{
v3 = *(_DWORD *)(a1 + 108);
}
else
{
v25 = *(unsigned int *)(a1 + 108);
v9 = (unsigned long long)&v5[v6];
v22 = 0;
while ( 1 )
{
v10 = (unsigned long long)(v5 + 1);
if ( *v5 )
{
v19 = (unsigned __int8)*v5 - 1;
v22 += v19 / 5;
v3 = v25 + v19 % 5 - 1;
}
else
{
v11 = -1;
if ( v10 >= v9 )
{
LABEL_10:
v15 = 0;
}
else
{
v12 = v5 + 2;
v13 = 0;
v14 = 0;
v15 = 0;
while ( 1 )
{
v15 |= (*(v12 - 1) & 0x7F) << v13;
if ( (char)*(v12 - 1) >= 0 )
break;
if ( v14 <= 3 )
{
++v14;
v13 += 7;
if ( (unsigned long long)v12++ < v9 )
continue;
}
goto LABEL_10;
}
v11 = v14 + 1;
}
if ( v11 >= 0 )
{
v24 = a2;
v22 += v15;
v10 += (unsigned int)v11;
sleb128 = get_sleb128(&v23, v10, v9);
if ( sleb128 < 0 )
{
v17 = 0;
}
else
{
v10 += (unsigned int)sleb128;
v3 = v25 + v23;
v17 = 1;
}
a2 = v24;
}
else
{
v17 = 0;
}
if ( !v17 )
return *(unsigned int *)(a1 + 108);
}
v18 = get_sleb128(&v23, v10, v9);
if ( v18 < 0 )
return *(unsigned int *)(a1 + 108);
if ( v22 > a2 )
break;
v7 += v23;
v25 = v3;
v5 = (_BYTE *)((unsigned int)v18 + v10);
if ( (unsigned long long)v5 >= v9 )
goto LABEL_26;
}
v3 = v25;
}
LABEL_26:
*v26 = v7;
}
else
{
return *(unsigned int *)(a1 + 108);
}
return v3;
}
|
find_line_num:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDI
MOV qword ptr [RSP + 0x20],RDX
MOV dword ptr [RDX],0x1
MOV RAX,qword ptr [RDI + 0x80]
TEST RAX,RAX
JZ 0x001428af
MOVSXD R15,dword ptr [R14 + 0x78]
MOV ECX,dword ptr [R14 + 0x6c]
MOV EBP,dword ptr [R14 + 0x70]
TEST R15,R15
JLE 0x001428b5
MOV EBX,ESI
MOV qword ptr [RSP + 0x18],RCX
ADD R15,RAX
MOV dword ptr [RSP + 0xc],0x0
LAB_00142798:
LEA R12,[RAX + 0x1]
MOVZX ECX,byte ptr [RAX]
TEST ECX,ECX
JNZ 0x0014283e
MOV EDX,0xffffffff
CMP R12,R15
JNC 0x001427ed
ADD RAX,0x2
XOR ECX,ECX
XOR EDI,EDI
XOR ESI,ESI
LAB_001427bb:
MOV R8D,ESI
MOVZX R9D,byte ptr [RAX + -0x1]
MOV ESI,R9D
AND ESI,0x7f
SHL ESI,CL
OR ESI,R8D
TEST R9B,R9B
JNS 0x0014289b
CMP EDI,0x3
JA 0x001427ed
INC EDI
ADD ECX,0x7
LEA R8,[RAX + 0x1]
CMP RAX,R15
MOV RAX,R8
JC 0x001427bb
LAB_001427ed:
XOR ESI,ESI
LAB_001427ef:
TEST EDX,EDX
JNS 0x00142867
XOR EAX,EAX
LAB_001427f5:
TEST AL,AL
JZ 0x001428af
LAB_001427fd:
LEA RDI,[RSP + 0x10]
MOV RSI,R12
MOV RDX,R15
CALL 0x00110cdf
TEST EAX,EAX
JS 0x001428af
CMP dword ptr [RSP + 0xc],EBX
JA 0x001428d1
ADD EBP,dword ptr [RSP + 0x10]
MOV EAX,EAX
ADD R12,RAX
MOV EAX,R13D
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,R12
CMP R12,R15
JC 0x00142798
JMP 0x001428b8
LAB_0014283e:
DEC ECX
MOV RAX,RCX
MOV EDX,0xcccccccd
IMUL RAX,RDX
SHR RAX,0x22
ADD dword ptr [RSP + 0xc],EAX
LEA EAX,[RAX + RAX*0x4]
SUB ECX,EAX
MOV RAX,qword ptr [RSP + 0x18]
LEA R13D,[RAX + RCX*0x1]
DEC R13D
JMP 0x001427fd
LAB_00142867:
MOV dword ptr [RSP + 0x14],EBX
ADD dword ptr [RSP + 0xc],ESI
MOV EAX,EDX
ADD R12,RAX
LEA RDI,[RSP + 0x10]
MOV RSI,R12
MOV RDX,R15
CALL 0x00110cdf
TEST EAX,EAX
JS 0x001428a4
MOV EAX,EAX
ADD R12,RAX
MOV R13D,dword ptr [RSP + 0x10]
ADD R13D,dword ptr [RSP + 0x18]
MOV AL,0x1
JMP 0x001428a6
LAB_0014289b:
INC EDI
MOV EDX,EDI
JMP 0x001427ef
LAB_001428a4:
XOR EAX,EAX
LAB_001428a6:
MOV EBX,dword ptr [RSP + 0x14]
JMP 0x001427f5
LAB_001428af:
MOV R13D,dword ptr [R14 + 0x6c]
JMP 0x001428bf
LAB_001428b5:
MOV R13D,ECX
LAB_001428b8:
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX],EBP
LAB_001428bf:
MOV EAX,R13D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001428d1:
MOV RAX,qword ptr [RSP + 0x18]
MOV R13D,EAX
JMP 0x001428b8
|
ulong find_line_num(long param_1,uint param_2,int *param_3)
{
uint uVar1;
byte bVar2;
int iVar3;
uint uVar4;
uint uVar5;
byte *pbVar6;
byte *pbVar7;
ulong unaff_R13;
byte *pbVar8;
bool bVar9;
uint local_4c;
int local_48;
uint local_44;
ulong local_40;
int *local_38;
*param_3 = 1;
pbVar6 = *(byte **)(param_1 + 0x80);
if (pbVar6 == (byte *)0x0) {
LAB_001428af:
unaff_R13 = (ulong)*(uint *)(param_1 + 0x6c);
}
else {
local_40 = (ulong)*(uint *)(param_1 + 0x6c);
iVar3 = *(int *)(param_1 + 0x70);
local_38 = param_3;
if ((long)*(int *)(param_1 + 0x78) < 1) {
unaff_R13 = (ulong)*(uint *)(param_1 + 0x6c);
}
else {
pbVar8 = pbVar6 + *(int *)(param_1 + 0x78);
local_4c = 0;
do {
pbVar7 = pbVar6 + 1;
if (*pbVar6 == 0) {
uVar1 = 0xffffffff;
if (pbVar7 < pbVar8) {
bVar2 = 0;
uVar5 = 0;
uVar4 = 0;
pbVar6 = pbVar6 + 2;
do {
uVar4 = (pbVar6[-1] & 0x7f) << (bVar2 & 0x1f) | uVar4;
if (-1 < (char)pbVar6[-1]) {
uVar1 = uVar5 + 1;
goto LAB_001427ef;
}
if (3 < uVar5) break;
uVar5 = uVar5 + 1;
bVar2 = bVar2 + 7;
bVar9 = pbVar6 < pbVar8;
pbVar6 = pbVar6 + 1;
} while (bVar9);
}
uVar4 = 0;
LAB_001427ef:
if ((int)uVar1 < 0) {
bVar9 = false;
}
else {
local_4c = local_4c + uVar4;
pbVar7 = pbVar7 + uVar1;
local_44 = param_2;
uVar1 = get_sleb128(&local_48,pbVar7,pbVar8);
bVar9 = -1 < (int)uVar1;
param_2 = local_44;
if (bVar9) {
pbVar7 = pbVar7 + uVar1;
unaff_R13 = (ulong)(uint)(local_48 + (int)local_40);
}
}
if (!bVar9) goto LAB_001428af;
}
else {
uVar1 = *pbVar6 - 1;
local_4c = local_4c + uVar1 / 5;
unaff_R13 = (ulong)(((int)local_40 + uVar1 % 5) - 1);
}
uVar1 = get_sleb128(&local_48,pbVar7,pbVar8);
if ((int)uVar1 < 0) goto LAB_001428af;
if (param_2 < local_4c) {
unaff_R13 = local_40 & 0xffffffff;
break;
}
iVar3 = iVar3 + local_48;
pbVar6 = pbVar7 + uVar1;
local_40 = unaff_R13 & 0xffffffff;
} while (pbVar6 < pbVar8);
}
*local_38 = iVar3;
}
return unaff_R13 & 0xffffffff;
}
|
|
17,206
|
find_line_num
|
bluesky950520[P]quickjs/quickjs.c
|
static int find_line_num(JSContext *ctx, JSFunctionBytecode *b,
uint32_t pc_value, int *col)
{
const uint8_t *p_end, *p;
int new_line_num, new_col_num, line_num, col_num, pc, v, ret;
unsigned int op;
*col = 1;
p = b->pc2line_buf;
if (!p)
goto fail;
p_end = p + b->pc2line_len;
pc = 0;
line_num = b->line_num;
col_num = b->col_num;
while (p < p_end) {
op = *p++;
if (op == 0) {
uint32_t val;
ret = get_leb128(&val, p, p_end);
if (ret < 0)
goto fail;
pc += val;
p += ret;
ret = get_sleb128(&v, p, p_end);
if (ret < 0)
goto fail;
p += ret;
new_line_num = line_num + v;
} else {
op -= PC2LINE_OP_FIRST;
pc += (op / PC2LINE_RANGE);
new_line_num = line_num + (op % PC2LINE_RANGE) + PC2LINE_BASE;
}
ret = get_sleb128(&v, p, p_end);
if (ret < 0)
goto fail;
p += ret;
new_col_num = col_num + v;
if (pc_value < pc)
break;
line_num = new_line_num;
col_num = new_col_num;
}
*col = col_num;
return line_num;
fail:
/* should never happen */
return b->line_num;
}
|
O3
|
c
|
find_line_num:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x1, (%rdx)
movq 0x80(%rdi), %r13
testq %r13, %r13
je 0x444c6
movq %rdx, %r8
movslq 0x78(%r14), %r15
movl 0x6c(%r14), %edx
movl 0x70(%r14), %r9d
testq %r15, %r15
jle 0x444cc
movl %esi, %r10d
addq %r13, %r15
xorl %r11d, %r11d
leaq 0x1(%r13), %rbp
movb (%r13), %al
testb %al, %al
movq %rdx, 0x20(%rsp)
jne 0x44407
cmpq %r15, %rbp
jae 0x444c6
addq $0x2, %r13
xorl %ecx, %ecx
movl $0x1, %eax
xorl %edx, %edx
xorl %ebx, %ebx
movl %ebx, %esi
movzbl -0x1(%r13), %edi
movl %edi, %ebx
andl $0x7f, %ebx
shll %cl, %ebx
orl %esi, %ebx
testb %dil, %dil
jns 0x44483
cmpl $0x3, %edx
ja 0x444c6
incl %edx
addl $0x7, %ecx
leaq 0x1(%r13), %rsi
incq %rax
cmpq %r15, %r13
movq %rsi, %r13
jae 0x444c6
jmp 0x443cb
movl %r11d, 0xc(%rsp)
movl %r10d, 0x10(%rsp)
movl %r9d, 0x14(%rsp)
movq %r8, 0x18(%rsp)
decb %al
movzbl %al, %eax
imull $0xcd, %eax, %ebx
shrl $0xa, %ebx
leal (%rbx,%rbx,4), %ecx
subb %cl, %al
movzbl %al, %eax
leal (%rdx,%rax), %r12d
decl %r12d
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x11040
testl %eax, %eax
movq 0x18(%rsp), %r8
movl 0x14(%rsp), %r9d
movl 0x10(%rsp), %r10d
movl 0xc(%rsp), %r11d
js 0x444c6
addl %ebx, %r11d
cmpl %r10d, %r11d
ja 0x444e4
addl 0x8(%rsp), %r9d
movl %eax, %eax
addq %rax, %rbp
movl %r12d, %edx
movq %rbp, %r13
cmpq %r15, %rbp
jb 0x443a2
jmp 0x444cf
testl %eax, %eax
js 0x444c6
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r8, 0x18(%rsp)
movl %r9d, 0x14(%rsp)
movl %r10d, 0x10(%rsp)
movl %r11d, 0xc(%rsp)
callq 0x11040
testl %eax, %eax
js 0x444c6
movl %eax, %eax
addq %rax, %r13
movl 0x8(%rsp), %r12d
addl 0x20(%rsp), %r12d
movq %r13, %rbp
jmp 0x44438
movl 0x6c(%r14), %r12d
jmp 0x444d2
movl %edx, %r12d
movl %r9d, (%r8)
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %rax
movl %eax, %r12d
jmp 0x444cf
|
find_line_num:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdi
mov dword ptr [rdx], 1
mov r13, [rdi+80h]
test r13, r13
jz loc_444C6
mov r8, rdx
movsxd r15, dword ptr [r14+78h]
mov edx, [r14+6Ch]
mov r9d, [r14+70h]
test r15, r15
jle loc_444CC
mov r10d, esi
add r15, r13
xor r11d, r11d
loc_443A2:
lea rbp, [r13+1]
mov al, [r13+0]
test al, al
mov [rsp+58h+var_38], rdx
jnz short loc_44407
cmp rbp, r15
jnb loc_444C6
add r13, 2
xor ecx, ecx
mov eax, 1
xor edx, edx
xor ebx, ebx
loc_443CB:
mov esi, ebx
movzx edi, byte ptr [r13-1]
mov ebx, edi
and ebx, 7Fh
shl ebx, cl
or ebx, esi
test dil, dil
jns loc_44483
cmp edx, 3
ja loc_444C6
inc edx
add ecx, 7
lea rsi, [r13+1]
inc rax
cmp r13, r15
mov r13, rsi
jnb loc_444C6
jmp short loc_443CB
loc_44407:
mov [rsp+58h+var_4C], r11d
mov [rsp+58h+var_48], r10d
mov [rsp+58h+var_44], r9d
mov [rsp+58h+var_40], r8
dec al
movzx eax, al
imul ebx, eax, 0CDh
shr ebx, 0Ah
lea ecx, [rbx+rbx*4]
sub al, cl
movzx eax, al
lea r12d, [rdx+rax]
dec r12d
loc_44438:
lea rdi, [rsp+58h+var_50]
mov rsi, rbp
mov rdx, r15
call get_sleb128
test eax, eax
mov r8, [rsp+58h+var_40]
mov r9d, [rsp+58h+var_44]
mov r10d, [rsp+58h+var_48]
mov r11d, [rsp+58h+var_4C]
js short loc_444C6
add r11d, ebx
cmp r11d, r10d
ja short loc_444E4
add r9d, [rsp+58h+var_50]
mov eax, eax
add rbp, rax
mov edx, r12d
mov r13, rbp
cmp rbp, r15
jb loc_443A2
jmp short loc_444CF
loc_44483:
test eax, eax
js short loc_444C6
lea rdi, [rsp+58h+var_50]
mov rsi, r13
mov rdx, r15
mov [rsp+58h+var_40], r8
mov [rsp+58h+var_44], r9d
mov [rsp+58h+var_48], r10d
mov [rsp+58h+var_4C], r11d
call get_sleb128
test eax, eax
js short loc_444C6
mov eax, eax
add r13, rax
mov r12d, [rsp+58h+var_50]
add r12d, dword ptr [rsp+58h+var_38]
mov rbp, r13
jmp loc_44438
loc_444C6:
mov r12d, [r14+6Ch]
jmp short loc_444D2
loc_444CC:
mov r12d, edx
loc_444CF:
mov [r8], r9d
loc_444D2:
mov eax, r12d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_444E4:
mov rax, [rsp+58h+var_38]
mov r12d, eax
jmp short loc_444CF
|
long long find_line_num(long long a1, unsigned int a2, _DWORD *a3)
{
char *v3; // r13
_DWORD *v4; // r8
long long v5; // r15
long long v6; // rdx
int v7; // r9d
unsigned long long v9; // r15
int v10; // r11d
unsigned long long v11; // rbp
char v12; // al
bool v13; // zf
unsigned long long v14; // r13
char v15; // cl
int v16; // eax
unsigned int v17; // edx
unsigned int v18; // ebx
int v20; // eax
unsigned int v21; // r12d
int v22; // eax
int sleb128; // eax
int v25; // [rsp+8h] [rbp-50h] BYREF
int v26; // [rsp+Ch] [rbp-4Ch]
unsigned int v27; // [rsp+10h] [rbp-48h]
int v28; // [rsp+14h] [rbp-44h]
_DWORD *v29; // [rsp+18h] [rbp-40h]
long long v30; // [rsp+20h] [rbp-38h]
*a3 = 1;
v3 = *(char **)(a1 + 128);
if ( v3 )
{
v4 = a3;
v5 = *(int *)(a1 + 120);
v6 = *(unsigned int *)(a1 + 108);
v7 = *(_DWORD *)(a1 + 112);
if ( v5 <= 0 )
{
v21 = *(_DWORD *)(a1 + 108);
}
else
{
v9 = (unsigned long long)&v3[v5];
v10 = 0;
while ( 1 )
{
v11 = (unsigned long long)(v3 + 1);
v12 = *v3;
v13 = *v3 == 0;
v30 = v6;
if ( v13 )
{
if ( v11 >= v9 )
return *(unsigned int *)(a1 + 108);
v14 = (unsigned long long)(v3 + 2);
v15 = 0;
v16 = 1;
v17 = 0;
v18 = 0;
while ( 1 )
{
v18 |= (*(_BYTE *)(v14 - 1) & 0x7F) << v15;
if ( *(char *)(v14 - 1) >= 0 )
break;
if ( v17 <= 3 )
{
++v17;
v15 += 7;
++v16;
if ( v14++ < v9 )
continue;
}
return *(unsigned int *)(a1 + 108);
}
if ( v16 < 0 )
return *(unsigned int *)(a1 + 108);
v29 = v4;
v28 = v7;
v27 = a2;
v26 = v10;
sleb128 = get_sleb128(&v25, v14, v9);
if ( sleb128 < 0 )
return *(unsigned int *)(a1 + 108);
v21 = v30 + v25;
v11 = (unsigned int)sleb128 + v14;
}
else
{
v26 = v10;
v27 = a2;
v28 = v7;
v29 = v4;
v20 = (unsigned __int8)(v12 - 1);
v18 = (unsigned int)(205 * v20) >> 10;
v21 = v6 + (unsigned __int8)(v20 - 5 * v18) - 1;
}
v22 = get_sleb128(&v25, v11, v9);
v4 = v29;
v7 = v28;
a2 = v27;
if ( v22 < 0 )
return *(unsigned int *)(a1 + 108);
v10 = v18 + v26;
if ( v18 + v26 > v27 )
break;
v7 = v25 + v28;
v6 = v21;
v3 = (char *)((unsigned int)v22 + v11);
if ( (unsigned long long)v3 >= v9 )
goto LABEL_21;
}
v21 = v30;
}
LABEL_21:
*v4 = v7;
}
else
{
return *(unsigned int *)(a1 + 108);
}
return v21;
}
|
find_line_num:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDI
MOV dword ptr [RDX],0x1
MOV R13,qword ptr [RDI + 0x80]
TEST R13,R13
JZ 0x001444c6
MOV R8,RDX
MOVSXD R15,dword ptr [R14 + 0x78]
MOV EDX,dword ptr [R14 + 0x6c]
MOV R9D,dword ptr [R14 + 0x70]
TEST R15,R15
JLE 0x001444cc
MOV R10D,ESI
ADD R15,R13
XOR R11D,R11D
LAB_001443a2:
LEA RBP,[R13 + 0x1]
MOV AL,byte ptr [R13]
TEST AL,AL
MOV qword ptr [RSP + 0x20],RDX
JNZ 0x00144407
CMP RBP,R15
JNC 0x001444c6
ADD R13,0x2
XOR ECX,ECX
MOV EAX,0x1
XOR EDX,EDX
XOR EBX,EBX
LAB_001443cb:
MOV ESI,EBX
MOVZX EDI,byte ptr [R13 + -0x1]
MOV EBX,EDI
AND EBX,0x7f
SHL EBX,CL
OR EBX,ESI
TEST DIL,DIL
JNS 0x00144483
CMP EDX,0x3
JA 0x001444c6
INC EDX
ADD ECX,0x7
LEA RSI,[R13 + 0x1]
INC RAX
CMP R13,R15
MOV R13,RSI
JNC 0x001444c6
JMP 0x001443cb
LAB_00144407:
MOV dword ptr [RSP + 0xc],R11D
MOV dword ptr [RSP + 0x10],R10D
MOV dword ptr [RSP + 0x14],R9D
MOV qword ptr [RSP + 0x18],R8
DEC AL
MOVZX EAX,AL
IMUL EBX,EAX,0xcd
SHR EBX,0xa
LEA ECX,[RBX + RBX*0x4]
SUB AL,CL
MOVZX EAX,AL
LEA R12D,[RDX + RAX*0x1]
DEC R12D
LAB_00144438:
LEA RDI,[RSP + 0x8]
MOV RSI,RBP
MOV RDX,R15
CALL 0x00111040
TEST EAX,EAX
MOV R8,qword ptr [RSP + 0x18]
MOV R9D,dword ptr [RSP + 0x14]
MOV R10D,dword ptr [RSP + 0x10]
MOV R11D,dword ptr [RSP + 0xc]
JS 0x001444c6
ADD R11D,EBX
CMP R11D,R10D
JA 0x001444e4
ADD R9D,dword ptr [RSP + 0x8]
MOV EAX,EAX
ADD RBP,RAX
MOV EDX,R12D
MOV R13,RBP
CMP RBP,R15
JC 0x001443a2
JMP 0x001444cf
LAB_00144483:
TEST EAX,EAX
JS 0x001444c6
LEA RDI,[RSP + 0x8]
MOV RSI,R13
MOV RDX,R15
MOV qword ptr [RSP + 0x18],R8
MOV dword ptr [RSP + 0x14],R9D
MOV dword ptr [RSP + 0x10],R10D
MOV dword ptr [RSP + 0xc],R11D
CALL 0x00111040
TEST EAX,EAX
JS 0x001444c6
MOV EAX,EAX
ADD R13,RAX
MOV R12D,dword ptr [RSP + 0x8]
ADD R12D,dword ptr [RSP + 0x20]
MOV RBP,R13
JMP 0x00144438
LAB_001444c6:
MOV R12D,dword ptr [R14 + 0x6c]
JMP 0x001444d2
LAB_001444cc:
MOV R12D,EDX
LAB_001444cf:
MOV dword ptr [R8],R9D
LAB_001444d2:
MOV EAX,R12D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001444e4:
MOV RAX,qword ptr [RSP + 0x20]
MOV R12D,EAX
JMP 0x001444cf
|
uint find_line_num(long param_1,uint param_2,int *param_3)
{
byte bVar1;
int iVar2;
uint uVar3;
uint uVar4;
uint uVar5;
char *pcVar6;
char *pcVar7;
char *pcVar8;
bool bVar9;
int local_50;
uint local_4c;
uint local_48;
int local_44;
int *local_40;
ulong local_38;
*param_3 = 1;
pcVar6 = *(char **)(param_1 + 0x80);
if (pcVar6 == (char *)0x0) {
LAB_001444c6:
uVar4 = *(uint *)(param_1 + 0x6c);
}
else {
uVar4 = *(uint *)(param_1 + 0x6c);
local_44 = *(int *)(param_1 + 0x70);
local_40 = param_3;
if (0 < (long)*(int *)(param_1 + 0x78)) {
pcVar8 = pcVar6 + *(int *)(param_1 + 0x78);
local_4c = 0;
local_48 = param_2;
do {
local_38 = (ulong)uVar4;
pcVar7 = pcVar6 + 1;
local_40 = param_3;
if (*pcVar6 == '\0') {
if (pcVar8 <= pcVar7) goto LAB_001444c6;
bVar1 = 0;
iVar2 = 1;
uVar4 = 0;
uVar5 = 0;
pcVar7 = pcVar6 + 2;
while (uVar5 = ((byte)pcVar7[-1] & 0x7f) << (bVar1 & 0x1f) | uVar5, pcVar7[-1] < '\0') {
if (3 < uVar4) goto LAB_001444c6;
uVar4 = uVar4 + 1;
bVar1 = bVar1 + 7;
iVar2 = iVar2 + 1;
bVar9 = pcVar8 <= pcVar7;
pcVar7 = pcVar7 + 1;
if (bVar9) goto LAB_001444c6;
}
if ((iVar2 < 0) || (uVar4 = get_sleb128(&local_50,pcVar7,pcVar8), (int)uVar4 < 0))
goto LAB_001444c6;
pcVar7 = pcVar7 + uVar4;
uVar4 = local_50 + (int)local_38;
}
else {
bVar1 = *pcVar6 - 1;
uVar5 = bVar1 / 5;
uVar4 = (uVar4 + (byte)(bVar1 + (char)uVar5 * -5)) - 1;
}
uVar3 = get_sleb128(&local_50,pcVar7,pcVar8);
if ((int)uVar3 < 0) goto LAB_001444c6;
local_4c = local_4c + uVar5;
if (local_48 < local_4c) {
uVar4 = (uint)local_38;
break;
}
local_44 = local_44 + local_50;
pcVar6 = pcVar7 + uVar3;
param_3 = local_40;
} while (pcVar6 < pcVar8);
}
*local_40 = local_44;
}
return uVar4;
}
|
|
17,207
|
my_thread_end
|
eloqsql/mysys/my_thr_init.c
|
void my_thread_end(void)
{
struct st_my_thread_var *tmp;
tmp= my_thread_var;
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_end(): tmp: %p pthread_self: %p thread_id: %ld\n",
tmp, pthread_self(), tmp ? (long) tmp->id : 0L);
#endif
/*
Remove the instrumentation for this thread.
This must be done before trashing st_my_thread_var,
because the LF_HASH depends on it.
*/
PSI_CALL_delete_current_thread();
/*
We need to disable DBUG early for this thread to ensure that the
the mutex calls doesn't enable it again
To this we have to both do DBUG_POP() and also reset THR_KEY_mysys
as the key is used by DBUG.
*/
DBUG_POP();
set_mysys_var(NULL);
if (tmp && tmp->init)
{
#if !defined(DBUG_OFF)
/* tmp->dbug is allocated inside DBUG library */
if (tmp->dbug)
{
free(tmp->dbug);
tmp->dbug=0;
}
#endif
my_thread_destory_thr_mutex(tmp);
/*
Decrement counter for number of running threads. We are using this
in my_thread_global_end() to wait until all threads have called
my_thread_end and thus freed all memory they have allocated in
my_thread_init() and DBUG_xxxx
*/
mysql_mutex_lock(&THR_LOCK_threads);
DBUG_ASSERT(THR_thread_count != 0);
if (--THR_thread_count == 0)
mysql_cond_signal(&THR_COND_threads);
mysql_mutex_unlock(&THR_LOCK_threads);
/* Trash variable so that we can detect false accesses to my_thread_var */
tmp->init= 2;
free(tmp);
}
}
|
O0
|
c
|
my_thread_end:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x26970
movq %rax, -0x8(%rbp)
leaq 0x1a6a68(%rip), %rax # 0x1cd8d0
movq (%rax), %rax
callq *0x138(%rax)
jmp 0x26e73
xorl %eax, %eax
movl %eax, %edi
callq 0x26e20
cmpq $0x0, -0x8(%rbp)
je 0x26efc
movq -0x8(%rbp), %rax
movsbl 0xe8(%rax), %eax
cmpl $0x0, %eax
je 0x26efc
movq -0x8(%rbp), %rdi
callq 0x26990
leaq 0x35e61d(%rip), %rdi # 0x3854c0
leaq 0x527b1(%rip), %rsi # 0x7965b
movl $0x175, %edx # imm = 0x175
callq 0x26cd0
jmp 0x26eb6
leaq 0x35e403(%rip), %rax # 0x3852c0
movl (%rax), %eax
addl $-0x1, %eax
leaq 0x35e3f7(%rip), %rcx # 0x3852c0
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x26edc
leaq 0x35e679(%rip), %rdi # 0x385550
callq 0x26f10
leaq 0x35e5dd(%rip), %rdi # 0x3854c0
callq 0x26dc0
movq -0x8(%rbp), %rax
movb $0x2, 0xe8(%rax)
movq -0x8(%rbp), %rdi
callq 0x24360
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_thread_end:
push rbp
mov rbp, rsp
sub rsp, 10h
call _my_thread_var
mov [rbp+var_8], rax
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+138h]
jmp short $+2
loc_26E73:
xor eax, eax
mov edi, eax
call set_mysys_var
cmp [rbp+var_8], 0
jz short loc_26EFC
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax+0E8h]
cmp eax, 0
jz short loc_26EFC
mov rdi, [rbp+var_8]
call my_thread_destory_thr_mutex
lea rdi, THR_LOCK_threads
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 175h
call inline_mysql_mutex_lock
jmp short $+2
loc_26EB6:
lea rax, THR_thread_count
mov eax, [rax]
add eax, 0FFFFFFFFh
lea rcx, THR_thread_count
mov [rcx], eax
cmp eax, 0
jnz short loc_26EDC
lea rdi, THR_COND_threads
call inline_mysql_cond_signal
loc_26EDC:
lea rdi, THR_LOCK_threads
call inline_mysql_mutex_unlock
mov rax, [rbp+var_8]
mov byte ptr [rax+0E8h], 2
mov rdi, [rbp+var_8]
call _free
loc_26EFC:
add rsp, 10h
pop rbp
retn
|
long long my_thread_end()
{
long long result; // rax
long long v1; // [rsp+8h] [rbp-8h]
v1 = my_thread_var();
(*((void (**)(void))PSI_server[0] + 39))();
result = set_mysys_var(0LL);
if ( v1 )
{
result = (unsigned int)*(char *)(v1 + 232);
if ( *(_BYTE *)(v1 + 232) )
{
my_thread_destory_thr_mutex(v1);
inline_mysql_mutex_lock(
(long long)&THR_LOCK_threads,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",
0x175u);
if ( !--THR_thread_count )
inline_mysql_cond_signal(&THR_COND_threads);
inline_mysql_mutex_unlock((long long)&THR_LOCK_threads);
*(_BYTE *)(v1 + 232) = 2;
return free(v1);
}
}
return result;
}
|
my_thread_end:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
CALL 0x00126970
MOV qword ptr [RBP + -0x8],RAX
LEA RAX,[0x2cd8d0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x138]
JMP 0x00126e73
LAB_00126e73:
XOR EAX,EAX
MOV EDI,EAX
CALL 0x00126e20
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00126efc
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + 0xe8]
CMP EAX,0x0
JZ 0x00126efc
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00126990
LEA RDI,[0x4854c0]
LEA RSI,[0x17965b]
MOV EDX,0x175
CALL 0x00126cd0
JMP 0x00126eb6
LAB_00126eb6:
LEA RAX,[0x4852c0]
MOV EAX,dword ptr [RAX]
ADD EAX,-0x1
LEA RCX,[0x4852c0]
MOV dword ptr [RCX],EAX
CMP EAX,0x0
JNZ 0x00126edc
LEA RDI,[0x485550]
CALL 0x00126f10
LAB_00126edc:
LEA RDI,[0x4854c0]
CALL 0x00126dc0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0xe8],0x2
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00124360
LAB_00126efc:
ADD RSP,0x10
POP RBP
RET
|
void my_thread_end(void)
{
void *__ptr;
__ptr = (void *)_my_thread_var();
(**(code **)(PSI_server + 0x138))();
set_mysys_var(0);
if ((__ptr != (void *)0x0) && (*(char *)((long)__ptr + 0xe8) != '\0')) {
my_thread_destory_thr_mutex(__ptr);
inline_mysql_mutex_lock
(THR_LOCK_threads,"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",0x175
);
THR_thread_count = THR_thread_count + -1;
if (THR_thread_count == 0) {
inline_mysql_cond_signal(THR_COND_threads);
}
inline_mysql_mutex_unlock(THR_LOCK_threads);
*(int1 *)((long)__ptr + 0xe8) = 2;
free(__ptr);
}
return;
}
|
|
17,208
|
minja::LiteralExpr::~LiteralExpr()
|
monkey531[P]llama/common/minja.hpp
|
LiteralExpr(const Location & location, const Value& v)
: Expression(location), value(v) {}
|
O3
|
cpp
|
minja::LiteralExpr::~LiteralExpr():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9c8ae(%rip), %rax # 0x12f528
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x60(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5d774
movq %r14, %rdi
callq 0x62bf0
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x92ca5
callq 0x725dc
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x92cb3
callq 0x725dc
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x92cc1
callq 0x725dc
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x92cf6
movq 0x9e2af(%rip), %rax # 0x130f80
cmpb $0x0, (%rax)
je 0x92ce1
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x92ceb
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x92cf6
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x9c6ab(%rip), %rax # 0x12f3a8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x92d19
popq %rbx
popq %r14
jmp 0x725dc
popq %rbx
popq %r14
retq
nop
|
_ZN5minja11LiteralExprD2Ev:
push r14
push rbx
push rax
mov rbx, rdi
lea rax, _ZTVN5minja11LiteralExprE; `vtable for'minja::LiteralExpr
add rax, 10h
mov [rdi], rax
lea r14, [rdi+60h]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rbx+58h]
test rdi, rdi
jz short loc_92CA5
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_92CA5:
mov rdi, [rbx+48h]
test rdi, rdi
jz short loc_92CB3
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_92CB3:
mov rdi, [rbx+38h]
test rdi, rdi
jz short loc_92CC1
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_92CC1:
mov rdi, [rbx+28h]
test rdi, rdi
jz short loc_92CF6
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_92CE1
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_92CEB
loc_92CE1:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_92CEB:
cmp eax, 1
jnz short loc_92CF6
mov rax, [rdi]
call qword ptr [rax+18h]
loc_92CF6:
lea rax, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
add rsp, 8
test rdi, rdi
jz short loc_92D19
pop rbx
pop r14
jmp _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_92D19:
pop rbx
pop r14
retn
|
void minja::LiteralExpr::~LiteralExpr(minja::LiteralExpr *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
volatile signed __int32 *v4; // rdi
volatile signed __int32 *v5; // rdi
signed __int32 v6; // eax
volatile signed __int32 *v7; // rdi
*(_QWORD *)this = &`vtable for'minja::LiteralExpr + 2;
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 + 96);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((char *)this + 96);
v2 = (volatile signed __int32 *)*((_QWORD *)this + 11);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
v3 = (volatile signed __int32 *)*((_QWORD *)this + 9);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
v4 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v4 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v4);
v5 = (volatile signed __int32 *)*((_QWORD *)this + 5);
if ( v5 )
{
if ( _libc_single_threaded )
{
v6 = *((_DWORD *)v5 + 3);
*((_DWORD *)v5 + 3) = v6 - 1;
}
else
{
v6 = _InterlockedExchangeAdd(v5 + 3, 0xFFFFFFFF);
}
if ( v6 == 1 )
(*(void ( **)(volatile signed __int32 *, _QWORD))(*(_QWORD *)v5 + 24LL))(v5, 0LL);
}
*(_QWORD *)this = &`vtable for'minja::Expression + 2;
v7 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v7 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v7);
}
|
~LiteralExpr:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x22f528]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
LEA R14,[RDI + 0x60]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0015d774
MOV RDI,R14
CALL 0x00162bf0
MOV RDI,qword ptr [RBX + 0x58]
TEST RDI,RDI
JZ 0x00192ca5
CALL 0x001725dc
LAB_00192ca5:
MOV RDI,qword ptr [RBX + 0x48]
TEST RDI,RDI
JZ 0x00192cb3
CALL 0x001725dc
LAB_00192cb3:
MOV RDI,qword ptr [RBX + 0x38]
TEST RDI,RDI
JZ 0x00192cc1
CALL 0x001725dc
LAB_00192cc1:
MOV RDI,qword ptr [RBX + 0x28]
TEST RDI,RDI
JZ 0x00192cf6
MOV RAX,qword ptr [0x00230f80]
CMP byte ptr [RAX],0x0
JZ 0x00192ce1
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00192ceb
LAB_00192ce1:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00192ceb:
CMP EAX,0x1
JNZ 0x00192cf6
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00192cf6:
LEA RAX,[0x22f3a8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
ADD RSP,0x8
TEST RDI,RDI
JZ 0x00192d19
POP RBX
POP R14
JMP 0x001725dc
LAB_00192d19:
POP RBX
POP R14
RET
|
/* minja::LiteralExpr::~LiteralExpr() */
void __thiscall minja::LiteralExpr::~LiteralExpr(LiteralExpr *this)
{
int *piVar1;
long *plVar2;
int iVar3;
*(int ***)this = &PTR_do_evaluate_0022f538;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)(this + 0x60),0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)(this + 0x60));
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x58) !=
(_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 + 0x58));
}
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x48) !=
(_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 + 0x48));
}
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38));
}
plVar2 = *(long **)(this + 0x28);
if (plVar2 != (long *)0x0) {
if (*PTR___libc_single_threaded_00230f80 == '\0') {
LOCK();
piVar1 = (int *)((long)plVar2 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)plVar2 + 0xc);
*(int *)((long)plVar2 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*plVar2 + 0x18))();
}
}
*(int ***)this = &PTR___cxa_pure_virtual_0022f3b8;
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;
}
|
|
17,209
|
alloc_dynamic
|
eloqsql/mysys/array.c
|
void *alloc_dynamic(DYNAMIC_ARRAY *array)
{
DBUG_ENTER("alloc_dynamic");
DBUG_ASSERT(array->size_of_element); /* Ensure init() is called */
if (array->elements == array->max_element)
{
char *new_ptr;
if (array->malloc_flags & MY_INIT_BUFFER_USED)
{
/*
In this scenario, the buffer is statically preallocated,
so we have to create an all-new malloc since we overflowed
*/
if (!(new_ptr= (char *) my_malloc(array->m_psi_key,
(array->max_element+
array->alloc_increment) *
array->size_of_element,
MYF(array->malloc_flags | MY_WME))))
DBUG_RETURN(0);
if (array->elements)
memcpy(new_ptr, array->buffer,
array->elements * array->size_of_element);
array->malloc_flags&= ~MY_INIT_BUFFER_USED;
}
else if (!(new_ptr=(char*)
my_realloc(array->m_psi_key, array->buffer,
(array->max_element+ array->alloc_increment) *
array->size_of_element,
MYF(MY_WME | MY_ALLOW_ZERO_PTR |
array->malloc_flags))))
DBUG_RETURN(0);
array->buffer= (uchar*) new_ptr;
array->max_element+=array->alloc_increment;
}
DBUG_RETURN(array->buffer+(array->elements++ * array->size_of_element));
}
|
O0
|
c
|
alloc_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
jmp 0x2fdbe
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x2fee7
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
andq $0x100, %rax # imm = 0x100
cmpq $0x0, %rax
je 0x2fe7a
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
orq $0x10, %rdx
callq 0x25b50
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2fe35
jmp 0x2fe28
movq $0x0, -0x8(%rbp)
jmp 0x2ff10
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x2fe62
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x24210
movq -0x10(%rbp), %rax
movabsq $0xfffffeff, %rcx # imm = 0xFFFFFEFF
andq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0x2fecb
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
orq $0x50, %rcx
callq 0x25d20
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2fec9
jmp 0x2febf
movq $0x0, -0x8(%rbp)
jmp 0x2ff10
jmp 0x2fecb
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
jmp 0x2fee9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x8(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rdx)
movq -0x10(%rbp), %rdx
imull 0x14(%rdx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
alloc_dynamic:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
jmp short $+2
loc_2FDBE:
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
cmp eax, [rcx+0Ch]
jnz loc_2FEE7
mov rax, [rbp+var_10]
mov rax, [rax+20h]
and rax, 100h
cmp rax, 0
jz loc_2FE7A
mov rax, [rbp+var_10]
mov edi, [rax+18h]
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
mov rcx, [rbp+var_10]
add eax, [rcx+10h]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov esi, eax
mov rax, [rbp+var_10]
mov rdx, [rax+20h]
or rdx, 10h
call my_malloc
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_2FE35
jmp short $+2
loc_2FE28:
mov [rbp+var_8], 0
jmp loc_2FF10
loc_2FE35:
mov rax, [rbp+var_10]
cmp dword ptr [rax+8], 0
jz short loc_2FE62
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
call _memcpy
loc_2FE62:
mov rax, [rbp+var_10]
mov rcx, 0FFFFFEFFh
and rcx, [rax+20h]
mov [rax+20h], rcx
jmp short loc_2FECB
loc_2FE7A:
mov rax, [rbp+var_10]
mov edi, [rax+18h]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
mov rcx, [rbp+var_10]
add eax, [rcx+10h]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
or rcx, 50h
call my_realloc
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_2FEC9
jmp short $+2
loc_2FEBF:
mov [rbp+var_8], 0
jmp short loc_2FF10
loc_2FEC9:
jmp short $+2
loc_2FECB:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+10h]
mov rax, [rbp+var_10]
add ecx, [rax+0Ch]
mov [rax+0Ch], ecx
loc_2FEE7:
jmp short $+2
loc_2FEE9:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+8]
mov esi, ecx
add esi, 1
mov [rdx+8], esi
mov rdx, [rbp+var_10]
imul ecx, [rdx+14h]
mov ecx, ecx
add rax, rcx
mov [rbp+var_8], rax
loc_2FF10:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
|
long long alloc_dynamic(long long *a1)
{
long long v1; // rax
int v2; // ecx
long long v4; // [rsp+8h] [rbp-18h]
if ( *((_DWORD *)a1 + 2) != *((_DWORD *)a1 + 3) )
goto LABEL_11;
if ( (a1[4] & 0x100) == 0 )
{
v4 = my_realloc(
*((_DWORD *)a1 + 6),
*a1,
(unsigned int)(*((_DWORD *)a1 + 5) * (*((_DWORD *)a1 + 4) + *((_DWORD *)a1 + 3))),
*((_BYTE *)a1 + 32) | 0x50u);
if ( !v4 )
return 0LL;
goto LABEL_10;
}
v4 = my_malloc(
*((_DWORD *)a1 + 6),
(unsigned int)(*((_DWORD *)a1 + 5) * (*((_DWORD *)a1 + 4) + *((_DWORD *)a1 + 3))),
*((_DWORD *)a1 + 8) | 0x10u);
if ( v4 )
{
if ( *((_DWORD *)a1 + 2) )
memcpy(v4, *a1, (unsigned int)(*((_DWORD *)a1 + 5) * *((_DWORD *)a1 + 2)));
a1[4] &= 0xFFFFFEFFuLL;
LABEL_10:
*a1 = v4;
*((_DWORD *)a1 + 3) += *((_DWORD *)a1 + 4);
LABEL_11:
v1 = *a1;
v2 = *((_DWORD *)a1 + 2);
*((_DWORD *)a1 + 2) = v2 + 1;
return (unsigned int)(*((_DWORD *)a1 + 5) * v2) + v1;
}
return 0LL;
}
|
alloc_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
JMP 0x0012fdbe
LAB_0012fdbe:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0xc]
JNZ 0x0012fee7
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
AND RAX,0x100
CMP RAX,0x0
JZ 0x0012fe7a
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x20]
OR RDX,0x10
CALL 0x00125b50
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x0012fe35
JMP 0x0012fe28
LAB_0012fe28:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0012ff10
LAB_0012fe35:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x0012fe62
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x00124210
LAB_0012fe62:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,0xfffffeff
AND RCX,qword ptr [RAX + 0x20]
MOV qword ptr [RAX + 0x20],RCX
JMP 0x0012fecb
LAB_0012fe7a:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
OR RCX,0x50
CALL 0x00125d20
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x0012fec9
JMP 0x0012febf
LAB_0012febf:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0012ff10
LAB_0012fec9:
JMP 0x0012fecb
LAB_0012fecb:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
ADD ECX,dword ptr [RAX + 0xc]
MOV dword ptr [RAX + 0xc],ECX
LAB_0012fee7:
JMP 0x0012fee9
LAB_0012fee9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x8]
MOV ESI,ECX
ADD ESI,0x1
MOV dword ptr [RDX + 0x8],ESI
MOV RDX,qword ptr [RBP + -0x10]
IMUL ECX,dword ptr [RDX + 0x14]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
LAB_0012ff10:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
long alloc_dynamic(long *param_1)
{
long lVar1;
void *local_20;
if ((int)param_1[1] == *(int *)((long)param_1 + 0xc)) {
if ((param_1[4] & 0x100U) == 0) {
local_20 = (void *)my_realloc((int)param_1[3],*param_1,
(*(int *)((long)param_1 + 0xc) + (int)param_1[2]) *
*(int *)((long)param_1 + 0x14),param_1[4] | 0x50);
if (local_20 == (void *)0x0) {
return 0;
}
}
else {
local_20 = (void *)my_malloc((int)param_1[3],
(*(int *)((long)param_1 + 0xc) + (int)param_1[2]) *
*(int *)((long)param_1 + 0x14),param_1[4] | 0x10);
if (local_20 == (void *)0x0) {
return 0;
}
if ((int)param_1[1] != 0) {
memcpy(local_20,(void *)*param_1,
(ulong)(uint)((int)param_1[1] * *(int *)((long)param_1 + 0x14)));
}
param_1[4] = param_1[4] & 0xfffffeff;
}
*param_1 = (long)local_20;
*(int *)((long)param_1 + 0xc) = (int)param_1[2] + *(int *)((long)param_1 + 0xc);
}
lVar1 = param_1[1];
*(int *)(param_1 + 1) = (int)lVar1 + 1;
return *param_1 + (ulong)(uint)((int)lVar1 * *(int *)((long)param_1 + 0x14));
}
|
|
17,210
|
maria_page_crc_check_bitmap
|
eloqsql/storage/maria/ma_pagecrc.c
|
my_bool maria_page_crc_check_bitmap(int res, PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
if (res)
{
return 1;
}
return (maria_page_crc_check(page, (uint32) page_no, share,
MARIA_NO_CRC_BITMAP_PAGE,
share->block_size - CRC_SIZE));
}
|
O3
|
c
|
maria_page_crc_check_bitmap:
pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
je 0x3e052
movb $0x1, %al
popq %rbp
retq
movq 0x10(%rsi), %rdx
movl 0x8(%rsi), %eax
movq (%rsi), %rdi
movl 0x7bc(%rdx), %r8d
addl $-0x4, %r8d
movq %rax, %rsi
movl $0xfffffffe, %ecx # imm = 0xFFFFFFFE
popq %rbp
jmp 0x3df10
|
maria_page_crc_check_bitmap:
push rbp
mov rbp, rsp
test edi, edi
jz short loc_3E052
mov al, 1
pop rbp
retn
loc_3E052:
mov rdx, [rsi+10h]
mov eax, [rsi+8]
mov rdi, [rsi]
mov r8d, [rdx+7BCh]
add r8d, 0FFFFFFFCh
mov rsi, rax
mov ecx, 0FFFFFFFEh
pop rbp
jmp maria_page_crc_check
|
char maria_page_crc_check_bitmap(int a1, long long a2)
{
if ( a1 )
return 1;
else
return maria_page_crc_check(
*(_QWORD *)a2,
*(_DWORD *)(a2 + 8),
*(_QWORD *)(a2 + 16),
-2,
*(_DWORD *)(*(_QWORD *)(a2 + 16) + 1980LL) - 4);
}
|
maria_page_crc_check_bitmap:
PUSH RBP
MOV RBP,RSP
TEST EDI,EDI
JZ 0x0013e052
MOV AL,0x1
POP RBP
RET
LAB_0013e052:
MOV RDX,qword ptr [RSI + 0x10]
MOV EAX,dword ptr [RSI + 0x8]
MOV RDI,qword ptr [RSI]
MOV R8D,dword ptr [RDX + 0x7bc]
ADD R8D,-0x4
MOV RSI,RAX
MOV ECX,0xfffffffe
POP RBP
JMP 0x0013df10
|
int8 maria_page_crc_check_bitmap(int param_1,int8 *param_2)
{
int8 uVar1;
if (param_1 != 0) {
return 1;
}
uVar1 = maria_page_crc_check
(*param_2,*(int4 *)(param_2 + 1),param_2[2],0xfffffffe,
*(int *)(param_2[2] + 0x7bc) + -4);
return uVar1;
}
|
|
17,211
|
thr_lock_init
|
eloqsql/mysys/thr_lock.c
|
void thr_lock_init(THR_LOCK *lock)
{
DBUG_ENTER("thr_lock_init");
bzero((char*) lock,sizeof(*lock));
mysql_mutex_init(key_THR_LOCK_mutex, &lock->mutex, MY_MUTEX_INIT_FAST);
lock->read.last= &lock->read.data;
lock->read_wait.last= &lock->read_wait.data;
lock->write_wait.last= &lock->write_wait.data;
lock->write.last= &lock->write.data;
mysql_mutex_lock(&THR_LOCK_lock); /* Add to locks in use */
lock->list.data=(void*) lock;
thr_lock_thread_list=list_add(thr_lock_thread_list,&lock->list);
mysql_mutex_unlock(&THR_LOCK_lock);
DBUG_VOID_RETURN;
}
|
O3
|
c
|
thr_lock_init:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0xf8, %edx
xorl %esi, %esi
callq 0x292c0
leaq 0xb657e9(%rip), %rax # 0xc07d3c
movl (%rax), %edi
leaq 0x18(%rbx), %r14
leaq 0x2e3ab0(%rip), %r15 # 0x386010
movq (%r15), %rax
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x58(%rbx)
movq %r14, 0x50(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
leaq 0xb664b1(%rip), %rsi # 0xc08a30
movq %r14, %rdi
callq 0x29340
leaq 0x70(%rbx), %rax
movq %rax, 0x78(%rbx)
leaq 0x60(%rbx), %rax
movq %rax, 0x68(%rbx)
leaq 0x80(%rbx), %rax
movq %rax, 0x88(%rbx)
leaq 0x90(%rbx), %rax
movq %rax, 0x98(%rbx)
leaq 0xb661be(%rip), %r14 # 0xc08778
cmpq $0x0, 0x40(%r14)
jne 0xa2605
leaq 0xb661b0(%rip), %rdi # 0xc08778
callq 0x29220
movq %rbx, 0x10(%rbx)
leaq 0xb66450(%rip), %r12 # 0xc08a28
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x9475c
movq %rax, (%r12)
movq 0x40(%r14), %rdi
testq %rdi, %rdi
jne 0xa260c
leaq 0xb66180(%rip), %rdi # 0xc08778
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x291e0
callq 0x2f1ce
jmp 0xa25cd
movq (%r15), %rax
callq *0x160(%rax)
jmp 0xa25f1
|
thr_lock_init:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdi
mov edx, 0F8h
xor esi, esi
call _memset
lea rax, key_THR_LOCK_mutex
mov edi, [rax]
lea r14, [rbx+18h]
lea r15, PSI_server
mov rax, [r15]
mov rsi, r14
call qword ptr [rax+40h]
mov [rbx+58h], rax
mov [rbx+50h], r14
xorps xmm0, xmm0
movups xmmword ptr [rbx+40h], xmm0
lea rsi, my_fast_mutexattr
mov rdi, r14
call _pthread_mutex_init
lea rax, [rbx+70h]
mov [rbx+78h], rax
lea rax, [rbx+60h]
mov [rbx+68h], rax
lea rax, [rbx+80h]
mov [rbx+88h], rax
lea rax, [rbx+90h]
mov [rbx+98h], rax
lea r14, THR_LOCK_lock
cmp qword ptr [r14+40h], 0
jnz short loc_A2605
lea rdi, THR_LOCK_lock
call _pthread_mutex_lock
loc_A25CD:
mov [rbx+10h], rbx
lea r12, thr_lock_thread_list
mov rdi, [r12]
mov rsi, rbx
call list_add
mov [r12], rax
mov rdi, [r14+40h]
test rdi, rdi
jnz short loc_A260C
loc_A25F1:
lea rdi, THR_LOCK_lock
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_A2605:
call thr_lock_init_cold_1
jmp short loc_A25CD
loc_A260C:
mov rax, [r15]
call qword ptr [rax+160h]
jmp short loc_A25F1
|
long long thr_lock_init(long long a1)
{
memset(a1, 0LL, 248LL);
*(_QWORD *)(a1 + 88) = ((long long ( *)(_QWORD, long long))PSI_server[8])(key_THR_LOCK_mutex, a1 + 24);
*(_QWORD *)(a1 + 80) = a1 + 24;
*(_OWORD *)(a1 + 64) = 0LL;
pthread_mutex_init(a1 + 24, &my_fast_mutexattr);
*(_QWORD *)(a1 + 120) = a1 + 112;
*(_QWORD *)(a1 + 104) = a1 + 96;
*(_QWORD *)(a1 + 136) = a1 + 128;
*(_QWORD *)(a1 + 152) = a1 + 144;
if ( THR_LOCK_lock[8] )
thr_lock_init_cold_1();
else
pthread_mutex_lock(THR_LOCK_lock);
*(_QWORD *)(a1 + 16) = a1;
thr_lock_thread_list = list_add(thr_lock_thread_list, (_QWORD *)a1);
if ( THR_LOCK_lock[8] )
PSI_server[44]();
return pthread_mutex_unlock(THR_LOCK_lock);
}
|
thr_lock_init:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV EDX,0xf8
XOR ESI,ESI
CALL 0x001292c0
LEA RAX,[0xd07d3c]
MOV EDI,dword ptr [RAX]
LEA R14,[RBX + 0x18]
LEA R15,[0x486010]
MOV RAX,qword ptr [R15]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [RBX + 0x58],RAX
MOV qword ptr [RBX + 0x50],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x40],XMM0
LEA RSI,[0xd08a30]
MOV RDI,R14
CALL 0x00129340
LEA RAX,[RBX + 0x70]
MOV qword ptr [RBX + 0x78],RAX
LEA RAX,[RBX + 0x60]
MOV qword ptr [RBX + 0x68],RAX
LEA RAX,[RBX + 0x80]
MOV qword ptr [RBX + 0x88],RAX
LEA RAX,[RBX + 0x90]
MOV qword ptr [RBX + 0x98],RAX
LEA R14,[0xd08778]
CMP qword ptr [R14 + 0x40],0x0
JNZ 0x001a2605
LEA RDI,[0xd08778]
CALL 0x00129220
LAB_001a25cd:
MOV qword ptr [RBX + 0x10],RBX
LEA R12,[0xd08a28]
MOV RDI,qword ptr [R12]
MOV RSI,RBX
CALL 0x0019475c
MOV qword ptr [R12],RAX
MOV RDI,qword ptr [R14 + 0x40]
TEST RDI,RDI
JNZ 0x001a260c
LAB_001a25f1:
LEA RDI,[0xd08778]
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x001291e0
LAB_001a2605:
CALL 0x0012f1ce
JMP 0x001a25cd
LAB_001a260c:
MOV RAX,qword ptr [R15]
CALL qword ptr [RAX + 0x160]
JMP 0x001a25f1
|
void thr_lock_init(void *param_1)
{
pthread_mutex_t *__mutex;
int8 uVar1;
memset(param_1,0,0xf8);
__mutex = (pthread_mutex_t *)((long)param_1 + 0x18);
uVar1 = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_mutex,__mutex);
*(int8 *)((long)param_1 + 0x58) = uVar1;
*(pthread_mutex_t **)((long)param_1 + 0x50) = __mutex;
*(int8 *)((long)param_1 + 0x40) = 0;
*(int8 *)((long)param_1 + 0x48) = 0;
pthread_mutex_init(__mutex,(pthread_mutexattr_t *)&my_fast_mutexattr);
*(long *)((long)param_1 + 0x78) = (long)param_1 + 0x70;
*(long *)((long)param_1 + 0x68) = (long)param_1 + 0x60;
*(long *)((long)param_1 + 0x88) = (long)param_1 + 0x80;
*(long *)((long)param_1 + 0x98) = (long)param_1 + 0x90;
if (THR_LOCK_lock._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_lock);
}
else {
thr_lock_init_cold_1();
}
*(void **)((long)param_1 + 0x10) = param_1;
thr_lock_thread_list = list_add(thr_lock_thread_list,param_1);
if (THR_LOCK_lock._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_lock);
return;
}
|
|
17,212
|
string_repeat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
|
monkey531[P]llama/common/common.cpp
|
std::string string_repeat(const std::string & str, size_t n) {
if (n == 0) {
return "";
}
std::string result;
result.reserve(str.length() * n);
for (size_t i = 0; i < n; ++i) {
result += str;
}
return result;
}
|
O2
|
cpp
|
string_repeat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x3e7f5
movq %rdx, %r14
movq %rsi, %r15
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%rsi), %rsi
imulq %rdx, %rsi
movq %rbx, %rdi
callq 0x22bf0
subq $0x1, %r14
jb 0x3e809
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22f10
jmp 0x3e7e2
leaq 0x5e445(%rip), %rsi # 0x9cc41
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x29014
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3e818
movq %rax, %r14
movq %rbx, %rdi
callq 0x22f98
movq %r14, %rdi
callq 0x22da0
|
_Z13string_repeatRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
test rdx, rdx
jz short loc_3E7F5
mov r14, rdx
mov r15, rsi
lea rax, [rbx+10h]
mov [rbx], rax
and qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
mov rsi, [rsi+8]
imul rsi, rdx
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
loc_3E7E2:
sub r14, 1
jb short loc_3E809
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_; std::string::append(std::string const&)
jmp short loc_3E7E2
loc_3E7F5:
lea rsi, aEndIndexOutOfB+19h; ""
lea rdx, [rsp+28h+var_19]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
loc_3E809:
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
jmp short $+2
loc_3E818:
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
|
long long string_repeat(long long a1, long long a2, long long a3)
{
long long v3; // r14
if ( a3 )
{
v3 = a3;
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
std::string::reserve(a1, a3 * *(_QWORD *)(a2 + 8));
while ( v3-- != 0 )
std::string::append(a1, a2);
}
else
{
std::string::basic_string<std::allocator<char>>((_QWORD *)a1, (long long)"");
}
return a1;
}
|
string_repeat:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
TEST RDX,RDX
JZ 0x0013e7f5
MOV R14,RDX
MOV R15,RSI
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
AND qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
MOV RSI,qword ptr [RSI + 0x8]
IMUL RSI,RDX
LAB_0013e7da:
MOV RDI,RBX
CALL 0x00122bf0
LAB_0013e7e2:
SUB R14,0x1
JC 0x0013e809
LAB_0013e7e8:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00122f10
LAB_0013e7f3:
JMP 0x0013e7e2
LAB_0013e7f5:
LEA RSI,[0x19cc41]
LEA RDX,[RSP + 0xf]
MOV RDI,RBX
CALL 0x00129014
LAB_0013e809:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* string_repeat(std::__cxx11::string const&, unsigned long) */
string * string_repeat(string *param_1,ulong param_2)
{
long in_RDX;
bool bVar1;
allocator local_19;
if (in_RDX == 0) {
std::__cxx11::string::string<std::allocator<char>>(param_1,"",&local_19);
}
else {
*(string **)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (string)0x0;
/* try { // try from 0013e7da to 0013e7e1 has its CatchHandler @ 0013e816 */
std::__cxx11::string::reserve((ulong)param_1);
while (bVar1 = in_RDX != 0, in_RDX = in_RDX + -1, bVar1) {
/* try { // try from 0013e7e8 to 0013e7f2 has its CatchHandler @ 0013e818 */
std::__cxx11::string::append(param_1);
}
}
return param_1;
}
|
|
17,213
|
table_mapping::set_table(unsigned long long, Table_map_log_event*)
|
eloqsql/sql/rpl_tblmap.cc
|
int table_mapping::set_table(ulonglong table_id, TABLE* table)
{
DBUG_ENTER("table_mapping::set_table(ulong,TABLE*)");
DBUG_PRINT("enter", ("table_id: %llu table: %p (%s)",
table_id,
table, MAYBE_TABLE_NAME(table)));
entry *e= find_entry(table_id);
if (e == 0)
{
if (m_free == 0 && expand())
DBUG_RETURN(ERR_MEMORY_ALLOCATION); // Memory allocation failed
e= m_free;
m_free= m_free->next;
}
else
{
#ifdef MYSQL_CLIENT
free_table_map_log_event(e->table);
#endif
my_hash_delete(&m_table_ids,(uchar *)e);
}
e->table_id= table_id;
e->table= table;
if (my_hash_insert(&m_table_ids,(uchar *)e))
{
/* we add this entry to the chain of free (free for use) entries */
e->next= m_free;
m_free= e;
DBUG_RETURN(ERR_MEMORY_ALLOCATION);
}
DBUG_PRINT("info", ("tid %llu -> table %p (%s)",
table_id, e->table,
MAYBE_TABLE_NAME(e->table)));
DBUG_RETURN(0); // All OK
}
|
O3
|
cpp
|
table_mapping::set_table(unsigned long long, Table_map_log_event*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x30(%rbp), %rsi
movq %r15, (%rsi)
leaq 0x48(%rdi), %r12
movl $0x8, %edx
movq %r12, %rdi
callq 0x7a106
testq %rax, %rax
je 0x3f84b
movq %rax, %r13
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3f83e
movq (%rdi), %rax
callq *0x30(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x7a66a
jmp 0x3f85c
movq 0x40(%rbx), %r13
testq %r13, %r13
je 0x3f88a
movq 0x8(%r13), %rax
movq %rax, 0x40(%rbx)
movq %r15, (%r13)
movq %r14, 0x8(%r13)
movq %r12, %rdi
movq %r13, %rsi
callq 0x7a366
testb %al, %al
je 0x3f886
movq 0x40(%rbx), %rax
movq %rax, 0x8(%r13)
movq %r13, 0x40(%rbx)
movl $0x2, %eax
jmp 0x3f89d
xorl %eax, %eax
jmp 0x3f89d
movq %rbx, %rdi
callq 0x41f24
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
je 0x3f8ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%rbx), %r13
jmp 0x3f854
|
_ZN13table_mapping9set_tableEyP19Table_map_log_event:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea rsi, [rbp+var_30]
mov [rsi], r15
lea r12, [rdi+48h]
mov edx, 8
mov rdi, r12
call my_hash_search
test rax, rax
jz short loc_3F84B
mov r13, rax
mov rdi, [rax+8]
test rdi, rdi
jz short loc_3F83E
mov rax, [rdi]
call qword ptr [rax+30h]
loc_3F83E:
mov rdi, r12
mov rsi, r13
call my_hash_delete
jmp short loc_3F85C
loc_3F84B:
mov r13, [rbx+40h]
test r13, r13
jz short loc_3F88A
loc_3F854:
mov rax, [r13+8]
mov [rbx+40h], rax
loc_3F85C:
mov [r13+0], r15
mov [r13+8], r14
mov rdi, r12
mov rsi, r13
call my_hash_insert
test al, al
jz short loc_3F886
mov rax, [rbx+40h]
mov [r13+8], rax
mov [rbx+40h], r13
mov eax, 2
jmp short loc_3F89D
loc_3F886:
xor eax, eax
jmp short loc_3F89D
loc_3F88A:
mov rdi, rbx; this
call _ZN13table_mapping6expandEv; table_mapping::expand(void)
mov ecx, eax
mov eax, 2
test ecx, ecx
jz short loc_3F8AC
loc_3F89D:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3F8AC:
mov r13, [rbx+40h]
jmp short loc_3F854
|
long long table_mapping::set_table(table_mapping *this, long long a2, Table_map_log_event *a3)
{
char *v5; // r12
long long v6; // rax
_QWORD *v7; // r13
long long v8; // rdi
long long result; // rax
int v10; // ecx
_QWORD v11[6]; // [rsp+0h] [rbp-30h] BYREF
v11[0] = a2;
v5 = (char *)this + 72;
v6 = my_hash_search((char *)this + 72, v11, 8LL);
if ( v6 )
{
v7 = (_QWORD *)v6;
v8 = *(_QWORD *)(v6 + 8);
if ( v8 )
(*(void ( **)(long long))(*(_QWORD *)v8 + 48LL))(v8);
my_hash_delete(v5, v7);
}
else
{
v7 = (_QWORD *)*((_QWORD *)this + 8);
if ( !v7 )
{
v10 = table_mapping::expand(this);
result = 2LL;
if ( v10 )
return result;
v7 = (_QWORD *)*((_QWORD *)this + 8);
}
*((_QWORD *)this + 8) = v7[1];
}
*v7 = a2;
v7[1] = a3;
if ( !(unsigned __int8)my_hash_insert(v5, v7) )
return 0LL;
v7[1] = *((_QWORD *)this + 8);
*((_QWORD *)this + 8) = v7;
return 2LL;
}
|
set_table:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA RSI,[RBP + -0x30]
MOV qword ptr [RSI],R15
LEA R12,[RDI + 0x48]
MOV EDX,0x8
MOV RDI,R12
CALL 0x0017a106
TEST RAX,RAX
JZ 0x0013f84b
MOV R13,RAX
MOV RDI,qword ptr [RAX + 0x8]
TEST RDI,RDI
JZ 0x0013f83e
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x30]
LAB_0013f83e:
MOV RDI,R12
MOV RSI,R13
CALL 0x0017a66a
JMP 0x0013f85c
LAB_0013f84b:
MOV R13,qword ptr [RBX + 0x40]
TEST R13,R13
JZ 0x0013f88a
LAB_0013f854:
MOV RAX,qword ptr [R13 + 0x8]
MOV qword ptr [RBX + 0x40],RAX
LAB_0013f85c:
MOV qword ptr [R13],R15
MOV qword ptr [R13 + 0x8],R14
MOV RDI,R12
MOV RSI,R13
CALL 0x0017a366
TEST AL,AL
JZ 0x0013f886
MOV RAX,qword ptr [RBX + 0x40]
MOV qword ptr [R13 + 0x8],RAX
MOV qword ptr [RBX + 0x40],R13
MOV EAX,0x2
JMP 0x0013f89d
LAB_0013f886:
XOR EAX,EAX
JMP 0x0013f89d
LAB_0013f88a:
MOV RDI,RBX
CALL 0x00141f24
MOV ECX,EAX
MOV EAX,0x2
TEST ECX,ECX
JZ 0x0013f8ac
LAB_0013f89d:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013f8ac:
MOV R13,qword ptr [RBX + 0x40]
JMP 0x0013f854
|
/* table_mapping::set_table(unsigned long long, Table_map_log_event*) */
int8 __thiscall
table_mapping::set_table(table_mapping *this,ulonglong param_1,Table_map_log_event *param_2)
{
table_mapping *ptVar1;
char cVar2;
int iVar3;
ulonglong *puVar4;
int8 uVar5;
ulonglong local_38;
ptVar1 = this + 0x48;
local_38 = param_1;
puVar4 = (ulonglong *)my_hash_search(ptVar1,&local_38,8);
if (puVar4 == (ulonglong *)0x0) {
puVar4 = *(ulonglong **)(this + 0x40);
if (puVar4 == (ulonglong *)0x0) {
iVar3 = expand(this);
if (iVar3 != 0) {
return 2;
}
puVar4 = *(ulonglong **)(this + 0x40);
}
*(ulonglong *)(this + 0x40) = puVar4[1];
}
else {
if ((long *)puVar4[1] != (long *)0x0) {
(**(code **)(*(long *)puVar4[1] + 0x30))();
}
my_hash_delete(ptVar1,puVar4);
}
*puVar4 = param_1;
puVar4[1] = (ulonglong)param_2;
cVar2 = my_hash_insert(ptVar1,puVar4);
if (cVar2 == '\0') {
uVar5 = 0;
}
else {
puVar4[1] = *(ulonglong *)(this + 0x40);
*(ulonglong **)(this + 0x40) = puVar4;
uVar5 = 2;
}
return uVar5;
}
|
|
17,214
|
js_parse_skip_parens_token
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_terminator)
{
char state[256];
size_t level = 0;
JSParsePos pos;
int last_tok, tok = TOK_EOF;
int c, tok_len, bits = 0;
/* protect from underflow */
state[level++] = 0;
js_parse_get_pos(s, &pos);
last_tok = 0;
for (;;) {
switch(s->token.val) {
case '(':
case '[':
case '{':
if (level >= sizeof(state))
goto done;
state[level++] = s->token.val;
break;
case ')':
if (state[--level] != '(')
goto done;
break;
case ']':
if (state[--level] != '[')
goto done;
break;
case '}':
c = state[--level];
if (c == '`') {
/* continue the parsing of the template */
free_token(s, &s->token);
/* Resume TOK_TEMPLATE parsing (s->token.line_num and
* s->token.ptr are OK) */
s->got_lf = FALSE;
s->last_line_num = s->token.line_num;
s->last_col_num = s->token.col_num;
if (js_parse_template_part(s, s->buf_ptr))
goto done;
goto handle_template;
} else if (c != '{') {
goto done;
}
break;
case TOK_TEMPLATE:
handle_template:
if (s->token.u.str.sep != '`') {
/* '${' inside the template : closing '}' and continue
parsing the template */
if (level >= sizeof(state))
goto done;
state[level++] = '`';
}
break;
case TOK_EOF:
goto done;
case ';':
if (level == 2) {
bits |= SKIP_HAS_SEMI;
}
break;
case TOK_ELLIPSIS:
if (level == 2) {
bits |= SKIP_HAS_ELLIPSIS;
}
break;
case '=':
bits |= SKIP_HAS_ASSIGNMENT;
break;
case TOK_DIV_ASSIGN:
tok_len = 2;
goto parse_regexp;
case '/':
tok_len = 1;
parse_regexp:
if (is_regexp_allowed(last_tok)) {
s->buf_ptr -= tok_len;
if (js_parse_regexp(s)) {
/* XXX: should clear the exception */
goto done;
}
}
break;
}
/* last_tok is only used to recognize regexps */
if (s->token.val == TOK_IDENT &&
(token_is_pseudo_keyword(s, JS_ATOM_of) ||
token_is_pseudo_keyword(s, JS_ATOM_yield))) {
last_tok = TOK_OF;
} else {
last_tok = s->token.val;
}
if (next_token(s)) {
/* XXX: should clear the exception generated by next_token() */
break;
}
if (level <= 1) {
tok = s->token.val;
if (token_is_pseudo_keyword(s, JS_ATOM_of))
tok = TOK_OF;
if (no_line_terminator && s->last_line_num != s->token.line_num)
tok = '\n';
break;
}
}
done:
if (pbits) {
*pbits = bits;
}
if (js_parse_seek_token(s, &pos))
return -1;
return tok;
}
|
O0
|
c
|
js_parse_skip_parens_token:
subq $0x178, %rsp # imm = 0x178
movq %rdi, 0x168(%rsp)
movq %rsi, 0x160(%rsp)
movl %edx, 0x15c(%rsp)
movq $0x0, 0x48(%rsp)
movl $0xffffffaa, 0x10(%rsp) # imm = 0xFFFFFFAA
movl $0x0, 0x4(%rsp)
movq 0x48(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rsp)
movb $0x0, 0x50(%rsp,%rax)
movq 0x168(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x9e270
movl $0x0, 0x14(%rsp)
movq 0x168(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, (%rsp)
subl $-0x7e, %eax
je 0xa40a9
jmp 0xa3ee0
movl (%rsp), %eax
subl $-0x7a, %eax
je 0xa4120
jmp 0xa3eee
movl (%rsp), %eax
subl $-0x5b, %eax
je 0xa40fe
jmp 0xa3efc
movl (%rsp), %eax
subl $-0x56, %eax
je 0xa40e4
jmp 0xa3f0a
movl (%rsp), %eax
subl $0x28, %eax
je 0xa3f7b
jmp 0xa3f14
movl (%rsp), %eax
subl $0x29, %eax
je 0xa3fb2
jmp 0xa3f22
movl (%rsp), %eax
subl $0x2f, %eax
je 0xa412a
jmp 0xa3f30
movl (%rsp), %eax
subl $0x3b, %eax
je 0xa40e9
jmp 0xa3f3e
movl (%rsp), %eax
subl $0x3d, %eax
je 0xa4113
jmp 0xa3f4c
movl (%rsp), %eax
subl $0x5b, %eax
je 0xa3f7b
jmp 0xa3f56
movl (%rsp), %eax
subl $0x5d, %eax
je 0xa3fd7
jmp 0xa3f60
movl (%rsp), %eax
subl $0x7b, %eax
je 0xa3f7b
jmp 0xa3f6a
movl (%rsp), %eax
subl $0x7d, %eax
je 0xa3ffc
jmp 0xa417a
cmpq $0x100, 0x48(%rsp) # imm = 0x100
jb 0xa3f8b
jmp 0xa424c
movq 0x168(%rsp), %rax
movl 0x20(%rax), %eax
movb %al, %cl
movq 0x48(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x48(%rsp)
movb %cl, 0x50(%rsp,%rax)
jmp 0xa417a
movq 0x48(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x48(%rsp)
movzbl 0x4f(%rsp,%rax), %eax
cmpl $0x28, %eax
je 0xa3fd2
jmp 0xa424c
jmp 0xa417a
movq 0x48(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x48(%rsp)
movzbl 0x4f(%rsp,%rax), %eax
cmpl $0x5b, %eax
je 0xa3ff7
jmp 0xa424c
jmp 0xa417a
movq 0x48(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x48(%rsp)
movzbl 0x4f(%rsp,%rax), %eax
movl %eax, 0xc(%rsp)
cmpl $0x60, 0xc(%rsp)
jne 0xa4096
movq 0x168(%rsp), %rdi
movq 0x168(%rsp), %rsi
addq $0x20, %rsi
callq 0x4e460
movq 0x168(%rsp), %rax
movl $0x0, 0x58(%rax)
movq 0x168(%rsp), %rax
movl 0x24(%rax), %ecx
movq 0x168(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x168(%rsp), %rax
movl 0x28(%rax), %ecx
movq 0x168(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x168(%rsp), %rdi
movq 0x168(%rsp), %rax
movq 0x70(%rax), %rsi
callq 0x9d5a0
cmpl $0x0, %eax
je 0xa4094
jmp 0xa424c
jmp 0xa40ab
cmpl $0x7b, 0xc(%rsp)
je 0xa40a2
jmp 0xa424c
jmp 0xa40a4
jmp 0xa417a
jmp 0xa40ab
movq 0x168(%rsp), %rax
cmpl $0x60, 0x48(%rax)
je 0xa40df
cmpq $0x100, 0x48(%rsp) # imm = 0x100
jb 0xa40c9
jmp 0xa424c
movq 0x48(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rsp)
movb $0x60, 0x50(%rsp,%rax)
jmp 0xa417a
jmp 0xa424c
cmpq $0x2, 0x48(%rsp)
jne 0xa40fc
movl 0x4(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xa417a
cmpq $0x2, 0x48(%rsp)
jne 0xa4111
movl 0x4(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x4(%rsp)
jmp 0xa417a
movl 0x4(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x4(%rsp)
jmp 0xa417a
movl $0x2, 0x8(%rsp)
jmp 0xa4132
movl $0x1, 0x8(%rsp)
movl 0x14(%rsp), %edi
callq 0xa6760
cmpl $0x0, %eax
je 0xa4178
movl 0x8(%rsp), %edx
movq 0x168(%rsp), %rax
movq 0x70(%rax), %rcx
movslq %edx, %rsi
xorl %edx, %edx
subq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, 0x70(%rax)
movq 0x168(%rsp), %rdi
callq 0xa67f0
cmpl $0x0, %eax
je 0xa4176
jmp 0xa424c
jmp 0xa4178
jmp 0xa417a
movq 0x168(%rsp), %rax
cmpl $-0x7d, 0x20(%rax)
jne 0xa41c0
movq 0x168(%rsp), %rdi
movl $0x44, %esi
callq 0x9e640
cmpl $0x0, %eax
jne 0xa41b6
movq 0x168(%rsp), %rdi
movl $0x2d, %esi
callq 0x9e640
cmpl $0x0, %eax
je 0xa41c0
movl $0xffffffd9, 0x14(%rsp) # imm = 0xFFFFFFD9
jmp 0xa41cf
movq 0x168(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x168(%rsp), %rdi
callq 0x9bd00
cmpl $0x0, %eax
je 0xa41e3
jmp 0xa424a
cmpq $0x1, 0x48(%rsp)
ja 0xa4245
movq 0x168(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x168(%rsp), %rdi
movl $0x44, %esi
callq 0x9e640
cmpl $0x0, %eax
je 0xa4219
movl $0xffffffd9, 0x10(%rsp) # imm = 0xFFFFFFD9
cmpl $0x0, 0x15c(%rsp)
je 0xa4243
movq 0x168(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x168(%rsp), %rcx
cmpl 0x24(%rcx), %eax
je 0xa4243
movl $0xa, 0x10(%rsp)
jmp 0xa424a
jmp 0xa3ec7
jmp 0xa424c
cmpq $0x0, 0x160(%rsp)
je 0xa4265
movl 0x4(%rsp), %ecx
movq 0x160(%rsp), %rax
movl %ecx, (%rax)
movq 0x168(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x9e310
cmpl $0x0, %eax
je 0xa4289
movl $0xffffffff, 0x174(%rsp) # imm = 0xFFFFFFFF
jmp 0xa4294
movl 0x10(%rsp), %eax
movl %eax, 0x174(%rsp)
movl 0x174(%rsp), %eax
addq $0x178, %rsp # imm = 0x178
retq
nopw %cs:(%rax,%rax)
|
js_parse_skip_parens_token:
sub rsp, 178h
mov [rsp+178h+var_10], rdi
mov [rsp+178h+var_18], rsi
mov [rsp+178h+var_1C], edx
mov [rsp+178h+var_130], 0
mov [rsp+178h+var_168], 0FFFFFFAAh
mov [rsp+178h+var_174], 0
mov rax, [rsp+178h+var_130]
mov rcx, rax
add rcx, 1
mov [rsp+178h+var_130], rcx
mov [rsp+rax+178h+var_128], 0
mov rdi, [rsp+178h+var_10]
lea rsi, [rsp+178h+var_160]
call js_parse_get_pos
mov [rsp+178h+var_164], 0
loc_A3EC7:
mov rax, [rsp+178h+var_10]
mov eax, [rax+20h]
mov [rsp+178h+var_178], eax
sub eax, 0FFFFFF82h
jz loc_A40A9
jmp short $+2
loc_A3EE0:
mov eax, [rsp+178h+var_178]
sub eax, 0FFFFFF86h
jz loc_A4120
jmp short $+2
loc_A3EEE:
mov eax, [rsp+178h+var_178]
sub eax, 0FFFFFFA5h
jz loc_A40FE
jmp short $+2
loc_A3EFC:
mov eax, [rsp+178h+var_178]
sub eax, 0FFFFFFAAh
jz loc_A40E4
jmp short $+2
loc_A3F0A:
mov eax, [rsp+178h+var_178]
sub eax, 28h ; '('
jz short loc_A3F7B
jmp short $+2
loc_A3F14:
mov eax, [rsp+178h+var_178]
sub eax, 29h ; ')'
jz loc_A3FB2
jmp short $+2
loc_A3F22:
mov eax, [rsp+178h+var_178]
sub eax, 2Fh ; '/'
jz loc_A412A
jmp short $+2
loc_A3F30:
mov eax, [rsp+178h+var_178]
sub eax, 3Bh ; ';'
jz loc_A40E9
jmp short $+2
loc_A3F3E:
mov eax, [rsp+178h+var_178]
sub eax, 3Dh ; '='
jz loc_A4113
jmp short $+2
loc_A3F4C:
mov eax, [rsp+178h+var_178]
sub eax, 5Bh ; '['
jz short loc_A3F7B
jmp short $+2
loc_A3F56:
mov eax, [rsp+178h+var_178]
sub eax, 5Dh ; ']'
jz short loc_A3FD7
jmp short $+2
loc_A3F60:
mov eax, [rsp+178h+var_178]
sub eax, 7Bh ; '{'
jz short loc_A3F7B
jmp short $+2
loc_A3F6A:
mov eax, [rsp+178h+var_178]
sub eax, 7Dh ; '}'
jz loc_A3FFC
jmp loc_A417A
loc_A3F7B:
cmp [rsp+178h+var_130], 100h
jb short loc_A3F8B
jmp loc_A424C
loc_A3F8B:
mov rax, [rsp+178h+var_10]
mov eax, [rax+20h]
mov cl, al
mov rax, [rsp+178h+var_130]
mov rdx, rax
add rdx, 1
mov [rsp+178h+var_130], rdx
mov [rsp+rax+178h+var_128], cl
jmp loc_A417A
loc_A3FB2:
mov rax, [rsp+178h+var_130]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rsp+178h+var_130], rcx
movzx eax, byte ptr [rsp+rax+178h+var_130+7]
cmp eax, 28h ; '('
jz short loc_A3FD2
jmp loc_A424C
loc_A3FD2:
jmp loc_A417A
loc_A3FD7:
mov rax, [rsp+178h+var_130]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rsp+178h+var_130], rcx
movzx eax, byte ptr [rsp+rax+178h+var_130+7]
cmp eax, 5Bh ; '['
jz short loc_A3FF7
jmp loc_A424C
loc_A3FF7:
jmp loc_A417A
loc_A3FFC:
mov rax, [rsp+178h+var_130]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rsp+178h+var_130], rcx
movzx eax, byte ptr [rsp+rax+178h+var_130+7]
mov [rsp+178h+var_16C], eax
cmp [rsp+178h+var_16C], 60h ; '`'
jnz short loc_A4096
mov rdi, [rsp+178h+var_10]
mov rsi, [rsp+178h+var_10]
add rsi, 20h ; ' '
call free_token
mov rax, [rsp+178h+var_10]
mov dword ptr [rax+58h], 0
mov rax, [rsp+178h+var_10]
mov ecx, [rax+24h]
mov rax, [rsp+178h+var_10]
mov [rax+8], ecx
mov rax, [rsp+178h+var_10]
mov ecx, [rax+28h]
mov rax, [rsp+178h+var_10]
mov [rax+0Ch], ecx
mov rdi, [rsp+178h+var_10]
mov rax, [rsp+178h+var_10]
mov rsi, [rax+70h]
call js_parse_template_part
cmp eax, 0
jz short loc_A4094
jmp loc_A424C
loc_A4094:
jmp short loc_A40AB
loc_A4096:
cmp [rsp+178h+var_16C], 7Bh ; '{'
jz short loc_A40A2
jmp loc_A424C
loc_A40A2:
jmp short $+2
loc_A40A4:
jmp loc_A417A
loc_A40A9:
jmp short $+2
loc_A40AB:
mov rax, [rsp+178h+var_10]
cmp dword ptr [rax+48h], 60h ; '`'
jz short loc_A40DF
cmp [rsp+178h+var_130], 100h
jb short loc_A40C9
jmp loc_A424C
loc_A40C9:
mov rax, [rsp+178h+var_130]
mov rcx, rax
add rcx, 1
mov [rsp+178h+var_130], rcx
mov [rsp+rax+178h+var_128], 60h ; '`'
loc_A40DF:
jmp loc_A417A
loc_A40E4:
jmp loc_A424C
loc_A40E9:
cmp [rsp+178h+var_130], 2
jnz short loc_A40FC
mov eax, [rsp+178h+var_174]
or eax, 1
mov [rsp+178h+var_174], eax
loc_A40FC:
jmp short loc_A417A
loc_A40FE:
cmp [rsp+178h+var_130], 2
jnz short loc_A4111
mov eax, [rsp+178h+var_174]
or eax, 2
mov [rsp+178h+var_174], eax
loc_A4111:
jmp short loc_A417A
loc_A4113:
mov eax, [rsp+178h+var_174]
or eax, 4
mov [rsp+178h+var_174], eax
jmp short loc_A417A
loc_A4120:
mov [rsp+178h+var_170], 2
jmp short loc_A4132
loc_A412A:
mov [rsp+178h+var_170], 1
loc_A4132:
mov edi, [rsp+178h+var_164]
call is_regexp_allowed
cmp eax, 0
jz short loc_A4178
mov edx, [rsp+178h+var_170]
mov rax, [rsp+178h+var_10]
mov rcx, [rax+70h]
movsxd rsi, edx
xor edx, edx
sub rdx, rsi
add rcx, rdx
mov [rax+70h], rcx
mov rdi, [rsp+178h+var_10]
call js_parse_regexp
cmp eax, 0
jz short loc_A4176
jmp loc_A424C
loc_A4176:
jmp short $+2
loc_A4178:
jmp short $+2
loc_A417A:
mov rax, [rsp+178h+var_10]
cmp dword ptr [rax+20h], 0FFFFFF83h
jnz short loc_A41C0
mov rdi, [rsp+178h+var_10]
mov esi, 44h ; 'D'
call token_is_pseudo_keyword
cmp eax, 0
jnz short loc_A41B6
mov rdi, [rsp+178h+var_10]
mov esi, 2Dh ; '-'
call token_is_pseudo_keyword
cmp eax, 0
jz short loc_A41C0
loc_A41B6:
mov [rsp+178h+var_164], 0FFFFFFD9h
jmp short loc_A41CF
loc_A41C0:
mov rax, [rsp+178h+var_10]
mov eax, [rax+20h]
mov [rsp+178h+var_164], eax
loc_A41CF:
mov rdi, [rsp+178h+var_10]
call next_token
cmp eax, 0
jz short loc_A41E3
jmp short loc_A424A
loc_A41E3:
cmp [rsp+178h+var_130], 1
ja short loc_A4245
mov rax, [rsp+178h+var_10]
mov eax, [rax+20h]
mov [rsp+178h+var_168], eax
mov rdi, [rsp+178h+var_10]
mov esi, 44h ; 'D'
call token_is_pseudo_keyword
cmp eax, 0
jz short loc_A4219
mov [rsp+178h+var_168], 0FFFFFFD9h
loc_A4219:
cmp [rsp+178h+var_1C], 0
jz short loc_A4243
mov rax, [rsp+178h+var_10]
mov eax, [rax+8]
mov rcx, [rsp+178h+var_10]
cmp eax, [rcx+24h]
jz short loc_A4243
mov [rsp+178h+var_168], 0Ah
loc_A4243:
jmp short loc_A424A
loc_A4245:
jmp loc_A3EC7
loc_A424A:
jmp short $+2
loc_A424C:
cmp [rsp+178h+var_18], 0
jz short loc_A4265
mov ecx, [rsp+178h+var_174]
mov rax, [rsp+178h+var_18]
mov [rax], ecx
loc_A4265:
mov rdi, [rsp+178h+var_10]
lea rsi, [rsp+178h+var_160]
call js_parse_seek_token
cmp eax, 0
jz short loc_A4289
mov [rsp+178h+var_4], 0FFFFFFFFh
jmp short loc_A4294
loc_A4289:
mov eax, [rsp+178h+var_168]
mov [rsp+178h+var_4], eax
loc_A4294:
mov eax, [rsp+178h+var_4]
add rsp, 178h
retn
|
long long js_parse_skip_parens_token(
long long *a1,
_DWORD *a2,
int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
double v11; // xmm4_8
double v12; // xmm5_8
char v13; // cl
unsigned long long v14; // rax
unsigned long long v15; // rax
unsigned long long v16; // rax
unsigned long long v17; // rax
double v18; // xmm4_8
double v19; // xmm5_8
unsigned long long v20; // rax
int v22; // [rsp+0h] [rbp-178h]
int v23; // [rsp+4h] [rbp-174h]
int v24; // [rsp+8h] [rbp-170h]
int v25; // [rsp+Ch] [rbp-16Ch]
unsigned int v26; // [rsp+10h] [rbp-168h]
unsigned int v27; // [rsp+14h] [rbp-164h]
_BYTE v28[48]; // [rsp+18h] [rbp-160h] BYREF
unsigned long long v29; // [rsp+48h] [rbp-130h]
_BYTE v30[268]; // [rsp+50h] [rbp-128h]
int v31; // [rsp+15Ch] [rbp-1Ch]
_DWORD *v32; // [rsp+160h] [rbp-18h]
long long *v33; // [rsp+168h] [rbp-10h]
v33 = a1;
v32 = a2;
v31 = a3;
v26 = -86;
v23 = 0;
v29 = 1LL;
v30[0] = 0;
js_parse_get_pos((long long)a1, (long long)v28);
v27 = 0;
do
{
v22 = *((_DWORD *)v33 + 8);
switch ( v22 )
{
case -126:
goto LABEL_27;
case -122:
v24 = 2;
break;
case -91:
if ( v29 == 2 )
v23 |= 2u;
goto LABEL_43;
case -86:
goto LABEL_57;
case 40:
LABEL_16:
if ( v29 >= 0x100 )
goto LABEL_57;
v13 = *((_DWORD *)v33 + 8);
v14 = v29++;
v30[v14] = v13;
goto LABEL_43;
case 41:
v15 = v29--;
if ( v30[v15 - 1] != 40 )
goto LABEL_57;
goto LABEL_43;
case 47:
v24 = 1;
break;
case 59:
if ( v29 == 2 )
v23 |= 1u;
goto LABEL_43;
case 61:
v23 |= 4u;
goto LABEL_43;
case 91:
goto LABEL_16;
case 93:
v16 = v29--;
if ( v30[v16 - 1] != 91 )
goto LABEL_57;
goto LABEL_43;
case 123:
goto LABEL_16;
case 125:
v17 = v29--;
v25 = (unsigned __int8)v30[v17 - 1];
if ( v25 != 96 )
{
if ( v25 != 123 )
goto LABEL_57;
goto LABEL_43;
}
free_token(v33, (long long)(v33 + 4));
*((_DWORD *)v33 + 22) = 0;
*((_DWORD *)v33 + 2) = *((_DWORD *)v33 + 9);
*((_DWORD *)v33 + 3) = *((_DWORD *)v33 + 10);
if ( (unsigned int)js_parse_template_part(v33, (unsigned __int8 *)v33[14], a4, a5, a6, a7, v18, v19, a10, a11) )
goto LABEL_57;
LABEL_27:
if ( *((_DWORD *)v33 + 18) != 96 )
{
if ( v29 >= 0x100 )
goto LABEL_57;
v20 = v29++;
v30[v20] = 96;
}
goto LABEL_43;
default:
goto LABEL_43;
}
if ( (unsigned int)is_regexp_allowed(v27) )
{
v33[14] -= v24;
if ( (unsigned int)js_parse_regexp(v33) )
goto LABEL_57;
}
LABEL_43:
if ( *((_DWORD *)v33 + 8) == -125
&& ((unsigned int)token_is_pseudo_keyword(v33, 68) || (unsigned int)token_is_pseudo_keyword(v33, 45)) )
{
v27 = -39;
}
else
{
v27 = *((_DWORD *)v33 + 8);
}
if ( (unsigned int)next_token(v33, a4, a5, a6, a7, v11, v12, a10, a11) )
goto LABEL_57;
}
while ( v29 > 1 );
v26 = *((_DWORD *)v33 + 8);
if ( (unsigned int)token_is_pseudo_keyword(v33, 68) )
v26 = -39;
if ( v31 && *((_DWORD *)v33 + 2) != *((_DWORD *)v33 + 9) )
v26 = 10;
LABEL_57:
if ( v32 )
*v32 = v23;
if ( (unsigned int)js_parse_seek_token((long long)v33, (long long)v28, a4, a5, a6, a7, v11, v12, a10, a11) )
return (unsigned int)-1;
else
return v26;
}
|
js_parse_skip_parens_token:
SUB RSP,0x178
MOV qword ptr [RSP + 0x168],RDI
MOV qword ptr [RSP + 0x160],RSI
MOV dword ptr [RSP + 0x15c],EDX
MOV qword ptr [RSP + 0x48],0x0
MOV dword ptr [RSP + 0x10],0xffffffaa
MOV dword ptr [RSP + 0x4],0x0
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0x48],RCX
MOV byte ptr [RSP + RAX*0x1 + 0x50],0x0
MOV RDI,qword ptr [RSP + 0x168]
LEA RSI,[RSP + 0x18]
CALL 0x0019e270
MOV dword ptr [RSP + 0x14],0x0
LAB_001a3ec7:
MOV RAX,qword ptr [RSP + 0x168]
MOV EAX,dword ptr [RAX + 0x20]
MOV dword ptr [RSP],EAX
SUB EAX,-0x7e
JZ 0x001a40a9
JMP 0x001a3ee0
LAB_001a3ee0:
MOV EAX,dword ptr [RSP]
SUB EAX,-0x7a
JZ 0x001a4120
JMP 0x001a3eee
LAB_001a3eee:
MOV EAX,dword ptr [RSP]
SUB EAX,-0x5b
JZ 0x001a40fe
JMP 0x001a3efc
LAB_001a3efc:
MOV EAX,dword ptr [RSP]
SUB EAX,-0x56
JZ 0x001a40e4
JMP 0x001a3f0a
LAB_001a3f0a:
MOV EAX,dword ptr [RSP]
SUB EAX,0x28
JZ 0x001a3f7b
JMP 0x001a3f14
LAB_001a3f14:
MOV EAX,dword ptr [RSP]
SUB EAX,0x29
JZ 0x001a3fb2
JMP 0x001a3f22
LAB_001a3f22:
MOV EAX,dword ptr [RSP]
SUB EAX,0x2f
JZ 0x001a412a
JMP 0x001a3f30
LAB_001a3f30:
MOV EAX,dword ptr [RSP]
SUB EAX,0x3b
JZ 0x001a40e9
JMP 0x001a3f3e
LAB_001a3f3e:
MOV EAX,dword ptr [RSP]
SUB EAX,0x3d
JZ 0x001a4113
JMP 0x001a3f4c
LAB_001a3f4c:
MOV EAX,dword ptr [RSP]
SUB EAX,0x5b
JZ 0x001a3f7b
JMP 0x001a3f56
LAB_001a3f56:
MOV EAX,dword ptr [RSP]
SUB EAX,0x5d
JZ 0x001a3fd7
JMP 0x001a3f60
LAB_001a3f60:
MOV EAX,dword ptr [RSP]
SUB EAX,0x7b
JZ 0x001a3f7b
JMP 0x001a3f6a
LAB_001a3f6a:
MOV EAX,dword ptr [RSP]
SUB EAX,0x7d
JZ 0x001a3ffc
JMP 0x001a417a
LAB_001a3f7b:
CMP qword ptr [RSP + 0x48],0x100
JC 0x001a3f8b
JMP 0x001a424c
LAB_001a3f8b:
MOV RAX,qword ptr [RSP + 0x168]
MOV EAX,dword ptr [RAX + 0x20]
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x48]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RSP + 0x48],RDX
MOV byte ptr [RSP + RAX*0x1 + 0x50],CL
JMP 0x001a417a
LAB_001a3fb2:
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RSP + 0x48],RCX
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x4f]
CMP EAX,0x28
JZ 0x001a3fd2
JMP 0x001a424c
LAB_001a3fd2:
JMP 0x001a417a
LAB_001a3fd7:
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RSP + 0x48],RCX
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x4f]
CMP EAX,0x5b
JZ 0x001a3ff7
JMP 0x001a424c
LAB_001a3ff7:
JMP 0x001a417a
LAB_001a3ffc:
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RSP + 0x48],RCX
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x4f]
MOV dword ptr [RSP + 0xc],EAX
CMP dword ptr [RSP + 0xc],0x60
JNZ 0x001a4096
MOV RDI,qword ptr [RSP + 0x168]
MOV RSI,qword ptr [RSP + 0x168]
ADD RSI,0x20
CALL 0x0014e460
MOV RAX,qword ptr [RSP + 0x168]
MOV dword ptr [RAX + 0x58],0x0
MOV RAX,qword ptr [RSP + 0x168]
MOV ECX,dword ptr [RAX + 0x24]
MOV RAX,qword ptr [RSP + 0x168]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RSP + 0x168]
MOV ECX,dword ptr [RAX + 0x28]
MOV RAX,qword ptr [RSP + 0x168]
MOV dword ptr [RAX + 0xc],ECX
MOV RDI,qword ptr [RSP + 0x168]
MOV RAX,qword ptr [RSP + 0x168]
MOV RSI,qword ptr [RAX + 0x70]
CALL 0x0019d5a0
CMP EAX,0x0
JZ 0x001a4094
JMP 0x001a424c
LAB_001a4094:
JMP 0x001a40ab
LAB_001a4096:
CMP dword ptr [RSP + 0xc],0x7b
JZ 0x001a40a2
JMP 0x001a424c
LAB_001a40a2:
JMP 0x001a40a4
LAB_001a40a4:
JMP 0x001a417a
LAB_001a40a9:
JMP 0x001a40ab
LAB_001a40ab:
MOV RAX,qword ptr [RSP + 0x168]
CMP dword ptr [RAX + 0x48],0x60
JZ 0x001a40df
CMP qword ptr [RSP + 0x48],0x100
JC 0x001a40c9
JMP 0x001a424c
LAB_001a40c9:
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0x48],RCX
MOV byte ptr [RSP + RAX*0x1 + 0x50],0x60
LAB_001a40df:
JMP 0x001a417a
LAB_001a40e4:
JMP 0x001a424c
LAB_001a40e9:
CMP qword ptr [RSP + 0x48],0x2
JNZ 0x001a40fc
MOV EAX,dword ptr [RSP + 0x4]
OR EAX,0x1
MOV dword ptr [RSP + 0x4],EAX
LAB_001a40fc:
JMP 0x001a417a
LAB_001a40fe:
CMP qword ptr [RSP + 0x48],0x2
JNZ 0x001a4111
MOV EAX,dword ptr [RSP + 0x4]
OR EAX,0x2
MOV dword ptr [RSP + 0x4],EAX
LAB_001a4111:
JMP 0x001a417a
LAB_001a4113:
MOV EAX,dword ptr [RSP + 0x4]
OR EAX,0x4
MOV dword ptr [RSP + 0x4],EAX
JMP 0x001a417a
LAB_001a4120:
MOV dword ptr [RSP + 0x8],0x2
JMP 0x001a4132
LAB_001a412a:
MOV dword ptr [RSP + 0x8],0x1
LAB_001a4132:
MOV EDI,dword ptr [RSP + 0x14]
CALL 0x001a6760
CMP EAX,0x0
JZ 0x001a4178
MOV EDX,dword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x168]
MOV RCX,qword ptr [RAX + 0x70]
MOVSXD RSI,EDX
XOR EDX,EDX
SUB RDX,RSI
ADD RCX,RDX
MOV qword ptr [RAX + 0x70],RCX
MOV RDI,qword ptr [RSP + 0x168]
CALL 0x001a67f0
CMP EAX,0x0
JZ 0x001a4176
JMP 0x001a424c
LAB_001a4176:
JMP 0x001a4178
LAB_001a4178:
JMP 0x001a417a
LAB_001a417a:
MOV RAX,qword ptr [RSP + 0x168]
CMP dword ptr [RAX + 0x20],-0x7d
JNZ 0x001a41c0
MOV RDI,qword ptr [RSP + 0x168]
MOV ESI,0x44
CALL 0x0019e640
CMP EAX,0x0
JNZ 0x001a41b6
MOV RDI,qword ptr [RSP + 0x168]
MOV ESI,0x2d
CALL 0x0019e640
CMP EAX,0x0
JZ 0x001a41c0
LAB_001a41b6:
MOV dword ptr [RSP + 0x14],0xffffffd9
JMP 0x001a41cf
LAB_001a41c0:
MOV RAX,qword ptr [RSP + 0x168]
MOV EAX,dword ptr [RAX + 0x20]
MOV dword ptr [RSP + 0x14],EAX
LAB_001a41cf:
MOV RDI,qword ptr [RSP + 0x168]
CALL 0x0019bd00
CMP EAX,0x0
JZ 0x001a41e3
JMP 0x001a424a
LAB_001a41e3:
CMP qword ptr [RSP + 0x48],0x1
JA 0x001a4245
MOV RAX,qword ptr [RSP + 0x168]
MOV EAX,dword ptr [RAX + 0x20]
MOV dword ptr [RSP + 0x10],EAX
MOV RDI,qword ptr [RSP + 0x168]
MOV ESI,0x44
CALL 0x0019e640
CMP EAX,0x0
JZ 0x001a4219
MOV dword ptr [RSP + 0x10],0xffffffd9
LAB_001a4219:
CMP dword ptr [RSP + 0x15c],0x0
JZ 0x001a4243
MOV RAX,qword ptr [RSP + 0x168]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RSP + 0x168]
CMP EAX,dword ptr [RCX + 0x24]
JZ 0x001a4243
MOV dword ptr [RSP + 0x10],0xa
LAB_001a4243:
JMP 0x001a424a
LAB_001a4245:
JMP 0x001a3ec7
LAB_001a424a:
JMP 0x001a424c
LAB_001a424c:
CMP qword ptr [RSP + 0x160],0x0
JZ 0x001a4265
MOV ECX,dword ptr [RSP + 0x4]
MOV RAX,qword ptr [RSP + 0x160]
MOV dword ptr [RAX],ECX
LAB_001a4265:
MOV RDI,qword ptr [RSP + 0x168]
LEA RSI,[RSP + 0x18]
CALL 0x0019e310
CMP EAX,0x0
JZ 0x001a4289
MOV dword ptr [RSP + 0x174],0xffffffff
JMP 0x001a4294
LAB_001a4289:
MOV EAX,dword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x174],EAX
LAB_001a4294:
MOV EAX,dword ptr [RSP + 0x174]
ADD RSP,0x178
RET
|
int4 js_parse_skip_parens_token(long param_1,uint *param_2,int param_3)
{
long lVar1;
int iVar2;
ulong uVar3;
uint local_174;
int local_170;
int4 local_168;
int4 local_164;
int1 local_160 [48];
int8 local_130;
int1 auStack_128 [268];
int local_1c;
uint *local_18;
long local_10;
int4 local_4;
local_168 = 0xffffffaa;
local_174 = 0;
local_130 = 1;
auStack_128[0] = 0;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
js_parse_get_pos(param_1,local_160);
local_164 = 0;
do {
iVar2 = *(int *)(local_10 + 0x20);
if (iVar2 == -0x7e) {
LAB_001a40ab:
if (*(int *)(local_10 + 0x48) != 0x60) {
if (0xff < local_130) goto LAB_001a424c;
auStack_128[local_130] = 0x60;
local_130 = local_130 + 1;
}
}
else if (iVar2 == -0x7a) {
local_170 = 2;
LAB_001a4132:
iVar2 = is_regexp_allowed(local_164);
if (iVar2 != 0) {
*(long *)(local_10 + 0x70) = *(long *)(local_10 + 0x70) - (long)local_170;
iVar2 = js_parse_regexp(local_10);
if (iVar2 != 0) goto LAB_001a424c;
}
}
else if (iVar2 == -0x5b) {
if (local_130 == 2) {
local_174 = local_174 | 2;
}
}
else {
if (iVar2 == -0x56) goto LAB_001a424c;
if (iVar2 == 0x28) goto LAB_001a3f7b;
if (iVar2 == 0x29) {
uVar3 = local_130 - 1;
lVar1 = local_130 - 1;
local_130 = uVar3;
if (auStack_128[lVar1] != '(') goto LAB_001a424c;
}
else {
if (iVar2 == 0x2f) {
local_170 = 1;
goto LAB_001a4132;
}
if (iVar2 == 0x3b) {
if (local_130 == 2) {
local_174 = local_174 | 1;
}
}
else if (iVar2 == 0x3d) {
local_174 = local_174 | 4;
}
else if (iVar2 == 0x5b) {
LAB_001a3f7b:
if (0xff < local_130) goto LAB_001a424c;
auStack_128[local_130] = (char)*(int4 *)(local_10 + 0x20);
local_130 = local_130 + 1;
}
else if (iVar2 == 0x5d) {
uVar3 = local_130 - 1;
lVar1 = local_130 - 1;
local_130 = uVar3;
if (auStack_128[lVar1] != '[') goto LAB_001a424c;
}
else {
if (iVar2 == 0x7b) goto LAB_001a3f7b;
if (iVar2 == 0x7d) {
uVar3 = local_130 - 1;
lVar1 = local_130 - 1;
local_130 = uVar3;
if (auStack_128[lVar1] == '`') {
free_token(local_10,local_10 + 0x20);
*(int4 *)(local_10 + 0x58) = 0;
*(int4 *)(local_10 + 8) = *(int4 *)(local_10 + 0x24);
*(int4 *)(local_10 + 0xc) = *(int4 *)(local_10 + 0x28);
iVar2 = js_parse_template_part(local_10,*(int8 *)(local_10 + 0x70));
if (iVar2 == 0) goto LAB_001a40ab;
goto LAB_001a424c;
}
if (auStack_128[lVar1] != '{') goto LAB_001a424c;
}
}
}
}
if ((*(int *)(local_10 + 0x20) == -0x7d) &&
((iVar2 = token_is_pseudo_keyword(local_10,0x44), iVar2 != 0 ||
(iVar2 = token_is_pseudo_keyword(local_10,0x2d), iVar2 != 0)))) {
local_164 = 0xffffffd9;
}
else {
local_164 = *(int4 *)(local_10 + 0x20);
}
iVar2 = next_token(local_10);
if (iVar2 != 0) goto LAB_001a424c;
} while (1 < local_130);
local_168 = *(int4 *)(local_10 + 0x20);
iVar2 = token_is_pseudo_keyword(local_10,0x44);
if (iVar2 != 0) {
local_168 = 0xffffffd9;
}
if ((local_1c != 0) && (*(int *)(local_10 + 8) != *(int *)(local_10 + 0x24))) {
local_168 = 10;
}
LAB_001a424c:
if (local_18 != (uint *)0x0) {
*local_18 = local_174;
}
iVar2 = js_parse_seek_token(local_10,local_160);
if (iVar2 == 0) {
local_4 = local_168;
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
|
|
17,215
|
print_xml_comment
|
eloqsql/client/mysqldump.c
|
static void print_xml_comment(FILE *xml_file, size_t len,
const char *comment_string)
{
const char* end;
fputs("<!-- ", xml_file);
for (end= comment_string + len; comment_string != end; comment_string++)
{
/*
The string "--" (double-hyphen) MUST NOT occur within xml comments.
*/
switch (*comment_string) {
case '-':
if (*(comment_string + 1) == '-') /* Only one hyphen allowed. */
break;
/* fall through */
default:
fputc(*comment_string, xml_file);
break;
}
}
fputs(" -->\n", xml_file);
check_io(xml_file);
}
|
O0
|
c
|
print_xml_comment:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x9d9ae(%rip), %rdi # 0xdb81d
callq 0x38340
movq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x3dec7
movq -0x18(%rbp), %rax
movb (%rax), %al
subb $0x2d, %al
jne 0x3dea7
jmp 0x3de96
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2d, %eax
jne 0x3dea5
jmp 0x3deb7
jmp 0x3dea7
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
movq -0x8(%rbp), %rsi
callq 0x388b0
jmp 0x3deb9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3de80
movq -0x8(%rbp), %rsi
leaq 0x9d951(%rip), %rdi # 0xdb823
callq 0x38340
movq -0x8(%rbp), %rdi
callq 0x38d60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
print_xml_comment:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rsi, [rbp+var_8]
lea rdi, asc_DB81D; "<!-- "
call _fputs
mov rax, [rbp+var_18]
add rax, [rbp+var_10]
mov [rbp+var_20], rax
loc_3DE80:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jz short loc_3DEC7
mov rax, [rbp+var_18]
mov al, [rax]
sub al, 2Dh ; '-'
jnz short loc_3DEA7
jmp short $+2
loc_3DE96:
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax+1]
cmp eax, 2Dh ; '-'
jnz short loc_3DEA5
jmp short loc_3DEB7
loc_3DEA5:
jmp short $+2
loc_3DEA7:
mov rax, [rbp+var_18]
movsx edi, byte ptr [rax]
mov rsi, [rbp+var_8]
call _fputc
loc_3DEB7:
jmp short $+2
loc_3DEB9:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_3DE80
loc_3DEC7:
mov rsi, [rbp+var_8]
lea rdi, asc_DB823; " -->\n"
call _fputs
mov rdi, [rbp+var_8]
call check_io
add rsp, 20h
pop rbp
retn
|
long long print_xml_comment(long long a1, long long a2, char *a3)
{
char *v4; // [rsp+0h] [rbp-20h]
fputs("<!-- ", a1);
v4 = &a3[a2];
while ( a3 != v4 )
{
if ( *a3 != 45 || a3[1] != 45 )
fputc((unsigned int)*a3, a1);
++a3;
}
fputs(" -->\n", a1);
return check_io(a1);
}
|
print_xml_comment:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[0x1db81d]
CALL 0x00138340
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
LAB_0013de80:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x0013dec7
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX]
SUB AL,0x2d
JNZ 0x0013dea7
JMP 0x0013de96
LAB_0013de96:
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x2d
JNZ 0x0013dea5
JMP 0x0013deb7
LAB_0013dea5:
JMP 0x0013dea7
LAB_0013dea7:
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EDI,byte ptr [RAX]
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x001388b0
LAB_0013deb7:
JMP 0x0013deb9
LAB_0013deb9:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0013de80
LAB_0013dec7:
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[0x1db823]
CALL 0x00138340
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00138d60
ADD RSP,0x20
POP RBP
RET
|
void print_xml_comment(FILE *param_1,long param_2,char *param_3)
{
char *local_20;
fputs("<!-- ",param_1);
for (local_20 = param_3; local_20 != param_3 + param_2; local_20 = local_20 + 1) {
if ((*local_20 != '-') || (local_20[1] != '-')) {
fputc((int)*local_20,param_1);
}
}
fputs(" -->\n",param_1);
check_io(param_1);
return;
}
|
|
17,216
|
nlohmann::json_abi_v3_11_3::detail::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>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::parser(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, 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>&)>, bool, bool)
|
hkr04[P]cpp-mcp/common/json.hpp
|
explicit parser(InputAdapterType&& adapter,
const parser_callback_t<BasicJsonType> cb = nullptr,
const bool allow_exceptions_ = true,
const bool skip_comments = false)
: callback(cb)
, m_lexer(std::move(adapter), skip_comments)
, allow_exceptions(allow_exceptions_)
{
// read first token
get_token();
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::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>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::parser(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, 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>&)>, bool, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x38164
movl $0x0, 0x20(%rbx)
leaq 0x28(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x387b8
movb %r14b, 0xc0(%rbx)
movq %r15, %rdi
callq 0x38858
movl %eax, 0x20(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x38824
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x387a8
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x8960
movq %rax, %rdi
callq 0xae2d
|
_ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEEC2EOSM_St8functionIFbiNS1_13parse_event_tERSF_EEbb:
push rbp
push r15
push r14
push r12
push rbx
mov ebp, r8d
mov r14d, ecx
mov r12, rsi
mov rbx, rdi
mov rsi, rdx
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEC2ERKSJ_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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> &)>::function(std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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 dword ptr [rbx+20h], 0
lea r15, [rbx+28h]
mov rdi, r15
mov rsi, r12
mov edx, ebp
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEEC2EOSM_b; 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>>>::lexer(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>&&,bool)
mov [rbx+0C0h], r14b
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE4scanEv; 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>>>::scan(void)
mov [rbx+20h], eax
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; 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>>>::~lexer()
mov rax, [rbx+10h]
test rax, rax
jz short loc_387A8
mov rdi, rbx
mov rsi, rbx
mov edx, 3
call rax
loc_387A8:
mov rdi, r14
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
|
long long nlohmann::json_abi_v3_11_3::detail::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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::parser(
long long a1,
long long a2,
long long a3,
char a4,
unsigned int a5)
{
long long result; // rax
std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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> &)>::function(
(_OWORD *)a1,
a3);
*(_DWORD *)(a1 + 32) = 0;
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>>>::lexer(
a1 + 40,
a2,
a5);
*(_BYTE *)(a1 + 192) = a4;
result = 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>>>::scan(a1 + 40);
*(_DWORD *)(a1 + 32) = result;
return result;
}
|
parser:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBP,R8D
MOV R14D,ECX
MOV R12,RSI
MOV RBX,RDI
MOV RSI,RDX
CALL 0x00138164
MOV dword ptr [RBX + 0x20],0x0
LEA R15,[RBX + 0x28]
MOV RDI,R15
MOV RSI,R12
MOV EDX,EBP
CALL 0x001387b8
MOV byte ptr [RBX + 0xc0],R14B
LAB_00138773:
MOV RDI,R15
CALL 0x00138858
MOV dword ptr [RBX + 0x20],EAX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::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>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > >
>::parser(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > >&&, std::function<bool (int,
nlohmann::json_abi_v3_11_3::detail::parse_event_t,
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>&)>, bool, bool) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::parser(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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this,iterator_input_adapter *param_1,function *param_3,
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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
param_4,bool param_5)
{
int4 uVar1;
std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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>&)>
::function((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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,param_3);
*(int4 *)(this + 0x20) = 0;
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>>>
::lexer((lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*)(this + 0x28),param_1,param_5);
this[0xc0] = param_4;
/* try { // try from 00138773 to 0013877a has its CatchHandler @ 00138787 */
uVar1 = 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>>>
::scan((lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*)(this + 0x28));
*(int4 *)(this + 0x20) = uVar1;
return;
}
|
|
17,217
|
common_params_get_system_info[abi:cxx11](common_params const&)
|
llama.cpp/common/common.cpp
|
std::string common_params_get_system_info(const common_params & params) {
std::ostringstream os;
os << "system_info: n_threads = " << params.cpuparams.n_threads;
if (params.cpuparams_batch.n_threads != -1) {
os << " (n_threads_batch = " << params.cpuparams_batch.n_threads << ")";
}
#if defined(_WIN32) && (_WIN32_WINNT >= 0x0601) && !defined(__MINGW64__) // windows 7 and later
// TODO: windows + arm64 + mingw64
DWORD logicalProcessorCount = GetActiveProcessorCount(ALL_PROCESSOR_GROUPS);
os << " / " << logicalProcessorCount << " | " << llama_print_system_info();
#else
os << " / " << std::thread::hardware_concurrency() << " | " << llama_print_system_info();
#endif
return os.str();
}
|
O3
|
cpp
|
common_params_get_system_info[abi:cxx11](common_params const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x21070
leaq 0x2d75d(%rip), %rsi # 0x127782
movl $0x19, %edx
movq %r15, %rdi
callq 0x210d0
movl 0x274(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x20540
cmpl $-0x1, 0x488(%r14)
je 0xfa088
leaq 0x2d748(%rip), %rsi # 0x12779c
leaq 0x8(%rsp), %rdi
movl $0x14, %edx
callq 0x210d0
movl 0x488(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x20540
leaq 0x25336(%rip), %rsi # 0x11f3b1
movl $0x1, %edx
movq %rax, %rdi
callq 0x210d0
leaq 0x2d722(%rip), %rsi # 0x1277b1
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
callq 0x210d0
callq 0x20e40
movl %eax, %esi
leaq 0x8(%rsp), %rdi
callq 0x208d0
movq %rax, %r14
leaq 0x2ecb5(%rip), %rsi # 0x128d6e
movl $0x3, %edx
movq %rax, %rdi
callq 0x210d0
callq 0x20060
movq %rax, %r15
testq %rax, %rax
je 0xfa0eb
movq %r15, %rdi
callq 0x206b0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x210d0
jmp 0xfa105
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x21330
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x20690
movq 0x6be3f(%rip), %rsi # 0x165f58
leaq 0x8(%rsp), %rdi
callq 0x20cd0
leaq 0x78(%rsp), %rdi
callq 0x20ca0
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x6be11(%rip), %rsi # 0x165f58
leaq 0x8(%rsp), %rdi
callq 0x20cd0
leaq 0x78(%rsp), %rdi
callq 0x20ca0
movq %rbx, %rdi
callq 0x20b50
|
_Z29common_params_get_system_infoB5cxx11RK13common_params:
push r15
push r14
push rbx
sub rsp, 180h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+198h+var_190]
mov rdi, r15
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rsi, aSystemInfoNThr; "system_info: n_threads = "
mov edx, 19h
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov esi, [r14+274h]
lea rdi, [rsp+198h+var_190]
call __ZNSolsEi; std::ostream::operator<<(int)
cmp dword ptr [r14+488h], 0FFFFFFFFh
jz short loc_FA088
lea rsi, aNThreadsBatch; " (n_threads_batch = "
lea rdi, [rsp+198h+var_190]
mov edx, 14h
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov esi, [r14+488h]
lea rdi, [rsp+198h+var_190]
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, aCompreplyCompg_2+3Ah; ")"
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_FA088:
lea rsi, asc_1277B1; " / "
lea rdi, [rsp+198h+var_190]; this
mov edx, 3
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
call __ZNSt6thread20hardware_concurrencyEv; std::thread::hardware_concurrency(void)
mov esi, eax
lea rdi, [rsp+198h+var_190]
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
mov r14, rax
lea rsi, asc_128D6D+1; " | "
mov edx, 3
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
call _llama_print_system_info
mov r15, rax
test rax, rax
jz short loc_FA0EB
mov rdi, r15
call _strlen
mov rdi, r14
mov rsi, r15
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_FA105
loc_FA0EB:
mov rax, [r14]
mov rax, [rax-18h]
mov rdi, r14
add rdi, rax
mov esi, [r14+rax+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_FA105:
lea rsi, [rsp+198h+var_188]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+198h+var_190]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+198h+var_120]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 180h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_0]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+arg_70]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
|
long long common_params_get_system_info[abi:cxx11](long long a1, long long a2)
{
long long v2; // rax
unsigned int v3; // eax
_QWORD *v4; // r14
long long v5; // rax
long long v6; // r15
long long v7; // rax
_BYTE v9[8]; // [rsp+8h] [rbp-190h] BYREF
_BYTE v10[104]; // [rsp+10h] [rbp-188h] BYREF
_BYTE v11[288]; // [rsp+78h] [rbp-120h] BYREF
std::ostringstream::basic_ostringstream(v9);
std::__ostream_insert<char,std::char_traits<char>>(v9, "system_info: n_threads = ", 25LL);
std::ostream::operator<<(v9, *(unsigned int *)(a2 + 628));
if ( *(_DWORD *)(a2 + 1160) != -1 )
{
std::__ostream_insert<char,std::char_traits<char>>(v9, " (n_threads_batch = ", 20LL);
v2 = std::ostream::operator<<(v9, *(unsigned int *)(a2 + 1160));
std::__ostream_insert<char,std::char_traits<char>>(v2, ")", 1LL);
}
std::__ostream_insert<char,std::char_traits<char>>(v9, " / ", 3LL);
v3 = std::thread::hardware_concurrency((std::thread *)v9);
v4 = (_QWORD *)std::ostream::_M_insert<unsigned long>(v9, v3);
std::__ostream_insert<char,std::char_traits<char>>(v4, " | ", 3LL);
v5 = llama_print_system_info();
v6 = v5;
if ( v5 )
{
v7 = strlen(v5);
std::__ostream_insert<char,std::char_traits<char>>(v4, v6, v7);
}
else
{
std::ios::clear((char *)v4 + *(_QWORD *)(*v4 - 24LL), *(_DWORD *)((char *)v4 + *(_QWORD *)(*v4 - 24LL) + 32) | 1u);
}
std::stringbuf::str(a1, v10);
std::ostringstream::~ostringstream(v9, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v11);
return a1;
}
|
common_params_get_system_info[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x180
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00121070
LAB_001fa01e:
LEA RSI,[0x227782]
MOV EDX,0x19
MOV RDI,R15
CALL 0x001210d0
MOV ESI,dword ptr [R14 + 0x274]
LEA RDI,[RSP + 0x8]
CALL 0x00120540
CMP dword ptr [R14 + 0x488],-0x1
JZ 0x001fa088
LEA RSI,[0x22779c]
LEA RDI,[RSP + 0x8]
MOV EDX,0x14
CALL 0x001210d0
MOV ESI,dword ptr [R14 + 0x488]
LEA RDI,[RSP + 0x8]
CALL 0x00120540
LEA RSI,[0x21f3b1]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001210d0
LAB_001fa088:
LEA RSI,[0x2277b1]
LEA RDI,[RSP + 0x8]
MOV EDX,0x3
CALL 0x001210d0
CALL 0x00120e40
MOV ESI,EAX
LEA RDI,[RSP + 0x8]
CALL 0x001208d0
MOV R14,RAX
LEA RSI,[0x228d6e]
MOV EDX,0x3
MOV RDI,RAX
CALL 0x001210d0
CALL 0x00120060
MOV R15,RAX
TEST RAX,RAX
JZ 0x001fa0eb
MOV RDI,R15
CALL 0x001206b0
MOV RDI,R14
MOV RSI,R15
MOV RDX,RAX
CALL 0x001210d0
JMP 0x001fa105
LAB_001fa0eb:
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + -0x18]
MOV RDI,R14
ADD RDI,RAX
MOV ESI,dword ptr [R14 + RAX*0x1 + 0x20]
OR ESI,0x1
CALL 0x00121330
LAB_001fa105:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00120690
LAB_001fa112:
MOV RSI,qword ptr [0x00265f58]
LEA RDI,[RSP + 0x8]
CALL 0x00120cd0
LEA RDI,[RSP + 0x78]
CALL 0x00120ca0
MOV RAX,RBX
ADD RSP,0x180
POP RBX
POP R14
POP R15
RET
|
/* common_params_get_system_info[abi:cxx11](common_params const&) */
common_params * common_params_get_system_info_abi_cxx11_(common_params *param_1)
{
ostream *poVar1;
char *__s;
size_t sVar2;
long in_RSI;
ostringstream local_190 [112];
ios_base local_120 [264];
std::__cxx11::ostringstream::ostringstream(local_190);
/* try { // try from 001fa01e to 001fa111 has its CatchHandler @ 001fa13d */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_190,"system_info: n_threads = ",0x19);
std::ostream::operator<<((ostream *)local_190,*(int *)(in_RSI + 0x274));
if (*(int *)(in_RSI + 0x488) != -1) {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_190," (n_threads_batch = ",0x14);
poVar1 = (ostream *)std::ostream::operator<<((ostream *)local_190,*(int *)(in_RSI + 0x488));
std::__ostream_insert<char,std::char_traits<char>>(poVar1,")",1);
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)local_190," / ",3);
std::thread::hardware_concurrency();
poVar1 = std::ostream::_M_insert<unsigned_long>((ulong)local_190);
std::__ostream_insert<char,std::char_traits<char>>(poVar1," | ",3);
__s = (char *)llama_print_system_info();
if (__s == (char *)0x0) {
std::ios::clear(poVar1 + *(long *)(*(long *)poVar1 + -0x18),
*(uint *)(poVar1 + *(long *)(*(long *)poVar1 + -0x18) + 0x20) | 1);
}
else {
sVar2 = strlen(__s);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,__s,sVar2);
}
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream(local_190);
std::ios_base::~ios_base(local_120);
return param_1;
}
|
|
17,218
|
common_set_adapter_lora(llama_context*, std::vector<common_adapter_lora_info, std::allocator<common_adapter_lora_info>>&)
|
monkey531[P]llama/common/common.cpp
|
void common_set_adapter_lora(struct llama_context * ctx, std::vector<common_adapter_lora_info> & lora) {
llama_clear_adapter_lora(ctx);
for (auto & la : lora) {
if (la.scale != 0.0f) {
llama_set_adapter_lora(ctx, la.ptr, la.scale);
}
}
}
|
O3
|
cpp
|
common_set_adapter_lora(llama_context*, std::vector<common_adapter_lora_info, std::allocator<common_adapter_lora_info>>&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1a950
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x7470d
movss 0x20(%r15), %xmm0
ucomiss 0x79011(%rip), %xmm0 # 0xed708
jne 0x746fb
jnp 0x74707
movq 0x28(%r15), %rsi
movq %rbx, %rdi
callq 0x1a930
addq $0x30, %r15
jmp 0x746e5
popq %rbx
popq %r14
popq %r15
retq
|
_Z23common_set_adapter_loraP13llama_contextRSt6vectorI24common_adapter_lora_infoSaIS2_EE:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
call _llama_clear_adapter_lora
mov r15, [r14]
mov r14, [r14+8]
loc_746E5:
cmp r15, r14
jz short loc_7470D
movss xmm0, dword ptr [r15+20h]
ucomiss xmm0, cs:dword_ED708
jnz short loc_746FB
jnp short loc_74707
loc_746FB:
mov rsi, [r15+28h]
mov rdi, rbx
call _llama_set_adapter_lora
loc_74707:
add r15, 30h ; '0'
jmp short loc_746E5
loc_7470D:
pop rbx
pop r14
pop r15
retn
|
long long common_set_adapter_lora(long long a1, long long *a2)
{
long long result; // rax
long long v3; // r15
long long v4; // r14
result = llama_clear_adapter_lora();
v3 = *a2;
v4 = a2[1];
while ( v3 != v4 )
{
if ( *(float *)(v3 + 32) != 0.0 )
result = llama_set_adapter_lora(a1, *(_QWORD *)(v3 + 40));
v3 += 48LL;
}
return result;
}
|
common_set_adapter_lora:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
CALL 0x0011a950
MOV R15,qword ptr [R14]
MOV R14,qword ptr [R14 + 0x8]
LAB_001746e5:
CMP R15,R14
JZ 0x0017470d
MOVSS XMM0,dword ptr [R15 + 0x20]
UCOMISS XMM0,dword ptr [0x001ed708]
JNZ 0x001746fb
JNP 0x00174707
LAB_001746fb:
MOV RSI,qword ptr [R15 + 0x28]
MOV RDI,RBX
CALL 0x0011a930
LAB_00174707:
ADD R15,0x30
JMP 0x001746e5
LAB_0017470d:
POP RBX
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* common_set_adapter_lora(llama_context*, std::vector<common_adapter_lora_info,
std::allocator<common_adapter_lora_info> >&) */
void common_set_adapter_lora(llama_context *param_1,vector *param_2)
{
long lVar1;
long lVar2;
llama_clear_adapter_lora();
lVar1 = *(long *)(param_2 + 8);
for (lVar2 = *(long *)param_2; lVar2 != lVar1; lVar2 = lVar2 + 0x30) {
if ((*(float *)(lVar2 + 0x20) != _DAT_001ed708) ||
(NAN(*(float *)(lVar2 + 0x20)) || NAN(_DAT_001ed708))) {
llama_set_adapter_lora(param_1,*(int8 *)(lVar2 + 0x28));
}
}
return;
}
|
|
17,219
|
mysys_namespace::crc32c::crc32c_sse42(unsigned int, char const*, unsigned long)
|
eloqsql/mysys/crc32/crc32c.cc
|
USE_SSE42
static uint32_t crc32c_sse42(uint32_t crc, const char* buf, size_t size)
{
const uint8_t *p = reinterpret_cast<const uint8_t *>(buf);
const uint8_t *e = p + size;
uint64_t l = crc ^ 0xffffffffu;
// Point x at first 16-byte aligned byte in string. This might be
// just past the end of the string.
const uintptr_t pval = reinterpret_cast<uintptr_t>(p);
const uint8_t* x = reinterpret_cast<const uint8_t*>(ALIGN(pval, 4));
if (x <= e)
// Process bytes until finished or p is 16-byte aligned
while (p != x)
STEP1;
// Process bytes 16 at a time
while ((e-p) >= 16)
{
Fast_CRC32(&l, &p);
Fast_CRC32(&l, &p);
}
// Process bytes 8 at a time
while ((e-p) >= 8)
Fast_CRC32(&l, &p);
// Process the last few bytes
while (p != e)
STEP1;
return static_cast<uint32_t>(l ^ 0xffffffffu);
}
|
O0
|
cpp
|
mysys_namespace::crc32c::crc32c_sse42(unsigned int, char const*, unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %eax
xorl $-0x1, %eax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0xf, %rax
andq $-0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0x8bff6
jmp 0x8bfa7
movq -0x20(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x8bff4
jmp 0x8bfb3
movq -0x30(%rbp), %rax
andq $0xff, %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movzbl (%rcx), %ecx
xorq %rcx, %rax
movl %eax, -0x44(%rbp)
movslq -0x44(%rbp), %rcx
leaq 0x52970(%rip), %rax # 0xde950
movl (%rax,%rcx,4), %eax
movq -0x30(%rbp), %rcx
shrq $0x8, %rcx
xorq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x8bfa7
jmp 0x8bff6
jmp 0x8bff8
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jl 0x8c025
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8c3f0
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8c3f0
jmp 0x8bff8
jmp 0x8c027
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
cmpq $0x8, %rax
jl 0x8c047
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8c3f0
jmp 0x8c027
jmp 0x8c049
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x8c096
jmp 0x8c055
movq -0x30(%rbp), %rax
andq $0xff, %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movzbl (%rcx), %ecx
xorq %rcx, %rax
movl %eax, -0x48(%rbp)
movslq -0x48(%rbp), %rcx
leaq 0x528ce(%rip), %rax # 0xde950
movl (%rax,%rcx,4), %eax
movq -0x30(%rbp), %rcx
shrq $0x8, %rcx
xorq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x8c049
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
xorq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_ZN15mysys_namespace6crc32cL12crc32c_sse42EjPKcm:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_18]
mov [rbp+var_28], rax
mov eax, [rbp+var_4]
xor eax, 0FFFFFFFFh
mov eax, eax
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
add rax, 0Fh
and rax, 0FFFFFFFFFFFFFFF0h
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
cmp rax, [rbp+var_28]
ja short loc_8BFF6
jmp short $+2
loc_8BFA7:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_40]
jz short loc_8BFF4
jmp short $+2
loc_8BFB3:
mov rax, [rbp+var_30]
and rax, 0FFh
mov rcx, [rbp+var_20]
mov rdx, rcx
add rdx, 1; unsigned __int8 **
mov [rbp+var_20], rdx
movzx ecx, byte ptr [rcx]
xor rax, rcx
mov [rbp+var_44], eax
movsxd rcx, [rbp+var_44]
lea rax, _ZN15mysys_namespace6crc32cL7table0_E; mysys_namespace::crc32c::table0_
mov eax, [rax+rcx*4]
mov rcx, [rbp+var_30]
shr rcx, 8
xor rax, rcx
mov [rbp+var_30], rax
jmp short loc_8BFA7
loc_8BFF4:
jmp short $+2
loc_8BFF6:
jmp short $+2
loc_8BFF8:
mov rax, [rbp+var_28]
mov rcx, [rbp+var_20]
sub rax, rcx
cmp rax, 10h
jl short loc_8C025
lea rdi, [rbp+var_30]; this
lea rsi, [rbp+var_20]; unsigned __int64 *
call _ZN15mysys_namespace6crc32cL10Fast_CRC32EPmPPKh; mysys_namespace::crc32c::Fast_CRC32(ulong *,uchar const**)
lea rdi, [rbp+var_30]; this
lea rsi, [rbp+var_20]; unsigned __int64 *
call _ZN15mysys_namespace6crc32cL10Fast_CRC32EPmPPKh; mysys_namespace::crc32c::Fast_CRC32(ulong *,uchar const**)
jmp short loc_8BFF8
loc_8C025:
jmp short $+2
loc_8C027:
mov rax, [rbp+var_28]
mov rcx, [rbp+var_20]
sub rax, rcx
cmp rax, 8
jl short loc_8C047
lea rdi, [rbp+var_30]; this
lea rsi, [rbp+var_20]; unsigned __int64 *
call _ZN15mysys_namespace6crc32cL10Fast_CRC32EPmPPKh; mysys_namespace::crc32c::Fast_CRC32(ulong *,uchar const**)
jmp short loc_8C027
loc_8C047:
jmp short $+2
loc_8C049:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jz short loc_8C096
jmp short $+2
loc_8C055:
mov rax, [rbp+var_30]
and rax, 0FFh
mov rcx, [rbp+var_20]
mov rdx, rcx
add rdx, 1
mov [rbp+var_20], rdx
movzx ecx, byte ptr [rcx]
xor rax, rcx
mov [rbp+var_48], eax
movsxd rcx, [rbp+var_48]
lea rax, _ZN15mysys_namespace6crc32cL7table0_E; mysys_namespace::crc32c::table0_
mov eax, [rax+rcx*4]
mov rcx, [rbp+var_30]
shr rcx, 8
xor rax, rcx
mov [rbp+var_30], rax
jmp short loc_8C049
loc_8C096:
mov rax, 0FFFFFFFFh
xor rax, [rbp+var_30]
add rsp, 50h
pop rbp
retn
|
unsigned long long mysys_namespace::crc32c::crc32c_sse42(
mysys_namespace::crc32c *this,
unsigned long long a2,
const unsigned __int8 **a3)
{
unsigned __int8 *v3; // rcx
const unsigned __int8 **v4; // rdx
unsigned __int8 *v5; // rcx
unsigned long long v7; // [rsp+20h] [rbp-30h] BYREF
const char *v8; // [rsp+28h] [rbp-28h]
unsigned long long v9[3]; // [rsp+30h] [rbp-20h] BYREF
int v10; // [rsp+4Ch] [rbp-4h]
v10 = (int)this;
v9[2] = a2;
v9[1] = (unsigned long long)a3;
v9[0] = a2;
v8 = (char *)a3 + a2;
v7 = (unsigned int)~(_DWORD)this;
if ( ((a2 + 15) & 0xFFFFFFFFFFFFFFF0LL) <= (unsigned long long)a3 + a2 )
{
while ( v9[0] != ((a2 + 15) & 0xFFFFFFFFFFFFFFF0LL) )
{
v3 = (unsigned __int8 *)v9[0];
a3 = (const unsigned __int8 **)++v9[0];
v7 = (v7 >> 8) ^ mysys_namespace::crc32c::table0_[*v3 ^ (unsigned __int8)v7];
}
}
while ( (long long)&v8[-v9[0]] >= 16 )
{
mysys_namespace::crc32c::Fast_CRC32((mysys_namespace::crc32c *)&v7, v9, a3);
mysys_namespace::crc32c::Fast_CRC32((mysys_namespace::crc32c *)&v7, v9, v4);
}
while ( (long long)&v8[-v9[0]] >= 8 )
mysys_namespace::crc32c::Fast_CRC32((mysys_namespace::crc32c *)&v7, v9, a3);
while ( (const char *)v9[0] != v8 )
{
v5 = (unsigned __int8 *)v9[0]++;
v7 = (v7 >> 8) ^ mysys_namespace::crc32c::table0_[*v5 ^ (unsigned __int8)v7];
}
return v7 ^ 0xFFFFFFFF;
}
|
crc32c_sse42:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x4]
XOR EAX,0xffffffff
MOV EAX,EAX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0xf
AND RAX,-0x10
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x28]
JA 0x0018bff6
JMP 0x0018bfa7
LAB_0018bfa7:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x40]
JZ 0x0018bff4
JMP 0x0018bfb3
LAB_0018bfb3:
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0xff
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOVZX ECX,byte ptr [RCX]
XOR RAX,RCX
MOV dword ptr [RBP + -0x44],EAX
MOVSXD RCX,dword ptr [RBP + -0x44]
LEA RAX,[0x1de950]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x8
XOR RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0018bfa7
LAB_0018bff4:
JMP 0x0018bff6
LAB_0018bff6:
JMP 0x0018bff8
LAB_0018bff8:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,RCX
CMP RAX,0x10
JL 0x0018c025
LEA RDI,[RBP + -0x30]
LEA RSI,[RBP + -0x20]
CALL 0x0018c3f0
LEA RDI,[RBP + -0x30]
LEA RSI,[RBP + -0x20]
CALL 0x0018c3f0
JMP 0x0018bff8
LAB_0018c025:
JMP 0x0018c027
LAB_0018c027:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,RCX
CMP RAX,0x8
JL 0x0018c047
LEA RDI,[RBP + -0x30]
LEA RSI,[RBP + -0x20]
CALL 0x0018c3f0
JMP 0x0018c027
LAB_0018c047:
JMP 0x0018c049
LAB_0018c049:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JZ 0x0018c096
JMP 0x0018c055
LAB_0018c055:
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0xff
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOVZX ECX,byte ptr [RCX]
XOR RAX,RCX
MOV dword ptr [RBP + -0x48],EAX
MOVSXD RCX,dword ptr [RBP + -0x48]
LEA RAX,[0x1de950]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x8
XOR RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0018c049
LAB_0018c096:
MOV RAX,0xffffffff
XOR RAX,qword ptr [RBP + -0x30]
ADD RSP,0x50
POP RBP
RET
|
/* mysys_namespace::crc32c::crc32c_sse42(unsigned int, char const*, unsigned long) */
ulong __thiscall
mysys_namespace::crc32c::crc32c_sse42(crc32c *this,uint param_1,char *param_2,ulong param_3)
{
int4 in_register_00000034;
ulong local_38;
byte *local_30;
byte *local_28;
char *local_20;
byte *local_18;
uint local_c;
local_18 = (byte *)CONCAT44(in_register_00000034,param_1);
local_c = (uint)this;
local_30 = local_18 + (long)param_2;
local_38 = (ulong)(local_c ^ 0xffffffff);
local_28 = local_18;
local_20 = param_2;
if ((byte *)((ulong)(local_18 + 0xf) & 0xfffffffffffffff0) <= local_30) {
for (; local_28 != (byte *)((ulong)(local_18 + 0xf) & 0xfffffffffffffff0);
local_28 = local_28 + 1) {
local_38 = (ulong)*(uint *)(table0_ + (long)(int)((uint)local_38 & 0xff ^ (uint)*local_28) * 4
) ^ local_38 >> 8;
}
}
while (0xf < (long)local_30 - (long)local_28) {
Fast_CRC32(&local_38,&local_28);
Fast_CRC32(&local_38,&local_28);
}
while (7 < (long)local_30 - (long)local_28) {
Fast_CRC32(&local_38,&local_28);
}
for (; local_28 != local_30; local_28 = local_28 + 1) {
local_38 = (ulong)*(uint *)(table0_ + (long)(int)((uint)local_38 & 0xff ^ (uint)*local_28) * 4)
^ local_38 >> 8;
}
return local_38 ^ 0xffffffff;
}
|
|
17,220
|
my_wc_mb_eucjpms
|
eloqsql/strings/ctype-eucjpms.c
|
static int
my_wc_mb_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int jp;
if ((int) wc < 0x80) /* ASCII [00-7F] */
{
if (s >= e)
return MY_CS_TOOSMALL;
*s= (uchar) wc;
return 1;
}
if (wc > 0xFFFF)
return MY_CS_ILUNI;
if ((jp= unicode_to_jisx0208_eucjpms[wc])) /* JIS-X-0208 MS */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, jp);
return 2;
}
if ((jp= unicode_to_jisx0212_eucjpms[wc])) /* JIS-X-0212 MS */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
s[0]= 0x8F;
MY_PUT_MB2(s + 1, jp);
return 3;
}
if (wc >= 0xFF61 && wc <= 0xFF9F) /* Half width Katakana */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
s[0]= 0x8E;
s[1]= (uchar) (wc - 0xFEC0);
return 2;
}
return MY_CS_ILUNI;
}
|
O3
|
c
|
my_wc_mb_eucjpms:
cmpl $0x7f, %esi
jg 0x370c5
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x370fa
movb %sil, (%rdx)
movl $0x1, %eax
retq
xorl %eax, %eax
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0x370fa
leaq 0xe86e9(%rip), %rdi # 0x11f7c0
movzwl (%rdi,%rsi,2), %edi
testw %di, %di
je 0x370fb
leaq 0x2(%rdx), %rsi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rsi
ja 0x370fa
rolw $0x8, %di
movw %di, (%rdx)
movl $0x2, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq 0x1086b9(%rip), %rdi # 0x13f7c0
movzwl (%rdi,%rsi,2), %ebx
testw %bx, %bx
je 0x3712e
leaq 0x3(%rdx), %rsi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rsi
ja 0x37159
movb $-0x71, (%rdx)
movb %bh, 0x1(%rdx)
movb %bl, 0x2(%rdx)
movl $0x3, %eax
jmp 0x37159
leaq -0xff61(%rsi), %rdi
cmpq $0x3e, %rdi
ja 0x37159
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x37159
movb $-0x72, (%rdx)
addb $0x40, %sil
movb %sil, 0x1(%rdx)
movl $0x2, %eax
popq %rbx
popq %rbp
retq
|
my_wc_mb_eucjpms:
cmp esi, 7Fh
jg short loc_370C5
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_370FA
mov [rdx], sil
mov eax, 1
retn
loc_370C5:
xor eax, eax
cmp rsi, 0FFFFh
ja short locret_370FA
lea rdi, unicode_to_jisx0208_eucjpms
movzx edi, word ptr [rdi+rsi*2]
test di, di
jz short loc_370FB
lea rsi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rsi, rcx
ja short locret_370FA
rol di, 8
mov [rdx], di
mov eax, 2
locret_370FA:
retn
loc_370FB:
push rbp
mov rbp, rsp
push rbx
lea rdi, unicode_to_jisx0212_eucjpms
movzx ebx, word ptr [rdi+rsi*2]
test bx, bx
jz short loc_3712E
lea rsi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rsi, rcx
ja short loc_37159
mov byte ptr [rdx], 8Fh
mov [rdx+1], bh
mov [rdx+2], bl
mov eax, 3
jmp short loc_37159
loc_3712E:
lea rdi, [rsi-0FF61h]
cmp rdi, 3Eh ; '>'
ja short loc_37159
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_37159
mov byte ptr [rdx], 8Eh
add sil, 40h ; '@'
mov [rdx+1], sil
mov eax, 2
loc_37159:
pop rbx
pop rbp
retn
|
long long my_wc_mb_eucjpms(long long a1, unsigned long long a2, unsigned long long a3, unsigned long long a4)
{
long long result; // rax
__int16 v5; // di
__int16 v6; // bx
if ( (int)a2 > 127 )
{
result = 0LL;
if ( a2 <= 0xFFFF )
{
v5 = unicode_to_jisx0208_eucjpms[a2];
if ( v5 )
{
result = 4294967194LL;
if ( a3 + 2 <= a4 )
{
*(_WORD *)a3 = __ROL2__(v5, 8);
return 2LL;
}
}
else
{
v6 = unicode_to_jisx0212_eucjpms[a2];
if ( v6 )
{
result = 4294967193LL;
if ( a3 + 3 <= a4 )
{
*(_BYTE *)a3 = -113;
*(_BYTE *)(a3 + 1) = HIBYTE(v6);
*(_BYTE *)(a3 + 2) = v6;
return 3LL;
}
}
else if ( a2 - 65377 <= 0x3E )
{
result = 4294967194LL;
if ( a3 + 2 <= a4 )
{
*(_BYTE *)a3 = -114;
*(_BYTE *)(a3 + 1) = a2 + 64;
return 2LL;
}
}
}
}
}
else
{
result = 4294967195LL;
if ( a3 < a4 )
{
*(_BYTE *)a3 = a2;
return 1LL;
}
}
return result;
}
|
my_wc_mb_eucjpms:
CMP ESI,0x7f
JG 0x001370c5
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001370fa
MOV byte ptr [RDX],SIL
MOV EAX,0x1
RET
LAB_001370c5:
XOR EAX,EAX
CMP RSI,0xffff
JA 0x001370fa
LEA RDI,[0x21f7c0]
MOVZX EDI,word ptr [RDI + RSI*0x2]
TEST DI,DI
JZ 0x001370fb
LEA RSI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RSI,RCX
JA 0x001370fa
ROL DI,0x8
MOV word ptr [RDX],DI
MOV EAX,0x2
LAB_001370fa:
RET
LAB_001370fb:
PUSH RBP
MOV RBP,RSP
PUSH RBX
LEA RDI,[0x23f7c0]
MOVZX EBX,word ptr [RDI + RSI*0x2]
TEST BX,BX
JZ 0x0013712e
LEA RSI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RSI,RCX
JA 0x00137159
MOV byte ptr [RDX],0x8f
MOV byte ptr [RDX + 0x1],BH
MOV byte ptr [RDX + 0x2],BL
MOV EAX,0x3
JMP 0x00137159
LAB_0013712e:
LEA RDI,[RSI + -0xff61]
CMP RDI,0x3e
JA 0x00137159
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x00137159
MOV byte ptr [RDX],0x8e
ADD SIL,0x40
MOV byte ptr [RDX + 0x1],SIL
MOV EAX,0x2
LAB_00137159:
POP RBX
POP RBP
RET
|
int8 my_wc_mb_eucjpms(int8 param_1,ulong param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
short sVar2;
int8 uVar3;
if ((int)param_2 < 0x80) {
uVar3 = 0xffffff9b;
if (param_3 < param_4) {
*(char *)param_3 = (char)param_2;
return 1;
}
}
else {
uVar3 = 0;
if (param_2 < 0x10000) {
uVar1 = *(ushort *)(unicode_to_jisx0208_eucjpms + param_2 * 2);
if (uVar1 == 0) {
sVar2 = *(short *)(unicode_to_jisx0212_eucjpms + param_2 * 2);
if (sVar2 == 0) {
if ((param_2 - 0xff61 < 0x3f) && (uVar3 = 0xffffff9a, param_3 + 1 <= param_4)) {
*(char *)param_3 = -0x72;
*(char *)((long)param_3 + 1) = (char)param_2 + '@';
uVar3 = 2;
}
}
else {
uVar3 = 0xffffff99;
if ((ushort *)((long)param_3 + 3) <= param_4) {
*(char *)param_3 = -0x71;
*(char *)((long)param_3 + 1) = (char)((ushort)sVar2 >> 8);
*(char *)(param_3 + 1) = (char)sVar2;
uVar3 = 3;
}
}
return uVar3;
}
uVar3 = 0xffffff9a;
if (param_3 + 1 <= param_4) {
*param_3 = uVar1 << 8 | uVar1 >> 8;
uVar3 = 2;
}
}
}
return uVar3;
}
|
|
17,221
|
pvio_socket_fast_send
|
eloqsql/libmariadb/plugins/pvio/pvio_socket.c
|
int pvio_socket_fast_send(MARIADB_PVIO *pvio)
{
int r= 0;
struct st_pvio_socket *csock= NULL;
if (!pvio || !pvio->data)
return 1;
csock= (struct st_pvio_socket *)pvio->data;
/* Setting IP_TOS is not recommended on Windows. See
http://msdn.microsoft.com/en-us/library/windows/desktop/ms738586(v=vs.85).aspx
*/
#if !defined(_WIN32) && defined(IPTOS_THROUGHPUT)
{
int tos = IPTOS_THROUGHPUT;
r= setsockopt(csock->socket, IPPROTO_IP, IP_TOS,
(const void *)&tos, sizeof(tos));
}
#endif /* !_WIN32 && IPTOS_THROUGHPUT */
if (!r)
{
int opt = 1;
/* turn off nagle algorithm */
r= setsockopt(csock->socket, IPPROTO_TCP, TCP_NODELAY,
#ifdef _WIN32
(const char *)&opt, (int)sizeof(opt));
#else
(const void *)&opt, sizeof(opt));
#endif
}
return r;
}
|
O0
|
c
|
pvio_socket_fast_send:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x73d8c
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x73d95
movl $0x1, -0x4(%rbp)
jmp 0x73dfb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x8, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
xorl %esi, %esi
movl $0x1, %edx
leaq -0x24(%rbp), %rcx
movl $0x4, %r8d
callq 0x38130
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x73df5
movl $0x1, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq -0x28(%rbp), %rcx
movl $0x4, %r8d
callq 0x38130
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
pvio_socket_fast_send:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], 0
mov [rbp+var_20], 0
cmp [rbp+var_10], 0
jz short loc_73D8C
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_73D95
loc_73D8C:
mov [rbp+var_4], 1
jmp short loc_73DFB
loc_73D95:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov [rbp+var_24], 8
mov rax, [rbp+var_20]
mov edi, [rax]
xor esi, esi
mov edx, 1
lea rcx, [rbp+var_24]
mov r8d, 4
call _setsockopt
mov [rbp+var_14], eax
cmp [rbp+var_14], 0
jnz short loc_73DF5
mov [rbp+var_28], 1
mov rax, [rbp+var_20]
mov edi, [rax]
mov esi, 6
mov edx, 1
lea rcx, [rbp+var_28]
mov r8d, 4
call _setsockopt
mov [rbp+var_14], eax
loc_73DF5:
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
loc_73DFB:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long pvio_socket_fast_send(unsigned int **a1)
{
int v2; // [rsp+8h] [rbp-28h] BYREF
int v3; // [rsp+Ch] [rbp-24h] BYREF
unsigned int *v4; // [rsp+10h] [rbp-20h]
unsigned int v5; // [rsp+1Ch] [rbp-14h]
unsigned int **v6; // [rsp+20h] [rbp-10h]
v6 = a1;
v5 = 0;
v4 = 0LL;
if ( a1 && *v6 )
{
v4 = *v6;
v3 = 8;
v5 = setsockopt(*v4, 0LL, 1LL, &v3, 4LL);
if ( !v5 )
{
v2 = 1;
return (unsigned int)setsockopt(*v4, 6LL, 1LL, &v2, 4LL);
}
return v5;
}
else
{
return 1;
}
}
|
pvio_socket_fast_send:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],0x0
MOV qword ptr [RBP + -0x20],0x0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00173d8c
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x00173d95
LAB_00173d8c:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00173dfb
LAB_00173d95:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x24],0x8
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX]
XOR ESI,ESI
MOV EDX,0x1
LEA RCX,[RBP + -0x24]
MOV R8D,0x4
CALL 0x00138130
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00173df5
MOV dword ptr [RBP + -0x28],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX]
MOV ESI,0x6
MOV EDX,0x1
LEA RCX,[RBP + -0x28]
MOV R8D,0x4
CALL 0x00138130
MOV dword ptr [RBP + -0x14],EAX
LAB_00173df5:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
LAB_00173dfb:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int pvio_socket_fast_send(long *param_1)
{
int4 local_30;
int4 local_2c;
int *local_28;
int local_1c;
long *local_18;
int local_c;
local_1c = 0;
if ((param_1 == (long *)0x0) || (*param_1 == 0)) {
local_c = 1;
}
else {
local_28 = (int *)*param_1;
local_2c = 8;
local_18 = param_1;
local_1c = setsockopt(*local_28,0,1,&local_2c,4);
if (local_1c == 0) {
local_30 = 1;
local_1c = setsockopt(*local_28,6,1,&local_30,4);
}
local_c = local_1c;
}
return local_c;
}
|
|
17,222
|
ftxui::Render(ftxui::Screen&, ftxui::Node*)
|
Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/dom/node.cpp
|
void Render(Screen& screen, Node* node) {
Box box;
box.x_min = 0;
box.y_min = 0;
box.x_max = screen.dimx() - 1;
box.y_max = screen.dimy() - 1;
Node::Status status;
node->Check(&status);
const int max_iterations = 20;
while (status.need_iteration && status.iteration < max_iterations) {
// Step 1: Find what dimension this elements wants to be.
node->ComputeRequirement();
// Step 2: Assign a dimension to the element.
node->SetBox(box);
// Check if the element needs another iteration of the layout algorithm.
status.need_iteration = false;
status.iteration++;
node->Check(&status);
}
// Step 3: Draw the element.
screen.stencil = box;
node->Render(screen);
// Step 4: Apply shaders
screen.ApplyShader();
}
|
O2
|
cpp
|
ftxui::Render(ftxui::Screen&, ftxui::Node*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rdi), %r12d
movl 0x14(%rdi), %r15d
decl %r12d
leaq 0x8(%rsp), %r13
andl $0x0, (%r13)
decl %r15d
shlq $0x20, %r15
movb $0x0, 0x4(%r13)
movq (%rsi), %rax
movq %rsi, %rdi
movq %r13, %rsi
callq *0x28(%rax)
shlq $0x20, %r12
cmpb $0x1, 0xc(%rsp)
jne 0x1f0cd
cmpl $0x13, 0x8(%rsp)
jg 0x1f0cd
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x18(%rax)
movb $0x0, 0xc(%rsp)
incl 0x8(%rsp)
movq (%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
callq *0x28(%rax)
jmp 0x1f090
movq %r12, (%rbx)
movq %r15, 0x8(%rbx)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq %rbx, %rdi
callq 0x306a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
_ZN5ftxui6RenderERNS_6ScreenEPNS_4NodeE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
mov r12d, [rdi+10h]
mov r15d, [rdi+14h]
dec r12d
lea r13, [rsp+38h+var_30]
and dword ptr [r13+0], 0
dec r15d
shl r15, 20h
mov byte ptr [r13+4], 0
mov rax, [rsi]
mov rdi, rsi
mov rsi, r13
call qword ptr [rax+28h]
shl r12, 20h
loc_1F090:
cmp [rsp+38h+var_2C], 1
jnz short loc_1F0CD
cmp [rsp+38h+var_30], 13h
jg short loc_1F0CD
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+10h]
mov rax, [r14]
mov rdi, r14
mov rsi, r12
mov rdx, r15
call qword ptr [rax+18h]
mov [rsp+38h+var_2C], 0
inc [rsp+38h+var_30]
mov rax, [r14]
mov rdi, r14
mov rsi, r13
call qword ptr [rax+28h]
jmp short loc_1F090
loc_1F0CD:
mov [rbx], r12
mov [rbx+8], r15
mov rax, [r14]
mov rdi, r14
mov rsi, rbx
call qword ptr [rax+20h]
mov rdi, rbx; this
call _ZN5ftxui6Screen11ApplyShaderEv; ftxui::Screen::ApplyShader(void)
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long ftxui::Render(ftxui *this, ftxui::Screen *a2, ftxui::Node *a3)
{
int v3; // r15d
long long v4; // r12
unsigned long long v5; // r15
long long v6; // r12
int v8; // [rsp+8h] [rbp-30h] BYREF
char v9; // [rsp+Ch] [rbp-2Ch]
v3 = *((_DWORD *)this + 5);
v4 = (unsigned int)(*((_DWORD *)this + 4) - 1);
v8 = 0;
v5 = (unsigned long long)(unsigned int)(v3 - 1) << 32;
v9 = 0;
(*(void ( **)(ftxui::Screen *, int *, ftxui::Node *))(*(_QWORD *)a2 + 40LL))(a2, &v8, a3);
v6 = v4 << 32;
while ( v9 == 1 && v8 <= 19 )
{
(*(void ( **)(ftxui::Screen *))(*(_QWORD *)a2 + 16LL))(a2);
(*(void ( **)(ftxui::Screen *, long long, unsigned long long))(*(_QWORD *)a2 + 24LL))(a2, v6, v5);
v9 = 0;
++v8;
(*(void ( **)(ftxui::Screen *, int *))(*(_QWORD *)a2 + 40LL))(a2, &v8);
}
*(_QWORD *)this = v6;
*((_QWORD *)this + 1) = v5;
(*(void ( **)(ftxui::Screen *, ftxui *))(*(_QWORD *)a2 + 32LL))(a2, this);
return ftxui::Screen::ApplyShader(this);
}
|
Render:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
MOV R12D,dword ptr [RDI + 0x10]
MOV R15D,dword ptr [RDI + 0x14]
DEC R12D
LEA R13,[RSP + 0x8]
AND dword ptr [R13],0x0
DEC R15D
SHL R15,0x20
MOV byte ptr [R13 + 0x4],0x0
MOV RAX,qword ptr [RSI]
MOV RDI,RSI
MOV RSI,R13
CALL qword ptr [RAX + 0x28]
SHL R12,0x20
LAB_0011f090:
CMP byte ptr [RSP + 0xc],0x1
JNZ 0x0011f0cd
CMP dword ptr [RSP + 0x8],0x13
JG 0x0011f0cd
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R14]
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL qword ptr [RAX + 0x18]
MOV byte ptr [RSP + 0xc],0x0
INC dword ptr [RSP + 0x8]
MOV RAX,qword ptr [R14]
MOV RDI,R14
MOV RSI,R13
CALL qword ptr [RAX + 0x28]
JMP 0x0011f090
LAB_0011f0cd:
MOV qword ptr [RBX],R12
MOV qword ptr [RBX + 0x8],R15
MOV RAX,qword ptr [R14]
MOV RDI,R14
MOV RSI,RBX
CALL qword ptr [RAX + 0x20]
MOV RDI,RBX
CALL 0x001306a0
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* ftxui::Render(ftxui::Screen&, ftxui::Node*) */
void ftxui::Render(Screen *param_1,Node *param_2)
{
int iVar1;
long lVar2;
long lVar3;
int local_30;
char local_2c;
iVar1 = *(int *)(param_1 + 0x10);
local_30 = 0;
lVar3 = (ulong)(*(int *)(param_1 + 0x14) - 1) << 0x20;
local_2c = '\0';
(**(code **)(*(long *)param_2 + 0x28))(param_2,&local_30);
lVar2 = (ulong)(iVar1 - 1) << 0x20;
while ((local_2c == '\x01' && (local_30 < 0x14))) {
(**(code **)(*(long *)param_2 + 0x10))(param_2);
(**(code **)(*(long *)param_2 + 0x18))(param_2,lVar2,lVar3);
local_2c = '\0';
local_30 = local_30 + 1;
(**(code **)(*(long *)param_2 + 0x28))(param_2,&local_30);
}
*(long *)param_1 = lVar2;
*(long *)(param_1 + 8) = lVar3;
(**(code **)(*(long *)param_2 + 0x20))(param_2,param_1);
Screen::ApplyShader(param_1);
return;
}
|
|
17,223
|
my_uca_scanner_contraction_find
|
eloqsql/strings/ctype-uca.c
|
static const MY_CONTRACTION *
my_uca_scanner_contraction_find(my_uca_scanner *scanner, my_wc_t *wc,
size_t max_char_length)
{
size_t clen= 1;
int flag;
const uchar *s, *beg[MY_UCA_MAX_CONTRACTION];
memset((void*) beg, 0, sizeof(beg));
/* Scan all contraction candidates */
for (s= scanner->sbeg, flag= MY_UCA_CNT_MID1;
clen < max_char_length;
flag<<= 1)
{
int mblen;
if ((mblen= my_ci_mb_wc(scanner->cs, &wc[clen], s, scanner->send)) <= 0)
break;
beg[clen]= s= s + mblen;
if (!my_uca_can_be_contraction_part(&scanner->level->contractions,
wc[clen++], flag))
break;
}
/* Find among candidates the longest real contraction */
for ( ; clen > 1; clen--)
{
const MY_CONTRACTION *cnt;
if (my_uca_can_be_contraction_tail(&scanner->level->contractions,
wc[clen - 1]) &&
(cnt= my_uca_contraction_find(&scanner->level->contractions,
wc, clen)))
{
scanner->wbeg= cnt->weight + 1;
scanner->sbeg= beg[clen - 1];
return cnt;
}
}
return NULL; /* No contractions were found */
}
|
O0
|
c
|
my_uca_scanner_contraction_find:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x241b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x4, -0x2c(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x5410a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
callq *%rax
movl %eax, -0x74(%rbp)
cmpl $0x0, %eax
jg 0x540b2
jmp 0x5410a
movq -0x38(%rbp), %rcx
movslq -0x74(%rbp), %rax
addq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rcx, -0x70(%rbp,%rax,8)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movq (%rax,%rcx,8), %rsi
movl -0x2c(%rbp), %edx
callq 0x541c0
cmpb $0x0, %al
jne 0x540fb
jmp 0x5410a
jmp 0x540fd
movl -0x2c(%rbp), %eax
shll %eax
movl %eax, -0x2c(%rbp)
jmp 0x54062
jmp 0x5410c
cmpq $0x1, -0x28(%rbp)
jbe 0x541a8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4b3b0
movsbl %al, %eax
cmpl $0x0, %eax
je 0x54195
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x537e0
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x54195
movq -0x80(%rbp), %rcx
addq $0x30, %rcx
addq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq -0x70(%rbp,%rax,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x541b0
jmp 0x54197
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5410c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
|
my_uca_scanner_contraction_find:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], 1
lea rdi, [rbp+var_70]
xor esi, esi
mov edx, 30h ; '0'
call _memset
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_38], rax
mov [rbp+var_2C], 4
loc_54062:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_20]
jnb loc_5410A
mov rax, [rbp+var_10]
mov rax, [rax+30h]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+30h]
mov rsi, [rbp+var_18]
mov rcx, [rbp+var_28]
shl rcx, 3
add rsi, rcx
mov rdx, [rbp+var_38]
mov rcx, [rbp+var_10]
mov rcx, [rcx+10h]
call rax
mov [rbp+var_74], eax
cmp eax, 0
jg short loc_540B2
jmp short loc_5410A
loc_540B2:
mov rcx, [rbp+var_38]
movsxd rax, [rbp+var_74]
add rcx, rax
mov [rbp+var_38], rcx
mov rax, [rbp+var_28]
mov [rbp+rax*8+var_70], rcx
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
add rdi, 18h
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
mov rdx, rcx
add rdx, 1
mov [rbp+var_28], rdx
mov rsi, [rax+rcx*8]
mov edx, [rbp+var_2C]
call my_uca_can_be_contraction_part
cmp al, 0
jnz short loc_540FB
jmp short loc_5410A
loc_540FB:
jmp short $+2
loc_540FD:
mov eax, [rbp+var_2C]
shl eax, 1
mov [rbp+var_2C], eax
jmp loc_54062
loc_5410A:
jmp short $+2
loc_5410C:
cmp [rbp+var_28], 1
jbe loc_541A8
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
add rdi, 18h
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
sub rcx, 1
mov rsi, [rax+rcx*8]
call my_uca_can_be_contraction_tail
movsx eax, al
cmp eax, 0
jz short loc_54195
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
add rdi, 18h
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_28]
call my_uca_contraction_find
mov [rbp+var_80], rax
cmp rax, 0
jz short loc_54195
mov rcx, [rbp+var_80]
add rcx, 30h ; '0'
add rcx, 2
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_28]
sub rax, 1
mov rcx, [rbp+rax*8+var_70]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_80]
mov [rbp+var_8], rax
jmp short loc_541B0
loc_54195:
jmp short $+2
loc_54197:
mov rax, [rbp+var_28]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_28], rax
jmp loc_5410C
loc_541A8:
mov [rbp+var_8], 0
loc_541B0:
mov rax, [rbp+var_8]
add rsp, 80h
pop rbp
retn
|
unsigned long long my_uca_scanner_contraction_find(_QWORD *a1, long long a2, unsigned long long a3)
{
long long v3; // rdi
unsigned long long v4; // rcx
unsigned long long v6; // [rsp+0h] [rbp-80h]
int v7; // [rsp+Ch] [rbp-74h]
_QWORD v8[7]; // [rsp+10h] [rbp-70h] BYREF
long long v9; // [rsp+48h] [rbp-38h]
unsigned int i; // [rsp+54h] [rbp-2Ch]
unsigned long long v11; // [rsp+58h] [rbp-28h]
unsigned long long v12; // [rsp+60h] [rbp-20h]
long long v13; // [rsp+68h] [rbp-18h]
_QWORD *v14; // [rsp+70h] [rbp-10h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = 1LL;
memset(v8, 0LL, 48LL);
v9 = v14[1];
for ( i = 4; v11 < v12; i *= 2 )
{
v7 = (*(long long ( **)(_QWORD, unsigned long long, long long, _QWORD))(*(_QWORD *)(v14[6] + 184LL) + 40LL))(
v14[6],
8 * v11 + v13,
v9,
v14[2]);
if ( v7 <= 0 )
break;
v9 += v7;
v8[v11] = v9;
v3 = v14[3] + 24LL;
v4 = v11++;
if ( !(unsigned __int8)my_uca_can_be_contraction_part(v3, *(_QWORD *)(v13 + 8 * v4), i) )
break;
}
while ( v11 > 1 )
{
if ( (unsigned __int8)my_uca_can_be_contraction_tail(v14[3] + 24LL, *(_QWORD *)(v13 + 8 * (v11 - 1))) )
{
v6 = my_uca_contraction_find((_QWORD *)(v14[3] + 24LL), v13, v11);
if ( v6 )
{
*v14 = v6 + 50;
v14[1] = v8[v11 - 1];
return v6;
}
}
--v11;
}
return 0LL;
}
|
my_uca_scanner_contraction_find:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],0x1
LEA RDI,[RBP + -0x70]
XOR ESI,ESI
MOV EDX,0x30
CALL 0x001241b0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x2c],0x4
LAB_00154062:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0015410a
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x30]
MOV RSI,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
SHL RCX,0x3
ADD RSI,RCX
MOV RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x10]
CALL RAX
MOV dword ptr [RBP + -0x74],EAX
CMP EAX,0x0
JG 0x001540b2
JMP 0x0015410a
LAB_001540b2:
MOV RCX,qword ptr [RBP + -0x38]
MOVSXD RAX,dword ptr [RBP + -0x74]
ADD RCX,RAX
MOV qword ptr [RBP + -0x38],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + RAX*0x8 + -0x70],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
ADD RDI,0x18
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV EDX,dword ptr [RBP + -0x2c]
CALL 0x001541c0
CMP AL,0x0
JNZ 0x001540fb
JMP 0x0015410a
LAB_001540fb:
JMP 0x001540fd
LAB_001540fd:
MOV EAX,dword ptr [RBP + -0x2c]
SHL EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x00154062
LAB_0015410a:
JMP 0x0015410c
LAB_0015410c:
CMP qword ptr [RBP + -0x28],0x1
JBE 0x001541a8
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
ADD RDI,0x18
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
SUB RCX,0x1
MOV RSI,qword ptr [RAX + RCX*0x8]
CALL 0x0014b3b0
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00154195
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
ADD RDI,0x18
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x001537e0
MOV qword ptr [RBP + -0x80],RAX
CMP RAX,0x0
JZ 0x00154195
MOV RCX,qword ptr [RBP + -0x80]
ADD RCX,0x30
ADD RCX,0x2
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,0x1
MOV RCX,qword ptr [RBP + RAX*0x8 + -0x70]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001541b0
LAB_00154195:
JMP 0x00154197
LAB_00154197:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0015410c
LAB_001541a8:
MOV qword ptr [RBP + -0x8],0x0
LAB_001541b0:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x80
POP RBP
RET
|
long my_uca_scanner_contraction_find(long *param_1,long param_2,ulong param_3)
{
char cVar1;
int iVar2;
long lVar3;
long local_78 [7];
long local_40;
int local_34;
ulong local_30;
ulong local_28;
long local_20;
long *local_18;
local_30 = 1;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
memset(local_78,0,0x30);
local_40 = local_18[1];
local_34 = 4;
while ((local_30 < local_28 &&
(iVar2 = (**(code **)(*(long *)(local_18[6] + 0xb8) + 0x28))
(local_18[6],local_20 + local_30 * 8,local_40,local_18[2]), 0 < iVar2)))
{
local_40 = local_40 + iVar2;
local_78[local_30] = local_40;
lVar3 = local_30 * 8;
local_30 = local_30 + 1;
cVar1 = my_uca_can_be_contraction_part
(local_18[3] + 0x18,*(int8 *)(local_20 + lVar3),local_34);
if (cVar1 == '\0') break;
local_34 = local_34 << 1;
}
while( true ) {
if (local_30 < 2) {
return 0;
}
cVar1 = my_uca_can_be_contraction_tail
(local_18[3] + 0x18,*(int8 *)(local_20 + (local_30 - 1) * 8));
if ((cVar1 != '\0') &&
(lVar3 = my_uca_contraction_find(local_18[3] + 0x18,local_20,local_30), lVar3 != 0)) break;
local_30 = local_30 - 1;
}
*local_18 = lVar3 + 0x32;
local_18[1] = local_78[local_30 - 1];
return lVar3;
}
|
|
17,224
|
translog_example_table_init
|
eloqsql/storage/maria/unittest/ma_loghandler_examples.c
|
void translog_example_table_init()
{
int i;
log_record_type_descriptor[LOGREC_FIXED_RECORD_0LSN_EXAMPLE]=
INIT_LOGREC_FIXED_RECORD_0LSN_EXAMPLE;
log_record_type_descriptor[LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE]=
INIT_LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE;
log_record_type_descriptor[LOGREC_FIXED_RECORD_1LSN_EXAMPLE]=
INIT_LOGREC_FIXED_RECORD_1LSN_EXAMPLE;
log_record_type_descriptor[LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE]=
INIT_LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE;
log_record_type_descriptor[LOGREC_FIXED_RECORD_2LSN_EXAMPLE]=
INIT_LOGREC_FIXED_RECORD_2LSN_EXAMPLE;
log_record_type_descriptor[LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE]=
INIT_LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE;
for (i= LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE + 1;
i < LOGREC_NUMBER_OF_TYPES;
i++)
log_record_type_descriptor[i].rclass= LOGRECTYPE_NOT_ALLOWED;
#ifndef DBUG_OFF
check_translog_description_table(LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE);
#endif
}
|
O3
|
c
|
translog_example_table_init:
pushq %rbp
movq %rsp, %rbp
leaq 0x3cba31(%rip), %rax # 0x3fce30
leaq 0x48(%rax), %rdi
leaq 0x3491f6(%rip), %rsi # 0x37a600
movl $0x9, %ecx
rep movsq (%rsi), %es:(%rdi)
leaq 0x90(%rax), %rdi
leaq 0x349228(%rip), %rsi # 0x37a648
movl $0x9, %ecx
rep movsq (%rsi), %es:(%rdi)
leaq 0xd8(%rax), %rdi
leaq 0x34925a(%rip), %rsi # 0x37a690
movl $0x9, %ecx
rep movsq (%rsi), %es:(%rdi)
leaq 0x120(%rax), %rdi
leaq 0x34928c(%rip), %rsi # 0x37a6d8
movl $0x9, %ecx
rep movsq (%rsi), %es:(%rdi)
leaq 0x168(%rax), %rdi
leaq 0x3492be(%rip), %rsi # 0x37a720
movl $0x9, %ecx
rep movsq (%rsi), %es:(%rdi)
leaq 0x1b0(%rax), %rdi
leaq 0x3492f0(%rip), %rsi # 0x37a768
movl $0x9, %ecx
rep movsq (%rsi), %es:(%rdi)
addq $0x1f8, %rax # imm = 0x1F8
xorl %ecx, %ecx
movdqa 0xa7bc0(%rip), %xmm0 # 0xd9050
movdqa 0xa7bc8(%rip), %xmm1 # 0xd9060
movdqa 0xa7bd0(%rip), %xmm2 # 0xd9070
movdqa 0xa7bd8(%rip), %xmm3 # 0xd9080
pshufd $0xf5, %xmm3, %xmm4 # xmm4 = xmm3[1,1,3,3]
movq %rcx, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm1, %xmm6
pxor %xmm2, %xmm6
movdqa %xmm3, %xmm7
pcmpgtd %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm6 # xmm6 = xmm6[1,1,3,3]
pcmpeqd %xmm4, %xmm6
pand %xmm7, %xmm6
movd %xmm6, %edx
testb $0x1, %dl
je 0x314e7
movl $0x0, (%rax)
pextrw $0x4, %xmm6, %edx
testb $0x1, %dl
je 0x314f8
movl $0x0, 0x48(%rax)
por %xmm0, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm3, %xmm6
pcmpgtd %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm5 # xmm5 = xmm5[1,1,3,3]
pcmpeqd %xmm4, %xmm5
pand %xmm6, %xmm5
pextrw $0x0, %xmm5, %edx
testb $0x1, %dl
je 0x31529
movl $0x0, 0x90(%rax)
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x3153d
movl $0x0, 0xd8(%rax)
addq $0x4, %rcx
addq $0x120, %rax # imm = 0x120
cmpq $0x3c, %rcx
jne 0x314ad
popq %rbp
retq
nop
|
translog_example_table_init:
push rbp
mov rbp, rsp
lea rax, log_record_type_descriptor
lea rdi, [rax+48h]
lea rsi, INIT_LOGREC_FIXED_RECORD_0LSN_EXAMPLE
mov ecx, 9
rep movsq
lea rdi, [rax+90h]
lea rsi, INIT_LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE
mov ecx, 9
rep movsq
lea rdi, [rax+0D8h]
lea rsi, INIT_LOGREC_FIXED_RECORD_1LSN_EXAMPLE
mov ecx, 9
rep movsq
lea rdi, [rax+120h]
lea rsi, INIT_LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE
mov ecx, 9
rep movsq
lea rdi, [rax+168h]
lea rsi, INIT_LOGREC_FIXED_RECORD_2LSN_EXAMPLE
mov ecx, 9
rep movsq
lea rdi, [rax+1B0h]
lea rsi, INIT_LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE
mov ecx, 9
rep movsq
add rax, 1F8h
xor ecx, ecx
movdqa xmm0, cs:xmmword_D9050
movdqa xmm1, cs:xmmword_D9060
movdqa xmm2, cs:xmmword_D9070
movdqa xmm3, cs:xmmword_D9080
pshufd xmm4, xmm3, 0F5h
loc_314AD:
movq xmm5, rcx
pshufd xmm5, xmm5, 44h ; 'D'
movdqa xmm6, xmm5
por xmm6, xmm1
pxor xmm6, xmm2
movdqa xmm7, xmm3
pcmpgtd xmm7, xmm6
pshufd xmm6, xmm6, 0F5h
pcmpeqd xmm6, xmm4
pand xmm6, xmm7
movd edx, xmm6
test dl, 1
jz short loc_314E7
mov dword ptr [rax], 0
loc_314E7:
pextrw edx, xmm6, 4
test dl, 1
jz short loc_314F8
mov dword ptr [rax+48h], 0
loc_314F8:
por xmm5, xmm0
pxor xmm5, xmm2
movdqa xmm6, xmm3
pcmpgtd xmm6, xmm5
pshufd xmm5, xmm5, 0F5h
pcmpeqd xmm5, xmm4
pand xmm5, xmm6
pextrw edx, xmm5, 0
test dl, 1
jz short loc_31529
mov dword ptr [rax+90h], 0
loc_31529:
pextrw edx, xmm5, 4
test dl, 1
jz short loc_3153D
mov dword ptr [rax+0D8h], 0
loc_3153D:
add rcx, 4
add rax, 120h
cmp rcx, 3Ch ; '<'
jnz loc_314AD
pop rbp
retn
|
_DWORD *translog_example_table_init()
{
_DWORD *result; // rax
unsigned long long v1; // rcx
__m128i si128; // xmm0
__m128i v3; // xmm1
__m128i v4; // xmm2
__m128i v5; // xmm3
__m128i v6; // xmm4
__m128i v7; // xmm5
__m128i v8; // xmm6
__m128i v9; // xmm6
__m128i v10; // xmm5
__m128i v11; // xmm5
qmemcpy((char *)&log_record_type_descriptor + 72, &INIT_LOGREC_FIXED_RECORD_0LSN_EXAMPLE, 0x48uLL);
qmemcpy((char *)&log_record_type_descriptor + 144, &INIT_LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE, 0x48uLL);
qmemcpy((char *)&log_record_type_descriptor + 216, &INIT_LOGREC_FIXED_RECORD_1LSN_EXAMPLE, 0x48uLL);
qmemcpy((char *)&log_record_type_descriptor + 288, &INIT_LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE, 0x48uLL);
qmemcpy((char *)&log_record_type_descriptor + 360, &INIT_LOGREC_FIXED_RECORD_2LSN_EXAMPLE, 0x48uLL);
qmemcpy((char *)&log_record_type_descriptor + 432, &INIT_LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE, 0x48uLL);
result = (_DWORD *)((char *)&log_record_type_descriptor + 504);
v1 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_D9050);
v3 = _mm_load_si128((const __m128i *)&xmmword_D9060);
v4 = _mm_load_si128((const __m128i *)&xmmword_D9070);
v5 = _mm_load_si128((const __m128i *)&xmmword_D9080);
v6 = _mm_shuffle_epi32(v5, 245);
do
{
v7 = _mm_shuffle_epi32((__m128i)v1, 68);
v8 = _mm_xor_si128(_mm_or_si128(v7, v3), v4);
v9 = _mm_and_si128(_mm_cmpeq_epi32(_mm_shuffle_epi32(v8, 245), v6), _mm_cmpgt_epi32(v5, v8));
if ( (_mm_cvtsi128_si32(v9) & 1) != 0 )
*result = 0;
if ( (_mm_extract_epi16(v9, 4) & 1) != 0 )
result[18] = 0;
v10 = _mm_xor_si128(_mm_or_si128(v7, si128), v4);
v11 = _mm_and_si128(_mm_cmpeq_epi32(_mm_shuffle_epi32(v10, 245), v6), _mm_cmpgt_epi32(v5, v10));
if ( (_mm_extract_epi16(v11, 0) & 1) != 0 )
result[36] = 0;
if ( (_mm_extract_epi16(v11, 4) & 1) != 0 )
result[54] = 0;
v1 += 4LL;
result += 72;
}
while ( v1 != 60 );
return result;
}
|
translog_example_table_init:
PUSH RBP
MOV RBP,RSP
LEA RAX,[0x4fce30]
LEA RDI,[RAX + 0x48]
LEA RSI,[0x47a600]
MOV ECX,0x9
MOVSQ.REP RDI,RSI
LEA RDI,[RAX + 0x90]
LEA RSI,[0x47a648]
MOV ECX,0x9
MOVSQ.REP RDI,RSI
LEA RDI,[RAX + 0xd8]
LEA RSI,[0x47a690]
MOV ECX,0x9
MOVSQ.REP RDI,RSI
LEA RDI,[RAX + 0x120]
LEA RSI,[0x47a6d8]
MOV ECX,0x9
MOVSQ.REP RDI,RSI
LEA RDI,[RAX + 0x168]
LEA RSI,[0x47a720]
MOV ECX,0x9
MOVSQ.REP RDI,RSI
LEA RDI,[RAX + 0x1b0]
LEA RSI,[0x47a768]
MOV ECX,0x9
MOVSQ.REP RDI,RSI
ADD RAX,0x1f8
XOR ECX,ECX
MOVDQA XMM0,xmmword ptr [0x001d9050]
MOVDQA XMM1,xmmword ptr [0x001d9060]
MOVDQA XMM2,xmmword ptr [0x001d9070]
MOVDQA XMM3,xmmword ptr [0x001d9080]
PSHUFD XMM4,XMM3,0xf5
LAB_001314ad:
MOVQ XMM5,RCX
PSHUFD XMM5,XMM5,0x44
MOVDQA XMM6,XMM5
POR XMM6,XMM1
PXOR XMM6,XMM2
MOVDQA XMM7,XMM3
PCMPGTD XMM7,XMM6
PSHUFD XMM6,XMM6,0xf5
PCMPEQD XMM6,XMM4
PAND XMM6,XMM7
MOVD EDX,XMM6
TEST DL,0x1
JZ 0x001314e7
MOV dword ptr [RAX],0x0
LAB_001314e7:
PEXTRW EDX,XMM6,0x4
TEST DL,0x1
JZ 0x001314f8
MOV dword ptr [RAX + 0x48],0x0
LAB_001314f8:
POR XMM5,XMM0
PXOR XMM5,XMM2
MOVDQA XMM6,XMM3
PCMPGTD XMM6,XMM5
PSHUFD XMM5,XMM5,0xf5
PCMPEQD XMM5,XMM4
PAND XMM5,XMM6
PEXTRW EDX,XMM5,0x0
TEST DL,0x1
JZ 0x00131529
MOV dword ptr [RAX + 0x90],0x0
LAB_00131529:
PEXTRW EDX,XMM5,0x4
TEST DL,0x1
JZ 0x0013153d
MOV dword ptr [RAX + 0xd8],0x0
LAB_0013153d:
ADD RCX,0x4
ADD RAX,0x120
CMP RCX,0x3c
JNZ 0x001314ad
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void translog_example_table_init(void)
{
int1 auVar1 [16];
int1 auVar2 [16];
int1 auVar3 [16];
int iVar4;
int iVar5;
int8 *puVar6;
long lVar7;
int8 *puVar8;
int1 auVar9 [16];
int1 auVar10 [16];
puVar6 = &INIT_LOGREC_FIXED_RECORD_0LSN_EXAMPLE;
puVar8 = &DAT_004fce78;
for (lVar7 = 9; lVar7 != 0; lVar7 = lVar7 + -1) {
*puVar8 = *puVar6;
puVar6 = puVar6 + 1;
puVar8 = puVar8 + 1;
}
puVar6 = &INIT_LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE;
puVar8 = &DAT_004fcec0;
for (lVar7 = 9; lVar7 != 0; lVar7 = lVar7 + -1) {
*puVar8 = *puVar6;
puVar6 = puVar6 + 1;
puVar8 = puVar8 + 1;
}
puVar6 = &INIT_LOGREC_FIXED_RECORD_1LSN_EXAMPLE;
puVar8 = &DAT_004fcf08;
for (lVar7 = 9; lVar7 != 0; lVar7 = lVar7 + -1) {
*puVar8 = *puVar6;
puVar6 = puVar6 + 1;
puVar8 = puVar8 + 1;
}
puVar6 = &INIT_LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE;
puVar8 = &DAT_004fcf50;
for (lVar7 = 9; lVar7 != 0; lVar7 = lVar7 + -1) {
*puVar8 = *puVar6;
puVar6 = puVar6 + 1;
puVar8 = puVar8 + 1;
}
puVar6 = &INIT_LOGREC_FIXED_RECORD_2LSN_EXAMPLE;
puVar8 = &DAT_004fcf98;
for (lVar7 = 9; lVar7 != 0; lVar7 = lVar7 + -1) {
*puVar8 = *puVar6;
puVar6 = puVar6 + 1;
puVar8 = puVar8 + 1;
}
puVar6 = &INIT_LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE;
puVar8 = &DAT_004fcfe0;
for (lVar7 = 9; iVar5 = _UNK_001d9084, iVar4 = _DAT_001d9080, auVar3 = _DAT_001d9070,
auVar2 = _DAT_001d9060, auVar1 = _DAT_001d9050, lVar7 != 0; lVar7 = lVar7 + -1) {
*puVar8 = *puVar6;
puVar6 = puVar6 + 1;
puVar8 = puVar8 + 1;
}
puVar6 = &DAT_004fd028;
lVar7 = 0;
do {
auVar9._8_4_ = (int)lVar7;
auVar9._0_8_ = lVar7;
auVar9._12_4_ = (int)((ulong)lVar7 >> 0x20);
auVar10 = (auVar9 | auVar2) ^ auVar3;
if (auVar10._4_4_ == iVar5 && auVar10._0_4_ < iVar4) {
*(int4 *)puVar6 = 0;
*(int4 *)(puVar6 + 9) = 0;
}
auVar9 = (auVar9 | auVar1) ^ auVar3;
if (auVar9._4_4_ == iVar5 && auVar9._0_4_ < iVar4) {
*(int4 *)(puVar6 + 0x12) = 0;
*(int4 *)(puVar6 + 0x1b) = 0;
}
lVar7 = lVar7 + 4;
puVar6 = puVar6 + 0x24;
} while (lVar7 != 0x3c);
return;
}
|
|
17,225
|
internalize_json_property
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue internalize_json_property(JSContext *ctx, JSValue holder,
JSAtom name, JSValue reviver)
{
JSValue val, new_el, name_val, res;
JSValue args[2];
int ret, is_array;
uint32_t i, len = 0;
JSAtom prop;
JSPropertyEnum *atoms = NULL;
if (js_check_stack_overflow(ctx->rt, 0)) {
return JS_ThrowStackOverflow(ctx);
}
val = JS_GetProperty(ctx, holder, name);
if (JS_IsException(val))
return val;
if (JS_IsObject(val)) {
is_array = JS_IsArray(ctx, val);
if (is_array < 0)
goto fail;
if (is_array) {
if (js_get_length32(ctx, &len, val))
goto fail;
} else {
ret = JS_GetOwnPropertyNamesInternal(ctx, &atoms, &len, JS_VALUE_GET_OBJ(val), JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK);
if (ret < 0)
goto fail;
}
for(i = 0; i < len; i++) {
if (is_array) {
prop = JS_NewAtomUInt32(ctx, i);
if (prop == JS_ATOM_NULL)
goto fail;
} else {
prop = JS_DupAtom(ctx, atoms[i].atom);
}
new_el = internalize_json_property(ctx, val, prop, reviver);
if (JS_IsException(new_el)) {
JS_FreeAtom(ctx, prop);
goto fail;
}
if (JS_IsUndefined(new_el)) {
ret = JS_DeleteProperty(ctx, val, prop, 0);
} else {
ret = JS_DefinePropertyValue(ctx, val, prop, new_el, JS_PROP_C_W_E);
}
JS_FreeAtom(ctx, prop);
if (ret < 0)
goto fail;
}
}
js_free_prop_enum(ctx, atoms, len);
atoms = NULL;
name_val = JS_AtomToValue(ctx, name);
if (JS_IsException(name_val))
goto fail;
args[0] = name_val;
args[1] = val;
res = JS_Call(ctx, reviver, holder, 2, args);
JS_FreeValue(ctx, name_val);
JS_FreeValue(ctx, val);
return res;
fail:
js_free_prop_enum(ctx, atoms, len);
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
}
|
O2
|
c
|
internalize_json_property:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
andl $0x0, -0x2c(%rbp)
andq $0x0, -0x78(%rbp)
movq %rdi, %r15
movq 0x18(%rdi), %rax
cmpq %rbp, 0xe8(%rax)
jbe 0x42c31
movq %r15, %rdi
callq 0x35d91
jmp 0x42cda
movq %r9, %r12
movq %r8, -0x48(%rbp)
movq %r15, %rdi
movq %rsi, -0x68(%rbp)
movq %rdx, -0x70(%rbp)
movl %ecx, -0x58(%rbp)
callq 0x1b043
movq %rax, %r14
movq %rdx, %rbx
cmpl $0x6, %ebx
je 0x42ce0
cmpl $-0x1, %ebx
jne 0x42c9b
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21d01
movl %eax, -0x54(%rbp)
testl %eax, %eax
js 0x42cbf
movq %r14, -0x50(%rbp)
je 0x42d5f
leaq -0x2c(%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x394f2
xorl %esi, %esi
testl %eax, %eax
jne 0x42cc1
jmp 0x42d89
movq %r12, -0x40(%rbp)
xorl %edx, %edx
xorl %esi, %esi
movq %r15, %rdi
callq 0x1ddc3
movq %r15, %rdi
movl -0x58(%rbp), %esi
callq 0x1a91e
movq %rdx, %r13
cmpl $0x6, %r13d
jne 0x42cf8
xorl %esi, %esi
movl -0x2c(%rbp), %edx
movq %r15, %rdi
callq 0x1ddc3
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1801e
pushq $0x6
popq %rbx
xorl %r14d, %r14d
movq %r14, %rax
movq %rbx, %rdx
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq -0xa0(%rbp), %rax
movq %r12, (%rax)
movq %r13, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rax, (%rsp)
pushq $0x2
popq %r9
movq %r15, %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x68(%rbp), %rcx
movq -0x70(%rbp), %r8
callq 0x21eb6
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1801e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1801e
movq -0x48(%rbp), %r14
movq -0x40(%rbp), %rbx
jmp 0x42ce0
leaq -0x78(%rbp), %r14
leaq -0x2c(%rbp), %rdx
pushq $0x11
popq %r8
movq %r15, %rdi
movq %r14, %rsi
movq -0x50(%rbp), %rcx
callq 0x1d5ef
movq (%r14), %rsi
movq -0x50(%rbp), %r14
testl %eax, %eax
js 0x42cc1
movq %rsi, -0x38(%rbp)
movq %r12, -0x40(%rbp)
movl -0x2c(%rbp), %edx
xorl %r12d, %r12d
movq %rdx, -0x60(%rbp)
cmpq %r12, %rdx
je 0x42e5e
cmpl $0x0, -0x54(%rbp)
je 0x42dc1
movq %r15, %rdi
movl %r12d, %esi
callq 0x1a498
movl %eax, %r13d
testl %eax, %eax
jne 0x42de1
jmp 0x42e72
movq -0x38(%rbp), %rax
movslq 0x4(%rax,%r12,8), %r13
cmpq $0xe0, %r13
jl 0x42de1
movq 0x18(%r15), %rax
movq 0x68(%rax), %rax
movq (%rax,%r13,8), %rax
incl (%rax)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r13d, %ecx
movq -0x48(%rbp), %r8
movq -0x40(%rbp), %r9
callq 0x42bf7
movq %rdx, %r9
cmpl $0x3, %r9d
je 0x42e26
cmpl $0x6, %r9d
je 0x42e67
movl $0x7, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r13d, %ecx
movq %rax, %r8
callq 0x20872
jmp 0x42e3a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r13d, %ecx
xorl %r8d, %r8d
callq 0x20af7
movl %eax, %r14d
movq %r15, %rdi
movl %r13d, %esi
callq 0x1a995
incq %r12
testl %r14d, %r14d
movq -0x50(%rbp), %r14
movq -0x60(%rbp), %rdx
jns 0x42d9b
jmp 0x42e72
movq -0x38(%rbp), %rsi
jmp 0x42ca3
movq %r15, %rdi
movl %r13d, %esi
callq 0x1a995
movq -0x38(%rbp), %rsi
jmp 0x42cc1
|
internalize_json_property:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
and [rbp+var_2C], 0
and [rbp+var_78], 0
mov r15, rdi
mov rax, [rdi+18h]
cmp [rax+0E8h], rbp
jbe short loc_42C31
mov rdi, r15
call JS_ThrowStackOverflow
jmp loc_42CDA
loc_42C31:
mov r12, r9
mov [rbp+var_48], r8
mov rdi, r15
mov [rbp+var_68], rsi
mov [rbp+var_70], rdx
mov [rbp+var_58], ecx
call JS_GetProperty
mov r14, rax
mov rbx, rdx
cmp ebx, 6
jz loc_42CE0
cmp ebx, 0FFFFFFFFh
jnz short loc_42C9B
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_IsArray
mov [rbp+var_54], eax
test eax, eax
js short loc_42CBF
mov [rbp+var_50], r14
jz loc_42D5F
lea rsi, [rbp+var_2C]
mov rdi, r15
mov rdx, r14
mov rcx, rbx
call js_get_length32
xor esi, esi
test eax, eax
jnz short loc_42CC1
jmp loc_42D89
loc_42C9B:
mov [rbp+var_40], r12
xor edx, edx
xor esi, esi
loc_42CA3:
mov rdi, r15
call js_free_prop_enum
mov rdi, r15
mov esi, [rbp+var_58]
call JS_AtomToValue
mov r13, rdx
cmp r13d, 6
jnz short loc_42CF8
loc_42CBF:
xor esi, esi
loc_42CC1:
mov edx, [rbp+var_2C]
mov rdi, r15
call js_free_prop_enum
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
loc_42CDA:
push 6
pop rbx
xor r14d, r14d
loc_42CE0:
mov rax, r14
mov rdx, rbx
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_42CF8:
mov r12, rax
lea rax, [rbp+var_A0]
mov [rax], r12
mov [rax+8], r13
mov [rax+10h], r14
mov [rax+18h], rbx
mov [rsp+0B0h+var_B0], rax
push 2
pop r9
mov rdi, r15
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_40]
mov rcx, [rbp+var_68]
mov r8, [rbp+var_70]
call JS_Call
mov [rbp+var_48], rax
mov [rbp+var_40], rdx
mov rdi, r15
mov rsi, r12
mov rdx, r13
call JS_FreeValue
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
mov r14, [rbp+var_48]
mov rbx, [rbp+var_40]
jmp short loc_42CE0
loc_42D5F:
lea r14, [rbp+var_78]
lea rdx, [rbp+var_2C]
push 11h
pop r8
mov rdi, r15
mov rsi, r14
mov rcx, [rbp+var_50]
call JS_GetOwnPropertyNamesInternal
mov rsi, [r14]
mov r14, [rbp+var_50]
test eax, eax
js loc_42CC1
loc_42D89:
mov [rbp+var_38], rsi
mov [rbp+var_40], r12
mov edx, [rbp+var_2C]
xor r12d, r12d
mov [rbp+var_60], rdx
loc_42D9B:
cmp rdx, r12
jz loc_42E5E
cmp [rbp+var_54], 0
jz short loc_42DC1
mov rdi, r15
mov esi, r12d
call JS_NewAtomUInt32
mov r13d, eax
test eax, eax
jnz short loc_42DE1
jmp loc_42E72
loc_42DC1:
mov rax, [rbp+var_38]
movsxd r13, dword ptr [rax+r12*8+4]
cmp r13, 0E0h
jl short loc_42DE1
mov rax, [r15+18h]
mov rax, [rax+68h]
mov rax, [rax+r13*8]
inc dword ptr [rax]
loc_42DE1:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov ecx, r13d
mov r8, [rbp+var_48]
mov r9, [rbp+var_40]
call internalize_json_property
mov r9, rdx
cmp r9d, 3
jz short loc_42E26
cmp r9d, 6
jz short loc_42E67
mov dword ptr [rsp+0B0h+var_B0], 7
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov ecx, r13d
mov r8, rax
call JS_DefinePropertyValue
jmp short loc_42E3A
loc_42E26:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov ecx, r13d
xor r8d, r8d
call JS_DeleteProperty
loc_42E3A:
mov r14d, eax
mov rdi, r15
mov esi, r13d
call JS_FreeAtom
inc r12
test r14d, r14d
mov r14, [rbp+var_50]
mov rdx, [rbp+var_60]
jns loc_42D9B
jmp short loc_42E72
loc_42E5E:
mov rsi, [rbp+var_38]
jmp loc_42CA3
loc_42E67:
mov rdi, r15
mov esi, r13d
call JS_FreeAtom
loc_42E72:
mov rsi, [rbp+var_38]
jmp loc_42CC1
|
long long internalize_json_property(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long Property; // rax
long long v16; // rdx
long long v17; // r14
long long v18; // rbx
int IsArray; // eax
long long v20; // rsi
long long v21; // rdx
long long v22; // rsi
long long v23; // rax
long long v24; // rdx
long long v25; // r13
long long v27; // r12
long long v28; // rdx
int OwnPropertyNamesInternal; // eax
long long v30; // r12
long long v31; // r13
_DWORD *v32; // rax
_DWORD *v33; // rax
long long v34; // rdx
__m128 v35; // xmm4
__m128 v36; // xmm5
int v37; // eax
int v38; // r14d
bool v39; // sf
char v40; // [rsp+0h] [rbp-B0h]
_QWORD v41[5]; // [rsp+10h] [rbp-A0h] BYREF
long long v42; // [rsp+38h] [rbp-78h] BYREF
long long v43; // [rsp+40h] [rbp-70h]
long long v44; // [rsp+48h] [rbp-68h]
long long v45; // [rsp+50h] [rbp-60h]
unsigned int v46; // [rsp+58h] [rbp-58h]
int v47; // [rsp+5Ch] [rbp-54h]
long long v48; // [rsp+60h] [rbp-50h]
long long v49; // [rsp+68h] [rbp-48h]
long long v50; // [rsp+70h] [rbp-40h]
long long v51; // [rsp+78h] [rbp-38h]
int v52[11]; // [rsp+84h] [rbp-2Ch] BYREF
long long savedregs; // [rsp+B0h] [rbp+0h] BYREF
v52[0] = 0;
v42 = 0LL;
if ( *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) > (unsigned long long)&savedregs )
{
JS_ThrowStackOverflow(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, a5, a6, v40);
return 0LL;
}
v49 = a5;
v44 = a2;
v43 = a3;
v46 = a4;
Property = JS_GetProperty(a1, a2, a3, a4);
v17 = Property;
v18 = v16;
if ( (_DWORD)v16 != 6 )
{
if ( (_DWORD)v16 == -1 )
{
IsArray = JS_IsArray(a1, Property, -1);
v47 = IsArray;
if ( IsArray >= 0 )
{
v48 = v17;
if ( IsArray )
{
v20 = 0LL;
if ( (unsigned int)js_get_length32(a1, v52, v17, -1) )
goto LABEL_12;
}
else
{
OwnPropertyNamesInternal = JS_GetOwnPropertyNamesInternal(a1, &v42, v52, v48, 17);
v20 = v42;
v17 = v48;
if ( OwnPropertyNamesInternal < 0 )
goto LABEL_12;
}
v51 = v20;
v50 = a6;
v21 = (unsigned int)v52[0];
v30 = 0LL;
v45 = (unsigned int)v52[0];
while ( 1 )
{
if ( v21 == v30 )
{
v22 = v51;
goto LABEL_10;
}
if ( v47 )
{
LODWORD(v31) = JS_NewAtomUInt32(a1, v30);
if ( !(_DWORD)v31 )
goto LABEL_32;
}
else
{
v31 = *(int *)(v51 + 8 * v30 + 4);
if ( v31 >= 224 )
{
v32 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8 * v31);
++*v32;
}
}
v33 = (_DWORD *)internalize_json_property(a1, v17, v18, (unsigned int)v31, v49, v50);
if ( (_DWORD)v34 == 3 )
{
v37 = JS_DeleteProperty(
a1,
a7,
a8,
a9,
a10,
*(double *)v35.m128_u64,
*(double *)v36.m128_u64,
a13,
a14,
v17,
v18,
v31,
0);
}
else
{
if ( (_DWORD)v34 == 6 )
{
JS_FreeAtom(a1, v31);
LABEL_32:
v20 = v51;
LABEL_12:
js_free_prop_enum(a1, v20, v52[0]);
JS_FreeValue(a1, v17, v18);
return 0LL;
}
v37 = JS_DefinePropertyValue(
a1,
v17,
v18,
(unsigned int)v31,
v33,
v34,
*(double *)a7.m128_u64,
a8,
a9,
a10,
v35,
v36,
a13,
a14,
7);
}
v38 = v37;
JS_FreeAtom(a1, v31);
++v30;
v39 = v38 < 0;
v17 = v48;
v21 = v45;
if ( v39 )
goto LABEL_32;
}
}
}
else
{
v50 = a6;
LODWORD(v21) = 0;
v22 = 0LL;
LABEL_10:
js_free_prop_enum(a1, v22, v21);
v23 = JS_AtomToValue(a1, v46);
v25 = v24;
if ( (_DWORD)v24 != 6 )
{
v27 = v23;
v41[0] = v23;
v41[1] = v24;
v41[2] = v17;
v41[3] = v18;
v49 = JS_Call(a1, v49, v50, v44, v43, 2, (long long)v41);
v50 = v28;
JS_FreeValue(a1, v27, v25);
JS_FreeValue(a1, v17, v18);
return v49;
}
}
v20 = 0LL;
goto LABEL_12;
}
return v17;
}
|
internalize_json_property:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
AND dword ptr [RBP + -0x2c],0x0
AND qword ptr [RBP + -0x78],0x0
MOV R15,RDI
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RAX + 0xe8],RBP
JBE 0x00142c31
MOV RDI,R15
CALL 0x00135d91
JMP 0x00142cda
LAB_00142c31:
MOV R12,R9
MOV qword ptr [RBP + -0x48],R8
MOV RDI,R15
MOV qword ptr [RBP + -0x68],RSI
MOV qword ptr [RBP + -0x70],RDX
MOV dword ptr [RBP + -0x58],ECX
CALL 0x0011b043
MOV R14,RAX
MOV RBX,RDX
CMP EBX,0x6
JZ 0x00142ce0
CMP EBX,-0x1
JNZ 0x00142c9b
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00121d01
MOV dword ptr [RBP + -0x54],EAX
TEST EAX,EAX
JS 0x00142cbf
MOV qword ptr [RBP + -0x50],R14
JZ 0x00142d5f
LEA RSI,[RBP + -0x2c]
MOV RDI,R15
MOV RDX,R14
MOV RCX,RBX
CALL 0x001394f2
XOR ESI,ESI
TEST EAX,EAX
JNZ 0x00142cc1
JMP 0x00142d89
LAB_00142c9b:
MOV qword ptr [RBP + -0x40],R12
XOR EDX,EDX
XOR ESI,ESI
LAB_00142ca3:
MOV RDI,R15
CALL 0x0011ddc3
MOV RDI,R15
MOV ESI,dword ptr [RBP + -0x58]
CALL 0x0011a91e
MOV R13,RDX
CMP R13D,0x6
JNZ 0x00142cf8
LAB_00142cbf:
XOR ESI,ESI
LAB_00142cc1:
MOV EDX,dword ptr [RBP + -0x2c]
MOV RDI,R15
CALL 0x0011ddc3
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011801e
LAB_00142cda:
PUSH 0x6
POP RBX
XOR R14D,R14D
LAB_00142ce0:
MOV RAX,R14
MOV RDX,RBX
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00142cf8:
MOV R12,RAX
LEA RAX,[RBP + -0xa0]
MOV qword ptr [RAX],R12
MOV qword ptr [RAX + 0x8],R13
MOV qword ptr [RAX + 0x10],R14
MOV qword ptr [RAX + 0x18],RBX
MOV qword ptr [RSP],RAX
PUSH 0x2
POP R9
MOV RDI,R15
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x68]
MOV R8,qword ptr [RBP + -0x70]
CALL 0x00121eb6
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x40],RDX
MOV RDI,R15
MOV RSI,R12
MOV RDX,R13
CALL 0x0011801e
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011801e
MOV R14,qword ptr [RBP + -0x48]
MOV RBX,qword ptr [RBP + -0x40]
JMP 0x00142ce0
LAB_00142d5f:
LEA R14,[RBP + -0x78]
LEA RDX,[RBP + -0x2c]
PUSH 0x11
POP R8
MOV RDI,R15
MOV RSI,R14
MOV RCX,qword ptr [RBP + -0x50]
CALL 0x0011d5ef
MOV RSI,qword ptr [R14]
MOV R14,qword ptr [RBP + -0x50]
TEST EAX,EAX
JS 0x00142cc1
LAB_00142d89:
MOV qword ptr [RBP + -0x38],RSI
MOV qword ptr [RBP + -0x40],R12
MOV EDX,dword ptr [RBP + -0x2c]
XOR R12D,R12D
MOV qword ptr [RBP + -0x60],RDX
LAB_00142d9b:
CMP RDX,R12
JZ 0x00142e5e
CMP dword ptr [RBP + -0x54],0x0
JZ 0x00142dc1
MOV RDI,R15
MOV ESI,R12D
CALL 0x0011a498
MOV R13D,EAX
TEST EAX,EAX
JNZ 0x00142de1
JMP 0x00142e72
LAB_00142dc1:
MOV RAX,qword ptr [RBP + -0x38]
MOVSXD R13,dword ptr [RAX + R12*0x8 + 0x4]
CMP R13,0xe0
JL 0x00142de1
MOV RAX,qword ptr [R15 + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RAX + R13*0x8]
INC dword ptr [RAX]
LAB_00142de1:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV ECX,R13D
MOV R8,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x40]
CALL 0x00142bf7
MOV R9,RDX
CMP R9D,0x3
JZ 0x00142e26
CMP R9D,0x6
JZ 0x00142e67
MOV dword ptr [RSP],0x7
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV ECX,R13D
MOV R8,RAX
CALL 0x00120872
JMP 0x00142e3a
LAB_00142e26:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV ECX,R13D
XOR R8D,R8D
CALL 0x00120af7
LAB_00142e3a:
MOV R14D,EAX
MOV RDI,R15
MOV ESI,R13D
CALL 0x0011a995
INC R12
TEST R14D,R14D
MOV R14,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x60]
JNS 0x00142d9b
JMP 0x00142e72
LAB_00142e5e:
MOV RSI,qword ptr [RBP + -0x38]
JMP 0x00142ca3
LAB_00142e67:
MOV RDI,R15
MOV ESI,R13D
CALL 0x0011a995
LAB_00142e72:
MOV RSI,qword ptr [RBP + -0x38]
JMP 0x00142cc1
|
int1 [16]
internalize_json_property
(long param_1,int8 param_2,int8 param_3,int4 param_4,int8 param_5,
int8 param_6)
{
int *piVar1;
int iVar2;
uint uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
long lVar7;
ulong uVar8;
ulong uVar9;
int8 uVar10;
int1 auVar11 [16];
int1 local_a8 [16];
int8 local_98;
int8 local_90;
long local_80;
int8 local_78;
int8 local_70;
ulong local_68;
int4 local_60;
int local_5c;
int8 local_58;
int1 local_50 [16];
long local_40;
uint local_34;
local_34 = 0;
local_80 = 0;
if (&stack0xfffffffffffffff8 < *(int1 **)(*(long *)(param_1 + 0x18) + 0xe8)) {
JS_ThrowStackOverflow(param_1);
goto LAB_00142cda;
}
local_78 = param_3;
local_70 = param_2;
local_60 = param_4;
local_50._0_8_ = param_5;
auVar11 = JS_GetProperty(param_1);
uVar5 = auVar11._8_8_;
uVar10 = auVar11._0_8_;
if (auVar11._8_4_ == 6) {
return auVar11;
}
if (auVar11._8_4_ == -1) {
local_5c = JS_IsArray(param_1,uVar10,uVar5);
if (local_5c < 0) goto LAB_00142cbf;
local_58 = uVar10;
if (local_5c == 0) {
iVar2 = JS_GetOwnPropertyNamesInternal(param_1,&local_80,&local_34,uVar10,0x11);
lVar7 = local_80;
uVar10 = local_58;
if (-1 < iVar2) goto LAB_00142d89;
}
else {
iVar2 = js_get_length32(param_1,&local_34,uVar10,uVar5);
lVar7 = 0;
if (iVar2 == 0) {
LAB_00142d89:
local_68 = (ulong)local_34;
uVar8 = 0;
local_50._8_8_ = param_6;
local_40 = lVar7;
do {
uVar9 = local_68;
lVar7 = local_40;
if (local_68 == uVar8) goto LAB_00142ca3;
if (local_5c == 0) {
uVar9 = (ulong)*(int *)(local_40 + 4 + uVar8 * 8);
if (0xdf < (long)uVar9) {
piVar1 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + uVar9 * 8);
*piVar1 = *piVar1 + 1;
}
}
else {
uVar3 = JS_NewAtomUInt32(param_1,uVar8 & 0xffffffff);
uVar9 = (ulong)uVar3;
lVar7 = local_40;
if (uVar3 == 0) break;
}
auVar11 = internalize_json_property
(param_1,uVar10,uVar5,uVar9 & 0xffffffff,local_50._0_8_,local_50._8_8_
);
if (auVar11._8_4_ == 3) {
iVar2 = JS_DeleteProperty(param_1,uVar10,uVar5,uVar9 & 0xffffffff,0);
}
else {
if (auVar11._8_4_ == 6) {
JS_FreeAtom(param_1,uVar9 & 0xffffffff);
lVar7 = local_40;
break;
}
iVar2 = JS_DefinePropertyValue
(param_1,uVar10,uVar5,uVar9 & 0xffffffff,auVar11._0_8_,auVar11._8_8_,7
);
}
JS_FreeAtom(param_1,uVar9 & 0xffffffff);
uVar8 = uVar8 + 1;
lVar7 = local_40;
uVar10 = local_58;
} while (-1 < iVar2);
}
}
}
else {
uVar9 = 0;
lVar7 = 0;
local_50._8_8_ = param_6;
LAB_00142ca3:
js_free_prop_enum(param_1,lVar7,uVar9);
local_a8 = JS_AtomToValue(param_1,local_60);
uVar6 = local_a8._8_8_;
uVar4 = local_a8._0_8_;
if (local_a8._8_4_ != 6) {
local_98 = uVar10;
local_90 = uVar5;
local_50 = JS_Call(param_1,local_50._0_8_,local_50._8_8_,local_70,local_78,2,local_a8);
JS_FreeValue(param_1,uVar4,uVar6);
JS_FreeValue(param_1,uVar10,uVar5);
return local_50;
}
LAB_00142cbf:
lVar7 = 0;
}
js_free_prop_enum(param_1,lVar7,local_34);
JS_FreeValue(param_1,uVar10,uVar5);
LAB_00142cda:
return ZEXT816(6) << 0x40;
}
|
|
17,226
|
ma_unpin_all_pages
|
eloqsql/storage/maria/ma_key_recover.c
|
void _ma_unpin_all_pages(MARIA_HA *info, LSN undo_lsn)
{
MARIA_PINNED_PAGE *page_link= ((MARIA_PINNED_PAGE*)
dynamic_array_ptr(&info->pinned_pages, 0));
MARIA_PINNED_PAGE *pinned_page= page_link + info->pinned_pages.elements;
DBUG_ENTER("_ma_unpin_all_pages");
DBUG_PRINT("info", ("undo_lsn: %lu", (ulong) undo_lsn));
if (!info->s->now_transactional)
DBUG_ASSERT(undo_lsn == LSN_IMPOSSIBLE || maria_in_recovery);
while (pinned_page-- != page_link)
{
/*
Note this assert fails if we got a disk error or the record file
is corrupted, which means we should have this enabled only in debug
builds.
*/
#ifdef EXTRA_DEBUG
DBUG_ASSERT((!pinned_page->changed ||
undo_lsn != LSN_IMPOSSIBLE || !info->s->now_transactional) ||
(info->s->state.changed & STATE_CRASHED_FLAGS));
#endif
pagecache_unlock_by_link(info->s->pagecache, pinned_page->link,
pinned_page->unlock, PAGECACHE_UNPIN,
info->trn->rec_lsn, undo_lsn,
pinned_page->changed, FALSE);
}
info->pinned_pages.elements= 0;
DBUG_VOID_RETURN;
}
|
O0
|
c
|
ma_unpin_all_pages:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x2e8(%rax), %rax
movq -0x8(%rbp), %rcx
imull $0x0, 0x2fc(%rcx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x2f0(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x43eda
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x7e7(%rax)
jne 0x43ef0
jmp 0x43eec
jmp 0x43eee
jmp 0x43ef0
jmp 0x43ef2
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x18, %rcx
movq %rcx, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
je 0x43f58
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x600(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x90(%rax), %r8
movq -0x10(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x3, %ecx
xorl %r10d, %r10d
movsbl 0x10(%rax), %eax
movl %eax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x3cd70
jmp 0x43ef2
movq -0x8(%rbp), %rax
movl $0x0, 0x2f0(%rax)
jmp 0x43f68
addq $0x30, %rsp
popq %rbp
retq
nop
|
_ma_unpin_all_pages:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax+2E8h]
mov rcx, [rbp+var_8]
imul ecx, [rcx+2FCh], 0
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
mov ecx, [rcx+2F0h]
imul rcx, 18h
add rax, rcx
mov [rbp+var_20], rax
jmp short $+2
loc_43EDA:
mov rax, [rbp+var_8]
mov rax, [rax]
cmp byte ptr [rax+7E7h], 0
jnz short loc_43EF0
jmp short $+2
loc_43EEC:
jmp short $+2
loc_43EEE:
jmp short $+2
loc_43EF0:
jmp short $+2
loc_43EF2:
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFE8h
mov [rbp+var_20], rcx
cmp rax, [rbp+var_18]
jz short loc_43F58
mov rax, [rbp+var_8]
mov rax, [rax]
mov rdi, [rax+600h]
mov rax, [rbp+var_20]
mov rsi, [rax]
mov rax, [rbp+var_20]
mov edx, [rax+8]
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov r8, [rax+90h]
mov r9, [rbp+var_10]
mov rax, [rbp+var_20]
mov ecx, 3
xor r10d, r10d
movsx eax, byte ptr [rax+10h]
mov [rsp+30h+var_30], eax
mov [rsp+30h+var_28], 0
call pagecache_unlock_by_link
jmp short loc_43EF2
loc_43F58:
mov rax, [rbp+var_8]
mov dword ptr [rax+2F0h], 0
jmp short $+2
loc_43F68:
add rsp, 30h
pop rbp
retn
|
long long ma_unpin_all_pages(long long a1, long long a2)
{
long long v2; // rax
long long result; // rax
long long i; // [rsp+10h] [rbp-20h]
long long v5; // [rsp+18h] [rbp-18h]
v5 = *(_QWORD *)(a1 + 744);
for ( i = 24LL * *(unsigned int *)(a1 + 752) + v5;
;
pagecache_unlock_by_link(
*(_QWORD **)(*(_QWORD *)a1 + 1536LL),
*(_QWORD *)i,
*(_DWORD *)(i + 8),
3,
*(_QWORD *)(*(_QWORD *)(a1 + 8) + 144LL),
a2,
*(_BYTE *)(i + 16),
0) )
{
v2 = i;
i -= 24LL;
if ( v2 == v5 )
break;
}
result = a1;
*(_DWORD *)(a1 + 752) = 0;
return result;
}
|
_ma_unpin_all_pages:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2e8]
MOV RCX,qword ptr [RBP + -0x8]
IMUL ECX,dword ptr [RCX + 0x2fc],0x0
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x2f0]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00143eda
LAB_00143eda:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX + 0x7e7],0x0
JNZ 0x00143ef0
JMP 0x00143eec
LAB_00143eec:
JMP 0x00143eee
LAB_00143eee:
JMP 0x00143ef0
LAB_00143ef0:
JMP 0x00143ef2
LAB_00143ef2:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,-0x18
MOV qword ptr [RBP + -0x20],RCX
CMP RAX,qword ptr [RBP + -0x18]
JZ 0x00143f58
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x600]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R8,qword ptr [RAX + 0x90]
MOV R9,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,0x3
XOR R10D,R10D
MOVSX EAX,byte ptr [RAX + 0x10]
MOV dword ptr [RSP],EAX
MOV dword ptr [RSP + 0x8],0x0
CALL 0x0013cd70
JMP 0x00143ef2
LAB_00143f58:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2f0],0x0
JMP 0x00143f68
LAB_00143f68:
ADD RSP,0x30
POP RBP
RET
|
void _ma_unpin_all_pages(long *param_1,int8 param_2)
{
int8 *puVar1;
int8 *local_28;
puVar1 = (int8 *)param_1[0x5d];
local_28 = puVar1 + (ulong)*(uint *)(param_1 + 0x5e) * 3;
while (local_28 != puVar1) {
pagecache_unlock_by_link
(*(int8 *)(*param_1 + 0x600),local_28[-3],*(int4 *)(local_28 + -2),3,
*(int8 *)(param_1[1] + 0x90),param_2,(int)*(char *)(local_28 + -1),0);
local_28 = local_28 + -3;
}
*(int4 *)(param_1 + 0x5e) = 0;
return;
}
|
|
17,227
|
sqr_fp4
|
corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/fp12_tower.c
|
static void sqr_fp4(vec384fp4 ret, const vec384x a0, const vec384x a1)
{
vec768x t0, t1, t2;
sqr_fp2x2(t0, a0);
sqr_fp2x2(t1, a1);
add_fp2(ret[1], a0, a1);
mul_by_u_plus_1_fp2x2(t2, t1);
add_fp2x2(t2, t2, t0);
redc_fp2x2(ret[0], t2);
sqr_fp2x2(t2, ret[1]);
sub_fp2x2(t2, t2, t0);
sub_fp2x2(t2, t2, t1);
redc_fp2x2(ret[1], t2);
}
|
O2
|
c
|
sqr_fp4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
leaq -0xf0(%rbp), %rdi
callq 0x5d0be
leaq -0x270(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x5d0be
leaq 0x60(%r13), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x5acb9
leaq -0x1b0(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5cf21
movq %r12, %rdi
movq %r12, %rsi
leaq -0xf0(%rbp), %rbx
movq %rbx, %rdx
callq 0x5cf65
movq %r13, %rdi
movq %r12, %rsi
callq 0x5cfad
movq %r12, %rdi
movq %r15, %rsi
callq 0x5d0be
movq %r12, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x5ced9
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x5ced9
movq %r15, %rdi
movq %r12, %rsi
callq 0x5cfad
addq $0x248, %rsp # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
sqr_fp4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 248h
mov r12, rdx
mov rbx, rsi
mov r13, rdi
lea rdi, [rbp+var_F0]
call sqr_fp2x2
lea r14, [rbp+var_270]
mov rdi, r14
mov rsi, r12
call sqr_fp2x2
lea r15, [r13+60h]
mov rdi, r15
mov rsi, rbx
mov rdx, r12
call add_fp2
lea r12, [rbp+var_1B0]
mov rdi, r12
mov rsi, r14
call mul_by_u_plus_1_fp2x2
mov rdi, r12
mov rsi, r12
lea rbx, [rbp+var_F0]
mov rdx, rbx
call add_fp2x2
mov rdi, r13
mov rsi, r12
call redc_fp2x2
mov rdi, r12
mov rsi, r15
call sqr_fp2x2
mov rdi, r12
mov rsi, r12
mov rdx, rbx
call _sub_fp2x2
mov rdi, r12
mov rsi, r12
mov rdx, r14
call _sub_fp2x2
mov rdi, r15
mov rsi, r12
call redc_fp2x2
add rsp, 248h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long sqr_fp4(long long a1, long long a2, long long a3)
{
_BYTE v5[192]; // [rsp+0h] [rbp-270h] BYREF
_BYTE v6[192]; // [rsp+C0h] [rbp-1B0h] BYREF
_BYTE v7[240]; // [rsp+180h] [rbp-F0h] BYREF
sqr_fp2x2(v7);
sqr_fp2x2(v5);
add_fp2(a1 + 96, a2, a3);
mul_by_u_plus_1_fp2x2((long long)v6, (long long)v5);
add_fp2x2((long long)v6, (long long)v6, (long long)v7);
redc_fp2x2(a1, (long long)v6);
sqr_fp2x2(v6);
sub_fp2x2((long long)v6, (long long)v6, (long long)v7);
sub_fp2x2((long long)v6, (long long)v6, (long long)v5);
return redc_fp2x2(a1 + 96, (long long)v6);
}
|
sqr_fp4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x248
MOV R12,RDX
MOV RBX,RSI
MOV R13,RDI
LEA RDI,[RBP + -0xf0]
CALL 0x0015d0be
LEA R14,[RBP + -0x270]
MOV RDI,R14
MOV RSI,R12
CALL 0x0015d0be
LEA R15,[R13 + 0x60]
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R12
CALL 0x0015acb9
LEA R12,[RBP + -0x1b0]
MOV RDI,R12
MOV RSI,R14
CALL 0x0015cf21
MOV RDI,R12
MOV RSI,R12
LEA RBX,[RBP + -0xf0]
MOV RDX,RBX
CALL 0x0015cf65
MOV RDI,R13
MOV RSI,R12
CALL 0x0015cfad
MOV RDI,R12
MOV RSI,R15
CALL 0x0015d0be
MOV RDI,R12
MOV RSI,R12
MOV RDX,RBX
CALL 0x0015ced9
MOV RDI,R12
MOV RSI,R12
MOV RDX,R14
CALL 0x0015ced9
MOV RDI,R15
MOV RSI,R12
CALL 0x0015cfad
ADD RSP,0x248
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void sqr_fp4(long param_1,int8 param_2,int8 param_3)
{
long lVar1;
int1 local_278 [192];
int1 local_1b8 [192];
int1 local_f8 [200];
sqr_fp2x2(local_f8);
sqr_fp2x2(local_278,param_3);
lVar1 = param_1 + 0x60;
add_fp2(lVar1,param_2,param_3);
mul_by_u_plus_1_fp2x2(local_1b8,local_278);
add_fp2x2(local_1b8,local_1b8,local_f8);
redc_fp2x2(param_1,local_1b8);
sqr_fp2x2(local_1b8,lVar1);
sub_fp2x2(local_1b8,local_1b8,local_f8);
sub_fp2x2(local_1b8,local_1b8,local_278);
redc_fp2x2(lVar1,local_1b8);
return;
}
|
|
17,228
|
common_log::pause()
|
monkey531[P]llama/common/log.cpp
|
void pause() {
{
std::lock_guard<std::mutex> lock(mtx);
if (!running) {
return;
}
running = false;
// push an entry to signal the worker thread to stop
{
auto & entry = entries[tail];
entry.is_end = true;
tail = (tail + 1) % entries.size();
}
cv.notify_one();
}
thrd.join();
}
|
O2
|
cpp
|
common_log::pause():
pushq %rbx
movq %rdi, %rbx
callq 0x96e32
cmpb $0x1, 0x6a(%rbx)
jne 0x96642
movb $0x0, 0x6a(%rbx)
movq 0x78(%rbx), %rdx
movq 0x98(%rbx), %rcx
imulq $0x30, %rcx, %rax
movb $0x1, 0x28(%rdx,%rax)
incq %rcx
movq 0x80(%rbx), %rax
subq %rdx, %rax
pushq $0x30
popq %rsi
cqto
idivq %rsi
movq %rax, %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, 0x98(%rbx)
leaq 0x30(%rbx), %rdi
callq 0x23490
movq %rbx, %rdi
callq 0x236f0
addq $0x28, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x23f20
movq %rbx, %rdi
popq %rbx
jmp 0x236f0
nop
|
_ZN10common_log5pauseEv:
push rbx
mov rbx, rdi
call _ZNSt5mutex4lockEv; std::mutex::lock(void)
cmp byte ptr [rbx+6Ah], 1
jnz short loc_96642
mov byte ptr [rbx+6Ah], 0
mov rdx, [rbx+78h]
mov rcx, [rbx+98h]
imul rax, rcx, 30h ; '0'
mov byte ptr [rdx+rax+28h], 1
inc rcx
mov rax, [rbx+80h]
sub rax, rdx
push 30h ; '0'
pop rsi
cqo
idiv rsi
mov rsi, rax
mov rax, rcx
xor edx, edx
div rsi
mov [rbx+98h], rdx
lea rdi, [rbx+30h]; this
call __ZNSt18condition_variable10notify_oneEv; std::condition_variable::notify_one(void)
mov rdi, rbx
call _pthread_mutex_unlock
add rbx, 28h ; '('
mov rdi, rbx; this
pop rbx
jmp __ZNSt6thread4joinEv; std::thread::join(void)
loc_96642:
mov rdi, rbx
pop rbx
jmp _pthread_mutex_unlock
|
long long common_log::pause(common_log *this)
{
long long v1; // rdx
long long v2; // rcx
std::mutex::lock(this);
if ( *((_BYTE *)this + 106) != 1 )
return pthread_mutex_unlock(this);
*((_BYTE *)this + 106) = 0;
v1 = *((_QWORD *)this + 15);
v2 = *((_QWORD *)this + 19);
*(_BYTE *)(v1 + 48 * v2 + 40) = 1;
*((_QWORD *)this + 19) = (v2 + 1) % (unsigned long long)((*((_QWORD *)this + 16) - v1) / 48);
std::condition_variable::notify_one((common_log *)((char *)this + 48));
pthread_mutex_unlock(this);
return std::thread::join((common_log *)((char *)this + 40));
}
|
pause:
PUSH RBX
MOV RBX,RDI
CALL 0x00196e32
CMP byte ptr [RBX + 0x6a],0x1
JNZ 0x00196642
MOV byte ptr [RBX + 0x6a],0x0
MOV RDX,qword ptr [RBX + 0x78]
MOV RCX,qword ptr [RBX + 0x98]
IMUL RAX,RCX,0x30
MOV byte ptr [RDX + RAX*0x1 + 0x28],0x1
INC RCX
MOV RAX,qword ptr [RBX + 0x80]
SUB RAX,RDX
PUSH 0x30
POP RSI
CQO
IDIV RSI
MOV RSI,RAX
MOV RAX,RCX
XOR EDX,EDX
DIV RSI
MOV qword ptr [RBX + 0x98],RDX
LEA RDI,[RBX + 0x30]
CALL 0x00123490
MOV RDI,RBX
CALL 0x001236f0
ADD RBX,0x28
MOV RDI,RBX
POP RBX
JMP 0x00123f20
LAB_00196642:
MOV RDI,RBX
POP RBX
JMP 0x001236f0
|
/* common_log::pause() */
void __thiscall common_log::pause(common_log *this)
{
long lVar1;
long lVar2;
std::mutex::lock((mutex *)this);
if (this[0x6a] == (common_log)0x1) {
this[0x6a] = (common_log)0x0;
lVar1 = *(long *)(this + 0x78);
lVar2 = *(long *)(this + 0x98);
*(int1 *)(lVar1 + 0x28 + lVar2 * 0x30) = 1;
*(ulong *)(this + 0x98) = (lVar2 + 1U) % (ulong)((*(long *)(this + 0x80) - lVar1) / 0x30);
std::condition_variable::notify_one();
pthread_mutex_unlock((pthread_mutex_t *)this);
std::thread::join();
return;
}
pthread_mutex_unlock((pthread_mutex_t *)this);
return;
}
|
|
17,229
|
ma_net_real_write
|
eloqsql/libmariadb/libmariadb/ma_net.c
|
int ma_net_real_write(NET *net, const char *packet, size_t len)
{
ssize_t length;
char *pos,*end;
if (net->error == 2)
return(-1); /* socket can't be used */
net->reading_or_writing=2;
#ifdef HAVE_COMPRESS
if (net->compress)
{
size_t complen;
uchar *b;
uint header_length=NET_HEADER_SIZE+COMP_HEADER_SIZE;
if (!(b=(uchar*) malloc(len + NET_HEADER_SIZE + COMP_HEADER_SIZE + 1)))
{
net->pvio->set_error(net->pvio->mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
net->error=2;
net->reading_or_writing=0;
return(1);
}
memcpy(b+header_length,packet,len);
if (_mariadb_compress(net, (unsigned char*) b+header_length,&len,&complen))
{
complen=0;
}
int3store(&b[NET_HEADER_SIZE],complen);
int3store(b,len);
b[3]=(uchar) (net->compress_pkt_nr++);
len+= header_length;
packet= (char*) b;
}
#endif /* HAVE_COMPRESS */
pos=(char*) packet; end=pos+len;
while (pos != end)
{
if ((length=ma_pvio_write(net->pvio,(uchar *)pos,(size_t) (end-pos))) <= 0)
{
int save_errno= errno;
char errmsg[100];
net->error=2; /* Close socket */
strerror_r(save_errno, errmsg, 100);
net->pvio->set_error(net->pvio->mysql, CR_ERR_NET_WRITE, SQLSTATE_UNKNOWN, 0,
errmsg, save_errno);
net->reading_or_writing=0;
#ifdef HAVE_COMPRESS
if (net->compress)
free((char*) packet);
#endif
return(1);
}
pos+=length;
}
#ifdef HAVE_COMPRESS
if (net->compress)
free((char*) packet);
#endif
net->reading_or_writing=0;
return(((int) (pos != end)));
}
|
O3
|
c
|
ma_net_real_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq %rdx, -0xa8(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpb $0x2, 0x94(%rdi)
je 0x311cd
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movb $0x2, 0x80(%rdi)
cmpb $0x0, 0x84(%rdi)
je 0x3109e
leaq 0x8(%rbx), %rdi
callq 0x13600
testq %rax, %rax
je 0x310a3
movq %rax, %r12
movq %rax, %r13
addq $0x7, %r13
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x13390
leaq -0xa8(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1dec3
testb %al, %al
jne 0x310d6
movq -0xa0(%rbp), %rax
jmp 0x310d8
movq %r15, %r12
jmp 0x3111e
movq (%r14), %r8
movq 0x40(%r8), %rdi
leaq 0x1797f(%rip), %rax # 0x48a30
movq (%rax), %rdx
movl $0x7d8, %esi # imm = 0x7D8
xorl %ecx, %ecx
xorl %eax, %eax
callq *0x50(%r8)
movb $0x2, 0x94(%r14)
movb $0x0, 0x80(%r14)
jmp 0x311c8
xorl %eax, %eax
movq %r12, %rdx
movb %al, 0x4(%r12)
movb %ah, 0x5(%rdx)
shrl $0x10, %eax
movb %al, 0x6(%r12)
movq -0xa8(%rbp), %rbx
movb %bl, (%r12)
movb %bh, 0x1(%rdx)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0x2(%r12)
movl 0x64(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x64(%r14)
movb %al, 0x3(%r12)
addq $0x7, %rbx
movq %rbx, -0xa8(%rbp)
testq %rbx, %rbx
je 0x31147
movq %r12, %r15
addq %r12, %rbx
movq (%r14), %rdi
movq %rbx, %rdx
subq %r15, %rdx
movq %r15, %rsi
callq 0x1d2aa
testq %rax, %rax
jle 0x31165
addq %rax, %r15
cmpq %rbx, %r15
jne 0x31129
cmpb $0x0, 0x84(%r14)
je 0x31159
movq %r12, %rdi
callq 0x13570
movb $0x0, 0x80(%r14)
xorl %eax, %eax
jmp 0x311cd
callq 0x13060
movl (%rax), %ebx
movb $0x2, 0x94(%r14)
leaq -0xa0(%rbp), %r15
movl $0x64, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x131e0
movq (%r14), %r10
movq 0x40(%r10), %rdi
leaq 0x17898(%rip), %rax # 0x48a30
movq (%rax), %rdx
movl $0x1396, %esi # imm = 0x1396
xorl %ecx, %ecx
movq %r15, %r8
movl %ebx, %r9d
xorl %eax, %eax
callq *0x50(%r10)
movb $0x0, 0x80(%r14)
cmpb $0x0, 0x84(%r14)
je 0x311c8
movq %r12, %rdi
callq 0x13570
movl $0x1, %eax
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x311ee
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
|
ma_net_real_write:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov rax, fs:28h
mov [rbp+var_30], rax
mov [rbp+var_A8], rdx
mov eax, 0FFFFFFFFh
cmp byte ptr [rdi+94h], 2
jz loc_311CD
mov rbx, rdx
mov r15, rsi
mov r14, rdi
mov byte ptr [rdi+80h], 2
cmp byte ptr [rdi+84h], 0
jz short loc_3109E
lea rdi, [rbx+8]
call _malloc
test rax, rax
jz short loc_310A3
mov r12, rax
mov r13, rax
add r13, 7
mov rdi, r13
mov rsi, r15
mov rdx, rbx
call _memcpy
lea rdx, [rbp+var_A8]
lea rcx, [rbp+var_A0]
mov rdi, r14
mov rsi, r13
call _mariadb_compress
test al, al
jnz short loc_310D6
mov rax, [rbp+var_A0]
jmp short loc_310D8
loc_3109E:
mov r12, r15
jmp short loc_3111E
loc_310A3:
mov r8, [r14]
mov rdi, [r8+40h]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7D8h
xor ecx, ecx
xor eax, eax
call qword ptr [r8+50h]
mov byte ptr [r14+94h], 2
mov byte ptr [r14+80h], 0
jmp loc_311C8
loc_310D6:
xor eax, eax
loc_310D8:
mov rdx, r12
mov [r12+4], al
mov [rdx+5], ah
shr eax, 10h
mov [r12+6], al
mov rbx, [rbp+var_A8]
mov [r12], bl
mov [rdx+1], bh
mov eax, ebx
shr eax, 10h
mov [r12+2], al
mov eax, [r14+64h]
lea ecx, [rax+1]
mov [r14+64h], ecx
mov [r12+3], al
add rbx, 7
mov [rbp+var_A8], rbx
loc_3111E:
test rbx, rbx
jz short loc_31147
mov r15, r12
add rbx, r12
loc_31129:
mov rdi, [r14]
mov rdx, rbx
sub rdx, r15
mov rsi, r15
call ma_pvio_write
test rax, rax
jle short loc_31165
add r15, rax
cmp r15, rbx
jnz short loc_31129
loc_31147:
cmp byte ptr [r14+84h], 0
jz short loc_31159
mov rdi, r12
call _free
loc_31159:
mov byte ptr [r14+80h], 0
xor eax, eax
jmp short loc_311CD
loc_31165:
call ___errno_location
mov ebx, [rax]
mov byte ptr [r14+94h], 2
lea r15, [rbp+var_A0]
mov edx, 64h ; 'd'
mov edi, ebx
mov rsi, r15
call ___xpg_strerror_r
mov r10, [r14]
mov rdi, [r10+40h]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 1396h
xor ecx, ecx
mov r8, r15
mov r9d, ebx
xor eax, eax
call qword ptr [r10+50h]
mov byte ptr [r14+80h], 0
cmp byte ptr [r14+84h], 0
jz short loc_311C8
mov rdi, r12
call _free
loc_311C8:
mov eax, 1
loc_311CD:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_311EE
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_311EE:
call ___stack_chk_fail
|
long long ma_net_real_write(_BYTE *a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rbx
long long v6; // rax
long long v7; // r12
long long v8; // r13
int v9; // eax
long long v10; // rbx
int v11; // eax
long long v12; // r15
long long v13; // rbx
long long v14; // rdi
long long v15; // rax
unsigned int v16; // ebx
long long v17; // [rsp+8h] [rbp-A8h] BYREF
_QWORD v18[20]; // [rsp+10h] [rbp-A0h] BYREF
v18[14] = __readfsqword(0x28u);
v17 = a3;
result = 0xFFFFFFFFLL;
if ( a1[148] != 2 )
{
v4 = a3;
a1[128] = 2;
if ( a1[132] )
{
v6 = malloc(a3 + 8);
if ( !v6 )
{
(*(void ( **)(_QWORD, long long, char *, _QWORD))(*(_QWORD *)a1 + 80LL))(
*(_QWORD *)(*(_QWORD *)a1 + 64LL),
2008LL,
SQLSTATE_UNKNOWN,
0LL);
a1[148] = 2;
a1[128] = 0;
return 1LL;
}
v7 = v6;
v8 = v6 + 7;
memcpy(v6 + 7, a2, v4);
if ( mariadb_compress((long long)a1, v8, &v17, v18) )
v9 = 0;
else
v9 = v18[0];
*(_WORD *)(v7 + 4) = v9;
*(_BYTE *)(v7 + 6) = BYTE2(v9);
v10 = v17;
*(_WORD *)v7 = v17;
*(_BYTE *)(v7 + 2) = BYTE2(v10);
v11 = *((_DWORD *)a1 + 25);
*((_DWORD *)a1 + 25) = v11 + 1;
*(_BYTE *)(v7 + 3) = v11;
v4 = v10 + 7;
v17 = v4;
}
else
{
v7 = a2;
}
if ( v4 )
{
v12 = v7;
v13 = v7 + v4;
while ( 1 )
{
v14 = *(_QWORD *)a1;
v15 = ma_pvio_write(*(_QWORD *)a1, v12, v13 - v12);
if ( v15 <= 0 )
break;
v12 += v15;
if ( v12 == v13 )
goto LABEL_14;
}
v16 = *(_DWORD *)__errno_location(v14);
a1[148] = 2;
__xpg_strerror_r(v16, v18, 100LL);
(*(void ( **)(_QWORD, long long, char *, _QWORD, _QWORD *, _QWORD))(*(_QWORD *)a1 + 80LL))(
*(_QWORD *)(*(_QWORD *)a1 + 64LL),
5014LL,
SQLSTATE_UNKNOWN,
0LL,
v18,
v16);
a1[128] = 0;
if ( a1[132] )
free(v7);
return 1LL;
}
LABEL_14:
if ( a1[132] )
free(v7);
a1[128] = 0;
return 0LL;
}
return result;
}
|
ma_net_real_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0xa8],RDX
MOV EAX,0xffffffff
CMP byte ptr [RDI + 0x94],0x2
JZ 0x001311cd
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
MOV byte ptr [RDI + 0x80],0x2
CMP byte ptr [RDI + 0x84],0x0
JZ 0x0013109e
LEA RDI,[RBX + 0x8]
CALL 0x00113600
TEST RAX,RAX
JZ 0x001310a3
MOV R12,RAX
MOV R13,RAX
ADD R13,0x7
MOV RDI,R13
MOV RSI,R15
MOV RDX,RBX
CALL 0x00113390
LEA RDX,[RBP + -0xa8]
LEA RCX,[RBP + -0xa0]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011dec3
TEST AL,AL
JNZ 0x001310d6
MOV RAX,qword ptr [RBP + -0xa0]
JMP 0x001310d8
LAB_0013109e:
MOV R12,R15
JMP 0x0013111e
LAB_001310a3:
MOV R8,qword ptr [R14]
MOV RDI,qword ptr [R8 + 0x40]
LEA RAX,[0x148a30]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7d8
XOR ECX,ECX
XOR EAX,EAX
CALL qword ptr [R8 + 0x50]
MOV byte ptr [R14 + 0x94],0x2
MOV byte ptr [R14 + 0x80],0x0
JMP 0x001311c8
LAB_001310d6:
XOR EAX,EAX
LAB_001310d8:
MOV RDX,R12
MOV byte ptr [R12 + 0x4],AL
MOV byte ptr [RDX + 0x5],AH
SHR EAX,0x10
MOV byte ptr [R12 + 0x6],AL
MOV RBX,qword ptr [RBP + -0xa8]
MOV byte ptr [R12],BL
MOV byte ptr [RDX + 0x1],BH
MOV EAX,EBX
SHR EAX,0x10
MOV byte ptr [R12 + 0x2],AL
MOV EAX,dword ptr [R14 + 0x64]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R14 + 0x64],ECX
MOV byte ptr [R12 + 0x3],AL
ADD RBX,0x7
MOV qword ptr [RBP + -0xa8],RBX
LAB_0013111e:
TEST RBX,RBX
JZ 0x00131147
MOV R15,R12
ADD RBX,R12
LAB_00131129:
MOV RDI,qword ptr [R14]
MOV RDX,RBX
SUB RDX,R15
MOV RSI,R15
CALL 0x0011d2aa
TEST RAX,RAX
JLE 0x00131165
ADD R15,RAX
CMP R15,RBX
JNZ 0x00131129
LAB_00131147:
CMP byte ptr [R14 + 0x84],0x0
JZ 0x00131159
MOV RDI,R12
CALL 0x00113570
LAB_00131159:
MOV byte ptr [R14 + 0x80],0x0
XOR EAX,EAX
JMP 0x001311cd
LAB_00131165:
CALL 0x00113060
MOV EBX,dword ptr [RAX]
MOV byte ptr [R14 + 0x94],0x2
LEA R15,[RBP + -0xa0]
MOV EDX,0x64
MOV EDI,EBX
MOV RSI,R15
CALL 0x001131e0
MOV R10,qword ptr [R14]
MOV RDI,qword ptr [R10 + 0x40]
LEA RAX,[0x148a30]
MOV RDX,qword ptr [RAX]
MOV ESI,0x1396
XOR ECX,ECX
MOV R8,R15
MOV R9D,EBX
XOR EAX,EAX
CALL qword ptr [R10 + 0x50]
MOV byte ptr [R14 + 0x80],0x0
CMP byte ptr [R14 + 0x84],0x0
JZ 0x001311c8
MOV RDI,R12
CALL 0x00113570
LAB_001311c8:
MOV EAX,0x1
LAB_001311cd:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x001311ee
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001311ee:
CALL 0x00113500
|
int8 ma_net_real_write(long *param_1,int1 *param_2,size_t param_3)
{
int iVar1;
char cVar2;
int8 uVar3;
int1 *puVar4;
long lVar5;
int *piVar6;
int1 *puVar7;
long in_FS_OFFSET;
size_t local_b0;
int4 local_a8 [28];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = 0xffffffff;
local_b0 = param_3;
if (*(char *)((long)param_1 + 0x94) != '\x02') {
*(int1 *)(param_1 + 0x10) = 2;
if (*(char *)((long)param_1 + 0x84) != '\0') {
puVar4 = (int1 *)malloc(param_3 + 8);
if (puVar4 == (int1 *)0x0) {
(**(code **)(*param_1 + 0x50))(*(int8 *)(*param_1 + 0x40),0x7d8,SQLSTATE_UNKNOWN,0);
*(int1 *)((long)param_1 + 0x94) = 2;
*(int1 *)(param_1 + 0x10) = 0;
LAB_001311c8:
uVar3 = 1;
goto LAB_001311cd;
}
memcpy(puVar4 + 7,param_2,param_3);
cVar2 = _mariadb_compress(param_1,puVar4 + 7,&local_b0,local_a8);
if (cVar2 != '\0') {
local_a8[0] = 0;
}
puVar4[4] = (char)local_a8[0];
puVar4[5] = (char)((uint)local_a8[0] >> 8);
puVar4[6] = (char)((uint)local_a8[0] >> 0x10);
*puVar4 = (char)local_b0;
puVar4[1] = (char)(local_b0 >> 8);
puVar4[2] = (char)(local_b0 >> 0x10);
iVar1 = *(int *)((long)param_1 + 100);
*(int *)((long)param_1 + 100) = iVar1 + 1;
puVar4[3] = (char)iVar1;
local_b0 = local_b0 + 7;
param_2 = puVar4;
}
if (local_b0 != 0) {
puVar7 = param_2 + local_b0;
puVar4 = param_2;
do {
lVar5 = ma_pvio_write(*param_1,puVar4,(long)puVar7 - (long)puVar4);
if (lVar5 < 1) {
piVar6 = __errno_location();
iVar1 = *piVar6;
*(int1 *)((long)param_1 + 0x94) = 2;
__xpg_strerror_r(iVar1,local_a8,100);
(**(code **)(*param_1 + 0x50))
(*(int8 *)(*param_1 + 0x40),0x1396,SQLSTATE_UNKNOWN,0,local_a8,iVar1);
*(int1 *)(param_1 + 0x10) = 0;
if (*(char *)((long)param_1 + 0x84) != '\0') {
free(param_2);
}
goto LAB_001311c8;
}
puVar4 = puVar4 + lVar5;
} while (puVar4 != puVar7);
}
if (*(char *)((long)param_1 + 0x84) != '\0') {
free(param_2);
}
*(int1 *)(param_1 + 0x10) = 0;
uVar3 = 0;
}
LAB_001311cd:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
}
|
|
17,230
|
bitmap_is_set_all
|
eloqsql/mysys/my_bitmap.c
|
my_bool bitmap_is_set_all(const MY_BITMAP *map)
{
my_bitmap_map *data_ptr= map->bitmap;
my_bitmap_map *end= map->last_word_ptr;
for (; data_ptr < end; data_ptr++)
if (*data_ptr != 0xFFFFFFFF)
return FALSE;
return (*data_ptr | map->last_word_mask) == 0xFFFFFFFF;
}
|
O0
|
c
|
bitmap_is_set_all:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xb4ec8
movq -0x18(%rbp), %rax
cmpl $-0x1, (%rax)
je 0xb4eb8
movb $0x0, -0x1(%rbp)
jmp 0xb4ee3
jmp 0xb4eba
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0xb4e9f
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
orl 0x18(%rcx), %eax
cmpl $-0x1, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
|
bitmap_is_set_all:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_20], rax
loc_B4E9F:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_B4EC8
mov rax, [rbp+var_18]
cmp dword ptr [rax], 0FFFFFFFFh
jz short loc_B4EB8
mov [rbp+var_1], 0
jmp short loc_B4EE3
loc_B4EB8:
jmp short $+2
loc_B4EBA:
mov rax, [rbp+var_18]
add rax, 4
mov [rbp+var_18], rax
jmp short loc_B4E9F
loc_B4EC8:
mov rax, [rbp+var_18]
mov eax, [rax]
mov rcx, [rbp+var_10]
or eax, [rcx+18h]
cmp eax, 0FFFFFFFFh
setz al
and al, 1
movzx eax, al
mov [rbp+var_1], al
loc_B4EE3:
mov al, [rbp+var_1]
pop rbp
retn
|
bool bitmap_is_set_all(long long a1)
{
_DWORD *i; // [rsp+8h] [rbp-18h]
for ( i = *(_DWORD **)a1; (unsigned long long)i < *(_QWORD *)(a1 + 8); ++i )
{
if ( *i != -1 )
return 0;
}
return (*(_DWORD *)(a1 + 24) | *i) == -1;
}
|
bitmap_is_set_all:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_001b4e9f:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x001b4ec8
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],-0x1
JZ 0x001b4eb8
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001b4ee3
LAB_001b4eb8:
JMP 0x001b4eba
LAB_001b4eba:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x4
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001b4e9f
LAB_001b4ec8:
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
OR EAX,dword ptr [RCX + 0x18]
CMP EAX,-0x1
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
LAB_001b4ee3:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int8 bitmap_is_set_all(int8 *param_1)
{
uint *local_20;
bool local_9;
local_20 = (uint *)*param_1;
do {
if ((uint *)param_1[1] <= local_20) {
local_9 = (*local_20 | *(uint *)(param_1 + 3)) == 0xffffffff;
local_20 = (uint *)0x0;
LAB_001b4ee3:
return CONCAT71((int7)((ulong)local_20 >> 8),local_9);
}
if (*local_20 != 0xffffffff) {
local_9 = false;
goto LAB_001b4ee3;
}
local_20 = local_20 + 1;
} while( true );
}
|
|
17,231
|
resize_simple_key_cache
|
eloqsql/mysys/mf_keycache.c
|
static
int resize_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache,
uint key_cache_block_size,
size_t use_mem, uint division_limit,
uint age_threshold, uint changed_blocks_hash_size)
{
int blocks= 0;
DBUG_ENTER("resize_simple_key_cache");
DBUG_ASSERT(keycache->key_cache_inited);
/*
Note that the cache_lock mutex and the resize_queue are left untouched.
We do not lose the cache_lock and will release it only at the end of
this function.
*/
if (prepare_resize_simple_key_cache(keycache, 0))
goto finish;
/* The following will work even if use_mem is 0 */
blocks= init_simple_key_cache(keycache, key_cache_block_size, use_mem,
division_limit, age_threshold,
changed_blocks_hash_size);
finish:
finish_resize_simple_key_cache(keycache);
DBUG_RETURN(blocks);
}
|
O3
|
c
|
resize_simple_key_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, -0x30(%rbp)
movl %r8d, -0x2c(%rbp)
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x57ba6
testl %eax, %eax
jne 0x5708c
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %r12d, %ecx
movl -0x2c(%rbp), %r8d
movl -0x30(%rbp), %r9d
callq 0x56b91
movl %eax, %r13d
movq %rbx, %rdi
callq 0x57d8a
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
resize_simple_key_cache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rbp+var_30], r9d
mov [rbp+var_2C], r8d
mov r12d, ecx
mov r14, rdx
mov r15d, esi
mov rbx, rdi
xor r13d, r13d
xor esi, esi
call prepare_resize_simple_key_cache
test eax, eax
jnz short loc_5708C
mov rdi, rbx
mov esi, r15d
mov rdx, r14
mov ecx, r12d
mov r8d, [rbp+var_2C]
mov r9d, [rbp+var_30]
call init_simple_key_cache
mov r13d, eax
loc_5708C:
mov rdi, rbx
call finish_resize_simple_key_cache
mov eax, r13d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long resize_simple_key_cache(
char *a1,
unsigned int a2,
unsigned long long a3,
unsigned int a4,
unsigned int a5,
unsigned int a6)
{
unsigned int inited; // r13d
inited = 0;
if ( !(unsigned int)prepare_resize_simple_key_cache(a1, 0LL) )
inited = init_simple_key_cache(a1, a2, a3, a4, a5, a6);
finish_resize_simple_key_cache(a1);
return inited;
}
|
resize_simple_key_cache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV dword ptr [RBP + -0x30],R9D
MOV dword ptr [RBP + -0x2c],R8D
MOV R12D,ECX
MOV R14,RDX
MOV R15D,ESI
MOV RBX,RDI
XOR R13D,R13D
XOR ESI,ESI
CALL 0x00157ba6
TEST EAX,EAX
JNZ 0x0015708c
MOV RDI,RBX
MOV ESI,R15D
MOV RDX,R14
MOV ECX,R12D
MOV R8D,dword ptr [RBP + -0x2c]
MOV R9D,dword ptr [RBP + -0x30]
CALL 0x00156b91
MOV R13D,EAX
LAB_0015708c:
MOV RDI,RBX
CALL 0x00157d8a
MOV EAX,R13D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4
resize_simple_key_cache
(int8 param_1,int4 param_2,int8 param_3,int4 param_4,
int4 param_5,int4 param_6)
{
int iVar1;
int4 uVar2;
uVar2 = 0;
iVar1 = prepare_resize_simple_key_cache(param_1,0);
if (iVar1 == 0) {
uVar2 = init_simple_key_cache(param_1,param_2,param_3,param_4,param_5,param_6);
}
finish_resize_simple_key_cache(param_1);
return uVar2;
}
|
|
17,232
|
stbi__jpeg_decode_block(stbi__jpeg*, short*, stbi__huffman*, stbi__huffman*, short*, int, unsigned short*)
|
llama.cpp/examples/llava/../../common/stb_image.h
|
static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)
{
int diff,dc,k;
int t;
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
t = stbi__jpeg_huff_decode(j, hdc);
if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG");
// 0 all the ac values now so we can do it 32-bits at a time
memset(data,0,64*sizeof(data[0]));
diff = t ? stbi__extend_receive(j, t) : 0;
if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG");
dc = j->img_comp[b].dc_pred + diff;
j->img_comp[b].dc_pred = dc;
if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
data[0] = (short) (dc * dequant[0]);
// decode AC components, see JPEG spec
k = 1;
do {
unsigned int zig;
int c,r,s;
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
r = fac[c];
if (r) { // fast-AC path
k += (r >> 4) & 15; // run
s = r & 15; // combined length
if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
j->code_buffer <<= s;
j->code_bits -= s;
// decode into unzigzag'd location
zig = stbi__jpeg_dezigzag[k++];
data[zig] = (short) ((r >> 8) * dequant[zig]);
} else {
int rs = stbi__jpeg_huff_decode(j, hac);
if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
s = rs & 15;
r = rs >> 4;
if (s == 0) {
if (rs != 0xf0) break; // end block
k += 16;
} else {
k += r;
// decode into unzigzag'd location
zig = stbi__jpeg_dezigzag[k++];
data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
}
}
} while (k < 64);
return 1;
}
|
O3
|
c
|
stbi__jpeg_decode_block(stbi__jpeg*, short*, stbi__huffman*, stbi__huffman*, short*, int, unsigned short*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
cmpl $0xf, 0x4824(%rdi)
jg 0x34b78
movq %rbx, %rdi
callq 0x35012
cmpl $0xf, 0x4824(%rbx)
jg 0x34b78
movq %rbx, %rdi
callq 0x35012
movl 0x4820(%rbx), %esi
movl %esi, %eax
shrl $0x17, %eax
movzbl (%r13,%rax), %eax
cmpq $0xff, %rax
je 0x34c8e
movzbl 0x500(%r13,%rax), %ecx
movl 0x4824(%rbx), %edx
subl %ecx, %edx
jl 0x34cba
movl %ebp, %r9d
shll %cl, %esi
movl %esi, 0x4820(%rbx)
movl %edx, 0x4824(%rbx)
addq %r13, %rax
addq $0x400, %rax # imm = 0x400
movzbl (%rax), %r13d
leaq 0x1abaf(%rip), %rbp # 0x4f780
cmpl $0xf, %r13d
ja 0x34cc1
movq %r14, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r12)
movups %xmm0, 0x60(%r12)
movups %xmm0, 0x50(%r12)
movups %xmm0, 0x40(%r12)
movups %xmm0, 0x30(%r12)
movups %xmm0, 0x20(%r12)
movups %xmm0, 0x10(%r12)
movups %xmm0, (%r12)
xorl %r14d, %r14d
testl %r13d, %r13d
je 0x34d3c
movl 0x4824(%rbx), %eax
cmpl %r13d, %eax
movl %r9d, %ebp
jge 0x34c39
movq %rbx, %rdi
callq 0x35012
movl 0x4824(%rbx), %eax
subl %r13d, %eax
jl 0x34d3f
movl 0x4820(%rbx), %esi
movl %esi, %edx
movl %r13d, %ecx
roll %cl, %edx
shll $0x2, %r13d
leaq 0x19de6(%rip), %rcx # 0x4ea40
movl (%r13,%rcx), %ecx
movl %ecx, %edi
notl %edi
andl %edx, %edi
movl %edi, 0x4820(%rbx)
andl %ecx, %edx
movl %eax, 0x4824(%rbx)
xorl %r14d, %r14d
testl %esi, %esi
js 0x34c86
leaq 0x19e0f(%rip), %rax # 0x4ea90
movl (%r13,%rax), %r14d
addl %edx, %r14d
jmp 0x34d3f
movl %esi, %eax
shrl $0x10, %eax
xorl %edi, %edi
movq %rdi, %rcx
incq %rdi
cmpl 0x62c(%r13,%rcx,4), %eax
jae 0x34c95
movl 0x4824(%rbx), %edx
cmpq $0x8, %rdi
jne 0x34ce5
addl $-0x10, %edx
movl %edx, 0x4824(%rbx)
leaq 0x1aabf(%rip), %rbp # 0x4f780
leaq 0x29078(%rip), %rdi # 0x5dd40
callq 0x1e400
movq %rbp, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %r9d
leaq 0x9(%rdi), %rax
leaq 0x1aa8d(%rip), %rbp # 0x4f780
cmpl %eax, %edx
jl 0x34cc1
movb $0x17, %cl
subb %dil, %cl
movl %esi, %r8d
shrl %cl, %r8d
leaq 0x19d37(%rip), %rcx # 0x4ea40
andl 0x24(%rcx,%rdi,4), %r8d
addl 0x670(%r13,%rdi,4), %r8d
cmpl $0xff, %r8d
ja 0x34cc1
subl %edi, %edx
addl $-0x9, %edx
movl %eax, %ecx
shll %cl, %esi
movl %edx, 0x4824(%rbx)
movl %esi, 0x4820(%rbx)
movl %r8d, %eax
jmp 0x34bbd
movl %r9d, %ebp
movslq %ebp, %rax
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
movl 0x46b8(%rbx,%rax), %ecx
movl %ecx, %edx
xorl %r14d, %edx
js 0x34d90
movl $0x80000000, %edx # imm = 0x80000000
subl %r14d, %edx
xorl %esi, %esi
cmpl %ecx, %edx
setg %sil
movl %r14d, %edx
xorl $0x7fffffff, %edx # imm = 0x7FFFFFFF
xorl %edi, %edi
cmpl %ecx, %edx
setl %dil
testl %r14d, %ecx
cmovsl %esi, %edi
testb %dil, %dil
je 0x34d90
leaq 0x1aa06(%rip), %rbp # 0x4f791
jmp 0x34cc1
movq 0x40(%rsp), %r13
addq %rbx, %rax
addq $0x46b8, %rax # imm = 0x46B8
addl %r14d, %ecx
movl %ecx, (%rax)
movzwl (%r13), %esi
testw %si, %si
movq (%rsp), %r14
je 0x34de3
testl %ecx, %ecx
js 0x34dd1
movw $0x7fff, %ax # imm = 0x7FFF
xorl %edx, %edx
divw %si
movzwl %ax, %eax
cmpl %eax, %ecx
jbe 0x34de3
leaq 0x1a9cf(%rip), %rbp # 0x4f79b
jmp 0x34cc1
movw $0x8000, %ax # imm = 0x8000
xorl %edx, %edx
divw %si
movzwl %ax, %eax
negl %eax
cmpl %eax, %ecx
jl 0x34dc5
imull %ecx, %esi
movw %si, (%r12)
movl 0x4824(%rbx), %edx
movl $0x1, %ebp
cmpl $0xf, %edx
jg 0x34e03
movq %rbx, %rdi
callq 0x35012
movl 0x4820(%rbx), %esi
movl %esi, %ecx
shrl $0x17, %ecx
movzwl (%r14,%rcx,2), %eax
testl %eax, %eax
je 0x34e6d
movl %eax, %ecx
andl $0xf, %ecx
movl 0x4824(%rbx), %edx
subl %ecx, %edx
jl 0x34cba
movswl %ax, %edi
shrl $0x4, %eax
andl $0xf, %eax
movslq %ebp, %r8
addq %rax, %r8
shll %cl, %esi
movl %esi, 0x4820(%rbx)
movl %edx, 0x4824(%rbx)
leal 0x1(%r8), %ebp
leaq 0x19b8e(%rip), %rax # 0x4e9e0
movzbl (%rax,%r8), %eax
shrl $0x8, %edi
addl %eax, %eax
imulw (%r13,%rax), %di
movw %di, (%r12,%rax)
jmp 0x34fff
cmpl $0xf, 0x4824(%rbx)
jg 0x34e89
movq %rbx, %rdi
callq 0x35012
movl 0x4820(%rbx), %esi
movl %esi, %ecx
shrl $0x17, %ecx
movzbl (%r15,%rcx), %eax
cmpq $0xff, %rax
je 0x34ec0
movzbl 0x500(%r15,%rax), %ecx
movl 0x4824(%rbx), %edx
subl %ecx, %edx
jl 0x34cba
shll %cl, %esi
movl %esi, 0x4820(%rbx)
movl %edx, 0x4824(%rbx)
jmp 0x34f42
movl %esi, %eax
shrl $0x10, %eax
xorl %edi, %edi
movq %rdi, %rcx
incq %rdi
cmpl 0x62c(%r15,%rcx,4), %eax
jae 0x34ec7
movl 0x4824(%rbx), %edx
cmpq $0x8, %rdi
je 0x34cb1
leaq 0x9(%rdi), %rax
cmpl %eax, %edx
jl 0x34cba
movb $0x17, %cl
subb %dil, %cl
movl %esi, %r8d
shrl %cl, %r8d
leaq 0x19b3b(%rip), %rcx # 0x4ea40
andl 0x24(%rcx,%rdi,4), %r8d
addl 0x670(%r15,%rdi,4), %r8d
cmpl $0xff, %r8d
ja 0x34cba
movl %edx, %r9d
subl %edi, %r9d
addl $-0x9, %r9d
subl %edi, %edx
movl %eax, %ecx
shll %cl, %esi
addl $-0x9, %edx
movl %r9d, 0x4824(%rbx)
movl %esi, 0x4820(%rbx)
movl %r8d, %eax
movzbl 0x400(%r15,%rax), %eax
movl %eax, %r13d
andl $0xf, %r13d
je 0x34ff0
shrl $0x4, %eax
movslq %ebp, %rbp
addq %rax, %rbp
leaq 0x19a78(%rip), %rax # 0x4e9e0
movzbl (%rax,%rbp), %r14d
cmpl %r13d, %edx
jge 0x34f80
movq %rbx, %rdi
callq 0x35012
movl 0x4824(%rbx), %edx
xorl %eax, %eax
movl %edx, %esi
subl %r13d, %esi
jl 0x34fd4
movl 0x4820(%rbx), %edx
movl %edx, %edi
movl %r13d, %ecx
roll %cl, %edi
shll $0x2, %r13d
leaq 0x19a9f(%rip), %rcx # 0x4ea40
movl (%r13,%rcx), %ecx
movl %ecx, %r8d
notl %r8d
andl %edi, %r8d
movl %r8d, 0x4820(%rbx)
movl %esi, 0x4824(%rbx)
testl %edx, %edx
js 0x34fcc
leaq 0x19ac9(%rip), %rax # 0x4ea90
movl (%r13,%rax), %eax
andl %ecx, %edi
addl %eax, %edi
movl %esi, %edx
movl %edi, %eax
incl %ebp
addl %r14d, %r14d
movq 0x40(%rsp), %r13
imulw (%r13,%r14), %ax
movw %ax, (%r12,%r14)
movq (%rsp), %r14
jmp 0x34fff
cmpl $0xf0, %eax
jne 0x35008
addl $0x10, %ebp
movq 0x40(%rsp), %r13
cmpl $0x40, %ebp
jl 0x34df6
movl $0x1, %eax
jmp 0x34cd6
|
_ZL23stbi__jpeg_decode_blockP10stbi__jpegPsP13stbi__huffmanS3_S1_iPt:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, r9d
mov r14, r8
mov r15, rcx
mov r13, rdx
mov r12, rsi
mov rbx, rdi
cmp dword ptr [rdi+4824h], 0Fh
jg short loc_34B78
mov rdi, rbx
call _ZL24stbi__grow_buffer_unsafeP10stbi__jpeg; stbi__grow_buffer_unsafe(stbi__jpeg *)
cmp dword ptr [rbx+4824h], 0Fh
jg short loc_34B78
mov rdi, rbx
call _ZL24stbi__grow_buffer_unsafeP10stbi__jpeg; stbi__grow_buffer_unsafe(stbi__jpeg *)
loc_34B78:
mov esi, [rbx+4820h]
mov eax, esi
shr eax, 17h
movzx eax, byte ptr [r13+rax+0]
cmp rax, 0FFh
jz loc_34C8E
movzx ecx, byte ptr [r13+rax+500h]
mov edx, [rbx+4824h]
sub edx, ecx
jl loc_34CBA
mov r9d, ebp
shl esi, cl
mov [rbx+4820h], esi
mov [rbx+4824h], edx
loc_34BBD:
add rax, r13
add rax, 400h
movzx r13d, byte ptr [rax]
lea rbp, aBadHuffmanCode; "bad huffman code"
cmp r13d, 0Fh
ja loc_34CC1
mov [rsp+38h+var_38], r14
xorps xmm0, xmm0
movups xmmword ptr [r12+70h], xmm0
movups xmmword ptr [r12+60h], xmm0
movups xmmword ptr [r12+50h], xmm0
movups xmmword ptr [r12+40h], xmm0
movups xmmword ptr [r12+30h], xmm0
movups xmmword ptr [r12+20h], xmm0
movups xmmword ptr [r12+10h], xmm0
movups xmmword ptr [r12], xmm0
xor r14d, r14d
test r13d, r13d
jz loc_34D3C
mov eax, [rbx+4824h]
cmp eax, r13d
mov ebp, r9d
jge short loc_34C39
mov rdi, rbx
call _ZL24stbi__grow_buffer_unsafeP10stbi__jpeg; stbi__grow_buffer_unsafe(stbi__jpeg *)
mov eax, [rbx+4824h]
loc_34C39:
sub eax, r13d
jl loc_34D3F
mov esi, [rbx+4820h]
mov edx, esi
mov ecx, r13d
rol edx, cl
shl r13d, 2
lea rcx, _ZL11stbi__bmask; stbi__bmask
mov ecx, [r13+rcx+0]
mov edi, ecx
not edi
and edi, edx
mov [rbx+4820h], edi
and edx, ecx
mov [rbx+4824h], eax
xor r14d, r14d
test esi, esi
js short loc_34C86
lea rax, _ZL11stbi__jbias; stbi__jbias
mov r14d, [r13+rax+0]
loc_34C86:
add r14d, edx
jmp loc_34D3F
loc_34C8E:
mov eax, esi
shr eax, 10h
xor edi, edi
loc_34C95:
mov rcx, rdi
inc rdi
cmp eax, [r13+rcx*4+62Ch]
jnb short loc_34C95
mov edx, [rbx+4824h]
cmp rdi, 8
jnz short loc_34CE5
loc_34CB1:
add edx, 0FFFFFFF0h
mov [rbx+4824h], edx
loc_34CBA:
lea rbp, aBadHuffmanCode; "bad huffman code"
loc_34CC1:
lea rdi, _ZL22stbi__g_failure_reason_tlsind
call ___tls_get_addr
mov [rax+0], rbp
xor eax, eax
loc_34CD6:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_34CE5:
mov r9d, ebp
lea rax, [rdi+9]
lea rbp, aBadHuffmanCode; "bad huffman code"
cmp edx, eax
jl short loc_34CC1
mov cl, 17h
sub cl, dil
mov r8d, esi
shr r8d, cl
lea rcx, _ZL11stbi__bmask; stbi__bmask
and r8d, [rcx+rdi*4+24h]
add r8d, [r13+rdi*4+670h]
cmp r8d, 0FFh
ja short loc_34CC1
sub edx, edi
add edx, 0FFFFFFF7h
mov ecx, eax
shl esi, cl
mov [rbx+4824h], edx
mov [rbx+4820h], esi
mov eax, r8d
jmp loc_34BBD
loc_34D3C:
mov ebp, r9d
loc_34D3F:
movsxd rax, ebp
lea rax, [rax+rax*2]
shl rax, 5
mov ecx, [rbx+rax+46B8h]
mov edx, ecx
xor edx, r14d
js short loc_34D90
mov edx, 80000000h
sub edx, r14d
xor esi, esi
cmp edx, ecx
setnle sil
mov edx, r14d
xor edx, 7FFFFFFFh
xor edi, edi
cmp edx, ecx
setl dil
test ecx, r14d
cmovs edi, esi
test dil, dil
jz short loc_34D90
lea rbp, aBadDelta; "bad delta"
jmp loc_34CC1
loc_34D90:
mov r13, [rsp+38h+arg_0]
add rax, rbx
add rax, 46B8h
add ecx, r14d
mov [rax], ecx
movzx esi, word ptr [r13+0]
test si, si
mov r14, [rsp+38h+var_38]
jz short loc_34DE3
test ecx, ecx
js short loc_34DD1
mov ax, 7FFFh
xor edx, edx
div si
movzx eax, ax
cmp ecx, eax
jbe short loc_34DE3
loc_34DC5:
lea rbp, aCanTMergeDcAnd; "can't merge dc and ac"
jmp loc_34CC1
loc_34DD1:
mov ax, 8000h
xor edx, edx
div si
movzx eax, ax
neg eax
cmp ecx, eax
jl short loc_34DC5
loc_34DE3:
imul esi, ecx
mov [r12], si
mov edx, [rbx+4824h]
mov ebp, 1
loc_34DF6:
cmp edx, 0Fh
jg short loc_34E03
mov rdi, rbx
call _ZL24stbi__grow_buffer_unsafeP10stbi__jpeg; stbi__grow_buffer_unsafe(stbi__jpeg *)
loc_34E03:
mov esi, [rbx+4820h]
mov ecx, esi
shr ecx, 17h
movzx eax, word ptr [r14+rcx*2]
test eax, eax
jz short loc_34E6D
mov ecx, eax
and ecx, 0Fh
mov edx, [rbx+4824h]
sub edx, ecx
jl loc_34CBA
movsx edi, ax
shr eax, 4
and eax, 0Fh
movsxd r8, ebp
add r8, rax
shl esi, cl
mov [rbx+4820h], esi
mov [rbx+4824h], edx
lea ebp, [r8+1]
lea rax, _ZL19stbi__jpeg_dezigzag; stbi__jpeg_dezigzag
movzx eax, byte ptr [rax+r8]
shr edi, 8
add eax, eax
imul di, [r13+rax+0]
mov [r12+rax], di
jmp loc_34FFF
loc_34E6D:
cmp dword ptr [rbx+4824h], 0Fh
jg short loc_34E89
mov rdi, rbx
call _ZL24stbi__grow_buffer_unsafeP10stbi__jpeg; stbi__grow_buffer_unsafe(stbi__jpeg *)
mov esi, [rbx+4820h]
mov ecx, esi
shr ecx, 17h
loc_34E89:
movzx eax, byte ptr [r15+rcx]
cmp rax, 0FFh
jz short loc_34EC0
movzx ecx, byte ptr [r15+rax+500h]
mov edx, [rbx+4824h]
sub edx, ecx
jl loc_34CBA
shl esi, cl
mov [rbx+4820h], esi
mov [rbx+4824h], edx
jmp loc_34F42
loc_34EC0:
mov eax, esi
shr eax, 10h
xor edi, edi
loc_34EC7:
mov rcx, rdi
inc rdi
cmp eax, [r15+rcx*4+62Ch]
jnb short loc_34EC7
mov edx, [rbx+4824h]
cmp rdi, 8
jz loc_34CB1
lea rax, [rdi+9]
cmp edx, eax
jl loc_34CBA
mov cl, 17h
sub cl, dil
mov r8d, esi
shr r8d, cl
lea rcx, _ZL11stbi__bmask; stbi__bmask
and r8d, [rcx+rdi*4+24h]
add r8d, [r15+rdi*4+670h]
cmp r8d, 0FFh
ja loc_34CBA
mov r9d, edx
sub r9d, edi
add r9d, 0FFFFFFF7h
sub edx, edi
mov ecx, eax
shl esi, cl
add edx, 0FFFFFFF7h
mov [rbx+4824h], r9d
mov [rbx+4820h], esi
mov eax, r8d
loc_34F42:
movzx eax, byte ptr [r15+rax+400h]
mov r13d, eax
and r13d, 0Fh
jz loc_34FF0
shr eax, 4
movsxd rbp, ebp
add rbp, rax
lea rax, _ZL19stbi__jpeg_dezigzag; stbi__jpeg_dezigzag
movzx r14d, byte ptr [rax+rbp]
cmp edx, r13d
jge short loc_34F80
mov rdi, rbx
call _ZL24stbi__grow_buffer_unsafeP10stbi__jpeg; stbi__grow_buffer_unsafe(stbi__jpeg *)
mov edx, [rbx+4824h]
loc_34F80:
xor eax, eax
mov esi, edx
sub esi, r13d
jl short loc_34FD4
mov edx, [rbx+4820h]
mov edi, edx
mov ecx, r13d
rol edi, cl
shl r13d, 2
lea rcx, _ZL11stbi__bmask; stbi__bmask
mov ecx, [r13+rcx+0]
mov r8d, ecx
not r8d
and r8d, edi
mov [rbx+4820h], r8d
mov [rbx+4824h], esi
test edx, edx
js short loc_34FCC
lea rax, _ZL11stbi__jbias; stbi__jbias
mov eax, [r13+rax+0]
loc_34FCC:
and edi, ecx
add edi, eax
mov edx, esi
mov eax, edi
loc_34FD4:
inc ebp
add r14d, r14d
mov r13, [rsp+38h+arg_0]
imul ax, [r13+r14+0]
mov [r12+r14], ax
mov r14, [rsp+38h+var_38]
jmp short loc_34FFF
loc_34FF0:
cmp eax, 0F0h
jnz short loc_35008
add ebp, 10h
mov r13, [rsp+38h+arg_0]
loc_34FFF:
cmp ebp, 40h ; '@'
jl loc_34DF6
loc_35008:
mov eax, 1
jmp loc_34CD6
|
long long stbi__jpeg_decode_block(
long long a1,
_OWORD *a2,
long long a3,
long long a4,
long long a5,
int a6,
_WORD *a7)
{
unsigned int v13; // esi
long long v14; // rax
int v15; // ecx
int v16; // edx
bool v17; // cc
int v18; // edx
int v19; // r9d
signed int v20; // r13d
const char *v21; // rbp
int v22; // r14d
signed int v23; // eax
int v24; // ebp
int v25; // eax
int v26; // esi
int v27; // edx
long long v28; // r13
int v29; // ecx
int v30; // edx
int v31; // r14d
long long v32; // rdi
long long v33; // rcx
int v34; // edx
unsigned int v36; // r8d
long long v37; // rax
int v38; // ecx
bool v39; // di
_WORD *v40; // r13
signed int v41; // ecx
unsigned __int16 v42; // si
long long v43; // r14
int v44; // edx
int v45; // ebp
unsigned int v46; // esi
long long v47; // rcx
__int16 v48; // ax
int v49; // ecx
int v50; // edx
long long v51; // r8
unsigned int v52; // edi
long long v53; // rax
long long v54; // rax
int v55; // ecx
int v56; // edx
long long v57; // rdi
long long v58; // rcx
unsigned int v59; // r8d
unsigned int v60; // eax
int v61; // r13d
long long v62; // rbp
int v63; // r14d
int v64; // eax
int v65; // esi
int v66; // edx
int v67; // edi
long long v68; // r13
int v69; // ecx
long long v70; // [rsp+0h] [rbp-38h]
if ( *(int *)(a1 + 18468) <= 15 )
{
stbi__grow_buffer_unsafe(a1);
if ( *(int *)(a1 + 18468) <= 15 )
stbi__grow_buffer_unsafe(a1);
}
v13 = *(_DWORD *)(a1 + 18464);
v14 = *(unsigned __int8 *)(a3 + (v13 >> 23));
if ( v14 != 255 )
{
v15 = *(unsigned __int8 *)(a3 + v14 + 1280);
v16 = *(_DWORD *)(a1 + 18468);
v17 = v16 < v15;
v18 = v16 - v15;
if ( !v17 )
{
v19 = a6;
*(_DWORD *)(a1 + 18464) = v13 << v15;
*(_DWORD *)(a1 + 18468) = v18;
goto LABEL_7;
}
LABEL_19:
v21 = "bad huffman code";
goto LABEL_20;
}
v32 = 0LL;
do
v33 = v32++;
while ( HIWORD(v13) >= *(_DWORD *)(a3 + 4 * v33 + 1580) );
v34 = *(_DWORD *)(a1 + 18468);
if ( v32 == 8 )
{
LABEL_18:
*(_DWORD *)(a1 + 18468) = v34 - 16;
goto LABEL_19;
}
v19 = a6;
v21 = "bad huffman code";
if ( v34 < (int)v32 + 9 )
goto LABEL_20;
v36 = *(_DWORD *)(a3 + 4 * v32 + 1648) + (stbi__bmask[v32 + 9] & (v13 >> (23 - v32)));
if ( v36 > 0xFF )
goto LABEL_20;
*(_DWORD *)(a1 + 18468) = v34 - v32 - 9;
*(_DWORD *)(a1 + 18464) = v13 << (v32 + 9);
v14 = v36;
LABEL_7:
v20 = *(unsigned __int8 *)(a3 + v14 + 1024);
v21 = "bad huffman code";
if ( (unsigned int)v20 > 0xF )
{
LABEL_20:
*(_QWORD *)__tls_get_addr(&ZL22stbi__g_failure_reason_tlsind) = v21;
return 0LL;
}
v70 = a5;
a2[7] = 0LL;
a2[6] = 0LL;
a2[5] = 0LL;
a2[4] = 0LL;
a2[3] = 0LL;
a2[2] = 0LL;
a2[1] = 0LL;
*a2 = 0LL;
v22 = 0;
if ( v20 )
{
v23 = *(_DWORD *)(a1 + 18468);
v24 = v19;
if ( v23 < v20 )
{
stbi__grow_buffer_unsafe(a1);
v23 = *(_DWORD *)(a1 + 18468);
}
v17 = v23 < v20;
v25 = v23 - v20;
if ( !v17 )
{
v26 = *(_DWORD *)(a1 + 18464);
v27 = __ROL4__(v26, v20);
v28 = (unsigned int)(4 * v20);
v29 = *(_DWORD *)((char *)stbi__bmask + v28);
*(_DWORD *)(a1 + 18464) = v27 & ~v29;
v30 = v29 & v27;
*(_DWORD *)(a1 + 18468) = v25;
v31 = 0;
if ( v26 >= 0 )
v31 = *(_DWORD *)((char *)&stbi__jbias + v28);
v22 = v30 + v31;
}
}
else
{
v24 = v19;
}
v37 = 96LL * v24;
v38 = *(_DWORD *)(a1 + v37 + 18104);
if ( (v22 ^ v38) >= 0 )
{
v39 = (v22 ^ 0x7FFFFFFF) < v38;
if ( (v22 & v38) < 0 )
v39 = (int)(0x80000000 - v22) > v38;
if ( v39 )
{
v21 = "bad delta";
goto LABEL_20;
}
}
v40 = a7;
v41 = v22 + v38;
*(_DWORD *)(a1 + v37 + 18104) = v41;
v42 = *a7;
v43 = v70;
if ( *a7 )
{
if ( v41 < 0 )
{
if ( v41 < -(unsigned __int16)(0x8000u / v42) )
goto LABEL_34;
}
else if ( v41 > 0x7FFFu / v42 )
{
LABEL_34:
v21 = "can't merge dc and ac";
goto LABEL_20;
}
}
*(_WORD *)a2 = v41 * v42;
v44 = *(_DWORD *)(a1 + 18468);
v45 = 1;
do
{
if ( v44 <= 15 )
stbi__grow_buffer_unsafe(a1);
v46 = *(_DWORD *)(a1 + 18464);
v47 = v46 >> 23;
v48 = *(_WORD *)(v43 + 2 * v47);
if ( v48 )
{
v49 = v48 & 0xF;
v50 = *(_DWORD *)(a1 + 18468);
v17 = v50 < v49;
v44 = v50 - v49;
if ( v17 )
goto LABEL_19;
v51 = ((unsigned __int8)v48 >> 4) + (long long)v45;
*(_DWORD *)(a1 + 18464) = v46 << v49;
*(_DWORD *)(a1 + 18468) = v44;
v45 = v51 + 1;
v52 = (unsigned int)v48 >> 8;
v53 = stbi__jpeg_dezigzag[v51];
*(_WORD *)((char *)a2 + v53 * 2) = v40[v53] * v52;
}
else
{
if ( *(int *)(a1 + 18468) <= 15 )
{
stbi__grow_buffer_unsafe(a1);
v46 = *(_DWORD *)(a1 + 18464);
v47 = v46 >> 23;
}
v54 = *(unsigned __int8 *)(a4 + v47);
if ( v54 == 255 )
{
v57 = 0LL;
do
v58 = v57++;
while ( HIWORD(v46) >= *(_DWORD *)(a4 + 4 * v58 + 1580) );
v34 = *(_DWORD *)(a1 + 18468);
if ( v57 == 8 )
goto LABEL_18;
if ( v34 < (int)v57 + 9 )
goto LABEL_19;
v59 = *(_DWORD *)(a4 + 4 * v57 + 1648) + (stbi__bmask[v57 + 9] & (v46 >> (23 - v57)));
if ( v59 > 0xFF )
goto LABEL_19;
v44 = v34 - v57 - 9;
*(_DWORD *)(a1 + 18468) = v44;
*(_DWORD *)(a1 + 18464) = v46 << (v57 + 9);
v54 = v59;
}
else
{
v55 = *(unsigned __int8 *)(a4 + v54 + 1280);
v56 = *(_DWORD *)(a1 + 18468);
v17 = v56 < v55;
v44 = v56 - v55;
if ( v17 )
goto LABEL_19;
*(_DWORD *)(a1 + 18464) = v46 << v55;
*(_DWORD *)(a1 + 18468) = v44;
}
v60 = *(unsigned __int8 *)(a4 + v54 + 1024);
v61 = v60 & 0xF;
if ( (v60 & 0xF) != 0 )
{
v62 = (v60 >> 4) + (long long)v45;
v63 = stbi__jpeg_dezigzag[v62];
if ( v44 < v61 )
{
stbi__grow_buffer_unsafe(a1);
v44 = *(_DWORD *)(a1 + 18468);
}
LOWORD(v64) = 0;
v65 = v44 - v61;
if ( v44 >= v61 )
{
v66 = *(_DWORD *)(a1 + 18464);
v67 = __ROL4__(v66, v61);
v68 = (unsigned int)(4 * v61);
v69 = *(_DWORD *)((char *)stbi__bmask + v68);
*(_DWORD *)(a1 + 18464) = v67 & ~v69;
*(_DWORD *)(a1 + 18468) = v65;
if ( v66 >= 0 )
v64 = *(_DWORD *)((char *)&stbi__jbias + v68);
v44 = v65;
LOWORD(v64) = v64 + (v69 & v67);
}
v45 = v62 + 1;
v40 = a7;
*(_WORD *)((char *)a2 + (unsigned int)(2 * v63)) = *(_WORD *)((char *)a7 + (unsigned int)(2 * v63)) * v64;
v43 = v70;
}
else
{
if ( v60 != 240 )
return 1LL;
v45 += 16;
v40 = a7;
}
}
}
while ( v45 < 64 );
return 1LL;
}
|
stbi__jpeg_decode_block:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,R9D
MOV R14,R8
MOV R15,RCX
MOV R13,RDX
MOV R12,RSI
MOV RBX,RDI
CMP dword ptr [RDI + 0x4824],0xf
JG 0x00134b78
MOV RDI,RBX
CALL 0x00135012
CMP dword ptr [RBX + 0x4824],0xf
JG 0x00134b78
MOV RDI,RBX
CALL 0x00135012
LAB_00134b78:
MOV ESI,dword ptr [RBX + 0x4820]
MOV EAX,ESI
SHR EAX,0x17
MOVZX EAX,byte ptr [R13 + RAX*0x1]
CMP RAX,0xff
JZ 0x00134c8e
MOVZX ECX,byte ptr [R13 + RAX*0x1 + 0x500]
MOV EDX,dword ptr [RBX + 0x4824]
SUB EDX,ECX
JL 0x00134cba
MOV R9D,EBP
SHL ESI,CL
MOV dword ptr [RBX + 0x4820],ESI
MOV dword ptr [RBX + 0x4824],EDX
LAB_00134bbd:
ADD RAX,R13
ADD RAX,0x400
MOVZX R13D,byte ptr [RAX]
LEA RBP,[0x14f780]
CMP R13D,0xf
JA 0x00134cc1
MOV qword ptr [RSP],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R12 + 0x70],XMM0
MOVUPS xmmword ptr [R12 + 0x60],XMM0
MOVUPS xmmword ptr [R12 + 0x50],XMM0
MOVUPS xmmword ptr [R12 + 0x40],XMM0
MOVUPS xmmword ptr [R12 + 0x30],XMM0
MOVUPS xmmword ptr [R12 + 0x20],XMM0
MOVUPS xmmword ptr [R12 + 0x10],XMM0
MOVUPS xmmword ptr [R12],XMM0
XOR R14D,R14D
TEST R13D,R13D
JZ 0x00134d3c
MOV EAX,dword ptr [RBX + 0x4824]
CMP EAX,R13D
MOV EBP,R9D
JGE 0x00134c39
MOV RDI,RBX
CALL 0x00135012
MOV EAX,dword ptr [RBX + 0x4824]
LAB_00134c39:
SUB EAX,R13D
JL 0x00134d3f
MOV ESI,dword ptr [RBX + 0x4820]
MOV EDX,ESI
MOV ECX,R13D
ROL EDX,CL
SHL R13D,0x2
LEA RCX,[0x14ea40]
MOV ECX,dword ptr [R13 + RCX*0x1]
MOV EDI,ECX
NOT EDI
AND EDI,EDX
MOV dword ptr [RBX + 0x4820],EDI
AND EDX,ECX
MOV dword ptr [RBX + 0x4824],EAX
XOR R14D,R14D
TEST ESI,ESI
JS 0x00134c86
LEA RAX,[0x14ea90]
MOV R14D,dword ptr [R13 + RAX*0x1]
LAB_00134c86:
ADD R14D,EDX
JMP 0x00134d3f
LAB_00134c8e:
MOV EAX,ESI
SHR EAX,0x10
XOR EDI,EDI
LAB_00134c95:
MOV RCX,RDI
INC RDI
CMP EAX,dword ptr [R13 + RCX*0x4 + 0x62c]
JNC 0x00134c95
MOV EDX,dword ptr [RBX + 0x4824]
CMP RDI,0x8
JNZ 0x00134ce5
LAB_00134cb1:
ADD EDX,-0x10
MOV dword ptr [RBX + 0x4824],EDX
LAB_00134cba:
LEA RBP,[0x14f780]
LAB_00134cc1:
LEA RDI,[0x15dd40]
CALL 0x0011e400
MOV qword ptr [RAX],RBP
XOR EAX,EAX
LAB_00134cd6:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00134ce5:
MOV R9D,EBP
LEA RAX,[RDI + 0x9]
LEA RBP,[0x14f780]
CMP EDX,EAX
JL 0x00134cc1
MOV CL,0x17
SUB CL,DIL
MOV R8D,ESI
SHR R8D,CL
LEA RCX,[0x14ea40]
AND R8D,dword ptr [RCX + RDI*0x4 + 0x24]
ADD R8D,dword ptr [R13 + RDI*0x4 + 0x670]
CMP R8D,0xff
JA 0x00134cc1
SUB EDX,EDI
ADD EDX,-0x9
MOV ECX,EAX
SHL ESI,CL
MOV dword ptr [RBX + 0x4824],EDX
MOV dword ptr [RBX + 0x4820],ESI
MOV EAX,R8D
JMP 0x00134bbd
LAB_00134d3c:
MOV EBP,R9D
LAB_00134d3f:
MOVSXD RAX,EBP
LEA RAX,[RAX + RAX*0x2]
SHL RAX,0x5
MOV ECX,dword ptr [RBX + RAX*0x1 + 0x46b8]
MOV EDX,ECX
XOR EDX,R14D
JS 0x00134d90
MOV EDX,0x80000000
SUB EDX,R14D
XOR ESI,ESI
CMP EDX,ECX
SETG SIL
MOV EDX,R14D
XOR EDX,0x7fffffff
XOR EDI,EDI
CMP EDX,ECX
SETL DIL
TEST ECX,R14D
CMOVS EDI,ESI
TEST DIL,DIL
JZ 0x00134d90
LEA RBP,[0x14f791]
JMP 0x00134cc1
LAB_00134d90:
MOV R13,qword ptr [RSP + 0x40]
ADD RAX,RBX
ADD RAX,0x46b8
ADD ECX,R14D
MOV dword ptr [RAX],ECX
MOVZX ESI,word ptr [R13]
TEST SI,SI
MOV R14,qword ptr [RSP]
JZ 0x00134de3
TEST ECX,ECX
JS 0x00134dd1
MOV AX,0x7fff
XOR EDX,EDX
DIV SI
MOVZX EAX,AX
CMP ECX,EAX
JBE 0x00134de3
LAB_00134dc5:
LEA RBP,[0x14f79b]
JMP 0x00134cc1
LAB_00134dd1:
MOV AX,0x8000
XOR EDX,EDX
DIV SI
MOVZX EAX,AX
NEG EAX
CMP ECX,EAX
JL 0x00134dc5
LAB_00134de3:
IMUL ESI,ECX
MOV word ptr [R12],SI
MOV EDX,dword ptr [RBX + 0x4824]
MOV EBP,0x1
LAB_00134df6:
CMP EDX,0xf
JG 0x00134e03
MOV RDI,RBX
CALL 0x00135012
LAB_00134e03:
MOV ESI,dword ptr [RBX + 0x4820]
MOV ECX,ESI
SHR ECX,0x17
MOVZX EAX,word ptr [R14 + RCX*0x2]
TEST EAX,EAX
JZ 0x00134e6d
MOV ECX,EAX
AND ECX,0xf
MOV EDX,dword ptr [RBX + 0x4824]
SUB EDX,ECX
JL 0x00134cba
MOVSX EDI,AX
SHR EAX,0x4
AND EAX,0xf
MOVSXD R8,EBP
ADD R8,RAX
SHL ESI,CL
MOV dword ptr [RBX + 0x4820],ESI
MOV dword ptr [RBX + 0x4824],EDX
LEA EBP,[R8 + 0x1]
LEA RAX,[0x14e9e0]
MOVZX EAX,byte ptr [RAX + R8*0x1]
SHR EDI,0x8
ADD EAX,EAX
IMUL DI,word ptr [R13 + RAX*0x1]
MOV word ptr [R12 + RAX*0x1],DI
JMP 0x00134fff
LAB_00134e6d:
CMP dword ptr [RBX + 0x4824],0xf
JG 0x00134e89
MOV RDI,RBX
CALL 0x00135012
MOV ESI,dword ptr [RBX + 0x4820]
MOV ECX,ESI
SHR ECX,0x17
LAB_00134e89:
MOVZX EAX,byte ptr [R15 + RCX*0x1]
CMP RAX,0xff
JZ 0x00134ec0
MOVZX ECX,byte ptr [R15 + RAX*0x1 + 0x500]
MOV EDX,dword ptr [RBX + 0x4824]
SUB EDX,ECX
JL 0x00134cba
SHL ESI,CL
MOV dword ptr [RBX + 0x4820],ESI
MOV dword ptr [RBX + 0x4824],EDX
JMP 0x00134f42
LAB_00134ec0:
MOV EAX,ESI
SHR EAX,0x10
XOR EDI,EDI
LAB_00134ec7:
MOV RCX,RDI
INC RDI
CMP EAX,dword ptr [R15 + RCX*0x4 + 0x62c]
JNC 0x00134ec7
MOV EDX,dword ptr [RBX + 0x4824]
CMP RDI,0x8
JZ 0x00134cb1
LEA RAX,[RDI + 0x9]
CMP EDX,EAX
JL 0x00134cba
MOV CL,0x17
SUB CL,DIL
MOV R8D,ESI
SHR R8D,CL
LEA RCX,[0x14ea40]
AND R8D,dword ptr [RCX + RDI*0x4 + 0x24]
ADD R8D,dword ptr [R15 + RDI*0x4 + 0x670]
CMP R8D,0xff
JA 0x00134cba
MOV R9D,EDX
SUB R9D,EDI
ADD R9D,-0x9
SUB EDX,EDI
MOV ECX,EAX
SHL ESI,CL
ADD EDX,-0x9
MOV dword ptr [RBX + 0x4824],R9D
MOV dword ptr [RBX + 0x4820],ESI
MOV EAX,R8D
LAB_00134f42:
MOVZX EAX,byte ptr [R15 + RAX*0x1 + 0x400]
MOV R13D,EAX
AND R13D,0xf
JZ 0x00134ff0
SHR EAX,0x4
MOVSXD RBP,EBP
ADD RBP,RAX
LEA RAX,[0x14e9e0]
MOVZX R14D,byte ptr [RAX + RBP*0x1]
CMP EDX,R13D
JGE 0x00134f80
MOV RDI,RBX
CALL 0x00135012
MOV EDX,dword ptr [RBX + 0x4824]
LAB_00134f80:
XOR EAX,EAX
MOV ESI,EDX
SUB ESI,R13D
JL 0x00134fd4
MOV EDX,dword ptr [RBX + 0x4820]
MOV EDI,EDX
MOV ECX,R13D
ROL EDI,CL
SHL R13D,0x2
LEA RCX,[0x14ea40]
MOV ECX,dword ptr [R13 + RCX*0x1]
MOV R8D,ECX
NOT R8D
AND R8D,EDI
MOV dword ptr [RBX + 0x4820],R8D
MOV dword ptr [RBX + 0x4824],ESI
TEST EDX,EDX
JS 0x00134fcc
LEA RAX,[0x14ea90]
MOV EAX,dword ptr [R13 + RAX*0x1]
LAB_00134fcc:
AND EDI,ECX
ADD EDI,EAX
MOV EDX,ESI
MOV EAX,EDI
LAB_00134fd4:
INC EBP
ADD R14D,R14D
MOV R13,qword ptr [RSP + 0x40]
IMUL AX,word ptr [R13 + R14*0x1]
MOV word ptr [R12 + R14*0x1],AX
MOV R14,qword ptr [RSP]
JMP 0x00134fff
LAB_00134ff0:
CMP EAX,0xf0
JNZ 0x00135008
ADD EBP,0x10
MOV R13,qword ptr [RSP + 0x40]
LAB_00134fff:
CMP EBP,0x40
JL 0x00134df6
LAB_00135008:
MOV EAX,0x1
JMP 0x00134cd6
|
/* stbi__jpeg_decode_block(stbi__jpeg*, short*, stbi__huffman*, stbi__huffman*, short*, int,
unsigned short*) */
int8
stbi__jpeg_decode_block
(stbi__jpeg *param_1,short *param_2,stbi__huffman *param_3,stbi__huffman *param_4,
short *param_5,int param_6,ushort *param_7)
{
stbi__huffman sVar1;
byte bVar2;
ushort uVar3;
uint uVar4;
bool bVar5;
bool bVar6;
short sVar7;
ulong uVar8;
int8 *puVar9;
ushort uVar10;
uint uVar11;
uint uVar12;
int iVar13;
char *pcVar14;
uint uVar15;
ulong uVar16;
short sVar17;
uint uVar18;
long lVar19;
long lVar20;
int iVar21;
if ((*(int *)(param_1 + 0x4824) < 0x10) &&
(stbi__grow_buffer_unsafe(param_1), *(int *)(param_1 + 0x4824) < 0x10)) {
stbi__grow_buffer_unsafe(param_1);
}
uVar15 = *(uint *)(param_1 + 0x4820);
uVar16 = (ulong)uVar15;
uVar8 = (ulong)(byte)param_3[uVar15 >> 0x17];
if (uVar8 == 0xff) {
lVar20 = 0;
do {
lVar19 = lVar20;
lVar20 = lVar19 + 1;
} while (*(uint *)(param_3 + lVar19 * 4 + 0x62c) <= uVar15 >> 0x10);
uVar11 = *(uint *)(param_1 + 0x4824);
if (lVar20 != 8) {
pcVar14 = "bad huffman code";
if (((int)uVar11 < (int)(lVar19 + 10)) ||
(uVar12 = (uVar15 >> (0x17U - (char)lVar20 & 0x1f) &
*(uint *)(stbi__bmask + lVar20 * 4 + 0x24)) +
*(int *)(param_3 + lVar20 * 4 + 0x670), 0xff < uVar12)) goto LAB_00134cc1;
uVar11 = (uVar11 - (int)lVar20) - 9;
uVar15 = uVar15 << ((byte)(lVar19 + 10) & 0x1f);
*(uint *)(param_1 + 0x4824) = uVar11;
*(uint *)(param_1 + 0x4820) = uVar15;
uVar8 = (ulong)uVar12;
goto LAB_00134bbd;
}
LAB_00134cb1:
uVar11 = uVar11 - 0x10;
*(uint *)(param_1 + 0x4824) = uVar11;
}
else {
sVar1 = param_3[uVar8 + 0x500];
uVar11 = *(int *)(param_1 + 0x4824) - (uint)(byte)sVar1;
if ((int)(uint)(byte)sVar1 <= *(int *)(param_1 + 0x4824)) {
uVar15 = uVar15 << ((byte)sVar1 & 0x1f);
*(uint *)(param_1 + 0x4820) = uVar15;
*(uint *)(param_1 + 0x4824) = uVar11;
LAB_00134bbd:
uVar16 = (ulong)uVar15;
sVar1 = param_3[uVar8 + 0x400];
pcVar14 = "bad huffman code";
if ((byte)sVar1 < 0x10) {
param_2[0x38] = 0;
param_2[0x39] = 0;
param_2[0x3a] = 0;
param_2[0x3b] = 0;
param_2[0x3c] = 0;
param_2[0x3d] = 0;
param_2[0x3e] = 0;
param_2[0x3f] = 0;
param_2[0x30] = 0;
param_2[0x31] = 0;
param_2[0x32] = 0;
param_2[0x33] = 0;
param_2[0x34] = 0;
param_2[0x35] = 0;
param_2[0x36] = 0;
param_2[0x37] = 0;
param_2[0x28] = 0;
param_2[0x29] = 0;
param_2[0x2a] = 0;
param_2[0x2b] = 0;
param_2[0x2c] = 0;
param_2[0x2d] = 0;
param_2[0x2e] = 0;
param_2[0x2f] = 0;
param_2[0x20] = 0;
param_2[0x21] = 0;
param_2[0x22] = 0;
param_2[0x23] = 0;
param_2[0x24] = 0;
param_2[0x25] = 0;
param_2[0x26] = 0;
param_2[0x27] = 0;
param_2[0x18] = 0;
param_2[0x19] = 0;
param_2[0x1a] = 0;
param_2[0x1b] = 0;
param_2[0x1c] = 0;
param_2[0x1d] = 0;
param_2[0x1e] = 0;
param_2[0x1f] = 0;
param_2[0x10] = 0;
param_2[0x11] = 0;
param_2[0x12] = 0;
param_2[0x13] = 0;
param_2[0x14] = 0;
param_2[0x15] = 0;
param_2[0x16] = 0;
param_2[0x17] = 0;
param_2[8] = 0;
param_2[9] = 0;
param_2[10] = 0;
param_2[0xb] = 0;
param_2[0xc] = 0;
param_2[0xd] = 0;
param_2[0xe] = 0;
param_2[0xf] = 0;
param_2[0] = 0;
param_2[1] = 0;
param_2[2] = 0;
param_2[3] = 0;
param_2[4] = 0;
param_2[5] = 0;
param_2[6] = 0;
param_2[7] = 0;
uVar15 = 0;
if (sVar1 != (stbi__huffman)0x0) {
iVar13 = *(int *)(param_1 + 0x4824);
if (iVar13 < (int)(uint)(byte)sVar1) {
stbi__grow_buffer_unsafe(param_1);
iVar13 = *(int *)(param_1 + 0x4824);
}
uVar15 = 0;
if ((int)(uint)(byte)sVar1 <= iVar13) {
uVar15 = *(uint *)(param_1 + 0x4820);
uVar12 = uVar15 << ((byte)sVar1 & 0x1f) | uVar15 >> 0x20 - ((byte)sVar1 & 0x1f);
uVar11 = *(uint *)(stbi__bmask + (ulong)(byte)sVar1 * 4);
*(uint *)(param_1 + 0x4820) = ~uVar11 & uVar12;
*(uint *)(param_1 + 0x4824) = iVar13 - (uint)(byte)sVar1;
iVar13 = 0;
if (-1 < (int)uVar15) {
iVar13 = *(int *)(stbi__jbias + (ulong)(byte)sVar1 * 4);
}
uVar15 = iVar13 + (uVar12 & uVar11);
}
}
uVar12 = *(uint *)(param_1 + (long)param_6 * 0x60 + 0x46b8);
if (-1 < (int)(uVar12 ^ uVar15)) {
bVar5 = (int)uVar12 < (int)(-0x80000000 - uVar15);
uVar16 = (ulong)bVar5;
uVar11 = uVar15 ^ 0x7fffffff;
bVar6 = (int)uVar11 < (int)uVar12;
if ((int)(uVar12 & uVar15) < 0) {
bVar6 = bVar5;
}
if (bVar6) {
pcVar14 = "bad delta";
goto LAB_00134cc1;
}
}
uVar12 = uVar12 + uVar15;
*(uint *)(param_1 + (long)param_6 * 0x60 + 0x46b8) = uVar12;
uVar3 = *param_7;
uVar16 = (ulong)uVar3;
if (uVar3 == 0) {
LAB_00134de3:
*param_2 = uVar3 * (short)uVar12;
uVar11 = *(uint *)(param_1 + 0x4824);
iVar13 = 1;
do {
if ((int)uVar11 < 0x10) {
stbi__grow_buffer_unsafe(param_1);
}
uVar15 = *(uint *)(param_1 + 0x4820);
uVar16 = (ulong)uVar15;
uVar8 = (ulong)(uVar15 >> 0x17);
uVar3 = param_5[uVar8];
if (uVar3 == 0) {
if (*(int *)(param_1 + 0x4824) < 0x10) {
stbi__grow_buffer_unsafe(param_1);
uVar16 = (ulong)*(uint *)(param_1 + 0x4820);
uVar8 = (ulong)(*(uint *)(param_1 + 0x4820) >> 0x17);
}
uVar8 = (ulong)(byte)param_4[uVar8];
uVar15 = (uint)uVar16;
if (uVar8 == 0xff) {
lVar20 = 0;
do {
lVar19 = lVar20;
lVar20 = lVar19 + 1;
} while (*(uint *)(param_4 + lVar19 * 4 + 0x62c) <= (uint)(uVar16 >> 0x10));
uVar11 = *(uint *)(param_1 + 0x4824);
if (lVar20 == 8) goto LAB_00134cb1;
if (((int)uVar11 < (int)(lVar19 + 10)) ||
(uVar12 = (uVar15 >> (0x17U - (char)lVar20 & 0x1f) &
*(uint *)(stbi__bmask + lVar20 * 4 + 0x24)) +
*(int *)(param_4 + lVar20 * 4 + 0x670), 0xff < uVar12))
goto LAB_00134cba;
iVar21 = uVar11 - (int)lVar20;
uVar11 = (uVar11 - (int)lVar20) - 9;
*(int *)(param_1 + 0x4824) = iVar21 + -9;
*(uint *)(param_1 + 0x4820) = uVar15 << ((byte)(lVar19 + 10) & 0x1f);
uVar8 = (ulong)uVar12;
}
else {
sVar1 = param_4[uVar8 + 0x500];
uVar11 = *(int *)(param_1 + 0x4824) - (uint)(byte)sVar1;
if (*(int *)(param_1 + 0x4824) < (int)(uint)(byte)sVar1) goto LAB_00134cba;
*(uint *)(param_1 + 0x4820) = uVar15 << ((byte)sVar1 & 0x1f);
*(uint *)(param_1 + 0x4824) = uVar11;
}
sVar1 = param_4[uVar8 + 0x400];
uVar15 = (byte)sVar1 & 0xf;
if (((byte)sVar1 & 0xf) == 0) {
if ((byte)sVar1 != 0xf0) {
return 1;
}
iVar13 = iVar13 + 0x10;
}
else {
lVar20 = (long)iVar13 + (ulong)((byte)sVar1 >> 4);
bVar2 = (&stbi__jpeg_dezigzag)[lVar20];
if ((int)uVar11 < (int)uVar15) {
stbi__grow_buffer_unsafe(param_1);
uVar11 = *(uint *)(param_1 + 0x4824);
}
sVar7 = 0;
sVar17 = 0;
if ((int)uVar15 <= (int)uVar11) {
uVar12 = *(uint *)(param_1 + 0x4820);
uVar18 = uVar12 << (sbyte)uVar15 | uVar12 >> 0x20 - (sbyte)uVar15;
uVar4 = *(uint *)(stbi__bmask + (uVar15 << 2));
*(uint *)(param_1 + 0x4820) = ~uVar4 & uVar18;
*(uint *)(param_1 + 0x4824) = uVar11 - uVar15;
if (-1 < (int)uVar12) {
sVar7 = (short)*(int4 *)(stbi__jbias + (uVar15 << 2));
}
sVar17 = ((ushort)uVar18 & (ushort)uVar4) + sVar7;
uVar11 = uVar11 - uVar15;
}
iVar13 = (int)lVar20 + 1;
*(short *)((long)param_2 + (ulong)((uint)bVar2 * 2)) =
sVar17 * *(short *)((long)param_7 + (ulong)((uint)bVar2 * 2));
}
}
else {
uVar12 = uVar3 & 0xf;
uVar11 = *(int *)(param_1 + 0x4824) - uVar12;
if (*(int *)(param_1 + 0x4824) < (int)uVar12) goto LAB_00134cba;
lVar20 = (long)iVar13 + (ulong)(uVar3 >> 4 & 0xf);
*(uint *)(param_1 + 0x4820) = uVar15 << (sbyte)uVar12;
*(uint *)(param_1 + 0x4824) = uVar11;
iVar13 = (int)lVar20 + 1;
*(short *)((long)param_2 + (ulong)((uint)(byte)(&stbi__jpeg_dezigzag)[lVar20] * 2)) =
(short)(char)(uVar3 >> 8) *
*(short *)((long)param_7 +
(ulong)((uint)(byte)(&stbi__jpeg_dezigzag)[lVar20] * 2));
}
if (0x3f < iVar13) {
return 1;
}
} while( true );
}
if ((int)uVar12 < 0) {
uVar15 = 0x8000 / uVar3;
uVar10 = (ushort)(0x8000 % (uint)uVar3);
if (SBORROW4(uVar12,-uVar15) == (int)(uVar12 + uVar15) < 0) goto LAB_00134de3;
}
else {
uVar10 = (ushort)(0x7fff % (uint)uVar3);
if (uVar12 <= 0x7fff / uVar3) goto LAB_00134de3;
}
uVar11 = (uint)uVar10;
pcVar14 = "can\'t merge dc and ac";
}
goto LAB_00134cc1;
}
}
LAB_00134cba:
pcVar14 = "bad huffman code";
LAB_00134cc1:
puVar9 = (int8 *)__tls_get_addr(&PTR_0015dd40,uVar16,uVar11);
*puVar9 = pcVar14;
return 0;
}
|
|
17,233
|
my_casedn_ucs2
|
eloqsql/strings/ctype-ucs2.c
|
static size_t my_casedn_ucs2(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= my_ucs2_uni(cs, &wc, (uchar*) src, (uchar*) srcend)) > 0)
{
my_tolower_ucs2(uni_plane, &wc);
if (res != my_uni_ucs2(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
}
|
O3
|
c
|
my_casedn_ucs2:
movq %rdx, %rax
cmpq $0x2, %rdx
jl 0x2b362
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rax), %rdx
addq %rcx, %r8
movq 0x78(%rdi), %rdi
addq $0x2, %rcx
movzbl (%rsi), %r9d
movzbl 0x1(%rsi), %r10d
movq 0x8(%rdi), %r11
movq (%r11,%r9,8), %r11
testq %r11, %r11
je 0x2b329
leaq (%r10,%r10,2), %r9
movl 0x4(%r11,%r9,4), %r9d
jmp 0x2b330
shll $0x8, %r9d
orq %r10, %r9
cmpq %r8, %rcx
ja 0x2b361
cmpl $0xffff, %r9d # imm = 0xFFFF
ja 0x2b361
rolw $0x8, %r9w
movw %r9w, -0x2(%rcx)
leaq 0x2(%rsi), %r9
cmpq %rdx, %r9
jae 0x2b361
addq $0x4, %rsi
addq $0x2, %rcx
cmpq %rdx, %rsi
movq %r9, %rsi
jbe 0x2b308
popq %rbp
retq
|
my_casedn_ucs2:
mov rax, rdx
cmp rdx, 2
jl short locret_2B362
push rbp
mov rbp, rsp
lea rdx, [rsi+rax]
add r8, rcx
mov rdi, [rdi+78h]
add rcx, 2
loc_2B308:
movzx r9d, byte ptr [rsi]
movzx r10d, byte ptr [rsi+1]
mov r11, [rdi+8]
mov r11, [r11+r9*8]
test r11, r11
jz short loc_2B329
lea r9, [r10+r10*2]
mov r9d, [r11+r9*4+4]
jmp short loc_2B330
loc_2B329:
shl r9d, 8
or r9, r10
loc_2B330:
cmp rcx, r8
ja short loc_2B361
cmp r9d, 0FFFFh
ja short loc_2B361
rol r9w, 8
mov [rcx-2], r9w
lea r9, [rsi+2]
cmp r9, rdx
jnb short loc_2B361
add rsi, 4
add rcx, 2
cmp rsi, rdx
mov rsi, r9
jbe short loc_2B308
loc_2B361:
pop rbp
locret_2B362:
retn
|
long long my_casedn_ucs2(long long a1, unsigned __int8 *a2, long long a3, long long a4, long long a5)
{
long long result; // rax
unsigned long long v6; // rdx
unsigned long long v7; // r8
long long v8; // rdi
unsigned long long v9; // rcx
long long v10; // r9
long long v11; // r10
long long v12; // r11
unsigned int v13; // r9d
bool v14; // cc
result = a3;
if ( a3 >= 2 )
{
v6 = (unsigned long long)&a2[a3];
v7 = a4 + a5;
v8 = *(_QWORD *)(a1 + 120);
v9 = a4 + 2;
do
{
v10 = *a2;
v11 = a2[1];
v12 = *(_QWORD *)(*(_QWORD *)(v8 + 8) + 8 * v10);
if ( v12 )
v13 = *(_DWORD *)(v12 + 12 * v11 + 4);
else
v13 = v11 | ((_DWORD)v10 << 8);
if ( v9 > v7 )
break;
if ( v13 > 0xFFFF )
break;
*(_WORD *)(v9 - 2) = __ROL2__(v13, 8);
if ( (unsigned long long)(a2 + 2) >= v6 )
break;
v9 += 2LL;
v14 = (unsigned long long)(a2 + 4) <= v6;
a2 += 2;
}
while ( v14 );
}
return result;
}
|
my_casedn_ucs2:
MOV RAX,RDX
CMP RDX,0x2
JL 0x0012b362
PUSH RBP
MOV RBP,RSP
LEA RDX,[RSI + RAX*0x1]
ADD R8,RCX
MOV RDI,qword ptr [RDI + 0x78]
ADD RCX,0x2
LAB_0012b308:
MOVZX R9D,byte ptr [RSI]
MOVZX R10D,byte ptr [RSI + 0x1]
MOV R11,qword ptr [RDI + 0x8]
MOV R11,qword ptr [R11 + R9*0x8]
TEST R11,R11
JZ 0x0012b329
LEA R9,[R10 + R10*0x2]
MOV R9D,dword ptr [R11 + R9*0x4 + 0x4]
JMP 0x0012b330
LAB_0012b329:
SHL R9D,0x8
OR R9,R10
LAB_0012b330:
CMP RCX,R8
JA 0x0012b361
CMP R9D,0xffff
JA 0x0012b361
ROL R9W,0x8
MOV word ptr [RCX + -0x2],R9W
LEA R9,[RSI + 0x2]
CMP R9,RDX
JNC 0x0012b361
ADD RSI,0x4
ADD RCX,0x2
CMP RSI,RDX
MOV RSI,R9
JBE 0x0012b308
LAB_0012b361:
POP RBP
LAB_0012b362:
RET
|
void my_casedn_ucs2(long param_1,byte *param_2,long param_3,long param_4,long param_5)
{
long lVar1;
long lVar2;
ulong uVar3;
byte *pbVar4;
byte *pbVar5;
uint uVar6;
if (1 < param_3) {
lVar1 = *(long *)(param_1 + 0x78);
uVar3 = param_4 + 2;
pbVar4 = param_2;
while( true ) {
lVar2 = *(long *)(*(long *)(lVar1 + 8) + (ulong)*pbVar4 * 8);
if (lVar2 == 0) {
uVar6 = (uint)CONCAT11(*pbVar4,pbVar4[1]);
}
else {
uVar6 = *(uint *)(lVar2 + 4 + (ulong)pbVar4[1] * 0xc);
}
if (((ulong)(param_5 + param_4) < uVar3) || (0xffff < uVar6)) break;
*(ushort *)(uVar3 - 2) = (ushort)uVar6 << 8 | (ushort)uVar6 >> 8;
if (param_2 + param_3 <= pbVar4 + 2) {
return;
}
pbVar5 = pbVar4 + 4;
uVar3 = uVar3 + 2;
pbVar4 = pbVar4 + 2;
if (param_2 + param_3 < pbVar5) {
return;
}
}
}
return;
}
|
|
17,234
|
ftxui::RadioboxOption::Simple()
|
Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/component/component_options.cpp
|
RadioboxOption RadioboxOption::Simple() {
auto option = RadioboxOption();
option.transform = [](const EntryState& s) {
#if defined(FTXUI_MICROSOFT_TERMINAL_FALLBACK)
// Microsoft terminal do not use fonts able to render properly the default
// radiobox glyph.
auto prefix = text(s.state ? "(*) " : "( ) "); // NOLINT
#else
auto prefix = text(s.state ? "◉ " : "○ "); // NOLINT
#endif
auto t = text(s.label);
if (s.active) {
t |= bold;
}
if (s.focused) {
t |= inverted;
}
return hbox({prefix, t});
};
return option;
}
|
O3
|
cpp
|
ftxui::RadioboxOption::Simple():
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x2190(%rip), %rcx # 0x3671c
movq %rcx, 0x58(%rdi)
leaq 0x2187(%rip), %rcx # 0x3671e
movq %rcx, 0x50(%rdi)
movb $0x0, 0x68(%rdi)
leaq 0x178e(%rip), %rcx # 0x35d34
movq %rcx, 0x30(%rdi)
leaq 0x1437(%rip), %rcx # 0x359e8
movq %rcx, 0x38(%rdi)
retq
|
_ZN5ftxui14RadioboxOption6SimpleEv:
mov rax, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+50h], xmm0
movups xmmword ptr [rdi+60h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
lea rcx, _ZNSt17_Function_handlerIFvvEN5ftxui14RadioboxOption9on_changeMUlvE_EE9_M_invokeERKSt9_Any_data
mov [rdi+58h], rcx
lea rcx, _ZNSt17_Function_handlerIFvvEN5ftxui14RadioboxOption9on_changeMUlvE_EE10_M_managerERSt9_Any_dataRKS6_St18_Manager_operation
mov [rdi+50h], rcx
mov byte ptr [rdi+68h], 0
lea rcx, _ZNSt17_Function_handlerIFSt10shared_ptrIN5ftxui4NodeEERKNS1_10EntryStateEEZNS1_14RadioboxOption6SimpleEvE3$_0E10_M_managerERSt9_Any_dataRKSB_St18_Manager_operation; std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::RadioboxOption::Simple(void)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rdi+30h], rcx
lea rcx, _ZNSt17_Function_handlerIFSt10shared_ptrIN5ftxui4NodeEERKNS1_10EntryStateEEZNS1_14RadioboxOption6SimpleEvE3$_0E9_M_invokeERKSt9_Any_dataS6_; std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::RadioboxOption::Simple(void)::$_0>::_M_invoke(std::_Any_data const&,ftxui::EntryState const&)
mov [rdi+38h], rcx
retn
|
ftxui::RadioboxOption * ftxui::RadioboxOption::Simple(ftxui::RadioboxOption *this)
{
ftxui::RadioboxOption *result; // rax
result = this;
*((_OWORD *)this + 5) = 0LL;
*((_OWORD *)this + 6) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_OWORD *)this + 4) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 1) = 0LL;
*(_OWORD *)this = 0LL;
*((_QWORD *)this + 11) = ZNSt17_Function_handlerIFvvEN5ftxui14RadioboxOption9on_changeMUlvE_EE9_M_invokeERKSt9_Any_data;
*((_QWORD *)this + 10) = ZNSt17_Function_handlerIFvvEN5ftxui14RadioboxOption9on_changeMUlvE_EE10_M_managerERSt9_Any_dataRKS6_St18_Manager_operation;
*((_BYTE *)this + 104) = 0;
*((_QWORD *)this + 6) = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::RadioboxOption::Simple(void)::$_0>::_M_manager;
*((_QWORD *)this + 7) = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::RadioboxOption::Simple(void)::$_0>::_M_invoke;
return result;
}
|
Simple:
MOV RAX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x50],XMM0
MOVUPS xmmword ptr [RDI + 0x60],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
LEA RCX,[0x13671c]
MOV qword ptr [RDI + 0x58],RCX
LEA RCX,[0x13671e]
MOV qword ptr [RDI + 0x50],RCX
MOV byte ptr [RDI + 0x68],0x0
LEA RCX,[0x135d34]
MOV qword ptr [RDI + 0x30],RCX
LEA RCX,[0x1359e8]
MOV qword ptr [RDI + 0x38],RCX
RET
|
/* ftxui::RadioboxOption::Simple() */
RadioboxOption * __thiscall ftxui::RadioboxOption::Simple(RadioboxOption *this)
{
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(code **)(this + 0x58) =
std::_Function_handler<void(),ftxui::RadioboxOption::on_change::{lambda()#1}>::_M_invoke;
*(code **)(this + 0x50) =
std::_Function_handler<void(),ftxui::RadioboxOption::on_change::{lambda()#1}>::_M_manager;
this[0x68] = (RadioboxOption)0x0;
*(code **)(this + 0x30) =
std::
_Function_handler<std::shared_ptr<ftxui::Node>(ftxui::EntryState_const&),ftxui::RadioboxOption::Simple()::$_0>
::_M_manager;
*(code **)(this + 0x38) =
std::
_Function_handler<std::shared_ptr<ftxui::Node>(ftxui::EntryState_const&),ftxui::RadioboxOption::Simple()::$_0>
::_M_invoke;
return this;
}
|
|
17,235
|
mj_step
|
aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_forward.c
|
void mj_step(const mjModel* m, mjData* d) {
TM_START;
// common to all integrators
mj_checkPos(m, d);
mj_checkVel(m, d);
mj_forward(m, d);
mj_checkAcc(m, d);
// compare forward and inverse solutions if enabled
if (mjENABLED(mjENBL_FWDINV)) {
mj_compareFwdInv(m, d);
}
// use selected integrator
switch ((mjtIntegrator) m->opt.integrator) {
case mjINT_EULER:
mj_Euler(m, d);
break;
case mjINT_RK4:
mj_RungeKutta(m, d, 4);
break;
case mjINT_IMPLICIT:
case mjINT_IMPLICITFAST:
mj_implicit(m, d);
break;
default:
mjERROR("invalid integrator");
}
TM_END(mjTIMER_STEP);
}
|
O0
|
c
|
mj_step:
subq $0x438, %rsp # imm = 0x438
movq %rdi, 0x430(%rsp)
movq %rsi, 0x428(%rsp)
movq 0x568c72(%rip), %rax # 0x5f9e80
cmpq $0x0, (%rax)
je 0x91225
movq 0x568c65(%rip), %rax # 0x5f9e80
callq *(%rax)
vmovsd %xmm0, 0x10(%rsp)
jmp 0x91231
vxorps %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x10(%rsp)
jmp 0x91231
vmovsd 0x10(%rsp), %xmm0
vmovsd %xmm0, 0x420(%rsp)
movq 0x430(%rsp), %rdi
movq 0x428(%rsp), %rsi
callq 0x49b30
movq 0x430(%rsp), %rdi
movq 0x428(%rsp), %rsi
callq 0x49b40
movq 0x430(%rsp), %rdi
movq 0x428(%rsp), %rsi
callq 0x49c60
movq 0x430(%rsp), %rdi
movq 0x428(%rsp), %rsi
callq 0x49b60
movq 0x430(%rsp), %rax
movl 0x25c(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x912bf
movq 0x430(%rsp), %rdi
movq 0x428(%rsp), %rsi
callq 0x49b70
movq 0x430(%rsp), %rax
movl 0x238(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x912f0
jmp 0x912d7
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x91307
jmp 0x912e2
movl 0xc(%rsp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x91323
jmp 0x9133a
movq 0x430(%rsp), %rdi
movq 0x428(%rsp), %rsi
callq 0x49ed0
jmp 0x91385
movq 0x430(%rsp), %rdi
movq 0x428(%rsp), %rsi
movl $0x4, %edx
callq 0x49b90
jmp 0x91385
movq 0x430(%rsp), %rdi
movq 0x428(%rsp), %rsi
callq 0x49ee0
jmp 0x91385
movq $0x7, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x4875ac(%rip), %rsi # 0x5188fb
movl $0x400, %edx # imm = 0x400
callq 0x49400
leaq 0x20(%rsp), %rdi
addq 0x18(%rsp), %rdi
movl $0x400, %esi # imm = 0x400
subq 0x18(%rsp), %rsi
leaq 0x487405(%rip), %rdx # 0x518779
movb $0x0, %al
callq 0x49410
leaq 0x20(%rsp), %rdi
callq 0x49420
movq 0x568af4(%rip), %rax # 0x5f9e80
cmpq $0x0, (%rax)
je 0x913a2
movq 0x568ae7(%rip), %rax # 0x5f9e80
callq *(%rax)
vmovsd %xmm0, (%rsp)
jmp 0x913ad
vxorps %xmm0, %xmm0, %xmm0
vmovsd %xmm0, (%rsp)
jmp 0x913ad
vmovsd (%rsp), %xmm0
vsubsd 0x420(%rsp), %xmm0, %xmm0
movq 0x428(%rsp), %rax
vaddsd 0x488(%rax), %xmm0, %xmm0
vmovsd %xmm0, 0x488(%rax)
movq 0x428(%rsp), %rax
movl 0x490(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x490(%rax)
addq $0x438, %rsp # imm = 0x438
retq
nopw %cs:(%rax,%rax)
|
mj_step:
sub rsp, 438h
mov [rsp+438h+var_8], rdi
mov [rsp+438h+var_10], rsi
mov rax, cs:mjcb_time_ptr
cmp qword ptr [rax], 0
jz short loc_91225
mov rax, cs:mjcb_time_ptr
call qword ptr [rax]
vmovsd [rsp+438h+var_428], xmm0
jmp short loc_91231
loc_91225:
vxorps xmm0, xmm0, xmm0
vmovsd [rsp+438h+var_428], xmm0
jmp short $+2
loc_91231:
vmovsd xmm0, [rsp+438h+var_428]
vmovsd [rsp+438h+var_18], xmm0
mov rdi, [rsp+438h+var_8]
mov rsi, [rsp+438h+var_10]
call _mj_checkPos
mov rdi, [rsp+438h+var_8]
mov rsi, [rsp+438h+var_10]
call _mj_checkVel
mov rdi, [rsp+438h+var_8]
mov rsi, [rsp+438h+var_10]
call _mj_forward
mov rdi, [rsp+438h+var_8]
mov rsi, [rsp+438h+var_10]
call _mj_checkAcc
mov rax, [rsp+438h+var_8]
mov eax, [rax+25Ch]
and eax, 4
cmp eax, 0
jz short loc_912BF
mov rdi, [rsp+438h+var_8]
mov rsi, [rsp+438h+var_10]
call _mj_compareFwdInv
loc_912BF:
mov rax, [rsp+438h+var_8]
mov eax, [rax+238h]
mov [rsp+438h+var_42C], eax
test eax, eax
jz short loc_912F0
jmp short $+2
loc_912D7:
mov eax, [rsp+438h+var_42C]
sub eax, 1
jz short loc_91307
jmp short $+2
loc_912E2:
mov eax, [rsp+438h+var_42C]
add eax, 0FFFFFFFEh
sub eax, 2
jb short loc_91323
jmp short loc_9133A
loc_912F0:
mov rdi, [rsp+438h+var_8]
mov rsi, [rsp+438h+var_10]
call _mj_Euler
jmp short loc_91385
loc_91307:
mov rdi, [rsp+438h+var_8]
mov rsi, [rsp+438h+var_10]
mov edx, 4
call _mj_RungeKutta
jmp short loc_91385
loc_91323:
mov rdi, [rsp+438h+var_8]
mov rsi, [rsp+438h+var_10]
call _mj_implicit
jmp short loc_91385
loc_9133A:
mov [rsp+438h+var_420], 7
lea rdi, [rsp+438h+var_418]
lea rsi, aMjStep_0; "mj_step"
mov edx, 400h
call _strncpy
lea rdi, [rsp+438h+var_418]
add rdi, [rsp+438h+var_420]
mov esi, 400h
sub rsi, [rsp+438h+var_420]
lea rdx, aInvalidIntegra; ": invalid integrator"
mov al, 0
call _snprintf
lea rdi, [rsp+438h+var_418]
call _mju_error_raw
loc_91385:
mov rax, cs:mjcb_time_ptr
cmp qword ptr [rax], 0
jz short loc_913A2
mov rax, cs:mjcb_time_ptr
call qword ptr [rax]
vmovsd [rsp+438h+var_438], xmm0
jmp short loc_913AD
loc_913A2:
vxorps xmm0, xmm0, xmm0
vmovsd [rsp+438h+var_438], xmm0
jmp short $+2
loc_913AD:
vmovsd xmm0, [rsp+438h+var_438]
vsubsd xmm0, xmm0, [rsp+438h+var_18]
mov rax, [rsp+438h+var_10]
vaddsd xmm0, xmm0, qword ptr [rax+488h]
vmovsd qword ptr [rax+488h], xmm0
mov rax, [rsp+438h+var_10]
mov ecx, [rax+490h]
add ecx, 1
mov [rax+490h], ecx
add rsp, 438h
retn
|
long long mj_step(long long a1, long long a2, __m128 _XMM0)
{
long long result; // rax
int v12; // [rsp+Ch] [rbp-42Ch]
_BYTE v14[7]; // [rsp+20h] [rbp-418h] BYREF
_BYTE v15[1025]; // [rsp+27h] [rbp-411h] BYREF
long long v16; // [rsp+428h] [rbp-10h]
long long v17; // [rsp+430h] [rbp-8h]
v17 = a1;
v16 = a2;
if ( mjcb_time )
{
*(double *)_XMM0.m128_u64 = mjcb_time(*(double *)_XMM0.m128_u64);
__asm { vmovsd [rsp+438h+var_428], xmm0 }
}
else
{
__asm
{
vxorps xmm0, xmm0, xmm0
vmovsd [rsp+438h+var_428], xmm0
}
}
__asm
{
vmovsd xmm0, [rsp+438h+var_428]
vmovsd [rsp+438h+var_18], xmm0
}
mj_checkPos(v17, v16);
mj_checkVel(v17, v16);
mj_forward(v17, v16);
mj_checkAcc(v17, v16);
if ( (*(_DWORD *)(v17 + 604) & 4) != 0 )
mj_compareFwdInv(v17, v16);
v12 = *(_DWORD *)(v17 + 568);
if ( v12 )
{
if ( v12 == 1 )
{
mj_RungeKutta(v17, v16, 4LL);
}
else if ( (unsigned int)(v12 - 2) < 2 )
{
mj_implicit(v17, v16);
}
else
{
strncpy(v14, "mj_step", 1024LL);
snprintf(v15, 1017LL, ": invalid integrator");
*(double *)&_XMM0 = mju_error_raw(v14);
}
}
else
{
mj_Euler(v17, v16);
}
if ( mjcb_time )
{
*(double *)&_XMM0 = mjcb_time(*(double *)&_XMM0);
__asm { vmovsd [rsp+438h+var_438], xmm0 }
}
else
{
__asm
{
vxorps xmm0, xmm0, xmm0
vmovsd [rsp+438h+var_438], xmm0
}
}
__asm
{
vmovsd xmm0, [rsp+438h+var_438]
vsubsd xmm0, xmm0, [rsp+438h+var_18]
}
_RAX = v16;
__asm
{
vaddsd xmm0, xmm0, qword ptr [rax+488h]
vmovsd qword ptr [rax+488h], xmm0
}
result = v16;
++*(_DWORD *)(v16 + 1168);
return result;
}
|
mj_step:
SUB RSP,0x438
MOV qword ptr [RSP + 0x430],RDI
MOV qword ptr [RSP + 0x428],RSI
MOV RAX,qword ptr [0x006f9e80]
CMP qword ptr [RAX],0x0
JZ 0x00191225
MOV RAX,qword ptr [0x006f9e80]
CALL qword ptr [RAX]
VMOVSD qword ptr [RSP + 0x10],XMM0
JMP 0x00191231
LAB_00191225:
VXORPS XMM0,XMM0,XMM0
VMOVSD qword ptr [RSP + 0x10],XMM0
JMP 0x00191231
LAB_00191231:
VMOVSD XMM0,qword ptr [RSP + 0x10]
VMOVSD qword ptr [RSP + 0x420],XMM0
MOV RDI,qword ptr [RSP + 0x430]
MOV RSI,qword ptr [RSP + 0x428]
CALL 0x00149b30
MOV RDI,qword ptr [RSP + 0x430]
MOV RSI,qword ptr [RSP + 0x428]
CALL 0x00149b40
MOV RDI,qword ptr [RSP + 0x430]
MOV RSI,qword ptr [RSP + 0x428]
CALL 0x00149c60
MOV RDI,qword ptr [RSP + 0x430]
MOV RSI,qword ptr [RSP + 0x428]
CALL 0x00149b60
MOV RAX,qword ptr [RSP + 0x430]
MOV EAX,dword ptr [RAX + 0x25c]
AND EAX,0x4
CMP EAX,0x0
JZ 0x001912bf
MOV RDI,qword ptr [RSP + 0x430]
MOV RSI,qword ptr [RSP + 0x428]
CALL 0x00149b70
LAB_001912bf:
MOV RAX,qword ptr [RSP + 0x430]
MOV EAX,dword ptr [RAX + 0x238]
MOV dword ptr [RSP + 0xc],EAX
TEST EAX,EAX
JZ 0x001912f0
JMP 0x001912d7
LAB_001912d7:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x1
JZ 0x00191307
JMP 0x001912e2
LAB_001912e2:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,-0x2
SUB EAX,0x2
JC 0x00191323
JMP 0x0019133a
LAB_001912f0:
MOV RDI,qword ptr [RSP + 0x430]
MOV RSI,qword ptr [RSP + 0x428]
CALL 0x00149ed0
JMP 0x00191385
LAB_00191307:
MOV RDI,qword ptr [RSP + 0x430]
MOV RSI,qword ptr [RSP + 0x428]
MOV EDX,0x4
CALL 0x00149b90
JMP 0x00191385
LAB_00191323:
MOV RDI,qword ptr [RSP + 0x430]
MOV RSI,qword ptr [RSP + 0x428]
CALL 0x00149ee0
JMP 0x00191385
LAB_0019133a:
MOV qword ptr [RSP + 0x18],0x7
LEA RDI,[RSP + 0x20]
LEA RSI,[0x6188fb]
MOV EDX,0x400
CALL 0x00149400
LEA RDI,[RSP + 0x20]
ADD RDI,qword ptr [RSP + 0x18]
MOV ESI,0x400
SUB RSI,qword ptr [RSP + 0x18]
LEA RDX,[0x618779]
MOV AL,0x0
CALL 0x00149410
LEA RDI,[RSP + 0x20]
CALL 0x00149420
LAB_00191385:
MOV RAX,qword ptr [0x006f9e80]
CMP qword ptr [RAX],0x0
JZ 0x001913a2
MOV RAX,qword ptr [0x006f9e80]
CALL qword ptr [RAX]
VMOVSD qword ptr [RSP],XMM0
JMP 0x001913ad
LAB_001913a2:
VXORPS XMM0,XMM0,XMM0
VMOVSD qword ptr [RSP],XMM0
JMP 0x001913ad
LAB_001913ad:
VMOVSD XMM0,qword ptr [RSP]
VSUBSD XMM0,XMM0,qword ptr [RSP + 0x420]
MOV RAX,qword ptr [RSP + 0x428]
VADDSD XMM0,XMM0,qword ptr [RAX + 0x488]
VMOVSD qword ptr [RAX + 0x488],XMM0
MOV RAX,qword ptr [RSP + 0x428]
MOV ECX,dword ptr [RAX + 0x490]
ADD ECX,0x1
MOV dword ptr [RAX + 0x490],ECX
ADD RSP,0x438
RET
|
void mj_step(long param_1,long param_2)
{
int iVar1;
double local_438;
double local_428;
char local_418 [7];
char acStack_411 [1017];
double local_18;
long local_10;
long local_8;
local_10 = param_2;
local_8 = param_1;
if (*(long *)PTR_mjcb_time_006f9e80 == 0) {
local_428 = 0.0;
}
else {
local_428 = (double)(**(code **)PTR_mjcb_time_006f9e80)();
}
local_18 = local_428;
mj_checkPos(local_8,local_10);
mj_checkVel(local_8,local_10);
mj_forward(local_8,local_10);
mj_checkAcc(local_8,local_10);
if ((*(uint *)(local_8 + 0x25c) & 4) != 0) {
mj_compareFwdInv(local_8,local_10);
}
iVar1 = *(int *)(local_8 + 0x238);
if (iVar1 == 0) {
mj_Euler(local_8,local_10);
}
else if (iVar1 == 1) {
mj_RungeKutta(local_8,local_10,4);
}
else if (iVar1 - 2U < 2) {
mj_implicit(local_8,local_10);
}
else {
strncpy(local_418,"mj_step",0x400);
snprintf(acStack_411,0x3f9,": invalid integrator");
mju_error_raw(local_418);
}
if (*(long *)PTR_mjcb_time_006f9e80 == 0) {
local_438 = 0.0;
}
else {
local_438 = (double)(**(code **)PTR_mjcb_time_006f9e80)();
}
*(double *)(local_10 + 0x488) = (local_438 - local_18) + *(double *)(local_10 + 0x488);
*(int *)(local_10 + 0x490) = *(int *)(local_10 + 0x490) + 1;
return;
}
|
|
17,236
|
nglog::tools::SafeFNMatch_(char const*, unsigned long, char const*, unsigned long)
|
ng-log[P]ng-log/src/vlog_is_on.cc
|
NGLOG_NO_EXPORT bool SafeFNMatch_(const char* pattern, size_t patt_len,
const char* str, size_t str_len) {
size_t p = 0;
size_t s = 0;
while (true) {
if (p == patt_len && s == str_len) return true;
if (p == patt_len) return false;
if (s == str_len) return p + 1 == patt_len && pattern[p] == '*';
if (pattern[p] == str[s] || pattern[p] == '?') {
p += 1;
s += 1;
continue;
}
if (pattern[p] == '*') {
if (p + 1 == patt_len) return true;
do {
if (SafeFNMatch_(pattern + (p + 1), patt_len - (p + 1), str + s,
str_len - s)) {
return true;
}
s += 1;
} while (s != str_len);
return false;
}
return false;
}
}
|
O3
|
cpp
|
nglog::tools::SafeFNMatch_(char const*, unsigned long, char const*, unsigned long):
testq %rcx, %rcx
sete %al
testq %rsi, %rsi
je 0x21655
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
decq %rcx
xorl %r15d, %r15d
testb $0x1, %al
jne 0x215ed
movb (%rdi,%r15), %al
cmpb $0x3f, %al
je 0x215d9
cmpb (%rbx,%r15), %al
jne 0x215ff
cmpq %r15, %rcx
leaq 0x1(%r15), %rdx
sete %al
movq %rdx, %r15
cmpq %rdx, %rsi
jne 0x215c7
jmp 0x2164a
decq %rsi
cmpq %r15, %rsi
jne 0x21648
cmpb $0x2a, (%rdi,%r15)
sete %al
jmp 0x2164a
cmpb $0x2a, %al
jne 0x21648
leaq -0x1(%rsi), %rcx
movb $0x1, %al
cmpq %r15, %rcx
je 0x2164a
addq %r15, %rbx
subq %r15, %r14
leaq (%rdi,%r15), %r12
incq %r12
notq %r15
addq %rsi, %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x215a4
testb %al, %al
jne 0x2164a
leaq -0x1(%r14), %rcx
incq %rbx
cmpq $0x1, %r14
movq %rcx, %r14
jne 0x21621
jmp 0x2164a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_ZN5nglog5tools12SafeFNMatch_EPKcmS2_m:
test rcx, rcx
setz al
test rsi, rsi
jz locret_21655
push r15
push r14
push r12
push rbx
push rax
mov r14, rcx
mov rbx, rdx
dec rcx
xor r15d, r15d
loc_215C7:
test al, 1
jnz short loc_215ED
mov al, [rdi+r15]
cmp al, 3Fh ; '?'
jz short loc_215D9
cmp al, [rbx+r15]
jnz short loc_215FF
loc_215D9:
cmp rcx, r15
lea rdx, [r15+1]
setz al
mov r15, rdx
cmp rsi, rdx
jnz short loc_215C7
jmp short loc_2164A
loc_215ED:
dec rsi
cmp rsi, r15
jnz short loc_21648
cmp byte ptr [rdi+r15], 2Ah ; '*'
setz al
jmp short loc_2164A
loc_215FF:
cmp al, 2Ah ; '*'
jnz short loc_21648
lea rcx, [rsi-1]
mov al, 1
cmp rcx, r15
jz short loc_2164A
add rbx, r15
sub r14, r15
lea r12, [rdi+r15]
inc r12
not r15
add r15, rsi
loc_21621:
mov rdi, r12; this
mov rsi, r15; char *
mov rdx, rbx; unsigned __int64
mov rcx, r14; char *
call _ZN5nglog5tools12SafeFNMatch_EPKcmS2_m; nglog::tools::SafeFNMatch_(char const*,ulong,char const*,ulong)
test al, al
jnz short loc_2164A
lea rcx, [r14-1]
inc rbx
cmp r14, 1
mov r14, rcx
jnz short loc_21621
jmp short loc_2164A
loc_21648:
xor eax, eax
loc_2164A:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
locret_21655:
retn
|
char nglog::tools::SafeFNMatch_(
nglog::tools *this,
const char *a2,
long long a3,
const char *a4,
unsigned long long a5)
{
char result; // al
const char *v7; // rcx
const char *v8; // r15
char v9; // al
unsigned long long v10; // rbx
const char *v11; // r14
nglog::tools *v12; // r12
const char *v13; // r15
result = a4 == 0LL;
if ( !a2 )
return result;
v7 = a4 - 1;
v8 = 0LL;
while ( 1 )
{
if ( (result & 1) != 0 )
{
if ( a2 - 1 == v8 )
return v8[(_QWORD)this] == 42;
return 0;
}
v9 = v8[(_QWORD)this];
if ( v9 != 63 && v9 != v8[a3] )
break;
result = v7 == v8++;
if ( a2 == v8 )
return result;
}
if ( v9 != 42 )
return 0;
result = 1;
if ( a2 - 1 != v8 )
{
v10 = (unsigned long long)&v8[a3];
v11 = (const char *)(a4 - v8);
v12 = (nglog::tools *)&v8[(_QWORD)this + 1];
v13 = &a2[~(unsigned long long)v8];
do
{
result = nglog::tools::SafeFNMatch_(v12, v13, v10, v11, a5);
if ( result )
break;
++v10;
--v11;
}
while ( v11 );
}
return result;
}
|
SafeFNMatch_:
TEST RCX,RCX
SETZ AL
TEST RSI,RSI
JZ 0x00121655
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV RBX,RDX
DEC RCX
XOR R15D,R15D
LAB_001215c7:
TEST AL,0x1
JNZ 0x001215ed
MOV AL,byte ptr [RDI + R15*0x1]
CMP AL,0x3f
JZ 0x001215d9
CMP AL,byte ptr [RBX + R15*0x1]
JNZ 0x001215ff
LAB_001215d9:
CMP RCX,R15
LEA RDX,[R15 + 0x1]
SETZ AL
MOV R15,RDX
CMP RSI,RDX
JNZ 0x001215c7
JMP 0x0012164a
LAB_001215ed:
DEC RSI
CMP RSI,R15
JNZ 0x00121648
CMP byte ptr [RDI + R15*0x1],0x2a
SETZ AL
JMP 0x0012164a
LAB_001215ff:
CMP AL,0x2a
JNZ 0x00121648
LEA RCX,[RSI + -0x1]
MOV AL,0x1
CMP RCX,R15
JZ 0x0012164a
ADD RBX,R15
SUB R14,R15
LEA R12,[RDI + R15*0x1]
INC R12
NOT R15
ADD R15,RSI
LAB_00121621:
MOV RDI,R12
MOV RSI,R15
MOV RDX,RBX
MOV RCX,R14
CALL 0x001215a4
TEST AL,AL
JNZ 0x0012164a
LEA RCX,[R14 + -0x1]
INC RBX
CMP R14,0x1
MOV R14,RCX
JNZ 0x00121621
JMP 0x0012164a
LAB_00121648:
XOR EAX,EAX
LAB_0012164a:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
LAB_00121655:
RET
|
/* nglog::tools::SafeFNMatch_(char const*, unsigned long, char const*, unsigned long) */
bool nglog::tools::SafeFNMatch_(char *param_1,ulong param_2,char *param_3,ulong param_4)
{
char cVar1;
char *pcVar2;
ulong uVar3;
ulong uVar4;
bool bVar5;
bVar5 = param_4 == 0;
if (param_2 == 0) {
return bVar5;
}
uVar4 = 0;
while( true ) {
if (bVar5) {
if (param_2 - 1 != uVar4) {
return false;
}
return param_1[uVar4] == '*';
}
cVar1 = param_1[uVar4];
if ((cVar1 != '?') && (cVar1 != param_3[uVar4])) break;
bVar5 = param_4 - 1 == uVar4;
uVar4 = uVar4 + 1;
if (param_2 == uVar4) {
return bVar5;
}
}
if (cVar1 != '*') {
return false;
}
if (param_2 - 1 != uVar4) {
pcVar2 = param_3 + uVar4;
uVar3 = param_4 - uVar4;
do {
cVar1 = SafeFNMatch_(param_1 + uVar4 + 1,~uVar4 + param_2,pcVar2,uVar3);
if (cVar1 != '\0') {
return (bool)cVar1;
}
pcVar2 = pcVar2 + 1;
bVar5 = uVar3 != 1;
uVar3 = uVar3 - 1;
} while (bVar5);
return false;
}
return true;
}
|
|
17,237
|
find_var_in_child_scope
|
bluesky950520[P]quickjs/quickjs.c
|
static int find_var_in_child_scope(JSContext *ctx, JSFunctionDef *fd,
JSAtom name, int scope_level)
{
int i;
for(i = 0; i < fd->var_count; i++) {
JSVarDef *vd = &fd->vars[i];
if (vd->var_name == name && vd->scope_level == 0) {
if (is_child_scope(ctx, fd, vd->scope_next,
scope_level))
return i;
}
}
return -1;
}
|
O0
|
c
|
find_var_in_child_scope:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0xa4(%rcx), %eax
jge 0xa66e2
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
cmpl 0x1c(%rsp), %eax
jne 0xa66d0
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xa66d0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edx
movl 0x18(%rsp), %ecx
callq 0xa6700
cmpl $0x0, %eax
je 0xa66ce
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0xa66ea
jmp 0xa66d0
jmp 0xa66d2
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xa665e
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
find_var_in_child_scope:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_1C], edx
mov [rsp+38h+var_20], ecx
mov [rsp+38h+var_24], 0
loc_A665E:
mov eax, [rsp+38h+var_24]
mov rcx, [rsp+38h+var_18]
cmp eax, [rcx+0A4h]
jge short loc_A66E2
mov rax, [rsp+38h+var_18]
mov rax, [rax+90h]
movsxd rcx, [rsp+38h+var_24]
shl rcx, 4
add rax, rcx
mov [rsp+38h+var_30], rax
mov rax, [rsp+38h+var_30]
mov eax, [rax]
cmp eax, [rsp+38h+var_1C]
jnz short loc_A66D0
mov rax, [rsp+38h+var_30]
cmp dword ptr [rax+4], 0
jnz short loc_A66D0
mov rdi, [rsp+38h+var_10]
mov rsi, [rsp+38h+var_18]
mov rax, [rsp+38h+var_30]
mov edx, [rax+8]
mov ecx, [rsp+38h+var_20]
call is_child_scope
cmp eax, 0
jz short loc_A66CE
mov eax, [rsp+38h+var_24]
mov [rsp+38h+var_4], eax
jmp short loc_A66EA
loc_A66CE:
jmp short $+2
loc_A66D0:
jmp short $+2
loc_A66D2:
mov eax, [rsp+38h+var_24]
add eax, 1
mov [rsp+38h+var_24], eax
jmp loc_A665E
loc_A66E2:
mov [rsp+38h+var_4], 0FFFFFFFFh
loc_A66EA:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
|
long long find_var_in_child_scope(long long a1, long long a2, int a3, unsigned int a4)
{
_DWORD *v5; // [rsp+8h] [rbp-30h]
unsigned int i; // [rsp+14h] [rbp-24h]
for ( i = 0; (signed int)i < *(_DWORD *)(a2 + 164); ++i )
{
v5 = (_DWORD *)(16LL * (int)i + *(_QWORD *)(a2 + 144));
if ( *v5 == a3 && !v5[1] && (unsigned int)is_child_scope(a1, a2, (unsigned int)v5[2], a4) )
return i;
}
return (unsigned int)-1;
}
|
find_var_in_child_scope:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV dword ptr [RSP + 0x1c],EDX
MOV dword ptr [RSP + 0x18],ECX
MOV dword ptr [RSP + 0x14],0x0
LAB_001a665e:
MOV EAX,dword ptr [RSP + 0x14]
MOV RCX,qword ptr [RSP + 0x20]
CMP EAX,dword ptr [RCX + 0xa4]
JGE 0x001a66e2
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x90]
MOVSXD RCX,dword ptr [RSP + 0x14]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RSP + 0x1c]
JNZ 0x001a66d0
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x4],0x0
JNZ 0x001a66d0
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x8]
MOV EDX,dword ptr [RAX + 0x8]
MOV ECX,dword ptr [RSP + 0x18]
CALL 0x001a6700
CMP EAX,0x0
JZ 0x001a66ce
MOV EAX,dword ptr [RSP + 0x14]
MOV dword ptr [RSP + 0x34],EAX
JMP 0x001a66ea
LAB_001a66ce:
JMP 0x001a66d0
LAB_001a66d0:
JMP 0x001a66d2
LAB_001a66d2:
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
JMP 0x001a665e
LAB_001a66e2:
MOV dword ptr [RSP + 0x34],0xffffffff
LAB_001a66ea:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int find_var_in_child_scope(int8 param_1,long param_2,int param_3,int4 param_4)
{
int iVar1;
int *piVar2;
int local_24;
local_24 = 0;
while( true ) {
if (*(int *)(param_2 + 0xa4) <= local_24) {
return -1;
}
piVar2 = (int *)(*(long *)(param_2 + 0x90) + (long)local_24 * 0x10);
if (((*piVar2 == param_3) && (piVar2[1] == 0)) &&
(iVar1 = is_child_scope(param_1,param_2,piVar2[2],param_4), iVar1 != 0)) break;
local_24 = local_24 + 1;
}
return local_24;
}
|
|
17,238
|
break_str_into_lines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
|
monkey531[P]llama/common/arg.cpp
|
static std::vector<std::string> break_str_into_lines(std::string input, size_t max_char_per_line) {
std::vector<std::string> result;
std::istringstream iss(input);
std::string line;
auto add_line = [&](const std::string& l) {
if (l.length() <= max_char_per_line) {
result.push_back(l);
} else {
std::istringstream line_stream(l);
std::string word, current_line;
while (line_stream >> word) {
if (current_line.length() + !current_line.empty() + word.length() > max_char_per_line) {
if (!current_line.empty()) result.push_back(current_line);
current_line = word;
} else {
current_line += (!current_line.empty() ? " " : "") + word;
}
}
if (!current_line.empty()) result.push_back(current_line);
}
};
while (std::getline(iss, line)) {
add_line(line);
}
return result;
}
|
O0
|
cpp
|
break_str_into_lines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long):
subq $0x208, %rsp # imm = 0x208
movq %rsi, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq %rdx, 0x1f0(%rsp)
movb $0x0, 0x1ef(%rsp)
callq 0x63a50
movq 0x20(%rsp), %rsi
leaq 0x68(%rsp), %rdi
movl $0x8, %edx
callq 0x5b900
jmp 0x6ec94
leaq 0x38(%rsp), %rdi
callq 0x5b640
movq 0x10(%rsp), %rax
leaq 0x1f0(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5ba00
movq %rax, 0x8(%rsp)
jmp 0x6eccb
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5b6b0
movb %al, 0x7(%rsp)
jmp 0x6ece5
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x6ecef
jmp 0x6ed36
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x88480
jmp 0x6ed00
jmp 0x6ecb5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x6ed73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5c7f8
leaq 0x68(%rsp), %rdi
callq 0x5bae0
jmp 0x6ed73
movb $0x1, 0x1ef(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5c7f8
leaq 0x68(%rsp), %rdi
callq 0x5bae0
testb $0x1, 0x1ef(%rsp)
jne 0x6ed66
movq 0x10(%rsp), %rdi
callq 0x63aa0
movq 0x18(%rsp), %rax
addq $0x208, %rsp # imm = 0x208
retq
movq 0x10(%rsp), %rdi
callq 0x63aa0
movq 0x60(%rsp), %rdi
callq 0x5bd10
nopw (%rax,%rax)
|
_ZL20break_str_into_linesNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm:
sub rsp, 208h
mov [rsp+208h+var_1E8], rsi
mov [rsp+208h+var_1F8], rdi
mov rax, rdi
mov [rsp+208h+var_1F0], rax
mov [rsp+208h+var_8], rdi
mov [rsp+208h+var_10], rsi
mov [rsp+208h+var_18], rdx
mov [rsp+208h+var_19], 0
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
mov rsi, [rsp+208h+var_1E8]
lea rdi, [rsp+208h+var_1A0]
mov edx, 8
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::istringstream::basic_istringstream(std::string const&,std::_Ios_Openmode)
jmp short $+2
loc_6EC94:
lea rdi, [rsp+208h+var_1D0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rax, [rsp+208h+var_1F8]
lea rcx, [rsp+208h+var_18]
mov [rsp+208h+var_1E0], rcx
mov [rsp+208h+var_1D8], rax
loc_6ECB5:
lea rdi, [rsp+208h+var_1A0]
lea rsi, [rsp+208h+var_1D0]
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &)
mov [rsp+208h+var_200], rax
jmp short $+2
loc_6ECCB:
mov rdi, [rsp+208h+var_200]
mov rax, [rdi]
mov rax, [rax-18h]
add rdi, rax
call __ZNKSt9basic_iosIcSt11char_traitsIcEEcvbEv; std::ios::operator bool(void)
mov [rsp+208h+var_201], al
jmp short $+2
loc_6ECE5:
mov al, [rsp+208h+var_201]
test al, 1
jnz short loc_6ECEF
jmp short loc_6ED36
loc_6ECEF:
lea rdi, [rsp+208h+var_1E0]
lea rsi, [rsp+208h+var_1D0]
call _ZZL20break_str_into_linesNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmENK3$_0clERKS4_; break_str_into_lines(std::string,ulong)::$_0::operator()(std::string const&)
jmp short $+2
loc_6ED00:
jmp short loc_6ECB5
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
jmp short loc_6ED73
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
lea rdi, [rsp+arg_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+arg_60]
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED1Ev; std::istringstream::~istringstream()
jmp short loc_6ED73
loc_6ED36:
mov [rsp+208h+var_19], 1
lea rdi, [rsp+208h+var_1D0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+208h+var_1A0]
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED1Ev; std::istringstream::~istringstream()
test [rsp+208h+var_19], 1
jnz short loc_6ED66
mov rdi, [rsp+208h+var_1F8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_6ED66:
mov rax, [rsp+208h+var_1F0]
add rsp, 208h
retn
loc_6ED73:
mov rdi, [rsp+arg_8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+arg_58]
call __Unwind_Resume
|
long long break_str_into_lines(long long a1, long long a2, long long a3)
{
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
int v8; // [rsp+0h] [rbp-208h]
_QWORD *v9; // [rsp+8h] [rbp-200h]
long long *v10; // [rsp+10h] [rbp-1F8h]
long long v11; // [rsp+18h] [rbp-1F0h]
char v12; // [rsp+20h] [rbp-1E8h]
_QWORD *v13; // [rsp+28h] [rbp-1E0h] BYREF
long long i; // [rsp+30h] [rbp-1D8h]
_DWORD v15[4]; // [rsp+38h] [rbp-1D0h] BYREF
long long v16; // [rsp+48h] [rbp-1C0h]
char v17; // [rsp+50h] [rbp-1B8h]
int v18; // [rsp+58h] [rbp-1B0h]
int v19; // [rsp+60h] [rbp-1A8h]
int v20; // [rsp+68h] [rbp-1A0h] BYREF
char v21; // [rsp+70h] [rbp-198h]
int v22; // [rsp+78h] [rbp-190h]
int v23; // [rsp+80h] [rbp-188h]
int v24; // [rsp+88h] [rbp-180h]
char v25; // [rsp+90h] [rbp-178h]
char v26; // [rsp+1EFh] [rbp-19h]
_QWORD v27[3]; // [rsp+1F0h] [rbp-18h] BYREF
v12 = a2;
v10 = (long long *)a1;
v11 = a1;
v27[2] = a1;
v27[1] = a2;
v27[0] = a3;
v26 = 0;
std::vector<std::string>::vector(a1);
std::istringstream::basic_istringstream(&v20, a2, 8LL);
std::string::basic_string(v15);
v13 = v27;
for ( i = a1;
;
break_str_into_lines(std::string,unsigned long)::$_0::operator()(
(unsigned int)&v13,
(unsigned int)v15,
v3,
v4,
v5,
v6,
v8,
(_DWORD)v9,
(_DWORD)v10,
v11,
v12,
(_DWORD)v13,
i,
v15[0],
v15[2],
v16,
v17,
v18,
v19,
v20,
v21,
v22,
v23,
v24,
v25) )
{
v9 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(&v20, v15);
if ( (std::ios::operator bool((char *)v9 + *(_QWORD *)(*v9 - 24LL)) & 1) == 0 )
break;
}
v26 = 1;
std::string::~string(v15);
std::istringstream::~istringstream(&v20);
if ( (v26 & 1) == 0 )
std::vector<std::string>::~vector(v10);
return v11;
}
|
break_str_into_lines:
SUB RSP,0x208
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x200],RDI
MOV qword ptr [RSP + 0x1f8],RSI
MOV qword ptr [RSP + 0x1f0],RDX
MOV byte ptr [RSP + 0x1ef],0x0
CALL 0x00163a50
MOV RSI,qword ptr [RSP + 0x20]
LAB_0016ec83:
LEA RDI,[RSP + 0x68]
MOV EDX,0x8
CALL 0x0015b900
JMP 0x0016ec94
LAB_0016ec94:
LEA RDI,[RSP + 0x38]
CALL 0x0015b640
MOV RAX,qword ptr [RSP + 0x10]
LEA RCX,[RSP + 0x1f0]
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RSP + 0x30],RAX
LAB_0016ecb5:
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x38]
CALL 0x0015ba00
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0016eccb
LAB_0016eccb:
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
ADD RDI,RAX
CALL 0x0015b6b0
MOV byte ptr [RSP + 0x7],AL
JMP 0x0016ece5
LAB_0016ece5:
MOV AL,byte ptr [RSP + 0x7]
TEST AL,0x1
JNZ 0x0016ecef
JMP 0x0016ed36
LAB_0016ecef:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x38]
CALL 0x00188480
LAB_0016ecfe:
JMP 0x0016ed00
LAB_0016ed00:
JMP 0x0016ecb5
LAB_0016ed36:
MOV byte ptr [RSP + 0x1ef],0x1
LEA RDI,[RSP + 0x38]
CALL 0x0015c7f8
LEA RDI,[RSP + 0x68]
CALL 0x0015bae0
TEST byte ptr [RSP + 0x1ef],0x1
JNZ 0x0016ed66
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00163aa0
LAB_0016ed66:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x208
RET
|
/* break_str_into_lines(std::__cxx11::string, unsigned long) */
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *
break_str_into_lines
(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *param_1,
int8 param_2,int8 param_3)
{
bool bVar1;
istream *piVar2;
int8 *local_1e0;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_1d8;
string local_1d0 [48];
istringstream local_1a0 [391];
byte local_19;
int8 local_18;
int8 local_10;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_8;
local_19 = 0;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector(param_1);
/* try { // try from 0016ec83 to 0016ec91 has its CatchHandler @ 0016ed02 */
std::__cxx11::istringstream::istringstream(local_1a0,param_2,8);
std::__cxx11::string::string(local_1d0);
local_1e0 = &local_18;
local_1d8 = param_1;
while( true ) {
/* try { // try from 0016ecb5 to 0016ecfd has its CatchHandler @ 0016ed12 */
piVar2 = std::getline<char,std::char_traits<char>,std::allocator<char>>
((istream *)local_1a0,local_1d0);
bVar1 = std::ios::operator_cast_to_bool((ios *)(piVar2 + *(long *)(*(long *)piVar2 + -0x18)));
if (!bVar1) break;
break_str_into_lines(std::__cxx11::string,unsigned_long)::$_0::operator()
((__0 *)&local_1e0,local_1d0);
}
local_19 = 1;
std::__cxx11::string::~string(local_1d0);
std::__cxx11::istringstream::~istringstream(local_1a0);
if ((local_19 & 1) == 0) {
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(param_1);
}
return param_1;
}
|
|
17,239
|
ma_free_root
|
eloqsql/libmariadb/libmariadb/ma_alloc.c
|
void ma_free_root(MA_MEM_ROOT *root, myf MyFlags)
{
reg1 MA_USED_MEM *next,*old;
if (!root)
return; /* purecov: inspected */
if (!(MyFlags & MY_KEEP_PREALLOC))
root->pre_alloc=0;
for ( next=root->used; next ;)
{
old=next; next= next->next ;
if (old != root->pre_alloc)
free(old);
}
for (next= root->free ; next ; )
{
old=next; next= next->next ;
if (old != root->pre_alloc)
free(old);
}
root->used=root->free=0;
if (root->pre_alloc)
{
root->free=root->pre_alloc;
root->free->left=root->pre_alloc->size-ALIGN_SIZE(sizeof(MA_USED_MEM));
root->free->next=0;
}
}
|
O0
|
c
|
ma_free_root:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4777b
jmp 0x47869
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x47792
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x477d1
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x477cf
movq -0x20(%rbp), %rdi
callq 0x361b0
jmp 0x4779e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4780f
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x4780d
movq -0x20(%rbp), %rdi
callq 0x361b0
jmp 0x477dc
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x47869
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
subq $0x18, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
|
ma_free_root:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
cmp [rbp+var_8], 0
jnz short loc_4777B
jmp loc_47869
loc_4777B:
mov eax, [rbp+var_C]
and eax, 1
cmp eax, 0
jnz short loc_47792
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 0
loc_47792:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_18], rax
loc_4779E:
cmp [rbp+var_18], 0
jz short loc_477D1
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
cmp rax, [rcx+10h]
jz short loc_477CF
mov rdi, [rbp+var_20]
call _free
loc_477CF:
jmp short loc_4779E
loc_477D1:
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
loc_477DC:
cmp [rbp+var_18], 0
jz short loc_4780F
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
cmp rax, [rcx+10h]
jz short loc_4780D
mov rdi, [rbp+var_20]
call _free
loc_4780D:
jmp short loc_477DC
loc_4780F:
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_8]
cmp qword ptr [rax+10h], 0
jz short loc_47869
mov rax, [rbp+var_8]
mov rcx, [rax+10h]
mov rax, [rbp+var_8]
mov [rax], rcx
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rcx, [rax+10h]
sub rcx, 18h
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rax+8], rcx
mov rax, [rbp+var_8]
mov rax, [rax]
mov qword ptr [rax], 0
loc_47869:
add rsp, 20h
pop rbp
retn
|
_QWORD * ma_free_root(_QWORD *a1, char a2)
{
_QWORD *result; // rax
_QWORD *v3; // [rsp+0h] [rbp-20h]
_QWORD *v4; // [rsp+0h] [rbp-20h]
_QWORD *v5; // [rsp+8h] [rbp-18h]
_QWORD *v6; // [rsp+8h] [rbp-18h]
if ( a1 )
{
if ( (a2 & 1) == 0 )
a1[2] = 0LL;
v5 = (_QWORD *)a1[1];
while ( v5 )
{
v3 = v5;
v5 = (_QWORD *)*v5;
if ( v3 != (_QWORD *)a1[2] )
free(v3);
}
v6 = (_QWORD *)*a1;
while ( v6 )
{
v4 = v6;
v6 = (_QWORD *)*v6;
if ( v4 != (_QWORD *)a1[2] )
free(v4);
}
*a1 = 0LL;
a1[1] = 0LL;
result = a1;
if ( a1[2] )
{
*a1 = a1[2];
*(_QWORD *)(*a1 + 8LL) = *(_QWORD *)(a1[2] + 16LL) - 24LL;
result = (_QWORD *)*a1;
*(_QWORD *)*a1 = 0LL;
}
}
return result;
}
|
ma_free_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0014777b
JMP 0x00147869
LAB_0014777b:
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x00147792
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x0
LAB_00147792:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
LAB_0014779e:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001477d1
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x10]
JZ 0x001477cf
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001361b0
LAB_001477cf:
JMP 0x0014779e
LAB_001477d1:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LAB_001477dc:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0014780f
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x10]
JZ 0x0014780d
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001361b0
LAB_0014780d:
JMP 0x001477dc
LAB_0014780f:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x00147869
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,0x18
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],0x0
LAB_00147869:
ADD RSP,0x20
POP RBP
RET
|
void ma_free_root(long *param_1,uint param_2)
{
int8 *puVar1;
int8 *local_20;
if (param_1 != (long *)0x0) {
if ((param_2 & 1) == 0) {
param_1[2] = 0;
}
puVar1 = (int8 *)param_1[1];
while (local_20 = puVar1, local_20 != (int8 *)0x0) {
puVar1 = (int8 *)*local_20;
if (local_20 != (int8 *)param_1[2]) {
free(local_20);
}
}
puVar1 = (int8 *)*param_1;
while (local_20 = puVar1, local_20 != (int8 *)0x0) {
puVar1 = (int8 *)*local_20;
if (local_20 != (int8 *)param_1[2]) {
free(local_20);
}
}
*param_1 = 0;
param_1[1] = 0;
if (param_1[2] != 0) {
*param_1 = param_1[2];
*(long *)(*param_1 + 8) = *(long *)(param_1[2] + 0x10) + -0x18;
*(int8 *)*param_1 = 0;
}
}
return;
}
|
|
17,240
|
js_proxy_revocable
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_proxy_revocable(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue proxy_obj, revoke_obj = JS_UNDEFINED, obj;
proxy_obj = js_proxy_constructor(ctx, JS_UNDEFINED, argc, argv);
if (JS_IsException(proxy_obj))
goto fail;
revoke_obj = js_proxy_revoke_constructor(ctx, proxy_obj);
if (JS_IsException(revoke_obj))
goto fail;
obj = JS_NewObject(ctx);
if (JS_IsException(obj))
goto fail;
// XXX: exceptions?
JS_DefinePropertyValue(ctx, obj, JS_ATOM_proxy, proxy_obj, JS_PROP_C_W_E);
JS_DefinePropertyValue(ctx, obj, JS_ATOM_revoke, revoke_obj, JS_PROP_C_W_E);
return obj;
fail:
JS_FreeValue(ctx, proxy_obj);
JS_FreeValue(ctx, revoke_obj);
return JS_EXCEPTION;
}
|
O0
|
c
|
js_proxy_revocable:
subq $0xb8, %rsp
movq %rsi, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rdi, 0x90(%rsp)
movl %ecx, 0x8c(%rsp)
movq %r8, 0x80(%rsp)
movq 0x815ab(%rip), %rax # 0x113b80
movq %rax, 0x60(%rsp)
movq 0x815a7(%rip), %rax # 0x113b88
movq %rax, 0x68(%rsp)
movq 0x90(%rsp), %rdi
movl $0x0, 0x30(%rsp)
movq $0x3, 0x38(%rsp)
movl 0x8c(%rsp), %ecx
movq 0x80(%rsp), %r8
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x58b40
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x92654
jmp 0x92759
movq 0x90(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x927c0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x926a2
jmp 0x92759
movq 0x90(%rsp), %rdi
callq 0x30860
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x926e3
jmp 0x92759
movq 0x90(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x70(%rsp), %r8
movq 0x78(%rsp), %r9
movl $0x84, %ecx
movl $0x7, (%rsp)
callq 0x3d4a0
movq 0x90(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x60(%rsp), %r8
movq 0x68(%rsp), %r9
movl $0x85, %ecx
movl $0x7, (%rsp)
callq 0x3d4a0
movq 0x50(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0xb0(%rsp)
jmp 0x9279e
movq 0x90(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x29f80
movq 0x90(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x29f80
movl $0x0, 0xa8(%rsp)
movq $0x6, 0xb0(%rsp)
movq 0xa8(%rsp), %rax
movq 0xb0(%rsp), %rdx
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
|
js_proxy_revocable:
sub rsp, 0B8h
mov [rsp+0B8h+var_20], rsi
mov [rsp+0B8h+var_18], rdx
mov [rsp+0B8h+var_28], rdi
mov [rsp+0B8h+var_2C], ecx
mov [rsp+0B8h+var_38], r8
mov rax, cs:qword_113B80
mov [rsp+0B8h+var_58], rax
mov rax, cs:qword_113B88
mov [rsp+0B8h+var_50], rax
mov rdi, [rsp+0B8h+var_28]
mov dword ptr [rsp+0B8h+var_88], 0
mov [rsp+0B8h+var_80], 3
mov ecx, [rsp+0B8h+var_2C]
mov r8, [rsp+0B8h+var_38]
mov rsi, [rsp+0B8h+var_88]
mov rdx, [rsp+0B8h+var_80]
call js_proxy_constructor
mov [rsp+0B8h+var_78], rax
mov [rsp+0B8h+var_70], rdx
mov rax, [rsp+0B8h+var_78]
mov [rsp+0B8h+var_48], rax
mov rax, [rsp+0B8h+var_70]
mov [rsp+0B8h+var_40], rax
mov rdi, [rsp+0B8h+var_48]
mov rsi, [rsp+0B8h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_92654
jmp loc_92759
loc_92654:
mov rdi, [rsp+0B8h+var_28]
mov rsi, [rsp+0B8h+var_48]
mov rdx, [rsp+0B8h+var_40]
call js_proxy_revoke_constructor
mov [rsp+0B8h+var_98], rax
mov [rsp+0B8h+var_90], rdx
mov rax, [rsp+0B8h+var_98]
mov [rsp+0B8h+var_58], rax
mov rax, [rsp+0B8h+var_90]
mov [rsp+0B8h+var_50], rax
mov rdi, [rsp+0B8h+var_58]
mov rsi, [rsp+0B8h+var_50]
call JS_IsException_1
cmp eax, 0
jz short loc_926A2
jmp loc_92759
loc_926A2:
mov rdi, [rsp+0B8h+var_28]
call JS_NewObject
mov [rsp+0B8h+var_A8], rax
mov [rsp+0B8h+var_A0], rdx
mov rax, [rsp+0B8h+var_A8]
mov [rsp+0B8h+var_68], rax
mov rax, [rsp+0B8h+var_A0]
mov [rsp+0B8h+var_60], rax
mov rdi, [rsp+0B8h+var_68]
mov rsi, [rsp+0B8h+var_60]
call JS_IsException_1
cmp eax, 0
jz short loc_926E3
jmp short loc_92759
loc_926E3:
mov rdi, [rsp+0B8h+var_28]
mov rsi, [rsp+0B8h+var_68]
mov rdx, [rsp+0B8h+var_60]
mov r8, [rsp+0B8h+var_48]
mov r9, [rsp+0B8h+var_40]
mov ecx, 84h
mov [rsp+0B8h+var_B8], 7
call JS_DefinePropertyValue
mov rdi, [rsp+0B8h+var_28]
mov rsi, [rsp+0B8h+var_68]
mov rdx, [rsp+0B8h+var_60]
mov r8, [rsp+0B8h+var_58]
mov r9, [rsp+0B8h+var_50]
mov ecx, 85h
mov [rsp+0B8h+var_B8], 7
call JS_DefinePropertyValue
mov rax, [rsp+0B8h+var_68]
mov [rsp+0B8h+var_10], rax
mov rax, [rsp+0B8h+var_60]
mov [rsp+0B8h+var_8], rax
jmp short loc_9279E
loc_92759:
mov rdi, [rsp+0B8h+var_28]
mov rsi, [rsp+0B8h+var_48]
mov rdx, [rsp+0B8h+var_40]
call JS_FreeValue
mov rdi, [rsp+0B8h+var_28]
mov rsi, [rsp+0B8h+var_58]
mov rdx, [rsp+0B8h+var_50]
call JS_FreeValue
mov dword ptr [rsp+0B8h+var_10], 0
mov [rsp+0B8h+var_8], 6
loc_9279E:
mov rax, [rsp+0B8h+var_10]
mov rdx, [rsp+0B8h+var_8]
add rsp, 0B8h
retn
|
long long js_proxy_revocable(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
unsigned int a12,
long long a13,
long long a14)
{
long long v14; // rdx
long long v15; // rdx
long long v16; // rdx
__m128 v17; // xmm4
__m128 v18; // xmm5
__m128 v19; // xmm4
__m128 v20; // xmm5
long long v22; // [rsp+10h] [rbp-A8h]
_DWORD *v23; // [rsp+20h] [rbp-98h]
long long v24; // [rsp+30h] [rbp-88h]
_DWORD *v25; // [rsp+40h] [rbp-78h]
long long v26; // [rsp+58h] [rbp-60h]
long long v27; // [rsp+60h] [rbp-58h]
long long v28; // [rsp+68h] [rbp-50h]
long long v29; // [rsp+78h] [rbp-40h]
long long v30; // [rsp+A8h] [rbp-10h]
v27 = 0LL;
v28 = 3LL;
LODWORD(v24) = 0;
v25 = (_DWORD *)js_proxy_constructor(a1, v24, 3LL, a2, a3, a4, a5, a6, a7, a8, a9, a12, a13, a14);
v29 = v14;
if ( JS_IsException_1((long long)v25, v14)
|| (v23 = (_DWORD *)js_proxy_revoke_constructor(a1, v25, v29),
v27 = (long long)v23,
v28 = v15,
JS_IsException_1((long long)v23, v15))
|| (v22 = JS_NewObject(a1), v26 = v16, JS_IsException_1(v22, v16)) )
{
JS_FreeValue(a1, (long long)v25, v29);
JS_FreeValue(a1, v27, v28);
LODWORD(v30) = 0;
}
else
{
JS_DefinePropertyValue(a1, v22, v26, 0x84u, v25, v29, a2, a3, a4, a5, v17, v18, a8, a9, 7);
JS_DefinePropertyValue(a1, v22, v26, 0x85u, v23, v28, a2, a3, a4, a5, v19, v20, a8, a9, 7);
return v22;
}
return v30;
}
|
js_proxy_revocable:
SUB RSP,0xb8
MOV qword ptr [RSP + 0x98],RSI
MOV qword ptr [RSP + 0xa0],RDX
MOV qword ptr [RSP + 0x90],RDI
MOV dword ptr [RSP + 0x8c],ECX
MOV qword ptr [RSP + 0x80],R8
MOV RAX,qword ptr [0x00213b80]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [0x00213b88]
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x90]
MOV dword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x38],0x3
MOV ECX,dword ptr [RSP + 0x8c]
MOV R8,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x00158b40
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x78]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x00192654
JMP 0x00192759
LAB_00192654:
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x001927c0
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x68]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001926a2
JMP 0x00192759
LAB_001926a2:
MOV RDI,qword ptr [RSP + 0x90]
CALL 0x00130860
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001926e3
JMP 0x00192759
LAB_001926e3:
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
MOV R8,qword ptr [RSP + 0x70]
MOV R9,qword ptr [RSP + 0x78]
MOV ECX,0x84
MOV dword ptr [RSP],0x7
CALL 0x0013d4a0
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
MOV R8,qword ptr [RSP + 0x60]
MOV R9,qword ptr [RSP + 0x68]
MOV ECX,0x85
MOV dword ptr [RSP],0x7
CALL 0x0013d4a0
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xb0],RAX
JMP 0x0019279e
LAB_00192759:
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
CALL 0x00129f80
MOV dword ptr [RSP + 0xa8],0x0
MOV qword ptr [RSP + 0xb0],0x6
LAB_0019279e:
MOV RAX,qword ptr [RSP + 0xa8]
MOV RDX,qword ptr [RSP + 0xb0]
ADD RSP,0xb8
RET
|
int1 [16]
js_proxy_revocable(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 param_5)
{
int iVar1;
int8 uVar3;
int1 auVar5 [16];
int1 auVar6 [16];
uint uStack_84;
int8 local_58;
int8 local_50;
int4 local_10;
int4 uStack_c;
int8 local_8;
int8 uVar2;
int8 uVar4;
auVar6._8_8_ = DAT_00213b88;
auVar6._0_8_ = DAT_00213b80;
auVar5 = js_proxy_constructor(param_1,(ulong)uStack_84 << 0x20,3,param_4,param_5);
uVar4 = auVar5._8_8_;
uVar2 = auVar5._0_8_;
iVar1 = JS_IsException(uVar2,uVar4);
if (iVar1 == 0) {
auVar6 = js_proxy_revoke_constructor(param_1,uVar2,uVar4);
iVar1 = JS_IsException(auVar6._0_8_,auVar6._8_8_);
if (iVar1 == 0) {
auVar5 = JS_NewObject(param_1);
local_8 = auVar5._8_8_;
uVar3 = auVar5._0_8_;
iVar1 = JS_IsException(uVar3,local_8);
if (iVar1 == 0) {
JS_DefinePropertyValue(param_1,uVar3,local_8,0x84,uVar2,uVar4,7);
JS_DefinePropertyValue(param_1,uVar3,local_8,0x85,auVar6._0_8_,auVar6._8_8_,7);
local_10 = auVar5._0_4_;
uStack_c = auVar5._4_4_;
goto LAB_0019279e;
}
}
}
local_50 = auVar6._8_8_;
local_58 = auVar6._0_8_;
JS_FreeValue(param_1,uVar2,uVar4);
JS_FreeValue(param_1,local_58,local_50);
local_10 = 0;
local_8 = 6;
LAB_0019279e:
auVar5._4_4_ = uStack_c;
auVar5._0_4_ = local_10;
auVar5._8_8_ = local_8;
return auVar5;
}
|
|
17,241
|
my_weight_utf32_general_ci
|
eloqsql/strings/ctype-ucs2.c
|
static inline int my_weight_utf32_general_ci(uchar b0, uchar b1,
uchar b2, uchar b3)
{
my_wc_t wc= MY_UTF32_WC4(b0, b1, b2, b3);
if (wc <= 0xFFFF)
{
MY_UNICASE_CHARACTER *page= my_unicase_default_pages[wc >> 8];
return (int) (page ? page[wc & 0xFF].sort : wc);
}
return MY_CS_REPLACEMENT_CHARACTER;
}
|
O0
|
c
|
my_weight_utf32_general_ci:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movb %dil, %sil
movb %sil, -0x5(%rbp)
movb %dl, -0x6(%rbp)
movb %cl, -0x7(%rbp)
movb %al, -0x8(%rbp)
movzbl -0x5(%rbp), %eax
shlq $0x18, %rax
movzbl -0x6(%rbp), %ecx
shll $0x10, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movzbl -0x7(%rbp), %ecx
shll $0x8, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movzbl -0x8(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpq $0xffff, -0x10(%rbp) # imm = 0xFFFF
ja 0x5fd90
movq -0x10(%rbp), %rcx
shrq $0x8, %rcx
leaq 0x308a6f(%rip), %rax # 0x3687c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5fd7f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
andq $0xff, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movq %rax, -0x20(%rbp)
jmp 0x5fd87
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x5fd97
movl $0xfffd, -0x4(%rbp) # imm = 0xFFFD
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
|
my_weight_utf32_general_ci:
push rbp
mov rbp, rsp
mov al, cl
mov cl, dl
mov dl, sil
mov sil, dil
mov [rbp+var_5], sil
mov [rbp+var_6], dl
mov [rbp+var_7], cl
mov [rbp+var_8], al
movzx eax, [rbp+var_5]
shl rax, 18h
movzx ecx, [rbp+var_6]
shl ecx, 10h
movsxd rcx, ecx
add rax, rcx
movzx ecx, [rbp+var_7]
shl ecx, 8
movsxd rcx, ecx
add rax, rcx
movzx ecx, [rbp+var_8]
add rax, rcx
mov [rbp+var_10], rax
cmp [rbp+var_10], 0FFFFh
ja short loc_5FD90
mov rcx, [rbp+var_10]
shr rcx, 8
lea rax, my_unicase_default_pages
mov rax, [rax+rcx*8]
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_5FD7F
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
and rcx, 0FFh
imul rcx, 0Ch
add rax, rcx
mov eax, [rax+8]
mov [rbp+var_20], rax
jmp short loc_5FD87
loc_5FD7F:
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
loc_5FD87:
mov rax, [rbp+var_20]
mov [rbp+var_4], eax
jmp short loc_5FD97
loc_5FD90:
mov [rbp+var_4], 0FFFDh
loc_5FD97:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_weight_utf32_general_ci(
unsigned __int8 a1,
unsigned __int8 a2,
unsigned __int8 a3,
unsigned __int8 a4)
{
long long v6; // [rsp+8h] [rbp-18h]
unsigned long long v7; // [rsp+10h] [rbp-10h]
v7 = a4 + (a3 << 8) + (a2 << 16) + ((unsigned long long)a1 << 24);
if ( v7 > 0xFFFF )
{
return 65533;
}
else
{
v6 = (long long)*(&my_unicase_default_pages + (v7 >> 8));
if ( v6 )
return *(unsigned int *)(12LL * a4 + v6 + 8);
else
return (unsigned int)(a4 + (a3 << 8) + (a2 << 16) + (a1 << 24));
}
}
|
my_weight_utf32_general_ci:
PUSH RBP
MOV RBP,RSP
MOV AL,CL
MOV CL,DL
MOV DL,SIL
MOV SIL,DIL
MOV byte ptr [RBP + -0x5],SIL
MOV byte ptr [RBP + -0x6],DL
MOV byte ptr [RBP + -0x7],CL
MOV byte ptr [RBP + -0x8],AL
MOVZX EAX,byte ptr [RBP + -0x5]
SHL RAX,0x18
MOVZX ECX,byte ptr [RBP + -0x6]
SHL ECX,0x10
MOVSXD RCX,ECX
ADD RAX,RCX
MOVZX ECX,byte ptr [RBP + -0x7]
SHL ECX,0x8
MOVSXD RCX,ECX
ADD RAX,RCX
MOVZX ECX,byte ptr [RBP + -0x8]
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0xffff
JA 0x0015fd90
MOV RCX,qword ptr [RBP + -0x10]
SHR RCX,0x8
LEA RAX,[0x4687c0]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0015fd7f
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
AND RCX,0xff
IMUL RCX,RCX,0xc
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0015fd87
LAB_0015fd7f:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
LAB_0015fd87:
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0015fd97
LAB_0015fd90:
MOV dword ptr [RBP + -0x4],0xfffd
LAB_0015fd97:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_weight_utf32_general_ci(byte param_1,byte param_2,byte param_3,byte param_4)
{
ulong local_28;
int4 local_c;
local_28 = (ulong)param_1 * 0x1000000 + (long)(int)((uint)param_2 << 0x10) +
(long)(int)((uint)param_3 << 8) + (ulong)param_4;
if (local_28 < 0x10000) {
if (*(long *)(my_unicase_default_pages + (local_28 >> 8) * 8) != 0) {
local_28 = (ulong)*(uint *)(*(long *)(my_unicase_default_pages + (local_28 >> 8) * 8) +
(local_28 & 0xff) * 0xc + 8);
}
local_c = (int4)local_28;
}
else {
local_c = 0xfffd;
}
return local_c;
}
|
|
17,242
|
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_12_0::detail::value_t)
|
shubhamoy[P]dir2txt/include/nlohmann/json.hpp
|
void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
{
//not initialized (e.g. due to exception in the ctor)
return;
}
if (t == value_t::array || t == value_t::object)
{
// flatten the current json_value to a heap-allocated stack
std::vector<basic_json> stack;
// move the top-level items to stack
if (t == value_t::array)
{
stack.reserve(array->size());
std::move(array->begin(), array->end(), std::back_inserter(stack));
}
else
{
stack.reserve(object->size());
for (auto&& it : *object)
{
stack.push_back(std::move(it.second));
}
}
while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
stack.pop_back();
// if current_item is array/object, move
// its children to the stack to be processed later
if (current_item.is_array())
{
std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
current_item.m_data.m_value.array->clear();
}
else if (current_item.is_object())
{
for (auto&& it : *current_item.m_data.m_value.object)
{
stack.push_back(std::move(it.second));
}
current_item.m_data.m_value.object->clear();
}
// it's now safe that current_item get destructed
// since it doesn't have any children
}
}
switch (t)
{
case value_t::object:
{
AllocatorType<object_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
break;
}
case value_t::array:
{
AllocatorType<array_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
break;
}
case value_t::string:
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
break;
}
case value_t::binary:
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
break;
}
case value_t::null:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::discarded:
default:
{
break;
}
}
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_12_0::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, %esi
sete %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x2be8e
movl %esi, %r14d
testq %rax, %rax
sete %cl
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
testb %cl, %sil
jne 0x2be8e
movq %rdi, %rbx
leal -0x1(%r14), %ecx
cmpb $0x1, %cl
ja 0x2be0e
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x4, %rsi
cmpb $0x2, %r14b
jne 0x2bcbd
movq %rsp, %rdi
callq 0x2bed2
movq (%rbx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
subq %r15, %r13
sarq $0x4, %r13
testq %r13, %r13
jle 0x2bcfe
incq %r13
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2c018
addq $0x10, %r15
decq %r13
cmpq $0x1, %r13
jg 0x2bca3
jmp 0x2bcfe
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rax
movq %rsp, %rdi
movq %rax, %rsi
callq 0x2bed2
movq (%rbx), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x2bcfe
movq %rsp, %r15
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x2c018
addq $0x30, %r12
cmpq %r13, %r12
jne 0x2bce8
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
je 0x2be06
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq -0x10(%r13), %rdi
movups -0x10(%r13), %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %esi, %esi
callq 0x2ab56
movb $0x0, -0x10(%r13)
movq $0x0, -0x8(%r13)
movq %r15, %rdi
movl $0x1, %esi
callq 0x2ab56
movq 0x8(%rsp), %r13
addq $-0x10, %r13
movq %r13, 0x8(%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x2ab56
movq %r13, %rdi
callq 0x2ac2c
movzbl 0x20(%rsp), %eax
cmpl $0x1, %eax
je 0x2bdb5
cmpl $0x2, %eax
jne 0x2bde5
movq 0x28(%rsp), %rax
movq (%rax), %r13
movq 0x8(%rax), %rbp
subq %r13, %rbp
sarq $0x4, %rbp
testq %rbp, %rbp
jle 0x2bda6
incq %rbp
movq %r12, %rdi
movq %r13, %rsi
callq 0x2c018
addq $0x10, %r13
decq %rbp
cmpq $0x1, %rbp
jg 0x2bd8e
movq 0x28(%rsp), %rdi
movq (%rdi), %rsi
callq 0x2c1bc
jmp 0x2bde5
movq 0x28(%rsp), %rax
movq (%rax), %r13
movq 0x8(%rax), %rbp
cmpq %rbp, %r13
je 0x2bdd8
leaq 0x20(%r13), %rsi
movq %r12, %rdi
callq 0x2c018
addq $0x30, %r13
jmp 0x2bdc1
movq 0x28(%rsp), %rdi
movq (%rdi), %rsi
callq 0x2c202
movq %r15, %rdi
xorl %esi, %esi
callq 0x2ab56
movq %r15, %rdi
callq 0x2ac2c
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
jne 0x2bd15
movq %rsp, %rdi
callq 0x2bf66
movzbl %r14b, %eax
decl %eax
cmpl $0x7, %eax
ja 0x2be8e
leaq 0xb248(%rip), %rcx # 0x37068
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x2c268
movl $0x20, %r14d
jmp 0x2be83
movq (%rbx), %rax
movq (%rax), %rdi
addq $0x10, %rax
movl $0x20, %r14d
cmpq %rax, %rdi
je 0x2be83
movq (%rax), %rsi
incq %rsi
jmp 0x2be7e
movq (%rbx), %rdi
callq 0x2bf66
movl $0x18, %r14d
jmp 0x2be83
movq (%rbx), %rax
movq (%rax), %rdi
movl $0x28, %r14d
testq %rdi, %rdi
je 0x2be83
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x8380
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x8380
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2bea1
jmp 0x2bea1
movq %rax, %rbx
jmp 0x2bec2
jmp 0x2bea8
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2ab56
movq %r14, %rdi
callq 0x2ac2c
movq %rsp, %rdi
callq 0x2bf66
movq %rbx, %rdi
callq 0x85d0
|
_ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
cmp esi, 1
setz cl
mov rax, [rdi]
test rax, rax
setz dl
test cl, dl
jnz def_2BE27; jumptable 000000000002BE27 default case, cases 4-7
mov r14d, esi
test rax, rax
setz cl
mov edx, r14d
and dl, 0FEh
cmp dl, 2
setz dl
cmp r14b, 8
setz sil
or sil, dl
test sil, cl
jnz def_2BE27; jumptable 000000000002BE27 default case, cases 4-7
mov rbx, rdi
lea ecx, [r14-1]
cmp cl, 1
ja loc_2BE0E
xorps xmm0, xmm0
movaps [rsp+68h+var_68], xmm0
mov [rsp+68h+var_58], 0
mov rsi, [rax+8]
sub rsi, [rax]
sar rsi, 4
cmp r14b, 2
jnz short loc_2BCBD
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r15, [rax]
mov r13, [rax+8]
sub r13, r15
sar r13, 4
test r13, r13
jle short loc_2BCFE
inc r13
mov r12, rsp
loc_2BCA3:
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> &&)
add r15, 10h
dec r13
cmp r13, 1
jg short loc_2BCA3
jmp short loc_2BCFE
loc_2BCBD:
mov rax, 0AAAAAAAAAAAAAAABh
imul rax, rsi
mov rdi, rsp
mov rsi, rax
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r12, [rax]
mov r13, [rax+8]
cmp r12, r13
jz short loc_2BCFE
mov r15, rsp
loc_2BCE8:
lea rsi, [r12+20h]
mov rdi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> &&)
add r12, 30h ; '0'
cmp r12, r13
jnz short loc_2BCE8
loc_2BCFE:
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jz loc_2BE06
lea r15, [rsp+68h+var_48]
mov r12, rsp
loc_2BD15:
lea rdi, [r13-10h]
movups xmm0, xmmword ptr [r13-10h]
movaps [rsp+68h+var_48], xmm0
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r13-10h], 0
mov qword ptr [r13-8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov r13, qword ptr [rsp+68h+var_68+8]
add r13, 0FFFFFFFFFFFFFFF0h
mov qword ptr [rsp+68h+var_68+8], r13
mov rdi, r13
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
movzx eax, byte ptr [rsp+68h+var_48]
cmp eax, 1
jz short loc_2BDB5
cmp eax, 2
jnz short loc_2BDE5
mov rax, qword ptr [rsp+68h+var_48+8]
mov r13, [rax]
mov rbp, [rax+8]
sub rbp, r13
sar rbp, 4
test rbp, rbp
jle short loc_2BDA6
inc rbp
loc_2BD8E:
mov rdi, r12
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> &&)
add r13, 10h
dec rbp
cmp rbp, 1
jg short loc_2BD8E
loc_2BDA6:
mov rdi, qword ptr [rsp+68h+var_48+8]
mov rsi, [rdi]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE15_M_erase_at_endEPSD_; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::_M_erase_at_end(nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>*)
jmp short loc_2BDE5
loc_2BDB5:
mov rax, qword ptr [rsp+68h+var_48+8]
mov r13, [rax]
mov rbp, [rax+8]
loc_2BDC1:
cmp r13, rbp
jz short loc_2BDD8
lea rsi, [r13+20h]
mov rdi, r12
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> &&)
add r13, 30h ; '0'
jmp short loc_2BDC1
loc_2BDD8:
mov rdi, qword ptr [rsp+68h+var_48+8]
mov rsi, [rdi]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_12_010basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE15_M_erase_at_endEPSG_; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>::_M_erase_at_end(std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>*)
loc_2BDE5:
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jnz loc_2BD15
loc_2BE06:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::~vector()
loc_2BE0E:
movzx eax, r14b
dec eax; switch 8 cases
cmp eax, 7
ja short def_2BE27; jumptable 000000000002BE27 default case, cases 4-7
lea rcx, jpt_2BE27
movsxd rax, ds:(jpt_2BE27 - 37068h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_2BE29:
mov rdi, [rbx]; jumptable 000000000002BE27 case 1
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_12_010basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EED2Ev; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>::~vector()
mov r14d, 20h ; ' '
jmp short loc_2BE83
loc_2BE39:
mov rax, [rbx]; jumptable 000000000002BE27 case 3
mov rdi, [rax]
add rax, 10h
mov r14d, 20h ; ' '
cmp rdi, rax
jz short loc_2BE83
mov rsi, [rax]
inc rsi
jmp short loc_2BE7E
loc_2BE56:
mov rdi, [rbx]; jumptable 000000000002BE27 case 2
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::~vector()
mov r14d, 18h
jmp short loc_2BE83
loc_2BE66:
mov rax, [rbx]; jumptable 000000000002BE27 case 8
mov rdi, [rax]; void *
mov r14d, 28h ; '('
test rdi, rdi
jz short loc_2BE83
mov rsi, [rax+10h]
sub rsi, rdi; unsigned __int64
loc_2BE7E:
call __ZdlPvm; operator delete(void *,ulong)
loc_2BE83:
mov rdi, [rbx]; void *
mov rsi, r14; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
def_2BE27:
add rsp, 38h; jumptable 000000000002BE27 default case, cases 4-7
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_2BEA1
jmp short $+2
loc_2BEA1:
mov rbx, rax
jmp short loc_2BEC2
jmp short $+2
loc_2BEA8:
mov rbx, rax
lea r14, [rsp+arg_18]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_2BEC2:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, rbx
call __Unwind_Resume
|
void nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::json_value::destroy(
void **a1,
int a2)
{
_QWORD *v2; // rax
char v3; // r14
long long v5; // rsi
long long v6; // r15
long long v7; // r13
long long v8; // r13
long long v9; // r12
long long i; // r13
long long j; // r13
char *v12; // r13
long long v13; // r13
long long v14; // rbp
long long v15; // rbp
long long v16; // r13
long long v17; // rbp
unsigned long long v18; // r14
_BYTE *v19; // rdi
_QWORD *v20; // rax
unsigned long long v21; // rsi
void **v22; // rax
__int128 v23; // [rsp+0h] [rbp-68h] BYREF
long long v24; // [rsp+10h] [rbp-58h]
_OWORD v25[4]; // [rsp+20h] [rbp-48h] BYREF
v2 = *a1;
if ( *a1 != 0LL || a2 != 1 )
{
v3 = a2;
if ( v2 != 0LL || (a2 & 0xFE) != 2 && (_BYTE)a2 != 8 )
{
if ( (unsigned __int8)(a2 - 1) <= 1u )
{
v23 = 0LL;
v24 = 0LL;
v5 = (long long)(v2[1] - *v2) >> 4;
if ( v3 == 2 )
{
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v23,
v5);
v6 = *(_QWORD *)*a1;
v7 = (*((_QWORD *)*a1 + 1) - v6) >> 4;
if ( v7 > 0 )
{
v8 = v7 + 1;
do
{
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>(
&v23,
v6);
v6 += 16LL;
--v8;
}
while ( v8 > 1 );
}
}
else
{
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v23,
0xAAAAAAAAAAAAAAABLL * v5);
v9 = *(_QWORD *)*a1;
for ( i = *((_QWORD *)*a1 + 1); v9 != i; v9 += 48LL )
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>(
&v23,
v9 + 32);
}
for ( j = *((_QWORD *)&v23 + 1); (_QWORD)v23 != *((_QWORD *)&v23 + 1); j = *((_QWORD *)&v23 + 1) )
{
v25[0] = *(_OWORD *)(j - 16);
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(j - 16));
*(_BYTE *)(j - 16) = 0;
*(_QWORD *)(j - 8) = 0LL;
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v25);
v12 = (char *)(*((_QWORD *)&v23 + 1) - 16LL);
*((_QWORD *)&v23 + 1) = v12;
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v12);
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::data::~data(v12);
if ( LOBYTE(v25[0]) == 1 )
{
v16 = **((_QWORD **)&v25[0] + 1);
v17 = *(_QWORD *)(*((_QWORD *)&v25[0] + 1) + 8LL);
while ( v16 != v17 )
{
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>(
&v23,
v16 + 32);
v16 += 48LL;
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>>::_M_erase_at_end(
*((_QWORD *)&v25[0] + 1),
**((_QWORD **)&v25[0] + 1));
}
else if ( LOBYTE(v25[0]) == 2 )
{
v13 = **((_QWORD **)&v25[0] + 1);
v14 = (long long)(*(_QWORD *)(*((_QWORD *)&v25[0] + 1) + 8LL) - **((_QWORD **)&v25[0] + 1)) >> 4;
if ( v14 > 0 )
{
v15 = v14 + 1;
do
{
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>(
&v23,
v13);
v13 += 16LL;
--v15;
}
while ( v15 > 1 );
}
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::_M_erase_at_end(
*((_QWORD *)&v25[0] + 1),
**((_QWORD **)&v25[0] + 1));
}
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v25);
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::data::~data(v25);
}
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::~vector(&v23);
}
switch ( v3 )
{
case 1:
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>>::~vector(*a1);
v18 = 32LL;
goto LABEL_32;
case 2:
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::~vector(*a1);
v18 = 24LL;
goto LABEL_32;
case 3:
v19 = *(_BYTE **)*a1;
v20 = (char *)*a1 + 16;
v18 = 32LL;
if ( v19 == (_BYTE *)v20 )
goto LABEL_32;
v21 = *v20 + 1LL;
break;
case 8:
v22 = (void **)*a1;
v19 = *(_BYTE **)*a1;
v18 = 40LL;
if ( !v19 )
goto LABEL_32;
v21 = (_BYTE *)v22[2] - v19;
break;
default:
return;
}
operator delete(v19, v21);
LABEL_32:
operator delete(*a1, v18);
}
}
}
|
destroy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
CMP ESI,0x1
SETZ CL
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
SETZ DL
TEST CL,DL
JNZ 0x0012be8e
MOV R14D,ESI
TEST RAX,RAX
SETZ CL
MOV EDX,R14D
AND DL,0xfe
CMP DL,0x2
SETZ DL
CMP R14B,0x8
SETZ SIL
OR SIL,DL
TEST SIL,CL
JNZ 0x0012be8e
MOV RBX,RDI
LEA ECX,[R14 + -0x1]
CMP CL,0x1
JA 0x0012be0e
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,qword ptr [RAX]
SAR RSI,0x4
CMP R14B,0x2
JNZ 0x0012bcbd
LAB_0012bc7f:
MOV RDI,RSP
CALL 0x0012bed2
MOV RAX,qword ptr [RBX]
MOV R15,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
SUB R13,R15
SAR R13,0x4
TEST R13,R13
JLE 0x0012bcfe
INC R13
MOV R12,RSP
LAB_0012bca3:
MOV RDI,R12
MOV RSI,R15
CALL 0x0012c018
ADD R15,0x10
DEC R13
CMP R13,0x1
JG 0x0012bca3
JMP 0x0012bcfe
LAB_0012bcbd:
MOV RAX,-0x5555555555555555
IMUL RAX,RSI
LAB_0012bccb:
MOV RDI,RSP
MOV RSI,RAX
CALL 0x0012bed2
MOV RAX,qword ptr [RBX]
MOV R12,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
CMP R12,R13
JZ 0x0012bcfe
MOV R15,RSP
LAB_0012bce8:
LEA RSI,[R12 + 0x20]
LAB_0012bced:
MOV RDI,R15
CALL 0x0012c018
ADD R12,0x30
CMP R12,R13
JNZ 0x0012bce8
LAB_0012bcfe:
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JZ 0x0012be06
LEA R15,[RSP + 0x20]
MOV R12,RSP
LAB_0012bd15:
LEA RDI,[R13 + -0x10]
MOVUPS XMM0,xmmword ptr [R13 + -0x10]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
XOR ESI,ESI
CALL 0x0012ab56
MOV byte ptr [R13 + -0x10],0x0
MOV qword ptr [R13 + -0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x0012ab56
MOV R13,qword ptr [RSP + 0x8]
ADD R13,-0x10
MOV qword ptr [RSP + 0x8],R13
MOV RDI,R13
XOR ESI,ESI
CALL 0x0012ab56
MOV RDI,R13
CALL 0x0012ac2c
MOVZX EAX,byte ptr [RSP + 0x20]
CMP EAX,0x1
JZ 0x0012bdb5
CMP EAX,0x2
JNZ 0x0012bde5
MOV RAX,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RAX]
MOV RBP,qword ptr [RAX + 0x8]
SUB RBP,R13
SAR RBP,0x4
TEST RBP,RBP
JLE 0x0012bda6
INC RBP
LAB_0012bd8e:
MOV RDI,R12
MOV RSI,R13
CALL 0x0012c018
ADD R13,0x10
DEC RBP
CMP RBP,0x1
JG 0x0012bd8e
LAB_0012bda6:
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RDI]
CALL 0x0012c1bc
JMP 0x0012bde5
LAB_0012bdb5:
MOV RAX,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RAX]
MOV RBP,qword ptr [RAX + 0x8]
LAB_0012bdc1:
CMP R13,RBP
JZ 0x0012bdd8
LEA RSI,[R13 + 0x20]
LAB_0012bdca:
MOV RDI,R12
CALL 0x0012c018
LAB_0012bdd2:
ADD R13,0x30
JMP 0x0012bdc1
LAB_0012bdd8:
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RDI]
CALL 0x0012c202
LAB_0012bde5:
MOV RDI,R15
XOR ESI,ESI
CALL 0x0012ab56
MOV RDI,R15
CALL 0x0012ac2c
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JNZ 0x0012bd15
LAB_0012be06:
MOV RDI,RSP
CALL 0x0012bf66
LAB_0012be0e:
MOVZX EAX,R14B
DEC EAX
CMP EAX,0x7
JA 0x0012be8e
LEA RCX,[0x137068]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBX]
CALL 0x0012c268
MOV R14D,0x20
JMP 0x0012be83
caseD_3:
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RAX]
ADD RAX,0x10
MOV R14D,0x20
CMP RDI,RAX
JZ 0x0012be83
MOV RSI,qword ptr [RAX]
INC RSI
JMP 0x0012be7e
caseD_2:
MOV RDI,qword ptr [RBX]
CALL 0x0012bf66
MOV R14D,0x18
JMP 0x0012be83
caseD_8:
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RAX]
MOV R14D,0x28
TEST RDI,RDI
JZ 0x0012be83
MOV RSI,qword ptr [RAX + 0x10]
SUB RSI,RDI
LAB_0012be7e:
CALL 0x00108380
LAB_0012be83:
MOV RDI,qword ptr [RBX]
MOV RSI,R14
CALL 0x00108380
caseD_4:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::json_value::destroy(nlohmann::json_abi_v3_12_0::detail::value_t) */
void __thiscall
nlohmann::json_abi_v3_12_0::
basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy(json_value *this,uint param_2)
{
long lVar1;
long *plVar2;
byte bVar3;
ulong uVar4;
ulong uVar5;
bool bVar6;
long *plVar7;
long lVar8;
data *pdVar9;
basic_json *pbVar10;
data *local_68;
data *pdStack_60;
int8 local_58;
int8 local_48;
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*pvStack_40;
plVar7 = *(long **)this;
if (param_2 == 1 && plVar7 == (long *)0x0) {
return;
}
bVar3 = (byte)param_2;
if ((bVar3 == 8 || (bVar3 & 0xfe) == 2) && plVar7 == (long *)0x0) {
return;
}
if ((byte)(bVar3 - 1) < 2) {
local_68 = (data *)0x0;
pdStack_60 = (data *)0x0;
local_58 = 0;
uVar4 = plVar7[1] - *plVar7 >> 4;
if (bVar3 == 2) {
/* try { // try from 0012bc7f to 0012bc86 has its CatchHandler @ 0012be9d */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,uVar4);
pbVar10 = (basic_json *)**(long **)this;
lVar8 = (*(long **)this)[1] - (long)pbVar10 >> 4;
if (0 < lVar8) {
lVar8 = lVar8 + 1;
do {
/* try { // try from 0012bca3 to 0012bcad has its CatchHandler @ 0012bea1 */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar10);
pbVar10 = pbVar10 + 0x10;
lVar8 = lVar8 + -1;
} while (1 < lVar8);
}
}
else {
/* try { // try from 0012bccb to 0012bcd5 has its CatchHandler @ 0012be9d */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,uVar4 * -0x5555555555555555);
lVar1 = (*(long **)this)[1];
for (lVar8 = **(long **)this; lVar8 != lVar1; lVar8 = lVar8 + 0x30) {
/* try { // try from 0012bced to 0012bcf4 has its CatchHandler @ 0012be9f */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(lVar8 + 0x20));
}
}
if (local_68 != pdStack_60) {
do {
pdVar9 = pdStack_60;
local_48 = *(int8 *)(pdStack_60 + -0x10);
pvStack_40 = *(vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pdStack_60 + -8);
assert_invariant((bool)((char)pdStack_60 + -0x10));
pdVar9[-0x10] = (data)0x0;
*(int8 *)(pdVar9 + -8) = 0;
bVar6 = SUB81((data *)&local_48,0);
assert_invariant(bVar6);
pdVar9 = pdStack_60 + -0x10;
pdStack_60 = pdVar9;
assert_invariant(SUB81(pdVar9,0));
data::~data(pdVar9);
if (local_48._0_1_ == (data)0x1) {
lVar1 = *(long *)(pvStack_40 + 8);
for (lVar8 = *(long *)pvStack_40; lVar8 != lVar1; lVar8 = lVar8 + 0x30) {
/* try { // try from 0012bdca to 0012bdd1 has its CatchHandler @ 0012bea8 */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(lVar8 + 0x20));
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::_M_erase_at_end((vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)pvStack_40,*(pair **)pvStack_40);
}
else if (local_48._0_1_ == (data)0x2) {
pbVar10 = *(basic_json **)pvStack_40;
lVar8 = *(long *)(pvStack_40 + 8) - (long)pbVar10 >> 4;
if (0 < lVar8) {
lVar8 = lVar8 + 1;
do {
/* try { // try from 0012bd8e to 0012bd98 has its CatchHandler @ 0012bea6 */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar10);
pbVar10 = pbVar10 + 0x10;
lVar8 = lVar8 + -1;
} while (1 < lVar8);
}
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::_M_erase_at_end(pvStack_40,*(basic_json **)pvStack_40);
}
assert_invariant(bVar6);
data::~data((data *)&local_48);
} while (local_68 != pdStack_60);
}
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector((vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68);
}
switch(param_2 & 0xff) {
case 1:
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::~vector(*(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)this);
uVar4 = 0x20;
break;
case 2:
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector(*(vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)this);
uVar4 = 0x18;
break;
case 3:
plVar7 = (long *)**(long **)this;
plVar2 = *(long **)this + 2;
uVar4 = 0x20;
if (plVar7 != plVar2) {
uVar5 = *plVar2 + 1;
LAB_0012be7e:
operator_delete(plVar7,uVar5);
}
break;
default:
goto switchD_0012be27_caseD_4;
case 8:
plVar7 = (long *)**(long **)this;
uVar4 = 0x28;
if (plVar7 != (long *)0x0) {
uVar5 = (*(long **)this)[2] - (long)plVar7;
goto LAB_0012be7e;
}
}
operator_delete(*(void **)this,uVar4);
switchD_0012be27_caseD_4:
return;
}
|
|
17,243
|
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_12_0::detail::value_t)
|
shubhamoy[P]dir2txt/include/nlohmann/json.hpp
|
void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
{
//not initialized (e.g. due to exception in the ctor)
return;
}
if (t == value_t::array || t == value_t::object)
{
// flatten the current json_value to a heap-allocated stack
std::vector<basic_json> stack;
// move the top-level items to stack
if (t == value_t::array)
{
stack.reserve(array->size());
std::move(array->begin(), array->end(), std::back_inserter(stack));
}
else
{
stack.reserve(object->size());
for (auto&& it : *object)
{
stack.push_back(std::move(it.second));
}
}
while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
stack.pop_back();
// if current_item is array/object, move
// its children to the stack to be processed later
if (current_item.is_array())
{
std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
current_item.m_data.m_value.array->clear();
}
else if (current_item.is_object())
{
for (auto&& it : *current_item.m_data.m_value.object)
{
stack.push_back(std::move(it.second));
}
current_item.m_data.m_value.object->clear();
}
// it's now safe that current_item get destructed
// since it doesn't have any children
}
}
switch (t)
{
case value_t::object:
{
AllocatorType<object_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
break;
}
case value_t::array:
{
AllocatorType<array_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
break;
}
case value_t::string:
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
break;
}
case value_t::binary:
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
break;
}
case value_t::null:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::discarded:
default:
{
break;
}
}
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_12_0::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %esi
sete %al
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testb %dl, %al
jne 0x26e6a
movl %esi, %r14d
testq %rcx, %rcx
sete %al
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
testb %al, %sil
jne 0x26e6a
movq %rdi, %rbx
leal -0x1(%r14), %eax
cmpb $0x1, %al
ja 0x26dd8
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq 0x8(%rcx), %rax
subq (%rcx), %rax
cmpb $0x2, %r14b
jne 0x26e01
sarq $0x4, %rax
movq %rsp, %rdi
movq %rax, %rsi
callq 0x26ea0
movq (%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %rsp, %rdx
callq 0x26fb8
leaq 0x18(%rsp), %r15
movq %rsp, %r12
movq 0x8(%rsp), %rsi
cmpq %rsi, (%rsp)
je 0x26dd0
addq $-0x10, %rsi
movq %r15, %rdi
callq 0x261a6
movq 0x8(%rsp), %rdi
addq $-0x10, %rdi
movq %rdi, 0x8(%rsp)
callq 0x23c38
movzbl 0x18(%rsp), %eax
cmpl $0x1, %eax
je 0x26d93
cmpl $0x2, %eax
jne 0x26dc3
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %r12, %rdx
callq 0x26fb8
movq 0x20(%rsp), %rdi
callq 0x26f34
jmp 0x26dc3
movq 0x20(%rsp), %rax
movq (%rax), %r13
movq 0x8(%rax), %rbp
cmpq %rbp, %r13
je 0x26db9
addq $0x20, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x26ff0
addq $0x10, %r13
jmp 0x26d9f
movq 0x20(%rsp), %rdi
callq 0x26f3c
movq %r15, %rdi
callq 0x23c38
jmp 0x26d36
movq %rsp, %rdi
callq 0x26f44
movzbl %r14b, %eax
decl %eax
cmpl $0x7, %eax
ja 0x26e6a
leaq 0xa2ca(%rip), %rcx # 0x310b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x2718a
jmp 0x26e47
pushq $0x30
popq %rcx
cqto
idivq %rcx
movq %rsp, %rdi
movq %rax, %rsi
callq 0x26ea0
movq (%rbx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
movq %rsp, %r12
cmpq %r13, %r15
je 0x26d2e
addq $0x20, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x26ff0
addq $0x10, %r15
jmp 0x26e21
movq (%rbx), %rdi
callq 0x8e46
pushq $0x20
jmp 0x26e61
movq (%rbx), %rdi
callq 0x26f44
pushq $0x18
jmp 0x26e61
movq (%rbx), %rdi
callq 0x24e62
pushq $0x28
popq %rsi
movq (%rbx), %rdi
callq 0x83b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26e7d
jmp 0x26e82
movq %rax, %rbx
jmp 0x26e8f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x23c38
movq %rsp, %rdi
callq 0x26f44
movq %rbx, %rdi
callq 0x85e0
nop
|
_ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
cmp esi, 1
setz al
mov rcx, [rdi]
test rcx, rcx
setz dl
test al, dl
jnz def_26DF5; jumptable 0000000000026DF5 default case, cases 4-7
mov r14d, esi
test rcx, rcx
setz al
mov edx, r14d
and dl, 0FEh
cmp dl, 2
setz dl
cmp r14b, 8
setz sil
or sil, dl
test sil, al
jnz def_26DF5; jumptable 0000000000026DF5 default case, cases 4-7
mov rbx, rdi
lea eax, [r14-1]
cmp al, 1
ja loc_26DD8
xorps xmm0, xmm0
movaps [rsp+58h+var_58], xmm0
and [rsp+58h+var_48], 0
mov rax, [rcx+8]
sub rax, [rcx]
cmp r14b, 2
jnz loc_26E01
sar rax, 4
mov rdi, rsp
mov rsi, rax
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov rdi, [rax]
mov rsi, [rax+8]
mov rdx, rsp
call _ZNSt11__copy_moveILb1ELb0ESt26random_access_iterator_tagE8__copy_mIPN8nlohmann16json_abi_v3_12_010basic_jsonINS4_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS4_14adl_serializerES7_IhSaIhEEvEESt20back_insert_iteratorIS7_ISH_SaISH_EEEEET0_T_SO_SN_; std::__copy_move<true,false,std::random_access_iterator_tag>::__copy_m<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>>(nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> *,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>)
loc_26D2E:
lea r15, [rsp+58h+var_40]
mov r12, rsp
loc_26D36:
mov rsi, qword ptr [rsp+58h+var_58+8]
cmp qword ptr [rsp+58h+var_58], rsi
jz loc_26DD0
add rsi, 0FFFFFFFFFFFFFFF0h
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>&&)
mov rdi, qword ptr [rsp+58h+var_58+8]
add rdi, 0FFFFFFFFFFFFFFF0h
mov qword ptr [rsp+58h+var_58+8], rdi
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::~basic_json()
movzx eax, [rsp+58h+var_40]
cmp eax, 1
jz short loc_26D93
cmp eax, 2
jnz short loc_26DC3
mov rax, [rsp+58h+var_38]
mov rdi, [rax]
mov rsi, [rax+8]
mov rdx, r12
call _ZNSt11__copy_moveILb1ELb0ESt26random_access_iterator_tagE8__copy_mIPN8nlohmann16json_abi_v3_12_010basic_jsonINS4_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS4_14adl_serializerES7_IhSaIhEEvEESt20back_insert_iteratorIS7_ISH_SaISH_EEEEET0_T_SO_SN_; std::__copy_move<true,false,std::random_access_iterator_tag>::__copy_m<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>>(nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> *,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>)
mov rdi, [rsp+58h+var_38]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE5clearEv; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::clear(void)
jmp short loc_26DC3
loc_26D93:
mov rax, [rsp+58h+var_38]
mov r13, [rax]
mov rbp, [rax+8]
loc_26D9F:
cmp r13, rbp
jz short loc_26DB9
add r13, 20h ; ' '
mov rdi, r12
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> &&)
add r13, 10h
jmp short loc_26D9F
loc_26DB9:
mov rdi, [rsp+58h+var_38]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_12_010basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE5clearEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>::clear(void)
loc_26DC3:
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp loc_26D36
loc_26DD0:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::~vector()
loc_26DD8:
movzx eax, r14b
dec eax; switch 8 cases
cmp eax, 7
ja def_26DF5; jumptable 0000000000026DF5 default case, cases 4-7
lea rcx, jpt_26DF5
movsxd rax, ds:(jpt_26DF5 - 310B8h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_26DF7:
mov rdi, [rbx]; jumptable 0000000000026DF5 case 1
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_12_010basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EED2Ev; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>::~vector()
jmp short loc_26E47
loc_26E01:
push 30h ; '0'
pop rcx
cqo
idiv rcx
mov rdi, rsp
mov rsi, rax
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r15, [rax]
mov r13, [rax+8]
mov r12, rsp
loc_26E21:
cmp r15, r13
jz loc_26D2E
add r15, 20h ; ' '
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> &&)
add r15, 10h
jmp short loc_26E21
loc_26E3F:
mov rdi, [rbx]; jumptable 0000000000026DF5 case 3
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_26E47:
push 20h ; ' '
jmp short loc_26E61
loc_26E4B:
mov rdi, [rbx]; jumptable 0000000000026DF5 case 2
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::~vector()
push 18h
jmp short loc_26E61
loc_26E57:
mov rdi, [rbx]; jumptable 0000000000026DF5 case 8
call _ZNSt12_Vector_baseIhSaIhEED2Ev; std::_Vector_base<uchar>::~_Vector_base()
push 28h ; '('
loc_26E61:
pop rsi; unsigned __int64
mov rdi, [rbx]; void *
call __ZdlPvm; operator delete(void *,ulong)
def_26DF5:
add rsp, 28h; jumptable 0000000000026DF5 default case, cases 4-7
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_26E7D
jmp short loc_26E82
loc_26E7D:
mov rbx, rax
jmp short loc_26E8F
loc_26E82:
mov rbx, rax
lea rdi, [rsp+arg_10]
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_26E8F:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, rbx
call __Unwind_Resume
|
void nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::json_value::destroy(
void **a1,
unsigned int a2)
{
_QWORD *v2; // rcx
long long v3; // rdx
long long v4; // rax
long long v5; // r13
long long v6; // rbp
long long v7; // r13
long long v8; // r15
long long v9; // r13
long long v10; // r15
__int128 v11; // [rsp+0h] [rbp-58h] BYREF
long long v12; // [rsp+10h] [rbp-48h]
char v13[8]; // [rsp+18h] [rbp-40h] BYREF
_QWORD *v14; // [rsp+20h] [rbp-38h]
v2 = *a1;
if ( *a1 != 0LL || a2 != 1 )
{
v3 = a2;
LOBYTE(v3) = (a2 & 0xFE) == 2;
if ( ((v2 == 0LL) & (unsigned __int8)(v3 | ((_BYTE)a2 == 8))) == 0 )
{
if ( (unsigned __int8)(a2 - 1) <= 1u )
{
v11 = 0LL;
v12 = 0LL;
v4 = v2[1] - *v2;
if ( (_BYTE)a2 == 2 )
{
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v11,
v4 >> 4,
v3);
std::__copy_move<true,false,std::random_access_iterator_tag>::__copy_m<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>>>(
*(_QWORD *)*a1,
*((_QWORD *)*a1 + 1),
&v11);
}
else
{
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v11,
v4 / 48,
v4 % 48);
v8 = *(_QWORD *)*a1;
v9 = *((_QWORD *)*a1 + 1);
while ( v8 != v9 )
{
v10 = v8 + 32;
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>(
&v11,
v10);
v8 = v10 + 16;
}
}
while ( (_QWORD)v11 != *((_QWORD *)&v11 + 1) )
{
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v13,
*((_QWORD *)&v11 + 1) - 16LL);
*((_QWORD *)&v11 + 1) -= 16LL;
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::~basic_json(*((long long *)&v11 + 1));
if ( v13[0] == 1 )
{
v5 = *v14;
v6 = v14[1];
while ( v5 != v6 )
{
v7 = v5 + 32;
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>(
&v11,
v7);
v5 = v7 + 16;
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>>::clear(v14);
}
else if ( v13[0] == 2 )
{
std::__copy_move<true,false,std::random_access_iterator_tag>::__copy_m<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>>>(
*v14,
v14[1],
&v11);
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::clear(v14);
}
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v13);
}
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::~vector(&v11);
}
switch ( (char)a2 )
{
case 1:
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>>::~vector(*a1);
goto LABEL_22;
case 2:
std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::~vector(*a1);
operator delete(*a1, 0x18uLL);
break;
case 3:
std::string::~string(*a1);
LABEL_22:
operator delete(*a1, 0x20uLL);
break;
case 8:
std::_Vector_base<unsigned char>::~_Vector_base(*a1);
operator delete(*a1, 0x28uLL);
break;
default:
return;
}
}
}
}
|
destroy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
CMP ESI,0x1
SETZ AL
MOV RCX,qword ptr [RDI]
TEST RCX,RCX
SETZ DL
TEST AL,DL
JNZ 0x00126e6a
MOV R14D,ESI
TEST RCX,RCX
SETZ AL
MOV EDX,R14D
AND DL,0xfe
CMP DL,0x2
SETZ DL
CMP R14B,0x8
SETZ SIL
OR SIL,DL
TEST SIL,AL
JNZ 0x00126e6a
MOV RBX,RDI
LEA EAX,[R14 + -0x1]
CMP AL,0x1
JA 0x00126dd8
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
AND qword ptr [RSP + 0x10],0x0
MOV RAX,qword ptr [RCX + 0x8]
SUB RAX,qword ptr [RCX]
CMP R14B,0x2
JNZ 0x00126e01
SAR RAX,0x4
LAB_00126d11:
MOV RDI,RSP
MOV RSI,RAX
CALL 0x00126ea0
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
MOV RDX,RSP
CALL 0x00126fb8
LAB_00126d2e:
LEA R15,[RSP + 0x18]
MOV R12,RSP
LAB_00126d36:
MOV RSI,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],RSI
JZ 0x00126dd0
ADD RSI,-0x10
MOV RDI,R15
CALL 0x001261a6
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,-0x10
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00123c38
MOVZX EAX,byte ptr [RSP + 0x18]
CMP EAX,0x1
JZ 0x00126d93
CMP EAX,0x2
JNZ 0x00126dc3
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
LAB_00126d7f:
MOV RDX,R12
CALL 0x00126fb8
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00126f34
JMP 0x00126dc3
LAB_00126d93:
MOV RAX,qword ptr [RSP + 0x20]
MOV R13,qword ptr [RAX]
MOV RBP,qword ptr [RAX + 0x8]
LAB_00126d9f:
CMP R13,RBP
JZ 0x00126db9
ADD R13,0x20
LAB_00126da8:
MOV RDI,R12
MOV RSI,R13
CALL 0x00126ff0
ADD R13,0x10
JMP 0x00126d9f
LAB_00126db9:
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00126f3c
LAB_00126dc3:
MOV RDI,R15
CALL 0x00123c38
JMP 0x00126d36
LAB_00126dd0:
MOV RDI,RSP
CALL 0x00126f44
LAB_00126dd8:
MOVZX EAX,R14B
DEC EAX
CMP EAX,0x7
JA 0x00126e6a
LEA RCX,[0x1310b8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBX]
CALL 0x0012718a
JMP 0x00126e47
LAB_00126e01:
PUSH 0x30
POP RCX
CQO
IDIV RCX
LAB_00126e09:
MOV RDI,RSP
MOV RSI,RAX
CALL 0x00126ea0
MOV RAX,qword ptr [RBX]
MOV R15,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
MOV R12,RSP
LAB_00126e21:
CMP R15,R13
JZ 0x00126d2e
ADD R15,0x20
LAB_00126e2e:
MOV RDI,R12
MOV RSI,R15
CALL 0x00126ff0
LAB_00126e39:
ADD R15,0x10
JMP 0x00126e21
caseD_3:
MOV RDI,qword ptr [RBX]
CALL 0x00108e46
LAB_00126e47:
PUSH 0x20
JMP 0x00126e61
caseD_2:
MOV RDI,qword ptr [RBX]
CALL 0x00126f44
PUSH 0x18
JMP 0x00126e61
caseD_8:
MOV RDI,qword ptr [RBX]
CALL 0x00124e62
PUSH 0x28
LAB_00126e61:
POP RSI
MOV RDI,qword ptr [RBX]
CALL 0x001083b0
caseD_4:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::json_value::destroy(nlohmann::json_abi_v3_12_0::detail::value_t) */
void __thiscall
nlohmann::json_abi_v3_12_0::
basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy(json_value *this,uint param_2)
{
long *plVar1;
long lVar2;
byte bVar3;
long lVar4;
ulong uStack_60;
basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*local_58;
basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*pbStack_50;
int8 local_48;
basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_40 [8];
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*local_38;
plVar1 = *(long **)this;
if (param_2 == 1 && plVar1 == (long *)0x0) {
return;
}
bVar3 = (byte)param_2;
if ((bVar3 == 8 || (bVar3 & 0xfe) == 2) && plVar1 == (long *)0x0) {
return;
}
if ((byte)(bVar3 - 1) < 2) {
local_58 = (basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)0x0;
pbStack_50 = (basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)0x0;
local_48 = 0;
if (bVar3 == 2) {
/* try { // try from 00126d11 to 00126d2d has its CatchHandler @ 00126e79 */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_58,plVar1[1] - *plVar1 >> 4);
std::__copy_move<true,false,std::random_access_iterator_tag>::
__copy_m<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
(**(int8 **)this,(*(int8 **)this)[1],&local_58);
}
else {
/* try { // try from 00126e09 to 00126e13 has its CatchHandler @ 00126e79 */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_58,(plVar1[1] - *plVar1) / 0x30);
lVar2 = (*(long **)this)[1];
for (lVar4 = **(long **)this; lVar4 != lVar2; lVar4 = lVar4 + 0x30) {
/* try { // try from 00126e2e to 00126e38 has its CatchHandler @ 00126e7d */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_58,(basic_json *)(lVar4 + 0x20));
}
}
while (local_58 != pbStack_50) {
basic_json(local_40,(basic_json *)(pbStack_50 + -0x10));
pbStack_50 = pbStack_50 + -0x10;
~basic_json(pbStack_50);
if (local_40[0] ==
(basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
lVar2 = *(long *)(local_38 + 8);
for (lVar4 = *(long *)local_38; lVar4 != lVar2; lVar4 = lVar4 + 0x30) {
/* try { // try from 00126da8 to 00126db2 has its CatchHandler @ 00126e82 */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_58,(basic_json *)(lVar4 + 0x20));
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::clear((vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)local_38);
}
else if (local_40[0] ==
(basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
/* try { // try from 00126d7f to 00126d86 has its CatchHandler @ 00126e7b */
std::__copy_move<true,false,std::random_access_iterator_tag>::
__copy_m<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
(*(long *)local_38,*(long *)(local_38 + 8),&local_58);
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::clear(local_38);
}
~basic_json(local_40);
}
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector((vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_58);
}
switch(param_2 & 0xff) {
case 1:
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::~vector(*(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)this);
goto LAB_00126e47;
case 2:
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector(*(vector<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)this);
uStack_60 = 0x18;
break;
case 3:
std::__cxx11::string::~string(*(string **)this);
LAB_00126e47:
uStack_60 = 0x20;
break;
default:
goto switchD_00126df5_caseD_4;
case 8:
std::_Vector_base<unsigned_char,std::allocator<unsigned_char>>::~_Vector_base
(*(_Vector_base<unsigned_char,std::allocator<unsigned_char>> **)this);
uStack_60 = 0x28;
}
operator_delete(*(void **)this,uStack_60);
switchD_00126df5_caseD_4:
return;
}
|
|
17,244
|
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_12_0::detail::value_t)
|
shubhamoy[P]dir2txt/include/nlohmann/json.hpp
|
void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
{
//not initialized (e.g. due to exception in the ctor)
return;
}
if (t == value_t::array || t == value_t::object)
{
// flatten the current json_value to a heap-allocated stack
std::vector<basic_json> stack;
// move the top-level items to stack
if (t == value_t::array)
{
stack.reserve(array->size());
std::move(array->begin(), array->end(), std::back_inserter(stack));
}
else
{
stack.reserve(object->size());
for (auto&& it : *object)
{
stack.push_back(std::move(it.second));
}
}
while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
stack.pop_back();
// if current_item is array/object, move
// its children to the stack to be processed later
if (current_item.is_array())
{
std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
current_item.m_data.m_value.array->clear();
}
else if (current_item.is_object())
{
for (auto&& it : *current_item.m_data.m_value.object)
{
stack.push_back(std::move(it.second));
}
current_item.m_data.m_value.object->clear();
}
// it's now safe that current_item get destructed
// since it doesn't have any children
}
}
switch (t)
{
case value_t::object:
{
AllocatorType<object_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
break;
}
case value_t::array:
{
AllocatorType<array_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
break;
}
case value_t::string:
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
break;
}
case value_t::binary:
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
break;
}
case value_t::null:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::discarded:
default:
{
break;
}
}
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_12_0::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, %esi
sete %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x29a92
movl %esi, %r14d
testq %rax, %rax
sete %cl
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
testb %cl, %sil
jne 0x29a92
movq %rdi, %rbx
leal -0x1(%r14), %ecx
cmpb $0x1, %cl
ja 0x29a01
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpb $0x2, %r14b
jne 0x298ab
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x4, %rsi
movq %rsp, %rdi
callq 0x29ad6
movq (%rbx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
subq %r15, %r13
sarq $0x4, %r13
testq %r13, %r13
jle 0x298e6
incq %r13
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x29c3e
addq $0x10, %r15
decq %r13
cmpq $0x1, %r13
ja 0x29891
jmp 0x298e6
movq 0x28(%rax), %rsi
movq %rsp, %rdi
callq 0x29ad6
movq (%rbx), %r13
movq 0x18(%r13), %r15
addq $0x8, %r13
cmpq %r13, %r15
je 0x298e6
movq %rsp, %r12
leaq 0x40(%r15), %rsi
movq %r12, %rdi
callq 0x29c3e
movq %r15, %rdi
callq 0x8280
movq %rax, %r15
cmpq %r13, %rax
jne 0x298ca
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
je 0x299f9
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq -0x10(%r13), %rdi
movups -0x10(%r13), %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %esi, %esi
callq 0x29700
movb $0x0, -0x10(%r13)
movq $0x0, -0x8(%r13)
movq %r15, %rdi
movl $0x1, %esi
callq 0x29700
movq 0x8(%rsp), %r13
addq $-0x10, %r13
movq %r13, 0x8(%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x29700
movq %r13, %rdi
callq 0x297d6
movzbl 0x20(%rsp), %eax
cmpl $0x1, %eax
je 0x299a0
cmpl $0x2, %eax
jne 0x299d8
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
subq %r13, %rbp
sarq $0x4, %rbp
testq %rbp, %rbp
jle 0x29996
incq %rbp
movq %r12, %rdi
movq %r13, %rsi
callq 0x29c3e
addq $0x10, %r13
decq %rbp
cmpq $0x1, %rbp
jg 0x29976
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq %r13, %rsi
callq 0x29de8
jmp 0x299d8
movq 0x28(%rsp), %rdi
movq 0x18(%rdi), %r13
leaq 0x8(%rdi), %rbp
cmpq %rbp, %r13
je 0x299d3
leaq 0x40(%r13), %rsi
movq %r12, %rdi
callq 0x29c3e
movq %r13, %rdi
callq 0x8280
movq %rax, %r13
cmpq %rbp, %rax
jne 0x299b2
movq 0x28(%rsp), %rdi
callq 0x29e60
movq %r15, %rdi
xorl %esi, %esi
callq 0x29700
movq %r15, %rdi
callq 0x297d6
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
jne 0x298fd
movq %rsp, %rdi
callq 0x29b6a
movzbl %r14b, %eax
decl %eax
cmpl $0x7, %eax
ja 0x29a92
leaq 0xd611(%rip), %rcx # 0x37028
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x29f88
movq (%rbx), %rdi
movl $0x30, %esi
jmp 0x29a8d
movq (%rbx), %rdi
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x29a52
movq (%rcx), %rsi
incq %rsi
movq %rax, %rdi
callq 0x8380
movq (%rbx), %rdi
movl $0x20, %esi
jmp 0x29a8d
movq (%rbx), %rdi
callq 0x29b6a
movq (%rbx), %rdi
movl $0x18, %esi
jmp 0x29a8d
movq (%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x29a88
movq 0x10(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x8380
movq (%rbx), %rdi
movl $0x28, %esi
callq 0x8380
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x29aa5
jmp 0x29aa5
movq %rax, %rbx
jmp 0x29ac6
jmp 0x29aac
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x29700
movq %r14, %rdi
callq 0x297d6
movq %rsp, %rdi
callq 0x29b6a
movq %rbx, %rdi
callq 0x85d0
|
_ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
cmp esi, 1
setz cl
mov rax, [rdi]
test rax, rax
setz dl
test cl, dl
jnz def_29A1E; jumptable 0000000000029A1E default case, cases 4-7
mov r14d, esi
test rax, rax
setz cl
mov edx, r14d
and dl, 0FEh
cmp dl, 2
setz dl
cmp r14b, 8
setz sil
or sil, dl
test sil, cl
jnz def_29A1E; jumptable 0000000000029A1E default case, cases 4-7
mov rbx, rdi
lea ecx, [r14-1]
cmp cl, 1
ja loc_29A01
xorps xmm0, xmm0
movaps [rsp+68h+var_68], xmm0
mov [rsp+68h+var_58], 0
cmp r14b, 2
jnz short loc_298AB
mov rsi, [rax+8]
sub rsi, [rax]
sar rsi, 4
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r15, [rax]
mov r13, [rax+8]
sub r13, r15
sar r13, 4
test r13, r13
jle short loc_298E6
inc r13
mov r12, rsp
loc_29891:
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> &&)
add r15, 10h
dec r13
cmp r13, 1
ja short loc_29891
jmp short loc_298E6
loc_298AB:
mov rsi, [rax+28h]
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov r13, [rbx]
mov r15, [r13+18h]
add r13, 8
cmp r15, r13
jz short loc_298E6
mov r12, rsp
loc_298CA:
lea rsi, [r15+40h]
mov rdi, r12
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> &&)
mov rdi, r15
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov r15, rax
cmp rax, r13
jnz short loc_298CA
loc_298E6:
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jz loc_299F9
lea r15, [rsp+68h+var_48]
mov r12, rsp
loc_298FD:
lea rdi, [r13-10h]
movups xmm0, xmmword ptr [r13-10h]
movaps [rsp+68h+var_48], xmm0
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r13-10h], 0
mov qword ptr [r13-8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov r13, qword ptr [rsp+68h+var_68+8]
add r13, 0FFFFFFFFFFFFFFF0h
mov qword ptr [rsp+68h+var_68+8], r13
mov rdi, r13
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
movzx eax, byte ptr [rsp+68h+var_48]
cmp eax, 1
jz short loc_299A0
cmp eax, 2
jnz short loc_299D8
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
mov rbp, [rdi+8]
sub rbp, r13
sar rbp, 4
test rbp, rbp
jle short loc_29996
inc rbp
loc_29976:
mov rdi, r12
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> &&)
add r13, 10h
dec rbp
cmp rbp, 1
jg short loc_29976
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
loc_29996:
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE15_M_erase_at_endEPSD_; std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::_M_erase_at_end(nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>*)
jmp short loc_299D8
loc_299A0:
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi+18h]
lea rbp, [rdi+8]
cmp r13, rbp
jz short loc_299D3
loc_299B2:
lea rsi, [r13+40h]
mov rdi, r12
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> &&)
mov rdi, r13
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov r13, rax
cmp rax, rbp
jnz short loc_299B2
mov rdi, qword ptr [rsp+68h+var_48+8]
loc_299D3:
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESt10_Select1stISH_ESt4lessIvESaISH_EE5clearEv; std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>>::clear(void)
loc_299D8:
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jnz loc_298FD
loc_299F9:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::~vector()
loc_29A01:
movzx eax, r14b
dec eax; switch 8 cases
cmp eax, 7
ja def_29A1E; jumptable 0000000000029A1E default case, cases 4-7
lea rcx, jpt_29A1E
movsxd rax, ds:(jpt_29A1E - 37028h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_29A20:
mov rdi, [rbx]; jumptable 0000000000029A1E case 1
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESt10_Select1stISH_ESt4lessIvESaISH_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>>::~_Rb_tree()
mov rdi, [rbx]
mov esi, 30h ; '0'
jmp short loc_29A8D
loc_29A32:
mov rdi, [rbx]; jumptable 0000000000029A1E case 3
mov rax, [rdi]
lea rcx, [rdi+10h]
cmp rax, rcx
jz short loc_29A52
mov rsi, [rcx]
inc rsi; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [rbx]
loc_29A52:
mov esi, 20h ; ' '
jmp short loc_29A8D
loc_29A59:
mov rdi, [rbx]; jumptable 0000000000029A1E case 2
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, [rbx]
mov esi, 18h
jmp short loc_29A8D
loc_29A6B:
mov rdi, [rbx]; jumptable 0000000000029A1E case 8
mov rax, [rdi]
test rax, rax
jz short loc_29A88
mov rsi, [rdi+10h]
sub rsi, rax; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [rbx]; void *
loc_29A88:
mov esi, 28h ; '('; unsigned __int64
loc_29A8D:
call __ZdlPvm; operator delete(void *,ulong)
def_29A1E:
add rsp, 38h; jumptable 0000000000029A1E default case, cases 4-7
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_29AA5
jmp short $+2
loc_29AA5:
mov rbx, rax
jmp short loc_29AC6
jmp short $+2
loc_29AAC:
mov rbx, rax
lea r14, [rsp+arg_18]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_29AC6:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, rbx
call __Unwind_Resume
|
void nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::json_value::destroy(
void ***a1,
int a2)
{
void **v2; // rax
char v3; // r14
char *v5; // r15
long long v6; // r13
long long v7; // r13
bool v8; // cf
long long v9; // r15
long long i; // r13
long long j; // r13
char *v12; // r13
long long v13; // rsi
long long v14; // rdi
long long v15; // r13
long long v16; // rbp
long long v17; // rbp
long long v18; // rdi
long long v19; // r13
long long v20; // rbp
void **v21; // rdi
unsigned long long v22; // rsi
_QWORD *v23; // rcx
_BYTE *v24; // rax
__int128 v25; // [rsp+0h] [rbp-68h] BYREF
long long v26; // [rsp+10h] [rbp-58h]
_OWORD v27[4]; // [rsp+20h] [rbp-48h] BYREF
v2 = *a1;
if ( *a1 != 0LL || a2 != 1 )
{
v3 = a2;
if ( v2 != 0LL || (a2 & 0xFE) != 2 && (_BYTE)a2 != 8 )
{
if ( (unsigned __int8)(a2 - 1) <= 1u )
{
v25 = 0LL;
v26 = 0LL;
if ( (_BYTE)a2 == 2 )
{
std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v25,
((_BYTE *)v2[1] - (_BYTE *)*v2) >> 4);
v5 = (char *)**a1;
v6 = ((_BYTE *)(*a1)[1] - v5) >> 4;
if ( v6 > 0 )
{
v7 = v6 + 1;
do
{
std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>(
&v25,
v5);
v5 += 16;
v8 = v7-- == 1;
}
while ( !v8 && v7 != 1 );
}
}
else
{
std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v25,
v2[5]);
v9 = (long long)(*a1)[3];
for ( i = (long long)(*a1 + 1); v9 != i; v9 = std::_Rb_tree_increment(v9) )
std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>(
&v25,
v9 + 64);
}
for ( j = *((_QWORD *)&v25 + 1); (_QWORD)v25 != *((_QWORD *)&v25 + 1); j = *((_QWORD *)&v25 + 1) )
{
v27[0] = *(_OWORD *)(j - 16);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(j - 16));
*(_BYTE *)(j - 16) = 0;
*(_QWORD *)(j - 8) = 0LL;
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
v12 = (char *)(*((_QWORD *)&v25 + 1) - 16LL);
*((_QWORD *)&v25 + 1) = v12;
v13 = 0LL;
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v12);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::data::~data(v12);
if ( LOBYTE(v27[0]) == 1 )
{
v18 = *((_QWORD *)&v27[0] + 1);
v19 = *(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 24LL);
v20 = *((_QWORD *)&v27[0] + 1) + 8LL;
if ( v19 != *((_QWORD *)&v27[0] + 1) + 8LL )
{
do
{
v13 = v19 + 64;
std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>(
&v25,
v19 + 64);
v19 = std::_Rb_tree_increment(v19);
}
while ( v19 != v20 );
v18 = *((_QWORD *)&v27[0] + 1);
}
std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>>>::clear(
v18,
v13);
}
else if ( LOBYTE(v27[0]) == 2 )
{
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
v16 = (long long)(*(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 8LL) - **((_QWORD **)&v27[0] + 1)) >> 4;
if ( v16 > 0 )
{
v17 = v16 + 1;
do
{
std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>(
&v25,
v15);
v15 += 16LL;
--v17;
}
while ( v17 > 1 );
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
}
std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::_M_erase_at_end(
v14,
v15);
}
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::data::~data(v27);
}
std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::~vector(&v25);
}
switch ( v3 )
{
case 1:
std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>>>::~_Rb_tree(*a1);
v21 = *a1;
v22 = 48LL;
goto LABEL_34;
case 2:
std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>::~vector(*a1);
v21 = *a1;
v22 = 24LL;
goto LABEL_34;
case 3:
v21 = *a1;
v23 = *a1 + 2;
if ( **a1 != v23 )
{
operator delete(**a1, *v23 + 1LL);
v21 = *a1;
}
v22 = 32LL;
goto LABEL_34;
case 8:
v21 = *a1;
v24 = **a1;
if ( v24 )
{
operator delete(**a1, (_BYTE *)v21[2] - v24);
v21 = *a1;
}
v22 = 40LL;
LABEL_34:
operator delete(v21, v22);
break;
default:
return;
}
}
}
}
|
destroy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
CMP ESI,0x1
SETZ CL
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
SETZ DL
TEST CL,DL
JNZ 0x00129a92
MOV R14D,ESI
TEST RAX,RAX
SETZ CL
MOV EDX,R14D
AND DL,0xfe
CMP DL,0x2
SETZ DL
CMP R14B,0x8
SETZ SIL
OR SIL,DL
TEST SIL,CL
JNZ 0x00129a92
MOV RBX,RDI
LEA ECX,[R14 + -0x1]
CMP CL,0x1
JA 0x00129a01
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
CMP R14B,0x2
JNZ 0x001298ab
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,qword ptr [RAX]
SAR RSI,0x4
LAB_0012986d:
MOV RDI,RSP
CALL 0x00129ad6
MOV RAX,qword ptr [RBX]
MOV R15,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
SUB R13,R15
SAR R13,0x4
TEST R13,R13
JLE 0x001298e6
INC R13
MOV R12,RSP
LAB_00129891:
MOV RDI,R12
MOV RSI,R15
CALL 0x00129c3e
ADD R15,0x10
DEC R13
CMP R13,0x1
JA 0x00129891
JMP 0x001298e6
LAB_001298ab:
MOV RSI,qword ptr [RAX + 0x28]
LAB_001298af:
MOV RDI,RSP
CALL 0x00129ad6
MOV R13,qword ptr [RBX]
MOV R15,qword ptr [R13 + 0x18]
ADD R13,0x8
CMP R15,R13
JZ 0x001298e6
MOV R12,RSP
LAB_001298ca:
LEA RSI,[R15 + 0x40]
LAB_001298ce:
MOV RDI,R12
CALL 0x00129c3e
MOV RDI,R15
CALL 0x00108280
MOV R15,RAX
CMP RAX,R13
JNZ 0x001298ca
LAB_001298e6:
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JZ 0x001299f9
LEA R15,[RSP + 0x20]
MOV R12,RSP
LAB_001298fd:
LEA RDI,[R13 + -0x10]
MOVUPS XMM0,xmmword ptr [R13 + -0x10]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
XOR ESI,ESI
CALL 0x00129700
MOV byte ptr [R13 + -0x10],0x0
MOV qword ptr [R13 + -0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00129700
MOV R13,qword ptr [RSP + 0x8]
ADD R13,-0x10
MOV qword ptr [RSP + 0x8],R13
MOV RDI,R13
XOR ESI,ESI
CALL 0x00129700
MOV RDI,R13
CALL 0x001297d6
MOVZX EAX,byte ptr [RSP + 0x20]
CMP EAX,0x1
JZ 0x001299a0
CMP EAX,0x2
JNZ 0x001299d8
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
SUB RBP,R13
SAR RBP,0x4
TEST RBP,RBP
JLE 0x00129996
INC RBP
LAB_00129976:
MOV RDI,R12
MOV RSI,R13
CALL 0x00129c3e
ADD R13,0x10
DEC RBP
CMP RBP,0x1
JG 0x00129976
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
LAB_00129996:
MOV RSI,R13
CALL 0x00129de8
JMP 0x001299d8
LAB_001299a0:
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI + 0x18]
LEA RBP,[RDI + 0x8]
CMP R13,RBP
JZ 0x001299d3
LAB_001299b2:
LEA RSI,[R13 + 0x40]
LAB_001299b6:
MOV RDI,R12
CALL 0x00129c3e
LAB_001299be:
MOV RDI,R13
CALL 0x00108280
MOV R13,RAX
CMP RAX,RBP
JNZ 0x001299b2
MOV RDI,qword ptr [RSP + 0x28]
LAB_001299d3:
CALL 0x00129e60
LAB_001299d8:
MOV RDI,R15
XOR ESI,ESI
CALL 0x00129700
MOV RDI,R15
CALL 0x001297d6
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JNZ 0x001298fd
LAB_001299f9:
MOV RDI,RSP
CALL 0x00129b6a
LAB_00129a01:
MOVZX EAX,R14B
DEC EAX
CMP EAX,0x7
JA 0x00129a92
LEA RCX,[0x137028]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBX]
CALL 0x00129f88
MOV RDI,qword ptr [RBX]
MOV ESI,0x30
JMP 0x00129a8d
caseD_3:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
LEA RCX,[RDI + 0x10]
CMP RAX,RCX
JZ 0x00129a52
MOV RSI,qword ptr [RCX]
INC RSI
MOV RDI,RAX
CALL 0x00108380
MOV RDI,qword ptr [RBX]
LAB_00129a52:
MOV ESI,0x20
JMP 0x00129a8d
caseD_2:
MOV RDI,qword ptr [RBX]
CALL 0x00129b6a
MOV RDI,qword ptr [RBX]
MOV ESI,0x18
JMP 0x00129a8d
caseD_8:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x00129a88
MOV RSI,qword ptr [RDI + 0x10]
SUB RSI,RAX
MOV RDI,RAX
CALL 0x00108380
MOV RDI,qword ptr [RBX]
LAB_00129a88:
MOV ESI,0x28
LAB_00129a8d:
CALL 0x00108380
caseD_4:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_12_0::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_12_0::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >,
void>::json_value::destroy(nlohmann::json_abi_v3_12_0::detail::value_t) */
void __thiscall
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy(json_value *this,uint param_2)
{
long *plVar1;
void *pvVar2;
_Rb_tree_node_base *p_Var3;
_Rb_tree_node_base *p_Var4;
byte bVar5;
bool bVar6;
int8 *puVar7;
long lVar8;
ulong uVar9;
data *pdVar10;
basic_json *pbVar11;
data *local_68;
data *pdStack_60;
int8 local_58;
int8 local_48;
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::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_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*p_Stack_40;
plVar1 = *(long **)this;
if ((param_2 != 1 || plVar1 != (long *)0x0) &&
(bVar5 = (byte)param_2, bVar5 != 8 && (bVar5 & 0xfe) != 2 || plVar1 != (long *)0x0)) {
if ((byte)(bVar5 - 1) < 2) {
local_68 = (data *)0x0;
pdStack_60 = (data *)0x0;
local_58 = 0;
if (bVar5 == 2) {
/* try { // try from 0012986d to 00129874 has its CatchHandler @ 00129aa1 */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,plVar1[1] - *plVar1 >> 4);
pbVar11 = (basic_json *)**(long **)this;
lVar8 = (*(long **)this)[1] - (long)pbVar11 >> 4;
if (0 < lVar8) {
uVar9 = lVar8 + 1;
do {
/* try { // try from 00129891 to 0012989b has its CatchHandler @ 00129aa5 */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar11);
pbVar11 = pbVar11 + 0x10;
uVar9 = uVar9 - 1;
} while (1 < uVar9);
}
}
else {
/* try { // try from 001298af to 001298b6 has its CatchHandler @ 00129aa1 */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,plVar1[5]);
lVar8 = *(long *)this;
for (p_Var3 = *(_Rb_tree_node_base **)(lVar8 + 0x18);
p_Var3 != (_Rb_tree_node_base *)(lVar8 + 8);
p_Var3 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var3)) {
/* try { // try from 001298ce to 001298d5 has its CatchHandler @ 00129aa3 */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(p_Var3 + 0x40));
}
}
if (local_68 != pdStack_60) {
do {
pdVar10 = pdStack_60;
local_48 = *(int8 *)(pdStack_60 + -0x10);
p_Stack_40 = *(_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::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_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(pdStack_60 + -8);
assert_invariant((bool)((char)pdStack_60 + -0x10));
pdVar10[-0x10] = (data)0x0;
*(int8 *)(pdVar10 + -8) = 0;
bVar6 = SUB81((data *)&local_48,0);
assert_invariant(bVar6);
pdVar10 = pdStack_60 + -0x10;
pdStack_60 = pdVar10;
assert_invariant(SUB81(pdVar10,0));
data::~data(pdVar10);
if (local_48._0_1_ == (data)0x1) {
p_Var3 = (_Rb_tree_node_base *)(p_Stack_40 + 8);
for (p_Var4 = *(_Rb_tree_node_base **)(p_Stack_40 + 0x18); p_Var4 != p_Var3;
p_Var4 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var4)) {
/* try { // try from 001299b6 to 001299bd has its CatchHandler @ 00129aac */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(p_Var4 + 0x40));
}
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::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_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::clear(p_Stack_40);
}
else if (local_48._0_1_ == (data)0x2) {
pbVar11 = *(basic_json **)p_Stack_40;
lVar8 = *(long *)(p_Stack_40 + 8) - (long)pbVar11 >> 4;
if (0 < lVar8) {
lVar8 = lVar8 + 1;
do {
/* try { // try from 00129976 to 00129980 has its CatchHandler @ 00129aaa */
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar11);
pbVar11 = pbVar11 + 0x10;
lVar8 = lVar8 + -1;
} while (1 < lVar8);
pbVar11 = *(basic_json **)p_Stack_40;
}
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::_M_erase_at_end((vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)p_Stack_40,pbVar11);
}
assert_invariant(bVar6);
data::~data((data *)&local_48);
} while (local_68 != pdStack_60);
}
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector((vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68);
}
switch(param_2 & 0xff) {
case 1:
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::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_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::~_Rb_tree(*(_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::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_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)this);
puVar7 = *(int8 **)this;
uVar9 = 0x30;
break;
case 2:
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector(*(vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)this);
puVar7 = *(int8 **)this;
uVar9 = 0x18;
break;
case 3:
puVar7 = *(int8 **)this;
if ((long *)*puVar7 != puVar7 + 2) {
operator_delete((long *)*puVar7,puVar7[2] + 1);
puVar7 = *(int8 **)this;
}
uVar9 = 0x20;
break;
default:
goto switchD_00129a1e_caseD_4;
case 8:
puVar7 = *(int8 **)this;
pvVar2 = (void *)*puVar7;
if (pvVar2 != (void *)0x0) {
operator_delete(pvVar2,puVar7[2] - (long)pvVar2);
puVar7 = *(int8 **)this;
}
uVar9 = 0x28;
}
operator_delete(puVar7,uVar9);
}
switchD_00129a1e_caseD_4:
return;
}
|
|
17,245
|
YAML::Scanner::PushIndentTo(int, YAML::Scanner::IndentMarker::INDENT_TYPE)
|
aimrt_mujoco_sim/_deps/yaml-cpp-src/src/scanner.cpp
|
Token* Scanner::PushToken(Token::TYPE type) {
m_tokens.push(Token(type, INPUT.mark()));
return &m_tokens.back();
}
|
O3
|
cpp
|
YAML::Scanner::PushIndentTo(int, YAML::Scanner::IndentMarker::INDENT_TYPE):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x1c0(%rdi), %rax
cmpq 0x1a0(%rdi), %rax
je 0x64714
xorl %r14d, %r14d
jmp 0x647d9
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r14
movl $0x18, %edi
callq 0x2d270
movq %rax, %rbx
movl %r12d, (%rax)
movl %ebp, 0x4(%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq %rax, (%rsp)
movq 0x158(%r14), %rax
cmpq 0x160(%r14), %rax
jne 0x64762
movq 0x170(%r14), %rcx
movl $0x200, %eax # imm = 0x200
addq -0x8(%rcx), %rax
leaq 0x128(%r14), %r15
movq -0x8(%rax), %rax
cmpl %r12d, (%rax)
jle 0x64777
xorl %r14d, %r14d
jmp 0x647cc
jne 0x64784
cmpl $0x1, %ebp
jne 0x64772
cmpl $0x0, 0x4(%rax)
jne 0x64772
movl %ebp, %esi
callq 0x6468c
movq %r14, %rdi
movl %eax, %esi
callq 0x645cc
movq %rax, 0x10(%rbx)
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
movq %r15, %rdi
callq 0x66d3a
leaq 0x178(%r14), %rdi
movq %rsp, %rsi
callq 0x66ba0
movq 0x180(%r14), %rax
movq -0x8(%rax), %r14
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x647d9
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2d2d0
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x647fa
movq %rax, %r14
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x64807
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2d2d0
movq %r14, %rdi
callq 0x2e220
nop
|
_ZN4YAML7Scanner12PushIndentToEiNS0_12IndentMarker11INDENT_TYPEE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rax, [rdi+1C0h]
cmp rax, [rdi+1A0h]
jz short loc_64714
xor r14d, r14d
jmp loc_647D9
loc_64714:
mov ebp, edx
mov r12d, esi
mov r14, rdi
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
mov [rax], r12d
mov [rax+4], ebp
mov dword ptr [rax+8], 0
mov qword ptr [rax+10h], 0
mov [rsp+38h+var_38], rax
mov rax, [r14+158h]
cmp rax, [r14+160h]
jnz short loc_64762
mov rcx, [r14+170h]
mov eax, 200h
add rax, [rcx-8]
loc_64762:
lea r15, [r14+128h]
mov rax, [rax-8]
cmp [rax], r12d
jle short loc_64777
loc_64772:
xor r14d, r14d
jmp short loc_647CC
loc_64777:
jnz short loc_64784
cmp ebp, 1
jnz short loc_64772
cmp dword ptr [rax+4], 0
jnz short loc_64772
loc_64784:
mov esi, ebp
call _ZNK4YAML7Scanner16GetStartTokenForENS0_12IndentMarker11INDENT_TYPEE; YAML::Scanner::GetStartTokenFor(YAML::Scanner::IndentMarker::INDENT_TYPE)
mov rdi, r14
mov esi, eax
call _ZN4YAML7Scanner9PushTokenENS_5Token4TYPEE; YAML::Scanner::PushToken(YAML::Token::TYPE)
mov [rbx+10h], rax
lea rsi, [rsp+38h+var_30]
mov [rsi], rbx
mov rdi, r15
call _ZNSt5dequeIPN4YAML7Scanner12IndentMarkerESaIS3_EE12emplace_backIJS3_EEERS3_DpOT_; std::deque<YAML::Scanner::IndentMarker *>::emplace_back<YAML::Scanner::IndentMarker *>(YAML::Scanner::IndentMarker * &&)
lea rdi, [r14+178h]
mov rsi, rsp
call _ZNSt6vectorISt10unique_ptrIN4YAML7Scanner12IndentMarkerESt14default_deleteIS3_EESaIS6_EE12emplace_backIJS6_EEERS6_DpOT_; std::vector<std::unique_ptr<YAML::Scanner::IndentMarker>>::emplace_back<std::unique_ptr<YAML::Scanner::IndentMarker>>(std::unique_ptr<YAML::Scanner::IndentMarker> &&)
mov rax, [r14+180h]
mov r14, [rax-8]
mov rbx, [rsp+38h+var_38]
test rbx, rbx
jz short loc_647D9
loc_647CC:
mov esi, 18h; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_647D9:
mov rax, r14
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
mov r14, rax
jmp short loc_647FA
mov r14, rax
mov rbx, [rsp+0]
test rbx, rbx
jz short loc_64807
loc_647FA:
mov esi, 18h; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_64807:
mov rdi, r14
call __Unwind_Resume
|
long long YAML::Scanner::PushIndentTo(_QWORD *a1, int a2, int a3)
{
long long v3; // r14
_DWORD *v5; // rbx
long long v6; // rax
_DWORD *v7; // rax
int StartTokenFor; // eax
if ( a1[56] == a1[52] )
{
v5 = (_DWORD *)operator new(0x18uLL);
*v5 = a2;
v5[1] = a3;
v5[2] = 0;
*((_QWORD *)v5 + 2) = 0LL;
v6 = a1[43];
if ( v6 == a1[44] )
v6 = *(_QWORD *)(a1[46] - 8LL) + 512LL;
v7 = *(_DWORD **)(v6 - 8);
if ( *v7 > a2 || *v7 == a2 && (a3 != 1 || v7[1]) )
{
v3 = 0LL;
}
else
{
StartTokenFor = YAML::Scanner::GetStartTokenFor(24LL, a3);
*((_QWORD *)v5 + 2) = YAML::Scanner::PushToken((long long)a1, StartTokenFor);
std::deque<YAML::Scanner::IndentMarker *>::emplace_back<YAML::Scanner::IndentMarker *>(a1 + 37);
std::vector<std::unique_ptr<YAML::Scanner::IndentMarker>>::emplace_back<std::unique_ptr<YAML::Scanner::IndentMarker>>(a1 + 47);
v3 = *(_QWORD *)(a1[48] - 8LL);
if ( !v5 )
return v3;
}
operator delete(v5, 0x18uLL);
return v3;
}
return 0LL;
}
|
PushIndentTo:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr [RDI + 0x1c0]
CMP RAX,qword ptr [RDI + 0x1a0]
JZ 0x00164714
XOR R14D,R14D
JMP 0x001647d9
LAB_00164714:
MOV EBP,EDX
MOV R12D,ESI
MOV R14,RDI
MOV EDI,0x18
CALL 0x0012d270
MOV RBX,RAX
MOV dword ptr [RAX],R12D
MOV dword ptr [RAX + 0x4],EBP
MOV dword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [R14 + 0x158]
CMP RAX,qword ptr [R14 + 0x160]
JNZ 0x00164762
MOV RCX,qword ptr [R14 + 0x170]
MOV EAX,0x200
ADD RAX,qword ptr [RCX + -0x8]
LAB_00164762:
LEA R15,[R14 + 0x128]
MOV RAX,qword ptr [RAX + -0x8]
CMP dword ptr [RAX],R12D
JLE 0x00164777
LAB_00164772:
XOR R14D,R14D
JMP 0x001647cc
LAB_00164777:
JNZ 0x00164784
CMP EBP,0x1
JNZ 0x00164772
CMP dword ptr [RAX + 0x4],0x0
JNZ 0x00164772
LAB_00164784:
MOV ESI,EBP
CALL 0x0016468c
MOV RDI,R14
MOV ESI,EAX
CALL 0x001645cc
MOV qword ptr [RBX + 0x10],RAX
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RBX
LAB_001647a1:
MOV RDI,R15
CALL 0x00166d3a
LEA RDI,[R14 + 0x178]
LAB_001647b0:
MOV RSI,RSP
CALL 0x00166ba0
LAB_001647b8:
MOV RAX,qword ptr [R14 + 0x180]
MOV R14,qword ptr [RAX + -0x8]
MOV RBX,qword ptr [RSP]
TEST RBX,RBX
JZ 0x001647d9
LAB_001647cc:
MOV ESI,0x18
MOV RDI,RBX
CALL 0x0012d2d0
LAB_001647d9:
MOV RAX,R14
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* YAML::Scanner::PushIndentTo(int, YAML::Scanner::IndentMarker::INDENT_TYPE) */
int8 __thiscall YAML::Scanner::PushIndentTo(Scanner *this,int param_1,int param_3)
{
int iVar1;
int4 uVar2;
IndentMarker *pIVar3;
long lVar4;
int8 uVar5;
IndentMarker *local_38;
IndentMarker *local_30;
if (*(long *)(this + 0x1c0) == *(long *)(this + 0x1a0)) {
pIVar3 = (IndentMarker *)operator_new(0x18);
*(int *)pIVar3 = param_1;
*(int *)(pIVar3 + 4) = param_3;
*(int *)(pIVar3 + 8) = 0;
*(int8 *)(pIVar3 + 0x10) = 0;
lVar4 = *(long *)(this + 0x158);
if (lVar4 == *(long *)(this + 0x160)) {
lVar4 = *(long *)(*(long *)(this + 0x170) + -8) + 0x200;
}
iVar1 = **(int **)(lVar4 + -8);
local_38 = pIVar3;
if ((param_1 < iVar1) ||
((iVar1 == param_1 && ((param_3 != 1 || ((*(int **)(lVar4 + -8))[1] != 0)))))) {
uVar5 = 0;
}
else {
/* try { // try from 00164784 to 00164794 has its CatchHandler @ 001647ee */
uVar2 = GetStartTokenFor();
uVar5 = PushToken(this,uVar2);
*(int8 *)(pIVar3 + 0x10) = uVar5;
local_30 = pIVar3;
/* try { // try from 001647a1 to 001647a8 has its CatchHandler @ 001647e9 */
std::deque<YAML::Scanner::IndentMarker*,std::allocator<YAML::Scanner::IndentMarker*>>::
emplace_back<YAML::Scanner::IndentMarker*>
((deque<YAML::Scanner::IndentMarker*,std::allocator<YAML::Scanner::IndentMarker*>> *
)(this + 0x128),&local_30);
/* try { // try from 001647b0 to 001647b7 has its CatchHandler @ 001647ee */
std::
vector<std::unique_ptr<YAML::Scanner::IndentMarker,std::default_delete<YAML::Scanner::IndentMarker>>,std::allocator<std::unique_ptr<YAML::Scanner::IndentMarker,std::default_delete<YAML::Scanner::IndentMarker>>>>
::
emplace_back<std::unique_ptr<YAML::Scanner::IndentMarker,std::default_delete<YAML::Scanner::IndentMarker>>>
((vector<std::unique_ptr<YAML::Scanner::IndentMarker,std::default_delete<YAML::Scanner::IndentMarker>>,std::allocator<std::unique_ptr<YAML::Scanner::IndentMarker,std::default_delete<YAML::Scanner::IndentMarker>>>>
*)(this + 0x178),(unique_ptr *)&local_38);
uVar5 = *(int8 *)(*(long *)(this + 0x180) + -8);
if (local_38 == (IndentMarker *)0x0) {
return uVar5;
}
}
operator_delete(local_38,0x18);
}
else {
uVar5 = 0;
}
return uVar5;
}
|
|
17,246
|
maria_rtree_overlapping_area
|
eloqsql/storage/maria/ma_rt_mbr.c
|
double maria_rtree_overlapping_area(HA_KEYSEG *keyseg, uchar* a, uchar* b,
uint key_length)
{
double res= 1;
for (; (int) key_length > 0 ; keyseg += 2)
{
uint32 keyseg_length;
switch ((enum ha_base_keytype) keyseg->type) {
case HA_KEYTYPE_INT8:
RT_OVL_AREA_KORR(int8, mi_sint1korr, 1);
break;
case HA_KEYTYPE_BINARY:
RT_OVL_AREA_KORR(uint8, mi_uint1korr, 1);
break;
case HA_KEYTYPE_SHORT_INT:
RT_OVL_AREA_KORR(int16, mi_sint2korr, 2);
break;
case HA_KEYTYPE_USHORT_INT:
RT_OVL_AREA_KORR(uint16, mi_uint2korr, 2);
break;
case HA_KEYTYPE_INT24:
RT_OVL_AREA_KORR(int32, mi_sint3korr, 3);
break;
case HA_KEYTYPE_UINT24:
RT_OVL_AREA_KORR(uint32, mi_uint3korr, 3);
break;
case HA_KEYTYPE_LONG_INT:
RT_OVL_AREA_KORR(int32, mi_sint4korr, 4);
break;
case HA_KEYTYPE_ULONG_INT:
RT_OVL_AREA_KORR(uint32, mi_uint4korr, 4);
break;
#ifdef HAVE_LONG_LONG
case HA_KEYTYPE_LONGLONG:
RT_OVL_AREA_KORR(longlong, mi_sint8korr, 8);
break;
case HA_KEYTYPE_ULONGLONG:
RT_OVL_AREA_KORR(longlong, mi_sint8korr, 8);
break;
#endif
case HA_KEYTYPE_FLOAT:
RT_OVL_AREA_GET(float, mi_float4get, 4);
break;
case HA_KEYTYPE_DOUBLE:
RT_OVL_AREA_GET(double, mi_float8get, 8);
break;
case HA_KEYTYPE_END:
return res;
default:
return -1;
}
keyseg_length= keyseg->length * 2;
key_length-= keyseg_length;
a+= keyseg_length;
b+= keyseg_length;
}
return res;
}
|
O3
|
c
|
maria_rtree_overlapping_area:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
testl %ecx, %ecx
jle 0x8887e
addq $0x18, %rdi
movsd 0x7cba1(%rip), %xmm0 # 0x105000
movsd 0x7cbd1(%rip), %xmm1 # 0x105038
leaq 0x7d436(%rip), %rax # 0x1058a4
movzbl (%rdi), %r8d
cmpq $0xe, %r8
ja 0x88893
movslq (%rax,%r8,4), %r8
addq %rax, %r8
jmpq *%r8
movq (%rsi), %r9
movq 0x8(%rsi), %r10
bswapq %r9
movq (%rdx), %r11
movq 0x8(%rdx), %r8
bswapq %r11
bswapq %r10
bswapq %r8
cmpq %r11, %r9
cmovgq %r9, %r11
cmpq %r8, %r10
cmovlq %r10, %r8
subq %r11, %r8
jg 0x88677
jmp 0x88888
movzbl (%rsi), %r11d
movl %r11d, %r8d
shll $0x10, %r8d
movzbl 0x1(%rsi), %r9d
shll $0x8, %r9d
movzbl 0x2(%rsi), %r10d
testb %r11b, %r11b
js 0x8879f
orl %r10d, %r8d
orl %r9d, %r8d
jmp 0x887ac
movzwl 0x1(%rsi), %r8d
movzwl 0x4(%rsi), %r9d
rolw $0x8, %r8w
movzwl %r8w, %r10d
movzbl (%rsi), %r8d
shll $0x10, %r8d
orl %r10d, %r8d
movzwl 0x1(%rdx), %r10d
movzwl 0x4(%rdx), %r11d
rolw $0x8, %r10w
movzwl %r10w, %r10d
movzbl (%rdx), %ebx
shll $0x10, %ebx
orl %r10d, %ebx
rolw $0x8, %r9w
movzwl %r9w, %r9d
movzbl 0x3(%rsi), %r10d
shll $0x10, %r10d
orl %r9d, %r10d
rolw $0x8, %r11w
movzwl %r11w, %r11d
movzbl 0x3(%rdx), %r9d
shll $0x10, %r9d
orl %r11d, %r9d
cmpl %ebx, %r8d
cmoval %r8d, %ebx
cmpl %r9d, %r10d
cmovbl %r10d, %r9d
subl %ebx, %r9d
jbe 0x88888
xorps %xmm2, %xmm2
cvtsi2sd %r9, %xmm2
jmp 0x8885d
movq (%rsi), %r8
movq 0x8(%rsi), %r9
bswapq %r8
movq %r8, %xmm3
movq (%rdx), %r8
bswapq %r8
movq 0x8(%rdx), %r10
movq %r8, %xmm2
bswapq %r9
maxsd %xmm2, %xmm3
movq %r9, %xmm2
bswapq %r10
movq %r10, %xmm4
minsd %xmm4, %xmm2
ucomisd %xmm2, %xmm3
jae 0x88888
subsd %xmm3, %xmm2
jmp 0x8885d
movl (%rsi), %r9d
movl 0x4(%rsi), %r10d
bswapl %r9d
movl (%rdx), %r11d
movl 0x4(%rdx), %r8d
bswapl %r11d
bswapl %r10d
bswapl %r8d
cmpl %r11d, %r9d
cmovgl %r9d, %r11d
cmpl %r8d, %r10d
cmovll %r10d, %r8d
subl %r11d, %r8d
jg 0x88639
jmp 0x88888
movzwl (%rsi), %r8d
movzwl 0x2(%rsi), %r9d
rolw $0x8, %r8w
movzwl %r8w, %r10d
movzwl (%rdx), %r8d
rolw $0x8, %r8w
movzwl 0x2(%rdx), %r11d
movzwl %r8w, %ebx
rolw $0x8, %r9w
movzwl %r9w, %r9d
rolw $0x8, %r11w
movzwl %r11w, %r8d
cmpl %ebx, %r10d
cmoval %r10d, %ebx
cmpl %r8d, %r9d
cmovbl %r9d, %r8d
subl %ebx, %r8d
jbe 0x88888
xorps %xmm2, %xmm2
cvtsi2sd %r8d, %xmm2
jmp 0x8885d
movl (%rsi), %r9d
movl 0x4(%rsi), %r10d
bswapl %r9d
movl (%rdx), %r11d
movl 0x4(%rdx), %r8d
bswapl %r11d
bswapl %r10d
bswapl %r8d
cmpl %r11d, %r9d
cmoval %r9d, %r11d
cmpl %r8d, %r10d
cmovbl %r10d, %r8d
subl %r11d, %r8d
jbe 0x88888
xorps %xmm2, %xmm2
cvtsi2sd %r8, %xmm2
jmp 0x8885d
movzbl (%rsi), %r9d
movzbl (%rdx), %r8d
leal 0x1(%r9), %r10d
leal 0x1(%r8), %r11d
cmpb %r8b, %r9b
cmovgl %r9d, %r8d
movzbl %r10b, %r10d
movzbl %r11b, %r9d
cmpb %r9b, %r10b
cmovll %r10d, %r9d
cmpb %r9b, %r8b
jge 0x88888
movsbl %r9b, %r9d
movsbl %r8b, %r8d
jmp 0x88740
movzwl (%rsi), %r10d
movzwl 0x2(%rsi), %r11d
rolw $0x8, %r10w
movzwl (%rdx), %r8d
movzwl 0x2(%rdx), %r9d
rolw $0x8, %r8w
rolw $0x8, %r11w
rolw $0x8, %r9w
cmpw %r8w, %r10w
cmovgl %r10d, %r8d
cmpw %r9w, %r11w
cmovll %r11d, %r9d
cmpw %r9w, %r8w
jge 0x88888
movswl %r9w, %r9d
movswl %r8w, %r8d
jmp 0x88740
movzbl (%rsi), %r9d
movzbl (%rdx), %r8d
leal 0x1(%r8), %r10d
cmpb %r8b, %r9b
cmoval %r9d, %r8d
incl %r9d
movzbl %r9b, %r11d
movzbl %r10b, %r9d
cmpb %r9b, %r11b
cmovbl %r11d, %r9d
cmpb %r9b, %r8b
jae 0x88888
movzbl %r9b, %r9d
movzbl %r8b, %r8d
subl %r8d, %r9d
xorps %xmm2, %xmm2
cvtsi2sd %r9d, %xmm2
jmp 0x8885d
movl (%rsi), %r8d
movl 0x4(%rsi), %r9d
bswapl %r8d
movd %r8d, %xmm2
movl (%rdx), %r8d
movl 0x4(%rdx), %r10d
bswapl %r8d
movd %r8d, %xmm3
maxss %xmm3, %xmm2
bswapl %r9d
movd %r9d, %xmm3
bswapl %r10d
movd %r10d, %xmm4
minss %xmm4, %xmm3
ucomiss %xmm3, %xmm2
jae 0x88888
subss %xmm2, %xmm3
xorps %xmm2, %xmm2
cvtss2sd %xmm3, %xmm2
jmp 0x8885d
orl %r10d, %r9d
addl %r9d, %r8d
addl $0xff000000, %r8d # imm = 0xFF000000
movzbl (%rdx), %ebx
movl %ebx, %r9d
shll $0x10, %r9d
movzbl 0x1(%rdx), %r10d
shll $0x8, %r10d
movzbl 0x2(%rdx), %r11d
testb %bl, %bl
js 0x887d0
orl %r11d, %r9d
orl %r10d, %r9d
jmp 0x887dd
orl %r11d, %r10d
addl %r10d, %r9d
addl $0xff000000, %r9d # imm = 0xFF000000
movzbl 0x3(%rsi), %r14d
movl %r14d, %r10d
shll $0x10, %r10d
movzbl 0x4(%rsi), %r11d
shll $0x8, %r11d
movzbl 0x5(%rsi), %ebx
testb %r14b, %r14b
js 0x88803
orl %ebx, %r10d
orl %r11d, %r10d
jmp 0x88810
orl %ebx, %r11d
addl %r11d, %r10d
addl $0xff000000, %r10d # imm = 0xFF000000
movzbl 0x3(%rdx), %r15d
movl %r15d, %r11d
shll $0x10, %r11d
movzbl 0x4(%rdx), %ebx
shll $0x8, %ebx
movzbl 0x5(%rdx), %r14d
testb %r15b, %r15b
js 0x88835
orl %r14d, %r11d
orl %ebx, %r11d
jmp 0x88842
orl %r14d, %ebx
addl %ebx, %r11d
addl $0xff000000, %r11d # imm = 0xFF000000
cmpl %r9d, %r8d
cmovgl %r8d, %r9d
cmpl %r11d, %r10d
cmovll %r10d, %r11d
subl %r9d, %r11d
jle 0x88888
xorps %xmm2, %xmm2
cvtsi2sd %r11d, %xmm2
mulsd %xmm2, %xmm0
movzwl -0x4(%rdi), %r8d
addl %r8d, %r8d
addq %r8, %rsi
addq %r8, %rdx
addq $0x40, %rdi
subl %r8d, %ecx
jg 0x8846e
jmp 0x8888c
movsd 0x7c77a(%rip), %xmm0 # 0x105000
jmp 0x8888c
xorpd %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movapd %xmm1, %xmm0
jmp 0x8888c
|
maria_rtree_overlapping_area:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
test ecx, ecx
jle loc_8887E
add rdi, 18h
movsd xmm0, cs:qword_105000
movsd xmm1, cs:qword_105038
lea rax, jpt_88483
loc_8846E:
movzx r8d, byte ptr [rdi]
cmp r8, 0Eh; switch 15 cases
ja def_88483; jumptable 0000000000088483 default case, cases 1,7
movsxd r8, ds:(jpt_88483 - 1058A4h)[rax+r8*4]
add r8, rax
jmp r8; switch jump
loc_88486:
mov r9, [rsi]; jumptable 0000000000088483 cases 10,11
mov r10, [rsi+8]
bswap r9
mov r11, [rdx]
mov r8, [rdx+8]
bswap r11
bswap r10
bswap r8
cmp r9, r11
cmovg r11, r9
cmp r10, r8
cmovl r8, r10
sub r8, r11
jg loc_88677
jmp loc_88888
loc_884BC:
movzx r11d, byte ptr [rsi]; jumptable 0000000000088483 case 12
mov r8d, r11d
shl r8d, 10h
movzx r9d, byte ptr [rsi+1]
shl r9d, 8
movzx r10d, byte ptr [rsi+2]
test r11b, r11b
js loc_8879F
or r8d, r10d
or r8d, r9d
jmp loc_887AC
loc_884E9:
movzx r8d, word ptr [rsi+1]; jumptable 0000000000088483 case 13
movzx r9d, word ptr [rsi+4]
rol r8w, 8
movzx r10d, r8w
movzx r8d, byte ptr [rsi]
shl r8d, 10h
or r8d, r10d
movzx r10d, word ptr [rdx+1]
movzx r11d, word ptr [rdx+4]
rol r10w, 8
movzx r10d, r10w
movzx ebx, byte ptr [rdx]
shl ebx, 10h
or ebx, r10d
rol r9w, 8
movzx r9d, r9w
movzx r10d, byte ptr [rsi+3]
shl r10d, 10h
or r10d, r9d
rol r11w, 8
movzx r11d, r11w
movzx r9d, byte ptr [rdx+3]
shl r9d, 10h
or r9d, r11d
cmp r8d, ebx
cmova ebx, r8d
cmp r10d, r9d
cmovb r9d, r10d
sub r9d, ebx
jbe loc_88888
xorps xmm2, xmm2
cvtsi2sd xmm2, r9
jmp loc_8885D
loc_88571:
mov r8, [rsi]; jumptable 0000000000088483 case 6
mov r9, [rsi+8]
bswap r8
movq xmm3, r8
mov r8, [rdx]
bswap r8
mov r10, [rdx+8]
movq xmm2, r8
bswap r9
maxsd xmm3, xmm2
movq xmm2, r9
bswap r10
movq xmm4, r10
minsd xmm2, xmm4
ucomisd xmm3, xmm2
jnb loc_88888
subsd xmm2, xmm3
jmp loc_8885D
loc_885BA:
mov r9d, [rsi]; jumptable 0000000000088483 case 4
mov r10d, [rsi+4]
bswap r9d
mov r11d, [rdx]
mov r8d, [rdx+4]
bswap r11d
bswap r10d
bswap r8d
cmp r9d, r11d
cmovg r11d, r9d
cmp r10d, r8d
cmovl r8d, r10d
sub r8d, r11d
jg short loc_88639
jmp loc_88888
loc_885EC:
movzx r8d, word ptr [rsi]; jumptable 0000000000088483 case 8
movzx r9d, word ptr [rsi+2]
rol r8w, 8
movzx r10d, r8w
movzx r8d, word ptr [rdx]
rol r8w, 8
movzx r11d, word ptr [rdx+2]
movzx ebx, r8w
rol r9w, 8
movzx r9d, r9w
rol r11w, 8
movzx r8d, r11w
cmp r10d, ebx
cmova ebx, r10d
cmp r9d, r8d
cmovb r8d, r9d
sub r8d, ebx
jbe loc_88888
loc_88639:
xorps xmm2, xmm2
cvtsi2sd xmm2, r8d
jmp loc_8885D
loc_88646:
mov r9d, [rsi]; jumptable 0000000000088483 case 9
mov r10d, [rsi+4]
bswap r9d
mov r11d, [rdx]
mov r8d, [rdx+4]
bswap r11d
bswap r10d
bswap r8d
cmp r9d, r11d
cmova r11d, r9d
cmp r10d, r8d
cmovb r8d, r10d
sub r8d, r11d
jbe loc_88888
loc_88677:
xorps xmm2, xmm2
cvtsi2sd xmm2, r8
jmp loc_8885D
loc_88684:
movzx r9d, byte ptr [rsi]; jumptable 0000000000088483 case 14
movzx r8d, byte ptr [rdx]
lea r10d, [r9+1]
lea r11d, [r8+1]
cmp r9b, r8b
cmovg r8d, r9d
movzx r10d, r10b
movzx r9d, r11b
cmp r10b, r9b
cmovl r9d, r10d
cmp r8b, r9b
jge loc_88888
movsx r9d, r9b
movsx r8d, r8b
jmp loc_88740
loc_886C0:
movzx r10d, word ptr [rsi]; jumptable 0000000000088483 case 3
movzx r11d, word ptr [rsi+2]
rol r10w, 8
movzx r8d, word ptr [rdx]
movzx r9d, word ptr [rdx+2]
rol r8w, 8
rol r11w, 8
rol r9w, 8
cmp r10w, r8w
cmovg r8d, r10d
cmp r11w, r9w
cmovl r9d, r11d
cmp r8w, r9w
jge loc_88888
movsx r9d, r9w
movsx r8d, r8w
jmp short loc_88740
loc_8870A:
movzx r9d, byte ptr [rsi]; jumptable 0000000000088483 case 2
movzx r8d, byte ptr [rdx]
lea r10d, [r8+1]
cmp r9b, r8b
cmova r8d, r9d
inc r9d
movzx r11d, r9b
movzx r9d, r10b
cmp r11b, r9b
cmovb r9d, r11d
cmp r8b, r9b
jnb loc_88888
movzx r9d, r9b
movzx r8d, r8b
loc_88740:
sub r9d, r8d
xorps xmm2, xmm2
cvtsi2sd xmm2, r9d
jmp loc_8885D
loc_88750:
mov r8d, [rsi]; jumptable 0000000000088483 case 5
mov r9d, [rsi+4]
bswap r8d
movd xmm2, r8d
mov r8d, [rdx]
mov r10d, [rdx+4]
bswap r8d
movd xmm3, r8d
maxss xmm2, xmm3
bswap r9d
movd xmm3, r9d
bswap r10d
movd xmm4, r10d
minss xmm3, xmm4
ucomiss xmm2, xmm3
jnb loc_88888
subss xmm3, xmm2
xorps xmm2, xmm2
cvtss2sd xmm2, xmm3
jmp loc_8885D
loc_8879F:
or r9d, r10d
add r8d, r9d
add r8d, 0FF000000h
loc_887AC:
movzx ebx, byte ptr [rdx]
mov r9d, ebx
shl r9d, 10h
movzx r10d, byte ptr [rdx+1]
shl r10d, 8
movzx r11d, byte ptr [rdx+2]
test bl, bl
js short loc_887D0
or r9d, r11d
or r9d, r10d
jmp short loc_887DD
loc_887D0:
or r10d, r11d
add r9d, r10d
add r9d, 0FF000000h
loc_887DD:
movzx r14d, byte ptr [rsi+3]
mov r10d, r14d
shl r10d, 10h
movzx r11d, byte ptr [rsi+4]
shl r11d, 8
movzx ebx, byte ptr [rsi+5]
test r14b, r14b
js short loc_88803
or r10d, ebx
or r10d, r11d
jmp short loc_88810
loc_88803:
or r11d, ebx
add r10d, r11d
add r10d, 0FF000000h
loc_88810:
movzx r15d, byte ptr [rdx+3]
mov r11d, r15d
shl r11d, 10h
movzx ebx, byte ptr [rdx+4]
shl ebx, 8
movzx r14d, byte ptr [rdx+5]
test r15b, r15b
js short loc_88835
or r11d, r14d
or r11d, ebx
jmp short loc_88842
loc_88835:
or ebx, r14d
add r11d, ebx
add r11d, 0FF000000h
loc_88842:
cmp r8d, r9d
cmovg r9d, r8d
cmp r10d, r11d
cmovl r11d, r10d
sub r11d, r9d
jle short loc_88888
xorps xmm2, xmm2
cvtsi2sd xmm2, r11d
loc_8885D:
mulsd xmm0, xmm2
movzx r8d, word ptr [rdi-4]
add r8d, r8d
add rsi, r8
add rdx, r8
add rdi, 40h ; '@'
sub ecx, r8d
jg loc_8846E
jmp short loc_8888C; jumptable 0000000000088483 case 0
loc_8887E:
movsd xmm0, cs:qword_105000
jmp short loc_8888C; jumptable 0000000000088483 case 0
loc_88888:
xorpd xmm0, xmm0
loc_8888C:
pop rbx; jumptable 0000000000088483 case 0
pop r14
pop r15
pop rbp
retn
def_88483:
movapd xmm0, xmm1; jumptable 0000000000088483 default case, cases 1,7
jmp short loc_8888C; jumptable 0000000000088483 case 0
|
double maria_rtree_overlapping_area(long long a1, _WORD *a2, _WORD *a3, int a4)
{
_BYTE *v4; // rdi
double result; // xmm0_8
signed long long v6; // r9
signed long long v7; // r11
signed long long v8; // r10
signed long long v9; // r8
bool v10; // cc
int v11; // r8d
int v12; // r8d
int v13; // r9d
int v14; // r10d
int v15; // r8d
unsigned int v16; // r8d
unsigned int v17; // ebx
unsigned int v18; // r10d
unsigned int v19; // r9d
int v20; // r9d
double v21; // xmm2_8
double v22; // xmm3_8
double v23; // xmm2_8
signed __int32 v24; // r9d
signed __int32 v25; // r11d
signed __int32 v26; // r10d
signed __int32 v27; // r8d
int v28; // r8d
unsigned int v29; // r10d
unsigned int v30; // ebx
unsigned int v31; // r9d
unsigned int v32; // r8d
unsigned __int32 v33; // r9d
unsigned __int32 v34; // r11d
unsigned __int32 v35; // r10d
unsigned __int32 v36; // r8d
int v37; // r8d
int v38; // r9d
__int16 v39; // r10
__int16 v40; // r11
float v41; // xmm2_4
float v42; // xmm3_4
int v43; // r9d
int v44; // r10d
int v45; // r11d
int v46; // r9d
int v47; // r10d
int v48; // r11d
int v49; // ebx
int v50; // r10d
int v51; // r11d
int v52; // ebx
int v53; // r14d
int v54; // r11d
int v55; // r11d
long long v56; // r8
if ( a4 <= 0 )
return 1.0;
v4 = (_BYTE *)(a1 + 24);
result = 1.0;
while ( 2 )
{
switch ( *v4 )
{
case 0:
return result;
case 2:
LOBYTE(v37) = *(_BYTE *)a3;
if ( *(_BYTE *)a2 > *(_BYTE *)a3 )
LOBYTE(v37) = *(_BYTE *)a2;
LOBYTE(v38) = *(_BYTE *)a3 + 1;
if ( (unsigned __int8)(*(_BYTE *)a2 + 1) < (unsigned __int8)v38 )
LOBYTE(v38) = *(_BYTE *)a2 + 1;
if ( (unsigned __int8)v37 >= (unsigned __int8)v38 )
return 0.0;
v38 = (unsigned __int8)v38;
v37 = (unsigned __int8)v37;
goto LABEL_56;
case 3:
v39 = __ROL2__(*a2, 8);
LOWORD(v37) = __ROL2__(*a3, 8);
v40 = __ROL2__(a2[1], 8);
LOWORD(v38) = __ROL2__(a3[1], 8);
if ( v39 > (__int16)v37 )
LOWORD(v37) = v39;
if ( v40 < (__int16)v38 )
LOWORD(v38) = v40;
if ( (__int16)v37 >= (__int16)v38 )
return 0.0;
v38 = (__int16)v38;
v37 = (__int16)v37;
goto LABEL_56;
case 4:
v24 = _byteswap_ulong(*(_DWORD *)a2);
v25 = _byteswap_ulong(*(_DWORD *)a3);
v26 = _byteswap_ulong(*((_DWORD *)a2 + 1));
v27 = _byteswap_ulong(*((_DWORD *)a3 + 1));
if ( v24 > v25 )
v25 = v24;
if ( v26 < v27 )
v27 = v26;
v10 = v27 <= v25;
v28 = v27 - v25;
if ( v10 )
return 0.0;
goto LABEL_31;
case 5:
v41 = fmaxf(COERCE_FLOAT(_byteswap_ulong(*(_DWORD *)a2)), COERCE_FLOAT(_byteswap_ulong(*(_DWORD *)a3)));
v42 = fminf(
COERCE_FLOAT(_byteswap_ulong(*((_DWORD *)a2 + 1))),
COERCE_FLOAT(_byteswap_ulong(*((_DWORD *)a3 + 1))));
if ( v41 >= v42 )
return 0.0;
v21 = (float)(v42 - v41);
goto LABEL_75;
case 6:
v22 = fmax(COERCE_DOUBLE(_byteswap_uint64(*(_QWORD *)a2)), COERCE_DOUBLE(_byteswap_uint64(*(_QWORD *)a3)));
v23 = fmin(
COERCE_DOUBLE(_byteswap_uint64(*((_QWORD *)a2 + 1))),
COERCE_DOUBLE(_byteswap_uint64(*((_QWORD *)a3 + 1))));
if ( v22 >= v23 )
return 0.0;
v21 = v23 - v22;
goto LABEL_75;
case 8:
v29 = (unsigned __int16)__ROL2__(*a2, 8);
v30 = (unsigned __int16)__ROL2__(*a3, 8);
v31 = (unsigned __int16)__ROL2__(a2[1], 8);
v32 = (unsigned __int16)__ROL2__(a3[1], 8);
if ( v29 > v30 )
v30 = v29;
if ( v31 < v32 )
v32 = v31;
v10 = v32 <= v30;
v28 = v32 - v30;
if ( v10 )
return 0.0;
LABEL_31:
v21 = (double)v28;
goto LABEL_75;
case 9:
v33 = _byteswap_ulong(*(_DWORD *)a2);
v34 = _byteswap_ulong(*(_DWORD *)a3);
v35 = _byteswap_ulong(*((_DWORD *)a2 + 1));
v36 = _byteswap_ulong(*((_DWORD *)a3 + 1));
if ( v33 > v34 )
v34 = v33;
if ( v35 < v36 )
v36 = v35;
v10 = v36 <= v34;
v11 = v36 - v34;
if ( !v10 )
goto LABEL_37;
return 0.0;
case 0xA:
case 0xB:
v6 = _byteswap_uint64(*(_QWORD *)a2);
v7 = _byteswap_uint64(*(_QWORD *)a3);
v8 = _byteswap_uint64(*((_QWORD *)a2 + 1));
v9 = _byteswap_uint64(*((_QWORD *)a3 + 1));
if ( v6 > v7 )
v7 = v6;
if ( v8 < v9 )
v9 = v8;
v10 = v9 <= v7;
v11 = v9 - v7;
if ( v10 )
return 0.0;
LABEL_37:
v21 = (double)v11;
goto LABEL_75;
case 0xC:
v12 = *(unsigned __int8 *)a2 << 16;
v13 = *((unsigned __int8 *)a2 + 1) << 8;
v14 = *((unsigned __int8 *)a2 + 2);
if ( *(char *)a2 < 0 )
v15 = (v14 | v13) + v12 - 0x1000000;
else
v15 = v13 | v14 | v12;
v43 = *(unsigned __int8 *)a3 << 16;
v44 = *((unsigned __int8 *)a3 + 1) << 8;
v45 = *((unsigned __int8 *)a3 + 2);
if ( *(char *)a3 < 0 )
v46 = (v45 | v44) + v43 - 0x1000000;
else
v46 = v44 | v45 | v43;
v47 = *((unsigned __int8 *)a2 + 3) << 16;
v48 = *((unsigned __int8 *)a2 + 4) << 8;
v49 = *((unsigned __int8 *)a2 + 5);
if ( *((char *)a2 + 3) < 0 )
v50 = (v49 | v48) + v47 - 0x1000000;
else
v50 = v48 | v49 | v47;
v51 = *((unsigned __int8 *)a3 + 3) << 16;
v52 = *((unsigned __int8 *)a3 + 4) << 8;
v53 = *((unsigned __int8 *)a3 + 5);
if ( *((char *)a3 + 3) < 0 )
v54 = (v53 | v52) + v51 - 0x1000000;
else
v54 = v52 | v53 | v51;
if ( v15 > v46 )
v46 = v15;
if ( v50 < v54 )
v54 = v50;
v10 = v54 <= v46;
v55 = v54 - v46;
if ( v10 )
return 0.0;
v21 = (double)v55;
goto LABEL_75;
case 0xD:
v16 = (unsigned __int16)__ROL2__(*(_WORD *)((char *)a2 + 1), 8) | (*(unsigned __int8 *)a2 << 16);
v17 = (unsigned __int16)__ROL2__(*(_WORD *)((char *)a3 + 1), 8) | (*(unsigned __int8 *)a3 << 16);
v18 = (unsigned __int16)__ROL2__(a2[2], 8) | (*((unsigned __int8 *)a2 + 3) << 16);
v19 = (unsigned __int16)__ROL2__(a3[2], 8) | (*((unsigned __int8 *)a3 + 3) << 16);
if ( v16 > v17 )
v17 = v16;
if ( v18 < v19 )
v19 = v18;
v10 = v19 <= v17;
v20 = v19 - v17;
if ( v10 )
return 0.0;
v21 = (double)v20;
goto LABEL_75;
case 0xE:
LOBYTE(v37) = *(_BYTE *)a3;
if ( *(_BYTE *)a2 > *(_BYTE *)a3 )
LOBYTE(v37) = *(_BYTE *)a2;
LOBYTE(v38) = *(_BYTE *)a3 + 1;
if ( (char)(*(_BYTE *)a2 + 1) < (char)v38 )
LOBYTE(v38) = *(_BYTE *)a2 + 1;
if ( (char)v37 < (char)v38 )
{
v38 = (char)v38;
v37 = (char)v37;
LABEL_56:
v21 = (double)(v38 - v37);
LABEL_75:
result = result * v21;
v56 = 2 * (unsigned int)*((unsigned __int16 *)v4 - 2);
a2 = (_WORD *)((char *)a2 + v56);
a3 = (_WORD *)((char *)a3 + v56);
v4 += 64;
v10 = a4 <= (int)v56;
a4 -= v56;
if ( v10 )
return result;
continue;
}
return 0.0;
default:
return -1.0;
}
}
}
|
maria_rtree_overlapping_area:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
TEST ECX,ECX
JLE 0x0018887e
ADD RDI,0x18
MOVSD XMM0,qword ptr [0x00205000]
MOVSD XMM1,qword ptr [0x00205038]
LEA RAX,[0x2058a4]
LAB_0018846e:
MOVZX R8D,byte ptr [RDI]
CMP R8,0xe
JA 0x00188893
MOVSXD R8,dword ptr [RAX + R8*0x4]
ADD R8,RAX
switchD:
JMP R8
caseD_a:
MOV R9,qword ptr [RSI]
MOV R10,qword ptr [RSI + 0x8]
BSWAP R9
MOV R11,qword ptr [RDX]
MOV R8,qword ptr [RDX + 0x8]
BSWAP R11
BSWAP R10
BSWAP R8
CMP R9,R11
CMOVG R11,R9
CMP R10,R8
CMOVL R8,R10
SUB R8,R11
JG 0x00188677
JMP 0x00188888
caseD_c:
MOVZX R11D,byte ptr [RSI]
MOV R8D,R11D
SHL R8D,0x10
MOVZX R9D,byte ptr [RSI + 0x1]
SHL R9D,0x8
MOVZX R10D,byte ptr [RSI + 0x2]
TEST R11B,R11B
JS 0x0018879f
OR R8D,R10D
OR R8D,R9D
JMP 0x001887ac
caseD_d:
MOVZX R8D,word ptr [RSI + 0x1]
MOVZX R9D,word ptr [RSI + 0x4]
ROL R8W,0x8
MOVZX R10D,R8W
MOVZX R8D,byte ptr [RSI]
SHL R8D,0x10
OR R8D,R10D
MOVZX R10D,word ptr [RDX + 0x1]
MOVZX R11D,word ptr [RDX + 0x4]
ROL R10W,0x8
MOVZX R10D,R10W
MOVZX EBX,byte ptr [RDX]
SHL EBX,0x10
OR EBX,R10D
ROL R9W,0x8
MOVZX R9D,R9W
MOVZX R10D,byte ptr [RSI + 0x3]
SHL R10D,0x10
OR R10D,R9D
ROL R11W,0x8
MOVZX R11D,R11W
MOVZX R9D,byte ptr [RDX + 0x3]
SHL R9D,0x10
OR R9D,R11D
CMP R8D,EBX
CMOVA EBX,R8D
CMP R10D,R9D
CMOVC R9D,R10D
SUB R9D,EBX
JBE 0x00188888
XORPS XMM2,XMM2
CVTSI2SD XMM2,R9
JMP 0x0018885d
caseD_6:
MOV R8,qword ptr [RSI]
MOV R9,qword ptr [RSI + 0x8]
BSWAP R8
MOVQ XMM3,R8
MOV R8,qword ptr [RDX]
BSWAP R8
MOV R10,qword ptr [RDX + 0x8]
MOVQ XMM2,R8
BSWAP R9
MAXSD XMM3,XMM2
MOVQ XMM2,R9
BSWAP R10
MOVQ XMM4,R10
MINSD XMM2,XMM4
UCOMISD XMM3,XMM2
JNC 0x00188888
SUBSD XMM2,XMM3
JMP 0x0018885d
caseD_4:
MOV R9D,dword ptr [RSI]
MOV R10D,dword ptr [RSI + 0x4]
BSWAP R9D
MOV R11D,dword ptr [RDX]
MOV R8D,dword ptr [RDX + 0x4]
BSWAP R11D
BSWAP R10D
BSWAP R8D
CMP R9D,R11D
CMOVG R11D,R9D
CMP R10D,R8D
CMOVL R8D,R10D
SUB R8D,R11D
JG 0x00188639
JMP 0x00188888
caseD_8:
MOVZX R8D,word ptr [RSI]
MOVZX R9D,word ptr [RSI + 0x2]
ROL R8W,0x8
MOVZX R10D,R8W
MOVZX R8D,word ptr [RDX]
ROL R8W,0x8
MOVZX R11D,word ptr [RDX + 0x2]
MOVZX EBX,R8W
ROL R9W,0x8
MOVZX R9D,R9W
ROL R11W,0x8
MOVZX R8D,R11W
CMP R10D,EBX
CMOVA EBX,R10D
CMP R9D,R8D
CMOVC R8D,R9D
SUB R8D,EBX
JBE 0x00188888
LAB_00188639:
XORPS XMM2,XMM2
CVTSI2SD XMM2,R8D
JMP 0x0018885d
caseD_9:
MOV R9D,dword ptr [RSI]
MOV R10D,dword ptr [RSI + 0x4]
BSWAP R9D
MOV R11D,dword ptr [RDX]
MOV R8D,dword ptr [RDX + 0x4]
BSWAP R11D
BSWAP R10D
BSWAP R8D
CMP R9D,R11D
CMOVA R11D,R9D
CMP R10D,R8D
CMOVC R8D,R10D
SUB R8D,R11D
JBE 0x00188888
LAB_00188677:
XORPS XMM2,XMM2
CVTSI2SD XMM2,R8
JMP 0x0018885d
caseD_e:
MOVZX R9D,byte ptr [RSI]
MOVZX R8D,byte ptr [RDX]
LEA R10D,[R9 + 0x1]
LEA R11D,[R8 + 0x1]
CMP R9B,R8B
CMOVG R8D,R9D
MOVZX R10D,R10B
MOVZX R9D,R11B
CMP R10B,R9B
CMOVL R9D,R10D
CMP R8B,R9B
JGE 0x00188888
MOVSX R9D,R9B
MOVSX R8D,R8B
JMP 0x00188740
caseD_3:
MOVZX R10D,word ptr [RSI]
MOVZX R11D,word ptr [RSI + 0x2]
ROL R10W,0x8
MOVZX R8D,word ptr [RDX]
MOVZX R9D,word ptr [RDX + 0x2]
ROL R8W,0x8
ROL R11W,0x8
ROL R9W,0x8
CMP R10W,R8W
CMOVG R8D,R10D
CMP R11W,R9W
CMOVL R9D,R11D
CMP R8W,R9W
JGE 0x00188888
MOVSX R9D,R9W
MOVSX R8D,R8W
JMP 0x00188740
caseD_2:
MOVZX R9D,byte ptr [RSI]
MOVZX R8D,byte ptr [RDX]
LEA R10D,[R8 + 0x1]
CMP R9B,R8B
CMOVA R8D,R9D
INC R9D
MOVZX R11D,R9B
MOVZX R9D,R10B
CMP R11B,R9B
CMOVC R9D,R11D
CMP R8B,R9B
JNC 0x00188888
MOVZX R9D,R9B
MOVZX R8D,R8B
LAB_00188740:
SUB R9D,R8D
XORPS XMM2,XMM2
CVTSI2SD XMM2,R9D
JMP 0x0018885d
caseD_5:
MOV R8D,dword ptr [RSI]
MOV R9D,dword ptr [RSI + 0x4]
BSWAP R8D
MOVD XMM2,R8D
MOV R8D,dword ptr [RDX]
MOV R10D,dword ptr [RDX + 0x4]
BSWAP R8D
MOVD XMM3,R8D
MAXSS XMM2,XMM3
BSWAP R9D
MOVD XMM3,R9D
BSWAP R10D
MOVD XMM4,R10D
MINSS XMM3,XMM4
UCOMISS XMM2,XMM3
JNC 0x00188888
SUBSS XMM3,XMM2
XORPS XMM2,XMM2
CVTSS2SD XMM2,XMM3
JMP 0x0018885d
LAB_0018879f:
OR R9D,R10D
ADD R8D,R9D
ADD R8D,0xff000000
LAB_001887ac:
MOVZX EBX,byte ptr [RDX]
MOV R9D,EBX
SHL R9D,0x10
MOVZX R10D,byte ptr [RDX + 0x1]
SHL R10D,0x8
MOVZX R11D,byte ptr [RDX + 0x2]
TEST BL,BL
JS 0x001887d0
OR R9D,R11D
OR R9D,R10D
JMP 0x001887dd
LAB_001887d0:
OR R10D,R11D
ADD R9D,R10D
ADD R9D,0xff000000
LAB_001887dd:
MOVZX R14D,byte ptr [RSI + 0x3]
MOV R10D,R14D
SHL R10D,0x10
MOVZX R11D,byte ptr [RSI + 0x4]
SHL R11D,0x8
MOVZX EBX,byte ptr [RSI + 0x5]
TEST R14B,R14B
JS 0x00188803
OR R10D,EBX
OR R10D,R11D
JMP 0x00188810
LAB_00188803:
OR R11D,EBX
ADD R10D,R11D
ADD R10D,0xff000000
LAB_00188810:
MOVZX R15D,byte ptr [RDX + 0x3]
MOV R11D,R15D
SHL R11D,0x10
MOVZX EBX,byte ptr [RDX + 0x4]
SHL EBX,0x8
MOVZX R14D,byte ptr [RDX + 0x5]
TEST R15B,R15B
JS 0x00188835
OR R11D,R14D
OR R11D,EBX
JMP 0x00188842
LAB_00188835:
OR EBX,R14D
ADD R11D,EBX
ADD R11D,0xff000000
LAB_00188842:
CMP R8D,R9D
CMOVG R9D,R8D
CMP R10D,R11D
CMOVL R11D,R10D
SUB R11D,R9D
JLE 0x00188888
XORPS XMM2,XMM2
CVTSI2SD XMM2,R11D
LAB_0018885d:
MULSD XMM0,XMM2
MOVZX R8D,word ptr [RDI + -0x4]
ADD R8D,R8D
ADD RSI,R8
ADD RDX,R8
ADD RDI,0x40
SUB ECX,R8D
JG 0x0018846e
JMP 0x0018888c
LAB_0018887e:
MOVSD XMM0,qword ptr [0x00205000]
JMP 0x0018888c
LAB_00188888:
XORPD XMM0,XMM0
caseD_0:
POP RBX
POP R14
POP R15
POP RBP
RET
caseD_1:
MOVAPD XMM0,XMM1
JMP 0x0018888c
|
double maria_rtree_overlapping_area(long param_1,ulong *param_2,ulong *param_3,int param_4)
{
ushort *puVar1;
byte bVar2;
byte bVar3;
ulong uVar4;
int1 *puVar5;
byte bVar6;
ushort uVar7;
uint uVar8;
int iVar9;
uint uVar10;
float fVar11;
float fVar12;
ulong uVar13;
double dVar14;
double dVar15;
char cVar16;
byte bVar17;
ushort uVar18;
uint uVar19;
ulong uVar20;
ushort uVar21;
uint uVar22;
uint uVar23;
float fVar24;
ulong uVar25;
ushort uVar26;
ulong uVar27;
bool bVar28;
double dVar29;
double dVar30;
dVar29 = DAT_00205000;
if (param_4 < 1) {
switchD_00188483_caseD_0:
return dVar29;
}
puVar5 = (int1 *)(param_1 + 0x18);
do {
switch(*puVar5) {
case 0:
goto switchD_00188483_caseD_0;
default:
return DAT_00205038;
case 2:
bVar2 = (byte)*param_2;
bVar3 = (byte)*param_3;
bVar6 = bVar3;
if (bVar3 < bVar2) {
bVar6 = bVar2;
}
bVar17 = bVar3 + 1;
if ((byte)(bVar2 + 1) < (byte)(bVar3 + 1)) {
bVar17 = bVar2 + 1;
}
if (bVar17 <= bVar6) {
return 0.0;
}
uVar19 = (uint)bVar17;
uVar10 = (uint)bVar6;
goto LAB_00188740;
case 3:
uVar21 = (ushort)*param_2 << 8 | (ushort)*param_2 >> 8;
uVar7 = (ushort)*param_3 << 8 | (ushort)*param_3 >> 8;
uVar26 = *(ushort *)((long)param_2 + 2) << 8 | *(ushort *)((long)param_2 + 2) >> 8;
uVar18 = *(ushort *)((long)param_3 + 2) << 8 | *(ushort *)((long)param_3 + 2) >> 8;
if ((short)uVar7 < (short)uVar21) {
uVar7 = uVar21;
}
if ((short)uVar26 < (short)uVar18) {
uVar18 = uVar26;
}
if ((short)uVar18 <= (short)uVar7) {
return 0.0;
}
uVar19 = (uint)(short)uVar18;
uVar10 = (uint)(short)uVar7;
goto LAB_00188740;
case 4:
uVar10 = (uint)*param_2;
uVar19 = *(uint *)((long)param_2 + 4);
uVar22 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar10 = (uint)*param_3;
uVar8 = *(uint *)((long)param_3 + 4);
uVar10 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar23 = uVar19 >> 0x18 | (uVar19 & 0xff0000) >> 8 | (uVar19 & 0xff00) << 8 | uVar19 << 0x18;
uVar19 = uVar8 >> 0x18 | (uVar8 & 0xff0000) >> 8 | (uVar8 & 0xff00) << 8 | uVar8 << 0x18;
if ((int)uVar10 < (int)uVar22) {
uVar10 = uVar22;
}
if ((int)uVar23 < (int)uVar19) {
uVar19 = uVar23;
}
iVar9 = uVar19 - uVar10;
if (iVar9 == 0 || (int)uVar19 < (int)uVar10) {
return 0.0;
}
goto LAB_00188639;
case 5:
uVar10 = (uint)*param_2;
uVar19 = *(uint *)((long)param_2 + 4);
fVar11 = (float)(uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 |
uVar10 << 0x18);
uVar10 = (uint)*param_3;
uVar8 = *(uint *)((long)param_3 + 4);
fVar12 = (float)(uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 |
uVar10 << 0x18);
if (fVar11 <= fVar12) {
fVar11 = fVar12;
}
fVar12 = (float)(uVar19 >> 0x18 | (uVar19 & 0xff0000) >> 8 | (uVar19 & 0xff00) << 8 |
uVar19 << 0x18);
fVar24 = (float)(uVar8 >> 0x18 | (uVar8 & 0xff0000) >> 8 | (uVar8 & 0xff00) << 8 |
uVar8 << 0x18);
if (fVar24 <= fVar12) {
fVar12 = fVar24;
}
if (fVar12 <= fVar11) {
return 0.0;
}
dVar30 = (double)(fVar12 - fVar11);
break;
case 6:
uVar13 = *param_2;
uVar25 = param_2[1];
dVar14 = (double)(uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 |
(uVar13 & 0xff00) << 0x28 | uVar13 << 0x38);
uVar13 = *param_3;
dVar15 = (double)(uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 |
(uVar13 & 0xff00) << 0x28 | uVar13 << 0x38);
uVar13 = param_3[1];
dVar30 = (double)(uVar25 >> 0x38 | (uVar25 & 0xff000000000000) >> 0x28 |
(uVar25 & 0xff0000000000) >> 0x18 | (uVar25 & 0xff00000000) >> 8 |
(uVar25 & 0xff000000) << 8 | (uVar25 & 0xff0000) << 0x18 |
(uVar25 & 0xff00) << 0x28 | uVar25 << 0x38);
if (dVar14 <= dVar15) {
dVar14 = dVar15;
}
dVar15 = (double)(uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 |
(uVar13 & 0xff00) << 0x28 | uVar13 << 0x38);
if (dVar15 <= dVar30) {
dVar30 = dVar15;
}
if (dVar30 <= dVar14) {
return 0.0;
}
dVar30 = dVar30 - dVar14;
break;
case 8:
uVar7 = (ushort)*param_3 << 8 | (ushort)*param_3 >> 8;
uVar19 = (uint)(ushort)((ushort)*param_2 << 8 | (ushort)*param_2 >> 8);
uVar10 = (uint)uVar7;
if (uVar7 < uVar19) {
uVar10 = uVar19;
}
uVar8 = (uint)(ushort)(*(ushort *)((long)param_2 + 2) << 8 |
*(ushort *)((long)param_2 + 2) >> 8);
uVar19 = (uint)(ushort)(*(ushort *)((long)param_3 + 2) << 8 |
*(ushort *)((long)param_3 + 2) >> 8);
if (uVar8 < uVar19) {
uVar19 = uVar8;
}
iVar9 = uVar19 - uVar10;
if (uVar19 < uVar10 || iVar9 == 0) {
return 0.0;
}
LAB_00188639:
dVar30 = (double)iVar9;
break;
case 9:
uVar10 = (uint)*param_2;
uVar19 = *(uint *)((long)param_2 + 4);
uVar22 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar10 = (uint)*param_3;
uVar8 = *(uint *)((long)param_3 + 4);
uVar10 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar23 = uVar19 >> 0x18 | (uVar19 & 0xff0000) >> 8 | (uVar19 & 0xff00) << 8 | uVar19 << 0x18;
uVar19 = uVar8 >> 0x18 | (uVar8 & 0xff0000) >> 8 | (uVar8 & 0xff00) << 8 | uVar8 << 0x18;
if (uVar10 < uVar22) {
uVar10 = uVar22;
}
if (uVar23 < uVar19) {
uVar19 = uVar23;
}
uVar25 = (ulong)(uVar19 - uVar10);
if (uVar19 < uVar10 || uVar19 - uVar10 == 0) {
return 0.0;
}
goto LAB_00188677;
case 10:
case 0xb:
uVar13 = *param_2;
uVar25 = param_2[1];
uVar20 = uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 | (uVar13 & 0xff00) << 0x28
| uVar13 << 0x38;
uVar13 = *param_3;
uVar4 = param_3[1];
uVar27 = uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 | (uVar13 & 0xff00) << 0x28
| uVar13 << 0x38;
uVar25 = uVar25 >> 0x38 | (uVar25 & 0xff000000000000) >> 0x28 |
(uVar25 & 0xff0000000000) >> 0x18 | (uVar25 & 0xff00000000) >> 8 |
(uVar25 & 0xff000000) << 8 | (uVar25 & 0xff0000) << 0x18 | (uVar25 & 0xff00) << 0x28
| uVar25 << 0x38;
uVar13 = uVar4 >> 0x38 | (uVar4 & 0xff000000000000) >> 0x28 | (uVar4 & 0xff0000000000) >> 0x18
| (uVar4 & 0xff00000000) >> 8 | (uVar4 & 0xff000000) << 8 |
(uVar4 & 0xff0000) << 0x18 | (uVar4 & 0xff00) << 0x28 | uVar4 << 0x38;
if ((long)uVar27 < (long)uVar20) {
uVar27 = uVar20;
}
if ((long)uVar25 < (long)uVar13) {
uVar13 = uVar25;
}
uVar25 = uVar13 - uVar27;
if (uVar25 == 0 || (long)uVar13 < (long)uVar27) {
return 0.0;
}
LAB_00188677:
dVar30 = (double)(long)uVar25;
break;
case 0xc:
uVar10 = (uint)(byte)*param_2 * 0x10000;
if ((char)(byte)*param_2 < '\0') {
uVar10 = (uVar10 + CONCAT11(*(byte *)((long)param_2 + 1),*(byte *)((long)param_2 + 2))) -
0x1000000;
}
else {
uVar10 = uVar10 | *(byte *)((long)param_2 + 2) | (uint)*(byte *)((long)param_2 + 1) << 8;
}
uVar19 = (uint)(byte)*param_3 * 0x10000;
if ((char)(byte)*param_3 < '\0') {
uVar19 = (uVar19 + CONCAT11(*(byte *)((long)param_3 + 1),*(byte *)((long)param_3 + 2))) -
0x1000000;
}
else {
uVar19 = uVar19 | *(byte *)((long)param_3 + 2) | (uint)*(byte *)((long)param_3 + 1) << 8;
}
uVar8 = (uint)*(byte *)((long)param_2 + 3) * 0x10000;
if ((char)*(byte *)((long)param_2 + 3) < '\0') {
uVar8 = (uVar8 + CONCAT11(*(byte *)((long)param_2 + 4),*(byte *)((long)param_2 + 5))) -
0x1000000;
}
else {
uVar8 = uVar8 | *(byte *)((long)param_2 + 5) | (uint)*(byte *)((long)param_2 + 4) << 8;
}
uVar22 = (uint)*(byte *)((long)param_3 + 3) * 0x10000;
if ((char)*(byte *)((long)param_3 + 3) < '\0') {
uVar22 = (uVar22 + CONCAT11(*(byte *)((long)param_3 + 4),*(byte *)((long)param_3 + 5))) -
0x1000000;
}
else {
uVar22 = uVar22 | *(byte *)((long)param_3 + 5) | (uint)*(byte *)((long)param_3 + 4) << 8;
}
if ((int)uVar19 < (int)uVar10) {
uVar19 = uVar10;
}
if ((int)uVar8 < (int)uVar22) {
uVar22 = uVar8;
}
if (uVar22 - uVar19 == 0 || (int)uVar22 < (int)uVar19) {
return 0.0;
}
dVar30 = (double)(int)(uVar22 - uVar19);
break;
case 0xd:
uVar8 = (uint)CONCAT12((byte)*param_2,
*(ushort *)((long)param_2 + 1) << 8 |
*(ushort *)((long)param_2 + 1) >> 8);
uVar10 = (uint)CONCAT12((byte)*param_3,
*(ushort *)((long)param_3 + 1) << 8 |
*(ushort *)((long)param_3 + 1) >> 8);
uVar22 = (uint)CONCAT12(*(byte *)((long)param_2 + 3),
*(ushort *)((long)param_2 + 4) << 8 |
*(ushort *)((long)param_2 + 4) >> 8);
uVar19 = (uint)CONCAT12(*(byte *)((long)param_3 + 3),
*(ushort *)((long)param_3 + 4) << 8 |
*(ushort *)((long)param_3 + 4) >> 8);
if (uVar10 < uVar8) {
uVar10 = uVar8;
}
if (uVar22 < uVar19) {
uVar19 = uVar22;
}
if (uVar19 < uVar10 || uVar19 - uVar10 == 0) {
return 0.0;
}
dVar30 = (double)(uVar19 - uVar10);
break;
case 0xe:
bVar2 = (byte)*param_2;
bVar3 = (byte)*param_3;
bVar6 = bVar3;
if ((char)bVar3 < (char)bVar2) {
bVar6 = bVar2;
}
cVar16 = bVar3 + 1;
if ((char)(bVar2 + 1) < (char)(bVar3 + 1)) {
cVar16 = bVar2 + 1;
}
if (cVar16 <= (char)bVar6) {
return 0.0;
}
uVar19 = (uint)cVar16;
uVar10 = (uint)(char)bVar6;
LAB_00188740:
dVar30 = (double)(int)(uVar19 - uVar10);
}
dVar29 = dVar29 * dVar30;
puVar1 = (ushort *)(puVar5 + -4);
uVar10 = (uint)*puVar1 * 2;
param_2 = (ulong *)((long)param_2 + (ulong)uVar10);
param_3 = (ulong *)((long)param_3 + (ulong)uVar10);
puVar5 = puVar5 + 0x40;
bVar28 = SBORROW4(param_4,uVar10);
param_4 = param_4 + (uint)*puVar1 * -2;
if (param_4 == 0 || bVar28 != param_4 < 0) {
return dVar29;
}
} while( true );
}
|
|
17,247
|
fmt::v10::appender fmt::v10::detail::format_uint<3u, char, fmt::v10::appender, unsigned long>(fmt::v10::appender, unsigned long, int, bool)
|
AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
FMT_CONSTEXPR inline auto format_uint(It out, UInt value, int num_digits,
bool upper = false) -> It {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[num_bits<UInt>() / BASE_BITS + 1] = {};
format_uint<BASE_BITS>(buffer, value, num_digits, upper);
return detail::copy_str_noinline<Char>(buffer, buffer + num_digits, out);
}
|
O0
|
c
|
fmt::v10::appender fmt::v10::detail::format_uint<3u, char, fmt::v10::appender, unsigned long>(fmt::v10::appender, unsigned long, int, bool):
subq $0x128, %rsp # imm = 0x128
movb %r8b, %al
movq %rdi, 0x118(%rsp)
movq %rsi, 0x100(%rsp)
movq %rdx, 0x108(%rsp)
movq 0x100(%rsp), %rdx
movq 0x108(%rsp), %rsi
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movl %ecx, 0xec(%rsp)
andb $0x1, %al
movb %al, 0xeb(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0xd8(%rsp)
movl 0xec(%rsp), %edi
callq 0x90310
movl %eax, %eax
movl %eax, %esi
movq 0xd8(%rsp), %rdi
callq 0x960a0
movq %rax, 0xe0(%rsp)
cmpq $0x0, 0xe0(%rsp)
je 0xb0fe8
movq 0xe0(%rsp), %rdi
movq 0xf0(%rsp), %rdx
movq 0xf8(%rsp), %rsi
movl 0xec(%rsp), %ecx
movb 0xeb(%rsp), %al
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
andb $0x1, %al
movzbl %al, %r8d
callq 0xb10b0
movq 0x118(%rsp), %rax
movq %rax, 0x120(%rsp)
jmp 0xb109e
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movb $0x0, 0xb0(%rsp)
leaq 0x30(%rsp), %rdi
movq 0xf0(%rsp), %rdx
movq 0xf8(%rsp), %rsi
movl 0xec(%rsp), %ecx
movb 0xeb(%rsp), %al
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
andb $0x1, %al
movzbl %al, %r8d
callq 0xb10b0
leaq 0x30(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movslq 0xec(%rsp), %rax
addq %rax, %rsi
movq 0x118(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
callq 0x96230
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rax
addq $0x128, %rsp # imm = 0x128
retq
nop
|
_ZN3fmt3v106detail11format_uintILj1EcNS0_8appenderEoEET1_S4_T2_ib:
sub rsp, 128h
mov al, r8b
mov [rsp+128h+var_10], rdi
mov [rsp+128h+var_28], rsi
mov [rsp+128h+var_20], rdx
mov rdx, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_20]
mov [rsp+128h+var_30], rsi
mov [rsp+128h+var_38], rdx
mov [rsp+128h+var_3C], ecx
and al, 1
mov [rsp+128h+var_3D], al
mov rax, [rsp+128h+var_10]
mov [rsp+128h+var_50], rax
mov edi, [rsp+128h+var_3C]
call _ZN3fmt3v106detail11to_unsignedIiEENSt13make_unsignedIT_E4typeES4_; fmt::v10::detail::to_unsigned<int>(int)
mov eax, eax
mov esi, eax
mov rdi, [rsp+128h+var_50]
call _ZN3fmt3v106detail10to_pointerIcEEPT_NSt11conditionalIXsr3std7is_sameIS3_cEE5valueENS0_8appenderESt20back_insert_iteratorINS1_6bufferIS3_EEEE4typeEm
mov [rsp+128h+var_48], rax
cmp [rsp+128h+var_48], 0
jz short loc_B0FE8
mov rdi, [rsp+128h+var_48]
mov rdx, [rsp+128h+var_38]
mov rsi, [rsp+128h+var_30]
mov ecx, [rsp+128h+var_3C]
mov al, [rsp+128h+var_3D]
mov [rsp+128h+var_60], rsi
mov [rsp+128h+var_68], rdx
mov rsi, [rsp+128h+var_68]
mov rdx, [rsp+128h+var_60]
and al, 1
movzx r8d, al
call _ZN3fmt3v106detail11format_uintILj1EcoEEPT0_S4_T1_ib; fmt::v10::detail::format_uint<1u,char,unsigned __int128>(char *,unsigned __int128,int,bool)
mov rax, [rsp+128h+var_10]
mov [rsp+128h+var_8], rax
jmp loc_B109E
loc_B0FE8:
xorps xmm0, xmm0
movaps [rsp+128h+var_128], xmm0
movaps [rsp+128h+var_88], xmm0
movaps [rsp+128h+var_98], xmm0
movaps [rsp+128h+var_A8], xmm0
movaps [rsp+128h+var_B8], xmm0
movaps [rsp+128h+var_C8], xmm0
movaps [rsp+128h+var_D8], xmm0
movaps [rsp+128h+var_E8], xmm0
movaps [rsp+128h+var_F8], xmm0
mov [rsp+128h+var_78], 0
lea rdi, [rsp+128h+var_F8]
mov rdx, [rsp+128h+var_38]
mov rsi, [rsp+128h+var_30]
mov ecx, [rsp+128h+var_3C]
mov al, [rsp+128h+var_3D]
mov [rsp+128h+var_100], rsi
mov [rsp+128h+var_108], rdx
mov rsi, [rsp+128h+var_108]
mov rdx, [rsp+128h+var_100]
and al, 1
movzx r8d, al
call _ZN3fmt3v106detail11format_uintILj1EcoEEPT0_S4_T1_ib; fmt::v10::detail::format_uint<1u,char,unsigned __int128>(char *,unsigned __int128,int,bool)
lea rdi, [rsp+128h+var_F8]
lea rsi, [rsp+128h+var_F8]
movsxd rax, [rsp+128h+var_3C]
add rsi, rax
mov rax, [rsp+128h+var_10]
mov [rsp+128h+var_110], rax
mov rdx, [rsp+128h+var_110]
call _ZN3fmt3v106detail17copy_str_noinlineIcPcNS0_8appenderEEET1_T0_S6_S5_; fmt::v10::detail::copy_str_noinline<char,char *,fmt::v10::appender>(char *,char *,fmt::v10::appender)
mov [rsp+128h+var_8], rax
loc_B109E:
mov rax, [rsp+128h+var_8]
add rsp, 128h
retn
|
long long fmt::v10::detail::format_uint<1u,char,fmt::v10::appender,unsigned __int128>(
long long a1,
long long a2,
long long a3,
unsigned int a4,
char a5)
{
unsigned int v5; // eax
long long v6; // r9
long long v7; // rcx
long long v8; // r8
long long v9; // r9
_OWORD v11[8]; // [rsp+30h] [rbp-F8h] BYREF
char v12; // [rsp+B0h] [rbp-78h]
long long v13; // [rsp+C0h] [rbp-68h]
long long v14; // [rsp+C8h] [rbp-60h]
long long v15; // [rsp+D8h] [rbp-50h]
long long v16; // [rsp+E0h] [rbp-48h]
char v17; // [rsp+EBh] [rbp-3Dh]
unsigned int v18; // [rsp+ECh] [rbp-3Ch]
long long v19; // [rsp+F0h] [rbp-38h]
long long v20; // [rsp+F8h] [rbp-30h]
long long v21; // [rsp+100h] [rbp-28h]
long long v22; // [rsp+108h] [rbp-20h]
long long v23; // [rsp+118h] [rbp-10h]
v23 = a1;
v21 = a2;
v22 = a3;
v20 = a3;
v19 = a2;
v18 = a4;
v17 = a5 & 1;
v15 = a1;
v5 = fmt::v10::detail::to_unsigned<int>(a4);
v16 = fmt::v10::detail::to_pointer<char>(a1, v5);
if ( v16 )
{
v14 = v20;
v13 = v19;
fmt::v10::detail::format_uint<1u,char,unsigned __int128>(v16, v19, v20, v18, v17 & 1, v6);
return v23;
}
else
{
memset(v11, 0, sizeof(v11));
v12 = 0;
fmt::v10::detail::format_uint<1u,char,unsigned __int128>(v11, v19, v20, v18, v17 & 1, v6);
return fmt::v10::detail::copy_str_noinline<char,char *,fmt::v10::appender>(
(long long)v11,
(long long)v11 + (int)v18,
v23,
v7,
v8,
v9);
}
}
|
format_uint<1u,char,fmt::v10::appender,unsigned__int128>:
SUB RSP,0x128
MOV AL,R8B
MOV qword ptr [RSP + 0x118],RDI
MOV qword ptr [RSP + 0x100],RSI
MOV qword ptr [RSP + 0x108],RDX
MOV RDX,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0x108]
MOV qword ptr [RSP + 0xf8],RSI
MOV qword ptr [RSP + 0xf0],RDX
MOV dword ptr [RSP + 0xec],ECX
AND AL,0x1
MOV byte ptr [RSP + 0xeb],AL
MOV RAX,qword ptr [RSP + 0x118]
MOV qword ptr [RSP + 0xd8],RAX
MOV EDI,dword ptr [RSP + 0xec]
CALL 0x00190310
MOV EAX,EAX
MOV ESI,EAX
MOV RDI,qword ptr [RSP + 0xd8]
CALL 0x001960a0
MOV qword ptr [RSP + 0xe0],RAX
CMP qword ptr [RSP + 0xe0],0x0
JZ 0x001b0fe8
MOV RDI,qword ptr [RSP + 0xe0]
MOV RDX,qword ptr [RSP + 0xf0]
MOV RSI,qword ptr [RSP + 0xf8]
MOV ECX,dword ptr [RSP + 0xec]
MOV AL,byte ptr [RSP + 0xeb]
MOV qword ptr [RSP + 0xc8],RSI
MOV qword ptr [RSP + 0xc0],RDX
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
AND AL,0x1
MOVZX R8D,AL
CALL 0x001b10b0
MOV RAX,qword ptr [RSP + 0x118]
MOV qword ptr [RSP + 0x120],RAX
JMP 0x001b109e
LAB_001b0fe8:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0xa0],XMM0
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOV byte ptr [RSP + 0xb0],0x0
LEA RDI,[RSP + 0x30]
MOV RDX,qword ptr [RSP + 0xf0]
MOV RSI,qword ptr [RSP + 0xf8]
MOV ECX,dword ptr [RSP + 0xec]
MOV AL,byte ptr [RSP + 0xeb]
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
AND AL,0x1
MOVZX R8D,AL
CALL 0x001b10b0
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x30]
MOVSXD RAX,dword ptr [RSP + 0xec]
ADD RSI,RAX
MOV RAX,qword ptr [RSP + 0x118]
MOV qword ptr [RSP + 0x18],RAX
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x00196230
MOV qword ptr [RSP + 0x120],RAX
LAB_001b109e:
MOV RAX,qword ptr [RSP + 0x120]
ADD RSP,0x128
RET
|
/* fmt::v10::appender fmt::v10::detail::format_uint<1u, char, fmt::v10::appender, unsigned
__int128>(fmt::v10::appender, unsigned __int128, int, bool) */
detail * __thiscall
fmt::v10::detail::format_uint<1u,char,fmt::v10::appender,unsigned__int128>
(detail *this,int8 param_2,int8 param_3,int param_4,byte param_5)
{
int4 uVar1;
char local_f8 [144];
int8 local_68;
int8 local_60;
detail *local_50;
char *local_48;
byte local_3d;
int local_3c;
int8 local_38;
int8 local_30;
int8 local_28;
int8 local_20;
detail *local_10;
detail *local_8;
local_3d = param_5 & 1;
local_50 = this;
local_3c = param_4;
local_38 = param_2;
local_30 = param_3;
local_28 = param_2;
local_20 = param_3;
local_10 = this;
uVar1 = to_unsigned<int>(param_4);
local_48 = to_pointer<char>(local_50,uVar1);
if (local_48 == (char *)0x0) {
local_f8[0x70] = '\0';
local_f8[0x71] = '\0';
local_f8[0x72] = '\0';
local_f8[0x73] = '\0';
local_f8[0x74] = '\0';
local_f8[0x75] = '\0';
local_f8[0x76] = '\0';
local_f8[0x77] = '\0';
local_f8[0x78] = '\0';
local_f8[0x79] = '\0';
local_f8[0x7a] = '\0';
local_f8[0x7b] = '\0';
local_f8[0x7c] = '\0';
local_f8[0x7d] = '\0';
local_f8[0x7e] = '\0';
local_f8[0x7f] = '\0';
local_f8[0x60] = '\0';
local_f8[0x61] = '\0';
local_f8[0x62] = '\0';
local_f8[99] = '\0';
local_f8[100] = '\0';
local_f8[0x65] = '\0';
local_f8[0x66] = '\0';
local_f8[0x67] = '\0';
local_f8[0x68] = '\0';
local_f8[0x69] = '\0';
local_f8[0x6a] = '\0';
local_f8[0x6b] = '\0';
local_f8[0x6c] = '\0';
local_f8[0x6d] = '\0';
local_f8[0x6e] = '\0';
local_f8[0x6f] = '\0';
local_f8[0x50] = '\0';
local_f8[0x51] = '\0';
local_f8[0x52] = '\0';
local_f8[0x53] = '\0';
local_f8[0x54] = '\0';
local_f8[0x55] = '\0';
local_f8[0x56] = '\0';
local_f8[0x57] = '\0';
local_f8[0x58] = '\0';
local_f8[0x59] = '\0';
local_f8[0x5a] = '\0';
local_f8[0x5b] = '\0';
local_f8[0x5c] = '\0';
local_f8[0x5d] = '\0';
local_f8[0x5e] = '\0';
local_f8[0x5f] = '\0';
local_f8[0x40] = '\0';
local_f8[0x41] = '\0';
local_f8[0x42] = '\0';
local_f8[0x43] = '\0';
local_f8[0x44] = '\0';
local_f8[0x45] = '\0';
local_f8[0x46] = '\0';
local_f8[0x47] = '\0';
local_f8[0x48] = '\0';
local_f8[0x49] = '\0';
local_f8[0x4a] = '\0';
local_f8[0x4b] = '\0';
local_f8[0x4c] = '\0';
local_f8[0x4d] = '\0';
local_f8[0x4e] = '\0';
local_f8[0x4f] = '\0';
local_f8[0x30] = '\0';
local_f8[0x31] = '\0';
local_f8[0x32] = '\0';
local_f8[0x33] = '\0';
local_f8[0x34] = '\0';
local_f8[0x35] = '\0';
local_f8[0x36] = '\0';
local_f8[0x37] = '\0';
local_f8[0x38] = '\0';
local_f8[0x39] = '\0';
local_f8[0x3a] = '\0';
local_f8[0x3b] = '\0';
local_f8[0x3c] = '\0';
local_f8[0x3d] = '\0';
local_f8[0x3e] = '\0';
local_f8[0x3f] = '\0';
local_f8[0x20] = '\0';
local_f8[0x21] = '\0';
local_f8[0x22] = '\0';
local_f8[0x23] = '\0';
local_f8[0x24] = '\0';
local_f8[0x25] = '\0';
local_f8[0x26] = '\0';
local_f8[0x27] = '\0';
local_f8[0x28] = '\0';
local_f8[0x29] = '\0';
local_f8[0x2a] = '\0';
local_f8[0x2b] = '\0';
local_f8[0x2c] = '\0';
local_f8[0x2d] = '\0';
local_f8[0x2e] = '\0';
local_f8[0x2f] = '\0';
local_f8[0x10] = '\0';
local_f8[0x11] = '\0';
local_f8[0x12] = '\0';
local_f8[0x13] = '\0';
local_f8[0x14] = '\0';
local_f8[0x15] = '\0';
local_f8[0x16] = '\0';
local_f8[0x17] = '\0';
local_f8[0x18] = '\0';
local_f8[0x19] = '\0';
local_f8[0x1a] = '\0';
local_f8[0x1b] = '\0';
local_f8[0x1c] = '\0';
local_f8[0x1d] = '\0';
local_f8[0x1e] = '\0';
local_f8[0x1f] = '\0';
local_f8[0] = '\0';
local_f8[1] = '\0';
local_f8[2] = '\0';
local_f8[3] = '\0';
local_f8[4] = '\0';
local_f8[5] = '\0';
local_f8[6] = '\0';
local_f8[7] = '\0';
local_f8[8] = '\0';
local_f8[9] = '\0';
local_f8[10] = '\0';
local_f8[0xb] = '\0';
local_f8[0xc] = '\0';
local_f8[0xd] = '\0';
local_f8[0xe] = '\0';
local_f8[0xf] = '\0';
local_f8[0x80] = 0;
format_uint<1u,char,unsigned__int128>(local_f8,(uint)local_38,(int)local_30,SUB41(local_3c,0));
local_8 = (detail *)
copy_str_noinline<char,char*,fmt::v10::appender>
(local_f8,local_f8 + local_3c,local_10);
}
else {
local_60 = local_30;
local_68 = local_38;
format_uint<1u,char,unsigned__int128>(local_48,(uint)local_38,(int)local_30,SUB41(local_3c,0));
local_8 = local_10;
}
return local_8;
}
|
|
17,248
|
maria_indexes_are_disabled
|
eloqsql/storage/maria/ma_open.c
|
int maria_indexes_are_disabled(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
/*
No keys or all are enabled. keys is the number of keys. Left shifted
gives us only one bit set. When decreased by one, gives us all all bits
up to this one set and it gets unset.
*/
if (!share->base.keys ||
(maria_is_all_keys_active(share->state.key_map, share->base.keys)))
return 0;
/* All are disabled */
if (maria_is_any_key_active(share->state.key_map))
return 1;
/*
We have keys. Some enabled, some disabled.
Don't check for any non-unique disabled but return directly 2
*/
return 2;
}
|
O0
|
c
|
maria_indexes_are_disabled:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x3e8(%rax)
je 0x93884
movq -0x18(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x40, 0x3e8(%rax)
jae 0x9386a
movq -0x18(%rbp), %rax
movl 0x3e8(%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x93877
movq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x93877
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9388d
movl $0x0, -0x4(%rbp)
jmp 0x938bb
movq -0x18(%rbp), %rax
cmpq $0x0, 0x140(%rax)
je 0x938a3
movb $0x1, %al
testb $0x1, %al
jne 0x938ab
jmp 0x938b4
xorl %eax, %eax
testb $0x1, %al
jne 0x938ab
jmp 0x938b4
movl $0x1, -0x4(%rbp)
jmp 0x938bb
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
|
maria_indexes_are_disabled:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
cmp dword ptr [rax+3E8h], 0
jz short loc_93884
mov rax, [rbp+var_18]
mov rax, [rax+140h]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
cmp dword ptr [rax+3E8h], 40h ; '@'
jnb short loc_9386A
mov rax, [rbp+var_18]
mov eax, [rax+3E8h]
mov ecx, eax
mov eax, 1
shl rax, cl
sub rax, 1
mov [rbp+var_28], rax
jmp short loc_93877
loc_9386A:
mov rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_28], rax
jmp short $+2
loc_93877:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_28]
cmp rax, rcx
jnz short loc_9388D
loc_93884:
mov [rbp+var_4], 0
jmp short loc_938BB
loc_9388D:
mov rax, [rbp+var_18]
cmp qword ptr [rax+140h], 0
jz short loc_938A3
mov al, 1
test al, 1
jnz short loc_938AB
jmp short loc_938B4
loc_938A3:
xor eax, eax
test al, 1
jnz short loc_938AB
jmp short loc_938B4
loc_938AB:
mov [rbp+var_4], 1
jmp short loc_938BB
loc_938B4:
mov [rbp+var_4], 2
loc_938BB:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long maria_indexes_are_disabled(long long *a1)
{
long long v2; // [rsp+0h] [rbp-28h]
long long v3; // [rsp+10h] [rbp-18h]
v3 = *a1;
if ( *(_DWORD *)(*a1 + 1000)
&& (*(_DWORD *)(v3 + 1000) >= 0x40u ? (v2 = -1LL) : (v2 = (1LL << *(_DWORD *)(v3 + 1000)) - 1),
*(_QWORD *)(v3 + 320) != v2) )
{
if ( *(_QWORD *)(v3 + 320) )
return 1;
else
return 2;
}
else
{
return 0;
}
}
|
maria_indexes_are_disabled:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x3e8],0x0
JZ 0x00193884
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x140]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x3e8],0x40
JNC 0x0019386a
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x3e8]
MOV ECX,EAX
MOV EAX,0x1
SHL RAX,CL
SUB RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00193877
LAB_0019386a:
MOV RAX,-0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00193877
LAB_00193877:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
CMP RAX,RCX
JNZ 0x0019388d
LAB_00193884:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001938bb
LAB_0019388d:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x140],0x0
JZ 0x001938a3
MOV AL,0x1
TEST AL,0x1
JNZ 0x001938ab
JMP 0x001938b4
LAB_001938a3:
XOR EAX,EAX
TEST AL,0x1
JNZ 0x001938ab
JMP 0x001938b4
LAB_001938ab:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001938bb
LAB_001938b4:
MOV dword ptr [RBP + -0x4],0x2
LAB_001938bb:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x001938a1) */
int4 maria_indexes_are_disabled(long *param_1)
{
long lVar1;
long local_30;
lVar1 = *param_1;
if (*(int *)(lVar1 + 1000) != 0) {
if (*(uint *)(lVar1 + 1000) < 0x40) {
local_30 = (1L << ((byte)*(int4 *)(lVar1 + 1000) & 0x3f)) + -1;
}
else {
local_30 = -1;
}
if (*(long *)(lVar1 + 0x140) != local_30) {
if (*(long *)(lVar1 + 0x140) != 0) {
return 1;
}
return 2;
}
}
return 0;
}
|
|
17,249
|
maria_indexes_are_disabled
|
eloqsql/storage/maria/ma_open.c
|
int maria_indexes_are_disabled(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
/*
No keys or all are enabled. keys is the number of keys. Left shifted
gives us only one bit set. When decreased by one, gives us all all bits
up to this one set and it gets unset.
*/
if (!share->base.keys ||
(maria_is_all_keys_active(share->state.key_map, share->base.keys)))
return 0;
/* All are disabled */
if (maria_is_any_key_active(share->state.key_map))
return 1;
/*
We have keys. Some enabled, some disabled.
Don't check for any non-unique disabled but return directly 2
*/
return 2;
}
|
O3
|
c
|
maria_indexes_are_disabled:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
movl 0x3e8(%rdx), %ecx
xorl %eax, %eax
testq %rcx, %rcx
je 0x6c099
movq 0x140(%rdx), %rdx
movq $-0x1, %rsi
movq $-0x1, %rdi
shlq %cl, %rdi
cmpl $0x40, %ecx
notq %rdi
cmovaeq %rsi, %rdi
cmpq %rdi, %rdx
je 0x6c099
xorl %eax, %eax
cmpq $0x1, %rdx
adcl $0x1, %eax
popq %rbp
retq
nop
|
maria_indexes_are_disabled:
push rbp
mov rbp, rsp
mov rdx, [rdi]
mov ecx, [rdx+3E8h]
xor eax, eax
test rcx, rcx
jz short loc_6C099
mov rdx, [rdx+140h]
mov rsi, 0FFFFFFFFFFFFFFFFh
mov rdi, 0FFFFFFFFFFFFFFFFh
shl rdi, cl
cmp ecx, 40h ; '@'
not rdi
cmovnb rdi, rsi
cmp rdx, rdi
jz short loc_6C099
xor eax, eax
cmp rdx, 1
adc eax, 1
loc_6C099:
pop rbp
retn
|
long long maria_indexes_are_disabled(long long a1)
{
unsigned int v1; // ecx
long long result; // rax
long long v3; // rdx
long long v4; // rdi
v1 = *(_DWORD *)(*(_QWORD *)a1 + 1000LL);
result = 0LL;
if ( v1 )
{
v3 = *(_QWORD *)(*(_QWORD *)a1 + 320LL);
v4 = ~(-1LL << v1);
if ( v1 >= 0x40 )
v4 = -1LL;
if ( v3 != v4 )
return (unsigned int)(v3 == 0) + 1;
}
return result;
}
|
maria_indexes_are_disabled:
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RDI]
MOV ECX,dword ptr [RDX + 0x3e8]
XOR EAX,EAX
TEST RCX,RCX
JZ 0x0016c099
MOV RDX,qword ptr [RDX + 0x140]
MOV RSI,-0x1
MOV RDI,-0x1
SHL RDI,CL
CMP ECX,0x40
NOT RDI
CMOVNC RDI,RSI
CMP RDX,RDI
JZ 0x0016c099
XOR EAX,EAX
CMP RDX,0x1
ADC EAX,0x1
LAB_0016c099:
POP RBP
RET
|
char maria_indexes_are_disabled(long *param_1)
{
uint uVar1;
ulong uVar2;
char cVar3;
ulong uVar4;
uVar1 = *(uint *)(*param_1 + 1000);
cVar3 = '\0';
if (uVar1 != 0) {
uVar2 = *(ulong *)(*param_1 + 0x140);
uVar4 = ~(-1L << ((byte)uVar1 & 0x3f));
if (0x3f < uVar1) {
uVar4 = 0xffffffffffffffff;
}
if (uVar2 != uVar4) {
cVar3 = (uVar2 == 0) + '\x01';
}
}
return cVar3;
}
|
|
17,250
|
ggml_cast
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
struct ggml_tensor * ggml_cast(
struct ggml_context * ctx,
struct ggml_tensor * a,
enum ggml_type type) {
struct ggml_tensor * result = ggml_new_tensor(ctx, type, GGML_MAX_DIMS, a->ne);
ggml_format_name(result, "%s (copy)", a->name);
result->op = GGML_OP_CPY;
result->src[0] = a;
result->src[1] = result;
return result;
}
|
O0
|
c
|
ggml_cast:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movl $0x4, %edx
callq 0x42510
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x100, %rdx # imm = 0x100
leaq 0x623d7(%rip), %rsi # 0xb198d
movb $0x0, %al
callq 0x481b0
movq -0x20(%rbp), %rax
movl $0x1f, 0x50(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
|
ggml_cast:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rdi, [rbp+var_8]
mov esi, [rbp+var_14]
mov rcx, [rbp+var_10]
add rcx, 10h
mov edx, 4
call _ggml_new_tensor
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
mov rdx, [rbp+var_10]
add rdx, 100h
lea rsi, aSCopy; "%s (copy)"
mov al, 0
call _ggml_format_name
mov rax, [rbp+var_20]
mov dword ptr [rax+50h], 1Fh
mov rcx, [rbp+var_10]
mov rax, [rbp+var_20]
mov [rax+98h], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_20]
mov [rax+0A0h], rcx
mov rax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
|
long long ggml_cast(
long long a1,
long long a2,
unsigned int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v11; // rax
long long v12; // rcx
long long v13; // r8
long long v14; // r9
__m128 v15; // xmm4
__m128 v16; // xmm5
long long v18; // [rsp+0h] [rbp-20h]
v11 = ggml_new_tensor(a1, a3, 4u, a2 + 16);
ggml_format_name(v11, (long long)"%s (copy)", a2 + 256, v12, v13, v14, a4, a5, a6, a7, v15, v16, a10, a11, v11);
*(_DWORD *)(v18 + 80) = 31;
*(_QWORD *)(v18 + 152) = a2;
*(_QWORD *)(v18 + 160) = v18;
return v18;
}
|
ggml_cast:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x10
MOV EDX,0x4
CALL 0x00142510
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,0x100
LEA RSI,[0x1b198d]
MOV AL,0x0
CALL 0x001481b0
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x50],0x1f
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0xa0],RCX
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
long ggml_cast(int8 param_1,long param_2,int4 param_3)
{
long lVar1;
lVar1 = ggml_new_tensor(param_1,param_3,4,param_2 + 0x10);
ggml_format_name(lVar1,"%s (copy)",param_2 + 0x100);
*(int4 *)(lVar1 + 0x50) = 0x1f;
*(long *)(lVar1 + 0x98) = param_2;
*(long *)(lVar1 + 0xa0) = lVar1;
return lVar1;
}
|
|
17,251
|
ggml_cast
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
struct ggml_tensor * ggml_cast(
struct ggml_context * ctx,
struct ggml_tensor * a,
enum ggml_type type) {
struct ggml_tensor * result = ggml_new_tensor(ctx, type, GGML_MAX_DIMS, a->ne);
ggml_format_name(result, "%s (copy)", a->name);
result->op = GGML_OP_CPY;
result->src[0] = a;
result->src[1] = result;
return result;
}
|
O1
|
c
|
ggml_cast:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x10(%rsi), %rcx
movl %edx, %esi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1b871
movq %rax, %r14
leaq 0x100(%rbx), %rdx
leaq 0x2f45f(%rip), %rsi # 0x4c945
movq %rax, %rdi
xorl %eax, %eax
callq 0x18a70
movl $0x1f, 0x50(%r14)
movq %rbx, 0x98(%r14)
movq %r14, 0xa0(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
ggml_cast:
push r14
push rbx
push rax
mov rbx, rsi
lea rcx, [rsi+10h]
mov esi, edx
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov r14, rax
lea rdx, [rbx+100h]
lea rsi, aSCopy; "%s (copy)"
mov rdi, rax
xor eax, eax
call _ggml_format_name
mov dword ptr [r14+50h], 1Fh
mov [r14+98h], rbx
mov [r14+0A0h], r14
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
|
long long ggml_cast(long long a1, long long a2, unsigned int a3, double a4)
{
long long v4; // r14
v4 = ggml_new_tensor_impl(a1, a3, 4, (long long *)(a2 + 16), 0LL, 0LL, a4);
ggml_format_name(v4, (long long)"%s (copy)");
*(_DWORD *)(v4 + 80) = 31;
*(_QWORD *)(v4 + 152) = a2;
*(_QWORD *)(v4 + 160) = v4;
return v4;
}
|
ggml_cast:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
LEA RCX,[RSI + 0x10]
MOV ESI,EDX
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0011b871
MOV R14,RAX
LEA RDX,[RBX + 0x100]
LEA RSI,[0x14c945]
MOV RDI,RAX
XOR EAX,EAX
CALL 0x00118a70
MOV dword ptr [R14 + 0x50],0x1f
MOV qword ptr [R14 + 0x98],RBX
MOV qword ptr [R14 + 0xa0],R14
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
long ggml_cast(int8 param_1,long param_2,int4 param_3)
{
long lVar1;
lVar1 = ggml_new_tensor_impl(param_1,param_3,4,param_2 + 0x10,0,0);
ggml_format_name(lVar1,"%s (copy)",param_2 + 0x100);
*(int4 *)(lVar1 + 0x50) = 0x1f;
*(long *)(lVar1 + 0x98) = param_2;
*(long *)(lVar1 + 0xa0) = lVar1;
return lVar1;
}
|
|
17,252
|
ggml_cast
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
struct ggml_tensor * ggml_cast(
struct ggml_context * ctx,
struct ggml_tensor * a,
enum ggml_type type) {
struct ggml_tensor * result = ggml_new_tensor(ctx, type, GGML_MAX_DIMS, a->ne);
ggml_format_name(result, "%s (copy)", a->name);
result->op = GGML_OP_CPY;
result->src[0] = a;
result->src[1] = result;
return result;
}
|
O3
|
c
|
ggml_cast:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x10(%rsi), %rcx
movl %edx, %esi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1a57f
movq %rax, %r14
leaq 0x100(%rbx), %rdx
leaq 0x307ee(%rip), %rsi # 0x4c9e9
movq %rax, %rdi
xorl %eax, %eax
callq 0x17a60
movl $0x1f, 0x50(%r14)
movq %rbx, 0x98(%r14)
movq %r14, 0xa0(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
ggml_cast:
push r14
push rbx
push rax
mov rbx, rsi
lea rcx, [rsi+10h]
mov esi, edx
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov r14, rax
lea rdx, [rbx+100h]
lea rsi, aSCopy; "%s (copy)"
mov rdi, rax
xor eax, eax
call _ggml_format_name
mov dword ptr [r14+50h], 1Fh
mov [r14+98h], rbx
mov [r14+0A0h], r14
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
|
long long ggml_cast(long long a1, long long a2, unsigned int a3, double a4)
{
long long v4; // r14
v4 = ggml_new_tensor_impl(a1, a3, 4u, (long long *)(a2 + 16), 0LL, 0LL, a4);
ggml_format_name(v4, (long long)"%s (copy)");
*(_DWORD *)(v4 + 80) = 31;
*(_QWORD *)(v4 + 152) = a2;
*(_QWORD *)(v4 + 160) = v4;
return v4;
}
|
ggml_cast:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
LEA RCX,[RSI + 0x10]
MOV ESI,EDX
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0011a57f
MOV R14,RAX
LEA RDX,[RBX + 0x100]
LEA RSI,[0x14c9e9]
MOV RDI,RAX
XOR EAX,EAX
CALL 0x00117a60
MOV dword ptr [R14 + 0x50],0x1f
MOV qword ptr [R14 + 0x98],RBX
MOV qword ptr [R14 + 0xa0],R14
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
long ggml_cast(int8 param_1,long param_2,int4 param_3)
{
long lVar1;
lVar1 = ggml_new_tensor_impl(param_1,param_3,4,param_2 + 0x10,0,0);
ggml_format_name(lVar1,"%s (copy)",param_2 + 0x100);
*(int4 *)(lVar1 + 0x50) = 0x1f;
*(long *)(lVar1 + 0x98) = param_2;
*(long *)(lVar1 + 0xa0) = lVar1;
return lVar1;
}
|
|
17,253
|
rlGetLocationUniform
|
csit-sgu[P]mit-game-2025-team-tyler/Libraries/raylib/src/rlgl.h
|
int rlGetLocationUniform(unsigned int shaderId, const char *uniformName)
{
int location = -1;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
location = glGetUniformLocation(shaderId, uniformName);
//if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader uniform: %s", shaderId, uniformName);
//else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader uniform (%s) set at location: %i", shaderId, uniformName, location);
#endif
return location;
}
|
O3
|
c
|
rlGetLocationUniform:
movq 0xd470c(%rip), %rax # 0x139ea0
jmpq *%rax
|
rlGetLocationUniform:
mov rax, cs:glad_glGetUniformLocation
jmp rax
|
long long rlGetLocationUniform(long long a1, long long a2)
{
return glad_glGetUniformLocation(a1, a2);
}
|
rlGetLocationUniform:
MOV RAX,qword ptr [0x00239ea0]
JMP RAX
|
void rlGetLocationUniform(void)
{
/* WARNING: Could not recover jumptable at 0x00165794. Too many branches */
/* WARNING: Treating indirect jump as call */
(*glad_glGetUniformLocation)();
return;
}
|
|
17,254
|
my_strntoull10rnd_mb2_or_mb4
|
eloqsql/strings/ctype-ucs2.c
|
static ulonglong
my_strntoull10rnd_mb2_or_mb4(CHARSET_INFO *cs,
const char *nptr, size_t length,
int unsign_fl,
char **endptr, int *err)
{
char buf[256], *b= buf;
ulonglong res;
const uchar *end, *s= (const uchar*) nptr;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
int cnv;
/* Cut too long strings */
if (length >= sizeof(buf))
length= sizeof(buf)-1;
end= s + length;
while ((cnv= mb_wc(cs, &wc, s, end)) > 0)
{
s+= cnv;
if (wc > (int) (uchar) 'e' || !wc)
break; /* Can't be a number part */
*b++= (char) wc;
}
res= my_strntoull10rnd_8bit(cs, buf, b - buf, unsign_fl, endptr, err);
*endptr= (char*) nptr + cs->mbminlen * (size_t) (*endptr - buf);
return res;
}
|
O0
|
c
|
my_strntoull10rnd_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x118(%rbp)
movq %rsi, -0x120(%rbp)
movq %rdx, -0x128(%rbp)
movl %ecx, -0x12c(%rbp)
movq %r8, -0x138(%rbp)
movq %r9, -0x140(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x120(%rbp), %rax
movq %rax, -0x160(%rbp)
movq -0x118(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x170(%rbp)
cmpq $0x100, -0x128(%rbp) # imm = 0x100
jb 0x93ece
movq $0xff, -0x128(%rbp)
movq -0x160(%rbp), %rax
addq -0x128(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x170(%rbp), %rax
movq -0x118(%rbp), %rdi
movq -0x160(%rbp), %rdx
movq -0x158(%rbp), %rcx
leaq -0x168(%rbp), %rsi
callq *%rax
movl %eax, -0x174(%rbp)
cmpl $0x0, %eax
jle 0x93f68
movl -0x174(%rbp), %ecx
movq -0x160(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x160(%rbp)
cmpq $0x65, -0x168(%rbp)
ja 0x93f41
cmpq $0x0, -0x168(%rbp)
jne 0x93f43
jmp 0x93f68
movq -0x168(%rbp), %rax
movb %al, %cl
movq -0x148(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x148(%rbp)
movb %cl, (%rax)
jmp 0x93ee3
movq -0x118(%rbp), %rdi
movq -0x148(%rbp), %rdx
leaq -0x110(%rbp), %rsi
movq %rsi, -0x188(%rbp)
subq %rsi, %rdx
movl -0x12c(%rbp), %ecx
movq -0x138(%rbp), %r8
movq -0x140(%rbp), %r9
callq 0x7e7e0
movq -0x188(%rbp), %rdi
movq %rax, -0x150(%rbp)
movq -0x120(%rbp), %rcx
movq -0x118(%rbp), %rax
movl 0x98(%rax), %eax
movl %eax, %edx
movq -0x138(%rbp), %rax
movq (%rax), %rsi
subq %rdi, %rsi
imulq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x150(%rbp), %rax
movq %rax, -0x180(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9400b
movq -0x180(%rbp), %rax
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
callq 0x26360
|
my_strntoull10rnd_mb2_or_mb4:
push rbp
mov rbp, rsp
sub rsp, 190h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_118], rdi
mov [rbp+var_120], rsi
mov [rbp+var_128], rdx
mov [rbp+var_12C], ecx
mov [rbp+var_138], r8
mov [rbp+var_140], r9
lea rax, [rbp+var_110]
mov [rbp+var_148], rax
mov rax, [rbp+var_120]
mov [rbp+var_160], rax
mov rax, [rbp+var_118]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov [rbp+var_170], rax
cmp [rbp+var_128], 100h
jb short loc_93ECE
mov [rbp+var_128], 0FFh
loc_93ECE:
mov rax, [rbp+var_160]
add rax, [rbp+var_128]
mov [rbp+var_158], rax
loc_93EE3:
mov rax, [rbp+var_170]
mov rdi, [rbp+var_118]
mov rdx, [rbp+var_160]
mov rcx, [rbp+var_158]
lea rsi, [rbp+var_168]
call rax
mov [rbp+var_174], eax
cmp eax, 0
jle short loc_93F68
mov ecx, [rbp+var_174]
mov rax, [rbp+var_160]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_160], rax
cmp [rbp+var_168], 65h ; 'e'
ja short loc_93F41
cmp [rbp+var_168], 0
jnz short loc_93F43
loc_93F41:
jmp short loc_93F68
loc_93F43:
mov rax, [rbp+var_168]
mov cl, al
mov rax, [rbp+var_148]
mov rdx, rax
add rdx, 1
mov [rbp+var_148], rdx
mov [rax], cl
jmp loc_93EE3
loc_93F68:
mov rdi, [rbp+var_118]
mov rdx, [rbp+var_148]
lea rsi, [rbp+var_110]
mov [rbp+var_188], rsi
sub rdx, rsi
mov ecx, [rbp+var_12C]
mov r8, [rbp+var_138]
mov r9, [rbp+var_140]
call my_strntoull10rnd_8bit
mov rdi, [rbp+var_188]
mov [rbp+var_150], rax
mov rcx, [rbp+var_120]
mov rax, [rbp+var_118]
mov eax, [rax+98h]
mov edx, eax
mov rax, [rbp+var_138]
mov rsi, [rax]
sub rsi, rdi
imul rdx, rsi
add rcx, rdx
mov [rax], rcx
mov rax, [rbp+var_150]
mov [rbp+var_180], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_9400B
mov rax, [rbp+var_180]
add rsp, 190h
pop rbp
retn
loc_9400B:
call ___stack_chk_fail
|
long long my_strntoull10rnd_mb2_or_mb4(
long long a1,
long long a2,
unsigned long long a3,
int a4,
_QWORD *a5,
int *a6)
{
_BYTE *v6; // rax
int v8; // [rsp+1Ch] [rbp-174h]
long long ( *v9)(long long, unsigned long long *, long long, long long); // [rsp+20h] [rbp-170h]
unsigned long long v10; // [rsp+28h] [rbp-168h] BYREF
long long v11; // [rsp+30h] [rbp-160h]
long long v12; // [rsp+38h] [rbp-158h]
long long v13; // [rsp+40h] [rbp-150h]
_BYTE *v14; // [rsp+48h] [rbp-148h]
int *v15; // [rsp+50h] [rbp-140h]
_QWORD *v16; // [rsp+58h] [rbp-138h]
int v17; // [rsp+64h] [rbp-12Ch]
long long v18; // [rsp+68h] [rbp-128h]
long long v19; // [rsp+70h] [rbp-120h]
long long v20; // [rsp+78h] [rbp-118h]
_BYTE v21[264]; // [rsp+80h] [rbp-110h] BYREF
unsigned long long v22; // [rsp+188h] [rbp-8h]
v22 = __readfsqword(0x28u);
v20 = a1;
v19 = a2;
v18 = a3;
v17 = a4;
v16 = a5;
v15 = a6;
v14 = v21;
v11 = a2;
v9 = *(long long ( **)(long long, unsigned long long *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
if ( a3 >= 0x100 )
v18 = 255LL;
v12 = v18 + v11;
while ( 1 )
{
v8 = v9(v20, &v10, v11, v12);
if ( v8 <= 0 )
break;
v11 += v8;
if ( v10 > 0x65 || !v10 )
break;
v6 = v14++;
*v6 = v10;
}
v13 = my_strntoull10rnd_8bit(v20, v21, v14 - v21, v17, v16, v15);
*v16 = (*v16 - (_QWORD)v21) * *(unsigned int *)(v20 + 152) + v19;
return v13;
}
|
my_strntoull10rnd_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x190
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x118],RDI
MOV qword ptr [RBP + -0x120],RSI
MOV qword ptr [RBP + -0x128],RDX
MOV dword ptr [RBP + -0x12c],ECX
MOV qword ptr [RBP + -0x138],R8
MOV qword ptr [RBP + -0x140],R9
LEA RAX,[RBP + -0x110]
MOV qword ptr [RBP + -0x148],RAX
MOV RAX,qword ptr [RBP + -0x120]
MOV qword ptr [RBP + -0x160],RAX
MOV RAX,qword ptr [RBP + -0x118]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x170],RAX
CMP qword ptr [RBP + -0x128],0x100
JC 0x00193ece
MOV qword ptr [RBP + -0x128],0xff
LAB_00193ece:
MOV RAX,qword ptr [RBP + -0x160]
ADD RAX,qword ptr [RBP + -0x128]
MOV qword ptr [RBP + -0x158],RAX
LAB_00193ee3:
MOV RAX,qword ptr [RBP + -0x170]
MOV RDI,qword ptr [RBP + -0x118]
MOV RDX,qword ptr [RBP + -0x160]
MOV RCX,qword ptr [RBP + -0x158]
LEA RSI,[RBP + -0x168]
CALL RAX
MOV dword ptr [RBP + -0x174],EAX
CMP EAX,0x0
JLE 0x00193f68
MOV ECX,dword ptr [RBP + -0x174]
MOV RAX,qword ptr [RBP + -0x160]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x160],RAX
CMP qword ptr [RBP + -0x168],0x65
JA 0x00193f41
CMP qword ptr [RBP + -0x168],0x0
JNZ 0x00193f43
LAB_00193f41:
JMP 0x00193f68
LAB_00193f43:
MOV RAX,qword ptr [RBP + -0x168]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x148]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x148],RDX
MOV byte ptr [RAX],CL
JMP 0x00193ee3
LAB_00193f68:
MOV RDI,qword ptr [RBP + -0x118]
MOV RDX,qword ptr [RBP + -0x148]
LEA RSI,[RBP + -0x110]
MOV qword ptr [RBP + -0x188],RSI
SUB RDX,RSI
MOV ECX,dword ptr [RBP + -0x12c]
MOV R8,qword ptr [RBP + -0x138]
MOV R9,qword ptr [RBP + -0x140]
CALL 0x0017e7e0
MOV RDI,qword ptr [RBP + -0x188]
MOV qword ptr [RBP + -0x150],RAX
MOV RCX,qword ptr [RBP + -0x120]
MOV RAX,qword ptr [RBP + -0x118]
MOV EAX,dword ptr [RAX + 0x98]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x138]
MOV RSI,qword ptr [RAX]
SUB RSI,RDI
IMUL RDX,RSI
ADD RCX,RDX
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x150]
MOV qword ptr [RBP + -0x180],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0019400b
MOV RAX,qword ptr [RBP + -0x180]
ADD RSP,0x190
POP RBP
RET
LAB_0019400b:
CALL 0x00126360
|
int8
my_strntoull10rnd_mb2_or_mb4
(long param_1,long param_2,ulong param_3,int4 param_4,long *param_5,
int8 param_6)
{
code *pcVar1;
int iVar2;
long in_FS_OFFSET;
ulong local_170;
long local_168;
long local_160;
int8 local_158;
int1 *local_150;
int8 local_148;
long *local_140;
int4 local_134;
ulong local_130;
long local_128;
long local_120;
int1 local_118 [264];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
local_130 = param_3;
if (0xff < param_3) {
local_130 = 0xff;
}
local_160 = param_2 + local_130;
local_168 = param_2;
local_150 = local_118;
local_148 = param_6;
local_140 = param_5;
local_134 = param_4;
local_128 = param_2;
local_120 = param_1;
while (((iVar2 = (*pcVar1)(local_120,&local_170,local_168,local_160), 0 < iVar2 &&
(local_168 = local_168 + iVar2, local_170 < 0x66)) && (local_170 != 0))) {
*local_150 = (char)local_170;
local_150 = local_150 + 1;
}
local_158 = my_strntoull10rnd_8bit
(local_120,local_118,(long)local_150 - (long)local_118,local_134,local_140,
local_148);
*local_140 = local_128 + (ulong)*(uint *)(local_120 + 0x98) * (*local_140 - (long)local_118);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_158;
}
|
|
17,255
|
my_strntoull10rnd_mb2_or_mb4
|
eloqsql/strings/ctype-ucs2.c
|
static ulonglong
my_strntoull10rnd_mb2_or_mb4(CHARSET_INFO *cs,
const char *nptr, size_t length,
int unsign_fl,
char **endptr, int *err)
{
char buf[256], *b= buf;
ulonglong res;
const uchar *end, *s= (const uchar*) nptr;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
int cnv;
/* Cut too long strings */
if (length >= sizeof(buf))
length= sizeof(buf)-1;
end= s + length;
while ((cnv= mb_wc(cs, &wc, s, end)) > 0)
{
s+= cnv;
if (wc > (int) (uchar) 'e' || !wc)
break; /* Can't be a number part */
*b++= (char) wc;
}
res= my_strntoull10rnd_8bit(cs, buf, b - buf, unsign_fl, endptr, err);
*endptr= (char*) nptr + cs->mbminlen * (size_t) (*endptr - buf);
return res;
}
|
O3
|
c
|
my_strntoull10rnd_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %r9, -0x150(%rbp)
movq %r8, -0x158(%rbp)
movl %ecx, -0x134(%rbp)
movq %rsi, %rcx
movq %rdi, %r12
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %rbx
movl $0xff, %r13d
cmpq %r13, %rdx
cmovbq %rdx, %r13
addq %rsi, %r13
leaq -0x148(%rbp), %rsi
movq %rcx, -0x140(%rbp)
movq %rcx, %rdx
movq %r13, %rcx
callq *%rbx
leaq -0x130(%rbp), %r15
testl %eax, %eax
jle 0x6a6af
movq -0x140(%rbp), %r14
movq -0x148(%rbp), %rcx
leaq -0x1(%rcx), %rdx
cmpq $0x64, %rdx
ja 0x6a6af
movl %eax, %eax
addq %rax, %r14
movb %cl, (%r15)
incq %r15
movq %r12, %rdi
leaq -0x148(%rbp), %rsi
movq %r14, %rdx
movq %r13, %rcx
callq *%rbx
testl %eax, %eax
jg 0x6a67d
leaq -0x130(%rbp), %r14
subq %r14, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl -0x134(%rbp), %ecx
movq -0x158(%rbp), %rbx
movq %rbx, %r8
movq -0x150(%rbp), %r9
callq 0x5c2f8
movl 0x98(%r12), %ecx
movq (%rbx), %rdx
subq %r14, %rdx
imulq %rcx, %rdx
movq -0x140(%rbp), %rcx
addq %rdx, %rcx
movq %rcx, (%rbx)
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x6a71e
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x263a0
|
my_strntoull10rnd_mb2_or_mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 138h
mov [rbp+var_150], r9
mov [rbp+var_158], r8
mov [rbp+var_134], ecx
mov rcx, rsi
mov r12, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi+0B8h]
mov rbx, [rax+28h]
mov r13d, 0FFh
cmp rdx, r13
cmovb r13, rdx
add r13, rsi
lea rsi, [rbp+var_148]
mov [rbp+var_140], rcx
mov rdx, rcx
mov rcx, r13
call rbx
lea r15, [rbp+var_130]
test eax, eax
jle short loc_6A6AF
mov r14, [rbp+var_140]
loc_6A67D:
mov rcx, [rbp+var_148]
lea rdx, [rcx-1]
cmp rdx, 64h ; 'd'
ja short loc_6A6AF
mov eax, eax
add r14, rax
mov [r15], cl
inc r15
mov rdi, r12
lea rsi, [rbp+var_148]
mov rdx, r14
mov rcx, r13
call rbx
test eax, eax
jg short loc_6A67D
loc_6A6AF:
lea r14, [rbp+var_130]
sub r15, r14
mov rdi, r12
mov rsi, r14
mov rdx, r15
mov ecx, [rbp+var_134]
mov rbx, [rbp+var_158]
mov r8, rbx
mov r9, [rbp+var_150]
call my_strntoull10rnd_8bit
mov ecx, [r12+98h]
mov rdx, [rbx]
sub rdx, r14
imul rdx, rcx
mov rcx, [rbp+var_140]
add rcx, rdx
mov [rbx], rcx
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_6A71E
add rsp, 138h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6A71E:
call ___stack_chk_fail
|
long long my_strntoull10rnd_mb2_or_mb4(
long long a1,
long long a2,
unsigned long long a3,
int a4,
unsigned __int8 **a5,
int *a6)
{
long long ( *v6)(long long, long long *, long long, long long); // rbx
long long v7; // r13
long long v8; // r13
int v9; // eax
unsigned __int8 *v10; // r15
long long v11; // r14
long long result; // rax
long long v15; // [rsp+18h] [rbp-148h] BYREF
long long v16; // [rsp+20h] [rbp-140h]
int v17; // [rsp+2Ch] [rbp-134h]
unsigned __int8 v18[256]; // [rsp+30h] [rbp-130h] BYREF
unsigned long long v19; // [rsp+130h] [rbp-30h]
v17 = a4;
v19 = __readfsqword(0x28u);
v6 = *(long long ( **)(long long, long long *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
v7 = 255LL;
if ( a3 < 0xFF )
v7 = a3;
v8 = a2 + v7;
v16 = a2;
v9 = v6(a1, &v15, a2, v8);
v10 = v18;
if ( v9 > 0 )
{
v11 = v16;
do
{
if ( (unsigned long long)(v15 - 1) > 0x64 )
break;
v11 += (unsigned int)v9;
*v10++ = v15;
v9 = v6(a1, &v15, v11, v8);
}
while ( v9 > 0 );
}
result = my_strntoull10rnd_8bit(a1, v18, v10 - v18, v17, a5, a6);
*a5 = (unsigned __int8 *)(*(unsigned int *)(a1 + 152) * (*a5 - v18) + v16);
return result;
}
|
my_strntoull10rnd_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x138
MOV qword ptr [RBP + -0x150],R9
MOV qword ptr [RBP + -0x158],R8
MOV dword ptr [RBP + -0x134],ECX
MOV RCX,RSI
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV RBX,qword ptr [RAX + 0x28]
MOV R13D,0xff
CMP RDX,R13
CMOVC R13,RDX
ADD R13,RSI
LEA RSI,[RBP + -0x148]
MOV qword ptr [RBP + -0x140],RCX
MOV RDX,RCX
MOV RCX,R13
CALL RBX
LEA R15,[RBP + -0x130]
TEST EAX,EAX
JLE 0x0016a6af
MOV R14,qword ptr [RBP + -0x140]
LAB_0016a67d:
MOV RCX,qword ptr [RBP + -0x148]
LEA RDX,[RCX + -0x1]
CMP RDX,0x64
JA 0x0016a6af
MOV EAX,EAX
ADD R14,RAX
MOV byte ptr [R15],CL
INC R15
MOV RDI,R12
LEA RSI,[RBP + -0x148]
MOV RDX,R14
MOV RCX,R13
CALL RBX
TEST EAX,EAX
JG 0x0016a67d
LAB_0016a6af:
LEA R14,[RBP + -0x130]
SUB R15,R14
MOV RDI,R12
MOV RSI,R14
MOV RDX,R15
MOV ECX,dword ptr [RBP + -0x134]
MOV RBX,qword ptr [RBP + -0x158]
MOV R8,RBX
MOV R9,qword ptr [RBP + -0x150]
CALL 0x0015c2f8
MOV ECX,dword ptr [R12 + 0x98]
MOV RDX,qword ptr [RBX]
SUB RDX,R14
IMUL RDX,RCX
MOV RCX,qword ptr [RBP + -0x140]
ADD RCX,RDX
MOV qword ptr [RBX],RCX
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0016a71e
ADD RSP,0x138
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016a71e:
CALL 0x001263a0
|
void my_strntoull10rnd_mb2_or_mb4
(long param_1,long param_2,ulong param_3,int4 param_4,long *param_5,
int8 param_6)
{
code *pcVar1;
uint uVar2;
ulong uVar3;
long lVar4;
int1 *puVar5;
long in_FS_OFFSET;
long local_150;
long local_148;
int4 local_13c;
int1 local_138 [256];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
uVar3 = 0xff;
if (param_3 < 0xff) {
uVar3 = param_3;
}
local_148 = param_2;
local_13c = param_4;
uVar2 = (*pcVar1)(param_1,&local_150,param_2,uVar3 + param_2);
puVar5 = local_138;
lVar4 = local_148;
while ((0 < (int)uVar2 && (local_150 - 1U < 0x65))) {
lVar4 = lVar4 + (ulong)uVar2;
*puVar5 = (char)local_150;
puVar5 = puVar5 + 1;
uVar2 = (*pcVar1)(param_1,&local_150,lVar4,uVar3 + param_2);
}
my_strntoull10rnd_8bit(param_1,local_138,(long)puVar5 - (long)local_138,local_13c,param_5,param_6)
;
*param_5 = local_148 + (*param_5 - (long)local_138) * (ulong)*(uint *)(param_1 + 0x98);
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
17,256
|
test_producer_thread
|
xtate/src/util-data/rte-ring.c
|
static void test_producer_thread(void *v) {
struct Test *test = (struct Test *)v;
unsigned i = 1000;
struct rte_ring *ring = test->ring;
pixie_locked_add_u32(&test->producer_started, 1);
while (i) {
int err;
for (;;) {
err = rte_ring_sp_enqueue(ring, (void *)(size_t)i);
if (err == 0)
break;
}
i--;
}
pixie_locked_add_u32(&test->producer_done, 1);
}
|
O3
|
c
|
test_producer_thread:
movq (%rdi), %rax
lock
incl 0x8(%rdi)
movl $0x3e8, %ecx # imm = 0x3E8
movl 0x10(%rax), %edx
movl 0x14(%rax), %r8d
movl 0x2c(%rax), %esi
addl %edx, %esi
cmpl %r8d, %esi
je 0x510ad
leal 0x1(%r8), %r9d
movl %r9d, 0x14(%rax)
movl %r8d, %r10d
andl %edx, %r10d
movq %rcx, 0x30(%rax,%r10,8)
sfence
addl %r8d, %edx
subl %esi, %edx
addl $0x2, %edx
cmpl 0x4(%rax), %edx
movl %r9d, 0x18(%rax)
ja 0x510ad
decq %rcx
jne 0x510ad
lock
incl 0xc(%rdi)
retq
|
test_producer_thread:
mov rax, [rdi]
lock inc dword ptr [rdi+8]
mov ecx, 3E8h
loc_510AD:
mov edx, [rax+10h]
mov r8d, [rax+14h]
mov esi, [rax+2Ch]
add esi, edx
cmp esi, r8d
jz short loc_510AD
lea r9d, [r8+1]
mov [rax+14h], r9d
mov r10d, r8d
and r10d, edx
mov [rax+r10*8+30h], rcx
sfence
add edx, r8d
sub edx, esi
add edx, 2
cmp edx, [rax+4]
mov [rax+18h], r9d
ja short loc_510AD
dec rcx
jnz short loc_510AD
lock inc dword ptr [rdi+0Ch]
retn
|
_DWORD * test_producer_thread(long long a1)
{
_DWORD *result; // rax
long long v2; // rcx
int v3; // edx
int v4; // r8d
int v5; // esi
bool v6; // cc
result = *(_DWORD **)a1;
_InterlockedIncrement((volatile signed __int32 *)(a1 + 8));
v2 = 1000LL;
do
{
do
{
v3 = result[4];
v4 = result[5];
v5 = v3 + result[11];
}
while ( v5 == v4 );
result[5] = v4 + 1;
*(_QWORD *)&result[2 * (v3 & v4) + 12] = v2;
_mm_sfence();
v6 = (unsigned int)(v4 + v3 - v5 + 2) <= result[1];
result[6] = v4 + 1;
}
while ( !v6 || --v2 );
_InterlockedIncrement((volatile signed __int32 *)(a1 + 12));
return result;
}
|
test_producer_thread:
MOV RAX,qword ptr [RDI]
INC.LOCK dword ptr [RDI + 0x8]
MOV ECX,0x3e8
LAB_001510ad:
MOV EDX,dword ptr [RAX + 0x10]
MOV R8D,dword ptr [RAX + 0x14]
MOV ESI,dword ptr [RAX + 0x2c]
ADD ESI,EDX
CMP ESI,R8D
JZ 0x001510ad
LEA R9D,[R8 + 0x1]
MOV dword ptr [RAX + 0x14],R9D
MOV R10D,R8D
AND R10D,EDX
MOV qword ptr [RAX + R10*0x8 + 0x30],RCX
SFENCE
ADD EDX,R8D
SUB EDX,ESI
ADD EDX,0x2
CMP EDX,dword ptr [RAX + 0x4]
MOV dword ptr [RAX + 0x18],R9D
JA 0x001510ad
DEC RCX
JNZ 0x001510ad
INC.LOCK dword ptr [RDI + 0xc]
RET
|
void test_producer_thread(long *param_1)
{
uint uVar1;
uint uVar2;
long lVar3;
long lVar4;
uint uVar5;
lVar3 = *param_1;
LOCK();
*(int *)(param_1 + 1) = (int)param_1[1] + 1;
UNLOCK();
lVar4 = 1000;
do {
do {
uVar1 = *(uint *)(lVar3 + 0x10);
uVar2 = *(uint *)(lVar3 + 0x14);
uVar5 = *(int *)(lVar3 + 0x2c) + uVar1;
} while (uVar5 == uVar2);
*(uint *)(lVar3 + 0x14) = uVar2 + 1;
*(long *)(lVar3 + 0x30 + (ulong)(uVar2 & uVar1) * 8) = lVar4;
*(uint *)(lVar3 + 0x18) = uVar2 + 1;
} while ((*(uint *)(lVar3 + 4) < ((uVar1 + uVar2) - uVar5) + 2) ||
(lVar4 = lVar4 + -1, lVar4 != 0));
LOCK();
*(int *)((long)param_1 + 0xc) = *(int *)((long)param_1 + 0xc) + 1;
UNLOCK();
return;
}
|
|
17,257
|
my_strnncollsp_latin1_de
|
eloqsql/strings/ctype-latin1.c
|
static int my_strnncollsp_latin1_de(CHARSET_INFO *cs __attribute__((unused)),
const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
const uchar *a_end= a + a_length, *b_end= b + b_length;
uchar a_char, a_extend= 0, b_char, b_extend= 0;
while ((a < a_end || a_extend) && (b < b_end || b_extend))
{
if (a_extend)
{
a_char=a_extend;
a_extend= 0;
}
else
{
a_extend= combo2map[*a];
a_char= combo1map[*a++];
}
if (b_extend)
{
b_char= b_extend;
b_extend= 0;
}
else
{
b_extend= combo2map[*b];
b_char= combo1map[*b++];
}
if (a_char != b_char)
return (int) a_char - (int) b_char;
}
/* Check if double character last */
if (a_extend)
return 1;
if (b_extend)
return -1;
if (a < a_end)
return my_strnncollsp_padspace_bin(a, a_end - a);
if (b < b_end)
return -my_strnncollsp_padspace_bin(b, b_end - b);
return 0;
}
|
O0
|
c
|
my_strnncollsp_latin1_de:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x42(%rbp)
movb $0x0, -0x44(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
jb 0x482f4
movzbl -0x42(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x45(%rbp)
je 0x48316
movq -0x28(%rbp), %rcx
movb $0x1, %al
cmpq -0x40(%rbp), %rcx
movb %al, -0x46(%rbp)
jb 0x48310
movzbl -0x44(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x46(%rbp)
movb -0x46(%rbp), %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0x48322
jmp 0x483d4
cmpb $0x0, -0x42(%rbp)
je 0x48334
movb -0x42(%rbp), %al
movb %al, -0x41(%rbp)
movb $0x0, -0x42(%rbp)
jmp 0x4836b
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x100abc(%rip), %rax # 0x148e00
movb (%rax,%rcx), %al
movb %al, -0x42(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x10099b(%rip), %rax # 0x148d00
movb (%rax,%rcx), %al
movb %al, -0x41(%rbp)
cmpb $0x0, -0x44(%rbp)
je 0x4837d
movb -0x44(%rbp), %al
movb %al, -0x43(%rbp)
movb $0x0, -0x44(%rbp)
jmp 0x483b4
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x100a73(%rip), %rax # 0x148e00
movb (%rax,%rcx), %al
movb %al, -0x44(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x100952(%rip), %rax # 0x148d00
movb (%rax,%rcx), %al
movb %al, -0x43(%rbp)
movzbl -0x41(%rbp), %eax
movzbl -0x43(%rbp), %ecx
cmpl %ecx, %eax
je 0x483cf
movzbl -0x41(%rbp), %eax
movzbl -0x43(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x48445
jmp 0x482dc
cmpb $0x0, -0x42(%rbp)
je 0x483e3
movl $0x1, -0x4(%rbp)
jmp 0x48445
cmpb $0x0, -0x44(%rbp)
je 0x483f2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x48445
movq -0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x48415
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rax
subq %rax, %rsi
callq 0x3eea0
movl %eax, -0x4(%rbp)
jmp 0x48445
movq -0x28(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x4843e
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rax
subq %rax, %rsi
callq 0x3eea0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x48445
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
|
my_strnncollsp_latin1_de:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_40], rax
mov [rbp+var_42], 0
mov [rbp+var_44], 0
loc_482DC:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_38]
jb short loc_482F4
movzx ecx, [rbp+var_42]
xor eax, eax
cmp ecx, 0
mov [rbp+var_45], al
jz short loc_48316
loc_482F4:
mov rcx, [rbp+var_28]
mov al, 1
cmp rcx, [rbp+var_40]
mov [rbp+var_46], al
jb short loc_48310
movzx eax, [rbp+var_44]
cmp eax, 0
setnz al
mov [rbp+var_46], al
loc_48310:
mov al, [rbp+var_46]
mov [rbp+var_45], al
loc_48316:
mov al, [rbp+var_45]
test al, 1
jnz short loc_48322
jmp loc_483D4
loc_48322:
cmp [rbp+var_42], 0
jz short loc_48334
mov al, [rbp+var_42]
mov [rbp+var_41], al
mov [rbp+var_42], 0
jmp short loc_4836B
loc_48334:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo2map
mov al, [rax+rcx]
mov [rbp+var_42], al
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo1map
mov al, [rax+rcx]
mov [rbp+var_41], al
loc_4836B:
cmp [rbp+var_44], 0
jz short loc_4837D
mov al, [rbp+var_44]
mov [rbp+var_43], al
mov [rbp+var_44], 0
jmp short loc_483B4
loc_4837D:
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo2map
mov al, [rax+rcx]
mov [rbp+var_44], al
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 1
mov [rbp+var_28], rcx
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo1map
mov al, [rax+rcx]
mov [rbp+var_43], al
loc_483B4:
movzx eax, [rbp+var_41]
movzx ecx, [rbp+var_43]
cmp eax, ecx
jz short loc_483CF
movzx eax, [rbp+var_41]
movzx ecx, [rbp+var_43]
sub eax, ecx
mov [rbp+var_4], eax
jmp short loc_48445
loc_483CF:
jmp loc_482DC
loc_483D4:
cmp [rbp+var_42], 0
jz short loc_483E3
mov [rbp+var_4], 1
jmp short loc_48445
loc_483E3:
cmp [rbp+var_44], 0
jz short loc_483F2
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_48445
loc_483F2:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_38]
jnb short loc_48415
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_18]
sub rsi, rax
call my_strnncollsp_padspace_bin
mov [rbp+var_4], eax
jmp short loc_48445
loc_48415:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_40]
jnb short loc_4843E
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_40]
mov rax, [rbp+var_28]
sub rsi, rax
call my_strnncollsp_padspace_bin
mov ecx, eax
xor eax, eax
sub eax, ecx
mov [rbp+var_4], eax
jmp short loc_48445
loc_4843E:
mov [rbp+var_4], 0
loc_48445:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long my_strnncollsp_latin1_de(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned __int8 *a4,
long long a5)
{
unsigned __int8 *v5; // rax
unsigned __int8 *v6; // rax
bool v8; // [rsp+Ah] [rbp-46h]
bool v9; // [rsp+Bh] [rbp-45h]
unsigned __int8 v10; // [rsp+Ch] [rbp-44h]
unsigned __int8 v11; // [rsp+Dh] [rbp-43h]
unsigned __int8 v12; // [rsp+Eh] [rbp-42h]
unsigned __int8 v13; // [rsp+Fh] [rbp-41h]
unsigned long long v14; // [rsp+10h] [rbp-40h]
unsigned long long v15; // [rsp+18h] [rbp-38h]
unsigned __int8 *v16; // [rsp+28h] [rbp-28h]
unsigned __int8 *v17; // [rsp+38h] [rbp-18h]
v17 = a2;
v16 = a4;
v15 = (unsigned long long)&a2[a3];
v14 = (unsigned long long)&a4[a5];
v12 = 0;
v10 = 0;
while ( 1 )
{
if ( (unsigned long long)v17 < v15 || (v9 = 0, v12) )
{
v8 = 1;
if ( (unsigned long long)v16 >= v14 )
v8 = v10 != 0;
v9 = v8;
}
if ( !v9 )
break;
if ( v12 )
{
v13 = v12;
v12 = 0;
}
else
{
v12 = combo2map[*v17];
v5 = v17++;
v13 = combo1map[*v5];
}
if ( v10 )
{
v11 = v10;
v10 = 0;
}
else
{
v10 = combo2map[*v16];
v6 = v16++;
v11 = combo1map[*v6];
}
if ( v13 != v11 )
return (unsigned int)(v13 - v11);
}
if ( v12 )
{
return 1;
}
else if ( v10 )
{
return (unsigned int)-1;
}
else if ( (unsigned long long)v17 >= v15 )
{
if ( (unsigned long long)v16 >= v14 )
return 0;
else
return (unsigned int)-(int)my_strnncollsp_padspace_bin(v16, v14 - (_QWORD)v16);
}
else
{
return (unsigned int)my_strnncollsp_padspace_bin(v17, v15 - (_QWORD)v17);
}
}
|
my_strnncollsp_latin1_de:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV byte ptr [RBP + -0x42],0x0
MOV byte ptr [RBP + -0x44],0x0
LAB_001482dc:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x38]
JC 0x001482f4
MOVZX ECX,byte ptr [RBP + -0x42]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x45],AL
JZ 0x00148316
LAB_001482f4:
MOV RCX,qword ptr [RBP + -0x28]
MOV AL,0x1
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x46],AL
JC 0x00148310
MOVZX EAX,byte ptr [RBP + -0x44]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x46],AL
LAB_00148310:
MOV AL,byte ptr [RBP + -0x46]
MOV byte ptr [RBP + -0x45],AL
LAB_00148316:
MOV AL,byte ptr [RBP + -0x45]
TEST AL,0x1
JNZ 0x00148322
JMP 0x001483d4
LAB_00148322:
CMP byte ptr [RBP + -0x42],0x0
JZ 0x00148334
MOV AL,byte ptr [RBP + -0x42]
MOV byte ptr [RBP + -0x41],AL
MOV byte ptr [RBP + -0x42],0x0
JMP 0x0014836b
LAB_00148334:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x248e00]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x42],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x248d00]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x41],AL
LAB_0014836b:
CMP byte ptr [RBP + -0x44],0x0
JZ 0x0014837d
MOV AL,byte ptr [RBP + -0x44]
MOV byte ptr [RBP + -0x43],AL
MOV byte ptr [RBP + -0x44],0x0
JMP 0x001483b4
LAB_0014837d:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x248e00]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x44],AL
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x248d00]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x43],AL
LAB_001483b4:
MOVZX EAX,byte ptr [RBP + -0x41]
MOVZX ECX,byte ptr [RBP + -0x43]
CMP EAX,ECX
JZ 0x001483cf
MOVZX EAX,byte ptr [RBP + -0x41]
MOVZX ECX,byte ptr [RBP + -0x43]
SUB EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148445
LAB_001483cf:
JMP 0x001482dc
LAB_001483d4:
CMP byte ptr [RBP + -0x42],0x0
JZ 0x001483e3
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00148445
LAB_001483e3:
CMP byte ptr [RBP + -0x44],0x0
JZ 0x001483f2
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00148445
LAB_001483f2:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x00148415
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x18]
SUB RSI,RAX
CALL 0x0013eea0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148445
LAB_00148415:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x0014843e
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
SUB RSI,RAX
CALL 0x0013eea0
MOV ECX,EAX
XOR EAX,EAX
SUB EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148445
LAB_0014843e:
MOV dword ptr [RBP + -0x4],0x0
LAB_00148445:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int my_strnncollsp_latin1_de
(int8 param_1,byte *param_2,long param_3,byte *param_4,long param_5)
{
int iVar1;
byte *pbVar2;
byte *pbVar3;
bool local_4e;
byte local_4c;
byte local_4b;
byte local_4a;
byte local_49;
byte *local_30;
byte *local_20;
pbVar2 = param_2 + param_3;
pbVar3 = param_4 + param_5;
local_4a = 0;
local_4c = 0;
local_30 = param_4;
local_20 = param_2;
while( true ) {
if ((local_20 < pbVar2) || (local_4e = false, local_4a != 0)) {
local_4e = local_30 < pbVar3 || local_4c != 0;
}
if (!local_4e) break;
if (local_4a == 0) {
local_4a = combo2map[*local_20];
local_49 = combo1map[*local_20];
local_20 = local_20 + 1;
}
else {
local_49 = local_4a;
local_4a = 0;
}
if (local_4c == 0) {
local_4c = combo2map[*local_30];
local_4b = combo1map[*local_30];
local_30 = local_30 + 1;
}
else {
local_4b = local_4c;
local_4c = 0;
}
if (local_49 != local_4b) {
return (uint)local_49 - (uint)local_4b;
}
}
if (local_4a != 0) {
return 1;
}
if (local_4c != 0) {
return -1;
}
if (local_20 < pbVar2) {
iVar1 = my_strnncollsp_padspace_bin(local_20,(long)pbVar2 - (long)local_20);
return iVar1;
}
if (local_30 < pbVar3) {
iVar1 = my_strnncollsp_padspace_bin(local_30,(long)pbVar3 - (long)local_30);
return -iVar1;
}
return 0;
}
|
|
17,258
|
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool)
|
monkey531[P]llama/common/./json.hpp
|
std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
}
|
O0
|
cpp
|
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool):
subq $0x148, %rsp # imm = 0x148
movb %dl, %al
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
andb $0x1, %al
movb %al, 0x127(%rsp)
movq 0x130(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0x20, %rdi
callq 0xb9100
xorb $-0x1, %al
testb $0x1, %al
jne 0xbfe20
jmp 0xbfe22
jmp 0xbfe41
leaq 0x10ee0b(%rip), %rdi # 0x1cec34
leaq 0x10caec(%rip), %rsi # 0x1cc91c
movl $0x1c28, %edx # imm = 0x1C28
leaq 0x10fc23(%rip), %rcx # 0x1cfa5f
callq 0x50230
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
callq 0xb9180
movq %rax, 0x110(%rsp)
movq %rdx, 0x118(%rsp)
leaq 0x110(%rsp), %rdi
callq 0xb72c0
xorb $-0x1, %al
testb $0x1, %al
jne 0xbfe74
jmp 0xbfeaa
movb $0x0, 0x10f(%rsp)
movq $0x0, 0x100(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x10f(%rsp), %rsi
leaq 0x100(%rsp), %rdx
callq 0xb9ca0
jmp 0xc031f
movq 0x128(%rsp), %rsi
leaq 0xf0(%rsp), %rdi
callq 0xbd2c0
movb $0x1, %al
testb $0x1, 0x127(%rsp)
movb %al, 0x3f(%rsp)
jne 0xbff12
movq 0x40(%rsp), %rdi
movq %rdi, %rax
subq $-0x80, %rax
movq %rax, 0x30(%rsp)
addq $0x8, %rdi
callq 0xb9280
movq 0x30(%rsp), %rdi
movl %eax, %esi
movl $0x5, %edx
leaq 0xf0(%rsp), %rcx
callq 0xb9220
movb %al, 0x3e(%rsp)
jmp 0xbff08
movb 0x3e(%rsp), %al
movb %al, 0x3f(%rsp)
jmp 0xbff12
movb 0x3f(%rsp), %al
andb $0x1, %al
movb %al, 0xef(%rsp)
testb $0x1, 0xef(%rsp)
jne 0xbff92
movb $0x0, 0xdb(%rsp)
movq $0x0, 0xd0(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0xdb(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
callq 0xb9ca0
jmp 0xbff5c
movl $0x1, 0xcc(%rsp)
jmp 0xc0312
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x6e0f0
jmp 0xc0336
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9cd0
testb $0x1, %al
jne 0xbffa6
jmp 0xc0023
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0xf0(%rsp), %rsi
callq 0x9f8d0
movq 0x28(%rsp), %rsi
movq 0x40(%rsp), %rax
movq (%rax), %rdi
callq 0xb3e10
movq 0x28(%rsp), %rdi
callq 0x6e0f0
movq 0x40(%rsp), %rax
movb $0x1, 0xb7(%rsp)
movq (%rax), %rax
movq %rax, 0xa8(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0xb7(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
callq 0xb9d20
jmp 0xc0013
movl $0x1, 0xcc(%rsp)
jmp 0xc0312
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
cmpq $0x0, (%rax)
jne 0xc007a
movb $0x0, 0xa7(%rsp)
movq $0x0, 0x98(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0xa7(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0xb9ca0
jmp 0xc006a
movl $0x1, 0xcc(%rsp)
jmp 0xc0312
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rdi
callq 0xa2c40
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x27(%rsp)
jne 0xc00b7
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rdi
callq 0xa2c80
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0xc00c1
jmp 0xc00c3
jmp 0xc00e2
leaq 0x10ec80(%rip), %rdi # 0x1ced4a
leaq 0x10c84b(%rip), %rsi # 0x1cc91c
movl $0x1c4b, %edx # imm = 0x1C4B
leaq 0x10f982(%rip), %rcx # 0x1cfa5f
callq 0x50230
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rdi
callq 0xa2c40
testb $0x1, %al
jne 0xc00fe
jmp 0xc017b
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xf0(%rsp), %rsi
callq 0xa36d0
jmp 0xc0122
movq 0x40(%rsp), %rdi
movb $0x1, 0x97(%rsp)
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0xa2be0
movq %rax, 0x88(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x97(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0xb9d20
jmp 0xc016b
movl $0x1, 0xcc(%rsp)
jmp 0xc0312
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rdi
callq 0xa2c80
testb $0x1, %al
jne 0xc0197
jmp 0xc0199
jmp 0xc01b8
leaq 0x10ebca(%rip), %rdi # 0x1ced6a
leaq 0x10c775(%rip), %rsi # 0x1cc91c
movl $0x1c55, %edx # imm = 0x1C55
leaq 0x10f8ac(%rip), %rcx # 0x1cfa5f
callq 0x50230
movq 0x40(%rsp), %rdi
addq $0x48, %rdi
callq 0xb9100
xorb $-0x1, %al
testb $0x1, %al
jne 0xc01ce
jmp 0xc01d0
jmp 0xc01ef
leaq 0x10ebb1(%rip), %rdi # 0x1ced88
leaq 0x10c73e(%rip), %rsi # 0x1cc91c
movl $0x1c57, %edx # imm = 0x1C57
leaq 0x10f875(%rip), %rcx # 0x1cfa5f
callq 0x50230
movq 0x40(%rsp), %rdi
addq $0x48, %rdi
callq 0xb9180
movq %rdx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
jmp 0xc0209
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movq %rax, 0x78(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xb72c0
movq 0x40(%rsp), %rdi
movb %al, 0x87(%rsp)
addq $0x48, %rdi
callq 0xb9200
jmp 0xc023e
testb $0x1, 0x87(%rsp)
jne 0xc027f
movb $0x0, 0x6f(%rsp)
movq $0x0, 0x60(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x6f(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0xb9ca0
jmp 0xc026f
movl $0x1, 0xcc(%rsp)
jmp 0xc0312
movq 0x40(%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0xc028d
jmp 0xc02ac
leaq 0x10eb0c(%rip), %rdi # 0x1ceda0
leaq 0x10c681(%rip), %rsi # 0x1cc91c
movl $0x1c60, %edx # imm = 0x1C60
leaq 0x10f7b8(%rip), %rcx # 0x1cfa5f
callq 0x50230
leaq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0xf0(%rsp), %rsi
callq 0x9f8d0
movq 0x40(%rsp), %rax
movq (%rsp), %rsi
movq %rax, %rcx
addq $0x70, %rcx
movq %rcx, 0x8(%rsp)
movq 0x70(%rax), %rdi
callq 0xb3e10
movq (%rsp), %rdi
callq 0x6e0f0
movq 0x8(%rsp), %rdx
movb $0x1, 0x4f(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x4f(%rsp), %rsi
callq 0xb9d50
jmp 0xc0307
movl $0x1, 0xcc(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x6e0f0
movb 0x138(%rsp), %al
movq 0x140(%rsp), %rdx
addq $0x148, %rsp # imm = 0x148
retq
movq 0xe0(%rsp), %rdi
callq 0x50940
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIRSB_EESt4pairIbPSF_EOT_b:
sub rsp, 148h
mov al, dl
mov [rsp+148h+var_18], rdi
mov [rsp+148h+var_20], rsi
and al, 1
mov [rsp+148h+var_21], al
mov rdi, [rsp+148h+var_18]
mov [rsp+148h+var_108], rdi
add rdi, 20h ; ' '
call _ZNKSt6vectorIbSaIbEE5emptyEv; std::vector<bool>::empty(void)
xor al, 0FFh
test al, 1
jnz short loc_BFE20
jmp short loc_BFE22
loc_BFE20:
jmp short loc_BFE41
loc_BFE22:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1C28h
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_BFE41:
mov rdi, [rsp+148h+var_108]
add rdi, 20h ; ' '
call _ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
mov [rsp+148h+var_38], rax
mov [rsp+148h+var_30], rdx
lea rdi, [rsp+148h+var_38]
call _ZNKSt14_Bit_referencecvbEv; std::_Bit_reference::operator bool(void)
xor al, 0FFh
test al, 1
jnz short loc_BFE74
jmp short loc_BFEAA
loc_BFE74:
mov [rsp+148h+var_39], 0
mov [rsp+148h+var_48], 0
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_39]
lea rdx, [rsp+148h+var_48]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp loc_C031F
loc_BFEAA:
mov rsi, [rsp+148h+var_20]
lea rdi, [rsp+148h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
mov al, 1
test [rsp+148h+var_21], 1
mov [rsp+148h+var_109], al
jnz short loc_BFF12
mov rdi, [rsp+148h+var_108]
mov rax, rdi
sub rax, 0FFFFFFFFFFFFFF80h
mov [rsp+148h+var_118], rax
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4sizeEv; 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> *,std::allocator<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> *>>::size(void)
mov rdi, [rsp+148h+var_118]
mov esi, eax
mov edx, 5
lea rcx, [rsp+148h+var_58]
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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 [rsp+148h+var_10A], al
jmp short $+2
loc_BFF08:
mov al, [rsp+148h+var_10A]
mov [rsp+148h+var_109], al
jmp short $+2
loc_BFF12:
mov al, [rsp+148h+var_109]
and al, 1
mov [rsp+148h+var_59], al
test [rsp+148h+var_59], 1
jnz short loc_BFF92
mov [rsp+148h+var_6D], 0
mov [rsp+148h+var_78], 0
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_6D]
lea rdx, [rsp+148h+var_78]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_BFF5C:
mov [rsp+148h+var_7C], 1
jmp loc_C0312
mov rcx, rax
mov eax, edx
mov [rsp+arg_D8], rcx
mov [rsp+arg_D4], eax
lea rdi, [rsp+arg_E8]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp loc_C0336
loc_BFF92:
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE5emptyEv; 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> *,std::allocator<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> *>>::empty(void)
test al, 1
jnz short loc_BFFA6
jmp short loc_C0023
loc_BFFA6:
lea rdi, [rsp+148h+var_90]
mov [rsp+148h+var_120], rdi
lea rsi, [rsp+148h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; 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>&&)
mov rsi, [rsp+148h+var_120]
mov rax, [rsp+148h+var_108]
mov rdi, [rax]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, [rsp+148h+var_120]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rax, [rsp+148h+var_108]
mov [rsp+148h+var_91], 1
mov rax, [rax]
mov [rsp+148h+var_A0], rax
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_91]
lea rdx, [rsp+148h+var_A0]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_C0013:
mov [rsp+148h+var_7C], 1
jmp loc_C0312
loc_C0023:
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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> *,std::allocator<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> *>>::back(void)
cmp qword ptr [rax], 0
jnz short loc_C007A
mov [rsp+148h+var_A1], 0
mov [rsp+148h+var_B0], 0
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_A1]
lea rdx, [rsp+148h+var_B0]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_C006A:
mov [rsp+148h+var_7C], 1
jmp loc_C0312
loc_C007A:
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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> *,std::allocator<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> *>>::back(void)
mov rdi, [rax]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8is_arrayEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_array(void)
mov cl, al
mov al, 1
test cl, 1
mov [rsp+148h+var_121], al
jnz short loc_C00B7
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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> *,std::allocator<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> *>>::back(void)
mov rdi, [rax]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_objectEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_object(void)
mov [rsp+148h+var_121], al
loc_C00B7:
mov al, [rsp+148h+var_121]
test al, 1
jnz short loc_C00C1
jmp short loc_C00C3
loc_C00C1:
jmp short loc_C00E2
loc_C00C3:
lea rdi, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1C4Bh
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_C00E2:
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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> *,std::allocator<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> *>>::back(void)
mov rdi, [rax]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8is_arrayEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_array(void)
test al, 1
jnz short loc_C00FE
jmp short loc_C017B
loc_C00FE:
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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> *,std::allocator<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> *>>::back(void)
mov rax, [rax]
mov rdi, [rax+8]
lea rsi, [rsp+148h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
jmp short $+2
loc_C0122:
mov rdi, [rsp+148h+var_108]
mov [rsp+148h+var_B1], 1
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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> *,std::allocator<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> *>>::back(void)
mov rax, [rax]
mov rdi, [rax+8]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE4backEv; 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>>::back(void)
mov [rsp+148h+var_C0], rax
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_B1]
lea rdx, [rsp+148h+var_C0]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_C016B:
mov [rsp+148h+var_7C], 1
jmp loc_C0312
loc_C017B:
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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> *,std::allocator<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> *>>::back(void)
mov rdi, [rax]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_objectEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_object(void)
test al, 1
jnz short loc_C0197
jmp short loc_C0199
loc_C0197:
jmp short loc_C01B8
loc_C0199:
lea rdi, aRefStackBackIs+20h; "ref_stack.back()->is_object()"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1C55h
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_C01B8:
mov rdi, [rsp+148h+var_108]
add rdi, 48h ; 'H'
call _ZNKSt6vectorIbSaIbEE5emptyEv; std::vector<bool>::empty(void)
xor al, 0FFh
test al, 1
jnz short loc_C01CE
jmp short loc_C01D0
loc_C01CE:
jmp short loc_C01EF
loc_C01D0:
lea rdi, aKeyKeepStackEm; "!key_keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1C57h
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_C01EF:
mov rdi, [rsp+148h+var_108]
add rdi, 48h ; 'H'
call _ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
mov [rsp+148h+var_138], rdx
mov [rsp+148h+var_130], rax
jmp short $+2
loc_C0209:
mov rax, [rsp+148h+var_138]
mov rcx, [rsp+148h+var_130]
mov [rsp+148h+var_D8], rcx
mov [rsp+148h+var_D0], rax
lea rdi, [rsp+148h+var_D8]
call _ZNKSt14_Bit_referencecvbEv; std::_Bit_reference::operator bool(void)
mov rdi, [rsp+148h+var_108]
mov [rsp+148h+var_C1], al
add rdi, 48h ; 'H'
call _ZNSt6vectorIbSaIbEE8pop_backEv; std::vector<bool>::pop_back(void)
jmp short $+2
loc_C023E:
test [rsp+148h+var_C1], 1
jnz short loc_C027F
mov [rsp+148h+var_D9], 0
mov [rsp+148h+var_E8], 0
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_D9]
lea rdx, [rsp+148h+var_E8]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_C026F:
mov [rsp+148h+var_7C], 1
jmp loc_C0312
loc_C027F:
mov rax, [rsp+148h+var_108]
cmp qword ptr [rax+70h], 0
jz short loc_C028D
jmp short loc_C02AC
loc_C028D:
lea rdi, aObjectElement; "object_element"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1C60h
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_C02AC:
lea rdi, [rsp+148h+var_F8]
mov [rsp+148h+var_148], rdi
lea rsi, [rsp+148h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; 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>&&)
mov rax, [rsp+148h+var_108]
mov rsi, [rsp+148h+var_148]
mov rcx, rax
add rcx, 70h ; 'p'
mov [rsp+148h+var_140], rcx
mov rdi, [rax+70h]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, [rsp+148h+var_148]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rdx, [rsp+148h+var_140]
mov [rsp+148h+var_F9], 1
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_F9]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbRSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISK_SL_EEEbE4typeELb1EEEOSK_OSL_
jmp short $+2
loc_C0307:
mov [rsp+148h+var_7C], 1
loc_C0312:
lea rdi, [rsp+148h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_C031F:
mov al, [rsp+148h+var_10]
mov rdx, [rsp+148h+var_8]
add rsp, 148h
retn
loc_C0336:
mov rdi, [rsp+arg_D8]
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>>::handle_value<std::string&>(
long long a1,
long long a2,
char a3)
{
long long v3; // rdx
int v4; // eax
_BYTE **v5; // rax
_BYTE **v6; // rax
_BYTE **v7; // rax
long long v8; // rax
long long v9; // rdx
long long v10; // rcx
long long v11; // r8
long long v12; // r9
long long v13; // rax
_BYTE **v14; // rax
long long v15; // rdx
bool is_object; // [rsp+27h] [rbp-121h]
char v18; // [rsp+3Fh] [rbp-109h]
char v19; // [rsp+4Fh] [rbp-F9h] BYREF
__int128 v20; // [rsp+50h] [rbp-F8h] BYREF
long long v21; // [rsp+60h] [rbp-E8h]
char v22; // [rsp+6Fh] [rbp-D9h] BYREF
_QWORD v23[2]; // [rsp+70h] [rbp-D8h] BYREF
bool v24; // [rsp+87h] [rbp-C1h]
long long v25; // [rsp+88h] [rbp-C0h] BYREF
char v26; // [rsp+97h] [rbp-B1h] BYREF
long long v27; // [rsp+98h] [rbp-B0h]
char v28; // [rsp+A7h] [rbp-A1h] BYREF
long long v29; // [rsp+A8h] [rbp-A0h] BYREF
char v30; // [rsp+B7h] [rbp-91h] BYREF
__int128 v31; // [rsp+B8h] [rbp-90h] BYREF
int v32; // [rsp+CCh] [rbp-7Ch]
long long v33; // [rsp+D0h] [rbp-78h]
_BYTE v34[21]; // [rsp+DBh] [rbp-6Dh] BYREF
_BYTE v35[16]; // [rsp+F0h] [rbp-58h] BYREF
long long v36; // [rsp+100h] [rbp-48h]
char v37; // [rsp+10Fh] [rbp-39h] BYREF
_QWORD v38[2]; // [rsp+110h] [rbp-38h] BYREF
char v39; // [rsp+127h] [rbp-21h]
long long v40; // [rsp+128h] [rbp-20h]
long long v41; // [rsp+130h] [rbp-18h]
_BYTE v42[8]; // [rsp+138h] [rbp-10h] BYREF
v41 = a1;
v40 = a2;
v39 = a3 & 1;
if ( (std::vector<bool>::empty((unsigned long long **)(a1 + 32)) & 1) != 0 )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7208LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ord"
"ered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value"
" = std::basic_string<char> &]");
v38[0] = std::vector<bool>::back(a1 + 32);
v38[1] = v3;
if ( std::_Bit_reference::operator bool((long long)v38) )
{
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(
v35,
v40);
v18 = 1;
if ( (v39 & 1) == 0 )
{
v4 = 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> *,std::allocator<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> *>>::size((_QWORD *)(a1 + 8));
v18 = std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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()(
(std::_Function_base *)(a1 + 128),
v4,
5,
(long long)v35);
}
v34[20] = v18 & 1;
if ( (v18 & 1) != 0 )
{
if ( (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> *,std::allocator<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> *>>::empty(a1 + 8) & 1) != 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>::basic_json(
&v31,
(long long)v35);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)a1,
(long long)&v31);
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)&v31);
v30 = 1;
v29 = *(_QWORD *)a1;
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
(long long)v42,
&v30,
&v29);
v32 = 1;
}
else if ( *(_QWORD *)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> *,std::allocator<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> *>>::back(a1 + 8) )
{
v5 = (_BYTE **)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> *,std::allocator<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> *>>::back(a1 + 8);
is_object = 1;
if ( !nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_array(*v5) )
{
v6 = (_BYTE **)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> *,std::allocator<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> *>>::back(a1 + 8);
is_object = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_object(*v6);
}
if ( !is_object )
__assert_fail(
"ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7243LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohman"
"n::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered"
"_map>, Value = std::basic_string<char> &]");
v7 = (_BYTE **)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> *,std::allocator<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> *>>::back(a1 + 8);
if ( nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_array(*v7) )
{
v8 = 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> *,std::allocator<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> *>>::back(a1 + 8);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*(_QWORD *)(*(_QWORD *)v8 + 8LL),
(long long)v35,
v9,
v10,
v11,
v12);
v26 = 1;
v13 = 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> *,std::allocator<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> *>>::back(a1 + 8);
v25 = 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>>::back(*(_QWORD *)(*(_QWORD *)v13 + 8LL));
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
(long long)v42,
&v26,
&v25);
v32 = 1;
}
else
{
v14 = (_BYTE **)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> *,std::allocator<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> *>>::back(a1 + 8);
if ( !nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_object(*v14) )
__assert_fail(
"ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7253LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohm"
"ann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ord"
"ered_map>, Value = std::basic_string<char> &]");
if ( (std::vector<bool>::empty((unsigned long long **)(a1 + 72)) & 1) != 0 )
__assert_fail(
"!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7255LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohm"
"ann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ord"
"ered_map>, Value = std::basic_string<char> &]");
v23[0] = std::vector<bool>::back(a1 + 72);
v23[1] = v15;
v24 = std::_Bit_reference::operator bool((long long)v23);
std::vector<bool>::pop_back(a1 + 72);
if ( v24 )
{
if ( !*(_QWORD *)(a1 + 112) )
__assert_fail(
"object_element",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7264LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlo"
"hmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann:"
":ordered_map>, Value = std::basic_string<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>::basic_json(
&v20,
(long long)v35);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(a1 + 112),
(long long)&v20);
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)&v20);
v19 = 1;
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbRSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISK_SL_EEEbE4typeELb1EEEOSK_OSL_(
(long long)v42,
&v19,
(_QWORD *)(a1 + 112));
v32 = 1;
}
else
{
v22 = 0;
v21 = 0LL;
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
(long long)v42,
&v22);
v32 = 1;
}
}
}
else
{
v28 = 0;
v27 = 0LL;
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
(long long)v42,
&v28);
v32 = 1;
}
}
else
{
v34[0] = 0;
v33 = 0LL;
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
(long long)v42,
v34);
v32 = 1;
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v35);
}
else
{
v37 = 0;
v36 = 0LL;
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
(long long)v42,
&v37);
}
return v42[0];
}
|
handle_value<std::__cxx11::string&>:
SUB RSP,0x148
MOV AL,DL
MOV qword ptr [RSP + 0x130],RDI
MOV qword ptr [RSP + 0x128],RSI
AND AL,0x1
MOV byte ptr [RSP + 0x127],AL
MOV RDI,qword ptr [RSP + 0x130]
MOV qword ptr [RSP + 0x40],RDI
ADD RDI,0x20
CALL 0x001b9100
XOR AL,0xff
TEST AL,0x1
JNZ 0x001bfe20
JMP 0x001bfe22
LAB_001bfe20:
JMP 0x001bfe41
LAB_001bfe22:
LEA RDI,[0x2cec34]
LEA RSI,[0x2cc91c]
MOV EDX,0x1c28
LEA RCX,[0x2cfa5f]
CALL 0x00150230
LAB_001bfe41:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x20
CALL 0x001b9180
MOV qword ptr [RSP + 0x110],RAX
MOV qword ptr [RSP + 0x118],RDX
LEA RDI,[RSP + 0x110]
CALL 0x001b72c0
XOR AL,0xff
TEST AL,0x1
JNZ 0x001bfe74
JMP 0x001bfeaa
LAB_001bfe74:
MOV byte ptr [RSP + 0x10f],0x0
MOV qword ptr [RSP + 0x100],0x0
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0x10f]
LEA RDX,[RSP + 0x100]
CALL 0x001b9ca0
JMP 0x001c031f
LAB_001bfeaa:
MOV RSI,qword ptr [RSP + 0x128]
LEA RDI,[RSP + 0xf0]
CALL 0x001bd2c0
MOV AL,0x1
TEST byte ptr [RSP + 0x127],0x1
MOV byte ptr [RSP + 0x3f],AL
JNZ 0x001bff12
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,RDI
SUB RAX,-0x80
MOV qword ptr [RSP + 0x30],RAX
ADD RDI,0x8
CALL 0x001b9280
MOV RDI,qword ptr [RSP + 0x30]
MOV ESI,EAX
LAB_001bfef0:
MOV EDX,0x5
LEA RCX,[RSP + 0xf0]
CALL 0x001b9220
MOV byte ptr [RSP + 0x3e],AL
JMP 0x001bff08
LAB_001bff08:
MOV AL,byte ptr [RSP + 0x3e]
MOV byte ptr [RSP + 0x3f],AL
JMP 0x001bff12
LAB_001bff12:
MOV AL,byte ptr [RSP + 0x3f]
AND AL,0x1
MOV byte ptr [RSP + 0xef],AL
TEST byte ptr [RSP + 0xef],0x1
JNZ 0x001bff92
MOV byte ptr [RSP + 0xdb],0x0
MOV qword ptr [RSP + 0xd0],0x0
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0xdb]
LEA RDX,[RSP + 0xd0]
CALL 0x001b9ca0
JMP 0x001bff5c
LAB_001bff5c:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001c0312
LAB_001bff92:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9cd0
TEST AL,0x1
JNZ 0x001bffa6
JMP 0x001c0023
LAB_001bffa6:
LEA RDI,[RSP + 0xb8]
MOV qword ptr [RSP + 0x28],RDI
LEA RSI,[RSP + 0xf0]
CALL 0x0019f8d0
MOV RSI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x40]
MOV RDI,qword ptr [RAX]
CALL 0x001b3e10
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0016e0f0
MOV RAX,qword ptr [RSP + 0x40]
MOV byte ptr [RSP + 0xb7],0x1
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0xa8],RAX
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0xb7]
LEA RDX,[RSP + 0xa8]
CALL 0x001b9d20
JMP 0x001c0013
LAB_001c0013:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001c0312
LAB_001c0023:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9880
CMP qword ptr [RAX],0x0
JNZ 0x001c007a
MOV byte ptr [RSP + 0xa7],0x0
MOV qword ptr [RSP + 0x98],0x0
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0xa7]
LEA RDX,[RSP + 0x98]
CALL 0x001b9ca0
JMP 0x001c006a
LAB_001c006a:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001c0312
LAB_001c007a:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RAX]
CALL 0x001a2c40
MOV CL,AL
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0x27],AL
JNZ 0x001c00b7
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RAX]
CALL 0x001a2c80
MOV byte ptr [RSP + 0x27],AL
LAB_001c00b7:
MOV AL,byte ptr [RSP + 0x27]
TEST AL,0x1
JNZ 0x001c00c1
JMP 0x001c00c3
LAB_001c00c1:
JMP 0x001c00e2
LAB_001c00c3:
LEA RDI,[0x2ced4a]
LEA RSI,[0x2cc91c]
MOV EDX,0x1c4b
LEA RCX,[0x2cfa5f]
CALL 0x00150230
LAB_001c00e2:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RAX]
CALL 0x001a2c40
TEST AL,0x1
JNZ 0x001c00fe
JMP 0x001c017b
LAB_001c00fe:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9880
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0xf0]
CALL 0x001a36d0
JMP 0x001c0122
LAB_001c0122:
MOV RDI,qword ptr [RSP + 0x40]
MOV byte ptr [RSP + 0x97],0x1
ADD RDI,0x8
CALL 0x001b9880
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001a2be0
MOV qword ptr [RSP + 0x88],RAX
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0x97]
LEA RDX,[RSP + 0x88]
CALL 0x001b9d20
JMP 0x001c016b
LAB_001c016b:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001c0312
LAB_001c017b:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RAX]
CALL 0x001a2c80
TEST AL,0x1
JNZ 0x001c0197
JMP 0x001c0199
LAB_001c0197:
JMP 0x001c01b8
LAB_001c0199:
LEA RDI,[0x2ced6a]
LEA RSI,[0x2cc91c]
MOV EDX,0x1c55
LEA RCX,[0x2cfa5f]
CALL 0x00150230
LAB_001c01b8:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x48
CALL 0x001b9100
XOR AL,0xff
TEST AL,0x1
JNZ 0x001c01ce
JMP 0x001c01d0
LAB_001c01ce:
JMP 0x001c01ef
LAB_001c01d0:
LEA RDI,[0x2ced88]
LEA RSI,[0x2cc91c]
MOV EDX,0x1c57
LEA RCX,[0x2cfa5f]
CALL 0x00150230
LAB_001c01ef:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x48
CALL 0x001b9180
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001c0209
LAB_001c0209:
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x70],RCX
MOV qword ptr [RSP + 0x78],RAX
LEA RDI,[RSP + 0x70]
CALL 0x001b72c0
MOV RDI,qword ptr [RSP + 0x40]
MOV byte ptr [RSP + 0x87],AL
ADD RDI,0x48
CALL 0x001b9200
JMP 0x001c023e
LAB_001c023e:
TEST byte ptr [RSP + 0x87],0x1
JNZ 0x001c027f
MOV byte ptr [RSP + 0x6f],0x0
MOV qword ptr [RSP + 0x60],0x0
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0x6f]
LEA RDX,[RSP + 0x60]
CALL 0x001b9ca0
JMP 0x001c026f
LAB_001c026f:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001c0312
LAB_001c027f:
MOV RAX,qword ptr [RSP + 0x40]
CMP qword ptr [RAX + 0x70],0x0
JZ 0x001c028d
JMP 0x001c02ac
LAB_001c028d:
LEA RDI,[0x2ceda0]
LEA RSI,[0x2cc91c]
MOV EDX,0x1c60
LEA RCX,[0x2cfa5f]
CALL 0x00150230
LAB_001c02ac:
LEA RDI,[RSP + 0x50]
MOV qword ptr [RSP],RDI
LEA RSI,[RSP + 0xf0]
CALL 0x0019f8d0
MOV RAX,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP]
MOV RCX,RAX
ADD RCX,0x70
MOV qword ptr [RSP + 0x8],RCX
MOV RDI,qword ptr [RAX + 0x70]
CALL 0x001b3e10
MOV RDI,qword ptr [RSP]
CALL 0x0016e0f0
MOV RDX,qword ptr [RSP + 0x8]
MOV byte ptr [RSP + 0x4f],0x1
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0x4f]
CALL 0x001b9d50
LAB_001c0305:
JMP 0x001c0307
LAB_001c0307:
MOV dword ptr [RSP + 0xcc],0x1
LAB_001c0312:
LEA RDI,[RSP + 0xf0]
CALL 0x0016e0f0
LAB_001c031f:
MOV AL,byte ptr [RSP + 0x138]
MOV RDX,qword ptr [RSP + 0x140]
ADD RSP,0x148
RET
|
/* std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*>
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::handle_value<std::__cxx11::string&>(std::__cxx11::string&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::handle_value<std::__cxx11::string&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,string *param_1,bool param_2)
{
byte bVar1;
bool bVar2;
int4 uVar3;
ulong uVar4;
long *plVar5;
int8 *puVar6;
int8 uVar7;
int1 auVar8 [16];
byte local_121;
byte local_109;
int1 local_f9;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_f8 [16];
int8 local_e8;
int1 local_d9;
int1 local_d8 [16];
byte local_c1;
int8 local_c0;
int1 local_b1;
int8 local_b0;
int1 local_a1;
int8 local_a0;
int1 local_91;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_90 [20];
int4 local_7c;
int8 local_78;
int1 local_6d [20];
byte local_59;
basic_json local_58 [16];
int8 local_48;
int1 local_39;
_Bit_reference local_38 [23];
byte local_21;
string *local_20;
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>>
*local_18;
int1 local_10 [8];
int8 local_8;
local_21 = param_2;
local_20 = param_1;
local_18 = this;
bVar1 = std::vector<bool,std::allocator<bool>>::empty
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if (((bVar1 ^ 0xff) & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
0x1c28,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = std::basic_string<char> &]"
);
}
local_38._0_16_ =
std::vector<bool,std::allocator<bool>>::back
((vector<bool,std::allocator<bool>> *)(this + 0x20));
bVar2 = std::_Bit_reference::operator_cast_to_bool(local_38);
if (((bVar2 ^ 0xffU) & 1) == 0) {
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_58,local_20);
local_109 = 1;
if ((local_21 & 1) == 0) {
uVar3 = 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>*>>
::size((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));
/* try { // try from 001bfef0 to 001c0304 has its CatchHandler @ 001bff6c */
local_109 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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()((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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 + 0x80),uVar3,5,local_58);
}
local_59 = local_109 & 1;
if (local_59 == 0) {
local_6d[0] = 0;
local_78 = 0;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_10,local_6d,&local_78);
}
else {
uVar4 = 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>*>>
::empty((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));
if ((uVar4 & 1) == 0) {
plVar5 = (long *)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>*>>
::back((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));
if (*plVar5 == 0) {
local_a1 = 0;
local_b0 = 0;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_10,&local_a1,&local_b0);
}
else {
puVar6 = (int8 *)
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>*>>
::back((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));
bVar1 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::is_array((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar6);
local_121 = 1;
if ((bVar1 & 1) == 0) {
puVar6 = (int8 *)
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>*>>
::back((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));
local_121 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::is_object((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar6);
}
if ((local_121 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c4b,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = std::basic_string<char> &]"
);
}
puVar6 = (int8 *)
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>*>>
::back((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));
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>
::is_array((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar6);
if ((uVar4 & 1) == 0) {
puVar6 = (int8 *)
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>*>>
::back((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));
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>
::is_object((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar6);
if ((uVar4 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c55,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = std::basic_string<char> &]"
);
}
bVar1 = std::vector<bool,std::allocator<bool>>::empty
((vector<bool,std::allocator<bool>> *)(this + 0x48));
if (((bVar1 ^ 0xff) & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c57,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = std::basic_string<char> &]"
);
}
local_d8 = std::vector<bool,std::allocator<bool>>::back
((vector<bool,std::allocator<bool>> *)(this + 0x48));
local_c1 = std::_Bit_reference::operator_cast_to_bool((_Bit_reference *)local_d8);
std::vector<bool,std::allocator<bool>>::pop_back
((vector<bool,std::allocator<bool>> *)(this + 0x48));
if ((local_c1 & 1) == 0) {
local_d9 = 0;
local_e8 = 0;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_10,&local_d9,&local_e8);
}
else {
if (*(long *)(this + 0x70) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("object_element",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c60,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = std::basic_string<char> &]"
);
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_f8,local_58);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(this + 0x70),local_f8);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_f8);
local_f9 = 1;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbRSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISK_SL_EEEbE4typeELb1EEEOSK_OSL_
(local_10,&local_f9,this + 0x70);
}
}
else {
plVar5 = (long *)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>*>>
::back((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>>
(*(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>>>
**)(*plVar5 + 8),local_58);
local_b1 = 1;
plVar5 = (long *)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>*>>
::back((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));
local_c0 = 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>>>
::back(*(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>>>
**)(*plVar5 + 8));
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_10,&local_b1,&local_c0);
}
}
}
else {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_90,local_58);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)this,local_90);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_90);
local_91 = 1;
local_a0 = *(int8 *)this;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_10,&local_91,&local_a0);
}
}
local_7c = 1;
uVar7 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)local_58);
}
else {
local_39 = 0;
local_48 = 0;
uVar7 = _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_10,&local_39,&local_48);
}
auVar8._1_7_ = (int7)((ulong)uVar7 >> 8);
auVar8[0] = local_10[0];
auVar8._8_8_ = local_8;
return auVar8;
}
|
|
17,259
|
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool)
|
monkey531[P]llama/common/./json.hpp
|
std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
}
|
O1
|
cpp
|
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x4d0a2
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
leaq (%rax,%rcx,8), %rax
leaq 0x3f(%r15), %rcx
andq %rdx, %rcx
xorl %edi, %edi
cmpq %r15, %rcx
setbe %dil
movq -0x8(%rax,%rdi,8), %rax
btq %rdx, %rax
jae 0x4cf35
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq (%rsi), %rsi
movq %r14, %rdi
callq 0x40218
movq %r14, %rdi
movl $0x1, %esi
callq 0x3efdc
testb %bpl, %bpl
jne 0x4cee2
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x4d0c1
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x4d076
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x4cf3f
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x4d076
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x4cf99
cmpl $0x2, %ecx
jne 0x4d0c6
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x40686
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x4d072
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x4d092
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x3efdc
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x487f0
movq %r15, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r15, %rdi
callq 0x4bfb8
movq (%rbx), %r14
jmp 0x4d072
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %ecx
cmpq %rax, 0x48(%rbx)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x4d0e5
movl %ecx, %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r15), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r15, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0x4d00b
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x4d076
cmpq $0x0, 0x70(%rbx)
je 0x4d104
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x3efdc
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x487f0
movq %r15, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r15, %rdi
callq 0x4bfb8
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x4d07b
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r15, %rdi
callq 0x4bfb8
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x700a4(%rip), %rdi # 0xbd14d
leaq 0x6dd7e(%rip), %rsi # 0xbae2e
leaq 0x70b3b(%rip), %rcx # 0xbdbf2
movl $0x1c28, %edx # imm = 0x1C28
callq 0x18470
callq 0x18260
leaq 0x70196(%rip), %rdi # 0xbd263
leaq 0x6dd5a(%rip), %rsi # 0xbae2e
leaq 0x70b17(%rip), %rcx # 0xbdbf2
movl $0x1c4b, %edx # imm = 0x1C4B
callq 0x18470
leaq 0x701b5(%rip), %rdi # 0xbd2a1
leaq 0x6dd3b(%rip), %rsi # 0xbae2e
leaq 0x70af8(%rip), %rcx # 0xbdbf2
movl $0x1c57, %edx # imm = 0x1C57
callq 0x18470
leaq 0x701ae(%rip), %rdi # 0xbd2b9
leaq 0x6dd1c(%rip), %rsi # 0xbae2e
leaq 0x70ad9(%rip), %rcx # 0xbdbf2
movl $0x1c60, %edx # imm = 0x1C60
callq 0x18470
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r14, %rdi
callq 0x4bfb8
movq %rbx, %rdi
callq 0x18b90
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIRlEESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov ebp, edx
mov rbx, rdi
mov rax, [rdi+30h]
mov ecx, [rdi+38h]
cmp [rdi+20h], rax
setz dl
test ecx, ecx
setz dil
and dil, dl
cmp dil, 1
jz loc_4D0A2
mov ecx, ecx
mov r15, 8000000000000000h
lea rdx, [rcx-1]
add rcx, 3Eh ; '>'
test rdx, rdx
cmovns rcx, rdx
sar rcx, 6
lea rax, [rax+rcx*8]
lea rcx, [r15+3Fh]
and rcx, rdx
xor edi, edi
cmp rcx, r15
setbe dil
mov rax, [rax+rdi*8-8]
bt rax, rdx
jnb loc_4CF35
xorps xmm0, xmm0
lea r14, [rsp+68h+var_58]
movaps xmmword ptr [r14], xmm0
mov rsi, [rsi]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE5EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_16number_integer_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_integer_t)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
test bpl, bpl
jnz short loc_4CEE2
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+68h+var_5C], eax
mov [rsp+68h+var_5D], 5
cmp qword ptr [rbx+90h], 0
jz loc_4D0C1
lea rdi, [rbx+80h]
lea rsi, [rsp+68h+var_5C]
lea rdx, [rsp+68h+var_5D]
lea rcx, [rsp+68h+var_58]
call qword ptr [rbx+98h]
test al, al
jz loc_4D076
loc_4CEE2:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_4CF3F
mov rax, [rax-8]
test rax, rax
jz loc_4D076
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_4CF99
cmp ecx, 2
jnz loc_4D0C6
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_4D072
loc_4CF35:
xor ebx, ebx
xor r14d, r14d
jmp loc_4D092
loc_4CF3F:
lea r14, [rsp+68h+var_58]
movaps xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_38]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx]
jmp loc_4D072
loc_4CF99:
mov rax, [rbx+58h]
mov ecx, [rbx+60h]
cmp [rbx+48h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_4D0E5
mov esi, ecx
lea rcx, [rsi-1]
mov rdx, rsi
add rdx, 3Eh ; '>'
test rcx, rcx
cmovns rdx, rcx
sar rdx, 6
lea rdi, [rax+rdx*8]
lea rdx, [r15+3Fh]
and rdx, rcx
xor r8d, r8d
cmp rdx, r15
setbe r8b
mov edx, 1
shl rdx, cl
and rdx, [rdi+r8*8-8]
sub esi, 1
mov [rbx+60h], esi
jnb short loc_4D00B
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_4D00B:
test rdx, rdx
jz short loc_4D076
cmp qword ptr [rbx+70h], 0
jz loc_4D104
lea r14, [rsp+68h+var_58]
movaps xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_48]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx+70h]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx+70h]
loc_4D072:
mov bl, 1
jmp short loc_4D07B
loc_4D076:
xor ebx, ebx
xor r14d, r14d
loc_4D07B:
lea r15, [rsp+68h+var_58]
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_4D092:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_4D0A2:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_3; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C28h
call ___assert_fail
loc_4D0C1:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_4D0C6:
lea rdi, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_3; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C4Bh
call ___assert_fail
loc_4D0E5:
lea rdi, aKeyKeepStackEm; "!key_keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_3; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C57h
call ___assert_fail
loc_4D104:
lea rdi, aObjectElement; "object_element"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_3; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C60h
call ___assert_fail
mov rbx, rax
lea r14, [rsp+68h+var_58]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::handle_value<long &>(
long long a1,
_QWORD *a2,
char a3)
{
unsigned int v4; // ebx
long long v5; // rax
unsigned int v6; // ecx
signed long long v7; // rdx
long long v8; // rcx
long long v9; // rax
long long v10; // rax
unsigned __int8 *v11; // rax
int v12; // ecx
long long v13; // rax
unsigned int v14; // ecx
long long v15; // rsi
long long v16; // rcx
long long v17; // rdx
long long v18; // rdx
char v20; // [rsp+Bh] [rbp-5Dh] BYREF
int v21; // [rsp+Ch] [rbp-5Ch] BYREF
__int128 v22; // [rsp+10h] [rbp-58h] BYREF
__int128 v23; // [rsp+20h] [rbp-48h] BYREF
_OWORD v24[3]; // [rsp+30h] [rbp-38h] BYREF
v4 = a1;
v5 = *(_QWORD *)(a1 + 48);
v6 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v5 && v6 == 0 )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7208LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ord"
"ered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = long &]");
v7 = v6 - 1LL;
v8 = v6 + 62LL;
if ( v7 >= 0 )
v8 = v7;
v9 = *(_QWORD *)(v5 + 8 * (v8 >> 6) + 8LL * ((v7 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8);
if ( _bittest64(&v9, v7) )
{
v22 = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
&v22,
*a2);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v22);
if ( a3 )
goto LABEL_8;
v21 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v20 = 5;
if ( !*(_QWORD *)(a1 + 144) )
std::__throw_bad_function_call();
if ( (*(unsigned __int8 ( **)(long long, int *, char *, __int128 *))(a1 + 152))(a1 + 128, &v21, &v20, &v22) )
{
LABEL_8:
v10 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v10 )
{
v24[0] = v22;
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 *)&v22);
LOBYTE(v22) = 0;
*((_QWORD *)&v22 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v24);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)a1,
(long long)v24);
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 *)v24);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void **)v24);
LABEL_23:
LOBYTE(v4) = 1;
LABEL_25:
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v22);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void **)&v22);
return v4;
}
v11 = *(unsigned __int8 **)(v10 - 8);
if ( v11 )
{
v12 = *v11;
if ( v12 != 1 )
{
if ( v12 != 2 )
__assert_fail(
"ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7243LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohm"
"ann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ord"
"ered_map>, Value = long &]");
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*((_QWORD *)v11 + 1),
(long long)&v22);
goto LABEL_23;
}
v13 = *(_QWORD *)(a1 + 88);
v14 = *(_DWORD *)(a1 + 96);
if ( *(_QWORD *)(a1 + 72) == v13 && v14 == 0 )
__assert_fail(
"!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7255LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohman"
"n::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered"
"_map>, Value = long &]");
v15 = v14;
v16 = v14 - 1LL;
v17 = v15 + 62;
if ( v16 >= 0 )
v17 = v16;
v18 = *(_QWORD *)(v13 + 8 * (v17 >> 6) + 8LL * ((v16 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8) & (1LL << v16);
*(_DWORD *)(a1 + 96) = v15 - 1;
if ( !(_DWORD)v15 )
{
*(_DWORD *)(a1 + 96) = 63;
*(_QWORD *)(a1 + 88) = v13 - 8;
}
if ( v18 )
{
if ( !*(_QWORD *)(a1 + 112) )
__assert_fail(
"object_element",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7264LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohm"
"ann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ord"
"ered_map>, Value = long &]");
v23 = v22;
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 *)&v22);
LOBYTE(v22) = 0;
*((_QWORD *)&v22 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v23);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(a1 + 112),
(long long)&v23);
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 *)&v23);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void **)&v23);
goto LABEL_23;
}
}
}
v4 = 0;
goto LABEL_25;
}
return 0;
}
|
handle_value<long&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV EBP,EDX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x30]
MOV ECX,dword ptr [RDI + 0x38]
CMP qword ptr [RDI + 0x20],RAX
SETZ DL
TEST ECX,ECX
SETZ DIL
AND DIL,DL
CMP DIL,0x1
JZ 0x0014d0a2
MOV ECX,ECX
MOV R15,-0x8000000000000000
LEA RDX,[RCX + -0x1]
ADD RCX,0x3e
TEST RDX,RDX
CMOVNS RCX,RDX
SAR RCX,0x6
LEA RAX,[RAX + RCX*0x8]
LEA RCX,[R15 + 0x3f]
AND RCX,RDX
XOR EDI,EDI
CMP RCX,R15
SETBE DIL
MOV RAX,qword ptr [RAX + RDI*0x8 + -0x8]
BT RAX,RDX
JNC 0x0014cf35
XORPS XMM0,XMM0
LEA R14,[RSP + 0x10]
MOVAPS xmmword ptr [R14],XMM0
MOV RSI,qword ptr [RSI]
MOV RDI,R14
CALL 0x00140218
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013efdc
TEST BPL,BPL
JNZ 0x0014cee2
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x5
CMP qword ptr [RBX + 0x90],0x0
JZ 0x0014d0c1
LEA RDI,[RBX + 0x80]
LAB_0014cec5:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x0014d076
LAB_0014cee2:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x0014cf3f
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x0014d076
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x0014cf99
CMP ECX,0x2
JNZ 0x0014d0c6
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x00140686
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x0014d072
LAB_0014cf35:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0014d092
LAB_0014cf3f:
LEA R14,[RSP + 0x10]
MOVAPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x30]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013efdc
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x0013efdc
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x001487f0
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013efdc
MOV RDI,R15
CALL 0x0014bfb8
MOV R14,qword ptr [RBX]
JMP 0x0014d072
LAB_0014cf99:
MOV RAX,qword ptr [RBX + 0x58]
MOV ECX,dword ptr [RBX + 0x60]
CMP qword ptr [RBX + 0x48],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x0014d0e5
MOV ESI,ECX
LEA RCX,[RSI + -0x1]
MOV RDX,RSI
ADD RDX,0x3e
TEST RCX,RCX
CMOVNS RDX,RCX
SAR RDX,0x6
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[R15 + 0x3f]
AND RDX,RCX
XOR R8D,R8D
CMP RDX,R15
SETBE R8B
MOV EDX,0x1
SHL RDX,CL
AND RDX,qword ptr [RDI + R8*0x8 + -0x8]
SUB ESI,0x1
MOV dword ptr [RBX + 0x60],ESI
JNC 0x0014d00b
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_0014d00b:
TEST RDX,RDX
JZ 0x0014d076
CMP qword ptr [RBX + 0x70],0x0
JZ 0x0014d104
LEA R14,[RSP + 0x10]
MOVAPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x20]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013efdc
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x0013efdc
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x001487f0
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013efdc
MOV RDI,R15
CALL 0x0014bfb8
MOV R14,qword ptr [RBX + 0x70]
LAB_0014d072:
MOV BL,0x1
JMP 0x0014d07b
LAB_0014d076:
XOR EBX,EBX
XOR R14D,R14D
LAB_0014d07b:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013efdc
MOV RDI,R15
CALL 0x0014bfb8
LAB_0014d092:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0014d0a2:
LEA RDI,[0x1bd14d]
LEA RSI,[0x1bae2e]
LEA RCX,[0x1bdbf2]
MOV EDX,0x1c28
CALL 0x00118470
LAB_0014d0c1:
CALL 0x00118260
LAB_0014d0c6:
LEA RDI,[0x1bd263]
LEA RSI,[0x1bae2e]
LEA RCX,[0x1bdbf2]
MOV EDX,0x1c4b
CALL 0x00118470
LAB_0014d0e5:
LEA RDI,[0x1bd2a1]
LEA RSI,[0x1bae2e]
LEA RCX,[0x1bdbf2]
MOV EDX,0x1c57
CALL 0x00118470
LAB_0014d104:
LEA RDI,[0x1bd2b9]
LEA RSI,[0x1bae2e]
LEA RCX,[0x1bdbf2]
MOV EDX,0x1c60
CALL 0x00118470
|
/* std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*>
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::handle_value<long&>(long&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::handle_value<long&>
(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,long *param_1,bool param_2)
{
uint uVar1;
char *pcVar2;
char cVar3;
ulong uVar4;
ulong uVar5;
bool bVar6;
long lVar7;
int1 auVar8 [16];
int1 local_5d;
int4 local_5c;
ulong local_58;
int8 uStack_50;
ulong local_48;
int8 uStack_40;
ulong local_38;
int8 uStack_30;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 == 0 && *(long *)(this + 0x20) == *(long *)(this + 0x30)) {
/* WARNING: Subroutine does not return */
__assert_fail("!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
0x1c28,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = long &]"
);
}
uVar5 = (ulong)uVar1 - 1;
uVar4 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar4 = uVar5;
}
if ((*(ulong *)(*(long *)(this + 0x30) + ((long)uVar4 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar5 & 0x3f) &
1) == 0) {
uVar5 = 0;
lVar7 = 0;
goto LAB_0014d092;
}
local_58 = 0;
uStack_50 = 0;
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(&local_58,*param_1);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
if (param_2) {
LAB_0014cee2:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
local_38 = local_58;
uStack_30 = uStack_50;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar6 = SUB81((data *)&local_38,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)this,(data *)&local_38);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_38);
lVar7 = *(long *)this;
}
else {
pcVar2 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar2 == (char *)0x0) goto LAB_0014d076;
if (*pcVar2 == '\x01') {
lVar7 = *(long *)(this + 0x58);
uVar1 = *(uint *)(this + 0x60);
if (uVar1 == 0 && *(long *)(this + 0x48) == lVar7) {
/* WARNING: Subroutine does not return */
__assert_fail("!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c57,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = long &]"
);
}
uVar5 = (ulong)uVar1 - 1;
uVar4 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar4 = uVar5;
}
uVar4 = *(ulong *)(lVar7 + ((long)uVar4 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar1 - 1;
if (uVar1 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = lVar7 + -8;
}
if ((1L << ((byte)uVar5 & 0x3f) & uVar4) == 0) goto LAB_0014d076;
if (*(long *)(this + 0x70) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("object_element",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c60,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = long &]"
);
}
local_48 = local_58;
uStack_40 = uStack_50;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar6 = SUB81((data *)&local_48,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(this + 0x70),(data *)&local_48);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_48);
lVar7 = *(long *)(this + 0x70);
}
else {
if (*pcVar2 != '\x02') {
/* WARNING: Subroutine does not return */
__assert_fail("ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c4b,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = long &]"
);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pcVar2 + 8),(basic_json *)&local_58);
lVar7 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar5 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
local_5c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_5d = 5;
if (*(long *)(this + 0x90) == 0) {
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
/* try { // try from 0014cec5 to 0014d0c5 has its CatchHandler @ 0014d123 */
cVar3 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,&local_58);
if (cVar3 != '\0') goto LAB_0014cee2;
LAB_0014d076:
uVar5 = 0;
lVar7 = 0;
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)&local_58,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_58);
LAB_0014d092:
auVar8._0_8_ = uVar5 & 0xffffffff;
auVar8._8_8_ = lVar7;
return auVar8;
}
|
|
17,260
|
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool)
|
monkey531[P]llama/common/./json.hpp
|
std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
}
|
O2
|
cpp
|
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq 0x30(%rdi), %rax
jne 0x45ec3
cmpl $0x0, 0x38(%rbx)
je 0x4601a
leaq 0x20(%rbx), %rdi
callq 0x442a8
testq %rdx, (%rax)
je 0x45f5d
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2b1d0
testb %bpl, %bpl
jne 0x45f0e
leaq 0x80(%rbx), %rdi
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
pushq $0x5
popq %rdx
leaq 0x8(%rsp), %rcx
callq 0x442d6
testb %al, %al
je 0x45ffb
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x45f67
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x45ffb
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x45f91
cmpl $0x2, %ecx
jne 0x46039
movq 0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3c71c
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x45ff7
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x4600a
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3b352
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x429ca
movq %r14, %rdi
callq 0x2b1f0
movq (%rbx), %r14
jmp 0x45ff7
movq 0x48(%rbx), %rax
cmpq 0x58(%rbx), %rax
jne 0x45fa5
cmpl $0x0, 0x60(%rbx)
je 0x46058
leaq 0x48(%rbx), %rdi
callq 0x442a8
movq %rdx, %r14
leaq 0x58(%rbx), %rdi
movq (%rax), %r15
callq 0x4393c
testq %r14, %r15
je 0x45ffb
cmpq $0x0, 0x70(%rbx)
je 0x46077
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3b352
movq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x429ca
movq %r14, %rdi
callq 0x2b1f0
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x46000
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
callq 0x2b1f0
movl %ebx, %eax
movq %r14, %rdx
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5612c(%rip), %rdi # 0x9c14d
leaq 0x53e06(%rip), %rsi # 0x99e2e
leaq 0x56adb(%rip), %rcx # 0x9cb0a
movl $0x1c28, %edx # imm = 0x1C28
callq 0x204a0
leaq 0x56223(%rip), %rdi # 0x9c263
leaq 0x53de7(%rip), %rsi # 0x99e2e
leaq 0x56abc(%rip), %rcx # 0x9cb0a
movl $0x1c4b, %edx # imm = 0x1C4B
callq 0x204a0
leaq 0x56242(%rip), %rdi # 0x9c2a1
leaq 0x53dc8(%rip), %rsi # 0x99e2e
leaq 0x56a9d(%rip), %rcx # 0x9cb0a
movl $0x1c57, %edx # imm = 0x1C57
callq 0x204a0
leaq 0x5623b(%rip), %rdi # 0x9c2b9
leaq 0x53da9(%rip), %rsi # 0x99e2e
leaq 0x56a7e(%rip), %rcx # 0x9cb0a
movl $0x1c60, %edx # imm = 0x1C60
callq 0x204a0
jmp 0x46098
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2b1f0
movq %rbx, %rdi
callq 0x20b90
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIDnEESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 38h
mov ebp, edx
mov rbx, rdi
mov rax, [rdi+20h]
cmp rax, [rdi+30h]
jnz short loc_45EC3
cmp dword ptr [rbx+38h], 0
jz loc_4601A
loc_45EC3:
lea rdi, [rbx+20h]
call _ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
test [rax], rdx
jz loc_45F5D
lea rdi, [rsp+58h+var_50]
xor esi, esi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; 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(decltype(nullptr))
test bpl, bpl
jnz short loc_45F0E
lea rdi, [rbx+80h]
mov rsi, [rbx+10h]
sub rsi, [rbx+8]
shr rsi, 3
push 5
pop rdx
lea rcx, [rsp+58h+var_50]
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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> &)
test al, al
jz loc_45FFB
loc_45F0E:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_45F67
mov rax, [rax-8]
test rax, rax
jz loc_45FFB
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz short loc_45F91
cmp ecx, 2
jnz loc_46039
mov rdi, [rax+8]
lea rsi, [rsp+58h+var_50]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_45FF7
loc_45F5D:
xor ebx, ebx
xor r14d, r14d
jmp loc_4600A
loc_45F67:
lea r14, [rsp+58h+var_30]
lea rsi, [rsp+58h+var_50]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; 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>&&)
mov rdi, [rbx]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov r14, [rbx]
jmp short loc_45FF7
loc_45F91:
mov rax, [rbx+48h]
cmp rax, [rbx+58h]
jnz short loc_45FA5
cmp dword ptr [rbx+60h], 0
jz loc_46058
loc_45FA5:
lea rdi, [rbx+48h]
call _ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
mov r14, rdx
lea rdi, [rbx+58h]; this
mov r15, [rax]
call _ZNSt18_Bit_iterator_base12_M_bump_downEv; std::_Bit_iterator_base::_M_bump_down(void)
test r15, r14
jz short loc_45FFB
cmp qword ptr [rbx+70h], 0
jz loc_46077
lea r14, [rsp+58h+var_40]
lea rsi, [rsp+58h+var_50]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; 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>&&)
mov rdi, [rbx+70h]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov r14, [rbx+70h]
loc_45FF7:
mov bl, 1
jmp short loc_46000
loc_45FFB:
xor ebx, ebx
xor r14d, r14d
loc_46000:
lea rdi, [rsp+58h+var_50]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_4600A:
mov eax, ebx
mov rdx, r14
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_4601A:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_2; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C28h
call ___assert_fail
loc_46039:
lea rdi, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_2; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C4Bh
call ___assert_fail
loc_46058:
lea rdi, aKeyKeepStackEm; "!key_keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_2; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C57h
call ___assert_fail
loc_46077:
lea rdi, aObjectElement; "object_element"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_2; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C60h
call ___assert_fail
jmp short $+2
loc_46098:
mov rbx, rax
lea rdi, [rsp+58h+var_50]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rdi, rbx
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::handle_value<decltype(nullptr)>(
long long a1,
long long a2,
char a3)
{
unsigned int v4; // ebx
_QWORD *v5; // rax
long long v6; // rdx
long long v7; // rax
unsigned __int8 *v8; // rax
int v9; // ecx
long long *v10; // rax
long long v11; // rdx
long long v12; // r14
long long v13; // r15
_BYTE v15[16]; // [rsp+8h] [rbp-50h] BYREF
__int128 v16; // [rsp+18h] [rbp-40h] BYREF
_OWORD v17[3]; // [rsp+28h] [rbp-30h] BYREF
v4 = a1;
if ( *(_QWORD *)(a1 + 32) == *(_QWORD *)(a1 + 48) && !*(_DWORD *)(a1 + 56) )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7208LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ord"
"ered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value"
" = std::nullptr_t]");
v5 = (_QWORD *)std::vector<bool>::back(a1 + 32);
if ( (v6 & *v5) != 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>::basic_json((long long)v15);
if ( a3
|| (unsigned __int8)std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()(
a1 + 128,
(*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3,
5) )
{
v7 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v7 )
{
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(
v17,
(long long)v15);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)a1,
(long long)v17);
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)v17);
LABEL_18:
LOBYTE(v4) = 1;
LABEL_20:
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)v15);
return v4;
}
v8 = *(unsigned __int8 **)(v7 - 8);
if ( v8 )
{
v9 = *v8;
if ( v9 != 1 )
{
if ( v9 != 2 )
__assert_fail(
"ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7243LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohm"
"ann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ord"
"ered_map>, Value = std::nullptr_t]");
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*((_QWORD *)v8 + 1),
(long long)v15);
goto LABEL_18;
}
if ( *(_QWORD *)(a1 + 72) == *(_QWORD *)(a1 + 88) && !*(_DWORD *)(a1 + 96) )
__assert_fail(
"!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7255LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohman"
"n::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered"
"_map>, Value = std::nullptr_t]");
v10 = (long long *)std::vector<bool>::back(a1 + 72);
v12 = v11;
v13 = *v10;
std::_Bit_iterator_base::_M_bump_down((std::_Bit_iterator_base *)(a1 + 88));
if ( (v12 & v13) != 0 )
{
if ( !*(_QWORD *)(a1 + 112) )
__assert_fail(
"object_element",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7264LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohm"
"ann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ord"
"ered_map>, Value = std::nullptr_t]");
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(
&v16,
(long long)v15);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(a1 + 112),
(long long)&v16);
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)&v16);
goto LABEL_18;
}
}
}
v4 = 0;
goto LABEL_20;
}
return 0;
}
| |||
17,261
|
js_global_decodeURI
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_global_decodeURI(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int isComponent)
{
JSValue str;
StringBuffer b_s, *b = &b_s;
JSString *p;
int k, c, c1, n, c_min;
str = JS_ToString(ctx, argv[0]);
if (JS_IsException(str))
return str;
string_buffer_init(ctx, b, 0);
p = JS_VALUE_GET_STRING(str);
for (k = 0; k < p->len;) {
c = string_get(p, k);
if (c == '%') {
c = hex_decode(ctx, p, k);
if (c < 0)
goto fail;
k += 3;
if (c < 0x80) {
if (!isComponent && isURIReserved(c)) {
c = '%';
k -= 2;
}
} else {
/* Decode URI-encoded UTF-8 sequence */
if (c >= 0xc0 && c <= 0xdf) {
n = 1;
c_min = 0x80;
c &= 0x1f;
} else if (c >= 0xe0 && c <= 0xef) {
n = 2;
c_min = 0x800;
c &= 0xf;
} else if (c >= 0xf0 && c <= 0xf7) {
n = 3;
c_min = 0x10000;
c &= 0x7;
} else {
n = 0;
c_min = 1;
c = 0;
}
while (n-- > 0) {
c1 = hex_decode(ctx, p, k);
if (c1 < 0)
goto fail;
k += 3;
if ((c1 & 0xc0) != 0x80) {
c = 0;
break;
}
c = (c << 6) | (c1 & 0x3f);
}
if (c < c_min || c > 0x10FFFF || is_surrogate(c)) {
js_throw_URIError(ctx, "malformed UTF-8");
goto fail;
}
}
} else {
k++;
}
string_buffer_putc(b, c);
}
JS_FreeValue(ctx, str);
return string_buffer_end(b);
fail:
JS_FreeValue(ctx, str);
string_buffer_free(b);
return JS_EXCEPTION;
}
|
O1
|
c
|
js_global_decodeURI:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, 0x1c(%rsp)
movq %rdi, %rbx
movq (%r8), %rsi
movq 0x8(%r8), %rdx
xorl %ecx, %ecx
callq 0x27add
movq %rax, 0x10(%rsp)
cmpl $0x6, %edx
je 0x79725
movq %rdx, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rsp)
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x20b73
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x79734
movq 0x10(%rsp), %r15
movq 0x4(%r15), %rax
testl $0x7fffffff, %eax # imm = 0x7FFFFFFF
je 0x796b7
xorl %ebp, %ebp
leaq 0x28(%rsp), %r14
movslq %ebp, %rcx
testl %eax, %eax
js 0x79541
movzbl 0x18(%r15,%rcx), %r12d
jmp 0x79547
movzwl 0x18(%r15,%rcx,2), %r12d
cmpl $0x25, %r12d
jne 0x795a3
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x79d0d
testl %eax, %eax
js 0x796ee
movl %eax, %r12d
leal 0x3(%rbp), %r13d
cmpl $0x7f, %eax
jg 0x795ad
cmpl $0x0, 0x1c(%rsp)
jne 0x7967e
movl $0xb, %edx
leaq 0x2890d(%rip), %rdi # 0xa1e94
movl %r12d, %esi
callq 0xe440
incl %ebp
testq %rax, %rax
movl $0x25, %eax
cmovnel %eax, %r12d
cmovel %r13d, %ebp
jmp 0x795a5
incl %ebp
movl %ebp, %r13d
jmp 0x7967e
movl %r12d, %eax
andl $0x7fffffe0, %eax # imm = 0x7FFFFFE0
cmpl $0xc0, %eax
jne 0x795c9
andl $0x1f, %r12d
movl $0x80, %ecx
xorl %ebx, %ebx
jmp 0x79609
movl %r12d, %eax
andl $0x7ffffff0, %eax # imm = 0x7FFFFFF0
cmpl $0xe0, %eax
jne 0x795e8
andl $0xf, %r12d
movl $0x800, %ecx # imm = 0x800
movl $0x1, %ebx
jmp 0x79609
movl %r12d, %eax
andl $0x7ffffff8, %eax # imm = 0x7FFFFFF8
cmpl $0xf0, %eax
jne 0x796a3
andl $0x7, %r12d
movl $0x10000, %ecx # imm = 0x10000
movl $0x2, %ebx
movb $0x1, %al
testb %al, %al
je 0x79661
movl %ecx, 0x18(%rsp)
incl %ebx
movl %r13d, %ebp
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x79d0d
testl %eax, %eax
js 0x796ee
movl %eax, %ecx
andl $0xc0, %ecx
cmpl $0x80, %ecx
jne 0x79654
shll $0x6, %r12d
andl $0x3f, %eax
orl %eax, %r12d
leal 0x3(%rbp), %r13d
decl %ebx
jg 0x79615
jmp 0x79657
xorl %r12d, %r12d
addl $0x3, %ebp
movl %ebp, %r13d
movl 0x18(%rsp), %ecx
cmpl %ecx, %r12d
jl 0x796db
cmpl $0x10ffff, %r12d # imm = 0x10FFFF
jg 0x796db
movl %r12d, %eax
andl $0xfffff800, %eax # imm = 0xFFFFF800
cmpl $0xd800, %eax # imm = 0xD800
je 0x796db
movq %r14, %rdi
movl %r12d, %esi
callq 0x333f0
movq 0x4(%r15), %rax
movl %eax, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
movl %r13d, %ebp
cmpl %ecx, %r13d
jl 0x79532
jmp 0x796b7
movl $0x1, %ecx
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
xorl %r12d, %r12d
xorl %eax, %eax
jmp 0x7960b
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rdx
callq 0x1d8c6
leaq 0x28(%rsp), %rdi
callq 0x33444
jmp 0x79725
leaq 0x28781(%rip), %rsi # 0xa1e63
movq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x79d7f
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rdx
callq 0x1d8c6
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1cb99
movq $0x0, 0x30(%rsp)
movl $0x6, %edx
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0x3c(%rsp)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x79517
|
js_global_decodeURI:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rsp+78h+var_5C], r9d
mov rbx, rdi
mov rsi, [r8]
mov rdx, [r8+8]
xor ecx, ecx
call JS_ToStringInternal
mov [rsp+78h+var_68], rax
cmp edx, 6
jz loc_79725
mov [rsp+78h+var_58], rdx
mov [rsp+78h+var_50], rbx
xorps xmm0, xmm0
movups [rsp+78h+var_40], xmm0
mov [rsp+78h+var_70], rbx
mov rdi, rbx
xor esi, esi
xor edx, edx
call js_alloc_string
mov [rsp+78h+var_48], rax
test rax, rax
jz loc_79734
loc_79517:
mov r15, [rsp+78h+var_68]
mov rax, [r15+4]
test eax, 7FFFFFFFh
jz loc_796B7
xor ebp, ebp
lea r14, [rsp+78h+var_50]
loc_79532:
movsxd rcx, ebp
test eax, eax
js short loc_79541
movzx r12d, byte ptr [r15+rcx+18h]
jmp short loc_79547
loc_79541:
movzx r12d, word ptr [r15+rcx*2+18h]
loc_79547:
cmp r12d, 25h ; '%'
jnz short loc_795A3
mov rdi, [rsp+78h+var_70]
mov rsi, r15
mov edx, ebp
call hex_decode
test eax, eax
js loc_796EE
mov r12d, eax
lea r13d, [rbp+3]
cmp eax, 7Fh
jg short loc_795AD
cmp [rsp+78h+var_5C], 0
jnz loc_7967E
mov edx, 0Bh
lea rdi, asc_A1E94; ";/?:@&=+$,#"
mov esi, r12d
call _memchr
inc ebp
test rax, rax
mov eax, 25h ; '%'
cmovnz r12d, eax
cmovz ebp, r13d
jmp short loc_795A5
loc_795A3:
inc ebp
loc_795A5:
mov r13d, ebp
jmp loc_7967E
loc_795AD:
mov eax, r12d
and eax, 7FFFFFE0h
cmp eax, 0C0h
jnz short loc_795C9
and r12d, 1Fh
mov ecx, 80h
xor ebx, ebx
jmp short loc_79609
loc_795C9:
mov eax, r12d
and eax, 7FFFFFF0h
cmp eax, 0E0h
jnz short loc_795E8
and r12d, 0Fh
mov ecx, 800h
mov ebx, 1
jmp short loc_79609
loc_795E8:
mov eax, r12d
and eax, 7FFFFFF8h
cmp eax, 0F0h
jnz loc_796A3
and r12d, 7
mov ecx, 10000h
mov ebx, 2
loc_79609:
mov al, 1
loc_7960B:
test al, al
jz short loc_79661
mov [rsp+78h+var_60], ecx
inc ebx
loc_79615:
mov ebp, r13d
mov rdi, [rsp+78h+var_70]
mov rsi, r15
mov edx, r13d
call hex_decode
test eax, eax
js loc_796EE
mov ecx, eax
and ecx, 0C0h
cmp ecx, 80h
jnz short loc_79654
shl r12d, 6
and eax, 3Fh
or r12d, eax
lea r13d, [rbp+3]
dec ebx
jg short loc_79615
jmp short loc_79657
loc_79654:
xor r12d, r12d
loc_79657:
add ebp, 3
mov r13d, ebp
mov ecx, [rsp+78h+var_60]
loc_79661:
cmp r12d, ecx
jl short loc_796DB
cmp r12d, 10FFFFh
jg short loc_796DB
mov eax, r12d
and eax, 0FFFFF800h
cmp eax, 0D800h
jz short loc_796DB
loc_7967E:
mov rdi, r14
mov esi, r12d
call string_buffer_putc
mov rax, [r15+4]
mov ecx, eax
and ecx, 7FFFFFFFh
mov ebp, r13d
cmp r13d, ecx
jl loc_79532
jmp short loc_796B7
loc_796A3:
mov ecx, 1
mov ebx, 0FFFFFFFFh
xor r12d, r12d
xor eax, eax
jmp loc_7960B
loc_796B7:
mov rsi, [rsp+78h+var_68]
mov rax, [rsp+78h+var_70]
mov rdi, [rax+18h]
mov rdx, [rsp+78h+var_58]
call JS_FreeValueRT
lea rdi, [rsp+78h+var_50]
call string_buffer_end
jmp short loc_79725
loc_796DB:
lea rsi, aMalformedUtf8; "malformed UTF-8"
mov rdi, [rsp+78h+var_70]
xor eax, eax
call js_throw_URIError
loc_796EE:
mov rsi, [rsp+78h+var_68]
mov rax, [rsp+78h+var_70]
mov rdi, [rax+18h]
mov rdx, [rsp+78h+var_58]
call JS_FreeValueRT
mov rdi, [rsp+78h+var_50]
mov rsi, [rsp+78h+var_48]
call js_free
mov [rsp+78h+var_48], 0
mov edx, 6
xor eax, eax
loc_79725:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_79734:
mov dword ptr [rsp+78h+var_40+4], 0
mov dword ptr [rsp+78h+var_40+0Ch], 0FFFFFFFFh
jmp loc_79517
|
_DWORD * js_global_decodeURI(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long *a13,
long long a14)
{
_DWORD *result; // rax
long long v15; // rdx
long long v16; // rax
int v17; // ebp
signed int v18; // r12d
int v19; // eax
int v20; // edx
int v21; // r8d
int v22; // r9d
int v23; // r13d
int v24; // ebp
long long v25; // rcx
int v26; // ebx
char v27; // al
int v28; // ebx
int v29; // ebp
int v30; // eax
_DWORD *v32; // [rsp+10h] [rbp-68h]
int v33; // [rsp+18h] [rbp-60h]
int v34; // [rsp+1Ch] [rbp-5Ch]
long long v35; // [rsp+20h] [rbp-58h]
long long v36; // [rsp+28h] [rbp-50h] BYREF
long long v37; // [rsp+30h] [rbp-48h]
__int128 v38; // [rsp+38h] [rbp-40h]
v34 = a14;
result = (_DWORD *)JS_ToStringInternal(a1, *a13, a13[1], 0, (long long)a13, a14, a2, a3, a4, a5, a6, a7, a8, a9);
v32 = result;
if ( (_DWORD)v15 == 6 )
return result;
v35 = v15;
v36 = a1;
v38 = 0LL;
v37 = js_alloc_string(a1, 0LL, 0);
if ( !v37 )
{
DWORD1(v38) = 0;
HIDWORD(v38) = -1;
}
v16 = *(_QWORD *)(v32 + 1);
if ( (v16 & 0x7FFFFFFF) == 0 )
{
LABEL_39:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v32, v35);
return string_buffer_end((long long)&v36);
}
v17 = 0;
while ( 1 )
{
if ( (int)v16 < 0 )
v18 = *((unsigned __int16 *)v32 + v17 + 12);
else
v18 = *((unsigned __int8 *)v32 + v17 + 24);
if ( v18 != 37 )
{
v24 = v17 + 1;
LABEL_17:
v23 = v24;
goto LABEL_36;
}
v19 = hex_decode(a1, v32, (unsigned int)v17, v17);
if ( v19 < 0 )
goto LABEL_41;
v18 = v19;
v23 = v17 + 3;
if ( v19 > 127 )
break;
if ( !v34 )
{
v24 = v17 + 1;
if ( memchr(";/?:@&=+$,#", (unsigned int)v19, 11LL) )
v18 = 37;
else
v24 = v23;
goto LABEL_17;
}
LABEL_36:
string_buffer_putc((long long)&v36, v18);
v16 = *(_QWORD *)(v32 + 1);
v17 = v23;
if ( v23 >= (v32[1] & 0x7FFFFFFF) )
goto LABEL_39;
}
if ( (v19 & 0x7FFFFFE0) == 0xC0 )
{
v18 = v19 & 0x1F;
v25 = 128LL;
v26 = 0;
LABEL_24:
v27 = 1;
goto LABEL_25;
}
if ( (v19 & 0x7FFFFFF0) == 0xE0 )
{
v18 = v19 & 0xF;
v25 = 2048LL;
v26 = 1;
goto LABEL_24;
}
if ( (v19 & 0x7FFFFFF8) == 0xF0 )
{
v18 = v19 & 7;
v25 = 0x10000LL;
v26 = 2;
goto LABEL_24;
}
v25 = 1LL;
v26 = -1;
v18 = 0;
v27 = 0;
LABEL_25:
if ( !v27 )
{
LABEL_33:
if ( v18 < (int)v25 || v18 > 1114111 || (v18 & 0xFFFFF800) == 0xD800 )
{
js_throw_URIError(a1, (unsigned int)"malformed UTF-8", v20, v25, v21, v22);
goto LABEL_41;
}
goto LABEL_36;
}
v33 = v25;
v28 = v26 + 1;
while ( 1 )
{
v29 = v23;
v30 = hex_decode(a1, v32, (unsigned int)v23, v25);
if ( v30 < 0 )
break;
v25 = (unsigned __int8)v30 & 0xC0;
if ( (_DWORD)v25 != 128 )
{
v18 = 0;
LABEL_32:
v23 = v29 + 3;
LODWORD(v25) = v33;
goto LABEL_33;
}
v18 = v30 & 0x3F | (v18 << 6);
v23 += 3;
if ( v28-- <= 1 )
goto LABEL_32;
}
LABEL_41:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v32, v35);
js_free(v36, v37);
return 0LL;
}
| |||
17,262
|
js_global_decodeURI
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_global_decodeURI(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int isComponent)
{
JSValue str;
StringBuffer b_s, *b = &b_s;
JSString *p;
int k, c, c1, n, c_min;
str = JS_ToString(ctx, argv[0]);
if (JS_IsException(str))
return str;
string_buffer_init(ctx, b, 0);
p = JS_VALUE_GET_STRING(str);
for (k = 0; k < p->len;) {
c = string_get(p, k);
if (c == '%') {
c = hex_decode(ctx, p, k);
if (c < 0)
goto fail;
k += 3;
if (c < 0x80) {
if (!isComponent && isURIReserved(c)) {
c = '%';
k -= 2;
}
} else {
/* Decode URI-encoded UTF-8 sequence */
if (c >= 0xc0 && c <= 0xdf) {
n = 1;
c_min = 0x80;
c &= 0x1f;
} else if (c >= 0xe0 && c <= 0xef) {
n = 2;
c_min = 0x800;
c &= 0xf;
} else if (c >= 0xf0 && c <= 0xf7) {
n = 3;
c_min = 0x10000;
c &= 0x7;
} else {
n = 0;
c_min = 1;
c = 0;
}
while (n-- > 0) {
c1 = hex_decode(ctx, p, k);
if (c1 < 0)
goto fail;
k += 3;
if ((c1 & 0xc0) != 0x80) {
c = 0;
break;
}
c = (c << 6) | (c1 & 0x3f);
}
if (c < c_min || c > 0x10FFFF || is_surrogate(c)) {
js_throw_URIError(ctx, "malformed UTF-8");
goto fail;
}
}
} else {
k++;
}
string_buffer_putc(b, c);
}
JS_FreeValue(ctx, str);
return string_buffer_end(b);
fail:
JS_FreeValue(ctx, str);
string_buffer_free(b);
return JS_EXCEPTION;
}
|
O2
|
c
|
js_global_decodeURI:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0x4(%rsp)
movq %rdi, %r15
movq (%r8), %rsi
movq 0x8(%r8), %rdx
callq 0x1b03c
movq %rax, %r14
movq %rdx, %rbx
cmpl $0x6, %ebx
je 0x660d9
leaq 0x8(%rsp), %rsi
xorl %r12d, %r12d
movq %r15, %rdi
xorl %edx, %edx
callq 0x2e042
movq 0x4(%r14), %rax
movl %eax, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
cmpl %ecx, %r12d
jge 0x660ee
movslq %r12d, %rcx
testl %eax, %eax
js 0x65f6f
movzbl 0x18(%r14,%rcx), %r13d
jmp 0x65f75
movzwl 0x18(%r14,%rcx,2), %r13d
cmpl $0x25, %r13d
jne 0x65fbf
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x665a8
testl %eax, %eax
js 0x660bb
movl %eax, %r13d
leal 0x3(%r12), %ebp
cmpl $0x7f, %eax
ja 0x65fda
cmpl $0x0, 0x4(%rsp)
jne 0x65fc5
movl %r13d, %edi
callq 0x66618
incl %r12d
testl %eax, %eax
pushq $0x25
popq %rax
cmovnel %eax, %r13d
cmovel %ebp, %r12d
jmp 0x65fc2
incl %r12d
movl %r12d, %ebp
leaq 0x8(%rsp), %rdi
movl %r13d, %esi
callq 0x2ca82
movl %ebp, %r12d
jmp 0x65f4b
movl %r13d, %eax
andl $0x7fffffe0, %eax # imm = 0x7FFFFFE0
cmpl $0xc0, %eax
jne 0x65ffb
andl $0x1f, %r13d
movl $0x80, (%rsp)
movl %r13d, %eax
pushq $0x1
jmp 0x6604b
movl %r13d, %eax
andl $0x7ffffff0, %eax # imm = 0x7FFFFFF0
cmpl $0xe0, %eax
jne 0x6601c
andl $0xf, %r13d
movl $0x800, (%rsp) # imm = 0x800
movl %r13d, %eax
pushq $0x2
jmp 0x6604b
movl %r13d, %ecx
andl $0x7ffffff8, %ecx # imm = 0x7FFFFFF8
xorl %eax, %eax
movl $0x0, %r12d
pushq $0x1
popq %rdx
movl %edx, (%rsp)
cmpl $0xf0, %ecx
jne 0x6604d
andl $0x7, %r13d
movl $0x10000, (%rsp) # imm = 0x10000
movl %r13d, %eax
pushq $0x3
popq %r12
movl %eax, %r13d
testl %r12d, %r12d
jle 0x66088
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x665a8
testl %eax, %eax
js 0x660bb
movl %eax, %ecx
andl $0xc0, %ecx
cmpl $0x80, %ecx
jne 0x660aa
addl $0x3, %ebp
shll $0x6, %r13d
andl $0x3f, %eax
orl %eax, %r13d
decl %r12d
jmp 0x66050
cmpl (%rsp), %r13d
jl 0x660aa
cmpl $0x10ffff, %r13d # imm = 0x10FFFF
jg 0x660aa
movl %r13d, %eax
andl $0xfffff800, %eax # imm = 0xFFFFF800
cmpl $0xd800, %eax # imm = 0xD800
jne 0x65fc5
leaq 0x22cec(%rip), %rsi # 0x88d9d
movq %r15, %rdi
xorl %eax, %eax
callq 0x66636
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1801e
leaq 0x8(%rsp), %rdi
callq 0x2ef01
pushq $0x6
popq %rbx
xorl %r14d, %r14d
movq %r14, %rax
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1801e
leaq 0x8(%rsp), %rdi
callq 0x2cad4
movq %rax, %r14
movq %rdx, %rbx
jmp 0x660d9
|
js_global_decodeURI:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_54], r9d
mov r15, rdi
mov rsi, [r8]
mov rdx, [r8+8]
call JS_ToString
mov r14, rax
mov rbx, rdx
cmp ebx, 6
jz loc_660D9
lea rsi, [rsp+58h+var_50]
xor r12d, r12d
mov rdi, r15
xor edx, edx
call string_buffer_init
loc_65F4B:
mov rax, [r14+4]
mov ecx, eax
and ecx, 7FFFFFFFh
cmp r12d, ecx
jge loc_660EE
movsxd rcx, r12d
test eax, eax
js short loc_65F6F
movzx r13d, byte ptr [r14+rcx+18h]
jmp short loc_65F75
loc_65F6F:
movzx r13d, word ptr [r14+rcx*2+18h]
loc_65F75:
cmp r13d, 25h ; '%'
jnz short loc_65FBF
mov rdi, r15
mov rsi, r14
mov edx, r12d
call hex_decode
test eax, eax
js loc_660BB
mov r13d, eax
lea ebp, [r12+3]
cmp eax, 7Fh
ja short loc_65FDA
cmp [rsp+58h+var_54], 0
jnz short loc_65FC5
mov edi, r13d
call isURIReserved
inc r12d
test eax, eax
push 25h ; '%'
pop rax
cmovnz r13d, eax
cmovz r12d, ebp
jmp short loc_65FC2
loc_65FBF:
inc r12d
loc_65FC2:
mov ebp, r12d
loc_65FC5:
lea rdi, [rsp+58h+var_50]
mov esi, r13d
call string_buffer_putc
mov r12d, ebp
jmp loc_65F4B
loc_65FDA:
mov eax, r13d
and eax, 7FFFFFE0h
cmp eax, 0C0h
jnz short loc_65FFB
and r13d, 1Fh
mov [rsp+58h+var_58], 80h
mov eax, r13d
push 1
jmp short loc_6604B
loc_65FFB:
mov eax, r13d
and eax, 7FFFFFF0h
cmp eax, 0E0h
jnz short loc_6601C
and r13d, 0Fh
mov [rsp+58h+var_58], 800h
mov eax, r13d
push 2
jmp short loc_6604B
loc_6601C:
mov ecx, r13d
and ecx, 7FFFFFF8h
xor eax, eax
mov r12d, 0
push 1
pop rdx
mov [rsp+58h+var_58], edx
cmp ecx, 0F0h
jnz short loc_6604D
and r13d, 7
mov [rsp+58h+var_58], 10000h
mov eax, r13d
push 3
loc_6604B:
pop r12
loc_6604D:
mov r13d, eax
loc_66050:
test r12d, r12d
jle short loc_66088
mov rdi, r15
mov rsi, r14
mov edx, ebp
call hex_decode
test eax, eax
js short loc_660BB
mov ecx, eax
and ecx, 0C0h
cmp ecx, 80h
jnz short loc_660AA
add ebp, 3
shl r13d, 6
and eax, 3Fh
or r13d, eax
dec r12d
jmp short loc_66050
loc_66088:
cmp r13d, [rsp+58h+var_58]
jl short loc_660AA
cmp r13d, 10FFFFh
jg short loc_660AA
mov eax, r13d
and eax, 0FFFFF800h
cmp eax, 0D800h
jnz loc_65FC5
loc_660AA:
lea rsi, aMalformedUtf8; "malformed UTF-8"
mov rdi, r15
xor eax, eax
call js_throw_URIError
loc_660BB:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
lea rdi, [rsp+58h+var_50]
call string_buffer_free
push 6
pop rbx
xor r14d, r14d
loc_660D9:
mov rax, r14
mov rdx, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_660EE:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
lea rdi, [rsp+58h+var_50]
call string_buffer_end
mov r14, rax
mov rbx, rdx
jmp short loc_660D9
|
long long js_global_decodeURI(long long a1, long long a2, long long a3, long long a4, long long *a5, int a6)
{
long long v6; // r14
long long v7; // rdx
long long v8; // rbx
int v9; // r12d
signed int v10; // r13d
int v11; // eax
int v12; // edx
long long v13; // rcx
int v14; // r8d
int v15; // r9d
unsigned int v16; // ebp
int v17; // r12d
int v18; // eax
int v19; // r12d
int v20; // eax
int v22; // [rsp-8h] [rbp-60h]
int v23; // [rsp+0h] [rbp-58h]
long long v25[10]; // [rsp+8h] [rbp-50h] BYREF
v6 = JS_ToString(a1, *a5, a5[1]);
v8 = v7;
if ( (_DWORD)v7 != 6 )
{
v9 = 0;
string_buffer_init(a1, (long long)v25, 0);
while ( 1 )
{
if ( v9 >= (*(_DWORD *)(v6 + 4) & 0x7FFFFFFF) )
{
JS_FreeValue(a1, v6, v8);
return string_buffer_end(v25);
}
if ( (int)*(_QWORD *)(v6 + 4) < 0 )
v10 = *(unsigned __int16 *)(v6 + 2LL * v9 + 24);
else
v10 = *(unsigned __int8 *)(v6 + v9 + 24);
if ( v10 != 37 )
{
v17 = v9 + 1;
LABEL_15:
v16 = v17;
goto LABEL_16;
}
v11 = hex_decode(a1, v6, (unsigned int)v9, v9);
if ( v11 < 0 )
{
LABEL_33:
JS_FreeValue(a1, v6, v8);
string_buffer_free(v25);
return 0LL;
}
v10 = v11;
v16 = v9 + 3;
if ( (unsigned int)v11 <= 0x7F )
{
if ( a6 )
goto LABEL_16;
v17 = v9 + 1;
if ( (unsigned int)isURIReserved((unsigned int)v11) )
v10 = 37;
else
v17 = v16;
goto LABEL_15;
}
if ( (v11 & 0x7FFFFFE0) == 0xC0 )
break;
if ( (v11 & 0x7FFFFFF0) == 0xE0 )
{
v23 = 2048;
v18 = v11 & 0xF;
v22 = 2;
goto LABEL_23;
}
v13 = v11 & 0x7FFFFFF8;
v18 = 0;
v19 = 0;
v12 = 1;
v23 = 1;
if ( (_DWORD)v13 == 240 )
{
v23 = 0x10000;
v18 = v10 & 7;
v22 = 3;
goto LABEL_23;
}
LABEL_24:
v10 = v18;
while ( v19 > 0 )
{
v20 = hex_decode(a1, v6, v16, v13);
if ( v20 < 0 )
goto LABEL_33;
v13 = (unsigned __int8)v20 & 0xC0;
if ( (_DWORD)v13 != 128 )
goto LABEL_32;
v16 += 3;
v10 = v20 & 0x3F | (v10 << 6);
--v19;
}
if ( v10 < v23 || v10 > 1114111 || (v10 & 0xFFFFF800) == 0xD800 )
{
LABEL_32:
js_throw_URIError(a1, (unsigned int)"malformed UTF-8", v12, v13, v14, v15, v23);
goto LABEL_33;
}
LABEL_16:
string_buffer_putc((long long)v25, v10);
v9 = v16;
}
v23 = 128;
v18 = v11 & 0x1F;
v22 = 1;
LABEL_23:
v19 = v22;
goto LABEL_24;
}
return v6;
}
|
js_global_decodeURI:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RSP + 0x4],R9D
MOV R15,RDI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
CALL 0x0011b03c
MOV R14,RAX
MOV RBX,RDX
CMP EBX,0x6
JZ 0x001660d9
LEA RSI,[RSP + 0x8]
XOR R12D,R12D
MOV RDI,R15
XOR EDX,EDX
CALL 0x0012e042
LAB_00165f4b:
MOV RAX,qword ptr [R14 + 0x4]
MOV ECX,EAX
AND ECX,0x7fffffff
CMP R12D,ECX
JGE 0x001660ee
MOVSXD RCX,R12D
TEST EAX,EAX
JS 0x00165f6f
MOVZX R13D,byte ptr [R14 + RCX*0x1 + 0x18]
JMP 0x00165f75
LAB_00165f6f:
MOVZX R13D,word ptr [R14 + RCX*0x2 + 0x18]
LAB_00165f75:
CMP R13D,0x25
JNZ 0x00165fbf
MOV RDI,R15
MOV RSI,R14
MOV EDX,R12D
CALL 0x001665a8
TEST EAX,EAX
JS 0x001660bb
MOV R13D,EAX
LEA EBP,[R12 + 0x3]
CMP EAX,0x7f
JA 0x00165fda
CMP dword ptr [RSP + 0x4],0x0
JNZ 0x00165fc5
MOV EDI,R13D
CALL 0x00166618
INC R12D
TEST EAX,EAX
PUSH 0x25
POP RAX
CMOVNZ R13D,EAX
CMOVZ R12D,EBP
JMP 0x00165fc2
LAB_00165fbf:
INC R12D
LAB_00165fc2:
MOV EBP,R12D
LAB_00165fc5:
LEA RDI,[RSP + 0x8]
MOV ESI,R13D
CALL 0x0012ca82
MOV R12D,EBP
JMP 0x00165f4b
LAB_00165fda:
MOV EAX,R13D
AND EAX,0x7fffffe0
CMP EAX,0xc0
JNZ 0x00165ffb
AND R13D,0x1f
MOV dword ptr [RSP],0x80
MOV EAX,R13D
PUSH 0x1
JMP 0x0016604b
LAB_00165ffb:
MOV EAX,R13D
AND EAX,0x7ffffff0
CMP EAX,0xe0
JNZ 0x0016601c
AND R13D,0xf
MOV dword ptr [RSP],0x800
MOV EAX,R13D
PUSH 0x2
JMP 0x0016604b
LAB_0016601c:
MOV ECX,R13D
AND ECX,0x7ffffff8
XOR EAX,EAX
MOV R12D,0x0
PUSH 0x1
POP RDX
MOV dword ptr [RSP],EDX
CMP ECX,0xf0
JNZ 0x0016604d
AND R13D,0x7
MOV dword ptr [RSP],0x10000
MOV EAX,R13D
PUSH 0x3
LAB_0016604b:
POP R12
LAB_0016604d:
MOV R13D,EAX
LAB_00166050:
TEST R12D,R12D
JLE 0x00166088
MOV RDI,R15
MOV RSI,R14
MOV EDX,EBP
CALL 0x001665a8
TEST EAX,EAX
JS 0x001660bb
MOV ECX,EAX
AND ECX,0xc0
CMP ECX,0x80
JNZ 0x001660aa
ADD EBP,0x3
SHL R13D,0x6
AND EAX,0x3f
OR R13D,EAX
DEC R12D
JMP 0x00166050
LAB_00166088:
CMP R13D,dword ptr [RSP]
JL 0x001660aa
CMP R13D,0x10ffff
JG 0x001660aa
MOV EAX,R13D
AND EAX,0xfffff800
CMP EAX,0xd800
JNZ 0x00165fc5
LAB_001660aa:
LEA RSI,[0x188d9d]
MOV RDI,R15
XOR EAX,EAX
CALL 0x00166636
LAB_001660bb:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011801e
LEA RDI,[RSP + 0x8]
CALL 0x0012ef01
PUSH 0x6
POP RBX
XOR R14D,R14D
LAB_001660d9:
MOV RAX,R14
MOV RDX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001660ee:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011801e
LEA RDI,[RSP + 0x8]
CALL 0x0012cad4
MOV R14,RAX
MOV RBX,RDX
JMP 0x001660d9
|
int1 [16] js_global_decodeURI(int8 param_1)
{
int iVar1;
uint uVar2;
int iVar3;
long lVar4;
int iVar5;
int8 *in_R8;
int in_R9D;
int iVar6;
uint uVar7;
int1 auVar8 [16];
int local_58;
int1 local_50 [32];
auVar8 = JS_ToString(param_1,*in_R8,in_R8[1]);
lVar4 = auVar8._0_8_;
if (auVar8._8_4_ != 6) {
iVar6 = 0;
string_buffer_init(param_1,local_50,0);
while (uVar7 = (uint)*(int8 *)(lVar4 + 4), iVar6 < (int)(uVar7 & 0x7fffffff)) {
if ((int)uVar7 < 0) {
uVar7 = (uint)*(ushort *)(lVar4 + 0x18 + (long)iVar6 * 2);
}
else {
uVar7 = (uint)*(byte *)(lVar4 + 0x18 + (long)iVar6);
}
if (uVar7 == 0x25) {
uVar2 = hex_decode(param_1,lVar4,iVar6);
if ((int)uVar2 < 0) {
LAB_001660bb:
JS_FreeValue(param_1,lVar4,auVar8._8_8_);
string_buffer_free(local_50);
return ZEXT816(6) << 0x40;
}
iVar5 = iVar6 + 3;
if (uVar2 < 0x80) {
uVar7 = uVar2;
iVar1 = iVar5;
if (in_R9D == 0) {
iVar3 = isURIReserved(uVar2);
uVar7 = 0x25;
iVar1 = iVar6 + 1;
if (iVar3 == 0) {
uVar7 = uVar2;
iVar1 = iVar5;
}
}
}
else {
if ((uVar2 & 0x7fffffe0) == 0xc0) {
uVar7 = uVar2 & 0x1f;
local_58 = 0x80;
iVar6 = 1;
}
else if ((uVar2 & 0x7ffffff0) == 0xe0) {
uVar7 = uVar2 & 0xf;
local_58 = 0x800;
iVar6 = 2;
}
else {
uVar7 = 0;
iVar6 = 0;
local_58 = 1;
if ((uVar2 & 0x7ffffff8) == 0xf0) {
uVar7 = uVar2 & 7;
local_58 = 0x10000;
iVar6 = 3;
}
}
for (; 0 < iVar6; iVar6 = iVar6 + -1) {
uVar2 = hex_decode(param_1,lVar4,iVar5);
if ((int)uVar2 < 0) goto LAB_001660bb;
if ((uVar2 & 0xc0) != 0x80) goto LAB_001660aa;
iVar5 = iVar5 + 3;
uVar7 = uVar7 << 6 | uVar2 & 0x3f;
}
if ((((int)uVar7 < local_58) || (0x10ffff < (int)uVar7)) ||
(iVar1 = iVar5, (uVar7 & 0xfffff800) == 0xd800)) {
LAB_001660aa:
js_throw_URIError(param_1,"malformed UTF-8");
goto LAB_001660bb;
}
}
}
else {
iVar1 = iVar6 + 1;
}
iVar6 = iVar1;
string_buffer_putc(local_50,uVar7);
}
JS_FreeValue(param_1,lVar4,auVar8._8_8_);
auVar8 = string_buffer_end(local_50);
}
return auVar8;
}
|
|
17,263
|
js_global_decodeURI
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_global_decodeURI(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int isComponent)
{
JSValue str;
StringBuffer b_s, *b = &b_s;
JSString *p;
int k, c, c1, n, c_min;
str = JS_ToString(ctx, argv[0]);
if (JS_IsException(str))
return str;
string_buffer_init(ctx, b, 0);
p = JS_VALUE_GET_STRING(str);
for (k = 0; k < p->len;) {
c = string_get(p, k);
if (c == '%') {
c = hex_decode(ctx, p, k);
if (c < 0)
goto fail;
k += 3;
if (c < 0x80) {
if (!isComponent && isURIReserved(c)) {
c = '%';
k -= 2;
}
} else {
/* Decode URI-encoded UTF-8 sequence */
if (c >= 0xc0 && c <= 0xdf) {
n = 1;
c_min = 0x80;
c &= 0x1f;
} else if (c >= 0xe0 && c <= 0xef) {
n = 2;
c_min = 0x800;
c &= 0xf;
} else if (c >= 0xf0 && c <= 0xf7) {
n = 3;
c_min = 0x10000;
c &= 0x7;
} else {
n = 0;
c_min = 1;
c = 0;
}
while (n-- > 0) {
c1 = hex_decode(ctx, p, k);
if (c1 < 0)
goto fail;
k += 3;
if ((c1 & 0xc0) != 0x80) {
c = 0;
break;
}
c = (c << 6) | (c1 & 0x3f);
}
if (c < c_min || c > 0x10FFFF || is_surrogate(c)) {
js_throw_URIError(ctx, "malformed UTF-8");
goto fail;
}
}
} else {
k++;
}
string_buffer_putc(b, c);
}
JS_FreeValue(ctx, str);
return string_buffer_end(b);
fail:
JS_FreeValue(ctx, str);
string_buffer_free(b);
return JS_EXCEPTION;
}
|
O3
|
c
|
js_global_decodeURI:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebx
movq %rdi, %r15
movq (%r8), %rsi
movq 0x8(%r8), %rdx
xorl %ecx, %ecx
callq 0x28154
movq %rax, %r14
cmpl $0x6, %edx
je 0x7c088
movl %ebx, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
movq %r15, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsp)
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x212c2
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x7c09a
movq 0x4(%r14), %rax
testl $0x7fffffff, %eax # imm = 0x7FFFFFFF
je 0x7c057
xorl %ebp, %ebp
movslq %ebp, %rcx
testl %eax, %eax
js 0x7bebb
movzbl 0x18(%r14,%rcx), %r12d
jmp 0x7bec1
movzwl 0x18(%r14,%rcx,2), %r12d
cmpl $0x25, %r12d
jne 0x7bf17
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x7c6ad
testl %eax, %eax
js 0x7c01a
movl %eax, %r12d
leal 0x3(%rbp), %r13d
cmpl $0x7f, %eax
ja 0x7bf46
cmpl $0x0, 0xc(%rsp)
jne 0x7bf1c
movl $0xb, %edx
leaq 0x28f43(%rip), %rdi # 0xa4e3e
movl %r12d, %esi
callq 0xe440
incl %ebp
testq %rax, %rax
movl $0x25, %eax
cmovnel %eax, %r12d
cmovel %r13d, %ebp
jmp 0x7bf19
incl %ebp
movl %ebp, %r13d
leaq 0x18(%rsp), %rdi
movl %r12d, %esi
callq 0x3425d
movq 0x4(%r14), %rax
movl %eax, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
movl %r13d, %ebp
cmpl %ecx, %r13d
jl 0x7beac
jmp 0x7c057
movl %r12d, %eax
andl $0x7fffffe0, %eax # imm = 0x7FFFFFE0
cmpl $0xc0, %eax
jne 0x7bf66
movl $0x80, 0x8(%rsp)
xorl %ebp, %ebp
movl $0x1f, %eax
jmp 0x7bfaa
movl %r12d, %eax
andl $0x7ffffff0, %eax # imm = 0x7FFFFFF0
cmpl $0xe0, %eax
jne 0x7bf89
movl $0x800, 0x8(%rsp) # imm = 0x800
movl $0x1, %ebp
movl $0xf, %eax
jmp 0x7bfaa
movl %r12d, %eax
andl $0x7ffffff8, %eax # imm = 0x7FFFFFF8
cmpl $0xf0, %eax
jne 0x7c009
movl $0x10000, 0x8(%rsp) # imm = 0x10000
movl $0x2, %ebp
movl $0x7, %eax
andl %eax, %r12d
incl %ebp
movl %r12d, %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x7c6ad
testl %eax, %eax
js 0x7c01a
movl %eax, %r12d
andl $0xc0, %eax
cmpl $0x80, %eax
jne 0x7c009
addl $0x3, %r13d
movl %ebx, %eax
shll $0x6, %eax
andl $0x3f, %r12d
orl %eax, %r12d
decl %ebp
jg 0x7bfaf
cmpl 0x8(%rsp), %r12d
jl 0x7c009
cmpl $0x10ffff, %r12d # imm = 0x10FFFF
jg 0x7c009
andl $0x3ffffe0, %ebx # imm = 0x3FFFFE0
cmpl $0x360, %ebx # imm = 0x360
jne 0x7bf1c
leaq 0x28dfd(%rip), %rsi # 0xa4e0d
movq %r15, %rdi
xorl %eax, %eax
callq 0x7c71f
movq 0x10(%rsp), %rdx
cmpl $-0x9, %edx
jb 0x7c03e
movq 0x18(%r15), %rdi
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x1, %eax
jg 0x7c03e
movq %r14, %rsi
callq 0x219cc
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1d481
movl $0x6, %edx
xorl %r14d, %r14d
jmp 0x7c088
movq 0x10(%rsp), %rdx
cmpl $-0x9, %edx
jb 0x7c07b
movq 0x18(%r15), %rdi
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x1, %eax
jg 0x7c07b
movq %r14, %rsi
callq 0x219cc
leaq 0x18(%rsp), %rdi
callq 0x342b1
movq %rax, %r14
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0x2c(%rsp)
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x7be9b
|
js_global_decodeURI:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov ebx, r9d
mov r15, rdi
mov rsi, [r8]
mov rdx, [r8+8]
xor ecx, ecx
call JS_ToStringInternal
mov r14, rax
cmp edx, 6
jz loc_7C088
mov [rsp+68h+var_5C], ebx
mov [rsp+68h+var_58], rdx
mov [rsp+68h+var_50], r15
xorps xmm0, xmm0
movups [rsp+68h+var_40], xmm0
mov rdi, r15
xor esi, esi
xor edx, edx
call js_alloc_string
mov [rsp+68h+var_48], rax
test rax, rax
jz loc_7C09A
loc_7BE9B:
mov rax, [r14+4]
test eax, 7FFFFFFFh
jz loc_7C057
xor ebp, ebp
loc_7BEAC:
movsxd rcx, ebp
test eax, eax
js short loc_7BEBB
movzx r12d, byte ptr [r14+rcx+18h]
jmp short loc_7BEC1
loc_7BEBB:
movzx r12d, word ptr [r14+rcx*2+18h]
loc_7BEC1:
cmp r12d, 25h ; '%'
jnz short loc_7BF17
mov rdi, r15
mov rsi, r14
mov edx, ebp
call hex_decode
test eax, eax
js loc_7C01A
mov r12d, eax
lea r13d, [rbp+3]
cmp eax, 7Fh
ja short loc_7BF46
cmp [rsp+68h+var_5C], 0
jnz short loc_7BF1C
mov edx, 0Bh
lea rdi, asc_A4E3E; ";/?:@&=+$,#"
mov esi, r12d
call _memchr
inc ebp
test rax, rax
mov eax, 25h ; '%'
cmovnz r12d, eax
cmovz ebp, r13d
jmp short loc_7BF19
loc_7BF17:
inc ebp
loc_7BF19:
mov r13d, ebp
loc_7BF1C:
lea rdi, [rsp+68h+var_50]
mov esi, r12d
call string_buffer_putc
mov rax, [r14+4]
mov ecx, eax
and ecx, 7FFFFFFFh
mov ebp, r13d
cmp r13d, ecx
jl loc_7BEAC
jmp loc_7C057
loc_7BF46:
mov eax, r12d
and eax, 7FFFFFE0h
cmp eax, 0C0h
jnz short loc_7BF66
mov [rsp+68h+var_60], 80h
xor ebp, ebp
mov eax, 1Fh
jmp short loc_7BFAA
loc_7BF66:
mov eax, r12d
and eax, 7FFFFFF0h
cmp eax, 0E0h
jnz short loc_7BF89
mov [rsp+68h+var_60], 800h
mov ebp, 1
mov eax, 0Fh
jmp short loc_7BFAA
loc_7BF89:
mov eax, r12d
and eax, 7FFFFFF8h
cmp eax, 0F0h
jnz short loc_7C009
mov [rsp+68h+var_60], offset loc_10000
mov ebp, 2
mov eax, 7
loc_7BFAA:
and r12d, eax
inc ebp
loc_7BFAF:
mov ebx, r12d
mov rdi, r15
mov rsi, r14
mov edx, r13d
call hex_decode
test eax, eax
js short loc_7C01A
mov r12d, eax
and eax, 0C0h
cmp eax, 80h
jnz short loc_7C009
add r13d, 3
mov eax, ebx
shl eax, 6
and r12d, 3Fh
or r12d, eax
dec ebp
jg short loc_7BFAF
cmp r12d, [rsp+68h+var_60]
jl short loc_7C009
cmp r12d, 10FFFFh
jg short loc_7C009
and ebx, 3FFFFE0h
cmp ebx, 360h
jnz loc_7BF1C
loc_7C009:
lea rsi, aMalformedUtf8; "malformed UTF-8"
mov rdi, r15
xor eax, eax
call js_throw_URIError
loc_7C01A:
mov rdx, [rsp+68h+var_58]
cmp edx, 0FFFFFFF7h
jb short loc_7C03E
mov rdi, [r15+18h]
mov eax, [r14]
lea ecx, [rax-1]
mov [r14], ecx
cmp eax, 1
jg short loc_7C03E
mov rsi, r14
call js_free_value_rt
loc_7C03E:
mov rdi, [rsp+68h+var_50]
mov rsi, [rsp+68h+var_48]
call js_free
mov edx, 6
xor r14d, r14d
jmp short loc_7C088
loc_7C057:
mov rdx, [rsp+68h+var_58]
cmp edx, 0FFFFFFF7h
jb short loc_7C07B
mov rdi, [r15+18h]
mov eax, [r14]
lea ecx, [rax-1]
mov [r14], ecx
cmp eax, 1
jg short loc_7C07B
mov rsi, r14
call js_free_value_rt
loc_7C07B:
lea rdi, [rsp+68h+var_50]
call string_buffer_end
mov r14, rax
loc_7C088:
mov rax, r14
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7C09A:
mov dword ptr [rsp+68h+var_40+4], 0
mov dword ptr [rsp+68h+var_40+0Ch], 0FFFFFFFFh
jmp loc_7BE9B
|
long long js_global_decodeURI(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
int v14; // ebx
unsigned int v15; // edx
_QWORD *v16; // r14
long long v17; // rax
int v18; // ebp
signed int v19; // r12d
int v20; // eax
int v21; // edx
long long v22; // rcx
int v23; // r8d
int v24; // r9d
int v25; // r13d
int v26; // ebp
int v27; // ebp
int v28; // eax
int v29; // ebp
signed int v30; // ebx
int v31; // eax
long long v33; // rdi
int v34; // eax
long long v35; // rdi
int v36; // eax
int v38; // [rsp+8h] [rbp-60h]
int v39; // [rsp+Ch] [rbp-5Ch]
unsigned int v40; // [rsp+10h] [rbp-58h]
long long v41; // [rsp+18h] [rbp-50h] BYREF
long long v42; // [rsp+20h] [rbp-48h]
__int128 v43; // [rsp+28h] [rbp-40h]
v14 = a14;
v16 = (_QWORD *)JS_ToStringInternal(
a1,
*(_DWORD **)a13,
*(_QWORD *)(a13 + 8),
0LL,
a13,
a14,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9);
if ( v15 == 6 )
return (long long)v16;
v39 = v14;
v40 = v15;
v41 = a1;
v43 = 0LL;
v42 = js_alloc_string(a1, 0LL, 0);
if ( !v42 )
{
DWORD1(v43) = 0;
HIDWORD(v43) = -1;
}
v17 = *(_QWORD *)((char *)v16 + 4);
if ( (v17 & 0x7FFFFFFF) == 0 )
{
LABEL_38:
if ( v40 >= 0xFFFFFFF7 )
{
v35 = *(_QWORD *)(a1 + 24);
v36 = (*(_DWORD *)v16)--;
if ( v36 <= 1 )
js_free_value_rt(v35, v16, v40);
}
return string_buffer_end(&v41);
}
v18 = 0;
while ( 1 )
{
if ( (int)v17 < 0 )
v19 = *((unsigned __int16 *)v16 + v18 + 12);
else
v19 = *((unsigned __int8 *)v16 + v18 + 24);
if ( v19 != 37 )
{
v26 = v18 + 1;
LABEL_17:
v25 = v26;
goto LABEL_18;
}
v20 = hex_decode(a1, v16, (unsigned int)v18, v18);
if ( v20 < 0 )
goto LABEL_34;
v19 = v20;
v25 = v18 + 3;
if ( (unsigned int)v20 > 0x7F )
break;
if ( !v39 )
{
v26 = v18 + 1;
if ( memchr(";/?:@&=+$,#", (unsigned int)v20, 11LL) )
v19 = 37;
else
v26 = v25;
goto LABEL_17;
}
LABEL_18:
string_buffer_putc((long long)&v41, v19);
v17 = *(_QWORD *)((char *)v16 + 4);
v18 = v25;
if ( v25 >= (*((_DWORD *)v16 + 1) & 0x7FFFFFFF) )
goto LABEL_38;
}
if ( (v20 & 0x7FFFFFE0) == 0xC0 )
{
v38 = 128;
v27 = 0;
v28 = 31;
LABEL_26:
v19 &= v28;
v29 = v27 + 1;
while ( 1 )
{
v30 = v19;
v31 = hex_decode(a1, v16, (unsigned int)v25, v22);
if ( v31 < 0 )
break;
if ( (v31 & 0xC0) != 0x80 )
goto LABEL_33;
v25 += 3;
v19 = (v19 << 6) | v31 & 0x3F;
if ( v29-- <= 1 )
{
if ( v19 >= v38 && v19 <= 1114111 && (v30 & 0x3FFFFE0) != 0x360 )
goto LABEL_18;
goto LABEL_33;
}
}
}
else
{
if ( (v20 & 0x7FFFFFF0) == 0xE0 )
{
v38 = 2048;
v27 = 1;
v28 = 15;
goto LABEL_26;
}
if ( (v20 & 0x7FFFFFF8) == 0xF0 )
{
v38 = (int)&loc_10000;
v27 = 2;
v28 = 7;
goto LABEL_26;
}
LABEL_33:
js_throw_URIError(a1, (unsigned int)"malformed UTF-8", v21, v22, v23, v24);
}
LABEL_34:
if ( v40 >= 0xFFFFFFF7 )
{
v33 = *(_QWORD *)(a1 + 24);
v34 = (*(_DWORD *)v16)--;
if ( v34 <= 1 )
js_free_value_rt(v33, v16, v40);
}
js_free(v41, v42);
return 0LL;
}
|
js_global_decodeURI:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV EBX,R9D
MOV R15,RDI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
XOR ECX,ECX
CALL 0x00128154
MOV R14,RAX
CMP EDX,0x6
JZ 0x0017c088
MOV dword ptr [RSP + 0xc],EBX
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x18],R15
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x28],XMM0
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001212c2
MOV qword ptr [RSP + 0x20],RAX
TEST RAX,RAX
JZ 0x0017c09a
LAB_0017be9b:
MOV RAX,qword ptr [R14 + 0x4]
TEST EAX,0x7fffffff
JZ 0x0017c057
XOR EBP,EBP
LAB_0017beac:
MOVSXD RCX,EBP
TEST EAX,EAX
JS 0x0017bebb
MOVZX R12D,byte ptr [R14 + RCX*0x1 + 0x18]
JMP 0x0017bec1
LAB_0017bebb:
MOVZX R12D,word ptr [R14 + RCX*0x2 + 0x18]
LAB_0017bec1:
CMP R12D,0x25
JNZ 0x0017bf17
MOV RDI,R15
MOV RSI,R14
MOV EDX,EBP
CALL 0x0017c6ad
TEST EAX,EAX
JS 0x0017c01a
MOV R12D,EAX
LEA R13D,[RBP + 0x3]
CMP EAX,0x7f
JA 0x0017bf46
CMP dword ptr [RSP + 0xc],0x0
JNZ 0x0017bf1c
MOV EDX,0xb
LEA RDI,[0x1a4e3e]
MOV ESI,R12D
CALL 0x0010e440
INC EBP
TEST RAX,RAX
MOV EAX,0x25
CMOVNZ R12D,EAX
CMOVZ EBP,R13D
JMP 0x0017bf19
LAB_0017bf17:
INC EBP
LAB_0017bf19:
MOV R13D,EBP
LAB_0017bf1c:
LEA RDI,[RSP + 0x18]
MOV ESI,R12D
CALL 0x0013425d
MOV RAX,qword ptr [R14 + 0x4]
MOV ECX,EAX
AND ECX,0x7fffffff
MOV EBP,R13D
CMP R13D,ECX
JL 0x0017beac
JMP 0x0017c057
LAB_0017bf46:
MOV EAX,R12D
AND EAX,0x7fffffe0
CMP EAX,0xc0
JNZ 0x0017bf66
MOV dword ptr [RSP + 0x8],0x80
XOR EBP,EBP
MOV EAX,0x1f
JMP 0x0017bfaa
LAB_0017bf66:
MOV EAX,R12D
AND EAX,0x7ffffff0
CMP EAX,0xe0
JNZ 0x0017bf89
MOV dword ptr [RSP + 0x8],0x800
MOV EBP,0x1
MOV EAX,0xf
JMP 0x0017bfaa
LAB_0017bf89:
MOV EAX,R12D
AND EAX,0x7ffffff8
CMP EAX,0xf0
JNZ 0x0017c009
MOV dword ptr [RSP + 0x8],0x10000
MOV EBP,0x2
MOV EAX,0x7
LAB_0017bfaa:
AND R12D,EAX
INC EBP
LAB_0017bfaf:
MOV EBX,R12D
MOV RDI,R15
MOV RSI,R14
MOV EDX,R13D
CALL 0x0017c6ad
TEST EAX,EAX
JS 0x0017c01a
MOV R12D,EAX
AND EAX,0xc0
CMP EAX,0x80
JNZ 0x0017c009
ADD R13D,0x3
MOV EAX,EBX
SHL EAX,0x6
AND R12D,0x3f
OR R12D,EAX
DEC EBP
JG 0x0017bfaf
CMP R12D,dword ptr [RSP + 0x8]
JL 0x0017c009
CMP R12D,0x10ffff
JG 0x0017c009
AND EBX,0x3ffffe0
CMP EBX,0x360
JNZ 0x0017bf1c
LAB_0017c009:
LEA RSI,[0x1a4e0d]
MOV RDI,R15
XOR EAX,EAX
CALL 0x0017c71f
LAB_0017c01a:
MOV RDX,qword ptr [RSP + 0x10]
CMP EDX,-0x9
JC 0x0017c03e
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [R14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14],ECX
CMP EAX,0x1
JG 0x0017c03e
MOV RSI,R14
CALL 0x001219cc
LAB_0017c03e:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x0011d481
MOV EDX,0x6
XOR R14D,R14D
JMP 0x0017c088
LAB_0017c057:
MOV RDX,qword ptr [RSP + 0x10]
CMP EDX,-0x9
JC 0x0017c07b
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [R14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14],ECX
CMP EAX,0x1
JG 0x0017c07b
MOV RSI,R14
CALL 0x001219cc
LAB_0017c07b:
LEA RDI,[RSP + 0x18]
CALL 0x001342b1
MOV R14,RAX
LAB_0017c088:
MOV RAX,R14
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017c09a:
MOV dword ptr [RSP + 0x2c],0x0
MOV dword ptr [RSP + 0x34],0xffffffff
JMP 0x0017be9b
|
int * js_global_decodeURI(long param_1)
{
int8 uVar1;
bool bVar2;
uint uVar3;
uint uVar4;
ulong uVar5;
void *pvVar6;
int *piVar7;
uint uVar8;
int iVar9;
int iVar10;
int8 *in_R8;
int in_R9D;
int iVar11;
int1 auVar12 [12];
int local_60;
long local_50;
long local_48;
ulong local_40;
int8 uStack_38;
auVar12 = JS_ToStringInternal(param_1,*in_R8,in_R8[1],0);
uVar8 = auVar12._8_4_;
piVar7 = auVar12._0_8_;
if (uVar8 != 6) {
local_40 = 0;
uStack_38 = 0;
local_50 = param_1;
local_48 = js_alloc_string(param_1,0,0);
if (local_48 == 0) {
local_40 = local_40 & 0xffffffff;
uStack_38 = CONCAT44(0xffffffff,(int4)uStack_38);
}
uVar5 = *(ulong *)(piVar7 + 1);
if ((uVar5 & 0x7fffffff) != 0) {
iVar9 = 0;
do {
if ((int)uVar5 < 0) {
uVar3 = (uint)*(ushort *)((long)piVar7 + (long)iVar9 * 2 + 0x18);
}
else {
uVar3 = (uint)*(byte *)((long)piVar7 + (long)iVar9 + 0x18);
}
if (uVar3 == 0x25) {
uVar3 = hex_decode(param_1,piVar7,iVar9);
if ((int)uVar3 < 0) goto LAB_0017c01a;
iVar11 = iVar9 + 3;
if (uVar3 < 0x80) {
if (in_R9D == 0) {
pvVar6 = memchr(";/?:@&=+$,#",uVar3,0xb);
if (pvVar6 != (void *)0x0) {
uVar3 = 0x25;
iVar11 = iVar9 + 1;
}
}
goto LAB_0017bf1c;
}
if ((uVar3 & 0x7fffffe0) == 0xc0) {
local_60 = 0x80;
iVar9 = 0;
uVar4 = 0x1f;
LAB_0017bfaa:
uVar3 = uVar3 & uVar4;
iVar9 = iVar9 + 1;
do {
uVar4 = uVar3;
uVar3 = hex_decode(param_1,piVar7,iVar11);
if ((int)uVar3 < 0) goto LAB_0017c01a;
if ((uVar3 & 0xc0) != 0x80) goto LAB_0017c009;
iVar11 = iVar11 + 3;
uVar3 = uVar3 & 0x3f | uVar4 << 6;
iVar10 = iVar9 + -1;
bVar2 = 0 < iVar9;
iVar9 = iVar10;
} while (iVar10 != 0 && bVar2);
if (((local_60 <= (int)uVar3) && ((int)uVar3 < 0x110000)) &&
((uVar4 & 0x3ffffe0) != 0x360)) goto LAB_0017bf1c;
}
else {
if ((uVar3 & 0x7ffffff0) == 0xe0) {
local_60 = 0x800;
iVar9 = 1;
uVar4 = 0xf;
goto LAB_0017bfaa;
}
if ((uVar3 & 0x7ffffff8) == 0xf0) {
local_60 = 0x10000;
iVar9 = 2;
uVar4 = 7;
goto LAB_0017bfaa;
}
}
LAB_0017c009:
js_throw_URIError(param_1,"malformed UTF-8");
LAB_0017c01a:
if (0xfffffff6 < uVar8) {
uVar1 = *(int8 *)(param_1 + 0x18);
iVar9 = *piVar7;
*piVar7 = iVar9 + -1;
if (iVar9 < 2) {
js_free_value_rt(uVar1,piVar7);
}
}
js_free(local_50,local_48);
return (int *)0x0;
}
iVar11 = iVar9 + 1;
LAB_0017bf1c:
iVar9 = iVar11;
string_buffer_putc(&local_50,uVar3);
uVar5 = *(ulong *)(piVar7 + 1);
} while (iVar9 < (int)((uint)uVar5 & 0x7fffffff));
}
if (0xfffffff6 < uVar8) {
uVar1 = *(int8 *)(param_1 + 0x18);
iVar9 = *piVar7;
*piVar7 = iVar9 + -1;
if (iVar9 < 2) {
js_free_value_rt(uVar1,piVar7);
}
}
piVar7 = (int *)string_buffer_end(&local_50);
}
return piVar7;
}
|
|
17,264
|
translog_read_record
|
eloqsql/storage/maria/ma_loghandler.c
|
translog_size_t translog_read_record(LSN lsn,
translog_size_t offset,
translog_size_t length,
uchar *buffer,
TRANSLOG_READER_DATA *data)
{
translog_size_t requested_length= length;
translog_size_t end= offset + length;
TRANSLOG_READER_DATA internal_data;
DBUG_ENTER("translog_read_record");
DBUG_ASSERT(translog_status == TRANSLOG_OK ||
translog_status == TRANSLOG_READONLY);
if (data == NULL)
{
DBUG_ASSERT(lsn != LSN_IMPOSSIBLE);
data= &internal_data;
}
if (lsn ||
(offset < data->current_offset &&
!(offset < data->read_header && offset + length < data->read_header)))
{
if (translog_init_reader_data(lsn, data))
DBUG_RETURN(0);
}
DBUG_PRINT("info", ("Offset: %lu length: %lu "
"Scanner: Cur: " LSN_FMT " Hrz: " LSN_FMT " "
"Lst: " LSN_FMT " Offset: %u(%x) fixed: %d",
(ulong) offset, (ulong) length,
LSN_IN_PARTS(data->scanner.page_addr),
LSN_IN_PARTS(data->scanner.horizon),
LSN_IN_PARTS(data->scanner.last_file_page),
(uint) data->scanner.page_offset,
(uint) data->scanner.page_offset,
data->scanner.fixed_horizon));
if (offset < data->read_header)
{
uint16 len= MY_MIN(data->read_header, end) - offset;
DBUG_PRINT("info",
("enter header offset: %lu length: %lu",
(ulong) offset, (ulong) length));
memcpy(buffer, data->header.header + offset, len);
length-= len;
if (length == 0)
{
translog_destroy_reader_data(data);
DBUG_RETURN(requested_length);
}
offset+= len;
buffer+= len;
DBUG_PRINT("info",
("len: %u offset: %lu curr: %lu length: %lu",
len, (ulong) offset, (ulong) data->current_offset,
(ulong) length));
}
/* TODO: find first page which we should read by offset */
/* read the record chunk by chunk */
for(;;)
{
uint page_end= data->current_offset + data->chunk_size;
DBUG_PRINT("info",
("enter body offset: %lu curr: %lu "
"length: %lu page_end: %lu",
(ulong) offset, (ulong) data->current_offset, (ulong) length,
(ulong) page_end));
if (offset < page_end)
{
uint len= page_end - offset;
set_if_smaller(len, length); /* in case we read beyond record's end */
DBUG_ASSERT(offset >= data->current_offset);
memcpy(buffer,
data->scanner.page + data->body_offset +
(offset - data->current_offset), len);
length-= len;
if (length == 0)
{
translog_destroy_reader_data(data);
DBUG_RETURN(requested_length);
}
offset+= len;
buffer+= len;
DBUG_PRINT("info",
("len: %u offset: %lu curr: %lu length: %lu",
len, (ulong) offset, (ulong) data->current_offset,
(ulong) length));
}
if (translog_record_read_next_chunk(data))
{
translog_destroy_reader_data(data);
DBUG_RETURN(requested_length - length);
}
}
}
|
O3
|
c
|
translog_read_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x24c8, %rsp # imm = 0x24C8
movq %r8, %r15
movq %rcx, -0x24d8(%rbp)
movl %esi, %r12d
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leal (%rdx,%r12), %esi
testq %r8, %r8
leaq -0x24b0(%rbp), %r14
movq %r8, %rax
cmoveq %r14, %rax
movq %rax, -0x24c8(%rbp)
testq %rdi, %rdi
movq %rdx, -0x24d0(%rbp)
je 0x46789
movl %esi, -0x24c0(%rbp)
movq %r12, -0x24e0(%rbp)
testq %r15, %r15
movq %r15, %r13
cmoveq %r14, %r13
addq $0x438, %r13 # imm = 0x438
movl $0x1, %esi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x45f13
xorl %ebx, %ebx
testb %al, %al
jne 0x46afd
testq %r15, %r15
movq %r15, %rax
cmoveq %r14, %rax
movl $0x0, 0x418(%rax)
movl 0x2460(%rax), %ecx
movzwl %cx, %esi
addq 0x2438(%rax), %rcx
movq -0x24c8(%rbp), %rdx
movq %rcx, (%rdx)
movq 0x2450(%rax), %rdi
movq %r13, %rcx
callq 0x472f8
cmpl $-0x1, %eax
je 0x46afd
testq %r15, %r15
movq %r15, %rcx
cmoveq %r14, %rcx
movw %ax, 0x2470(%rcx)
movzwl 0x432(%rcx), %edx
movl %edx, 0x2468(%rcx)
movzwl 0x434(%rcx), %edx
movw %dx, 0x2472(%rcx)
movzwl %ax, %eax
movl %eax, 0x246c(%rcx)
movq $0x0, 0x2474(%rcx)
movb $0x0, 0x247c(%rcx)
movq -0x24d0(%rbp), %rdx
movq -0x24e0(%rbp), %r12
movl -0x24c0(%rbp), %esi
jmp 0x467c0
testq %r15, %r15
movq %r15, %rax
cmoveq %r14, %rax
cmpl %r12d, 0x246c(%rax)
jbe 0x467c0
testq %r15, %r15
movq %r15, %rax
cmoveq %r14, %rax
movzwl 0x2470(%rax), %eax
cmpl %r12d, %eax
seta %cl
cmpl %eax, %esi
setb %al
testb %al, %cl
je 0x466ac
testq %r15, %r15
movq %r15, %rax
cmoveq %r14, %rax
movzwl 0x2470(%rax), %eax
cmpl %r12d, %eax
jbe 0x4682b
cmpl %eax, %esi
cmovbl %esi, %eax
subl %r12d, %eax
testq %r15, %r15
movq %r15, %rcx
cmoveq %r14, %rcx
movl %r12d, %edx
leaq 0x18(%rcx,%rdx), %rsi
movzwl %ax, %ebx
movq -0x24d8(%rbp), %r13
movq %r13, %rdi
movq %rbx, %rdx
callq 0x29090
movq -0x24d0(%rbp), %rax
movl %eax, %ecx
subl %ebx, %ecx
movl %ecx, -0x24b4(%rbp)
je 0x46ac9
addl %ebx, %r12d
addq %rbx, %r13
movq %r13, -0x24d8(%rbp)
jmp 0x46831
movl %edx, -0x24b4(%rbp)
testq %r15, %r15
cmovneq %r15, %r14
leaq 0x438(%r14), %rax
movq %rax, -0x24c0(%rbp)
movl 0x246c(%r14), %r15d
movzwl 0x2472(%r14), %eax
movzwl %ax, %eax
addl %r15d, %eax
movl %eax, %ebx
subl %r12d, %ebx
jbe 0x468c7
movl -0x24b4(%rbp), %r13d
cmpl %r13d, %ebx
cmovael %r13d, %ebx
movl 0x2468(%r14), %eax
addq 0x2450(%r14), %rax
movl %r12d, %esi
subl %r15d, %esi
addq %rax, %rsi
movq -0x24d8(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x29090
subl %ebx, %r13d
movl %r13d, -0x24b4(%rbp)
je 0x46b20
addl %ebx, %r12d
addq %rbx, %r15
movq %r15, -0x24d8(%rbp)
movzwl 0x2472(%r14), %r15d
addl 0x246c(%r14), %r15d
jmp 0x468ca
movl %eax, %r15d
cmpb $0x0, 0x247c(%r14)
jne 0x46ae2
movl 0x418(%r14), %edx
testl %edx, %edx
je 0x4695d
decl %edx
movl 0x2474(%r14), %ecx
movl 0x2478(%r14), %eax
cmpl %ecx, %edx
je 0x46964
movq 0x8(%r14), %rdx
movq %rcx, %rsi
shlq $0x4, %rsi
movzbl 0x8(%rdx,%rsi), %edx
cmpl %edx, %eax
jne 0x46964
incl %ecx
movl %ecx, 0x2474(%r14)
movl $0x0, 0x2478(%r14)
movq 0x2458(%r14), %rdi
callq 0x472c6
movq 0x8(%r14), %rax
movl 0x2474(%r14), %ecx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdi
movl $0x1, %esi
movq -0x24c0(%rbp), %rdx
movl $0x1, %ecx
callq 0x45f13
movq 0x2450(%r14), %rbx
jmp 0x46998
movl 0x2478(%r14), %eax
incl %eax
movl %eax, 0x2478(%r14)
movq -0x24c0(%rbp), %rdi
callq 0x45fba
testb %al, %al
jne 0x46ae2
movq 0x2450(%r14), %rbx
leaq 0xbb76f1(%rip), %rax # 0xbfe080
cmpq %rax, %rbx
je 0x46ae2
movq %r12, -0x24e0(%rbp)
movl 0x2460(%r14), %r12d
movzbl (%rbx,%r12), %eax
movl %eax, %ecx
andl $0xc0, %ecx
je 0x46a1c
cmpl $0x40, %ecx
je 0x46ada
shrl $0x6, %eax
movw $0x3, %r13w
leaq 0x99443(%rip), %rcx # 0xdfe10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq (%rbx,%r12), %rax
movq %rax, -0x24f0(%rbp)
addq $0x3, %rax
movq %rax, -0x24e8(%rbp)
leaq -0x24e8(%rbp), %rdi
callq 0x4a390
movq -0x24e8(%rbp), %rax
movl %eax, %r13d
subl -0x24f0(%rbp), %r13d
addl $0x2, %r13d
cmpw $0x0, (%rax)
movl $0x0, %eax
cmovnel %eax, %r13d
jmp 0x46a91
cmpl $0x0, 0x418(%r14)
je 0x46ada
movq 0x2458(%r14), %rdi
callq 0x472c6
movq 0x428(%r14), %rdi
movl $0x1, %esi
movq -0x24c0(%rbp), %rdx
movl $0x1, %ecx
callq 0x45f13
movzwl 0x436(%r14), %eax
movw %ax, 0x2472(%r14)
movl 0x2460(%r14), %ecx
movl %ecx, 0x2468(%r14)
movl %r15d, 0x246c(%r14)
movb $0x1, 0x247c(%r14)
movq -0x24e0(%rbp), %r12
jmp 0x46855
movw $0x1, %r13w
movzwl %r12w, %esi
movq %rbx, %rdi
callq 0x45be4
subl %r13d, %eax
movzwl %r13w, %ecx
movw %ax, 0x2472(%r14)
addl %r12d, %ecx
movl %ecx, 0x2468(%r14)
movl %r15d, 0x246c(%r14)
movq -0x24e0(%rbp), %r12
jmp 0x46855
movq -0x24c8(%rbp), %rdi
movq %rax, %rbx
callq 0x4795f
jmp 0x46afd
movb $0x1, 0x247c(%r14)
movq -0x24c8(%rbp), %rdi
callq 0x4795f
movq -0x24d0(%rbp), %rax
subl -0x24b4(%rbp), %eax
movl %eax, %ebx
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x46b35
movl %ebx, %eax
addq $0x24c8, %rsp # imm = 0x24C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x24c8(%rbp), %rdi
callq 0x4795f
movq -0x24d0(%rbp), %rax
jmp 0x46afb
callq 0x29260
|
translog_read_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 24C8h
mov r15, r8
mov [rbp+var_24D8], rcx
mov r12d, esi
mov rax, fs:28h
mov [rbp+var_30], rax
lea esi, [rdx+r12]
test r8, r8
lea r14, [rbp+var_24B0]
mov rax, r8
cmovz rax, r14
mov [rbp+var_24C8], rax
test rdi, rdi
mov [rbp+var_24D0], rdx
jz loc_46789
loc_466AC:
mov dword ptr [rbp+var_24C0], esi
mov [rbp+var_24E0], r12
test r15, r15
mov r13, r15
cmovz r13, r14
add r13, 438h
mov esi, 1
mov rdx, r13
mov ecx, 1
call translog_scanner_init
xor ebx, ebx
test al, al
jnz loc_46AFD
test r15, r15
mov rax, r15
cmovz rax, r14
mov dword ptr [rax+418h], 0
mov ecx, [rax+2460h]
movzx esi, cx
add rcx, [rax+2438h]
mov rdx, [rbp+var_24C8]
mov [rdx], rcx
mov rdi, [rax+2450h]
mov rcx, r13
call translog_read_record_header_from_buffer
cmp eax, 0FFFFFFFFh
jz loc_46AFD
test r15, r15
mov rcx, r15
cmovz rcx, r14
mov [rcx+2470h], ax
movzx edx, word ptr [rcx+432h]
mov [rcx+2468h], edx
movzx edx, word ptr [rcx+434h]
mov [rcx+2472h], dx
movzx eax, ax
mov [rcx+246Ch], eax
mov qword ptr [rcx+2474h], 0
mov byte ptr [rcx+247Ch], 0
mov rdx, [rbp+var_24D0]
mov r12, [rbp+var_24E0]
mov esi, dword ptr [rbp+var_24C0]
jmp short loc_467C0
loc_46789:
test r15, r15
mov rax, r15
cmovz rax, r14
cmp [rax+246Ch], r12d
jbe short loc_467C0
test r15, r15
mov rax, r15
cmovz rax, r14
movzx eax, word ptr [rax+2470h]
cmp eax, r12d
setnbe cl
cmp esi, eax
setb al
test cl, al
jz loc_466AC
loc_467C0:
test r15, r15
mov rax, r15
cmovz rax, r14
movzx eax, word ptr [rax+2470h]
cmp eax, r12d
jbe short loc_4682B
cmp esi, eax
cmovb eax, esi
sub eax, r12d
test r15, r15
mov rcx, r15
cmovz rcx, r14
mov edx, r12d
lea rsi, [rcx+rdx+18h]
movzx ebx, ax
mov r13, [rbp+var_24D8]
mov rdi, r13
mov rdx, rbx
call _memcpy
mov rax, [rbp+var_24D0]
mov ecx, eax
sub ecx, ebx
mov [rbp+var_24B4], ecx
jz loc_46AC9
add r12d, ebx
add r13, rbx
mov [rbp+var_24D8], r13
jmp short loc_46831
loc_4682B:
mov [rbp+var_24B4], edx
loc_46831:
test r15, r15
cmovnz r14, r15
lea rax, [r14+438h]
mov [rbp+var_24C0], rax
mov r15d, [r14+246Ch]
movzx eax, word ptr [r14+2472h]
loc_46855:
movzx eax, ax
add eax, r15d
mov ebx, eax
sub ebx, r12d
jbe short loc_468C7
mov r13d, [rbp+var_24B4]
cmp ebx, r13d
cmovnb ebx, r13d
mov eax, [r14+2468h]
add rax, [r14+2450h]
mov esi, r12d
sub esi, r15d
add rsi, rax
mov r15, [rbp+var_24D8]
mov rdi, r15
mov rdx, rbx
call _memcpy
sub r13d, ebx
mov [rbp+var_24B4], r13d
jz loc_46B20
add r12d, ebx
add r15, rbx
mov [rbp+var_24D8], r15
movzx r15d, word ptr [r14+2472h]
add r15d, [r14+246Ch]
jmp short loc_468CA
loc_468C7:
mov r15d, eax
loc_468CA:
cmp byte ptr [r14+247Ch], 0
jnz loc_46AE2
mov edx, [r14+418h]
test edx, edx
jz short loc_4695D
dec edx
mov ecx, [r14+2474h]
mov eax, [r14+2478h]
cmp edx, ecx
jz short loc_46964
mov rdx, [r14+8]
mov rsi, rcx
shl rsi, 4
movzx edx, byte ptr [rdx+rsi+8]
cmp eax, edx
jnz short loc_46964
inc ecx
mov [r14+2474h], ecx
mov dword ptr [r14+2478h], 0
mov rdi, [r14+2458h]
call translog_free_link
mov rax, [r14+8]
mov ecx, [r14+2474h]
shl rcx, 4
mov rdi, [rax+rcx]
mov esi, 1
mov rdx, [rbp+var_24C0]
mov ecx, 1
call translog_scanner_init
mov rbx, [r14+2450h]
jmp short loc_46998
loc_4695D:
mov eax, [r14+2478h]
loc_46964:
inc eax
mov [r14+2478h], eax
mov rdi, [rbp+var_24C0]
call translog_get_next_chunk
test al, al
jnz loc_46AE2
mov rbx, [r14+2450h]
lea rax, end_of_log
cmp rbx, rax
jz loc_46AE2
loc_46998:
mov [rbp+var_24E0], r12
mov r12d, [r14+2460h]
movzx eax, byte ptr [rbx+r12]
mov ecx, eax
and ecx, 0C0h
jz short loc_46A1C
cmp ecx, 40h ; '@'
jz loc_46ADA
shr eax, 6
mov r13w, 3
lea rcx, jpt_469D4
movsxd rax, ds:(jpt_469D4 - 0DFE10h)[rcx+rax*4]; switch 4 cases
add rax, rcx
jmp rax; switch jump
loc_469D6:
lea rax, [rbx+r12]; jumptable 00000000000469D4 case 0
mov [rbp+var_24F0], rax
add rax, 3
mov [rbp+var_24E8], rax
lea rdi, [rbp+var_24E8]
call translog_variable_record_1group_decode_len
mov rax, [rbp+var_24E8]
mov r13d, eax
sub r13d, dword ptr [rbp+var_24F0]
add r13d, 2
cmp word ptr [rax], 0
mov eax, 0
cmovnz r13d, eax
jmp short loc_46A91; jumptable 00000000000469D4 cases 1,3
loc_46A1C:
cmp dword ptr [r14+418h], 0
jz loc_46ADA
mov rdi, [r14+2458h]
call translog_free_link
mov rdi, [r14+428h]
mov esi, 1
mov rdx, [rbp+var_24C0]
mov ecx, 1
call translog_scanner_init
movzx eax, word ptr [r14+436h]
mov [r14+2472h], ax
mov ecx, [r14+2460h]
mov [r14+2468h], ecx
mov [r14+246Ch], r15d
mov byte ptr [r14+247Ch], 1
mov r12, [rbp+var_24E0]
jmp loc_46855
loc_46A8C:
mov r13w, 1; jumptable 00000000000469D4 case 2
loc_46A91:
movzx esi, r12w; jumptable 00000000000469D4 cases 1,3
mov rdi, rbx
call translog_get_total_chunk_length
sub eax, r13d
movzx ecx, r13w
mov [r14+2472h], ax
add ecx, r12d
mov [r14+2468h], ecx
mov [r14+246Ch], r15d
mov r12, [rbp+var_24E0]
jmp loc_46855
loc_46AC9:
mov rdi, [rbp+var_24C8]
mov rbx, rax
call translog_destroy_reader_data
jmp short loc_46AFD
loc_46ADA:
mov byte ptr [r14+247Ch], 1
loc_46AE2:
mov rdi, [rbp+var_24C8]
call translog_destroy_reader_data
mov rax, [rbp+var_24D0]
sub eax, [rbp+var_24B4]
loc_46AFB:
mov ebx, eax
loc_46AFD:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_46B35
mov eax, ebx
add rsp, 24C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_46B20:
mov rdi, [rbp+var_24C8]
call translog_destroy_reader_data
mov rax, [rbp+var_24D0]
jmp short loc_46AFB
loc_46B35:
call ___stack_chk_fail
|
long long translog_read_record(long long a1, unsigned int a2, long long a3, long long a4, _BYTE *a5)
{
long long v6; // r12
unsigned int v7; // esi
_BYTE *v8; // r14
_BYTE *v9; // rax
_BYTE *v10; // r13
long long v11; // r13
unsigned int v12; // ebx
_BYTE *v13; // rax
long long v14; // rcx
_QWORD *v15; // rdx
int record_header_from_buffer; // eax
_BYTE *v17; // rcx
_BYTE *v18; // rax
_BYTE *v19; // rax
_BYTE *v20; // rax
unsigned int v21; // eax
unsigned __int16 v22; // ax
_BYTE *v23; // rcx
long long v24; // rbx
int v25; // r15d
unsigned __int16 v26; // ax
unsigned int v27; // eax
long long v28; // rbx
unsigned int v29; // r13d
long long v30; // rsi
long long v31; // r15
int v32; // edx
long long v33; // rcx
int v34; // eax
_BYTE *v35; // rbx
long long v36; // r12
unsigned __int16 v37; // r13
_WORD *v40; // [rsp+8h] [rbp-24E8h] BYREF
long long v41; // [rsp+10h] [rbp-24E0h]
long long v42; // [rsp+18h] [rbp-24D8h]
long long v43; // [rsp+20h] [rbp-24D0h]
_QWORD *v44; // [rsp+28h] [rbp-24C8h]
_BYTE *v45; // [rsp+30h] [rbp-24C0h]
unsigned int v46; // [rsp+3Ch] [rbp-24B4h]
_BYTE v47[9344]; // [rsp+40h] [rbp-24B0h] BYREF
unsigned long long v48; // [rsp+24C0h] [rbp-30h]
v42 = a4;
v6 = a2;
v48 = __readfsqword(0x28u);
v7 = a3 + a2;
v8 = v47;
v9 = a5;
if ( !a5 )
v9 = v47;
v44 = v9;
v43 = a3;
if ( a1 )
goto LABEL_4;
v18 = a5;
if ( !a5 )
v18 = v47;
if ( *((_DWORD *)v18 + 2331) > (unsigned int)v6 )
{
v19 = a5;
if ( !a5 )
v19 = v47;
if ( v7 >= *((unsigned __int16 *)v19 + 4664) || *((unsigned __int16 *)v19 + 4664) <= (unsigned int)v6 )
{
LABEL_4:
LODWORD(v45) = v7;
v41 = v6;
v10 = a5;
if ( !a5 )
v10 = v47;
v11 = (long long)(v10 + 1080);
v12 = 0;
if ( translog_scanner_init(a1, 1, v11, 1) )
return v12;
v13 = a5;
if ( !a5 )
v13 = v47;
*((_DWORD *)v13 + 262) = 0;
v14 = *((unsigned int *)v13 + 2328);
v15 = v44;
*v44 = *((_QWORD *)v13 + 1159) + v14;
record_header_from_buffer = translog_read_record_header_from_buffer(
*((_QWORD *)v13 + 1162),
(unsigned __int16)v14,
v15,
v11);
if ( record_header_from_buffer == -1 )
return v12;
v17 = a5;
if ( !a5 )
v17 = v47;
*((_WORD *)v17 + 4664) = record_header_from_buffer;
*((_DWORD *)v17 + 2330) = *((unsigned __int16 *)v17 + 537);
*((_WORD *)v17 + 4665) = *((_WORD *)v17 + 538);
*((_DWORD *)v17 + 2331) = (unsigned __int16)record_header_from_buffer;
*(_QWORD *)(v17 + 9332) = 0LL;
v17[9340] = 0;
LODWORD(a3) = v43;
v6 = v41;
v7 = (unsigned int)v45;
}
}
v20 = a5;
if ( !a5 )
v20 = v47;
v21 = *((unsigned __int16 *)v20 + 4664);
if ( v21 <= (unsigned int)v6 )
{
v46 = a3;
}
else
{
if ( v7 < v21 )
LOWORD(v21) = v7;
v22 = v21 - v6;
v23 = a5;
if ( !a5 )
v23 = v47;
v24 = v22;
memcpy(v42, &v23[(unsigned int)v6 + 24], v22);
v46 = v43 - v24;
if ( (_DWORD)v43 == (_DWORD)v24 )
{
v12 = v43;
translog_destroy_reader_data(v44);
return v12;
}
v6 = (unsigned int)(v24 + v6);
v42 += v24;
}
if ( a5 )
v8 = a5;
v45 = v8 + 1080;
v25 = *((_DWORD *)v8 + 2331);
v26 = *((_WORD *)v8 + 4665);
while ( 1 )
{
v27 = v25 + v26;
v28 = v27 - (unsigned int)v6;
if ( v27 > (unsigned int)v6 )
break;
v25 = v27;
LABEL_38:
if ( v8[9340] )
goto LABEL_58;
v32 = *((_DWORD *)v8 + 262);
if ( !v32 )
{
v34 = *((_DWORD *)v8 + 2334);
LABEL_44:
*((_DWORD *)v8 + 2334) = v34 + 1;
if ( translog_get_next_chunk((long long)v45) )
goto LABEL_58;
v35 = (_BYTE *)*((_QWORD *)v8 + 1162);
if ( v35 == (_BYTE *)&end_of_log )
goto LABEL_58;
goto LABEL_46;
}
v33 = *((unsigned int *)v8 + 2333);
v34 = *((_DWORD *)v8 + 2334);
if ( v32 - 1 == (_DWORD)v33 || v34 != *(unsigned __int8 *)(*((_QWORD *)v8 + 1) + 16 * v33 + 8) )
goto LABEL_44;
*(_QWORD *)(v8 + 9332) = (unsigned int)(v33 + 1);
translog_free_link(*((_QWORD *)v8 + 1163));
translog_scanner_init(*(_QWORD *)(*((_QWORD *)v8 + 1) + 16LL * *((unsigned int *)v8 + 2333)), 1, (long long)v45, 1);
v35 = (_BYTE *)*((_QWORD *)v8 + 1162);
LABEL_46:
v41 = v6;
v36 = *((unsigned int *)v8 + 2328);
if ( (v35[v36] & 0xC0) != 0 )
{
if ( (v35[v36] & 0xC0) == 0x40 )
goto LABEL_57;
v37 = 3;
switch ( (unsigned __int8)v35[v36] >> 6 )
{
case 0:
v40 = &v35[v36 + 3];
translog_variable_record_1group_decode_len(&v40);
v37 = (_WORD)v40 - ((_WORD)v35 + v36) + 2;
if ( *v40 )
v37 = 0;
break;
case 1:
case 3:
break;
case 2:
v37 = 1;
break;
}
v26 = translog_get_total_chunk_length((long long)v35, (unsigned __int16)v36) - v37;
*((_WORD *)v8 + 4665) = v26;
*((_DWORD *)v8 + 2330) = v36 + v37;
*((_DWORD *)v8 + 2331) = v25;
v6 = v41;
}
else
{
if ( !*((_DWORD *)v8 + 262) )
{
LABEL_57:
v8[9340] = 1;
LABEL_58:
translog_destroy_reader_data(v44);
return (unsigned int)(v43 - v46);
}
translog_free_link(*((_QWORD *)v8 + 1163));
translog_scanner_init(*((_QWORD *)v8 + 133), 1, (long long)v45, 1);
v26 = *((_WORD *)v8 + 539);
*((_WORD *)v8 + 4665) = v26;
*((_DWORD *)v8 + 2330) = *((_DWORD *)v8 + 2328);
*((_DWORD *)v8 + 2331) = v25;
v8[9340] = 1;
v6 = v41;
}
}
v29 = v46;
if ( (unsigned int)v28 >= v46 )
v28 = v46;
v30 = *((_QWORD *)v8 + 1162) + *((unsigned int *)v8 + 2330) + (unsigned int)(v6 - v25);
v31 = v42;
memcpy(v42, v30, v28);
v46 = v29 - v28;
if ( v29 != (_DWORD)v28 )
{
v6 = (unsigned int)(v28 + v6);
v42 = v28 + v31;
v25 = *((_DWORD *)v8 + 2331) + *((unsigned __int16 *)v8 + 4665);
goto LABEL_38;
}
translog_destroy_reader_data(v44);
return (unsigned int)v43;
}
|
translog_read_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x24c8
MOV R15,R8
MOV qword ptr [RBP + -0x24d8],RCX
MOV R12D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA ESI,[RDX + R12*0x1]
TEST R8,R8
LEA R14,[RBP + -0x24b0]
MOV RAX,R8
CMOVZ RAX,R14
MOV qword ptr [RBP + -0x24c8],RAX
TEST RDI,RDI
MOV qword ptr [RBP + -0x24d0],RDX
JZ 0x00146789
LAB_001466ac:
MOV dword ptr [RBP + -0x24c0],ESI
MOV qword ptr [RBP + -0x24e0],R12
TEST R15,R15
MOV R13,R15
CMOVZ R13,R14
ADD R13,0x438
MOV ESI,0x1
MOV RDX,R13
MOV ECX,0x1
CALL 0x00145f13
XOR EBX,EBX
TEST AL,AL
JNZ 0x00146afd
TEST R15,R15
MOV RAX,R15
CMOVZ RAX,R14
MOV dword ptr [RAX + 0x418],0x0
MOV ECX,dword ptr [RAX + 0x2460]
MOVZX ESI,CX
ADD RCX,qword ptr [RAX + 0x2438]
MOV RDX,qword ptr [RBP + -0x24c8]
MOV qword ptr [RDX],RCX
MOV RDI,qword ptr [RAX + 0x2450]
MOV RCX,R13
CALL 0x001472f8
CMP EAX,-0x1
JZ 0x00146afd
TEST R15,R15
MOV RCX,R15
CMOVZ RCX,R14
MOV word ptr [RCX + 0x2470],AX
MOVZX EDX,word ptr [RCX + 0x432]
MOV dword ptr [RCX + 0x2468],EDX
MOVZX EDX,word ptr [RCX + 0x434]
MOV word ptr [RCX + 0x2472],DX
MOVZX EAX,AX
MOV dword ptr [RCX + 0x246c],EAX
MOV qword ptr [RCX + 0x2474],0x0
MOV byte ptr [RCX + 0x247c],0x0
MOV RDX,qword ptr [RBP + -0x24d0]
MOV R12,qword ptr [RBP + -0x24e0]
MOV ESI,dword ptr [RBP + -0x24c0]
JMP 0x001467c0
LAB_00146789:
TEST R15,R15
MOV RAX,R15
CMOVZ RAX,R14
CMP dword ptr [RAX + 0x246c],R12D
JBE 0x001467c0
TEST R15,R15
MOV RAX,R15
CMOVZ RAX,R14
MOVZX EAX,word ptr [RAX + 0x2470]
CMP EAX,R12D
SETA CL
CMP ESI,EAX
SETC AL
TEST CL,AL
JZ 0x001466ac
LAB_001467c0:
TEST R15,R15
MOV RAX,R15
CMOVZ RAX,R14
MOVZX EAX,word ptr [RAX + 0x2470]
CMP EAX,R12D
JBE 0x0014682b
CMP ESI,EAX
CMOVC EAX,ESI
SUB EAX,R12D
TEST R15,R15
MOV RCX,R15
CMOVZ RCX,R14
MOV EDX,R12D
LEA RSI,[RCX + RDX*0x1 + 0x18]
MOVZX EBX,AX
MOV R13,qword ptr [RBP + -0x24d8]
MOV RDI,R13
MOV RDX,RBX
CALL 0x00129090
MOV RAX,qword ptr [RBP + -0x24d0]
MOV ECX,EAX
SUB ECX,EBX
MOV dword ptr [RBP + -0x24b4],ECX
JZ 0x00146ac9
ADD R12D,EBX
ADD R13,RBX
MOV qword ptr [RBP + -0x24d8],R13
JMP 0x00146831
LAB_0014682b:
MOV dword ptr [RBP + -0x24b4],EDX
LAB_00146831:
TEST R15,R15
CMOVNZ R14,R15
LEA RAX,[R14 + 0x438]
MOV qword ptr [RBP + -0x24c0],RAX
MOV R15D,dword ptr [R14 + 0x246c]
MOVZX EAX,word ptr [R14 + 0x2472]
LAB_00146855:
MOVZX EAX,AX
ADD EAX,R15D
MOV EBX,EAX
SUB EBX,R12D
JBE 0x001468c7
MOV R13D,dword ptr [RBP + -0x24b4]
CMP EBX,R13D
CMOVNC EBX,R13D
MOV EAX,dword ptr [R14 + 0x2468]
ADD RAX,qword ptr [R14 + 0x2450]
MOV ESI,R12D
SUB ESI,R15D
ADD RSI,RAX
MOV R15,qword ptr [RBP + -0x24d8]
MOV RDI,R15
MOV RDX,RBX
CALL 0x00129090
SUB R13D,EBX
MOV dword ptr [RBP + -0x24b4],R13D
JZ 0x00146b20
ADD R12D,EBX
ADD R15,RBX
MOV qword ptr [RBP + -0x24d8],R15
MOVZX R15D,word ptr [R14 + 0x2472]
ADD R15D,dword ptr [R14 + 0x246c]
JMP 0x001468ca
LAB_001468c7:
MOV R15D,EAX
LAB_001468ca:
CMP byte ptr [R14 + 0x247c],0x0
JNZ 0x00146ae2
MOV EDX,dword ptr [R14 + 0x418]
TEST EDX,EDX
JZ 0x0014695d
DEC EDX
MOV ECX,dword ptr [R14 + 0x2474]
MOV EAX,dword ptr [R14 + 0x2478]
CMP EDX,ECX
JZ 0x00146964
MOV RDX,qword ptr [R14 + 0x8]
MOV RSI,RCX
SHL RSI,0x4
MOVZX EDX,byte ptr [RDX + RSI*0x1 + 0x8]
CMP EAX,EDX
JNZ 0x00146964
INC ECX
MOV dword ptr [R14 + 0x2474],ECX
MOV dword ptr [R14 + 0x2478],0x0
MOV RDI,qword ptr [R14 + 0x2458]
CALL 0x001472c6
MOV RAX,qword ptr [R14 + 0x8]
MOV ECX,dword ptr [R14 + 0x2474]
SHL RCX,0x4
MOV RDI,qword ptr [RAX + RCX*0x1]
MOV ESI,0x1
MOV RDX,qword ptr [RBP + -0x24c0]
MOV ECX,0x1
CALL 0x00145f13
MOV RBX,qword ptr [R14 + 0x2450]
JMP 0x00146998
LAB_0014695d:
MOV EAX,dword ptr [R14 + 0x2478]
LAB_00146964:
INC EAX
MOV dword ptr [R14 + 0x2478],EAX
MOV RDI,qword ptr [RBP + -0x24c0]
CALL 0x00145fba
TEST AL,AL
JNZ 0x00146ae2
MOV RBX,qword ptr [R14 + 0x2450]
LEA RAX,[0xcfe080]
CMP RBX,RAX
JZ 0x00146ae2
LAB_00146998:
MOV qword ptr [RBP + -0x24e0],R12
MOV R12D,dword ptr [R14 + 0x2460]
MOVZX EAX,byte ptr [RBX + R12*0x1]
MOV ECX,EAX
AND ECX,0xc0
JZ 0x00146a1c
CMP ECX,0x40
JZ 0x00146ada
SHR EAX,0x6
MOV R13W,0x3
LEA RCX,[0x1dfe10]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
JMP RAX
LAB_00146a1c:
CMP dword ptr [R14 + 0x418],0x0
JZ 0x00146ada
MOV RDI,qword ptr [R14 + 0x2458]
CALL 0x001472c6
MOV RDI,qword ptr [R14 + 0x428]
MOV ESI,0x1
MOV RDX,qword ptr [RBP + -0x24c0]
MOV ECX,0x1
CALL 0x00145f13
MOVZX EAX,word ptr [R14 + 0x436]
MOV word ptr [R14 + 0x2472],AX
MOV ECX,dword ptr [R14 + 0x2460]
MOV dword ptr [R14 + 0x2468],ECX
MOV dword ptr [R14 + 0x246c],R15D
MOV byte ptr [R14 + 0x247c],0x1
MOV R12,qword ptr [RBP + -0x24e0]
JMP 0x00146855
LAB_00146ac9:
MOV RDI,qword ptr [RBP + -0x24c8]
MOV RBX,RAX
CALL 0x0014795f
JMP 0x00146afd
LAB_00146ada:
MOV byte ptr [R14 + 0x247c],0x1
LAB_00146ae2:
MOV RDI,qword ptr [RBP + -0x24c8]
CALL 0x0014795f
MOV RAX,qword ptr [RBP + -0x24d0]
SUB EAX,dword ptr [RBP + -0x24b4]
LAB_00146afb:
MOV EBX,EAX
LAB_00146afd:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00146b35
MOV EAX,EBX
ADD RSP,0x24c8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00146b20:
MOV RDI,qword ptr [RBP + -0x24c8]
CALL 0x0014795f
MOV RAX,qword ptr [RBP + -0x24d0]
JMP 0x00146afb
LAB_00146b35:
CALL 0x00129260
|
ulong translog_read_record(long param_1,uint param_2,uint param_3,void *param_4,long *param_5)
{
byte bVar1;
char cVar2;
ushort uVar3;
uint uVar4;
uint uVar5;
long *plVar6;
long *plVar7;
long *plVar8;
ulong uVar9;
uint uVar10;
int1 *puVar11;
uint uVar12;
uint uVar13;
long in_FS_OFFSET;
void *local_24e0;
uint local_24bc;
long local_24b8 [1168];
long local_38;
uVar9 = (ulong)param_2;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar12 = param_3 + param_2;
plVar6 = param_5;
if (param_5 == (long *)0x0) {
plVar6 = local_24b8;
}
if (param_1 == 0) {
plVar8 = param_5;
if (param_5 == (long *)0x0) {
plVar8 = local_24b8;
}
if (param_2 < *(uint *)((long)plVar8 + 0x246c)) {
plVar8 = param_5;
if (param_5 == (long *)0x0) {
plVar8 = local_24b8;
}
if (*(ushort *)(plVar8 + 0x48e) <= param_2 || *(ushort *)(plVar8 + 0x48e) <= uVar12)
goto LAB_001466ac;
}
}
else {
LAB_001466ac:
plVar8 = param_5;
if (param_5 == (long *)0x0) {
plVar8 = local_24b8;
}
cVar2 = translog_scanner_init(param_1,1,plVar8 + 0x87,1);
uVar10 = 0;
if (cVar2 != '\0') goto LAB_00146afd;
plVar7 = param_5;
if (param_5 == (long *)0x0) {
plVar7 = local_24b8;
}
*(int4 *)(plVar7 + 0x83) = 0;
uVar4 = *(uint *)(plVar7 + 0x48c);
*plVar6 = (ulong)uVar4 + plVar7[0x487];
uVar4 = translog_read_record_header_from_buffer(plVar7[0x48a],(short)uVar4,plVar6,plVar8 + 0x87)
;
if (uVar4 == 0xffffffff) goto LAB_00146afd;
plVar8 = param_5;
if (param_5 == (long *)0x0) {
plVar8 = local_24b8;
}
*(short *)(plVar8 + 0x48e) = (short)uVar4;
*(uint *)(plVar8 + 0x48d) = (uint)*(ushort *)((long)plVar8 + 0x432);
*(int2 *)((long)plVar8 + 0x2472) = *(int2 *)((long)plVar8 + 0x434);
*(uint *)((long)plVar8 + 0x246c) = uVar4 & 0xffff;
*(int8 *)((long)plVar8 + 0x2474) = 0;
*(int1 *)((long)plVar8 + 0x247c) = 0;
}
plVar8 = param_5;
if (param_5 == (long *)0x0) {
plVar8 = local_24b8;
}
uVar3 = *(ushort *)(plVar8 + 0x48e);
local_24e0 = param_4;
local_24bc = param_3;
uVar10 = param_3;
if (param_2 < uVar3) {
uVar4 = (uint)uVar3;
if (uVar12 < uVar3) {
uVar4 = uVar12;
}
plVar8 = param_5;
if (param_5 == (long *)0x0) {
plVar8 = local_24b8;
}
uVar12 = uVar4 - param_2 & 0xffff;
memcpy(param_4,(void *)((long)plVar8 + uVar9 + 0x18),(ulong)uVar12);
local_24bc = param_3 - uVar12;
if (local_24bc == 0) {
translog_destroy_reader_data(plVar6);
goto LAB_00146afd;
}
uVar9 = (ulong)(param_2 + uVar12);
local_24e0 = (void *)((long)param_4 + (ulong)uVar12);
}
plVar8 = local_24b8;
if (param_5 != (long *)0x0) {
plVar8 = param_5;
}
plVar7 = plVar8 + 0x87;
uVar12 = *(uint *)((long)plVar8 + 0x246c);
uVar3 = *(ushort *)((long)plVar8 + 0x2472);
LAB_00146855:
uVar5 = uVar3 + uVar12;
uVar13 = (uint)uVar9;
uVar4 = uVar5 - uVar13;
if (uVar13 <= uVar5 && uVar4 != 0) {
if (local_24bc <= uVar4) {
uVar4 = local_24bc;
}
memcpy(local_24e0,
(void *)((ulong)(uVar13 - uVar12) + (ulong)*(uint *)(plVar8 + 0x48d) + plVar8[0x48a]),
(ulong)uVar4);
local_24bc = local_24bc - uVar4;
if (local_24bc == 0) {
translog_destroy_reader_data(plVar6);
goto LAB_00146afd;
}
uVar9 = (ulong)(uVar13 + uVar4);
local_24e0 = (void *)((long)local_24e0 + (ulong)uVar4);
uVar5 = (uint)*(ushort *)((long)plVar8 + 0x2472) + *(int *)((long)plVar8 + 0x246c);
}
uVar12 = uVar5;
if (*(char *)((long)plVar8 + 0x247c) != '\0') goto LAB_00146ae2;
if ((int)plVar8[0x83] == 0) {
uVar4 = *(uint *)(plVar8 + 0x48f);
LAB_00146964:
*(uint *)(plVar8 + 0x48f) = uVar4 + 1;
cVar2 = translog_get_next_chunk(plVar7);
if ((cVar2 != '\0') || (puVar11 = (int1 *)plVar8[0x48a], puVar11 == &end_of_log))
goto LAB_00146ae2;
}
else {
uVar5 = *(uint *)((long)plVar8 + 0x2474);
uVar4 = *(uint *)(plVar8 + 0x48f);
if (((int)plVar8[0x83] - 1U == uVar5) ||
(uVar4 != *(byte *)(plVar8[1] + 8 + (ulong)uVar5 * 0x10))) goto LAB_00146964;
*(uint *)((long)plVar8 + 0x2474) = uVar5 + 1;
*(int4 *)(plVar8 + 0x48f) = 0;
translog_free_link(plVar8[0x48b]);
translog_scanner_init
(*(int8 *)(plVar8[1] + (ulong)*(uint *)((long)plVar8 + 0x2474) * 0x10),1,plVar7,
1);
puVar11 = (int1 *)plVar8[0x48a];
}
bVar1 = puVar11[*(uint *)(plVar8 + 0x48c)];
if ((bVar1 & 0xc0) == 0) {
if ((int)plVar8[0x83] == 0) goto LAB_00146ada;
translog_free_link(plVar8[0x48b]);
translog_scanner_init(plVar8[0x85],1,plVar7,1);
uVar3 = *(ushort *)((long)plVar8 + 0x436);
*(ushort *)((long)plVar8 + 0x2472) = uVar3;
*(int *)(plVar8 + 0x48d) = (int)plVar8[0x48c];
*(uint *)((long)plVar8 + 0x246c) = uVar12;
*(int1 *)((long)plVar8 + 0x247c) = 1;
goto LAB_00146855;
}
if ((bVar1 & 0xc0) != 0x40) {
/* WARNING: Could not recover jumptable at 0x001469d4. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar9 = (*(code *)(&DAT_001dfe10 + *(int *)(&DAT_001dfe10 + (ulong)(bVar1 >> 6) * 4)))();
return uVar9;
}
LAB_00146ada:
*(int1 *)((long)plVar8 + 0x247c) = 1;
LAB_00146ae2:
translog_destroy_reader_data(plVar6);
uVar10 = param_3 - local_24bc;
LAB_00146afd:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (ulong)uVar10;
}
|
|
17,265
|
google::protobuf::compiler::objectivec::HasNonZeroDefaultValue(google::protobuf::FieldDescriptor const*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/objectivec/objectivec_helpers.cc
|
bool HasNonZeroDefaultValue(const FieldDescriptor* field) {
// Repeated fields don't have defaults.
if (field->is_repeated()) {
return false;
}
// As much as checking field->has_default_value() seems useful, it isn't
// because of enums. proto2 syntax allows the first item in an enum (the
// default) to be non zero. So checking field->has_default_value() would
// result in missing this non zero default. See MessageWithOneBasedEnum in
// objectivec/Tests/unittest_objc.proto for a test Message to confirm this.
// Some proto file set the default to the zero value, so make sure the value
// isn't the zero case.
switch (field->cpp_type()) {
case FieldDescriptor::CPPTYPE_INT32:
return field->default_value_int32() != 0;
case FieldDescriptor::CPPTYPE_UINT32:
return field->default_value_uint32() != 0U;
case FieldDescriptor::CPPTYPE_INT64:
return field->default_value_int64() != 0LL;
case FieldDescriptor::CPPTYPE_UINT64:
return field->default_value_uint64() != 0ULL;
case FieldDescriptor::CPPTYPE_DOUBLE:
return field->default_value_double() != 0.0;
case FieldDescriptor::CPPTYPE_FLOAT:
return field->default_value_float() != 0.0f;
case FieldDescriptor::CPPTYPE_BOOL:
return field->default_value_bool();
case FieldDescriptor::CPPTYPE_STRING: {
const std::string& default_string = field->default_value_string();
return default_string.length() != 0;
}
case FieldDescriptor::CPPTYPE_ENUM:
return field->default_value_enum()->number() != 0;
case FieldDescriptor::CPPTYPE_MESSAGE:
return false;
}
// Some compilers report reaching end of function even though all cases of
// the enum are handed in the switch.
GOOGLE_LOG(FATAL) << "Can't get here.";
return false;
}
|
O0
|
cpp
|
google::protobuf::compiler::objectivec::HasNonZeroDefaultValue(google::protobuf::FieldDescriptor const*):
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x58050
testb $0x1, %al
jne 0x86ea9
jmp 0x86eb3
movb $0x0, 0x77(%rsp)
jmp 0x87072
movq 0x68(%rsp), %rdi
callq 0x58090
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x9, %eax
ja 0x87000
movq 0x10(%rsp), %rax
leaq 0x3298c1(%rip), %rcx # 0x3b079c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x68(%rsp), %rdi
callq 0x580c0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0x87072
movq 0x68(%rsp), %rdi
callq 0x580e0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0x87072
movq 0x68(%rsp), %rdi
callq 0x580d0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0x87072
movq 0x68(%rsp), %rdi
callq 0x580f0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0x87072
movq 0x68(%rsp), %rdi
callq 0x58110
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0x87072
movq 0x68(%rsp), %rdi
callq 0x58100
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0x87072
movq 0x68(%rsp), %rdi
callq 0x58120
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0x87072
movq 0x68(%rsp), %rdi
callq 0x58a20
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x21650
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0x87072
movq 0x68(%rsp), %rdi
callq 0x24eb30
movq %rax, %rdi
callq 0x580b0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0x87072
movb $0x0, 0x77(%rsp)
jmp 0x87072
leaq 0x3299f3(%rip), %rdx # 0x3b09fa
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x3, %esi
movl $0x482, %ecx # imm = 0x482
callq 0x219560
movq (%rsp), %rdi
leaq 0x3246b4(%rip), %rsi # 0x3ab6de
callq 0x218e20
movq %rax, 0x8(%rsp)
jmp 0x87036
movq 0x8(%rsp), %rsi
leaq 0x1b(%rsp), %rdi
callq 0x218fd0
jmp 0x87047
leaq 0x28(%rsp), %rdi
callq 0x2195a0
movb $0x0, 0x77(%rsp)
jmp 0x87072
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2195a0
jmp 0x8707d
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x21700
nopw (%rax,%rax)
|
_ZN6google8protobuf8compiler10objectivec22HasNonZeroDefaultValueEPKNS0_15FieldDescriptorE:
sub rsp, 78h
mov [rsp+78h+var_10], rdi
mov rdi, [rsp+78h+var_10]; this
call _ZNK6google8protobuf15FieldDescriptor11is_repeatedEv; google::protobuf::FieldDescriptor::is_repeated(void)
test al, 1
jnz short loc_86EA9
jmp short loc_86EB3
loc_86EA9:
mov [rsp+78h+var_1], 0
jmp loc_87072
loc_86EB3:
mov rdi, [rsp+78h+var_10]; this
call _ZNK6google8protobuf15FieldDescriptor8cpp_typeEv; google::protobuf::FieldDescriptor::cpp_type(void)
dec eax; switch 10 cases
mov ecx, eax
mov [rsp+78h+var_68], rcx
sub eax, 9
ja def_86EE2; jumptable 0000000000086EE2 default case
mov rax, [rsp+78h+var_68]
lea rcx, jpt_86EE2
movsxd rax, ds:(jpt_86EE2 - 3B079Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_86EE4:
mov rdi, [rsp+78h+var_10]; jumptable 0000000000086EE2 case 1
call _ZNK6google8protobuf15FieldDescriptor19default_value_int32Ev; google::protobuf::FieldDescriptor::default_value_int32(void)
cmp eax, 0
setnz al
and al, 1
mov [rsp+78h+var_1], al
jmp loc_87072
loc_86EFF:
mov rdi, [rsp+78h+var_10]; jumptable 0000000000086EE2 case 3
call _ZNK6google8protobuf15FieldDescriptor20default_value_uint32Ev; google::protobuf::FieldDescriptor::default_value_uint32(void)
cmp eax, 0
setnz al
and al, 1
mov [rsp+78h+var_1], al
jmp loc_87072
loc_86F1A:
mov rdi, [rsp+78h+var_10]; jumptable 0000000000086EE2 case 2
call _ZNK6google8protobuf15FieldDescriptor19default_value_int64Ev; google::protobuf::FieldDescriptor::default_value_int64(void)
cmp rax, 0
setnz al
and al, 1
mov [rsp+78h+var_1], al
jmp loc_87072
loc_86F36:
mov rdi, [rsp+78h+var_10]; jumptable 0000000000086EE2 case 4
call _ZNK6google8protobuf15FieldDescriptor20default_value_uint64Ev; google::protobuf::FieldDescriptor::default_value_uint64(void)
cmp rax, 0
setnz al
and al, 1
mov [rsp+78h+var_1], al
jmp loc_87072
loc_86F52:
mov rdi, [rsp+78h+var_10]; jumptable 0000000000086EE2 case 5
call _ZNK6google8protobuf15FieldDescriptor20default_value_doubleEv; google::protobuf::FieldDescriptor::default_value_double(void)
xorps xmm1, xmm1
ucomisd xmm0, xmm1
setnz al
setp cl
or al, cl
and al, 1
mov [rsp+78h+var_1], al
jmp loc_87072
loc_86F76:
mov rdi, [rsp+78h+var_10]; jumptable 0000000000086EE2 case 6
call _ZNK6google8protobuf15FieldDescriptor19default_value_floatEv; google::protobuf::FieldDescriptor::default_value_float(void)
xorps xmm1, xmm1
ucomiss xmm0, xmm1
setnz al
setp cl
or al, cl
and al, 1
mov [rsp+78h+var_1], al
jmp loc_87072
loc_86F99:
mov rdi, [rsp+78h+var_10]; jumptable 0000000000086EE2 case 7
call _ZNK6google8protobuf15FieldDescriptor18default_value_boolEv; google::protobuf::FieldDescriptor::default_value_bool(void)
and al, 1
mov [rsp+78h+var_1], al
jmp loc_87072
loc_86FAE:
mov rdi, [rsp+78h+var_10]; jumptable 0000000000086EE2 case 9
call _ZNK6google8protobuf15FieldDescriptor20default_value_stringB5cxx11Ev; google::protobuf::FieldDescriptor::default_value_string(void)
mov [rsp+78h+var_18], rax
mov rdi, [rsp+78h+var_18]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
cmp rax, 0
setnz al
and al, 1
mov [rsp+78h+var_1], al
jmp loc_87072
loc_86FD9:
mov rdi, [rsp+78h+var_10]; jumptable 0000000000086EE2 case 8
call _ZNK6google8protobuf15FieldDescriptor18default_value_enumEv; google::protobuf::FieldDescriptor::default_value_enum(void)
mov rdi, rax; this
call _ZNK6google8protobuf19EnumValueDescriptor6numberEv; google::protobuf::EnumValueDescriptor::number(void)
cmp eax, 0
setnz al
and al, 1
mov [rsp+78h+var_1], al
jmp short loc_87072
loc_86FF9:
mov [rsp+78h+var_1], 0; jumptable 0000000000086EE2 case 10
jmp short loc_87072
def_86EE2:
lea rdx, aWorkspaceLlm4b_10; jumptable 0000000000086EE2 default case
lea rdi, [rsp+78h+var_50]
mov [rsp+78h+var_78], rdi
mov esi, 3
mov ecx, 482h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+78h+var_78]
lea rsi, aCanTGetHere; "Can't get here."
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+78h+var_70], rax
jmp short $+2
loc_87036:
mov rsi, [rsp+78h+var_70]
lea rdi, [rsp+78h+var_5D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_87047:
lea rdi, [rsp+78h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov [rsp+78h+var_1], 0
jmp short loc_87072
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
lea rdi, [rsp+arg_20]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_8707D
loc_87072:
mov al, [rsp+78h+var_1]
and al, 1
add rsp, 78h
retn
loc_8707D:
mov rdi, [rsp+arg_18]
call __Unwind_Resume
|
char google::protobuf::compiler::objectivec::HasNonZeroDefaultValue(
google::protobuf::compiler::objectivec *this,
const google::protobuf::FieldDescriptor *a2)
{
google::protobuf::EnumValueDescriptor *v2; // rax
long long v4; // [rsp+8h] [rbp-70h]
_BYTE v5[13]; // [rsp+1Bh] [rbp-5Dh] BYREF
_BYTE v6[56]; // [rsp+28h] [rbp-50h] BYREF
long long v7; // [rsp+60h] [rbp-18h]
google::protobuf::FieldDescriptor *v8; // [rsp+68h] [rbp-10h]
char v9; // [rsp+77h] [rbp-1h]
v8 = this;
if ( google::protobuf::FieldDescriptor::is_repeated(this) )
{
v9 = 0;
}
else
{
switch ( (unsigned int)google::protobuf::FieldDescriptor::cpp_type(v8) )
{
case 1u:
v9 = (unsigned int)google::protobuf::FieldDescriptor::default_value_int32(v8) != 0;
break;
case 2u:
v9 = google::protobuf::FieldDescriptor::default_value_int64(v8) != 0;
break;
case 3u:
v9 = (unsigned int)google::protobuf::FieldDescriptor::default_value_uint32(v8) != 0;
break;
case 4u:
v9 = google::protobuf::FieldDescriptor::default_value_uint64(v8) != 0;
break;
case 5u:
v9 = google::protobuf::FieldDescriptor::default_value_double(v8) != 0.0;
break;
case 6u:
v9 = google::protobuf::FieldDescriptor::default_value_float(v8) != 0.0;
break;
case 7u:
v9 = google::protobuf::FieldDescriptor::default_value_bool(v8) & 1;
break;
case 8u:
v2 = (google::protobuf::EnumValueDescriptor *)google::protobuf::FieldDescriptor::default_value_enum(v8);
v9 = (unsigned int)google::protobuf::EnumValueDescriptor::number(v2) != 0;
break;
case 9u:
v7 = google::protobuf::FieldDescriptor::default_value_string[abi:cxx11]((long long)v8);
v9 = std::string::length(v7) != 0;
break;
case 0xAu:
v9 = 0;
break;
default:
google::protobuf::internal::LogMessage::LogMessage(
v6,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/objectivec/o"
"bjectivec_helpers.cc",
1154LL);
v4 = google::protobuf::internal::LogMessage::operator<<(v6, "Can't get here.");
google::protobuf::internal::LogFinisher::operator=(v5, v4);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v6);
v9 = 0;
break;
}
}
return v9 & 1;
}
|
HasNonZeroDefaultValue:
SUB RSP,0x78
MOV qword ptr [RSP + 0x68],RDI
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00158050
TEST AL,0x1
JNZ 0x00186ea9
JMP 0x00186eb3
LAB_00186ea9:
MOV byte ptr [RSP + 0x77],0x0
JMP 0x00187072
LAB_00186eb3:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00158090
DEC EAX
MOV ECX,EAX
MOV qword ptr [RSP + 0x10],RCX
SUB EAX,0x9
JA 0x00187000
MOV RAX,qword ptr [RSP + 0x10]
LEA RCX,[0x4b079c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001580c0
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOV byte ptr [RSP + 0x77],AL
JMP 0x00187072
caseD_3:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001580e0
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOV byte ptr [RSP + 0x77],AL
JMP 0x00187072
caseD_2:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001580d0
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOV byte ptr [RSP + 0x77],AL
JMP 0x00187072
caseD_4:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001580f0
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOV byte ptr [RSP + 0x77],AL
JMP 0x00187072
caseD_5:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00158110
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
SETNZ AL
SETP CL
OR AL,CL
AND AL,0x1
MOV byte ptr [RSP + 0x77],AL
JMP 0x00187072
caseD_6:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00158100
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
SETNZ AL
SETP CL
OR AL,CL
AND AL,0x1
MOV byte ptr [RSP + 0x77],AL
JMP 0x00187072
caseD_7:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00158120
AND AL,0x1
MOV byte ptr [RSP + 0x77],AL
JMP 0x00187072
caseD_9:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00158a20
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x00121650
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOV byte ptr [RSP + 0x77],AL
JMP 0x00187072
caseD_8:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x0034eb30
MOV RDI,RAX
CALL 0x001580b0
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOV byte ptr [RSP + 0x77],AL
JMP 0x00187072
caseD_a:
MOV byte ptr [RSP + 0x77],0x0
JMP 0x00187072
default:
LEA RDX,[0x4b09fa]
LEA RDI,[RSP + 0x28]
MOV qword ptr [RSP],RDI
MOV ESI,0x3
MOV ECX,0x482
CALL 0x00319560
MOV RDI,qword ptr [RSP]
LAB_00187023:
LEA RSI,[0x4ab6de]
CALL 0x00318e20
MOV qword ptr [RSP + 0x8],RAX
JMP 0x00187036
LAB_00187036:
MOV RSI,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x1b]
CALL 0x00318fd0
LAB_00187045:
JMP 0x00187047
LAB_00187047:
LEA RDI,[RSP + 0x28]
CALL 0x003195a0
MOV byte ptr [RSP + 0x77],0x0
JMP 0x00187072
LAB_00187072:
MOV AL,byte ptr [RSP + 0x77]
AND AL,0x1
ADD RSP,0x78
RET
|
/* google::protobuf::compiler::objectivec::HasNonZeroDefaultValue(google::protobuf::FieldDescriptor
const*) */
bool google::protobuf::compiler::objectivec::HasNonZeroDefaultValue(FieldDescriptor *param_1)
{
byte bVar1;
int4 uVar2;
int iVar3;
ulong uVar4;
long lVar5;
EnumValueDescriptor *this;
LogMessage *pLVar6;
int4 extraout_XMM0_Da;
float extraout_XMM0_Da_00;
int4 extraout_XMM0_Db;
LogFinisher local_5d [13];
LogMessage local_50 [56];
int8 local_18;
FieldDescriptor *local_10;
bool local_1;
local_10 = param_1;
uVar4 = FieldDescriptor::is_repeated(param_1);
if ((uVar4 & 1) == 0) {
uVar2 = FieldDescriptor::cpp_type(local_10);
switch(uVar2) {
case 1:
iVar3 = FieldDescriptor::default_value_int32(local_10);
local_1 = iVar3 != 0;
break;
case 2:
lVar5 = FieldDescriptor::default_value_int64(local_10);
local_1 = lVar5 != 0;
break;
case 3:
iVar3 = FieldDescriptor::default_value_uint32(local_10);
local_1 = iVar3 != 0;
break;
case 4:
lVar5 = FieldDescriptor::default_value_uint64(local_10);
local_1 = lVar5 != 0;
break;
case 5:
FieldDescriptor::default_value_double(local_10);
local_1 = (double)CONCAT44(extraout_XMM0_Db,extraout_XMM0_Da) != 0.0;
break;
case 6:
FieldDescriptor::default_value_float(local_10);
local_1 = extraout_XMM0_Da_00 != 0.0;
break;
case 7:
bVar1 = FieldDescriptor::default_value_bool(local_10);
local_1 = (bool)(bVar1 & 1);
break;
case 8:
this = (EnumValueDescriptor *)FieldDescriptor::default_value_enum(local_10);
iVar3 = EnumValueDescriptor::number(this);
local_1 = iVar3 != 0;
break;
case 9:
local_18 = FieldDescriptor::default_value_string_abi_cxx11_(local_10);
lVar5 = std::__cxx11::string::length();
local_1 = lVar5 != 0;
break;
case 10:
local_1 = false;
break;
default:
internal::LogMessage::LogMessage
(local_50,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/objectivec/objectivec_helpers.cc"
,0x482);
/* try { // try from 00187023 to 00187044 has its CatchHandler @ 00187058 */
pLVar6 = (LogMessage *)internal::LogMessage::operator<<(local_50,"Can\'t get here.");
internal::LogFinisher::operator=(local_5d,pLVar6);
internal::LogMessage::~LogMessage(local_50);
local_1 = false;
}
}
else {
local_1 = false;
}
return local_1;
}
|
|
17,266
|
common_token_to_piece[abi:cxx11](llama_vocab const*, int, bool)
|
monkey531[P]llama/common/common.cpp
|
std::string common_token_to_piece(const struct llama_vocab * vocab, llama_token token, bool special) {
std::string piece;
piece.resize(piece.capacity()); // using string internal cache, 15 bytes + '\n'
const int n_chars = llama_token_to_piece(vocab, token, &piece[0], piece.size(), 0, special);
if (n_chars < 0) {
piece.resize(-n_chars);
int check = llama_token_to_piece(vocab, token, &piece[0], piece.size(), 0, special);
GGML_ASSERT(check == -n_chars);
}
else {
piece.resize(n_chars);
}
return piece;
}
|
O0
|
cpp
|
common_token_to_piece[abi:cxx11](llama_vocab const*, int, bool):
subq $0x88, %rsp
movq %rdi, 0x50(%rsp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, 0x48(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
andb $0x1, %al
movb %al, 0x73(%rsp)
movb $0x0, 0x72(%rsp)
callq 0x5a610
movq 0x50(%rsp), %rdi
callq 0x5a390
movq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0x5a710
jmp 0xf1f10
movq 0x50(%rsp), %rdi
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x74(%rsp), %eax
movl %eax, 0x3c(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x5b3e0
movq %rax, 0x40(%rsp)
jmp 0xf1f37
movq 0x50(%rsp), %rdi
callq 0x5a550
movq 0x30(%rsp), %rdi
movl 0x3c(%rsp), %esi
movq 0x40(%rsp), %rdx
movl %eax, %ecx
movzbl 0x73(%rsp), %r9d
andl $0x1, %r9d
xorl %r8d, %r8d
callq 0x5a660
movl %eax, 0x2c(%rsp)
jmp 0xf1f69
movl 0x2c(%rsp), %eax
movl %eax, 0x60(%rsp)
cmpl $0x0, 0x60(%rsp)
jge 0xf203f
movq 0x50(%rsp), %rdi
movl 0x60(%rsp), %eax
negl %eax
movslq %eax, %rsi
callq 0x5a710
jmp 0xf1f91
movq 0x50(%rsp), %rdi
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x74(%rsp), %eax
movl %eax, 0x1c(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x5b3e0
movq %rax, 0x20(%rsp)
jmp 0xf1fb8
movq 0x50(%rsp), %rdi
callq 0x5a550
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x20(%rsp), %rdx
movl %eax, %ecx
movzbl 0x73(%rsp), %r9d
andl $0x1, %r9d
xorl %r8d, %r8d
callq 0x5a660
movl %eax, 0xc(%rsp)
jmp 0xf1fea
movl 0xc(%rsp), %eax
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
xorl %ecx, %ecx
subl 0x60(%rsp), %ecx
cmpl %ecx, %eax
je 0xf203d
leaq 0x11e5de(%rip), %rdi # 0x2105e5
leaq 0x11b39c(%rip), %rdx # 0x20d3aa
leaq 0x11ec63(%rip), %rcx # 0x210c78
xorl %eax, %eax
movl $0x6cc, %esi # imm = 0x6CC
callq 0x5aef0
jmp 0xf2023
movq 0x50(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x5b588
jmp 0xf2075
jmp 0xf2052
movq 0x50(%rsp), %rdi
movslq 0x60(%rsp), %rsi
callq 0x5a710
jmp 0xf2050
jmp 0xf2052
movb $0x1, 0x72(%rsp)
testb $0x1, 0x72(%rsp)
jne 0xf2068
movq 0x50(%rsp), %rdi
callq 0x5b588
movq 0x48(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x5abf0
nop
|
_Z21common_token_to_pieceB5cxx11PK11llama_vocabib:
sub rsp, 88h
mov [rsp+88h+var_38], rdi
mov al, cl
mov rcx, rdi
mov [rsp+88h+var_40], rcx
mov [rsp+88h+var_8], rdi
mov [rsp+88h+var_10], rsi
mov [rsp+88h+var_14], edx
and al, 1
mov [rsp+88h+var_15], al
mov [rsp+88h+var_16], 0
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rdi, [rsp+88h+var_38]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE8capacityEv; std::string::capacity(void)
mov rdi, [rsp+88h+var_38]
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEm; std::string::resize(ulong)
jmp short $+2
loc_F1F10:
mov rdi, [rsp+88h+var_38]
mov rax, [rsp+88h+var_10]
mov [rsp+88h+var_58], rax
mov eax, [rsp+88h+var_14]
mov [rsp+88h+var_4C], eax
xor eax, eax
mov esi, eax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
mov [rsp+88h+var_48], rax
jmp short $+2
loc_F1F37:
mov rdi, [rsp+88h+var_38]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv; std::string::size(void)
mov rdi, [rsp+88h+var_58]
mov esi, [rsp+88h+var_4C]
mov rdx, [rsp+88h+var_48]
mov ecx, eax
movzx r9d, [rsp+88h+var_15]
and r9d, 1
xor r8d, r8d
call _llama_token_to_piece
mov [rsp+88h+var_5C], eax
jmp short $+2
loc_F1F69:
mov eax, [rsp+88h+var_5C]
mov [rsp+88h+var_28], eax
cmp [rsp+88h+var_28], 0
jge loc_F203F
mov rdi, [rsp+88h+var_38]
mov eax, [rsp+88h+var_28]
neg eax
movsxd rsi, eax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEm; std::string::resize(ulong)
jmp short $+2
loc_F1F91:
mov rdi, [rsp+88h+var_38]
mov rax, [rsp+88h+var_10]
mov [rsp+88h+var_78], rax
mov eax, [rsp+88h+var_14]
mov [rsp+88h+var_6C], eax
xor eax, eax
mov esi, eax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
mov [rsp+88h+var_68], rax
jmp short $+2
loc_F1FB8:
mov rdi, [rsp+88h+var_38]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv; std::string::size(void)
mov rdi, [rsp+88h+var_78]
mov esi, [rsp+88h+var_6C]
mov rdx, [rsp+88h+var_68]
mov ecx, eax
movzx r9d, [rsp+88h+var_15]
and r9d, 1
xor r8d, r8d
call _llama_token_to_piece
mov [rsp+88h+var_7C], eax
jmp short $+2
loc_F1FEA:
mov eax, [rsp+88h+var_7C]
mov [rsp+88h+var_2C], eax
mov eax, [rsp+88h+var_2C]
xor ecx, ecx
sub ecx, [rsp+88h+var_28]
cmp eax, ecx
jz short loc_F203D
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCheckNChars; "check == -n_chars"
xor eax, eax
mov esi, 6CCh
call _ggml_abort
jmp short $+2
loc_F2023:
mov rdi, [rsp+88h+var_38]; void *
mov rcx, rax
mov eax, edx
mov [rsp+88h+var_20], rcx
mov [rsp+88h+var_24], eax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_F2075
loc_F203D:
jmp short loc_F2052
loc_F203F:
mov rdi, [rsp+88h+var_38]
movsxd rsi, [rsp+88h+var_28]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEm; std::string::resize(ulong)
jmp short $+2
loc_F2050:
jmp short $+2
loc_F2052:
mov [rsp+88h+var_16], 1
test [rsp+88h+var_16], 1
jnz short loc_F2068
mov rdi, [rsp+88h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_F2068:
mov rax, [rsp+88h+var_40]
add rsp, 88h
retn
loc_F2075:
mov rdi, [rsp+88h+var_20]
call __Unwind_Resume
|
void * common_token_to_piece[abi:cxx11](void *a1, long long a2, unsigned int a3, char a4)
{
long long v4; // rax
unsigned int v5; // eax
unsigned int v6; // eax
long long v8; // [rsp+20h] [rbp-68h]
long long v9; // [rsp+40h] [rbp-48h]
int v10; // [rsp+60h] [rbp-28h]
long long v11; // [rsp+68h] [rbp-20h]
char v12; // [rsp+73h] [rbp-15h]
v12 = a4 & 1;
std::string::basic_string(a1);
v4 = std::string::capacity(a1);
std::string::resize(a1, v4);
v9 = std::string::operator[](a1, 0LL);
v5 = std::string::size(a1);
v10 = llama_token_to_piece(a2, a3, v9, v5, 0LL, v12 & 1);
if ( v10 >= 0 )
{
std::string::resize(a1, v10);
}
else
{
std::string::resize(a1, -v10);
v8 = std::string::operator[](a1, 0LL);
v6 = std::string::size(a1);
if ( (unsigned int)llama_token_to_piece(a2, a3, v8, v6, 0LL, v12 & 1) != -v10 )
{
v11 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
1740LL,
"GGML_ASSERT(%s) failed",
"check == -n_chars");
std::string::~string(a1);
_Unwind_Resume(v11);
}
}
return a1;
}
|
common_token_to_piece[abi:cxx11]:
SUB RSP,0x88
MOV qword ptr [RSP + 0x50],RDI
MOV AL,CL
MOV RCX,RDI
MOV qword ptr [RSP + 0x48],RCX
MOV qword ptr [RSP + 0x80],RDI
MOV qword ptr [RSP + 0x78],RSI
MOV dword ptr [RSP + 0x74],EDX
AND AL,0x1
MOV byte ptr [RSP + 0x73],AL
MOV byte ptr [RSP + 0x72],0x0
CALL 0x0015a610
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x0015a390
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,RAX
LAB_001f1f09:
CALL 0x0015a710
JMP 0x001f1f10
LAB_001f1f10:
MOV RDI,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x30],RAX
MOV EAX,dword ptr [RSP + 0x74]
MOV dword ptr [RSP + 0x3c],EAX
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0015b3e0
MOV qword ptr [RSP + 0x40],RAX
JMP 0x001f1f37
LAB_001f1f37:
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x0015a550
MOV RDI,qword ptr [RSP + 0x30]
MOV ESI,dword ptr [RSP + 0x3c]
MOV RDX,qword ptr [RSP + 0x40]
MOV ECX,EAX
MOVZX R9D,byte ptr [RSP + 0x73]
AND R9D,0x1
XOR R8D,R8D
CALL 0x0015a660
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x001f1f69
LAB_001f1f69:
MOV EAX,dword ptr [RSP + 0x2c]
MOV dword ptr [RSP + 0x60],EAX
CMP dword ptr [RSP + 0x60],0x0
JGE 0x001f203f
MOV RDI,qword ptr [RSP + 0x50]
MOV EAX,dword ptr [RSP + 0x60]
NEG EAX
MOVSXD RSI,EAX
CALL 0x0015a710
JMP 0x001f1f91
LAB_001f1f91:
MOV RDI,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x10],RAX
MOV EAX,dword ptr [RSP + 0x74]
MOV dword ptr [RSP + 0x1c],EAX
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0015b3e0
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001f1fb8
LAB_001f1fb8:
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x0015a550
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RSP + 0x1c]
MOV RDX,qword ptr [RSP + 0x20]
MOV ECX,EAX
MOVZX R9D,byte ptr [RSP + 0x73]
AND R9D,0x1
XOR R8D,R8D
CALL 0x0015a660
MOV dword ptr [RSP + 0xc],EAX
JMP 0x001f1fea
LAB_001f1fea:
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x5c],EAX
MOV EAX,dword ptr [RSP + 0x5c]
XOR ECX,ECX
SUB ECX,dword ptr [RSP + 0x60]
CMP EAX,ECX
JZ 0x001f203d
LEA RDI,[0x3105e5]
LEA RDX,[0x30d3aa]
LEA RCX,[0x310c78]
XOR EAX,EAX
MOV ESI,0x6cc
CALL 0x0015aef0
JMP 0x001f2023
LAB_001f2023:
MOV RDI,qword ptr [RSP + 0x50]
MOV RCX,RAX
MOV EAX,EDX
MOV qword ptr [RSP + 0x68],RCX
MOV dword ptr [RSP + 0x64],EAX
CALL 0x0015b588
JMP 0x001f2075
LAB_001f203d:
JMP 0x001f2052
LAB_001f203f:
MOV RDI,qword ptr [RSP + 0x50]
MOVSXD RSI,dword ptr [RSP + 0x60]
CALL 0x0015a710
LAB_001f204e:
JMP 0x001f2050
LAB_001f2050:
JMP 0x001f2052
LAB_001f2052:
MOV byte ptr [RSP + 0x72],0x1
TEST byte ptr [RSP + 0x72],0x1
JNZ 0x001f2068
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x0015b588
LAB_001f2068:
MOV RAX,qword ptr [RSP + 0x48]
ADD RSP,0x88
RET
LAB_001f2075:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x0015abf0
|
/* WARNING: Removing unreachable block (ram,0x001f205e) */
/* common_token_to_piece[abi:cxx11](llama_vocab const*, int, bool) */
llama_vocab * common_token_to_piece_abi_cxx11_(llama_vocab *param_1,int param_2,bool param_3)
{
int4 uVar1;
int iVar2;
int iVar3;
int8 uVar4;
byte in_CL;
int7 in_register_00000011;
int4 in_register_00000034;
std::__cxx11::string::string((string *)param_1);
std::__cxx11::string::capacity();
/* try { // try from 001f1f09 to 001f204d has its CatchHandler @ 001f2023 */
std::__cxx11::string::resize((ulong)param_1);
uVar4 = std::__cxx11::string::operator[]((ulong)param_1);
uVar1 = std::__cxx11::string::size();
iVar2 = llama_token_to_piece
(CONCAT44(in_register_00000034,param_2),
CONCAT71(in_register_00000011,param_3) & 0xffffffff,uVar4,uVar1,0,in_CL & 1);
if (iVar2 < 0) {
std::__cxx11::string::resize((ulong)param_1);
uVar4 = std::__cxx11::string::operator[]((ulong)param_1);
uVar1 = std::__cxx11::string::size();
iVar3 = llama_token_to_piece
(CONCAT44(in_register_00000034,param_2),
CONCAT71(in_register_00000011,param_3) & 0xffffffff,uVar4,uVar1,0,in_CL & 1);
if (iVar3 != -iVar2) {
uVar4 = ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp"
,0x6cc,"GGML_ASSERT(%s) failed","check == -n_chars");
/* catch() { ... } // from try @ 001f1f09 with catch @ 001f2023 */
std::__cxx11::string::~string((string *)param_1);
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar4);
}
}
else {
std::__cxx11::string::resize((ulong)param_1);
}
return param_1;
}
|
|
17,267
|
fmt::v11::basic_appender<char> fmt::v11::detail::write<char, fmt::v11::basic_appender<char>, bool, 0>(fmt::v11::basic_appender<char>, bool, fmt::v11::format_specs const&, fmt::v11::detail::locale_ref)
|
zkingston[P]unknot/build_O0/_deps/fmt-src/include/fmt/format.h
|
FMT_CONSTEXPR auto write(OutputIt out, T value, const format_specs& specs = {},
locale_ref = {}) -> OutputIt {
return specs.type() != presentation_type::none &&
specs.type() != presentation_type::string
? write<Char>(out, value ? 1 : 0, specs, {})
: write_bytes<Char>(out, value ? "true" : "false", specs);
}
|
O0
|
c
|
fmt::v11::basic_appender<char> fmt::v11::detail::write<char, fmt::v11::basic_appender<char>, bool, 0>(fmt::v11::basic_appender<char>, bool, fmt::v11::format_specs const&, fmt::v11::detail::locale_ref):
subq $0xf8, %rsp
movb %sil, %al
movq %rdi, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
andb $0x1, %al
movb %al, 0x6f(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0xae030
cmpb $0x0, %al
je 0xadf93
movq 0x60(%rsp), %rdi
callq 0xae030
cmpb $0x2, %al
je 0xadf93
movq 0x78(%rsp), %rax
movq %rax, 0x58(%rsp)
movb 0x6f(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x2c(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xa7bd0
movl 0x2c(%rsp), %ecx
movq 0x30(%rsp), %rax
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movl %ecx, 0xdc(%rsp)
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rdi
callq 0xae0b0
testb $0x1, %al
jne 0xade8e
jmp 0xadf21
movq 0xe8(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl 0xdc(%rsp), %esi
leaq 0xa0(%rsp), %rdi
callq 0xae0d0
movq 0xd0(%rsp), %rsi
movq 0xe0(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0xc8(%rsp), %rdi
movq 0x98(%rsp), %rdx
leaq 0xa0(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xa5310
testb $0x1, %al
jne 0xadf0f
jmp 0xadf21
movq 0xe8(%rsp), %rax
movq %rax, 0xf0(%rsp)
jmp 0xadf81
movq 0xe8(%rsp), %rax
movq %rax, 0x90(%rsp)
movl 0xdc(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0xd0(%rsp), %rdi
callq 0xae670
movl 0x28(%rsp), %edi
movl %eax, %esi
callq 0xae5f0
movq %rax, 0x88(%rsp)
movq 0xd0(%rsp), %rdx
movq 0x90(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0xae100
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0xadfe1
movq 0x78(%rsp), %rax
movq %rax, 0x48(%rsp)
movb 0x6f(%rsp), %cl
leaq 0x51f996(%rip), %rsi # 0x5cd93e
leaq 0x51f98a(%rip), %rax # 0x5cd939
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0xa7b80
movq 0x60(%rsp), %rcx
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xae040
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
_ZN3fmt3v116detail5writeIcNS0_14basic_appenderIcEEbTnNSt9enable_ifIXsr3std7is_sameIT1_bEE5valueEiE4typeELi0EEET0_S9_S6_RKNS0_12format_specsENS1_10locale_refE:
sub rsp, 0F8h
mov al, sil
mov [rsp+0F8h+var_80], rdi
mov [rsp+0F8h+var_88], rcx
and al, 1
mov [rsp+0F8h+var_89], al
mov [rsp+0F8h+var_98], rdx
mov rdi, [rsp+0F8h+var_98]; this
call _ZNK3fmt3v1111basic_specs4typeEv; fmt::v11::basic_specs::type(void)
cmp al, 0
jz loc_ADF93
mov rdi, [rsp+0F8h+var_98]; this
call _ZNK3fmt3v1111basic_specs4typeEv; fmt::v11::basic_specs::type(void)
cmp al, 2
jz loc_ADF93
mov rax, [rsp+0F8h+var_80]
mov [rsp+0F8h+var_A0], rax
mov dl, [rsp+0F8h+var_89]
xor eax, eax
mov ecx, 1
test dl, 1
cmovnz eax, ecx
mov [rsp+0F8h+var_CC], eax
mov rax, [rsp+0F8h+var_98]
mov [rsp+0F8h+var_C8], rax
lea rdi, [rsp+0F8h+var_A8]; this
call _ZN3fmt3v116detail10locale_refC2Ev; fmt::v11::detail::locale_ref::locale_ref(void)
mov ecx, [rsp+0F8h+var_CC]
mov rax, [rsp+0F8h+var_C8]
mov rsi, [rsp+0F8h+var_A0]
mov rdx, [rsp+0F8h+var_A8]
mov [rsp+0F8h+var_10], rsi
mov [rsp+0F8h+var_18], rdx
mov [rsp+0F8h+var_1C], ecx
mov [rsp+0F8h+var_28], rax
mov rdi, [rsp+0F8h+var_28]; this
call _ZNK3fmt3v1111basic_specs9localizedEv; fmt::v11::basic_specs::localized(void)
test al, 1
jnz short loc_ADE8E
jmp loc_ADF21
loc_ADE8E:
mov rax, [rsp+0F8h+var_10]
mov [rsp+0F8h+var_30], rax
mov esi, [rsp+0F8h+var_1C]
lea rdi, [rsp+0F8h+var_58]
call _ZN3fmt3v119loc_valueC2IiTnNSt9enable_ifIXntsr6detail11is_float128IT_EE5valueEiE4typeELi0EEES4_
mov rsi, [rsp+0F8h+var_28]
mov rax, [rsp+0F8h+var_18]
mov [rsp+0F8h+var_60], rax
mov rdi, [rsp+0F8h+var_30]
mov rdx, [rsp+0F8h+var_60]
lea rax, [rsp+0F8h+var_58]
mov rcx, [rax]
mov [rsp+0F8h+var_F8], rcx
mov rcx, [rax+8]
mov [rsp+0F8h+var_F0], rcx
mov rcx, [rax+10h]
mov [rsp+0F8h+var_E8], rcx
mov rax, [rax+18h]
mov [rsp+0F8h+var_E0], rax
call _ZN3fmt3v116detail9write_locENS0_14basic_appenderIcEENS0_9loc_valueERKNS0_12format_specsENS1_10locale_refE; fmt::v11::detail::write_loc(fmt::v11::basic_appender<char>,fmt::v11::loc_value,fmt::v11::format_specs const&,fmt::v11::detail::locale_ref)
test al, 1
jnz short loc_ADF0F
jmp short loc_ADF21
loc_ADF0F:
mov rax, [rsp+0F8h+var_10]
mov [rsp+0F8h+var_8], rax
jmp short loc_ADF81
loc_ADF21:
mov rax, [rsp+0F8h+var_10]
mov [rsp+0F8h+var_68], rax
mov eax, [rsp+0F8h+var_1C]
mov [rsp+0F8h+var_D0], eax
mov rdi, [rsp+0F8h+var_28]; this
call _ZNK3fmt3v1111basic_specs4signEv; fmt::v11::basic_specs::sign(void)
mov edi, [rsp+0F8h+var_D0]
mov esi, eax
call _ZN3fmt3v116detail18make_write_int_argIiEENS1_13write_int_argINSt11conditionalIXaalecl8num_bitsIT_EELi32EntLi0EEjNS4_IXlecl8num_bitsIS5_EELi64EEmoE4typeEE4typeEEES5_NS0_4signE; fmt::v11::detail::make_write_int_arg<int>(int,fmt::v11::sign)
mov [rsp+0F8h+var_70], rax
mov rdx, [rsp+0F8h+var_28]
mov rdi, [rsp+0F8h+var_68]
mov rsi, [rsp+0F8h+var_70]
call _ZN3fmt3v116detail18write_int_noinlineIcNS0_14basic_appenderIcEEjEET0_S5_NS1_13write_int_argIT1_EERKNS0_12format_specsE; fmt::v11::detail::write_int_noinline<char,fmt::v11::basic_appender<char>,uint>(fmt::v11::basic_appender<char>,fmt::v11::detail::write_int_arg<uint>,fmt::v11::format_specs const&)
mov [rsp+0F8h+var_8], rax
loc_ADF81:
mov rax, [rsp+0F8h+var_8]
mov [rsp+0F8h+var_78], rax
jmp short loc_ADFE1
loc_ADF93:
mov rax, [rsp+0F8h+var_80]
mov [rsp+0F8h+var_B0], rax
mov cl, [rsp+0F8h+var_89]
lea rsi, aFalse; "false"
lea rax, aTrue; "true"
test cl, 1
cmovnz rsi, rax
lea rdi, [rsp+0F8h+var_C0]
call _ZN3fmt3v1117basic_string_viewIcEC2EPKc; fmt::v11::basic_string_view<char>::basic_string_view(char const*)
mov rcx, [rsp+0F8h+var_98]
mov rdi, [rsp+0F8h+var_B0]
mov rsi, [rsp+0F8h+var_C0]
mov rdx, [rsp+0F8h+var_B8]
call _ZN3fmt3v116detail11write_bytesIcLNS0_5alignE1ENS0_14basic_appenderIcEEEET1_S6_NS0_17basic_string_viewIcEERKNS0_12format_specsE; fmt::v11::detail::write_bytes<char,(fmt::v11::align)1,fmt::v11::basic_appender<char>>(fmt::v11::basic_appender<char>,fmt::v11::basic_string_view<char>,fmt::v11::format_specs const&)
mov [rsp+0F8h+var_78], rax
loc_ADFE1:
mov rax, [rsp+0F8h+var_78]
add rsp, 0F8h
retn
|
long long ZN3fmt3v116detail5writeIcNS0_14basic_appenderIcEEbTnNSt9enable_ifIXsr3std7is_sameIT1_bEE5valueEiE4typeELi0EEET0_S9_S6_RKNS0_12format_specsENS1_10locale_refE(
long long a1,
char a2,
fmt::v11::basic_specs *a3,
long long a4)
{
long long v4; // r8
long long v5; // r9
unsigned int v6; // eax
const char *v7; // rsi
unsigned int v9; // [rsp+28h] [rbp-D0h]
BOOL v10; // [rsp+2Ch] [rbp-CCh]
fmt::v11::basic_specs *v11; // [rsp+30h] [rbp-C8h]
_QWORD v12[2]; // [rsp+38h] [rbp-C0h] BYREF
long long v13; // [rsp+48h] [rbp-B0h]
long long v14; // [rsp+50h] [rbp-A8h] BYREF
long long v15; // [rsp+58h] [rbp-A0h]
fmt::v11::basic_specs *v16; // [rsp+60h] [rbp-98h]
char v17; // [rsp+6Fh] [rbp-89h]
long long v18; // [rsp+70h] [rbp-88h]
long long v19; // [rsp+78h] [rbp-80h]
long long v21; // [rsp+88h] [rbp-70h]
long long v22; // [rsp+90h] [rbp-68h]
long long v23; // [rsp+98h] [rbp-60h]
__int128 v24; // [rsp+A0h] [rbp-58h] BYREF
__int128 v25; // [rsp+B0h] [rbp-48h]
long long v26; // [rsp+C8h] [rbp-30h]
fmt::v11::basic_specs *v27; // [rsp+D0h] [rbp-28h]
unsigned int v28; // [rsp+DCh] [rbp-1Ch]
long long v29; // [rsp+E0h] [rbp-18h]
long long v30; // [rsp+E8h] [rbp-10h]
v19 = a1;
v18 = a4;
v17 = a2 & 1;
v16 = a3;
if ( !(unsigned __int8)fmt::v11::basic_specs::type(a3) || (unsigned __int8)fmt::v11::basic_specs::type(v16) == 2 )
{
v13 = v19;
v7 = "false";
if ( (v17 & 1) != 0 )
v7 = "true";
fmt::v11::basic_string_view<char>::basic_string_view(v12, (long long)v7);
return fmt::v11::detail::write_bytes<char,(fmt::v11::align)1,fmt::v11::basic_appender<char>>(
v13,
v12[0],
v12[1],
v16);
}
else
{
v15 = v19;
v10 = (v17 & 1) != 0;
v11 = v16;
fmt::v11::detail::locale_ref::locale_ref((fmt::v11::detail::locale_ref *)&v14);
v30 = v15;
v29 = v14;
v28 = v10;
v27 = v11;
if ( (fmt::v11::basic_specs::localized(v11) & 1) != 0 )
{
v26 = v30;
ZN3fmt3v119loc_valueC2IiTnNSt9enable_ifIXntsr6detail11is_float128IT_EE5valueEiE4typeELi0EEES4_(&v24, v28);
v23 = v29;
if ( (fmt::v11::detail::write_loc(v26, (long long)v27, v29, v25, v4, v5, v24, v25) & 1) != 0 )
return v30;
}
v22 = v30;
v9 = v28;
v6 = fmt::v11::basic_specs::sign(v27);
v21 = fmt::v11::detail::make_write_int_arg<int>(v9, v6);
return fmt::v11::detail::write_int_noinline<char,fmt::v11::basic_appender<char>,unsigned int>(v22, v21, v27);
}
}
|
_ZN3fmt3v116detail5writeIcNS0_14basic_appenderIcEEbTnNSt9enable_ifIXsr3std7is_sameIT1_bEE5valueEiE4typeELi0EEET0_S9_S6_RKNS0_12format_specsENS1_10locale_refE:
SUB RSP,0xf8
MOV AL,SIL
MOV qword ptr [RSP + 0x78],RDI
MOV qword ptr [RSP + 0x70],RCX
AND AL,0x1
MOV byte ptr [RSP + 0x6f],AL
MOV qword ptr [RSP + 0x60],RDX
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x001ae030
CMP AL,0x0
JZ 0x001adf93
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x001ae030
CMP AL,0x2
JZ 0x001adf93
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x58],RAX
MOV DL,byte ptr [RSP + 0x6f]
XOR EAX,EAX
MOV ECX,0x1
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RSP + 0x2c],EAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x30],RAX
LEA RDI,[RSP + 0x50]
CALL 0x001a7bd0
MOV ECX,dword ptr [RSP + 0x2c]
MOV RAX,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0xe8],RSI
MOV qword ptr [RSP + 0xe0],RDX
MOV dword ptr [RSP + 0xdc],ECX
MOV qword ptr [RSP + 0xd0],RAX
MOV RDI,qword ptr [RSP + 0xd0]
CALL 0x001ae0b0
TEST AL,0x1
JNZ 0x001ade8e
JMP 0x001adf21
LAB_001ade8e:
MOV RAX,qword ptr [RSP + 0xe8]
MOV qword ptr [RSP + 0xc8],RAX
MOV ESI,dword ptr [RSP + 0xdc]
LEA RDI,[RSP + 0xa0]
CALL 0x001ae0d0
MOV RSI,qword ptr [RSP + 0xd0]
MOV RAX,qword ptr [RSP + 0xe0]
MOV qword ptr [RSP + 0x98],RAX
MOV RDI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0x98]
LEA RAX,[RSP + 0xa0]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RCX
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x18],RAX
CALL 0x001a5310
TEST AL,0x1
JNZ 0x001adf0f
JMP 0x001adf21
LAB_001adf0f:
MOV RAX,qword ptr [RSP + 0xe8]
MOV qword ptr [RSP + 0xf0],RAX
JMP 0x001adf81
LAB_001adf21:
MOV RAX,qword ptr [RSP + 0xe8]
MOV qword ptr [RSP + 0x90],RAX
MOV EAX,dword ptr [RSP + 0xdc]
MOV dword ptr [RSP + 0x28],EAX
MOV RDI,qword ptr [RSP + 0xd0]
CALL 0x001ae670
MOV EDI,dword ptr [RSP + 0x28]
MOV ESI,EAX
CALL 0x001ae5f0
MOV qword ptr [RSP + 0x88],RAX
MOV RDX,qword ptr [RSP + 0xd0]
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x88]
CALL 0x001ae100
MOV qword ptr [RSP + 0xf0],RAX
LAB_001adf81:
MOV RAX,qword ptr [RSP + 0xf0]
MOV qword ptr [RSP + 0x80],RAX
JMP 0x001adfe1
LAB_001adf93:
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x48],RAX
MOV CL,byte ptr [RSP + 0x6f]
LEA RSI,[0x6cd93e]
LEA RAX,[0x6cd939]
TEST CL,0x1
CMOVNZ RSI,RAX
LEA RDI,[RSP + 0x38]
CALL 0x001a7b80
MOV RCX,qword ptr [RSP + 0x60]
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
CALL 0x001ae040
MOV qword ptr [RSP + 0x80],RAX
LAB_001adfe1:
MOV RAX,qword ptr [RSP + 0x80]
ADD RSP,0xf8
RET
|
detail * _ZN3fmt3v116detail5writeIcNS0_14basic_appenderIcEEbTnNSt9enable_ifIXsr3std7is_sameIT1_bEE5valueEiE4typeELi0EEET0_S9_S6_RKNS0_12format_specsENS1_10locale_refE
(detail *param_1,byte param_2,basic_specs *param_3,int8 param_4)
{
byte bVar1;
basic_specs *this;
uint uVar2;
char cVar3;
int4 uVar4;
ulong uVar5;
detail *pdVar6;
char *pcVar7;
int8 local_c0;
int8 local_b8;
detail *local_b0;
int8 local_a8;
detail *local_a0;
basic_specs *local_98;
byte local_89;
int8 local_88;
detail *local_80;
int8 local_70;
detail *local_68;
int8 local_60;
int1 local_58 [40];
detail *local_30;
basic_specs *local_28;
uint local_1c;
int8 local_18;
detail *local_10;
local_89 = param_2 & 1;
local_98 = param_3;
local_88 = param_4;
local_80 = param_1;
cVar3 = fmt::v11::basic_specs::type(param_3);
if ((cVar3 != '\0') &&
(cVar3 = fmt::v11::basic_specs::type(local_98), this = local_98, cVar3 != '\x02')) {
local_a0 = local_80;
bVar1 = local_89 & 1;
fmt::v11::detail::locale_ref::locale_ref((locale_ref *)&local_a8);
local_10 = local_a0;
local_18 = local_a8;
local_28 = this;
local_1c = (uint)(bVar1 != 0);
uVar5 = fmt::v11::basic_specs::localized(this);
if ((uVar5 & 1) != 0) {
local_30 = local_10;
_ZN3fmt3v119loc_valueC2IiTnNSt9enable_ifIXntsr6detail11is_float128IT_EE5valueEiE4typeELi0EEES4_
(local_58,local_1c);
local_60 = local_18;
uVar5 = fmt::v11::detail::write_loc(local_30,local_28,local_18);
if ((uVar5 & 1) != 0) {
return local_10;
}
}
uVar2 = local_1c;
local_68 = local_10;
uVar4 = fmt::v11::basic_specs::sign(local_28);
local_70 = fmt::v11::detail::write_int_arg<std::
conditional<(((num_bits<int>)())<=(32))&&(!(0)),unsigned_int,std::
conditional<((num_bits<int>)())<=(64),unsigned_long,unsigned__int128>::type>::
type>fmt::v11::detail::make_write_int_arg<int>(uVar2,uVar4);
pdVar6 = (detail *)
fmt::v11::detail::write_int_noinline<char,fmt::v11::basic_appender<char>,unsigned_int>
(local_68,local_70,local_28);
return pdVar6;
}
local_b0 = local_80;
pcVar7 = "false";
if ((local_89 & 1) != 0) {
pcVar7 = "true";
}
fmt::v11::basic_string_view<char>::basic_string_view((basic_string_view<char> *)&local_c0,pcVar7);
pdVar6 = (detail *)
fmt::v11::detail::write_bytes<char,(fmt::v11::align)1,fmt::v11::basic_appender<char>>
(local_b0,local_c0,local_b8,local_98);
return pdVar6;
}
|
|
17,268
|
w_search
|
eloqsql/storage/myisam/mi_write.c
|
static int w_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
uint comp_flag, uchar *key, uint key_length, my_off_t page,
uchar *father_buff, uchar *father_keypos,
my_off_t father_page, my_bool insert_last)
{
int error,flag;
uint nod_flag, search_key_length;
uchar *temp_buff,*keypos;
uchar keybuff[HA_MAX_KEY_BUFF];
my_bool was_last_key;
my_off_t next_page, dupp_key_pos;
DBUG_ENTER("w_search");
DBUG_PRINT("enter",("page: %ld", (long) page));
search_key_length= (comp_flag & SEARCH_FIND) ? key_length : USE_WHOLE_KEY;
if (!(temp_buff= (uchar*) my_alloca((uint) keyinfo->block_length+
HA_MAX_KEY_BUFF*2)))
DBUG_RETURN(-1);
if (!_mi_fetch_keypage(info,keyinfo,page,DFLT_INIT_HITS,temp_buff,0))
goto err;
flag=(*keyinfo->bin_search)(info,keyinfo,temp_buff,key,search_key_length,
comp_flag, &keypos, keybuff, &was_last_key);
nod_flag=mi_test_if_nod(temp_buff);
if (flag == 0)
{
uint tmp_key_length;
/* get position to record with duplicated key */
tmp_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&keypos,keybuff);
if (tmp_key_length)
dupp_key_pos=_mi_dpos(info,0,keybuff+tmp_key_length);
else
dupp_key_pos= HA_OFFSET_ERROR;
if (keyinfo->flag & HA_FULLTEXT)
{
uint off;
int subkeys;
get_key_full_length_rdonly(off, keybuff);
subkeys=ft_sintXkorr(keybuff+off);
comp_flag=SEARCH_SAME;
if (subkeys >= 0)
{
/* normal word, one-level tree structure */
flag=(*keyinfo->bin_search)(info, keyinfo, temp_buff, key,
USE_WHOLE_KEY, comp_flag,
&keypos, keybuff, &was_last_key);
}
else
{
/* popular word. two-level tree. going down */
my_off_t root=dupp_key_pos;
keyinfo=&info->s->ft2_keyinfo;
get_key_full_length_rdonly(off, key);
key+=off;
keypos-=keyinfo->keylength+nod_flag; /* we'll modify key entry 'in vivo' */
error=_mi_ck_real_write_btree(info, keyinfo, key, 0,
&root, comp_flag);
_mi_dpointer(info, keypos+HA_FT_WLEN, root);
subkeys--; /* should there be underflow protection ? */
DBUG_ASSERT(subkeys < 0);
ft_intXstore(keypos, subkeys);
if (!error)
error=_mi_write_keypage(info,keyinfo,page,DFLT_INIT_HITS,temp_buff);
my_afree((uchar*) temp_buff);
DBUG_RETURN(error);
}
}
else /* not HA_FULLTEXT, normal HA_NOSAME key */
{
info->dupp_key_pos= dupp_key_pos;
my_afree((uchar*) temp_buff);
my_errno=HA_ERR_FOUND_DUPP_KEY;
DBUG_RETURN(-1);
}
}
if (flag == MI_FOUND_WRONG_KEY)
DBUG_RETURN(-1);
if (!was_last_key)
insert_last=0;
next_page=_mi_kpos(nod_flag,keypos);
if (next_page == HA_OFFSET_ERROR ||
(error=w_search(info, keyinfo, comp_flag, key, key_length, next_page,
temp_buff, keypos, page, insert_last)) >0)
{
error=_mi_insert(info,keyinfo,key,temp_buff,keypos,keybuff,father_buff,
father_keypos,father_page, insert_last);
if (_mi_write_keypage(info,keyinfo,page,DFLT_INIT_HITS,temp_buff))
goto err;
}
my_afree((uchar*) temp_buff);
DBUG_RETURN(error);
err:
my_afree((uchar*) temp_buff);
DBUG_PRINT("exit",("Error: %d",my_errno));
DBUG_RETURN (-1);
}
|
O3
|
c
|
w_search:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4f8, %rsp # imm = 0x4F8
movq %r9, %rbx
movl %r8d, -0x504(%rbp)
movq %rcx, -0x510(%rbp)
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movzwl 0xe(%rsi), %eax
movq %rsp, %r15
addl $0x97f, %eax # imm = 0x97F
andl $-0x10, %eax
subq %rax, %r15
movq %r15, %rsp
movq %r9, %rdx
movl $0x3, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x83cb0
testq %rax, %rax
je 0x885e2
movq %rbx, -0x518(%rbp)
testb $0x1, %r12b
movl $0x970, %r8d # imm = 0x970
cmovnel -0x504(%rbp), %r8d
subq $0x8, %rsp
leaq -0x4f1(%rbp), %rbx
leaq -0x4f0(%rbp), %rax
leaq -0x500(%rbp), %r10
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq -0x510(%rbp), %rcx
movl %r12d, -0x508(%rbp)
movl %r12d, %r9d
pushq %rbx
pushq %rax
pushq %r10
callq *0x40(%r13)
addq $0x20, %rsp
cmpb $0x0, (%r15)
movl $0x0, %r12d
jns 0x884b2
movq (%r14), %rcx
movl 0x17c(%rcx), %r12d
testl %eax, %eax
je 0x8858d
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
je 0x885e7
xorl %eax, %eax
cmpb $0x0, -0x4f1(%rbp)
movzbl 0x28(%rbp), %ebx
cmovel %eax, %ebx
movq -0x500(%rbp), %rsi
movl %r12d, %edi
callq 0x8462a
movsbl %bl, %r10d
cmpq $-0x1, %rax
movq %r14, %r12
movq -0x510(%rbp), %r14
je 0x8853d
movq %r12, %rdi
movq %r13, %rsi
movl -0x508(%rbp), %edx
movq %r14, %rcx
movl -0x504(%rbp), %r8d
movq %rax, %r9
pushq %r10
pushq -0x518(%rbp)
pushq -0x500(%rbp)
pushq %r15
movq %r10, %rbx
callq 0x883d8
movq %rbx, %r10
addq $0x20, %rsp
testl %eax, %eax
jle 0x88788
movq -0x500(%rbp), %r8
leaq -0x4f0(%rbp), %r9
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
pushq %r10
pushq 0x20(%rbp)
pushq 0x18(%rbp)
pushq 0x10(%rbp)
callq 0x888a3
addq $0x20, %rsp
movl %eax, %ebx
movq %r12, %rdi
movq %r13, %rsi
movq -0x518(%rbp), %rdx
movl $0x3, %ecx
movq %r15, %r8
callq 0x83d5c
testl %eax, %eax
jne 0x885e2
jmp 0x885e7
leaq -0x500(%rbp), %rdx
leaq -0x4f0(%rbp), %rcx
movq %r13, %rdi
movl %r12d, %esi
callq *0x48(%r13)
testl %eax, %eax
je 0x885c2
movl %eax, %eax
leaq (%rax,%rbp), %rdx
addq $-0x4f0, %rdx # imm = 0xFB10
movq %r14, %rdi
xorl %esi, %esi
callq 0x84709
jmp 0x885c9
movq $-0x1, %rax
testb $-0x80, 0xa(%r13)
jne 0x8860b
movq %rax, 0x1a0(%r14)
callq 0xa1afa
movl $0x79, (%rax)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x8878f
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl -0x4f0(%rbp), %ecx
cmpq $0xff, %rcx
je 0x88620
incq %rcx
jmp 0x88632
movzwl -0x4ef(%rbp), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addq $0x3, %rcx
movzbl -0x4f0(%rbp,%rcx), %edx
shll $0x18, %edx
js 0x88687
subq $0x8, %rsp
movl $0x4, -0x508(%rbp)
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq -0x510(%rbp), %rcx
movl $0x970, %r8d # imm = 0x970
movl $0x4, %r9d
pushq %rbx
leaq -0x4f0(%rbp), %rax
pushq %rax
leaq -0x500(%rbp), %rax
pushq %rax
callq *0x40(%r13)
addq $0x20, %rsp
jmp 0x884ba
movq %r12, %rdi
movzwl -0x4ee(%rbp,%rcx), %esi
rolw $0x8, %si
movzwl %si, %esi
movzbl -0x4ef(%rbp,%rcx), %ecx
shll $0x10, %ecx
orl %esi, %ecx
orl %edx, %ecx
movl %ecx, -0x504(%rbp)
movq %rax, -0x520(%rbp)
movq (%r14), %rax
leaq 0x1a8(%rax), %r12
movq -0x510(%rbp), %rdx
movzbl (%rdx), %ecx
cmpq $0xff, %rcx
je 0x886d7
incq %rcx
jmp 0x886e6
movzwl 0x1(%rdx), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addq $0x3, %rcx
addq %rcx, %rdx
movzwl 0x1ba(%rax), %eax
addl %eax, %edi
subq %rdi, -0x500(%rbp)
leaq -0x520(%rbp), %r13
movq %r14, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
movq %r13, %r8
movl $0x4, %r9d
callq 0x88357
movl %eax, %ebx
movq -0x500(%rbp), %rsi
addq $0x4, %rsi
movq (%r13), %rdx
movq %r14, %rdi
callq 0x853cf
movl -0x504(%rbp), %edx
decl %edx
movq -0x500(%rbp), %rax
movb %dl, 0x3(%rax)
movq -0x500(%rbp), %rax
movb %dh, 0x2(%rax)
movl %edx, %eax
shrl $0x10, %eax
movq -0x500(%rbp), %rcx
movb %al, 0x1(%rcx)
shrl $0x18, %edx
movq -0x500(%rbp), %rax
movb %dl, (%rax)
testl %ebx, %ebx
jne 0x885e7
movq %r14, %rdi
movq %r12, %rsi
movq -0x518(%rbp), %rdx
movl $0x3, %ecx
movq %r15, %r8
callq 0x83d5c
movl %eax, %ebx
jmp 0x885e7
callq 0x29270
|
w_search_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 4F8h
mov rbx, r9
mov [rbp+var_504], r8d
mov [rbp+var_510], rcx
mov r12d, edx
mov r13, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
movzx eax, word ptr [rsi+0Eh]
mov r15, rsp
add eax, 97Fh
and eax, 0FFFFFFF0h
sub r15, rax
mov rsp, r15
mov rdx, r9
mov ecx, 3
mov r8, r15
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz loc_885E2
mov [rbp+var_518], rbx
test r12b, 1
mov r8d, 970h
cmovnz r8d, [rbp+var_504]
sub rsp, 8
lea rbx, [rbp+var_4F1]
lea rax, [rbp+var_4F0]
lea r10, [rbp+var_500]
mov rdi, r14
mov rsi, r13
mov rdx, r15
mov rcx, [rbp+var_510]
mov [rbp+var_508], r12d
mov r9d, r12d
push rbx
push rax
push r10
call qword ptr [r13+40h]
add rsp, 20h
cmp byte ptr [r15], 0
mov r12d, 0
jns short loc_884B2
mov rcx, [r14]
mov r12d, [rcx+17Ch]
loc_884B2:
test eax, eax
jz loc_8858D
loc_884BA:
mov ebx, 0FFFFFFFFh
cmp eax, 7FFFFFFFh
jz loc_885E7
xor eax, eax
cmp [rbp+var_4F1], 0
movzx ebx, [rbp+arg_18]
cmovz ebx, eax
mov rsi, [rbp+var_500]
mov edi, r12d
call _mi_kpos
movsx r10d, bl
cmp rax, 0FFFFFFFFFFFFFFFFh
mov r12, r14
mov r14, [rbp+var_510]
jz short loc_8853D
mov rdi, r12
mov rsi, r13
mov edx, [rbp+var_508]
mov rcx, r14
mov r8d, [rbp+var_504]
mov r9, rax
push r10
push [rbp+var_518]
push [rbp+var_500]
push r15
mov rbx, r10
call w_search_0
mov r10, rbx
add rsp, 20h
test eax, eax
jle loc_88788
loc_8853D:
mov r8, [rbp+var_500]
lea r9, [rbp+var_4F0]
mov rdi, r12
mov rsi, r13
mov rdx, r14
mov rcx, r15
push r10
push [rbp+arg_10]
push [rbp+arg_8]
push [rbp+arg_0]
call _mi_insert
add rsp, 20h
mov ebx, eax
mov rdi, r12
mov rsi, r13
mov rdx, [rbp+var_518]
mov ecx, 3
mov r8, r15
call _mi_write_keypage
test eax, eax
jnz short loc_885E2
jmp short loc_885E7
loc_8858D:
lea rdx, [rbp+var_500]
lea rcx, [rbp+var_4F0]
mov rdi, r13
mov esi, r12d
call qword ptr [r13+48h]
test eax, eax
jz short loc_885C2
mov eax, eax
lea rdx, [rax+rbp]
add rdx, 0FFFFFFFFFFFFFB10h
mov rdi, r14
xor esi, esi
call _mi_dpos
jmp short loc_885C9
loc_885C2:
mov rax, 0FFFFFFFFFFFFFFFFh
loc_885C9:
test byte ptr [r13+0Ah], 80h
jnz short loc_8860B
mov [r14+1A0h], rax
call _my_thread_var
mov dword ptr [rax], 79h ; 'y'
loc_885E2:
mov ebx, 0FFFFFFFFh
loc_885E7:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_8878F
mov eax, ebx
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8860B:
movzx ecx, [rbp+var_4F0]
cmp rcx, 0FFh
jz short loc_88620
inc rcx
jmp short loc_88632
loc_88620:
movzx ecx, [rbp+var_4EF]
rol cx, 8
movzx ecx, cx
add rcx, 3
loc_88632:
movzx edx, [rbp+rcx+var_4F0]
shl edx, 18h
js short loc_88687
sub rsp, 8
mov [rbp+var_508], 4
mov rdi, r14
mov rsi, r13
mov rdx, r15
mov rcx, [rbp+var_510]
mov r8d, 970h
mov r9d, 4
push rbx
lea rax, [rbp+var_4F0]
push rax
lea rax, [rbp+var_500]
push rax
call qword ptr [r13+40h]
add rsp, 20h
jmp loc_884BA
loc_88687:
mov rdi, r12
movzx esi, [rbp+rcx+var_4EF+1]
rol si, 8
movzx esi, si
movzx ecx, byte ptr [rbp+rcx+var_4EF]
shl ecx, 10h
or ecx, esi
or ecx, edx
mov [rbp+var_504], ecx
mov [rbp+var_520], rax
mov rax, [r14]
lea r12, [rax+1A8h]
mov rdx, [rbp+var_510]
movzx ecx, byte ptr [rdx]
cmp rcx, 0FFh
jz short loc_886D7
inc rcx
jmp short loc_886E6
loc_886D7:
movzx ecx, word ptr [rdx+1]
rol cx, 8
movzx ecx, cx
add rcx, 3
loc_886E6:
add rdx, rcx
movzx eax, word ptr [rax+1BAh]
add edi, eax
sub [rbp+var_500], rdi
lea r13, [rbp+var_520]
mov rdi, r14
mov rsi, r12
xor ecx, ecx
mov r8, r13
mov r9d, 4
call _mi_ck_real_write_btree
mov ebx, eax
mov rsi, [rbp+var_500]
add rsi, 4
mov rdx, [r13+0]
mov rdi, r14
call _mi_dpointer
mov edx, [rbp+var_504]
dec edx
mov rax, [rbp+var_500]
mov [rax+3], dl
mov rax, [rbp+var_500]
mov [rax+2], dh
mov eax, edx
shr eax, 10h
mov rcx, [rbp+var_500]
mov [rcx+1], al
shr edx, 18h
mov rax, [rbp+var_500]
mov [rax], dl
test ebx, ebx
jnz loc_885E7
mov rdi, r14
mov rsi, r12
mov rdx, [rbp+var_518]
mov ecx, 3
mov r8, r15
call _mi_write_keypage
loc_88788:
mov ebx, eax
jmp loc_885E7
loc_8878F:
call ___stack_chk_fail
|
// bad sp value at call has been detected, the output may be wrong!
long long w_search_0(
long long *a1,
long long a2,
unsigned int a3,
unsigned __int8 *a4,
unsigned int a5,
long long a6,
long long a7,
long long a8,
long long a9,
char a10)
{
char *v14; // r15
long long v15; // r8
int v16; // eax
unsigned int v17; // r12d
unsigned int v18; // ebx
unsigned long long v20; // rax
char v21; // r10
long long *v22; // r12
int v23; // r14d
int v24; // eax
long long *v25; // rdi
const char *v26; // rsi
unsigned int v27; // eax
unsigned long long v28; // rax
long long v30; // rcx
unsigned int v31; // edi
long long v32; // r12
long long v33; // rcx
long long v34; // rcx
unsigned int v35; // edx
unsigned long long v36; // [rsp+0h] [rbp-520h] BYREF
unsigned long long v37; // [rsp+8h] [rbp-518h]
unsigned __int8 *v38; // [rsp+10h] [rbp-510h]
int v39; // [rsp+18h] [rbp-508h]
unsigned int v40; // [rsp+1Ch] [rbp-504h]
_BYTE *v41; // [rsp+20h] [rbp-500h] BYREF
char v42; // [rsp+2Fh] [rbp-4F1h] BYREF
unsigned __int8 v43; // [rsp+30h] [rbp-4F0h] BYREF
_WORD v44[607]; // [rsp+31h] [rbp-4EFh]
unsigned long long v45; // [rsp+4F0h] [rbp-30h]
v40 = a5;
v38 = a4;
v45 = __readfsqword(0x28u);
v14 = (char *)&v36 - ((*(unsigned __int16 *)(a2 + 14) + 2431) & 0xFFFFFFF0);
if ( !mi_fetch_keypage(a1, a2, a6) )
return (unsigned int)-1;
v37 = a6;
v15 = 2416LL;
if ( (a3 & 1) != 0 )
v15 = v40;
v39 = a3;
v16 = (*(long long ( **)(long long *, long long, char *, unsigned __int8 *, long long, _QWORD, _BYTE **, unsigned __int8 *, char *))(a2 + 64))(
a1,
a2,
v14,
v38,
v15,
a3,
&v41,
&v43,
&v42);
v17 = 0;
if ( *v14 < 0 )
v17 = *(_DWORD *)(*a1 + 380);
if ( v16 )
{
LABEL_7:
v18 = -1;
if ( v16 != 0x7FFFFFFF )
{
if ( !v42 )
a10 = 0;
v20 = mi_kpos(v17, (long long)v41);
v21 = a10;
v22 = a1;
v23 = (int)v38;
if ( v20 == -1LL
|| (v24 = w_search_0((_DWORD)v22, a2, v39, (_DWORD)v38, v40, v20, (long long)v14, (long long)v41, v37, a10),
v21 = a10,
v24 > 0) )
{
v18 = mi_insert((_DWORD)v22, a2, v23, (_DWORD)v14, (_DWORD)v41, (unsigned int)&v43, a7, a8, a9, v21);
if ( !(unsigned int)mi_write_keypage(v22, a2, v37, 3u, v14) )
return v18;
return (unsigned int)-1;
}
return (unsigned int)v24;
}
return v18;
}
v25 = (long long *)a2;
v26 = (const char *)v17;
v27 = (*(long long ( **)(long long, _QWORD, _BYTE **, unsigned __int8 *))(a2 + 72))(a2, v17, &v41, &v43);
if ( v27 )
{
v25 = a1;
v26 = 0LL;
v28 = mi_dpos(a1, 0, (long long)(&v43 + v27));
}
else
{
v28 = -1LL;
}
if ( *(char *)(a2 + 10) >= 0 )
{
a1[52] = v28;
*(_DWORD *)my_thread_var(v25, v26) = 121;
return (unsigned int)-1;
}
if ( v43 == 255LL )
v30 = (unsigned __int16)__ROL2__(v44[0], 8) + 3LL;
else
v30 = v43 + 1LL;
if ( (*(&v43 + v30) & 0x80) == 0 )
{
v39 = 4;
v16 = (*(long long ( **)(long long *, long long, char *, unsigned __int8 *, long long, long long, _BYTE **, unsigned __int8 *, char *))(a2 + 64))(
a1,
a2,
v14,
v38,
2416LL,
4LL,
&v41,
&v43,
&v42);
goto LABEL_7;
}
v31 = v17;
v40 = (*(&v43 + v30) << 24) | (unsigned __int16)__ROL2__(*(_WORD *)((char *)v44 + v30 + 1), 8) | (*((unsigned __int8 *)v44 + v30) << 16);
v36 = v28;
v32 = *a1 + 424;
v33 = *v38;
if ( v33 == 255 )
v34 = (unsigned __int16)__ROL2__(*(_WORD *)(v38 + 1), 8) + 3LL;
else
v34 = v33 + 1;
v41 += -*(unsigned __int16 *)(*a1 + 442) - v31;
v18 = mi_ck_real_write_btree((long long)a1, v32, (long long)&v38[v34], 0, &v36, 4);
mi_dpointer(a1, (long long)(v41 + 4), v36);
v35 = v40 - 1;
v41[3] = v40 - 1;
v41[2] = BYTE1(v35);
v41[1] = BYTE2(v35);
*v41 = HIBYTE(v35);
if ( !v18 )
return (unsigned int)mi_write_keypage(a1, v32, v37, 3u, v14);
return v18;
}
|
w_search:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x4f8
MOV RBX,R9
MOV dword ptr [RBP + -0x504],R8D
MOV qword ptr [RBP + -0x510],RCX
MOV R12D,EDX
MOV R13,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOVZX EAX,word ptr [RSI + 0xe]
MOV R15,RSP
ADD EAX,0x97f
AND EAX,0xfffffff0
SUB R15,RAX
MOV RSP,R15
MOV RDX,R9
MOV ECX,0x3
MOV R8,R15
XOR R9D,R9D
CALL 0x00183cb0
TEST RAX,RAX
JZ 0x001885e2
MOV qword ptr [RBP + -0x518],RBX
TEST R12B,0x1
MOV R8D,0x970
CMOVNZ R8D,dword ptr [RBP + -0x504]
SUB RSP,0x8
LEA RBX,[RBP + -0x4f1]
LEA RAX,[RBP + -0x4f0]
LEA R10,[RBP + -0x500]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x510]
MOV dword ptr [RBP + -0x508],R12D
MOV R9D,R12D
PUSH RBX
PUSH RAX
PUSH R10
CALL qword ptr [R13 + 0x40]
ADD RSP,0x20
CMP byte ptr [R15],0x0
MOV R12D,0x0
JNS 0x001884b2
MOV RCX,qword ptr [R14]
MOV R12D,dword ptr [RCX + 0x17c]
LAB_001884b2:
TEST EAX,EAX
JZ 0x0018858d
LAB_001884ba:
MOV EBX,0xffffffff
CMP EAX,0x7fffffff
JZ 0x001885e7
XOR EAX,EAX
CMP byte ptr [RBP + -0x4f1],0x0
MOVZX EBX,byte ptr [RBP + 0x28]
CMOVZ EBX,EAX
MOV RSI,qword ptr [RBP + -0x500]
MOV EDI,R12D
CALL 0x0018462a
MOVSX R10D,BL
CMP RAX,-0x1
MOV R12,R14
MOV R14,qword ptr [RBP + -0x510]
JZ 0x0018853d
MOV RDI,R12
MOV RSI,R13
MOV EDX,dword ptr [RBP + -0x508]
MOV RCX,R14
MOV R8D,dword ptr [RBP + -0x504]
MOV R9,RAX
PUSH R10
PUSH qword ptr [RBP + -0x518]
PUSH qword ptr [RBP + -0x500]
PUSH R15
MOV RBX,R10
CALL 0x001883d8
MOV R10,RBX
ADD RSP,0x20
TEST EAX,EAX
JLE 0x00188788
LAB_0018853d:
MOV R8,qword ptr [RBP + -0x500]
LEA R9,[RBP + -0x4f0]
MOV RDI,R12
MOV RSI,R13
MOV RDX,R14
MOV RCX,R15
PUSH R10
PUSH qword ptr [RBP + 0x20]
PUSH qword ptr [RBP + 0x18]
PUSH qword ptr [RBP + 0x10]
CALL 0x001888a3
ADD RSP,0x20
MOV EBX,EAX
MOV RDI,R12
MOV RSI,R13
MOV RDX,qword ptr [RBP + -0x518]
MOV ECX,0x3
MOV R8,R15
CALL 0x00183d5c
TEST EAX,EAX
JNZ 0x001885e2
JMP 0x001885e7
LAB_0018858d:
LEA RDX,[RBP + -0x500]
LEA RCX,[RBP + -0x4f0]
MOV RDI,R13
MOV ESI,R12D
CALL qword ptr [R13 + 0x48]
TEST EAX,EAX
JZ 0x001885c2
MOV EAX,EAX
LEA RDX,[RAX + RBP*0x1]
ADD RDX,-0x4f0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00184709
JMP 0x001885c9
LAB_001885c2:
MOV RAX,-0x1
LAB_001885c9:
TEST byte ptr [R13 + 0xa],0x80
JNZ 0x0018860b
MOV qword ptr [R14 + 0x1a0],RAX
CALL 0x001a1afa
MOV dword ptr [RAX],0x79
LAB_001885e2:
MOV EBX,0xffffffff
LAB_001885e7:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0018878f
MOV EAX,EBX
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018860b:
MOVZX ECX,byte ptr [RBP + -0x4f0]
CMP RCX,0xff
JZ 0x00188620
INC RCX
JMP 0x00188632
LAB_00188620:
MOVZX ECX,word ptr [RBP + -0x4ef]
ROL CX,0x8
MOVZX ECX,CX
ADD RCX,0x3
LAB_00188632:
MOVZX EDX,byte ptr [RBP + RCX*0x1 + -0x4f0]
SHL EDX,0x18
JS 0x00188687
SUB RSP,0x8
MOV dword ptr [RBP + -0x508],0x4
MOV RDI,R14
MOV RSI,R13
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x510]
MOV R8D,0x970
MOV R9D,0x4
PUSH RBX
LEA RAX,[RBP + -0x4f0]
PUSH RAX
LEA RAX,[RBP + -0x500]
PUSH RAX
CALL qword ptr [R13 + 0x40]
ADD RSP,0x20
JMP 0x001884ba
LAB_00188687:
MOV RDI,R12
MOVZX ESI,word ptr [RBP + RCX*0x1 + -0x4ee]
ROL SI,0x8
MOVZX ESI,SI
MOVZX ECX,byte ptr [RBP + RCX*0x1 + -0x4ef]
SHL ECX,0x10
OR ECX,ESI
OR ECX,EDX
MOV dword ptr [RBP + -0x504],ECX
MOV qword ptr [RBP + -0x520],RAX
MOV RAX,qword ptr [R14]
LEA R12,[RAX + 0x1a8]
MOV RDX,qword ptr [RBP + -0x510]
MOVZX ECX,byte ptr [RDX]
CMP RCX,0xff
JZ 0x001886d7
INC RCX
JMP 0x001886e6
LAB_001886d7:
MOVZX ECX,word ptr [RDX + 0x1]
ROL CX,0x8
MOVZX ECX,CX
ADD RCX,0x3
LAB_001886e6:
ADD RDX,RCX
MOVZX EAX,word ptr [RAX + 0x1ba]
ADD EDI,EAX
SUB qword ptr [RBP + -0x500],RDI
LEA R13,[RBP + -0x520]
MOV RDI,R14
MOV RSI,R12
XOR ECX,ECX
MOV R8,R13
MOV R9D,0x4
CALL 0x00188357
MOV EBX,EAX
MOV RSI,qword ptr [RBP + -0x500]
ADD RSI,0x4
MOV RDX,qword ptr [R13]
MOV RDI,R14
CALL 0x001853cf
MOV EDX,dword ptr [RBP + -0x504]
DEC EDX
MOV RAX,qword ptr [RBP + -0x500]
MOV byte ptr [RAX + 0x3],DL
MOV RAX,qword ptr [RBP + -0x500]
MOV byte ptr [RAX + 0x2],DH
MOV EAX,EDX
SHR EAX,0x10
MOV RCX,qword ptr [RBP + -0x500]
MOV byte ptr [RCX + 0x1],AL
SHR EDX,0x18
MOV RAX,qword ptr [RBP + -0x500]
MOV byte ptr [RAX],DL
TEST EBX,EBX
JNZ 0x001885e7
MOV RDI,R14
MOV RSI,R12
MOV RDX,qword ptr [RBP + -0x518]
MOV ECX,0x3
MOV R8,R15
CALL 0x00183d5c
LAB_00188788:
MOV EBX,EAX
JMP 0x001885e7
LAB_0018878f:
CALL 0x00129270
|
int w_search(long *param_1,long param_2,uint param_3,byte *param_4,int param_5,int8 param_6,
int8 param_7,int8 param_8,int8 param_9,char param_10)
{
code *pcVar1;
long lVar2;
int8 uVar3;
int iVar4;
int iVar5;
int iVar6;
uint uVar7;
long lVar8;
int4 *puVar9;
long lVar10;
long lVar11;
byte *pbVar12;
int1 *puVar13;
char *pcVar14;
long in_FS_OFFSET;
long alStack_550 [5];
long local_528;
int8 local_520;
byte *local_518;
uint local_510;
int local_50c;
int1 *local_508;
char local_4f9;
byte local_4f8;
int1 local_4f7 [1215];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar2 = -(ulong)(*(ushort *)(param_2 + 0xe) + 0x97f & 0xfffffff0);
pcVar14 = (char *)((long)&local_528 + lVar2);
local_518 = param_4;
local_50c = param_5;
*(int8 *)((long)alStack_550 + lVar2 + 0x20) = 0x18843b;
lVar8 = _mi_fetch_keypage(param_1,param_2,param_6,3,pcVar14,0);
pbVar12 = local_518;
if (lVar8 != 0) {
iVar6 = 0x970;
if ((param_3 & 1) != 0) {
iVar6 = local_50c;
}
local_520 = param_6;
local_510 = param_3;
*(char **)((long)alStack_550 + lVar2 + 0x18) = &local_4f9;
*(byte **)((long)alStack_550 + lVar2 + 0x10) = &local_4f8;
*(int1 ***)((long)alStack_550 + lVar2 + 8) = &local_508;
pcVar1 = *(code **)(param_2 + 0x40);
*(int8 *)((long)alStack_550 + lVar2) = 0x188498;
iVar4 = (*pcVar1)(param_1,param_2,pcVar14,pbVar12,iVar6,param_3);
iVar6 = 0;
if (*pcVar14 < '\0') {
iVar6 = *(int *)(*param_1 + 0x17c);
}
if (iVar4 == 0) {
pcVar1 = *(code **)(param_2 + 0x48);
*(int8 *)((long)alStack_550 + lVar2 + 0x20) = 0x1885a5;
uVar7 = (*pcVar1)(param_2,iVar6,&local_508,&local_4f8);
if (uVar7 == 0) {
lVar8 = -1;
}
else {
*(int8 *)((long)alStack_550 + lVar2 + 0x20) = 0x1885c0;
lVar8 = _mi_dpos(param_1,0,&local_4f8 + uVar7);
}
pbVar12 = local_518;
if ((*(byte *)(param_2 + 10) & 0x80) == 0) {
param_1[0x34] = lVar8;
*(int8 *)((long)alStack_550 + lVar2 + 0x20) = 0x1885dc;
puVar9 = (int4 *)_my_thread_var();
*puVar9 = 0x79;
goto LAB_001885e2;
}
if ((ulong)local_4f8 == 0xff) {
lVar10 = (ulong)(ushort)(local_4f7._0_2_ << 8 | (ushort)local_4f7._0_2_ >> 8) + 3;
}
else {
lVar10 = (ulong)local_4f8 + 1;
}
if ((int)((uint)(&local_4f8)[lVar10] << 0x18) < 0) {
local_50c = CONCAT13((&local_4f8)[lVar10],
CONCAT12(local_4f7[lVar10],
*(ushort *)(local_4f7 + lVar10 + 1) << 8 |
*(ushort *)(local_4f7 + lVar10 + 1) >> 8));
lVar10 = *param_1 + 0x1a8;
if ((ulong)*local_518 == 0xff) {
lVar11 = (ulong)(ushort)(*(ushort *)(local_518 + 1) << 8 | *(ushort *)(local_518 + 1) >> 8
) + 3;
}
else {
lVar11 = (ulong)*local_518 + 1;
}
pbVar12 = local_518 + lVar11;
local_508 = local_508 + -(ulong)(iVar6 + (uint)*(ushort *)(*param_1 + 0x1ba));
local_528 = lVar8;
*(int8 *)((long)alStack_550 + lVar2 + 0x20) = 0x188716;
iVar5 = _mi_ck_real_write_btree(param_1,lVar10,pbVar12,0,&local_528,4);
lVar8 = local_528;
puVar13 = local_508 + 4;
*(int8 *)((long)alStack_550 + lVar2 + 0x20) = 0x18872f;
_mi_dpointer(param_1,puVar13,lVar8);
uVar3 = local_520;
iVar6 = local_50c + -1;
local_508[3] = (char)iVar6;
local_508[2] = (char)((uint)iVar6 >> 8);
local_508[1] = (char)((uint)iVar6 >> 0x10);
*local_508 = (char)((uint)iVar6 >> 0x18);
if (iVar5 == 0) {
*(int8 *)((long)alStack_550 + lVar2 + 0x20) = 0x188788;
iVar5 = _mi_write_keypage(param_1,lVar10,uVar3,3,pcVar14);
}
goto LAB_001885e7;
}
local_510 = 4;
*(char **)((long)alStack_550 + lVar2 + 0x18) = &local_4f9;
*(byte **)((long)alStack_550 + lVar2 + 0x10) = &local_4f8;
*(int1 ***)((long)alStack_550 + lVar2 + 8) = &local_508;
pcVar1 = *(code **)(param_2 + 0x40);
*(int8 *)((long)alStack_550 + lVar2) = 0x18867e;
iVar4 = (*pcVar1)(param_1,param_2,pcVar14,pbVar12,0x970,4);
}
puVar13 = local_508;
iVar5 = -1;
if (iVar4 == 0x7fffffff) goto LAB_001885e7;
if (local_4f9 == '\0') {
param_10 = '\0';
}
*(int8 *)((long)alStack_550 + lVar2 + 0x20) = 0x1884e9;
lVar8 = _mi_kpos(iVar6,puVar13);
iVar6 = local_50c;
uVar7 = local_510;
pbVar12 = local_518;
if (lVar8 != -1) {
*(ulong *)((long)alStack_550 + lVar2 + 0x20) = (ulong)(uint)(int)param_10;
*(int8 *)((long)alStack_550 + lVar2 + 0x18) = local_520;
*(int1 **)((long)alStack_550 + lVar2 + 0x10) = local_508;
*(char **)((long)alStack_550 + lVar2 + 8) = pcVar14;
*(int8 *)((long)alStack_550 + lVar2) = 0x18852e;
iVar5 = w_search(param_1,param_2,uVar7,pbVar12,iVar6,lVar8);
if (iVar5 < 1) goto LAB_001885e7;
}
puVar13 = local_508;
*(ulong *)((long)alStack_550 + lVar2 + 0x20) = (ulong)(uint)(int)param_10;
*(int8 *)((long)alStack_550 + lVar2 + 0x18) = param_9;
*(int8 *)((long)alStack_550 + lVar2 + 0x10) = param_8;
*(int8 *)((long)alStack_550 + lVar2 + 8) = param_7;
*(int8 *)((long)alStack_550 + lVar2) = 0x188567;
iVar5 = _mi_insert(param_1,param_2,pbVar12,pcVar14,puVar13,&local_4f8);
uVar3 = local_520;
*(int8 *)((long)alStack_550 + lVar2 + 0x20) = 0x188587;
iVar6 = _mi_write_keypage(param_1,param_2,uVar3,3,pcVar14);
if (iVar6 == 0) goto LAB_001885e7;
}
LAB_001885e2:
iVar5 = -1;
LAB_001885e7:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)((long)alStack_550 + lVar2 + 0x20) = _mi_enlarge_root;
__stack_chk_fail();
}
return iVar5;
}
|
|
17,269
|
POINTonE2_is_equal
|
corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/e2.c
|
void blst_p2_add(POINTonE2 *out, const POINTonE2 *a, const POINTonE2 *b)
{ POINTonE2_add(out, a, b); }
|
O3
|
c
|
POINTonE2_is_equal:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rsi, %r15
movq %rdi, %r12
movl $0xc0, %r14d
leaq (%rdi,%r14), %rbx
movl $0x60, %esi
movq %rbx, %rdi
movq %rbx, -0x30(%rbp)
callq 0x6e900
movq %rax, -0x38(%rbp)
leaq (%r15,%r14), %r13
movl $0x60, %esi
movq %r13, %rdi
callq 0x6e900
movq %rax, %r14
leaq 0x2ea80(%rip), %rdx # 0x8a910
leaq -0x100(%rbp), %rdi
movabsq $-0x760c000300030003, %rcx # imm = 0x89F3FFFCFFFCFFFD
movq %rbx, %rsi
movq %rdx, %rbx
callq 0x71ca0
leaq -0xa0(%rbp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
movabsq $-0x760c000300030003, %rcx # imm = 0x89F3FFFCFFFCFFFD
callq 0x71ca0
leaq -0x1c0(%rbp), %rdi
movq %r12, %rsi
leaq -0xa0(%rbp), %rdx
movq %rbx, %rcx
movabsq $-0x760c000300030003, %r8 # imm = 0x89F3FFFCFFFCFFFD
callq 0x71b60
leaq -0x280(%rbp), %rdi
movq %r15, %rsi
leaq -0x100(%rbp), %rdx
movq %rbx, %rcx
movabsq $-0x760c000300030003, %r8 # imm = 0x89F3FFFCFFFCFFFD
callq 0x71b60
leaq -0x160(%rbp), %rdi
addq $0x60, %r12
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movabsq $-0x760c000300030003, %r8 # imm = 0x89F3FFFCFFFCFFFD
callq 0x71b60
leaq -0x220(%rbp), %r12
addq $0x60, %r15
movq %r12, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rcx
movabsq $-0x760c000300030003, %r8 # imm = 0x89F3FFFCFFFCFFFD
movq %r8, %r15
callq 0x71b60
leaq -0x160(%rbp), %rdi
movq %rdi, %rsi
leaq -0xa0(%rbp), %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x71b60
movq %r12, %rdi
movq %r12, %rsi
leaq -0x100(%rbp), %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x71b60
movl $0xc0, %edx
leaq -0x1c0(%rbp), %rdi
leaq -0x280(%rbp), %rsi
callq 0x6e940
xorq -0x38(%rbp), %r14
xorq $0x1, %r14
andq %r14, %rax
addq $0x258, %rsp # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
POINTonE2_is_equal:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 258h
mov r15, rsi
mov r12, rdi
mov r14d, 0C0h
lea rbx, [rdi+r14]
mov esi, 60h ; '`'
mov rdi, rbx
mov [rbp+var_30], rbx
call vec_is_zero_16x
mov [rbp+var_38], rax
lea r13, [r15+r14]
mov esi, 60h ; '`'
mov rdi, r13
call vec_is_zero_16x
mov r14, rax
lea rdx, BLS12_381_P
lea rdi, [rbp+var_100]
mov rcx, 89F3FFFCFFFCFFFDh
mov rsi, rbx
mov rbx, rdx
call sqr_mont_384x
lea rdi, [rbp+var_A0]
mov rsi, r13
mov rdx, rbx
mov rcx, 89F3FFFCFFFCFFFDh
call sqr_mont_384x
lea rdi, [rbp+var_1C0]
mov rsi, r12
lea rdx, [rbp+var_A0]
mov rcx, rbx
mov r8, 89F3FFFCFFFCFFFDh
call mul_mont_384x
lea rdi, [rbp+var_280]
mov rsi, r15
lea rdx, [rbp+var_100]
mov rcx, rbx
mov r8, 89F3FFFCFFFCFFFDh
call mul_mont_384x
lea rdi, [rbp+var_160]
add r12, 60h ; '`'
mov rsi, r12
mov rdx, r13
mov rcx, rbx
mov r8, 89F3FFFCFFFCFFFDh
call mul_mont_384x
lea r12, [rbp+var_220]
add r15, 60h ; '`'
mov rdi, r12
mov rsi, r15
mov rdx, [rbp+var_30]
mov rcx, rbx
mov r8, 89F3FFFCFFFCFFFDh
mov r15, r8
call mul_mont_384x
lea rdi, [rbp+var_160]
mov rsi, rdi
lea rdx, [rbp+var_A0]
mov rcx, rbx
mov r8, r15
call mul_mont_384x
mov rdi, r12
mov rsi, r12
lea rdx, [rbp+var_100]
mov rcx, rbx
mov r8, r15
call mul_mont_384x
mov edx, 0C0h
lea rdi, [rbp+var_1C0]
lea rsi, [rbp+var_280]
call vec_is_equal_16x
xor r14, [rbp+var_38]
xor r14, 1
and rax, r14
add rsp, 258h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long POINTonE2_is_equal(long long a1, long long a2)
{
long long v2; // r14
long long is_equal_16x; // rax
_BYTE v5[96]; // [rsp+0h] [rbp-280h] BYREF
_BYTE v6[96]; // [rsp+60h] [rbp-220h] BYREF
_BYTE v7[96]; // [rsp+C0h] [rbp-1C0h] BYREF
_BYTE v8[96]; // [rsp+120h] [rbp-160h] BYREF
_BYTE v9[96]; // [rsp+180h] [rbp-100h] BYREF
_BYTE v10[104]; // [rsp+1E0h] [rbp-A0h] BYREF
long long is_zero_16x; // [rsp+248h] [rbp-38h]
long long v12; // [rsp+250h] [rbp-30h]
v12 = a1 + 192;
is_zero_16x = vec_is_zero_16x(a1 + 192, 96LL);
v2 = vec_is_zero_16x(a2 + 192, 96LL);
sqr_mont_384x(v9, a1 + 192, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
sqr_mont_384x(v10, a2 + 192, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384x(v7, a1, v10, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384x(v5, a2, v9, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384x(v8, a1 + 96, a2 + 192, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384x(v6, a2 + 96, v12, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384x(v8, v8, v10, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384x(v6, v6, v9, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
is_equal_16x = vec_is_equal_16x(v7, v5, 192LL);
return (is_zero_16x ^ v2 ^ 1) & is_equal_16x;
}
|
POINTonE2_is_equal:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x258
MOV R15,RSI
MOV R12,RDI
MOV R14D,0xc0
LEA RBX,[RDI + R14*0x1]
MOV ESI,0x60
MOV RDI,RBX
MOV qword ptr [RBP + -0x30],RBX
CALL 0x0016e900
MOV qword ptr [RBP + -0x38],RAX
LEA R13,[R15 + R14*0x1]
MOV ESI,0x60
MOV RDI,R13
CALL 0x0016e900
MOV R14,RAX
LEA RDX,[0x18a910]
LEA RDI,[RBP + -0x100]
MOV RCX,-0x760c000300030003
MOV RSI,RBX
MOV RBX,RDX
CALL 0x00171ca0
LEA RDI,[RBP + -0xa0]
MOV RSI,R13
MOV RDX,RBX
MOV RCX,-0x760c000300030003
CALL 0x00171ca0
LEA RDI,[RBP + -0x1c0]
MOV RSI,R12
LEA RDX,[RBP + -0xa0]
MOV RCX,RBX
MOV R8,-0x760c000300030003
CALL 0x00171b60
LEA RDI,[RBP + -0x280]
MOV RSI,R15
LEA RDX,[RBP + -0x100]
MOV RCX,RBX
MOV R8,-0x760c000300030003
CALL 0x00171b60
LEA RDI,[RBP + -0x160]
ADD R12,0x60
MOV RSI,R12
MOV RDX,R13
MOV RCX,RBX
MOV R8,-0x760c000300030003
CALL 0x00171b60
LEA R12,[RBP + -0x220]
ADD R15,0x60
MOV RDI,R12
MOV RSI,R15
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,RBX
MOV R8,-0x760c000300030003
MOV R15,R8
CALL 0x00171b60
LEA RDI,[RBP + -0x160]
MOV RSI,RDI
LEA RDX,[RBP + -0xa0]
MOV RCX,RBX
MOV R8,R15
CALL 0x00171b60
MOV RDI,R12
MOV RSI,R12
LEA RDX,[RBP + -0x100]
MOV RCX,RBX
MOV R8,R15
CALL 0x00171b60
MOV EDX,0xc0
LEA RDI,[RBP + -0x1c0]
LEA RSI,[RBP + -0x280]
CALL 0x0016e940
XOR R14,qword ptr [RBP + -0x38]
XOR R14,0x1
AND RAX,R14
ADD RSP,0x258
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong POINTonE2_is_equal(long param_1,long param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int1 local_288 [96];
int1 local_228 [96];
int1 local_1c8 [96];
int1 local_168 [96];
int1 local_108 [96];
int1 local_a8 [104];
ulong local_40;
long local_38;
lVar1 = param_1 + 0xc0;
local_38 = lVar1;
local_40 = vec_is_zero_16x(lVar1,0x60);
lVar2 = param_2 + 0xc0;
uVar3 = vec_is_zero_16x(lVar2,0x60);
sqr_mont_384x(local_108,lVar1,BLS12_381_P,0x89f3fffcfffcfffd);
sqr_mont_384x(local_a8,lVar2,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384x(local_1c8,param_1,local_a8,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384x(local_288,param_2,local_108,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384x(local_168,param_1 + 0x60,lVar2,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384x(local_228,param_2 + 0x60,local_38,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384x(local_168,local_168,local_a8,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384x(local_228,local_228,local_108,BLS12_381_P,0x89f3fffcfffcfffd);
uVar4 = vec_is_equal_16x(local_1c8,local_288,0xc0);
return uVar4 & (uVar3 ^ local_40 ^ 1);
}
|
|
17,270
|
coro::detail::engine::engine()
|
tinyCoroLab/include/coro/engine.hpp
|
engine() noexcept { m_id = ginfo.engine_id.fetch_add(1, std::memory_order_relaxed); }
|
O3
|
cpp
|
coro::detail::engine::engine():
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x0, 0x8(%rdi)
xorl %edi, %edi
xorl %esi, %esi
callq 0x7330
movl %eax, 0x8(%rbx)
leaq 0x180(%rbx), %rdi
leaq 0xf(%rsp), %rdx
movl $0x4000, %esi # imm = 0x4000
callq 0x20f60
movl $0x1, %eax
lock
xaddl %eax, 0x10564(%rip) # 0x314b4
movl %eax, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x86bc
|
_ZN4coro6detail6engineC2Ev:
push rbx
sub rsp, 10h
mov rbx, rdi
mov dword ptr [rdi+8], 0
xor edi, edi
xor esi, esi
call _eventfd
mov [rbx+8], eax
lea rdi, [rbx+180h]
lea rdx, [rsp+18h+var_9]
mov esi, 4000h
call _ZN12atomic_queue13AtomicQueueB2INSt7__n486116coroutine_handleIvEESaIS3_ELb1ELb0ELb0EEC2EjRKS4_; atomic_queue::AtomicQueueB2<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>,true,false,false>::AtomicQueueB2(uint,std::allocator<std::__n4861::coroutine_handle<void>> const&)
mov eax, 1
lock xadd cs:dword_314B4, eax
mov [rbx], eax
add rsp, 10h
pop rbx
retn
mov rdi, rax
call __clang_call_terminate
|
long long coro::detail::engine::engine(coro::detail::engine *this)
{
long long result; // rax
_BYTE v2[9]; // [rsp+Fh] [rbp-9h] BYREF
*((_DWORD *)this + 2) = 0;
*((_DWORD *)this + 2) = eventfd(0LL, 0LL);
atomic_queue::AtomicQueueB2<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>,true,false,false>::AtomicQueueB2(
(char *)this + 384,
0x4000LL,
v2);
result = (unsigned int)_InterlockedExchangeAdd(&dword_314B4, 1u);
*(_DWORD *)this = result;
return result;
}
|
engine:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV dword ptr [RDI + 0x8],0x0
XOR EDI,EDI
XOR ESI,ESI
CALL 0x00107330
MOV dword ptr [RBX + 0x8],EAX
LEA RDI,[RBX + 0x180]
LAB_00120f34:
LEA RDX,[RSP + 0xf]
MOV ESI,0x4000
CALL 0x00120f60
MOV EAX,0x1
XADD.LOCK dword ptr [0x001314b4],EAX
MOV dword ptr [RBX],EAX
ADD RSP,0x10
POP RBX
RET
|
/* coro::detail::engine::engine() */
void __thiscall coro::detail::engine::engine(engine *this)
{
int iVar1;
*(int4 *)(this + 8) = 0;
iVar1 = eventfd(0,0);
*(int *)(this + 8) = iVar1;
/* try { // try from 00120f34 to 00120f42 has its CatchHandler @ 00120f58 */
atomic_queue::
AtomicQueueB2<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>,true,false,false>
::AtomicQueueB2((int)this + 0x180,(allocator *)0x4000);
LOCK();
UNLOCK();
iVar1 = DAT_001314b4 + 1;
*(int *)this = DAT_001314b4;
DAT_001314b4 = iVar1;
return;
}
|
|
17,271
|
bitmap_copy
|
eloqsql/mysys/my_bitmap.c
|
void bitmap_copy(MY_BITMAP *map, const MY_BITMAP *map2)
{
my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end;
DBUG_ASSERT(map->bitmap);
DBUG_ASSERT(map2->bitmap);
DBUG_ASSERT(map->n_bits == map2->n_bits);
end= map->last_word_ptr;
while (to <= end)
*to++ = *from++;
}
|
O3
|
c
|
bitmap_copy:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rcx, %rax
ja 0x9e944
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
movl (%rdx), %esi
addq $0x4, %rdx
movl %esi, (%rax)
addq $0x4, %rax
cmpq %rcx, %rax
jbe 0x9e932
popq %rbp
retq
|
bitmap_copy:
mov rax, [rdi]
mov rcx, [rdi+8]
cmp rax, rcx
ja short locret_9E944
push rbp
mov rbp, rsp
mov rdx, [rsi]
loc_9E932:
mov esi, [rdx]
add rdx, 4
mov [rax], esi
add rax, 4
cmp rax, rcx
jbe short loc_9E932
pop rbp
locret_9E944:
retn
|
_DWORD * bitmap_copy(long long a1, int **a2)
{
_DWORD *result; // rax
unsigned long long v3; // rcx
int *v4; // rdx
int v5; // esi
result = *(_DWORD **)a1;
v3 = *(_QWORD *)(a1 + 8);
if ( *(_QWORD *)a1 <= v3 )
{
v4 = *a2;
do
{
v5 = *v4++;
*result++ = v5;
}
while ( (unsigned long long)result <= v3 );
}
return result;
}
|
bitmap_copy:
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x8]
CMP RAX,RCX
JA 0x0019e944
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RSI]
LAB_0019e932:
MOV ESI,dword ptr [RDX]
ADD RDX,0x4
MOV dword ptr [RAX],ESI
ADD RAX,0x4
CMP RAX,RCX
JBE 0x0019e932
POP RBP
LAB_0019e944:
RET
|
void bitmap_copy(int8 *param_1,int8 *param_2)
{
int4 uVar1;
int4 *puVar2;
int4 *puVar3;
int4 *puVar4;
puVar3 = (int4 *)*param_1;
puVar2 = (int4 *)param_1[1];
if (puVar3 <= puVar2) {
puVar4 = (int4 *)*param_2;
do {
uVar1 = *puVar4;
puVar4 = puVar4 + 1;
*puVar3 = uVar1;
puVar3 = puVar3 + 1;
} while (puVar3 <= puVar2);
}
return;
}
|
|
17,272
|
common_arg::set_env(char const*)
|
monkey531[P]llama/common/arg.cpp
|
common_arg & common_arg::set_env(const char * env) {
help = help + "\n(env: " + env + ")";
this->env = env;
return *this;
}
|
O1
|
cpp
|
common_arg::set_env(char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x90(%rdi), %rsi
movq 0x98(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2d612
leaq 0xc6835(%rip), %rsi # 0xf6d20
movq %r15, %rdi
callq 0x1c1b0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1c1b0
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x30527
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x3052f
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xd4301(%rip), %rsi # 0x104853
callq 0x1c1b0
leaq 0x90(%rbx), %rdi
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x30585
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x3058c
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r15, %rsi
callq 0x1bac0
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x305c5
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x305dc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x305f3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq %r14, 0x88(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x3062d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8f0
jmp 0x3062d
jmp 0x3062a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x30644
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq %rbx, %rdi
callq 0x1c020
|
_ZN10common_arg7set_envEPKc:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, rsi
mov rbx, rdi
lea r12, [rsp+98h+var_80]
mov [r12-10h], r12
mov rsi, [rdi+90h]
mov rdx, [rdi+98h]
add rdx, rsi
lea r15, [rsp+98h+var_90]
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rsi, aEnv; "\n(env: "
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+98h+var_90]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r13, [rsp+98h+var_60]
mov [r13-10h], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_30527
mov [rsp+98h+var_70], rdx
mov rdx, [rcx]
mov [rsp+98h+var_60], rdx
jmp short loc_3052F
loc_30527:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
loc_3052F:
mov rdx, [rax+8]
lea rdi, [rsp+98h+var_70]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rsi, a09401910201912+51h; ")"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rbx+90h]
lea rbp, [rsp+98h+var_40]
mov [rbp-10h], rbp
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_30585
mov [rsp+98h+var_50], rdx
mov rdx, [rcx]
mov [rsp+98h+var_40], rdx
jmp short loc_3058C
loc_30585:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rbp+0], xmm0
loc_3058C:
mov rdx, [rax+8]
lea r15, [rsp+98h+var_50]
mov [r15+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r15]; void *
cmp rdi, rbp
jz short loc_305C5
mov rsi, [rsp+98h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_305C5:
mov rdi, [rsp+98h+var_70]; void *
cmp rdi, r13
jz short loc_305DC
mov rsi, [rsp+98h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_305DC:
mov rdi, [rsp+98h+var_90]; void *
cmp rdi, r12
jz short loc_305F3
mov rsi, [rsp+98h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_305F3:
mov [rbx+88h], r14
mov rax, rbx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_3062D
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_3062D
jmp short $+2
loc_3062A:
mov rbx, rax
loc_3062D:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_30644
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_30644:
mov rdi, rbx
call __Unwind_Resume
|
common_arg * common_arg::set_env(common_arg *this, const char *a2)
{
long long v2; // rax
__int128 *v3; // rcx
long long v4; // rax
_OWORD *v5; // rcx
void *v7[2]; // [rsp+8h] [rbp-90h] BYREF
_QWORD v8[2]; // [rsp+18h] [rbp-80h] BYREF
void *v9[2]; // [rsp+28h] [rbp-70h] BYREF
__int128 v10; // [rsp+38h] [rbp-60h] BYREF
void *v11[2]; // [rsp+48h] [rbp-50h] BYREF
_OWORD v12[4]; // [rsp+58h] [rbp-40h] BYREF
v7[0] = v8;
std::string::_M_construct<char *>(v7, *((_BYTE **)this + 18), *((_QWORD *)this + 18) + *((_QWORD *)this + 19));
std::string::append(v7, "\n(env: ");
v2 = std::string::append(v7, a2);
v9[0] = &v10;
v3 = (__int128 *)(v2 + 16);
if ( *(_QWORD *)v2 == v2 + 16 )
{
v10 = *v3;
}
else
{
v9[0] = *(void **)v2;
*(_QWORD *)&v10 = *(_QWORD *)v3;
}
v9[1] = *(void **)(v2 + 8);
*(_QWORD *)v2 = v3;
*(_QWORD *)(v2 + 8) = 0LL;
*(_BYTE *)(v2 + 16) = 0;
v4 = std::string::append(v9, ")");
v11[0] = v12;
v5 = (_OWORD *)(v4 + 16);
if ( *(_QWORD *)v4 == v4 + 16 )
{
v12[0] = *v5;
}
else
{
v11[0] = *(void **)v4;
*(_QWORD *)&v12[0] = *(_QWORD *)v5;
}
v11[1] = *(void **)(v4 + 8);
*(_QWORD *)v4 = v5;
*(_QWORD *)(v4 + 8) = 0LL;
*(_BYTE *)(v4 + 16) = 0;
std::string::operator=((char *)this + 144, v11);
if ( v11[0] != v12 )
operator delete(v11[0], *(_QWORD *)&v12[0] + 1LL);
if ( v9[0] != &v10 )
operator delete(v9[0], v10 + 1);
if ( v7[0] != v8 )
operator delete(v7[0], v8[0] + 1LL);
*((_QWORD *)this + 17) = a2;
return this;
}
|
set_env:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RSI
MOV RBX,RDI
LEA R12,[RSP + 0x18]
MOV qword ptr [R12 + -0x10],R12
MOV RSI,qword ptr [RDI + 0x90]
MOV RDX,qword ptr [RDI + 0x98]
ADD RDX,RSI
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x0012d612
LAB_001304e4:
LEA RSI,[0x1f6d20]
MOV RDI,R15
CALL 0x0011c1b0
LAB_001304f3:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x0011c1b0
LEA R13,[RSP + 0x38]
MOV qword ptr [R13 + -0x10],R13
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00130527
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x38],RDX
JMP 0x0013052f
LAB_00130527:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R13],XMM0
LAB_0013052f:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x28]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_0013054b:
LEA RSI,[0x204853]
CALL 0x0011c1b0
LAB_00130557:
LEA RDI,[RBX + 0x90]
LEA RBP,[RSP + 0x58]
MOV qword ptr [RBP + -0x10],RBP
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00130585
MOV qword ptr [RSP + 0x48],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x58],RDX
JMP 0x0013058c
LAB_00130585:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RBP],XMM0
LAB_0013058c:
MOV RDX,qword ptr [RAX + 0x8]
LEA R15,[RSP + 0x48]
MOV qword ptr [R15 + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RSI,R15
CALL 0x0011bac0
MOV RDI,qword ptr [R15]
CMP RDI,RBP
JZ 0x001305c5
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0011b8f0
LAB_001305c5:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x001305dc
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011b8f0
LAB_001305dc:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x001305f3
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8f0
LAB_001305f3:
MOV qword ptr [RBX + 0x88],R14
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* common_arg::set_env(char const*) */
common_arg * __thiscall common_arg::set_env(common_arg *this,char *param_1)
{
long *plVar1;
long *plVar2;
long *local_90 [2];
long local_80 [2];
long *local_70;
long local_68;
long local_60;
long lStack_58;
long *local_50;
long local_48;
long local_40;
long lStack_38;
local_90[0] = local_80;
std::__cxx11::string::_M_construct<char*>
(local_90,*(long *)(this + 0x90),*(long *)(this + 0x98) + *(long *)(this + 0x90));
/* try { // try from 001304e4 to 001304f2 has its CatchHandler @ 0013062a */
std::__cxx11::string::append((char *)local_90);
/* try { // try from 001304f3 to 001304ff has its CatchHandler @ 00130628 */
plVar1 = (long *)std::__cxx11::string::append((char *)local_90);
plVar2 = plVar1 + 2;
if ((long *)*plVar1 == plVar2) {
local_60 = *plVar2;
lStack_58 = plVar1[3];
local_70 = &local_60;
}
else {
local_60 = *plVar2;
local_70 = (long *)*plVar1;
}
local_68 = plVar1[1];
*plVar1 = (long)plVar2;
plVar1[1] = 0;
*(int1 *)(plVar1 + 2) = 0;
/* try { // try from 0013054b to 00130556 has its CatchHandler @ 0013060c */
plVar1 = (long *)std::__cxx11::string::append((char *)&local_70);
plVar2 = plVar1 + 2;
if ((long *)*plVar1 == plVar2) {
local_40 = *plVar2;
lStack_38 = plVar1[3];
local_50 = &local_40;
}
else {
local_40 = *plVar2;
local_50 = (long *)*plVar1;
}
local_48 = plVar1[1];
*plVar1 = (long)plVar2;
plVar1[1] = 0;
*(int1 *)(plVar1 + 2) = 0;
std::__cxx11::string::operator=((string *)(this + 0x90),(string *)&local_50);
if (local_50 != &local_40) {
operator_delete(local_50,local_40 + 1);
}
if (local_70 != &local_60) {
operator_delete(local_70,local_60 + 1);
}
if (local_90[0] != local_80) {
operator_delete(local_90[0],local_80[0] + 1);
}
*(char **)(this + 0x88) = param_1;
return this;
}
|
|
17,273
|
nglog::(anonymous namespace)::LogCleaner::IsLogLastModifiedOver(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&) const
|
ng-log[P]ng-log/src/logging.cc
|
bool LogCleaner::IsLogLastModifiedOver(
const string& filepath,
const std::chrono::system_clock::time_point& current_time) const {
// Try to get the last modified time of this file.
struct stat file_stat;
if (stat(filepath.c_str(), &file_stat) == 0) {
const auto last_modified_time =
std::chrono::system_clock::from_time_t(file_stat.st_mtime);
const auto diff = current_time - last_modified_time;
return diff >= overdue_;
}
// If failed to get file stat, don't return true!
return false;
}
|
O0
|
cpp
|
nglog::(anonymous namespace)::LogCleaner::IsLogLastModifiedOver(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&) const:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x92c0
movq %rax, %rdi
leaq -0xb0(%rbp), %rsi
callq 0x9630
cmpl $0x0, %eax
jne 0x15e24
movq -0x58(%rbp), %rdi
callq 0x18da0
movq %rax, -0xb8(%rbp)
movq -0x20(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x18d50
movq -0xc8(%rbp), %rsi
movq %rax, -0xc0(%rbp)
addq $0x8, %rsi
leaq -0xc0(%rbp), %rdi
callq 0x1b5f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x15e28
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZNK5nglog12_GLOBAL__N_110LogCleaner21IsLogLastModifiedOverERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNSt6chrono10time_pointINSA_3_V212system_clockENSA_8durationIlSt5ratioILl1ELl1000000000EEEEEE:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov [rbp+var_C8], rax
mov rdi, [rbp+var_18]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, rax
lea rsi, [rbp+var_B0]; __int64
call _stat
cmp eax, 0
jnz short loc_15E24
mov rdi, [rbp+var_58]; this
call _ZNSt6chrono3_V212system_clock11from_time_tEl; std::chrono::_V2::system_clock::from_time_t(long)
mov [rbp+var_B8], rax
mov rdi, [rbp+var_20]
lea rsi, [rbp+var_B8]
call _ZNSt6chronomiINS_3_V212system_clockENS_8durationIlSt5ratioILl1ELl1000000000EEEES6_EENSt11common_typeIJT0_T1_EE4typeERKNS_10time_pointIT_S8_EERKNSC_ISD_S9_EE; std::chrono::operator-<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>,std::chrono::duration<long,std::ratio<1l,1000000000l>>>(std::chrono::time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>> const&,std::chrono::time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>> const&)
mov rsi, [rbp+var_C8]
mov [rbp+var_C0], rax
add rsi, 8
lea rdi, [rbp+var_C0]
call _ZNSt6chronogeIlSt5ratioILl1ELl1000000000EElS1_ILl60ELl1EEEEbRKNS_8durationIT_T0_EERKNS4_IT1_T2_EE; std::chrono::operator>=<long,std::ratio<1l,1000000000l>,long,std::ratio<60l,1l>>(std::chrono::duration<long,std::ratio<1l,1000000000l>> const&,std::chrono::duration<long,std::ratio<60l,1l>> const&)
and al, 1
mov [rbp+var_1], al
jmp short loc_15E28
loc_15E24:
mov [rbp+var_1], 0
loc_15E28:
mov al, [rbp+var_1]
and al, 1
add rsp, 0D0h
pop rbp
retn
|
char nglog::`anonymous namespace'::LogCleaner::IsLogLastModifiedOver(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v5; // [rsp+10h] [rbp-C0h] BYREF
long long v6; // [rsp+18h] [rbp-B8h] BYREF
long long v7[18]; // [rsp+20h] [rbp-B0h] BYREF
long long v8; // [rsp+B0h] [rbp-20h]
long long v9; // [rsp+B8h] [rbp-18h]
long long v10; // [rsp+C0h] [rbp-10h]
v10 = a1;
v9 = a2;
v8 = a3;
v3 = std::string::c_str(a2);
if ( (unsigned int)stat(v3, v7) )
return 0;
v6 = std::chrono::_V2::system_clock::from_time_t((std::chrono::_V2::system_clock *)v7[11], (long long)v7);
v5 = std::chrono::operator-<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>,std::chrono::duration<long,std::ratio<1l,1000000000l>>>(
v8,
&v6);
return std::chrono::operator>=<long,std::ratio<1l,1000000000l>,long,std::ratio<60l,1l>>(&v5, a1 + 8) & 1;
}
|
IsLogLastModifiedOver:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0xc8],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001092c0
MOV RDI,RAX
LEA RSI,[RBP + -0xb0]
CALL 0x00109630
CMP EAX,0x0
JNZ 0x00115e24
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x00118da0
MOV qword ptr [RBP + -0xb8],RAX
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0xb8]
CALL 0x00118d50
MOV RSI,qword ptr [RBP + -0xc8]
MOV qword ptr [RBP + -0xc0],RAX
ADD RSI,0x8
LEA RDI,[RBP + -0xc0]
CALL 0x0011b5f0
AND AL,0x1
MOV byte ptr [RBP + -0x1],AL
JMP 0x00115e28
LAB_00115e24:
MOV byte ptr [RBP + -0x1],0x0
LAB_00115e28:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0xd0
POP RBP
RET
|
/* nglog::(anonymous namespace)::LogCleaner::IsLogLastModifiedOver(std::__cxx11::string const&,
std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long,
std::ratio<1l, 1000000000l> > > const&) const */
int8 __thiscall
nglog::(anonymous_namespace)::LogCleaner::IsLogLastModifiedOver
(LogCleaner *this,string *param_1,time_point *param_2)
{
int iVar1;
char *__file;
int4 extraout_var_00;
int7 extraout_var;
int8 uVar2;
int8 local_c8;
int8 local_c0;
stat local_b8;
time_point *local_28;
string *local_20;
LogCleaner *local_18;
bool local_9;
local_28 = param_2;
local_20 = param_1;
local_18 = this;
__file = (char *)std::__cxx11::string::c_str();
iVar1 = stat(__file,&local_b8);
uVar2 = CONCAT44(extraout_var_00,iVar1);
if (iVar1 == 0) {
local_c0 = std::chrono::_V2::system_clock::from_time_t(local_b8.st_mtim.tv_sec);
local_c8 = std::chrono::operator-(local_28,(time_point *)&local_c0);
local_9 = std::chrono::operator>=((duration *)&local_c8,(duration *)(this + 8));
uVar2 = CONCAT71(extraout_var,local_9);
}
else {
local_9 = false;
}
return CONCAT71((int7)((ulong)uVar2 >> 8),local_9);
}
|
|
17,274
|
testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**)
|
giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc
|
static void CaptureStream(int fd, const char* stream_name,
CapturedStream** stream) {
if (*stream != nullptr) {
GTEST_LOG_(FATAL) << "Only one " << stream_name
<< " capturer can exist at a time.";
}
*stream = new CapturedStream(fd);
}
|
O1
|
cpp
|
testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %edi, %ebp
cmpq $0x0, (%rdx)
je 0x170c9
movq %rsi, %r14
leaq 0x2b37a(%rip), %rdx # 0x423b9
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x4ab, %ecx # imm = 0x4AB
callq 0x16e72
movq 0x41f8e(%rip), %r15 # 0x58fe8
leaq 0x2cdc5(%rip), %rsi # 0x43e26
movl $0x9, %edx
movq %r15, %rdi
callq 0x85b0
testq %r14, %r14
je 0x1708f
movq %r14, %rdi
callq 0x8200
movq 0x41f66(%rip), %rdi # 0x58fe8
movq %r14, %rsi
movq %rax, %rdx
callq 0x85b0
jmp 0x170a7
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x8930
movq 0x41f3a(%rip), %rdi # 0x58fe8
leaq 0x2cd7b(%rip), %rsi # 0x43e30
movl $0x1e, %edx
callq 0x85b0
leaq 0x4(%rsp), %rdi
callq 0x16fb4
movl $0x28, %edi
callq 0x84b0
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x362c0
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x84e0
jmp 0x1710d
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x16fb4
movq %rbx, %rdi
callq 0x8990
|
_ZN7testing8internalL13CaptureStreamEiPKcPPNS0_14CapturedStreamE:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov ebp, edi
cmp qword ptr [rdx], 0
jz loc_170C9
mov r14, rsi
lea rdx, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rsp+28h+var_24]
mov esi, 3
mov ecx, 4ABh
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov r15, cs:_ZSt4cerr_ptr
lea rsi, aOnlyOne; "Only one "
mov edx, 9
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
test r14, r14
jz short loc_1708F
mov rdi, r14
call _strlen
mov rdi, cs:_ZSt4cerr_ptr
mov rsi, r14
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_170A7
loc_1708F:
mov rax, [r15]
mov rax, [rax-18h]
lea rdi, [r15+rax]
mov esi, [r15+rax+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_170A7:
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aCapturerCanExi; " capturer can exist at a time."
mov edx, 1Eh
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rdi, [rsp+28h+var_24]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
loc_170C9:
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rdi, rax; this
mov esi, ebp; int
call _ZN7testing8internal14CapturedStreamC2Ei; testing::internal::CapturedStream::CapturedStream(int)
mov [rbx], r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov esi, 28h ; '('; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1710D
mov rbx, rax
lea rdi, [rsp+4]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
loc_1710D:
mov rdi, rbx
call __Unwind_Resume
|
long long testing::internal::CaptureStream(
testing::internal *this,
long long a2,
char *a3,
testing::internal::CapturedStream **a4)
{
long long v4; // rax
long long v6; // rax
long long v7; // rdx
long long v8; // rcx
testing::internal::CapturedStream *v9; // r14
long long result; // rax
_DWORD v11[9]; // [rsp+0h] [rbp-24h] BYREF
v11[0] = HIDWORD(v4);
if ( *(_QWORD *)a3 )
{
testing::internal::GTestLog::GTestLog(
v11,
3,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc",
1195);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "Only one ", 9LL);
if ( a2 )
{
v6 = strlen(a2);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, a2, v6);
}
else
{
std::ios::clear(
(char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL),
*(_DWORD *)((char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL) + 32) | 1u);
}
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, " capturer can exist at a time.", 30LL);
testing::internal::GTestLog::~GTestLog(
(testing::internal::GTestLog *)v11,
(long long)" capturer can exist at a time.",
v7,
v8);
}
v9 = (testing::internal::CapturedStream *)operator new(0x28uLL);
result = testing::internal::CapturedStream::CapturedStream(v9, (int)this);
*(_QWORD *)a3 = v9;
return result;
}
|
CaptureStream:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV EBP,EDI
CMP qword ptr [RDX],0x0
JZ 0x001170c9
MOV R14,RSI
LEA RDX,[0x1423b9]
LEA RDI,[RSP + 0x4]
MOV ESI,0x3
MOV ECX,0x4ab
CALL 0x00116e72
LAB_00117053:
MOV R15,qword ptr [0x00158fe8]
LEA RSI,[0x143e26]
MOV EDX,0x9
MOV RDI,R15
CALL 0x001085b0
TEST R14,R14
JZ 0x0011708f
MOV RDI,R14
CALL 0x00108200
MOV RDI,qword ptr [0x00158fe8]
MOV RSI,R14
MOV RDX,RAX
CALL 0x001085b0
JMP 0x001170a7
LAB_0011708f:
MOV RAX,qword ptr [R15]
MOV RAX,qword ptr [RAX + -0x18]
LEA RDI,[R15 + RAX*0x1]
MOV ESI,dword ptr [R15 + RAX*0x1 + 0x20]
OR ESI,0x1
CALL 0x00108930
LAB_001170a7:
MOV RDI,qword ptr [0x00158fe8]
LEA RSI,[0x143e30]
MOV EDX,0x1e
CALL 0x001085b0
LAB_001170bf:
LEA RDI,[RSP + 0x4]
CALL 0x00116fb4
LAB_001170c9:
MOV EDI,0x28
CALL 0x001084b0
MOV R14,RAX
LAB_001170d6:
MOV RDI,RAX
MOV ESI,EBP
CALL 0x001362c0
LAB_001170e0:
MOV qword ptr [RBX],R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**) */
void testing::internal::CaptureStream(int param_1,char *param_2,CapturedStream **param_3)
{
int *puVar1;
size_t sVar2;
CapturedStream *this;
GTestLog local_24 [4];
if (*param_3 != (CapturedStream *)0x0) {
GTestLog::GTestLog(local_24,3,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc"
,0x4ab);
puVar1 = PTR_cerr_00158fe8;
/* try { // try from 00117053 to 001170be has its CatchHandler @ 00117100 */
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_00158fe8,"Only one ",9);
if (param_2 == (char *)0x0) {
std::ios::clear(puVar1 + *(long *)(*(long *)puVar1 + -0x18),
*(uint *)(puVar1 + *(long *)(*(long *)puVar1 + -0x18) + 0x20) | 1);
}
else {
sVar2 = strlen(param_2);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_00158fe8,param_2,sVar2)
;
}
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00158fe8," capturer can exist at a time.",0x1e);
GTestLog::~GTestLog(local_24);
}
this = (CapturedStream *)operator_new(0x28);
/* try { // try from 001170d6 to 001170df has its CatchHandler @ 001170ee */
CapturedStream::CapturedStream(this,param_1);
*param_3 = this;
return;
}
|
|
17,275
|
evmone::instr::core::mulmod(evmone::StackTop)
|
corpus-core[P]colibri-stateless/build_O2/_deps/evmone_external-src/lib/evmone/instructions.hpp
|
inline void mulmod(StackTop stack) noexcept
{
const auto& x = stack[0];
const auto& y = stack[1];
auto& m = stack[2];
m = m != 0 ? intx::mulmod(x, y, m) : 0;
}
|
O2
|
cpp
|
evmone::instr::core::mulmod(evmone::StackTop):
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq -0x40(%rdi), %rbx
leaq 0xc(%rsp), %rsi
andl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x38f0c
testb %al, %al
je 0x3a45e
leaq -0x20(%r14), %rdx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x3a484
jmp 0x3a46b
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
|
_ZN6evmone5instr4core6mulmodENS_8StackTopE:
push r14
push rbx
sub rsp, 38h
mov r14, rdi
lea rbx, [rdi-40h]
lea rsi, [rsp+48h+var_3C]
and dword ptr [rsi], 0
mov rdi, rbx
call _ZN4intxneILj256EivEEbRKNS_4uintIXT_EEERKT0_; intx::operator!=<256u,int,void>(intx::uint<256u> const&,int const&)
test al, al
jz short loc_3A45E
lea rdx, [r14-20h]
lea rdi, [rsp+48h+var_38]
mov rsi, r14
mov rcx, rbx
call _ZN4intx6mulmodERKNS_4uintILj256EEES3_S3_; intx::mulmod(intx::uint<256u> const&,intx::uint<256u> const&,intx::uint<256u> const&)
jmp short loc_3A46B
loc_3A45E:
xorps xmm0, xmm0
movaps [rsp+48h+var_28], xmm0
movaps [rsp+48h+var_38], xmm0
loc_3A46B:
movaps xmm0, [rsp+48h+var_38]
movaps xmm1, [rsp+48h+var_28]
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
add rsp, 38h
pop rbx
pop r14
retn
|
long long evmone::instr::core::mulmod(long long a1)
{
_OWORD *v1; // rbx
long long result; // rax
__int128 v3; // xmm0
__int128 v4; // [rsp+10h] [rbp-38h] BYREF
__int128 v5; // [rsp+20h] [rbp-28h]
v1 = (_OWORD *)(a1 - 64);
result = intx::operator!=<256u,int,void>();
if ( (_BYTE)result )
{
result = intx::mulmod(&v4, a1, a1 - 32, v1);
}
else
{
v5 = 0LL;
v4 = 0LL;
}
v3 = v4;
v1[1] = v5;
*v1 = v3;
return result;
}
|
mulmod:
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R14,RDI
LEA RBX,[RDI + -0x40]
LEA RSI,[RSP + 0xc]
AND dword ptr [RSI],0x0
MOV RDI,RBX
CALL 0x00138f0c
TEST AL,AL
JZ 0x0013a45e
LEA RDX,[R14 + -0x20]
LEA RDI,[RSP + 0x10]
MOV RSI,R14
MOV RCX,RBX
CALL 0x0013a484
JMP 0x0013a46b
LAB_0013a45e:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
LAB_0013a46b:
MOVAPS XMM0,xmmword ptr [RSP + 0x10]
MOVAPS XMM1,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
ADD RSP,0x38
POP RBX
POP R14
RET
|
/* evmone::instr::core::mulmod(evmone::StackTop) */
void evmone::instr::core::mulmod(uint *param_1)
{
uint *puVar1;
bool bVar2;
int local_3c;
int8 local_38;
int8 uStack_30;
int8 local_28;
int8 uStack_20;
puVar1 = param_1 + -0x40;
local_3c = 0;
bVar2 = intx::operator!=(puVar1,&local_3c);
if (bVar2) {
intx::mulmod((intx *)&local_38,param_1,param_1 + -0x20,puVar1);
}
else {
local_28 = 0;
uStack_20 = 0;
local_38 = 0;
uStack_30 = 0;
}
*(int8 *)(param_1 + -0x30) = local_28;
*(int8 *)(param_1 + -0x28) = uStack_20;
*(int8 *)puVar1 = local_38;
*(int8 *)(param_1 + -0x38) = uStack_30;
return;
}
|
|
17,276
|
ggml_compute_forward_sub
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c
|
static void ggml_compute_forward_sub(
const struct ggml_compute_params * params,
struct ggml_tensor * dst) {
const struct ggml_tensor * src0 = dst->src[0];
switch (src0->type) {
case GGML_TYPE_F32:
{
ggml_compute_forward_sub_f32(params, dst);
} break;
default:
{
GGML_ABORT("fatal error");
}
}
}
|
O0
|
c
|
ggml_compute_forward_sub:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
testl %eax, %eax
jne 0x1440a
jmp 0x143fb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23aa0
jmp 0x14424
leaq 0x5f751(%rip), %rdi # 0x73b62
movl $0x13cf, %esi # imm = 0x13CF
leaq 0x5f9a0(%rip), %rdx # 0x73dbd
movb $0x0, %al
callq 0xe270
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
ggml_compute_forward_sub:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax+98h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov eax, [rax]
test eax, eax
jnz short loc_1440A
jmp short $+2
loc_143FB:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call ggml_compute_forward_sub_f32
jmp short loc_14424
loc_1440A:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 13CFh
lea rdx, aFatalError; "fatal error"
mov al, 0
call _ggml_abort
loc_14424:
add rsp, 20h
pop rbp
retn
|
double ggml_compute_forward_sub(long long a1, long long a2)
{
double result; // xmm0_8
if ( **(_DWORD **)(a2 + 152) )
return ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
5071LL,
"fatal error");
ggml_compute_forward_sub_f32(a1, a2);
return result;
}
|
ggml_compute_forward_sub:
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 RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNZ 0x0011440a
JMP 0x001143fb
LAB_001143fb:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00123aa0
JMP 0x00114424
LAB_0011440a:
LEA RDI,[0x173b62]
MOV ESI,0x13cf
LEA RDX,[0x173dbd]
MOV AL,0x0
CALL 0x0010e270
LAB_00114424:
ADD RSP,0x20
POP RBP
RET
|
void ggml_compute_forward_sub(int8 param_1,long param_2)
{
if (**(int **)(param_2 + 0x98) == 0) {
ggml_compute_forward_sub_f32(param_1,param_2);
}
else {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x13cf,"fatal error");
}
return;
}
|
|
17,277
|
nglog::LogDestination::LogDestination(nglog::LogSeverity, char const*)
|
ng-log[P]ng-log/src/logging.cc
|
LogDestination::LogDestination(LogSeverity severity, const char* base_filename)
: fileobject_(severity, base_filename), logger_(&fileobject_) {}
|
O1
|
cpp
|
nglog::LogDestination::LogDestination(nglog::LogSeverity, char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x24d44(%rip), %rax # 0x2e7c0
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
leaq 0x38(%rdi), %r14
testq %rdx, %rdx
setne 0x30(%rdi)
leaq 0x190e2(%rip), %r15 # 0x22b86
cmovneq %rdx, %r15
leaq 0x48(%rdi), %r12
movq %r12, 0x38(%rdi)
movq %r15, %rdi
callq 0x71f0
leaq (%rax,%r15), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x9902
callq 0x2153b
leaq 0x58(%rbx), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x98c4
leaq 0x88(%rbx), %rax
movq %rax, 0x78(%rbx)
xorl %eax, %eax
movq %rax, 0x80(%rbx)
movb $0x0, 0x88(%rbx)
movq %rax, 0x98(%rbx)
movl %ebp, 0xa0(%rbx)
movaps 0x188e4(%rip), %xmm0 # 0x223f0
movups %xmm0, 0xa4(%rbx)
movq %rax, 0xb8(%rbx)
callq 0x7060
movq %rax, 0xc0(%rbx)
movq %rbx, 0xc8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9b3c
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x9b53
movq (%r12), %rsi
incq %rsi
callq 0x8fcc
movq %rbx, %rdi
callq 0x7930
nop
|
_ZN5nglog14LogDestinationC2ENS_11LogSeverityEPKc:
push rbp; Alternative name is 'nglog::LogDestination::LogDestination(nglog::LogSeverity, char const*)'
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov ebp, esi
mov rbx, rdi
lea rax, off_2E7C0
mov [rdi], rax
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
movups xmmword ptr [rdi+18h], xmm0
mov qword ptr [rdi+28h], 0
lea r14, [rdi+38h]
test rdx, rdx
setnz byte ptr [rdi+30h]
lea r15, asc_22B84+2; ""
cmovnz r15, rdx
lea r12, [rdi+48h]
mov [rdi+38h], r12
mov rdi, r15
call _strlen
lea rdx, [rax+r15]
mov rdi, r14; this
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
call _ZN5nglog5tools26ProgramInvocationShortNameEv; nglog::tools::ProgramInvocationShortName(void)
lea rdi, [rbx+58h]; this
lea rdx, [rsp+38h+var_29]
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rax, [rbx+88h]
mov [rbx+78h], rax
xor eax, eax
mov [rbx+80h], rax
mov byte ptr [rbx+88h], 0
mov [rbx+98h], rax
mov [rbx+0A0h], ebp
movaps xmm0, cs:xmmword_223F0
movups xmmword ptr [rbx+0A4h], xmm0
mov [rbx+0B8h], rax
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov [rbx+0C0h], rax
mov [rbx+0C8h], rbx
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_9B3C:
mov rbx, rax
mov rdi, [r14]; void *
cmp rdi, r12
jz short loc_9B53
mov rsi, [r12]
inc rsi; unsigned __int64
call _ZdlPvm; operator delete(void *,ulong)
loc_9B53:
mov rdi, rbx
call __Unwind_Resume
|
long long nglog::LogDestination::LogDestination(long long a1, int a2, char *a3)
{
nglog::tools *v3; // r14
char *v4; // r15
long long v5; // rax
long long v6; // rax
long long result; // rax
*(_QWORD *)a1 = off_2E7C0;
*(_OWORD *)(a1 + 8) = 0LL;
*(_OWORD *)(a1 + 24) = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
v3 = (nglog::tools *)(a1 + 56);
*(_BYTE *)(a1 + 48) = a3 != 0LL;
v4 = "";
if ( a3 )
v4 = a3;
*(_QWORD *)(a1 + 56) = a1 + 72;
v5 = strlen(v4);
std::string::_M_construct<char const*>(v3, v4, (long long)&v4[v5]);
v6 = nglog::tools::ProgramInvocationShortName(v3);
std::string::basic_string<std::allocator<char>>((_QWORD *)(a1 + 88), v6);
*(_QWORD *)(a1 + 120) = a1 + 136;
*(_QWORD *)(a1 + 128) = 0LL;
*(_BYTE *)(a1 + 136) = 0;
*(_QWORD *)(a1 + 152) = 0LL;
*(_DWORD *)(a1 + 160) = a2;
*(_OWORD *)(a1 + 164) = xmmword_223F0;
*(_QWORD *)(a1 + 184) = 0LL;
result = std::chrono::_V2::system_clock::now((std::chrono::_V2::system_clock *)(a1 + 88));
*(_QWORD *)(a1 + 192) = result;
*(_QWORD *)(a1 + 200) = a1;
return result;
}
|
LogDestination:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV EBP,ESI
MOV RBX,RDI
LEA RAX,[0x12e7c0]
MOV qword ptr [RDI],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOVUPS xmmword ptr [RDI + 0x18],XMM0
MOV qword ptr [RDI + 0x28],0x0
LEA R14,[RDI + 0x38]
TEST RDX,RDX
SETNZ byte ptr [RDI + 0x30]
LEA R15,[0x122b86]
CMOVNZ R15,RDX
LEA R12,[RDI + 0x48]
MOV qword ptr [RDI + 0x38],R12
MOV RDI,R15
CALL 0x001071f0
LEA RDX,[RAX + R15*0x1]
MOV RDI,R14
MOV RSI,R15
CALL 0x00109902
LAB_00109ac7:
CALL 0x0012153b
LEA RDI,[RBX + 0x58]
LAB_00109ad0:
LEA RDX,[RSP + 0xf]
MOV RSI,RAX
CALL 0x001098c4
LAB_00109add:
LEA RAX,[RBX + 0x88]
MOV qword ptr [RBX + 0x78],RAX
XOR EAX,EAX
MOV qword ptr [RBX + 0x80],RAX
MOV byte ptr [RBX + 0x88],0x0
MOV qword ptr [RBX + 0x98],RAX
MOV dword ptr [RBX + 0xa0],EBP
MOVAPS XMM0,xmmword ptr [0x001223f0]
MOVUPS xmmword ptr [RBX + 0xa4],XMM0
MOV qword ptr [RBX + 0xb8],RAX
CALL 0x00107060
MOV qword ptr [RBX + 0xc0],RAX
MOV qword ptr [RBX + 0xc8],RBX
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* nglog::LogDestination::LogDestination(nglog::LogSeverity, char const*) */
void __thiscall
nglog::LogDestination::LogDestination(LogDestination *this,int4 param_2,char *param_3)
{
size_t sVar1;
char *pcVar2;
int8 uVar3;
allocator local_29;
*(int ***)this = &PTR__LogFileObject_0012e7c0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
this[0x30] = (LogDestination)(param_3 != (char *)0x0);
pcVar2 = "";
if (param_3 != (char *)0x0) {
pcVar2 = param_3;
}
*(LogDestination **)(this + 0x38) = this + 0x48;
sVar1 = strlen(pcVar2);
std::__cxx11::string::_M_construct<char_const*>(this + 0x38,pcVar2,pcVar2 + sVar1);
/* try { // try from 00109ac7 to 00109acb has its CatchHandler @ 00109b3c */
pcVar2 = (char *)tools::ProgramInvocationShortName();
/* try { // try from 00109ad0 to 00109adc has its CatchHandler @ 00109b3a */
std::__cxx11::string::string<std::allocator<char>>((string *)(this + 0x58),pcVar2,&local_29);
*(LogDestination **)(this + 0x78) = this + 0x88;
*(int8 *)(this + 0x80) = 0;
this[0x88] = (LogDestination)0x0;
*(int8 *)(this + 0x98) = 0;
*(int4 *)(this + 0xa0) = param_2;
uVar3 = _UNK_001223f8;
*(int8 *)(this + 0xa4) = _DAT_001223f0;
*(int8 *)(this + 0xac) = uVar3;
*(int8 *)(this + 0xb8) = 0;
uVar3 = std::chrono::_V2::system_clock::now();
*(int8 *)(this + 0xc0) = uVar3;
*(LogDestination **)(this + 200) = this;
return;
}
|
|
17,278
|
uf_varchar2
|
eloqsql/storage/myisam/mi_packrec.c
|
static void uf_varchar2(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
uchar *to, uchar *end __attribute__((unused)))
{
if (get_bit(bit_buff))
to[0]=to[1]=0; /* Zero lengths */
else
{
ulong length=get_bits(bit_buff,rec->space_length_bits);
int2store(to,length);
decode_bytes(rec,bit_buff,to+2,to+2+length);
}
}
|
O3
|
c
|
uf_varchar2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x83af7
movl (%r14), %r13d
decl %eax
movl %eax, 0x4(%r14)
btl %eax, %r13d
jae 0x83b14
movw $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x82399
movl $0x1f, 0x4(%r14)
movl (%r14), %r13d
movl $0x1f, %eax
testl %r13d, %r13d
js 0x83ae3
movl 0x1c(%r15), %r12d
movl %eax, %ecx
subl %r12d, %ecx
jae 0x83b59
subl %eax, %r12d
movl %eax, %eax
leaq 0x5dd45(%rip), %rcx # 0xe1870
andl (%rcx,%rax,4), %r13d
movl %r12d, %ecx
shll %cl, %r13d
movq %r14, %rdi
callq 0x82399
movl $0x20, %eax
subl %r12d, %eax
movl %eax, 0x4(%r14)
movl (%r14), %eax
negl %r12d
movl %r12d, %ecx
shrl %cl, %eax
addl %eax, %r13d
jmp 0x83b6f
movl %ecx, 0x4(%r14)
shrl %cl, %r13d
movl 0x1c(%r15), %eax
leaq 0x5dd05(%rip), %rcx # 0xe1870
andl (%rcx,%rax,4), %r13d
movl %r13d, %eax
movw %r13w, (%rbx)
leaq (%rbx,%rax), %rcx
addq $0x2, %rcx
addq $0x2, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x82c8a
|
uf_varchar2_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_83AF7
mov r13d, [r14]
dec eax
mov [r14+4], eax
bt r13d, eax
jnb short loc_83B14
loc_83AE3:
mov word ptr [rbx], 0
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_83AF7:
mov rdi, r14
call fill_buffer_0
mov dword ptr [r14+4], 1Fh
mov r13d, [r14]
mov eax, 1Fh
test r13d, r13d
js short loc_83AE3
loc_83B14:
mov r12d, [r15+1Ch]
mov ecx, eax
sub ecx, r12d
jnb short loc_83B59
sub r12d, eax
mov eax, eax
lea rcx, mask_0
and r13d, [rcx+rax*4]
mov ecx, r12d
shl r13d, cl
mov rdi, r14
call fill_buffer_0
mov eax, 20h ; ' '
sub eax, r12d
mov [r14+4], eax
mov eax, [r14]
neg r12d
mov ecx, r12d
shr eax, cl
add r13d, eax
jmp short loc_83B6F
loc_83B59:
mov [r14+4], ecx
shr r13d, cl
mov eax, [r15+1Ch]
lea rcx, mask_0
and r13d, [rcx+rax*4]
loc_83B6F:
mov eax, r13d
mov [rbx], r13w
lea rcx, [rbx+rax]
add rcx, 2
add rbx, 2
mov rdi, r15
mov rsi, r14
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp decode_bytes_0
|
long long uf_varchar2_0(long long a1, unsigned int *a2, long long a3)
{
unsigned int v4; // eax
unsigned int v5; // r13d
long long result; // rax
unsigned int v7; // r12d
unsigned int v8; // ecx
int v9; // r12d
int v10; // r13d
unsigned int v11; // r13d
v4 = a2[1];
if ( v4 )
{
v5 = *a2;
result = v4 - 1;
a2[1] = result;
if ( _bittest((const int *)&v5, result) )
{
LABEL_3:
*(_WORD *)a3 = 0;
return result;
}
}
else
{
fill_buffer_0((long long)a2);
a2[1] = 31;
v5 = *a2;
result = 31LL;
if ( (*a2 & 0x80000000) != 0 )
goto LABEL_3;
}
v7 = *(_DWORD *)(a1 + 28);
v8 = result - v7;
if ( (unsigned int)result >= v7 )
{
a2[1] = v8;
v11 = mask_0[*(unsigned int *)(a1 + 28)] & (v5 >> v8);
}
else
{
v9 = v7 - result;
v10 = (mask_0[(unsigned int)result] & v5) << v9;
fill_buffer_0((long long)a2);
a2[1] = 32 - v9;
v11 = (*a2 >> -(char)v9) + v10;
}
*(_WORD *)a3 = v11;
return (long long)decode_bytes_0(a1, (long long)a2, (_BYTE *)(a3 + 2), (_BYTE *)(a3 + v11 + 2));
}
|
uf_varchar2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x00183af7
MOV R13D,dword ptr [R14]
DEC EAX
MOV dword ptr [R14 + 0x4],EAX
BT R13D,EAX
JNC 0x00183b14
LAB_00183ae3:
MOV word ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00183af7:
MOV RDI,R14
CALL 0x00182399
MOV dword ptr [R14 + 0x4],0x1f
MOV R13D,dword ptr [R14]
MOV EAX,0x1f
TEST R13D,R13D
JS 0x00183ae3
LAB_00183b14:
MOV R12D,dword ptr [R15 + 0x1c]
MOV ECX,EAX
SUB ECX,R12D
JNC 0x00183b59
SUB R12D,EAX
MOV EAX,EAX
LEA RCX,[0x1e1870]
AND R13D,dword ptr [RCX + RAX*0x4]
MOV ECX,R12D
SHL R13D,CL
MOV RDI,R14
CALL 0x00182399
MOV EAX,0x20
SUB EAX,R12D
MOV dword ptr [R14 + 0x4],EAX
MOV EAX,dword ptr [R14]
NEG R12D
MOV ECX,R12D
SHR EAX,CL
ADD R13D,EAX
JMP 0x00183b6f
LAB_00183b59:
MOV dword ptr [R14 + 0x4],ECX
SHR R13D,CL
MOV EAX,dword ptr [R15 + 0x1c]
LEA RCX,[0x1e1870]
AND R13D,dword ptr [RCX + RAX*0x4]
LAB_00183b6f:
MOV EAX,R13D
MOV word ptr [RBX],R13W
LEA RCX,[RBX + RAX*0x1]
ADD RCX,0x2
ADD RBX,0x2
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00182c8a
|
void uf_varchar2(long param_1,uint *param_2,int2 *param_3)
{
uint uVar1;
uint uVar2;
uint uVar3;
byte bVar4;
uint uVar5;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar5 = *param_2;
uVar3 = 0x1f;
if (-1 < (int)uVar5) goto LAB_00183b14;
}
else {
uVar5 = *param_2;
uVar3 = param_2[1] - 1;
param_2[1] = uVar3;
if ((uVar5 >> (uVar3 & 0x1f) & 1) == 0) {
LAB_00183b14:
uVar1 = *(uint *)(param_1 + 0x1c);
if (uVar3 < uVar1) {
uVar2 = (&mask)[uVar3];
bVar4 = (byte)(uVar1 - uVar3);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar1 - uVar3);
uVar5 = ((uVar5 & uVar2) << (bVar4 & 0x1f)) + (*param_2 >> (-bVar4 & 0x1f));
}
else {
param_2[1] = uVar3 - uVar1;
uVar5 = uVar5 >> ((byte)(uVar3 - uVar1) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x1c)];
}
*param_3 = (short)uVar5;
decode_bytes(param_1,param_2,param_3 + 1,(long)param_3 + (ulong)uVar5 + 2);
return;
}
}
*param_3 = 0;
return;
}
|
|
17,279
|
PFS_host::aggregate_memory(bool)
|
eloqsql/storage/perfschema/pfs_host.cc
|
void PFS_host::aggregate_memory(bool alive)
{
if (read_instr_class_memory_stats() == NULL)
return;
/*
Aggregate MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME to:
- MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME
*/
aggregate_all_memory(alive,
write_instr_class_memory_stats(),
global_instr_class_memory_array);
}
|
O0
|
cpp
|
PFS_host::aggregate_memory(bool):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x419b0
cmpq $0x0, %rax
jne 0x59089
jmp 0x590b2
movq -0x18(%rbp), %rdi
movb -0x9(%rbp), %al
movb %al, -0x19(%rbp)
callq 0x419f0
movq %rax, %rsi
movb -0x19(%rbp), %al
leaq 0x3b4a63(%rip), %rcx # 0x40db08
movq (%rcx), %rdx
andb $0x1, %al
movzbl %al, %edi
callq 0x3c580
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ZN8PFS_host16aggregate_memoryEb:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, sil
mov [rbp+var_8], rdi
and al, 1
mov [rbp+var_9], al
mov rdi, [rbp+var_8]; this
mov [rbp+var_18], rdi
call _ZNK20PFS_connection_slice29read_instr_class_memory_statsEv; PFS_connection_slice::read_instr_class_memory_stats(void)
cmp rax, 0
jnz short loc_59089
jmp short loc_590B2
loc_59089:
mov rdi, [rbp+var_18]; this
mov al, [rbp+var_9]
mov [rbp+var_19], al
call _ZN20PFS_connection_slice30write_instr_class_memory_statsEv; PFS_connection_slice::write_instr_class_memory_stats(void)
mov rsi, rax; PFS_memory_stat *
mov al, [rbp+var_19]
lea rcx, global_instr_class_memory_array
mov rdx, [rcx]; PFS_memory_stat *
and al, 1
movzx edi, al; bool
call _Z20aggregate_all_memorybP15PFS_memory_statS0_; aggregate_all_memory(bool,PFS_memory_stat *,PFS_memory_stat *)
loc_590B2:
add rsp, 20h
pop rbp
retn
|
PFS_memory_stat * PFS_host::aggregate_memory(PFS_host *this, char a2)
{
PFS_memory_stat *result; // rax
PFS_memory_stat *v3; // rax
result = (PFS_memory_stat *)PFS_connection_slice::read_instr_class_memory_stats(this);
if ( result )
{
v3 = (PFS_memory_stat *)PFS_connection_slice::write_instr_class_memory_stats(this);
return aggregate_all_memory(a2 & 1, v3, global_instr_class_memory_array);
}
return result;
}
|
aggregate_memory:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
AND AL,0x1
MOV byte ptr [RBP + -0x9],AL
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RDI
CALL 0x001419b0
CMP RAX,0x0
JNZ 0x00159089
JMP 0x001590b2
LAB_00159089:
MOV RDI,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RBP + -0x9]
MOV byte ptr [RBP + -0x19],AL
CALL 0x001419f0
MOV RSI,RAX
MOV AL,byte ptr [RBP + -0x19]
LEA RCX,[0x50db08]
MOV RDX,qword ptr [RCX]
AND AL,0x1
MOVZX EDI,AL
CALL 0x0013c580
LAB_001590b2:
ADD RSP,0x20
POP RBP
RET
|
/* PFS_host::aggregate_memory(bool) */
void __thiscall PFS_host::aggregate_memory(PFS_host *this,bool param_1)
{
long lVar1;
PFS_memory_stat *pPVar2;
lVar1 = PFS_connection_slice::read_instr_class_memory_stats((PFS_connection_slice *)this);
if (lVar1 != 0) {
pPVar2 = (PFS_memory_stat *)
PFS_connection_slice::write_instr_class_memory_stats((PFS_connection_slice *)this);
aggregate_all_memory(param_1,pPVar2,global_instr_class_memory_array);
}
return;
}
|
|
17,280
|
PFS_host::aggregate_memory(bool)
|
eloqsql/storage/perfschema/pfs_host.cc
|
void PFS_host::aggregate_memory(bool alive)
{
if (read_instr_class_memory_stats() == NULL)
return;
/*
Aggregate MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME to:
- MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME
*/
aggregate_all_memory(alive,
write_instr_class_memory_stats(),
global_instr_class_memory_array);
}
|
O3
|
cpp
|
PFS_host::aggregate_memory(bool):
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
setne %cl
andb 0x4(%rdi), %cl
cmpb $0x1, %cl
jne 0x4606b
leaq 0x38aa71(%rip), %rcx # 0x3d0ad0
movq (%rcx), %rdx
movzbl %al, %edi
popq %rbp
jmp 0x38c4a
popq %rbp
retq
nop
|
_ZN8PFS_host16aggregate_memoryEb:
push rbp
mov rbp, rsp
mov eax, esi
mov rsi, [rdi+28h]; PFS_memory_stat *
test rsi, rsi
setnz cl
and cl, [rdi+4]
cmp cl, 1
jnz short loc_4606B
lea rcx, global_instr_class_memory_array
mov rdx, [rcx]; PFS_memory_stat *
movzx edi, al; bool
pop rbp
jmp _Z20aggregate_all_memorybP15PFS_memory_statS0_; aggregate_all_memory(bool,PFS_memory_stat *,PFS_memory_stat *)
loc_4606B:
pop rbp
retn
|
unsigned long long PFS_host::aggregate_memory(PFS_host *this, unsigned int a2)
{
unsigned long long result; // rax
PFS_memory_stat *v3; // rsi
result = a2;
v3 = (PFS_memory_stat *)*((_QWORD *)this + 5);
if ( (*((_BYTE *)this + 4) & (v3 != 0LL)) == 1 )
return aggregate_all_memory((unsigned __int8)result, v3, global_instr_class_memory_array);
return result;
}
|
aggregate_memory:
PUSH RBP
MOV RBP,RSP
MOV EAX,ESI
MOV RSI,qword ptr [RDI + 0x28]
TEST RSI,RSI
SETNZ CL
AND CL,byte ptr [RDI + 0x4]
CMP CL,0x1
JNZ 0x0014606b
LEA RCX,[0x4d0ad0]
MOV RDX,qword ptr [RCX]
MOVZX EDI,AL
POP RBP
JMP 0x00138c4a
LAB_0014606b:
POP RBP
RET
|
/* PFS_host::aggregate_memory(bool) */
void __thiscall PFS_host::aggregate_memory(PFS_host *this,bool param_1)
{
if ((*(PFS_memory_stat **)(this + 0x28) != (PFS_memory_stat *)0x0 & (byte)this[4]) == 1) {
aggregate_all_memory(param_1,*(PFS_memory_stat **)(this + 0x28),global_instr_class_memory_array)
;
return;
}
return;
}
|
|
17,281
|
minja::ExpressionNode::ExpressionNode(minja::Location const&, std::shared_ptr<minja::Expression>&&)
|
monkey531[P]llama/common/minja.hpp
|
ExpressionNode(const Location & location, std::shared_ptr<Expression> && e) : TemplateNode(location), expr(std::move(e)) {}
|
O2
|
cpp
|
minja::ExpressionNode::ExpressionNode(minja::Location const&, std::shared_ptr<minja::Expression>&&):
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x728bc
leaq 0x86198(%rip), %rax # 0xfb2b8
addq $0x10, %rax
movq %rax, (%r14)
andq $0x0, 0x28(%r14)
movups (%rbx), %xmm0
andq $0x0, 0x8(%rbx)
movups %xmm0, 0x20(%r14)
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN5minja14ExpressionNodeC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEE:
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rdi
call _ZN5minja12TemplateNodeC2ERKNS_8LocationE; minja::TemplateNode::TemplateNode(minja::Location const&)
lea rax, _ZTVN5minja14ExpressionNodeE; `vtable for'minja::ExpressionNode
add rax, 10h
mov [r14], rax
and qword ptr [r14+28h], 0
movups xmm0, xmmword ptr [rbx]
and qword ptr [rbx+8], 0
movups xmmword ptr [r14+20h], xmm0
and qword ptr [rbx], 0
add rsp, 8
pop rbx
pop r14
retn
|
long long * minja::ExpressionNode::ExpressionNode(long long a1, _QWORD *a2, __int128 *a3)
{
long long *result; // rax
__int128 v5; // xmm0
minja::TemplateNode::TemplateNode((_QWORD *)a1, a2);
result = &`vtable for'minja::ExpressionNode + 2;
*(_QWORD *)a1 = &`vtable for'minja::ExpressionNode + 2;
*(_QWORD *)(a1 + 40) = 0LL;
v5 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v5;
*(_QWORD *)a3 = 0LL;
return result;
}
|
ExpressionNode:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
CALL 0x001728bc
LEA RAX,[0x1fb2b8]
ADD RAX,0x10
MOV qword ptr [R14],RAX
AND qword ptr [R14 + 0x28],0x0
MOVUPS XMM0,xmmword ptr [RBX]
AND qword ptr [RBX + 0x8],0x0
MOVUPS xmmword ptr [R14 + 0x20],XMM0
AND qword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::ExpressionNode::ExpressionNode(minja::Location const&,
std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::ExpressionNode::ExpressionNode(ExpressionNode *this,Location *param_1,shared_ptr *param_2)
{
int8 uVar1;
TemplateNode::TemplateNode((TemplateNode *)this,param_1);
*(int ***)this = &PTR_do_render_001fb2c8;
*(int8 *)(this + 0x28) = 0;
uVar1 = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar1;
*(int8 *)param_2 = 0;
return;
}
|
|
17,282
|
ggml_vec_dot_q5_1_q8_1
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c
|
void ggml_vec_dot_q5_1_q8_1(int n, float * restrict s, size_t bs, const void * restrict vx, size_t bx, const void * restrict vy, size_t by, int nrc) {
const int qk = QK8_1;
const int nb = n / qk;
int ib = 0;
float sumf = 0;
assert(n % qk == 0);
assert(qk == QK5_1);
assert(nrc == 1);
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
const block_q5_1 * restrict x = vx;
const block_q8_1 * restrict y = vy;
#if defined(__ARM_NEON)
float32x4_t sumv0 = vdupq_n_f32(0.0f);
float32x4_t sumv1 = vdupq_n_f32(0.0f);
float summs0 = 0.0f;
float summs1 = 0.0f;
uint32_t qh0;
uint32_t qh1;
uint64_t tmp0[4];
uint64_t tmp1[4];
for (; ib + 1 < nb; ib += 2) {
const block_q5_1 * restrict x0 = &x[ib];
const block_q5_1 * restrict x1 = &x[ib + 1];
const block_q8_1 * restrict y0 = &y[ib];
const block_q8_1 * restrict y1 = &y[ib + 1];
const uint8x16_t m4b = vdupq_n_u8(0x0F);
summs0 += GGML_FP16_TO_FP32(x0->m) * GGML_FP16_TO_FP32(y0->s);
summs1 += GGML_FP16_TO_FP32(x1->m) * GGML_FP16_TO_FP32(y1->s);
// extract the 5th bit via lookup table ((b) << 4)
memcpy(&qh0, x0->qh, sizeof(qh0));
memcpy(&qh1, x1->qh, sizeof(qh1));
tmp0[0] = table_b2b_0[(qh0 >> 0) & 0xFF];
tmp0[1] = table_b2b_0[(qh0 >> 8) & 0xFF];
tmp0[2] = table_b2b_0[(qh0 >> 16) & 0xFF];
tmp0[3] = table_b2b_0[(qh0 >> 24) ];
tmp1[0] = table_b2b_0[(qh1 >> 0) & 0xFF];
tmp1[1] = table_b2b_0[(qh1 >> 8) & 0xFF];
tmp1[2] = table_b2b_0[(qh1 >> 16) & 0xFF];
tmp1[3] = table_b2b_0[(qh1 >> 24) ];
const int8x16_t qhl0 = vld1q_s8((const int8_t *)(tmp0 + 0));
const int8x16_t qhh0 = vld1q_s8((const int8_t *)(tmp0 + 2));
const int8x16_t qhl1 = vld1q_s8((const int8_t *)(tmp1 + 0));
const int8x16_t qhh1 = vld1q_s8((const int8_t *)(tmp1 + 2));
const uint8x16_t v0_0 = vld1q_u8(x0->qs);
const uint8x16_t v0_1 = vld1q_u8(x1->qs);
// 4-bit -> 8-bit
const int8x16_t v0_0l = vreinterpretq_s8_u8(vandq_u8 (v0_0, m4b));
const int8x16_t v0_0h = vreinterpretq_s8_u8(vshrq_n_u8(v0_0, 4));
const int8x16_t v0_1l = vreinterpretq_s8_u8(vandq_u8 (v0_1, m4b));
const int8x16_t v0_1h = vreinterpretq_s8_u8(vshrq_n_u8(v0_1, 4));
// add high bit
const int8x16_t v0_0lf = vorrq_s8(v0_0l, qhl0);
const int8x16_t v0_0hf = vorrq_s8(v0_0h, qhh0);
const int8x16_t v0_1lf = vorrq_s8(v0_1l, qhl1);
const int8x16_t v0_1hf = vorrq_s8(v0_1h, qhh1);
// load y
const int8x16_t v1_0l = vld1q_s8(y0->qs);
const int8x16_t v1_0h = vld1q_s8(y0->qs + 16);
const int8x16_t v1_1l = vld1q_s8(y1->qs);
const int8x16_t v1_1h = vld1q_s8(y1->qs + 16);
sumv0 = vmlaq_n_f32(sumv0, vcvtq_f32_s32(vaddq_s32(
ggml_vdotq_s32(vdupq_n_s32(0), v0_0lf, v1_0l),
ggml_vdotq_s32(vdupq_n_s32(0), v0_0hf, v1_0h))), GGML_FP16_TO_FP32(x0->d)*GGML_FP16_TO_FP32(y0->d));
sumv1 = vmlaq_n_f32(sumv1, vcvtq_f32_s32(vaddq_s32(
ggml_vdotq_s32(vdupq_n_s32(0), v0_1lf, v1_1l),
ggml_vdotq_s32(vdupq_n_s32(0), v0_1hf, v1_1h))), GGML_FP16_TO_FP32(x1->d)*GGML_FP16_TO_FP32(y1->d));
}
sumf = vaddvq_f32(sumv0) + vaddvq_f32(sumv1) + summs0 + summs1;
#elif defined(__wasm_simd128__)
v128_t sumv = wasm_f32x4_splat(0.0f);
float summs = 0.0f;
uint32_t qh;
uint64_t tmp[4];
// TODO: check if unrolling this is better
for (; ib < nb; ++ib) {
const block_q5_1 * restrict x0 = &x[ib];
const block_q8_1 * restrict y0 = &y[ib];
summs += GGML_FP16_TO_FP32(x0->m) * GGML_FP16_TO_FP32(y0->s);
const v128_t m4b = wasm_i8x16_splat(0x0F);
// extract the 5th bit
memcpy(&qh, x0->qh, sizeof(qh));
tmp[0] = table_b2b_0[(qh >> 0) & 0xFF];
tmp[1] = table_b2b_0[(qh >> 8) & 0xFF];
tmp[2] = table_b2b_0[(qh >> 16) & 0xFF];
tmp[3] = table_b2b_0[(qh >> 24) ];
const v128_t qhl = wasm_v128_load(tmp + 0);
const v128_t qhh = wasm_v128_load(tmp + 2);
const v128_t v0 = wasm_v128_load(x0->qs);
// 4-bit -> 8-bit
const v128_t v0l = wasm_v128_and (v0, m4b);
const v128_t v0h = wasm_u8x16_shr(v0, 4);
// add high bit
const v128_t v0lf = wasm_v128_or(v0l, qhl);
const v128_t v0hf = wasm_v128_or(v0h, qhh);
// load y
const v128_t v1l = wasm_v128_load(y0->qs);
const v128_t v1h = wasm_v128_load(y0->qs + 16);
// int8x16 -> int16x8
const v128_t v0lfl = wasm_i16x8_extend_low_i8x16 (v0lf);
const v128_t v0lfh = wasm_i16x8_extend_high_i8x16(v0lf);
const v128_t v0hfl = wasm_i16x8_extend_low_i8x16 (v0hf);
const v128_t v0hfh = wasm_i16x8_extend_high_i8x16(v0hf);
const v128_t v1ll = wasm_i16x8_extend_low_i8x16 (v1l);
const v128_t v1lh = wasm_i16x8_extend_high_i8x16(v1l);
const v128_t v1hl = wasm_i16x8_extend_low_i8x16 (v1h);
const v128_t v1hh = wasm_i16x8_extend_high_i8x16(v1h);
// dot product
sumv = wasm_f32x4_add(sumv,
wasm_f32x4_mul(wasm_f32x4_convert_i32x4(wasm_i32x4_add(
wasm_i32x4_add(wasm_i32x4_dot_i16x8(v0lfl, v1ll),
wasm_i32x4_dot_i16x8(v0lfh, v1lh)),
wasm_i32x4_add(wasm_i32x4_dot_i16x8(v0hfl, v1hl),
wasm_i32x4_dot_i16x8(v0hfh, v1hh)))),
wasm_f32x4_splat(GGML_FP16_TO_FP32(x0->d) * GGML_FP16_TO_FP32(y0->d))));
}
sumf = wasm_f32x4_extract_lane(sumv, 0) + wasm_f32x4_extract_lane(sumv, 1) +
wasm_f32x4_extract_lane(sumv, 2) + wasm_f32x4_extract_lane(sumv, 3) + summs;
#elif defined(__AVX2__)
// Initialize accumulator with zeros
__m256 acc = _mm256_setzero_ps();
float summs = 0.0f;
// Main loop
for (; ib < nb; ++ib) {
const __m256 dx = _mm256_set1_ps(GGML_FP16_TO_FP32(x[ib].d));
summs += GGML_FP16_TO_FP32(x[ib].m) * GGML_FP16_TO_FP32(y[ib].s);
__m256i qx = bytes_from_nibbles_32(x[ib].qs);
__m256i bxhi = bytes_from_bits_32(x[ib].qh);
bxhi = _mm256_and_si256(bxhi, _mm256_set1_epi8(0x10));
qx = _mm256_or_si256(qx, bxhi);
const __m256 dy = _mm256_set1_ps(GGML_FP16_TO_FP32(y[ib].d));
const __m256i qy = _mm256_loadu_si256((const __m256i *)y[ib].qs);
const __m256 q = mul_sum_us8_pairs_float(qx, qy);
acc = _mm256_fmadd_ps(q, _mm256_mul_ps(dx, dy), acc);
}
sumf = hsum_float_8(acc) + summs;
#elif defined(__AVX__)
// Initialize accumulator with zeros
__m256 acc = _mm256_setzero_ps();
__m128i mask = _mm_set1_epi8(0x10);
float summs = 0.0f;
// Main loop
for (; ib < nb; ++ib) {
const __m256 dx = _mm256_set1_ps(GGML_FP16_TO_FP32(x[ib].d));
summs += GGML_FP16_TO_FP32(x[ib].m) * GGML_FP16_TO_FP32(y[ib].s);
__m256i bx_0 = bytes_from_nibbles_32(x[ib].qs);
const __m256i bxhi = bytes_from_bits_32(x[ib].qh);
__m128i bxhil = _mm256_castsi256_si128(bxhi);
__m128i bxhih = _mm256_extractf128_si256(bxhi, 1);
bxhil = _mm_and_si128(bxhil, mask);
bxhih = _mm_and_si128(bxhih, mask);
__m128i bxl = _mm256_castsi256_si128(bx_0);
__m128i bxh = _mm256_extractf128_si256(bx_0, 1);
bxl = _mm_or_si128(bxl, bxhil);
bxh = _mm_or_si128(bxh, bxhih);
bx_0 = MM256_SET_M128I(bxh, bxl);
const __m256 dy = _mm256_set1_ps(GGML_FP16_TO_FP32(y[ib].d));
const __m256i by_0 = _mm256_loadu_si256((const __m256i *)y[ib].qs);
const __m256 q = mul_sum_us8_pairs_float(bx_0, by_0);
acc = _mm256_add_ps(_mm256_mul_ps(q, _mm256_mul_ps(dx, dy)), acc);
}
sumf = hsum_float_8(acc) + summs;
#elif defined(__riscv_v_intrinsic)
uint32_t qh;
size_t vl = __riscv_vsetvl_e8m1(qk/2);
// temporary registers for shift operations
vuint32m2_t vt_1 = __riscv_vid_v_u32m2(vl);
vuint32m2_t vt_2 = __riscv_vadd_vx_u32m2(vt_1, 12, vl);
for (; ib < nb; ++ib) {
memcpy(&qh, x[ib].qh, sizeof(uint32_t));
// load qh
vuint32m2_t vqh = __riscv_vmv_v_x_u32m2(qh, vl);
// ((qh >> (j + 0)) << 4) & 0x10;
vuint32m2_t xhr_0 = __riscv_vsrl_vv_u32m2(vqh, vt_1, vl);
vuint32m2_t xhl_0 = __riscv_vsll_vx_u32m2(xhr_0, 4, vl);
vuint32m2_t xha_0 = __riscv_vand_vx_u32m2(xhl_0, 0x10, vl);
// ((qh >> (j + 12)) ) & 0x10;
vuint32m2_t xhr_1 = __riscv_vsrl_vv_u32m2(vqh, vt_2, vl);
vuint32m2_t xha_1 = __riscv_vand_vx_u32m2(xhr_1, 0x10, vl);
// narrowing
vuint16m1_t xhc_0 = __riscv_vncvt_x_x_w_u16m1(xha_0, vl);
vuint8mf2_t xh_0 = __riscv_vncvt_x_x_w_u8mf2(xhc_0, vl);
vuint16m1_t xhc_1 = __riscv_vncvt_x_x_w_u16m1(xha_1, vl);
vuint8mf2_t xh_1 = __riscv_vncvt_x_x_w_u8mf2(xhc_1, vl);
// load
vuint8mf2_t tx = __riscv_vle8_v_u8mf2(x[ib].qs, vl);
vint8mf2_t y0 = __riscv_vle8_v_i8mf2(y[ib].qs, vl);
vint8mf2_t y1 = __riscv_vle8_v_i8mf2(y[ib].qs+16, vl);
vuint8mf2_t x_at = __riscv_vand_vx_u8mf2(tx, 0x0F, vl);
vuint8mf2_t x_lt = __riscv_vsrl_vx_u8mf2(tx, 0x04, vl);
vuint8mf2_t x_a = __riscv_vor_vv_u8mf2(x_at, xh_0, vl);
vuint8mf2_t x_l = __riscv_vor_vv_u8mf2(x_lt, xh_1, vl);
vint8mf2_t v0 = __riscv_vreinterpret_v_u8mf2_i8mf2(x_a);
vint8mf2_t v1 = __riscv_vreinterpret_v_u8mf2_i8mf2(x_l);
vint16m1_t vec_mul1 = __riscv_vwmul_vv_i16m1(v0, y0, vl);
vint16m1_t vec_mul2 = __riscv_vwmul_vv_i16m1(v1, y1, vl);
vint32m1_t vec_zero = __riscv_vmv_v_x_i32m1(0, vl);
vint32m1_t vs1 = __riscv_vwredsum_vs_i16m1_i32m1(vec_mul1, vec_zero, vl);
vint32m1_t vs2 = __riscv_vwredsum_vs_i16m1_i32m1(vec_mul2, vs1, vl);
int sumi = __riscv_vmv_x_s_i32m1_i32(vs2);
sumf += (GGML_FP16_TO_FP32(x[ib].d)*GGML_FP16_TO_FP32(y[ib].d))*sumi + GGML_FP16_TO_FP32(x[ib].m)*GGML_FP16_TO_FP32(y[ib].s);
}
#elif defined(__POWER9_VECTOR__)
const vector signed char lowMask = vec_splats((signed char)0xF);
const vector signed int v0 = vec_splats((int32_t)0);
const vector unsigned char v4 = vec_splats((unsigned char)0x4);
vector float vsumf0 = vec_splats(0.0f);
#pragma GCC unroll 4
for (; ib < nb; ++ib) {
__builtin_prefetch(x[ib].qs, 0, 1);
__builtin_prefetch(y[ib].qs, 0, 1);
vector float vxd = vec_splats(GGML_FP16_TO_FP32(x[ib].d));
vector float vyd = vec_splats(GGML_FP16_TO_FP32(y[ib].d));
vector float vd = vec_mul(vxd, vyd);
vector float vxmin = vec_splats(GGML_FP16_TO_FP32(x[ib].m));
vector float vys = {GGML_FP16_TO_FP32(y[ib].s), 0.f, 0.f, 0.f};
vsumf0 = vec_madd(vxmin, vys, vsumf0);
vector unsigned long long aux64x2_0 = {(uint64_t)(table_b2b_0[x[ib].qh[0]]), (uint64_t)(table_b2b_0[x[ib].qh[1]])};
vector unsigned long long aux64x2_1 = {(uint64_t)(table_b2b_0[x[ib].qh[2]]), (uint64_t)(table_b2b_0[x[ib].qh[3]])};
vector signed char qh0 = (vector signed char)aux64x2_0;
vector signed char qh1 = (vector signed char)aux64x2_1;
vector signed char qxs = (vector signed char)vec_xl( 0, x[ib].qs);
vector unsigned char q5x0 = (vector unsigned char)vec_or(vec_and(qxs, lowMask), qh0);
vector unsigned char q5x1 = (vector unsigned char)vec_or(vec_sr(qxs, v4), qh1);
vector signed char q8y0 = vec_xl( 0, y[ib].qs);
vector signed char q8y1 = vec_xl( 16, y[ib].qs);
vector signed int vsumi0 = v0;
vsumi0 = vec_msum(q8y0, q5x0, vsumi0);
vsumi0 = vec_msum(q8y1, q5x1, vsumi0);
vsumf0 = vec_madd(vec_ctf(vsumi0, 0), vd, vsumf0);
}
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 4));
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 8));
sumf = vec_extract(vsumf0, 0);
#elif defined(__loongarch_asx)
// Initialize accumulator with zeros
__m256 acc = (__m256)__lasx_xvldi(0);
float summs = 0.0f;
// Main loop
for (; ib < nb; ++ib) {
const __m256 dx = __lasx_xvreplfr2vr_s(GGML_FP16_TO_FP32(x[ib].d));
summs += GGML_FP16_TO_FP32(x[ib].m) * GGML_FP16_TO_FP32(y[ib].s);
__m256i qx = bytes_from_nibbles_32(x[ib].qs);
__m256i bxhi = bytes_from_bits_32(x[ib].qh);
bxhi = __lasx_xvand_v(bxhi, __lasx_xvreplgr2vr_b(0x10));
qx = __lasx_xvor_v(qx, bxhi);
const __m256 dy = __lasx_xvreplfr2vr_s(GGML_FP16_TO_FP32(y[ib].d));
const __m256i qy = __lasx_xvld((const __m256i *)y[ib].qs, 0);
const __m256 q = mul_sum_us8_pairs_float(qx, qy);
acc = __lasx_xvfmadd_s(q, __lasx_xvfmul_s(dx, dy), acc);
}
sumf = hsum_float_8(acc) + summs;
#endif
for (; ib < nb; ++ib) {
uint32_t qh;
memcpy(&qh, x[ib].qh, sizeof(qh));
int sumi0 = 0;
int sumi1 = 0;
for (int j = 0; j < qk/2; ++j) {
const uint8_t xh_0 = ((qh >> (j + 0)) << 4) & 0x10;
const uint8_t xh_1 = ((qh >> (j + 12)) ) & 0x10;
const int32_t x0 = (x[ib].qs[j] & 0xF) | xh_0;
const int32_t x1 = (x[ib].qs[j] >> 4) | xh_1;
sumi0 += (x0 * y[ib].qs[j]);
sumi1 += (x1 * y[ib].qs[j + qk/2]);
}
int sumi = sumi0 + sumi1;
sumf += (GGML_FP16_TO_FP32(x[ib].d)*GGML_FP16_TO_FP32(y[ib].d))*sumi + GGML_FP16_TO_FP32(x[ib].m)*GGML_FP16_TO_FP32(y[ib].s);
}
*s = sumf;
}
|
O2
|
c
|
ggml_vec_dot_q5_1_q8_1:
pushq %rax
pushq $0x20
popq %r8
movl %edi, %eax
cltd
idivl %r8d
testb $0x1f, %dil
jne 0x2f6cb
cmpl $0x1, 0x18(%rsp)
jne 0x2f6ea
movl %eax, %edx
sarl $0x1f, %edx
andnl %eax, %edx, %eax
imulq $0x18, %rax, %rax
addq $0x4, %r9
vxorps %xmm1, %xmm1, %xmm1
vxorps %xmm0, %xmm0, %xmm0
xorl %edx, %edx
movq 0x16982(%rip), %rdi # 0x45f68
vmovdqa 0x7c52(%rip), %ymm2 # 0x37240
vpbroadcastq 0x7e59(%rip), %ymm3 # 0x37450
vpcmpeqd %ymm4, %ymm4, %ymm4
vpbroadcastq 0x7e54(%rip), %ymm5 # 0x37458
vpbroadcastq 0x7e53(%rip), %ymm6 # 0x37460
vpbroadcastw 0x7e94(%rip), %ymm7 # 0x374aa
cmpq %rdx, %rax
je 0x2f6a7
movzwl (%rcx,%rdx), %r8d
vmovss (%rdi,%r8,4), %xmm8
movzwl 0x2(%rcx,%rdx), %r8d
vmovss (%rdi,%r8,4), %xmm9
movzwl -0x2(%r9), %r8d
vfmadd231ss (%rdi,%r8,4), %xmm9, %xmm0 # xmm0 = (xmm9 * mem) + xmm0
vmovdqu 0x8(%rcx,%rdx), %xmm9
vpsrlw $0x4, %xmm9, %xmm10
vmovd 0x4(%rcx,%rdx), %xmm11
vinserti128 $0x1, %xmm10, %ymm9, %ymm9
vpermq $0x44, %ymm11, %ymm10 # ymm10 = ymm11[0,1,0,1]
vpshufb %ymm2, %ymm10, %ymm10
vpor %ymm3, %ymm10, %ymm10
vpcmpeqb %ymm4, %ymm10, %ymm10
vpand %ymm5, %ymm10, %ymm10
vpternlogq $0xf8, %ymm6, %ymm9, %ymm10
movzwl -0x4(%r9), %r8d
vpmaddubsw (%r9), %ymm10, %ymm9
vpmaddwd %ymm7, %ymm9, %ymm9
vcvtdq2ps %ymm9, %ymm9
vmulss (%rdi,%r8,4), %xmm8, %xmm8
vbroadcastss %xmm8, %ymm8
vfmadd231ps %ymm8, %ymm9, %ymm1 # ymm1 = (ymm9 * ymm8) + ymm1
addq $0x18, %rdx
addq $0x24, %r9
jmp 0x2f616
vextractf128 $0x1, %ymm1, %xmm2
vaddps %xmm1, %xmm2, %xmm1
vshufpd $0x1, %xmm1, %xmm1, %xmm2 # xmm2 = xmm1[1,0]
vaddps %xmm2, %xmm1, %xmm1
vhaddps %xmm1, %xmm1, %xmm1
vaddss %xmm1, %xmm0, %xmm0
vmovss %xmm0, (%rsi)
popq %rax
vzeroupper
retq
leaq 0x7276(%rip), %rdi # 0x36948
leaq 0x107f7(%rip), %rsi # 0x3fed0
leaq 0x10bd7(%rip), %rcx # 0x402b7
movl $0xba0, %edx # imm = 0xBA0
callq 0x8460
leaq 0x4435(%rip), %rdi # 0x33b26
leaq 0x107d8(%rip), %rsi # 0x3fed0
leaq 0x10bb8(%rip), %rcx # 0x402b7
movl $0xba2, %edx # imm = 0xBA2
callq 0x8460
|
ggml_vec_dot_q5_1_q8_1:
push rax
push 20h ; ' '
pop r8
mov eax, edi
cdq
idiv r8d
test dil, 1Fh
jnz loc_2F6CB
cmp [rsp+8+arg_8], 1
jnz loc_2F6EA
mov edx, eax
sar edx, 1Fh
andn eax, edx, eax
imul rax, 18h
add r9, 4
vxorps xmm1, xmm1, xmm1
vxorps xmm0, xmm0, xmm0
xor edx, edx
mov rdi, cs:ggml_table_f32_f16_ptr
vmovdqa ymm2, cs:ymmword_37240
vpbroadcastq ymm3, cs:qword_37450
vpcmpeqd ymm4, ymm4, ymm4
vpbroadcastq ymm5, cs:qword_37458
vpbroadcastq ymm6, cs:qword_37460
vpbroadcastw ymm7, cs:word_374AA
loc_2F616:
cmp rax, rdx
jz loc_2F6A7
movzx r8d, word ptr [rcx+rdx]
vmovss xmm8, dword ptr [rdi+r8*4]
movzx r8d, word ptr [rcx+rdx+2]
vmovss xmm9, dword ptr [rdi+r8*4]
movzx r8d, word ptr [r9-2]
vfmadd231ss xmm0, xmm9, dword ptr [rdi+r8*4]
vmovdqu xmm9, xmmword ptr [rcx+rdx+8]
vpsrlw xmm10, xmm9, 4
vmovd xmm11, dword ptr [rcx+rdx+4]
vinserti128 ymm9, ymm9, xmm10, 1
vpermq ymm10, ymm11, 44h ; 'D'
vpshufb ymm10, ymm10, ymm2
vpor ymm10, ymm10, ymm3
vpcmpeqb ymm10, ymm10, ymm4
vpand ymm10, ymm10, ymm5
vpternlogq ymm10, ymm9, ymm6, 0F8h
movzx r8d, word ptr [r9-4]
vpmaddubsw ymm9, ymm10, ymmword ptr [r9]
vpmaddwd ymm9, ymm9, ymm7
vcvtdq2ps ymm9, ymm9
vmulss xmm8, xmm8, dword ptr [rdi+r8*4]
vbroadcastss ymm8, xmm8
vfmadd231ps ymm1, ymm9, ymm8
add rdx, 18h
add r9, 24h ; '$'
jmp loc_2F616
loc_2F6A7:
vextractf128 xmm2, ymm1, 1
vaddps xmm1, xmm2, xmm1
vshufpd xmm2, xmm1, xmm1, 1
vaddps xmm1, xmm1, xmm2
vhaddps xmm1, xmm1, xmm1
vaddss xmm0, xmm0, xmm1
vmovss dword ptr [rsi], xmm0
pop rax
vzeroupper
retn
loc_2F6CB:
lea rdi, aNQk0; "n % qk == 0"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlVecDot_5; "void ggml_vec_dot_q5_1_q8_1(int, float "...
mov edx, 0BA0h
call ___assert_fail
loc_2F6EA:
lea rdi, aNrc1; "nrc == 1"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlVecDot_5; "void ggml_vec_dot_q5_1_q8_1(int, float "...
mov edx, 0BA2h
call ___assert_fail
|
void __spoils<rdx,rcx,r8,r9,r10,r11,xmm0,xmm4,xmm5> ggml_vec_dot_q5_1_q8_1(
int a1,
long long _RSI,
__m128 _XMM0,
__m128 _XMM1,
long long a5,
long long _RCX,
long long a7,
long long a8,
int a9,
int a10)
{
long long v14; // rax
long long v15; // r9
if ( (a1 & 0x1F) != 0 )
__assert_fail(
"n % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c",
2976LL,
"void ggml_vec_dot_q5_1_q8_1(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)");
if ( a10 != 1 )
__assert_fail(
"nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c",
2978LL,
"void ggml_vec_dot_q5_1_q8_1(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)");
v14 = 24LL * ((a1 / 32) & (unsigned int)~((a1 / 32) >> 31));
v15 = a8 + 4;
__asm
{
vxorps xmm1, xmm1, xmm1
vxorps xmm0, xmm0, xmm0
}
_RDX = 0LL;
_RDI = &ggml_table_f32_f16;
__asm
{
vmovdqa ymm2, cs:ymmword_37240
vpbroadcastq ymm3, cs:qword_37450
vpcmpeqd ymm4, ymm4, ymm4
vpbroadcastq ymm5, cs:qword_37458
vpbroadcastq ymm6, cs:qword_37460
vpbroadcastw ymm7, cs:word_374AA
}
while ( v14 != _RDX )
{
_R8 = *(unsigned __int16 *)(_RCX + _RDX);
__asm { vmovss xmm8, dword ptr [rdi+r8*4] }
_R8 = *(unsigned __int16 *)(_RCX + _RDX + 2);
__asm
{
vmovss xmm9, dword ptr [rdi+r8*4]
vfmadd231ss xmm0, xmm9, dword ptr [rdi+r8*4]
vmovdqu xmm9, xmmword ptr [rcx+rdx+8]
vpsrlw xmm10, xmm9, 4
vmovd xmm11, dword ptr [rcx+rdx+4]
vinserti128 ymm9, ymm9, xmm10, 1
vpermq ymm10, ymm11, 44h ; 'D'
vpshufb ymm10, ymm10, ymm2
vpor ymm10, ymm10, ymm3
vpcmpeqb ymm10, ymm10, ymm4
vpand ymm10, ymm10, ymm5
vpternlogq ymm10, ymm9, ymm6, 0F8h
vpmaddubsw ymm9, ymm10, ymmword ptr [r9]
vpmaddwd ymm9, ymm9, ymm7
vcvtdq2ps ymm9, ymm9
vmulss xmm8, xmm8, dword ptr [rdi+r8*4]
vbroadcastss ymm8, xmm8
vfmadd231ps ymm1, ymm9, ymm8
}
_RDX += 24LL;
v15 += 36LL;
}
__asm
{
vextractf128 xmm2, ymm1, 1
vaddps xmm1, xmm2, xmm1
vshufpd xmm2, xmm1, xmm1, 1
vaddps xmm1, xmm1, xmm2
vhaddps xmm1, xmm1, xmm1
vaddss xmm0, xmm0, xmm1
vmovss dword ptr [rsi], xmm0
vzeroupper
}
}
|
ggml_vec_dot_q5_1_q8_1:
PUSH RAX
PUSH 0x20
POP R8
MOV EAX,EDI
CDQ
IDIV R8D
TEST DIL,0x1f
JNZ 0x0012f6cb
CMP dword ptr [RSP + 0x18],0x1
JNZ 0x0012f6ea
MOV EDX,EAX
SAR EDX,0x1f
ANDN EAX,EDX,EAX
IMUL RAX,RAX,0x18
ADD R9,0x4
VXORPS XMM1,XMM1,XMM1
VXORPS XMM0,XMM0,XMM0
XOR EDX,EDX
MOV RDI,qword ptr [0x00145f68]
VMOVDQA YMM2,ymmword ptr [0x00137240]
VPBROADCASTQ YMM3,qword ptr [0x00137450]
VPCMPEQD YMM4,YMM4,YMM4
VPBROADCASTQ YMM5,qword ptr [0x00137458]
VPBROADCASTQ YMM6,qword ptr [0x00137460]
VPBROADCASTW YMM7,word ptr [0x001374aa]
LAB_0012f616:
CMP RAX,RDX
JZ 0x0012f6a7
MOVZX R8D,word ptr [RCX + RDX*0x1]
VMOVSS XMM8,dword ptr [RDI + R8*0x4]
MOVZX R8D,word ptr [RCX + RDX*0x1 + 0x2]
VMOVSS XMM9,dword ptr [RDI + R8*0x4]
MOVZX R8D,word ptr [R9 + -0x2]
VFMADD231SS XMM0,XMM9,dword ptr [RDI + R8*0x4]
VMOVDQU XMM9,xmmword ptr [RCX + RDX*0x1 + 0x8]
VPSRLW XMM10,XMM9,0x4
VMOVD XMM11,dword ptr [RCX + RDX*0x1 + 0x4]
VINSERTI128 YMM9,YMM9,XMM10,0x1
VPERMQ YMM10,YMM11,0x44
VPSHUFB YMM10,YMM10,YMM2
VPOR YMM10,YMM10,YMM3
VPCMPEQB YMM10,YMM10,YMM4
VPAND YMM10,YMM10,YMM5
VPTERNLOGQ YMM10,YMM9,YMM6,0xf8
MOVZX R8D,word ptr [R9 + -0x4]
VPMADDUBSW YMM9,YMM10,ymmword ptr [R9]
VPMADDWD YMM9,YMM9,YMM7
VCVTDQ2PS YMM9,YMM9
VMULSS XMM8,XMM8,dword ptr [RDI + R8*0x4]
VBROADCASTSS YMM8,XMM8
VFMADD231PS YMM1,YMM9,YMM8
ADD RDX,0x18
ADD R9,0x24
JMP 0x0012f616
LAB_0012f6a7:
VEXTRACTF128 XMM2,YMM1,0x1
VADDPS XMM1,XMM2,XMM1
VSHUFPD XMM2,XMM1,XMM1,0x1
VADDPS XMM1,XMM1,XMM2
VHADDPS XMM1,XMM1,XMM1
VADDSS XMM0,XMM0,XMM1
VMOVSS dword ptr [RSI],XMM0
POP RAX
VZEROUPPER
RET
LAB_0012f6cb:
LEA RDI,[0x136948]
LEA RSI,[0x13fed0]
LEA RCX,[0x1402b7]
MOV EDX,0xba0
CALL 0x00108460
LAB_0012f6ea:
LEA RDI,[0x133b26]
LEA RSI,[0x13fed0]
LEA RCX,[0x1402b7]
MOV EDX,0xba2
CALL 0x00108460
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8
ggml_vec_dot_q5_1_q8_1
(uint param_1,float *param_2,int8 param_3,long param_4,int8 param_5,
long param_6,int8 param_7,int param_8)
{
float fVar1;
int1 auVar2 [32];
int8 in_RAX;
long lVar3;
int1 (*pauVar4) [32];
int1 auVar5 [32];
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
int1 auVar9 [32];
int1 in_ZMM4 [64];
int1 auVar10 [32];
int1 auVar11 [32];
int1 auVar12 [32];
int1 auVar13 [32];
int1 auVar14 [32];
int1 auVar15 [16];
if ((param_1 & 0x1f) != 0) {
/* WARNING: Subroutine does not return */
__assert_fail("n % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c"
,0xba0,
"void ggml_vec_dot_q5_1_q8_1(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)"
);
}
if (param_8 != 1) {
/* WARNING: Subroutine does not return */
__assert_fail("nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c"
,0xba2,
"void ggml_vec_dot_q5_1_q8_1(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)"
);
}
pauVar4 = (int1 (*) [32])(param_6 + 4);
auVar7 = ZEXT816(0) << 0x40;
auVar6 = ZEXT816(0) << 0x40;
lVar3 = 0;
auVar9._8_8_ = DAT_00137450;
auVar9._0_8_ = DAT_00137450;
auVar9._16_8_ = DAT_00137450;
auVar9._24_8_ = DAT_00137450;
auVar2 = vpcmpeqd_avx2(in_ZMM4._0_32_,in_ZMM4._0_32_);
auVar10._8_8_ = DAT_00137458;
auVar10._0_8_ = DAT_00137458;
auVar10._16_8_ = DAT_00137458;
auVar10._24_8_ = DAT_00137458;
auVar11._8_8_ = DAT_00137460;
auVar11._0_8_ = DAT_00137460;
auVar11._16_8_ = DAT_00137460;
auVar11._24_8_ = DAT_00137460;
auVar12._2_2_ = DAT_001374aa;
auVar12._0_2_ = DAT_001374aa;
auVar12._4_2_ = DAT_001374aa;
auVar12._6_2_ = DAT_001374aa;
auVar12._8_2_ = DAT_001374aa;
auVar12._10_2_ = DAT_001374aa;
auVar12._12_2_ = DAT_001374aa;
auVar12._14_2_ = DAT_001374aa;
auVar12._16_2_ = DAT_001374aa;
auVar12._18_2_ = DAT_001374aa;
auVar12._20_2_ = DAT_001374aa;
auVar12._22_2_ = DAT_001374aa;
auVar12._24_2_ = DAT_001374aa;
auVar12._26_2_ = DAT_001374aa;
auVar12._28_2_ = DAT_001374aa;
auVar12._30_2_ = DAT_001374aa;
for (; (ulong)(uint)(~((int)param_1 / 0x20 >> 0x1f) & (int)param_1 / 0x20) * 0x18 - lVar3 != 0;
lVar3 = lVar3 + 0x18) {
auVar6 = vfmadd231ss_fma(auVar6,ZEXT416(*(uint *)(PTR_ggml_table_f32_f16_00145f68 +
(ulong)*(ushort *)(param_4 + 2 + lVar3) * 4)),
ZEXT416(*(uint *)(PTR_ggml_table_f32_f16_00145f68 +
(ulong)*(ushort *)(pauVar4[-1] + 0x1e) * 4)));
auVar8 = *(int1 (*) [16])(param_4 + 8 + lVar3);
auVar15 = vpsrlw_avx(auVar8,4);
auVar14._0_16_ = ZEXT116(0) * auVar15 + ZEXT116(1) * auVar8;
auVar14._16_16_ = ZEXT116(0) * SUB4816((int1 [48])0x0,0) + ZEXT116(1) * auVar15;
auVar5 = vpermq_avx2(ZEXT432(*(uint *)(param_4 + 4 + lVar3)),0x44);
auVar5 = vpshufb_avx2(auVar5,_DAT_00137240);
auVar5 = vpor_avx2(auVar5,auVar9);
auVar5 = vpcmpeqb_avx2(auVar5,auVar2);
auVar5 = vpand_avx2(auVar5,auVar10);
auVar5 = vpternlogq_avx512vl(auVar5,auVar14,auVar11,0xf8);
auVar5 = vpmaddubsw_avx2(auVar5,*pauVar4);
auVar5 = vpmaddwd_avx2(auVar5,auVar12);
auVar5 = vcvtdq2ps_avx(auVar5);
fVar1 = *(float *)(PTR_ggml_table_f32_f16_00145f68 + (ulong)*(ushort *)(param_4 + lVar3) * 4) *
*(float *)(PTR_ggml_table_f32_f16_00145f68 + (ulong)*(ushort *)(pauVar4[-1] + 0x1c) * 4)
;
auVar13._4_4_ = fVar1;
auVar13._0_4_ = fVar1;
auVar13._8_4_ = fVar1;
auVar13._12_4_ = fVar1;
auVar13._16_4_ = fVar1;
auVar13._20_4_ = fVar1;
auVar13._24_4_ = fVar1;
auVar13._28_4_ = fVar1;
auVar7 = vfmadd231ps_fma(ZEXT1632(auVar7),auVar5,auVar13);
pauVar4 = (int1 (*) [32])(pauVar4[1] + 4);
}
auVar8._0_4_ = auVar7._0_4_ + 0.0;
auVar8._4_4_ = auVar7._4_4_ + 0.0;
auVar8._8_4_ = auVar7._8_4_ + 0.0;
auVar8._12_4_ = auVar7._12_4_ + 0.0;
auVar7 = vshufpd_avx(auVar8,auVar8,1);
auVar15._0_4_ = auVar8._0_4_ + auVar7._0_4_;
auVar15._4_4_ = auVar8._4_4_ + auVar7._4_4_;
auVar15._8_4_ = auVar8._8_4_ + auVar7._8_4_;
auVar15._12_4_ = auVar8._12_4_ + auVar7._12_4_;
auVar7 = vhaddps_avx(auVar15,auVar15);
*param_2 = auVar6._0_4_ + auVar7._0_4_;
return in_RAX;
}
|
|
17,283
|
ggml_vec_dot_q5_1_q8_1
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c
|
void ggml_vec_dot_q5_1_q8_1(int n, float * restrict s, size_t bs, const void * restrict vx, size_t bx, const void * restrict vy, size_t by, int nrc) {
const int qk = QK8_1;
const int nb = n / qk;
int ib = 0;
float sumf = 0;
assert(n % qk == 0);
assert(qk == QK5_1);
assert(nrc == 1);
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
const block_q5_1 * restrict x = vx;
const block_q8_1 * restrict y = vy;
#if defined(__ARM_NEON)
float32x4_t sumv0 = vdupq_n_f32(0.0f);
float32x4_t sumv1 = vdupq_n_f32(0.0f);
float summs0 = 0.0f;
float summs1 = 0.0f;
uint32_t qh0;
uint32_t qh1;
uint64_t tmp0[4];
uint64_t tmp1[4];
for (; ib + 1 < nb; ib += 2) {
const block_q5_1 * restrict x0 = &x[ib];
const block_q5_1 * restrict x1 = &x[ib + 1];
const block_q8_1 * restrict y0 = &y[ib];
const block_q8_1 * restrict y1 = &y[ib + 1];
const uint8x16_t m4b = vdupq_n_u8(0x0F);
summs0 += GGML_FP16_TO_FP32(x0->m) * GGML_FP16_TO_FP32(y0->s);
summs1 += GGML_FP16_TO_FP32(x1->m) * GGML_FP16_TO_FP32(y1->s);
// extract the 5th bit via lookup table ((b) << 4)
memcpy(&qh0, x0->qh, sizeof(qh0));
memcpy(&qh1, x1->qh, sizeof(qh1));
tmp0[0] = table_b2b_0[(qh0 >> 0) & 0xFF];
tmp0[1] = table_b2b_0[(qh0 >> 8) & 0xFF];
tmp0[2] = table_b2b_0[(qh0 >> 16) & 0xFF];
tmp0[3] = table_b2b_0[(qh0 >> 24) ];
tmp1[0] = table_b2b_0[(qh1 >> 0) & 0xFF];
tmp1[1] = table_b2b_0[(qh1 >> 8) & 0xFF];
tmp1[2] = table_b2b_0[(qh1 >> 16) & 0xFF];
tmp1[3] = table_b2b_0[(qh1 >> 24) ];
const int8x16_t qhl0 = vld1q_s8((const int8_t *)(tmp0 + 0));
const int8x16_t qhh0 = vld1q_s8((const int8_t *)(tmp0 + 2));
const int8x16_t qhl1 = vld1q_s8((const int8_t *)(tmp1 + 0));
const int8x16_t qhh1 = vld1q_s8((const int8_t *)(tmp1 + 2));
const uint8x16_t v0_0 = vld1q_u8(x0->qs);
const uint8x16_t v0_1 = vld1q_u8(x1->qs);
// 4-bit -> 8-bit
const int8x16_t v0_0l = vreinterpretq_s8_u8(vandq_u8 (v0_0, m4b));
const int8x16_t v0_0h = vreinterpretq_s8_u8(vshrq_n_u8(v0_0, 4));
const int8x16_t v0_1l = vreinterpretq_s8_u8(vandq_u8 (v0_1, m4b));
const int8x16_t v0_1h = vreinterpretq_s8_u8(vshrq_n_u8(v0_1, 4));
// add high bit
const int8x16_t v0_0lf = vorrq_s8(v0_0l, qhl0);
const int8x16_t v0_0hf = vorrq_s8(v0_0h, qhh0);
const int8x16_t v0_1lf = vorrq_s8(v0_1l, qhl1);
const int8x16_t v0_1hf = vorrq_s8(v0_1h, qhh1);
// load y
const int8x16_t v1_0l = vld1q_s8(y0->qs);
const int8x16_t v1_0h = vld1q_s8(y0->qs + 16);
const int8x16_t v1_1l = vld1q_s8(y1->qs);
const int8x16_t v1_1h = vld1q_s8(y1->qs + 16);
sumv0 = vmlaq_n_f32(sumv0, vcvtq_f32_s32(vaddq_s32(
ggml_vdotq_s32(vdupq_n_s32(0), v0_0lf, v1_0l),
ggml_vdotq_s32(vdupq_n_s32(0), v0_0hf, v1_0h))), GGML_FP16_TO_FP32(x0->d)*GGML_FP16_TO_FP32(y0->d));
sumv1 = vmlaq_n_f32(sumv1, vcvtq_f32_s32(vaddq_s32(
ggml_vdotq_s32(vdupq_n_s32(0), v0_1lf, v1_1l),
ggml_vdotq_s32(vdupq_n_s32(0), v0_1hf, v1_1h))), GGML_FP16_TO_FP32(x1->d)*GGML_FP16_TO_FP32(y1->d));
}
sumf = vaddvq_f32(sumv0) + vaddvq_f32(sumv1) + summs0 + summs1;
#elif defined(__wasm_simd128__)
v128_t sumv = wasm_f32x4_splat(0.0f);
float summs = 0.0f;
uint32_t qh;
uint64_t tmp[4];
// TODO: check if unrolling this is better
for (; ib < nb; ++ib) {
const block_q5_1 * restrict x0 = &x[ib];
const block_q8_1 * restrict y0 = &y[ib];
summs += GGML_FP16_TO_FP32(x0->m) * GGML_FP16_TO_FP32(y0->s);
const v128_t m4b = wasm_i8x16_splat(0x0F);
// extract the 5th bit
memcpy(&qh, x0->qh, sizeof(qh));
tmp[0] = table_b2b_0[(qh >> 0) & 0xFF];
tmp[1] = table_b2b_0[(qh >> 8) & 0xFF];
tmp[2] = table_b2b_0[(qh >> 16) & 0xFF];
tmp[3] = table_b2b_0[(qh >> 24) ];
const v128_t qhl = wasm_v128_load(tmp + 0);
const v128_t qhh = wasm_v128_load(tmp + 2);
const v128_t v0 = wasm_v128_load(x0->qs);
// 4-bit -> 8-bit
const v128_t v0l = wasm_v128_and (v0, m4b);
const v128_t v0h = wasm_u8x16_shr(v0, 4);
// add high bit
const v128_t v0lf = wasm_v128_or(v0l, qhl);
const v128_t v0hf = wasm_v128_or(v0h, qhh);
// load y
const v128_t v1l = wasm_v128_load(y0->qs);
const v128_t v1h = wasm_v128_load(y0->qs + 16);
// int8x16 -> int16x8
const v128_t v0lfl = wasm_i16x8_extend_low_i8x16 (v0lf);
const v128_t v0lfh = wasm_i16x8_extend_high_i8x16(v0lf);
const v128_t v0hfl = wasm_i16x8_extend_low_i8x16 (v0hf);
const v128_t v0hfh = wasm_i16x8_extend_high_i8x16(v0hf);
const v128_t v1ll = wasm_i16x8_extend_low_i8x16 (v1l);
const v128_t v1lh = wasm_i16x8_extend_high_i8x16(v1l);
const v128_t v1hl = wasm_i16x8_extend_low_i8x16 (v1h);
const v128_t v1hh = wasm_i16x8_extend_high_i8x16(v1h);
// dot product
sumv = wasm_f32x4_add(sumv,
wasm_f32x4_mul(wasm_f32x4_convert_i32x4(wasm_i32x4_add(
wasm_i32x4_add(wasm_i32x4_dot_i16x8(v0lfl, v1ll),
wasm_i32x4_dot_i16x8(v0lfh, v1lh)),
wasm_i32x4_add(wasm_i32x4_dot_i16x8(v0hfl, v1hl),
wasm_i32x4_dot_i16x8(v0hfh, v1hh)))),
wasm_f32x4_splat(GGML_FP16_TO_FP32(x0->d) * GGML_FP16_TO_FP32(y0->d))));
}
sumf = wasm_f32x4_extract_lane(sumv, 0) + wasm_f32x4_extract_lane(sumv, 1) +
wasm_f32x4_extract_lane(sumv, 2) + wasm_f32x4_extract_lane(sumv, 3) + summs;
#elif defined(__AVX2__)
// Initialize accumulator with zeros
__m256 acc = _mm256_setzero_ps();
float summs = 0.0f;
// Main loop
for (; ib < nb; ++ib) {
const __m256 dx = _mm256_set1_ps(GGML_FP16_TO_FP32(x[ib].d));
summs += GGML_FP16_TO_FP32(x[ib].m) * GGML_FP16_TO_FP32(y[ib].s);
__m256i qx = bytes_from_nibbles_32(x[ib].qs);
__m256i bxhi = bytes_from_bits_32(x[ib].qh);
bxhi = _mm256_and_si256(bxhi, _mm256_set1_epi8(0x10));
qx = _mm256_or_si256(qx, bxhi);
const __m256 dy = _mm256_set1_ps(GGML_FP16_TO_FP32(y[ib].d));
const __m256i qy = _mm256_loadu_si256((const __m256i *)y[ib].qs);
const __m256 q = mul_sum_us8_pairs_float(qx, qy);
acc = _mm256_fmadd_ps(q, _mm256_mul_ps(dx, dy), acc);
}
sumf = hsum_float_8(acc) + summs;
#elif defined(__AVX__)
// Initialize accumulator with zeros
__m256 acc = _mm256_setzero_ps();
__m128i mask = _mm_set1_epi8(0x10);
float summs = 0.0f;
// Main loop
for (; ib < nb; ++ib) {
const __m256 dx = _mm256_set1_ps(GGML_FP16_TO_FP32(x[ib].d));
summs += GGML_FP16_TO_FP32(x[ib].m) * GGML_FP16_TO_FP32(y[ib].s);
__m256i bx_0 = bytes_from_nibbles_32(x[ib].qs);
const __m256i bxhi = bytes_from_bits_32(x[ib].qh);
__m128i bxhil = _mm256_castsi256_si128(bxhi);
__m128i bxhih = _mm256_extractf128_si256(bxhi, 1);
bxhil = _mm_and_si128(bxhil, mask);
bxhih = _mm_and_si128(bxhih, mask);
__m128i bxl = _mm256_castsi256_si128(bx_0);
__m128i bxh = _mm256_extractf128_si256(bx_0, 1);
bxl = _mm_or_si128(bxl, bxhil);
bxh = _mm_or_si128(bxh, bxhih);
bx_0 = MM256_SET_M128I(bxh, bxl);
const __m256 dy = _mm256_set1_ps(GGML_FP16_TO_FP32(y[ib].d));
const __m256i by_0 = _mm256_loadu_si256((const __m256i *)y[ib].qs);
const __m256 q = mul_sum_us8_pairs_float(bx_0, by_0);
acc = _mm256_add_ps(_mm256_mul_ps(q, _mm256_mul_ps(dx, dy)), acc);
}
sumf = hsum_float_8(acc) + summs;
#elif defined(__riscv_v_intrinsic)
uint32_t qh;
size_t vl = __riscv_vsetvl_e8m1(qk/2);
// temporary registers for shift operations
vuint32m2_t vt_1 = __riscv_vid_v_u32m2(vl);
vuint32m2_t vt_2 = __riscv_vadd_vx_u32m2(vt_1, 12, vl);
for (; ib < nb; ++ib) {
memcpy(&qh, x[ib].qh, sizeof(uint32_t));
// load qh
vuint32m2_t vqh = __riscv_vmv_v_x_u32m2(qh, vl);
// ((qh >> (j + 0)) << 4) & 0x10;
vuint32m2_t xhr_0 = __riscv_vsrl_vv_u32m2(vqh, vt_1, vl);
vuint32m2_t xhl_0 = __riscv_vsll_vx_u32m2(xhr_0, 4, vl);
vuint32m2_t xha_0 = __riscv_vand_vx_u32m2(xhl_0, 0x10, vl);
// ((qh >> (j + 12)) ) & 0x10;
vuint32m2_t xhr_1 = __riscv_vsrl_vv_u32m2(vqh, vt_2, vl);
vuint32m2_t xha_1 = __riscv_vand_vx_u32m2(xhr_1, 0x10, vl);
// narrowing
vuint16m1_t xhc_0 = __riscv_vncvt_x_x_w_u16m1(xha_0, vl);
vuint8mf2_t xh_0 = __riscv_vncvt_x_x_w_u8mf2(xhc_0, vl);
vuint16m1_t xhc_1 = __riscv_vncvt_x_x_w_u16m1(xha_1, vl);
vuint8mf2_t xh_1 = __riscv_vncvt_x_x_w_u8mf2(xhc_1, vl);
// load
vuint8mf2_t tx = __riscv_vle8_v_u8mf2(x[ib].qs, vl);
vint8mf2_t y0 = __riscv_vle8_v_i8mf2(y[ib].qs, vl);
vint8mf2_t y1 = __riscv_vle8_v_i8mf2(y[ib].qs+16, vl);
vuint8mf2_t x_at = __riscv_vand_vx_u8mf2(tx, 0x0F, vl);
vuint8mf2_t x_lt = __riscv_vsrl_vx_u8mf2(tx, 0x04, vl);
vuint8mf2_t x_a = __riscv_vor_vv_u8mf2(x_at, xh_0, vl);
vuint8mf2_t x_l = __riscv_vor_vv_u8mf2(x_lt, xh_1, vl);
vint8mf2_t v0 = __riscv_vreinterpret_v_u8mf2_i8mf2(x_a);
vint8mf2_t v1 = __riscv_vreinterpret_v_u8mf2_i8mf2(x_l);
vint16m1_t vec_mul1 = __riscv_vwmul_vv_i16m1(v0, y0, vl);
vint16m1_t vec_mul2 = __riscv_vwmul_vv_i16m1(v1, y1, vl);
vint32m1_t vec_zero = __riscv_vmv_v_x_i32m1(0, vl);
vint32m1_t vs1 = __riscv_vwredsum_vs_i16m1_i32m1(vec_mul1, vec_zero, vl);
vint32m1_t vs2 = __riscv_vwredsum_vs_i16m1_i32m1(vec_mul2, vs1, vl);
int sumi = __riscv_vmv_x_s_i32m1_i32(vs2);
sumf += (GGML_FP16_TO_FP32(x[ib].d)*GGML_FP16_TO_FP32(y[ib].d))*sumi + GGML_FP16_TO_FP32(x[ib].m)*GGML_FP16_TO_FP32(y[ib].s);
}
#elif defined(__POWER9_VECTOR__)
const vector signed char lowMask = vec_splats((signed char)0xF);
const vector signed int v0 = vec_splats((int32_t)0);
const vector unsigned char v4 = vec_splats((unsigned char)0x4);
vector float vsumf0 = vec_splats(0.0f);
#pragma GCC unroll 4
for (; ib < nb; ++ib) {
__builtin_prefetch(x[ib].qs, 0, 1);
__builtin_prefetch(y[ib].qs, 0, 1);
vector float vxd = vec_splats(GGML_FP16_TO_FP32(x[ib].d));
vector float vyd = vec_splats(GGML_FP16_TO_FP32(y[ib].d));
vector float vd = vec_mul(vxd, vyd);
vector float vxmin = vec_splats(GGML_FP16_TO_FP32(x[ib].m));
vector float vys = {GGML_FP16_TO_FP32(y[ib].s), 0.f, 0.f, 0.f};
vsumf0 = vec_madd(vxmin, vys, vsumf0);
vector unsigned long long aux64x2_0 = {(uint64_t)(table_b2b_0[x[ib].qh[0]]), (uint64_t)(table_b2b_0[x[ib].qh[1]])};
vector unsigned long long aux64x2_1 = {(uint64_t)(table_b2b_0[x[ib].qh[2]]), (uint64_t)(table_b2b_0[x[ib].qh[3]])};
vector signed char qh0 = (vector signed char)aux64x2_0;
vector signed char qh1 = (vector signed char)aux64x2_1;
vector signed char qxs = (vector signed char)vec_xl( 0, x[ib].qs);
vector unsigned char q5x0 = (vector unsigned char)vec_or(vec_and(qxs, lowMask), qh0);
vector unsigned char q5x1 = (vector unsigned char)vec_or(vec_sr(qxs, v4), qh1);
vector signed char q8y0 = vec_xl( 0, y[ib].qs);
vector signed char q8y1 = vec_xl( 16, y[ib].qs);
vector signed int vsumi0 = v0;
vsumi0 = vec_msum(q8y0, q5x0, vsumi0);
vsumi0 = vec_msum(q8y1, q5x1, vsumi0);
vsumf0 = vec_madd(vec_ctf(vsumi0, 0), vd, vsumf0);
}
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 4));
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 8));
sumf = vec_extract(vsumf0, 0);
#elif defined(__loongarch_asx)
// Initialize accumulator with zeros
__m256 acc = (__m256)__lasx_xvldi(0);
float summs = 0.0f;
// Main loop
for (; ib < nb; ++ib) {
const __m256 dx = __lasx_xvreplfr2vr_s(GGML_FP16_TO_FP32(x[ib].d));
summs += GGML_FP16_TO_FP32(x[ib].m) * GGML_FP16_TO_FP32(y[ib].s);
__m256i qx = bytes_from_nibbles_32(x[ib].qs);
__m256i bxhi = bytes_from_bits_32(x[ib].qh);
bxhi = __lasx_xvand_v(bxhi, __lasx_xvreplgr2vr_b(0x10));
qx = __lasx_xvor_v(qx, bxhi);
const __m256 dy = __lasx_xvreplfr2vr_s(GGML_FP16_TO_FP32(y[ib].d));
const __m256i qy = __lasx_xvld((const __m256i *)y[ib].qs, 0);
const __m256 q = mul_sum_us8_pairs_float(qx, qy);
acc = __lasx_xvfmadd_s(q, __lasx_xvfmul_s(dx, dy), acc);
}
sumf = hsum_float_8(acc) + summs;
#endif
for (; ib < nb; ++ib) {
uint32_t qh;
memcpy(&qh, x[ib].qh, sizeof(qh));
int sumi0 = 0;
int sumi1 = 0;
for (int j = 0; j < qk/2; ++j) {
const uint8_t xh_0 = ((qh >> (j + 0)) << 4) & 0x10;
const uint8_t xh_1 = ((qh >> (j + 12)) ) & 0x10;
const int32_t x0 = (x[ib].qs[j] & 0xF) | xh_0;
const int32_t x1 = (x[ib].qs[j] >> 4) | xh_1;
sumi0 += (x0 * y[ib].qs[j]);
sumi1 += (x1 * y[ib].qs[j + qk/2]);
}
int sumi = sumi0 + sumi1;
sumf += (GGML_FP16_TO_FP32(x[ib].d)*GGML_FP16_TO_FP32(y[ib].d))*sumi + GGML_FP16_TO_FP32(x[ib].m)*GGML_FP16_TO_FP32(y[ib].s);
}
*s = sumf;
}
|
O3
|
c
|
ggml_vec_dot_q5_1_q8_1:
pushq %rbp
pushq %r14
pushq %rbx
leal 0x1f(%rdi), %eax
testl %edi, %edi
cmovnsl %edi, %eax
testb $0x1f, %dil
jne 0x32af8
cmpl $0x1, 0x28(%rsp)
jne 0x32b17
sarl $0x5, %eax
cmpl $0x20, %edi
jl 0x3295e
movl %eax, %edi
leaq 0x4(%r9), %rdx
shlq $0x3, %rdi
leaq (%rdi,%rdi,2), %rdi
vxorps %xmm0, %xmm0, %xmm0
vxorps %xmm1, %xmm1, %xmm1
xorl %r8d, %r8d
movq 0x166cc(%rip), %r10 # 0x48f68
vmovdqa 0x7abc(%rip), %ymm2 # 0x3a360
vpbroadcastq 0x7cbb(%rip), %ymm3 # 0x3a568
vpcmpeqd %ymm4, %ymm4, %ymm4
vpbroadcastq 0x7cb6(%rip), %ymm5 # 0x3a570
vpbroadcastq 0x7cb5(%rip), %ymm6 # 0x3a578
vpbroadcastw 0x7d06(%rip), %ymm7 # 0x3a5d2
movzwl (%rcx,%r8), %r11d
vmovss (%r10,%r11,4), %xmm8
movzwl 0x2(%rcx,%r8), %r11d
vmovss (%r10,%r11,4), %xmm9
movzwl -0x2(%rdx), %r11d
vfmadd231ss (%r10,%r11,4), %xmm9, %xmm0 # xmm0 = (xmm9 * mem) + xmm0
vmovdqu 0x8(%rcx,%r8), %xmm9
vpsrlw $0x4, %xmm9, %xmm10
vinserti128 $0x1, %xmm10, %ymm9, %ymm9
vmovd 0x4(%rcx,%r8), %xmm10
vpermq $0x44, %ymm10, %ymm10 # ymm10 = ymm10[0,1,0,1]
vpshufb %ymm2, %ymm10, %ymm10
vpor %ymm3, %ymm10, %ymm10
vpcmpeqb %ymm4, %ymm10, %ymm10
vpand %ymm5, %ymm10, %ymm10
vpternlogq $0xf8, %ymm6, %ymm9, %ymm10
movzwl -0x4(%rdx), %r11d
vpmaddubsw (%rdx), %ymm10, %ymm9
vpmaddwd %ymm7, %ymm9, %ymm9
vmulss (%r10,%r11,4), %xmm8, %xmm8
vcvtdq2ps %ymm9, %ymm9
vbroadcastss %xmm8, %ymm8
vfmadd231ps %ymm8, %ymm9, %ymm1 # ymm1 = (ymm9 * ymm8) + ymm1
addq $0x24, %rdx
addq $0x18, %r8
cmpq %r8, %rdi
jne 0x328cc
movl %eax, %edx
jmp 0x32968
xorl %edx, %edx
vxorps %xmm1, %xmm1, %xmm1
vxorps %xmm0, %xmm0, %xmm0
vextractf128 $0x1, %ymm1, %xmm2
vaddps %xmm1, %xmm2, %xmm1
vshufpd $0x1, %xmm1, %xmm1, %xmm2 # xmm2 = xmm1[1,0]
vaddps %xmm2, %xmm1, %xmm1
vhaddps %xmm1, %xmm1, %xmm1
vaddss %xmm1, %xmm0, %xmm0
cmpl %eax, %edx
jge 0x32aec
movl %edx, %edx
leaq (%rdx,%rdx,2), %rdi
leaq (%rcx,%rdi,8), %rdi
addq $0x8, %rdi
leaq (%rdx,%rdx,8), %r8
vpmovsxbd 0x3e72(%rip), %ymm1 # 0x36818
vpbroadcastd 0x797d(%rip), %ymm2 # 0x3a32c
vpbroadcastd 0x797c(%rip), %ymm3 # 0x3a334
leaq (%r9,%r8,4), %r8
addq $0x14, %r8
vpbroadcastd 0x6d27(%rip), %ymm4 # 0x396f0
vpbroadcastd 0x376a(%rip), %ymm5 # 0x3613c
movq 0x1658f(%rip), %r10 # 0x48f68
leaq (%rdx,%rdx,2), %r11
leaq (%rcx,%r11,8), %r11
vpbroadcastd 0x4(%r11), %ymm8
vpxor %xmm7, %xmm7, %xmm7
xorl %ebx, %ebx
vpxor %xmm6, %xmm6, %xmm6
vmovdqa %ymm1, %ymm9
vmovdqa %ymm1, %ymm10
vpsrlvd %ymm9, %ymm8, %ymm11
vpslld $0x4, %ymm11, %ymm11
vpaddd %ymm3, %ymm10, %ymm12
vpsrlvd %ymm12, %ymm8, %ymm12
vpmovzxbd (%rdi,%rbx), %ymm13
vpand %ymm4, %ymm13, %ymm14
vpternlogd $0xf8, %ymm2, %ymm11, %ymm14
vpsrld $0x4, %ymm13, %ymm11
vpternlogd $0xf8, %ymm2, %ymm12, %ymm11
vpmovsxbw -0x10(%r8,%rbx), %xmm12
vpmovdw %ymm14, %xmm13
vpmaddwd %xmm12, %xmm13, %xmm12
vpaddd %ymm7, %ymm12, %ymm7
vpmovsxbw (%r8,%rbx), %xmm12
vpmovdw %ymm11, %xmm11
vpmaddwd %xmm12, %xmm11, %xmm11
vpaddd %ymm6, %ymm11, %ymm6
addq $0x8, %rbx
vpaddd %ymm5, %ymm9, %ymm9
vpaddd %ymm5, %ymm10, %ymm10
cmpq $0x10, %rbx
jne 0x329f9
vextracti128 $0x1, %ymm7, %xmm8
vphaddd %xmm7, %xmm8, %xmm7
vphaddd %xmm7, %xmm7, %xmm7
vphaddd %xmm7, %xmm7, %xmm7
vextracti128 $0x1, %ymm6, %xmm8
vphaddd %xmm6, %xmm8, %xmm6
vphaddd %xmm6, %xmm6, %xmm6
vphaddd %xmm6, %xmm6, %xmm6
vmovd %xmm7, %ebx
vmovd %xmm6, %ebp
addl %ebx, %ebp
movzwl (%r11), %ebx
vmovss (%r10,%rbx,4), %xmm6
leaq (%rdx,%rdx,8), %rbx
movzwl (%r9,%rbx,4), %r14d
vmulss (%r10,%r14,4), %xmm6, %xmm6
vcvtsi2ss %ebp, %xmm15, %xmm7
movzwl 0x2(%r11), %r11d
vmovss (%r10,%r11,4), %xmm8
movzwl 0x2(%r9,%rbx,4), %r11d
vmulss (%r10,%r11,4), %xmm8, %xmm8
vfmadd231ss %xmm7, %xmm6, %xmm8 # xmm8 = (xmm6 * xmm7) + xmm8
vaddss %xmm0, %xmm8, %xmm0
incq %rdx
addq $0x18, %rdi
addq $0x24, %r8
cmpl %edx, %eax
jg 0x329d9
vmovss %xmm0, (%rsi)
popq %rbx
popq %r14
popq %rbp
vzeroupper
retq
leaq 0x6f43(%rip), %rdi # 0x39a42
leaq 0x104ea(%rip), %rsi # 0x42ff0
leaq 0x108ca(%rip), %rcx # 0x433d7
movl $0xba0, %edx # imm = 0xBA0
callq 0x83b0
leaq 0x4118(%rip), %rdi # 0x36c36
leaq 0x104cb(%rip), %rsi # 0x42ff0
leaq 0x108ab(%rip), %rcx # 0x433d7
movl $0xba2, %edx # imm = 0xBA2
callq 0x83b0
|
ggml_vec_dot_q5_1_q8_1:
push rbp
push r14
push rbx
lea eax, [rdi+1Fh]
test edi, edi
cmovns eax, edi
test dil, 1Fh
jnz loc_32AF8
cmp [rsp+18h+arg_8], 1
jnz loc_32B17
sar eax, 5
cmp edi, 20h ; ' '
jl loc_3295E
mov edi, eax
lea rdx, [r9+4]
shl rdi, 3
lea rdi, [rdi+rdi*2]
vxorps xmm0, xmm0, xmm0
vxorps xmm1, xmm1, xmm1
xor r8d, r8d
mov r10, cs:ggml_table_f32_f16_ptr
vmovdqa ymm2, cs:ymmword_3A360
vpbroadcastq ymm3, cs:qword_3A568
vpcmpeqd ymm4, ymm4, ymm4
vpbroadcastq ymm5, cs:qword_3A570
vpbroadcastq ymm6, cs:qword_3A578
vpbroadcastw ymm7, cs:word_3A5D2
loc_328CC:
movzx r11d, word ptr [rcx+r8]
vmovss xmm8, dword ptr [r10+r11*4]
movzx r11d, word ptr [rcx+r8+2]
vmovss xmm9, dword ptr [r10+r11*4]
movzx r11d, word ptr [rdx-2]
vfmadd231ss xmm0, xmm9, dword ptr [r10+r11*4]
vmovdqu xmm9, xmmword ptr [rcx+r8+8]
vpsrlw xmm10, xmm9, 4
vinserti128 ymm9, ymm9, xmm10, 1
vmovd xmm10, dword ptr [rcx+r8+4]
vpermq ymm10, ymm10, 44h ; 'D'
vpshufb ymm10, ymm10, ymm2
vpor ymm10, ymm10, ymm3
vpcmpeqb ymm10, ymm10, ymm4
vpand ymm10, ymm10, ymm5
vpternlogq ymm10, ymm9, ymm6, 0F8h
movzx r11d, word ptr [rdx-4]
vpmaddubsw ymm9, ymm10, ymmword ptr [rdx]
vpmaddwd ymm9, ymm9, ymm7
vmulss xmm8, xmm8, dword ptr [r10+r11*4]
vcvtdq2ps ymm9, ymm9
vbroadcastss ymm8, xmm8
vfmadd231ps ymm1, ymm9, ymm8
add rdx, 24h ; '$'
add r8, 18h
cmp rdi, r8
jnz loc_328CC
mov edx, eax
jmp short loc_32968
loc_3295E:
xor edx, edx
vxorps xmm1, xmm1, xmm1
vxorps xmm0, xmm0, xmm0
loc_32968:
vextractf128 xmm2, ymm1, 1
vaddps xmm1, xmm2, xmm1
vshufpd xmm2, xmm1, xmm1, 1
vaddps xmm1, xmm1, xmm2
vhaddps xmm1, xmm1, xmm1
vaddss xmm0, xmm0, xmm1
cmp edx, eax
jge loc_32AEC
mov edx, edx
lea rdi, [rdx+rdx*2]
lea rdi, [rcx+rdi*8]
add rdi, 8
lea r8, [rdx+rdx*8]
vpmovsxbd ymm1, cs:qword_36818
vpbroadcastd ymm2, cs:dword_3A32C
vpbroadcastd ymm3, cs:dword_3A334
lea r8, [r9+r8*4]
add r8, 14h
vpbroadcastd ymm4, cs:dword_396F0
vpbroadcastd ymm5, dword ptr cs:ymmword_3613C
mov r10, cs:ggml_table_f32_f16_ptr
loc_329D9:
lea r11, [rdx+rdx*2]
lea r11, [rcx+r11*8]
vpbroadcastd ymm8, dword ptr [r11+4]
vpxor xmm7, xmm7, xmm7
xor ebx, ebx
vpxor xmm6, xmm6, xmm6
vmovdqa ymm9, ymm1
vmovdqa ymm10, ymm1
loc_329F9:
vpsrlvd ymm11, ymm8, ymm9
vpslld ymm11, ymm11, 4
vpaddd ymm12, ymm10, ymm3
vpsrlvd ymm12, ymm8, ymm12
vpmovzxbd ymm13, qword ptr [rdi+rbx]
vpand ymm14, ymm13, ymm4
vpternlogd ymm14, ymm11, ymm2, 0F8h
vpsrld ymm11, ymm13, 4
vpternlogd ymm11, ymm12, ymm2, 0F8h
vpmovsxbw xmm12, qword ptr [r8+rbx-10h]
vpmovdw xmm13, ymm14
vpmaddwd xmm12, xmm13, xmm12
vpaddd ymm7, ymm12, ymm7
vpmovsxbw xmm12, qword ptr [r8+rbx]
vpmovdw xmm11, ymm11
vpmaddwd xmm11, xmm11, xmm12
vpaddd ymm6, ymm11, ymm6
add rbx, 8
vpaddd ymm9, ymm9, ymm5
vpaddd ymm10, ymm10, ymm5
cmp rbx, 10h
jnz short loc_329F9
vextracti128 xmm8, ymm7, 1
vphaddd xmm7, xmm8, xmm7
vphaddd xmm7, xmm7, xmm7
vphaddd xmm7, xmm7, xmm7
vextracti128 xmm8, ymm6, 1
vphaddd xmm6, xmm8, xmm6
vphaddd xmm6, xmm6, xmm6
vphaddd xmm6, xmm6, xmm6
vmovd ebx, xmm7
vmovd ebp, xmm6
add ebp, ebx
movzx ebx, word ptr [r11]
vmovss xmm6, dword ptr [r10+rbx*4]
lea rbx, [rdx+rdx*8]
movzx r14d, word ptr [r9+rbx*4]
vmulss xmm6, xmm6, dword ptr [r10+r14*4]
vcvtsi2ss xmm7, xmm15, ebp
movzx r11d, word ptr [r11+2]
vmovss xmm8, dword ptr [r10+r11*4]
movzx r11d, word ptr [r9+rbx*4+2]
vmulss xmm8, xmm8, dword ptr [r10+r11*4]
vfmadd231ss xmm8, xmm6, xmm7
vaddss xmm0, xmm8, xmm0
inc rdx
add rdi, 18h
add r8, 24h ; '$'
cmp eax, edx
jg loc_329D9
loc_32AEC:
vmovss dword ptr [rsi], xmm0
pop rbx
pop r14
pop rbp
vzeroupper
retn
loc_32AF8:
lea rdi, aNQk0; "n % qk == 0"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlVecDot_5; "void ggml_vec_dot_q5_1_q8_1(int, float "...
mov edx, 0BA0h
call ___assert_fail
loc_32B17:
lea rdi, aNrc1; "nrc == 1"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlVecDot_5; "void ggml_vec_dot_q5_1_q8_1(int, float "...
mov edx, 0BA2h
call ___assert_fail
|
long long ggml_vec_dot_q5_1_q8_1(
int a1,
long long _RSI,
__m128 _XMM0,
__m128 _XMM1,
double a5,
double a6,
double a7,
double a8,
__m128 _XMM6,
__m128 _XMM7,
long long a11,
long long _RCX,
long long a13,
long long a14,
int a15,
int a16)
{
int v21; // eax
long long result; // rax
long long v23; // rdx
long long v51; // rdx
v21 = a1 + 31;
if ( a1 >= 0 )
v21 = a1;
if ( (a1 & 0x1F) != 0 )
__assert_fail(
"n % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c",
2976LL,
"void ggml_vec_dot_q5_1_q8_1(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)");
if ( a16 != 1 )
__assert_fail(
"nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c",
2978LL,
"void ggml_vec_dot_q5_1_q8_1(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)");
result = (unsigned int)(v21 >> 5);
if ( a1 < 32 )
{
LODWORD(v51) = 0;
__asm
{
vxorps xmm1, xmm1, xmm1
vxorps xmm0, xmm0, xmm0
}
}
else
{
v23 = a14 + 4;
__asm
{
vxorps xmm0, xmm0, xmm0
vxorps xmm1, xmm1, xmm1
}
_R8 = 0LL;
_R10 = &ggml_table_f32_f16;
__asm
{
vmovdqa ymm2, cs:ymmword_3A360
vpbroadcastq ymm3, cs:qword_3A568
vpcmpeqd ymm4, ymm4, ymm4
vpbroadcastq ymm5, cs:qword_3A570
vpbroadcastq ymm6, cs:qword_3A578
vpbroadcastw ymm7, cs:word_3A5D2
}
do
{
_R11 = *(unsigned __int16 *)(_RCX + _R8);
__asm { vmovss xmm8, dword ptr [r10+r11*4] }
_R11 = *(unsigned __int16 *)(_RCX + _R8 + 2);
__asm
{
vmovss xmm9, dword ptr [r10+r11*4]
vfmadd231ss xmm0, xmm9, dword ptr [r10+r11*4]
vmovdqu xmm9, xmmword ptr [rcx+r8+8]
vpsrlw xmm10, xmm9, 4
vinserti128 ymm9, ymm9, xmm10, 1
vmovd xmm10, dword ptr [rcx+r8+4]
vpermq ymm10, ymm10, 44h ; 'D'
vpshufb ymm10, ymm10, ymm2
vpor ymm10, ymm10, ymm3
vpcmpeqb ymm10, ymm10, ymm4
vpand ymm10, ymm10, ymm5
vpternlogq ymm10, ymm9, ymm6, 0F8h
vpmaddubsw ymm9, ymm10, ymmword ptr [rdx]
vpmaddwd ymm9, ymm9, ymm7
vmulss xmm8, xmm8, dword ptr [r10+r11*4]
vcvtdq2ps ymm9, ymm9
vbroadcastss ymm8, xmm8
vfmadd231ps ymm1, ymm9, ymm8
}
v23 += 36LL;
_R8 += 24LL;
}
while ( 24LL * (unsigned int)result != _R8 );
LODWORD(v51) = result;
}
__asm
{
vextractf128 xmm2, ymm1, 1
vaddps xmm1, xmm2, xmm1
vshufpd xmm2, xmm1, xmm1, 1
vaddps xmm1, xmm1, xmm2
vhaddps xmm1, xmm1, xmm1
vaddss xmm0, xmm0, xmm1
}
if ( (int)v51 < (int)result )
{
v51 = (unsigned int)v51;
_RDI = _RCX + 24LL * (unsigned int)v51 + 8;
__asm
{
vpmovsxbd ymm1, cs:qword_36818
vpbroadcastd ymm2, cs:dword_3A32C
vpbroadcastd ymm3, cs:dword_3A334
}
_R8 = a14 + 36LL * (unsigned int)v51 + 20;
__asm
{
vpbroadcastd ymm4, cs:dword_396F0
vpbroadcastd ymm5, dword ptr cs:ymmword_3613C
}
_R10 = &ggml_table_f32_f16;
do
{
_R11 = (unsigned __int16 *)(_RCX + 24 * v51);
__asm
{
vpbroadcastd ymm8, dword ptr [r11+4]
vpxor xmm7, xmm7, xmm7
}
_RBX = 0LL;
__asm
{
vpxor xmm6, xmm6, xmm6
vmovdqa ymm9, ymm1
vmovdqa ymm10, ymm1
}
do
{
__asm
{
vpsrlvd ymm11, ymm8, ymm9
vpslld ymm11, ymm11, 4
vpaddd ymm12, ymm10, ymm3
vpsrlvd ymm12, ymm8, ymm12
vpmovzxbd ymm13, qword ptr [rdi+rbx]
vpand ymm14, ymm13, ymm4
vpternlogd ymm14, ymm11, ymm2, 0F8h
vpsrld ymm11, ymm13, 4
vpternlogd ymm11, ymm12, ymm2, 0F8h
vpmovsxbw xmm12, qword ptr [r8+rbx-10h]
vpmovdw xmm13, ymm14
vpmaddwd xmm12, xmm13, xmm12
vpaddd ymm7, ymm12, ymm7
vpmovsxbw xmm12, qword ptr [r8+rbx]
vpmovdw xmm11, ymm11
vpmaddwd xmm11, xmm11, xmm12
vpaddd ymm6, ymm11, ymm6
}
_RBX += 8LL;
__asm
{
vpaddd ymm9, ymm9, ymm5
vpaddd ymm10, ymm10, ymm5
}
}
while ( _RBX != 16 );
__asm
{
vextracti128 xmm8, ymm7, 1
vphaddd xmm7, xmm8, xmm7
vphaddd xmm7, xmm7, xmm7
vphaddd xmm7, xmm7, xmm7
vextracti128 xmm8, ymm6, 1
vphaddd xmm6, xmm8, xmm6
vphaddd xmm6, xmm6, xmm6
vphaddd xmm6, xmm6, xmm6
vmovd ebx, xmm7
vmovd ebp, xmm6
}
_RBX = *_R11;
__asm
{
vmovss xmm6, dword ptr [r10+rbx*4]
vmulss xmm6, xmm6, dword ptr [r10+r14*4]
vcvtsi2ss xmm7, xmm15, ebp
}
_R11 = _R11[1];
__asm
{
vmovss xmm8, dword ptr [r10+r11*4]
vmulss xmm8, xmm8, dword ptr [r10+r11*4]
vfmadd231ss xmm8, xmm6, xmm7
vaddss xmm0, xmm8, xmm0
}
++v51;
_RDI += 24LL;
_R8 += 36LL;
}
while ( (int)result > (int)v51 );
}
__asm
{
vmovss dword ptr [rsi], xmm0
vzeroupper
}
return result;
}
|
ggml_vec_dot_q5_1_q8_1:
PUSH RBP
PUSH R14
PUSH RBX
LEA EAX,[RDI + 0x1f]
TEST EDI,EDI
CMOVNS EAX,EDI
TEST DIL,0x1f
JNZ 0x00132af8
CMP dword ptr [RSP + 0x28],0x1
JNZ 0x00132b17
SAR EAX,0x5
CMP EDI,0x20
JL 0x0013295e
MOV EDI,EAX
LEA RDX,[R9 + 0x4]
SHL RDI,0x3
LEA RDI,[RDI + RDI*0x2]
VXORPS XMM0,XMM0,XMM0
VXORPS XMM1,XMM1,XMM1
XOR R8D,R8D
MOV R10,qword ptr [0x00148f68]
VMOVDQA YMM2,ymmword ptr [0x0013a360]
VPBROADCASTQ YMM3,qword ptr [0x0013a568]
VPCMPEQD YMM4,YMM4,YMM4
VPBROADCASTQ YMM5,qword ptr [0x0013a570]
VPBROADCASTQ YMM6,qword ptr [0x0013a578]
VPBROADCASTW YMM7,word ptr [0x0013a5d2]
LAB_001328cc:
MOVZX R11D,word ptr [RCX + R8*0x1]
VMOVSS XMM8,dword ptr [R10 + R11*0x4]
MOVZX R11D,word ptr [RCX + R8*0x1 + 0x2]
VMOVSS XMM9,dword ptr [R10 + R11*0x4]
MOVZX R11D,word ptr [RDX + -0x2]
VFMADD231SS XMM0,XMM9,dword ptr [R10 + R11*0x4]
VMOVDQU XMM9,xmmword ptr [RCX + R8*0x1 + 0x8]
VPSRLW XMM10,XMM9,0x4
VINSERTI128 YMM9,YMM9,XMM10,0x1
VMOVD XMM10,dword ptr [RCX + R8*0x1 + 0x4]
VPERMQ YMM10,YMM10,0x44
VPSHUFB YMM10,YMM10,YMM2
VPOR YMM10,YMM10,YMM3
VPCMPEQB YMM10,YMM10,YMM4
VPAND YMM10,YMM10,YMM5
VPTERNLOGQ YMM10,YMM9,YMM6,0xf8
MOVZX R11D,word ptr [RDX + -0x4]
VPMADDUBSW YMM9,YMM10,ymmword ptr [RDX]
VPMADDWD YMM9,YMM9,YMM7
VMULSS XMM8,XMM8,dword ptr [R10 + R11*0x4]
VCVTDQ2PS YMM9,YMM9
VBROADCASTSS YMM8,XMM8
VFMADD231PS YMM1,YMM9,YMM8
ADD RDX,0x24
ADD R8,0x18
CMP RDI,R8
JNZ 0x001328cc
MOV EDX,EAX
JMP 0x00132968
LAB_0013295e:
XOR EDX,EDX
VXORPS XMM1,XMM1,XMM1
VXORPS XMM0,XMM0,XMM0
LAB_00132968:
VEXTRACTF128 XMM2,YMM1,0x1
VADDPS XMM1,XMM2,XMM1
VSHUFPD XMM2,XMM1,XMM1,0x1
VADDPS XMM1,XMM1,XMM2
VHADDPS XMM1,XMM1,XMM1
VADDSS XMM0,XMM0,XMM1
CMP EDX,EAX
JGE 0x00132aec
MOV EDX,EDX
LEA RDI,[RDX + RDX*0x2]
LEA RDI,[RCX + RDI*0x8]
ADD RDI,0x8
LEA R8,[RDX + RDX*0x8]
VPMOVSXBD YMM1,qword ptr [0x00136818]
VPBROADCASTD YMM2,dword ptr [0x0013a32c]
VPBROADCASTD YMM3,dword ptr [0x0013a334]
LEA R8,[R9 + R8*0x4]
ADD R8,0x14
VPBROADCASTD YMM4,dword ptr [0x001396f0]
VPBROADCASTD YMM5,dword ptr [0x0013613c]
MOV R10,qword ptr [0x00148f68]
LAB_001329d9:
LEA R11,[RDX + RDX*0x2]
LEA R11,[RCX + R11*0x8]
VPBROADCASTD YMM8,dword ptr [R11 + 0x4]
VPXOR XMM7,XMM7,XMM7
XOR EBX,EBX
VPXOR XMM6,XMM6,XMM6
VMOVDQA YMM9,YMM1
VMOVDQA YMM10,YMM1
LAB_001329f9:
VPSRLVD YMM11,YMM8,YMM9
VPSLLD YMM11,YMM11,0x4
VPADDD YMM12,YMM10,YMM3
VPSRLVD YMM12,YMM8,YMM12
VPMOVZXBD YMM13,qword ptr [RDI + RBX*0x1]
VPAND YMM14,YMM13,YMM4
VPTERNLOGD YMM14,YMM11,YMM2,0xf8
VPSRLD YMM11,YMM13,0x4
VPTERNLOGD YMM11,YMM12,YMM2,0xf8
VPMOVSXBW XMM12,qword ptr [R8 + RBX*0x1 + -0x10]
VPMOVDW XMM13,YMM14
VPMADDWD XMM12,XMM13,XMM12
VPADDD YMM7,YMM12,YMM7
VPMOVSXBW XMM12,qword ptr [R8 + RBX*0x1]
VPMOVDW XMM11,YMM11
VPMADDWD XMM11,XMM11,XMM12
VPADDD YMM6,YMM11,YMM6
ADD RBX,0x8
VPADDD YMM9,YMM9,YMM5
VPADDD YMM10,YMM10,YMM5
CMP RBX,0x10
JNZ 0x001329f9
VEXTRACTI128 XMM8,YMM7,0x1
VPHADDD XMM7,XMM8,XMM7
VPHADDD XMM7,XMM7,XMM7
VPHADDD XMM7,XMM7,XMM7
VEXTRACTI128 XMM8,YMM6,0x1
VPHADDD XMM6,XMM8,XMM6
VPHADDD XMM6,XMM6,XMM6
VPHADDD XMM6,XMM6,XMM6
VMOVD EBX,XMM7
VMOVD EBP,XMM6
ADD EBP,EBX
MOVZX EBX,word ptr [R11]
VMOVSS XMM6,dword ptr [R10 + RBX*0x4]
LEA RBX,[RDX + RDX*0x8]
MOVZX R14D,word ptr [R9 + RBX*0x4]
VMULSS XMM6,XMM6,dword ptr [R10 + R14*0x4]
VCVTSI2SS XMM7,XMM15,EBP
MOVZX R11D,word ptr [R11 + 0x2]
VMOVSS XMM8,dword ptr [R10 + R11*0x4]
MOVZX R11D,word ptr [R9 + RBX*0x4 + 0x2]
VMULSS XMM8,XMM8,dword ptr [R10 + R11*0x4]
VFMADD231SS XMM8,XMM6,XMM7
VADDSS XMM0,XMM8,XMM0
INC RDX
ADD RDI,0x18
ADD R8,0x24
CMP EAX,EDX
JG 0x001329d9
LAB_00132aec:
VMOVSS dword ptr [RSI],XMM0
POP RBX
POP R14
POP RBP
VZEROUPPER
RET
LAB_00132af8:
LEA RDI,[0x139a42]
LEA RSI,[0x142ff0]
LEA RCX,[0x1433d7]
MOV EDX,0xba0
CALL 0x001083b0
LAB_00132b17:
LEA RDI,[0x136c36]
LEA RSI,[0x142ff0]
LEA RCX,[0x1433d7]
MOV EDX,0xba2
CALL 0x001083b0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_vec_dot_q5_1_q8_1
(uint param_1,float *param_2,int8 param_3,long param_4,int8 param_5,
long param_6,int8 param_7,int param_8)
{
ushort *puVar1;
int4 uVar2;
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
uint uVar7;
uint uVar8;
int1 (*pauVar9) [32];
ulong uVar10;
long lVar11;
long lVar12;
long lVar13;
int1 auVar14 [32];
int1 auVar15 [32];
float fVar16;
int1 auVar17 [64];
int1 auVar18 [16];
int1 auVar19 [64];
int1 auVar20 [32];
int1 auVar21 [32];
int1 auVar22 [32];
int1 auVar23 [32];
int1 in_ZMM4 [64];
int1 auVar24 [32];
int1 auVar25 [32];
int1 auVar26 [16];
int1 auVar27 [32];
int1 auVar28 [32];
int1 auVar29 [16];
int1 auVar30 [16];
int1 auVar31 [32];
int1 auVar32 [32];
int1 auVar33 [16];
int1 in_register_000015c4 [12];
uVar7 = param_1 + 0x1f;
if (-1 < (int)param_1) {
uVar7 = param_1;
}
if ((param_1 & 0x1f) == 0) {
if (param_8 == 1) {
uVar7 = (int)uVar7 >> 5;
if ((int)param_1 < 0x20) {
auVar14 = SUB6432(ZEXT864(0),0);
auVar17 = ZEXT864(0);
uVar8 = 0;
}
else {
pauVar9 = (int1 (*) [32])(param_6 + 4);
auVar17 = ZEXT864(0);
auVar19 = ZEXT864(0);
lVar12 = 0;
auVar21._8_8_ = DAT_0013a568;
auVar21._0_8_ = DAT_0013a568;
auVar21._16_8_ = DAT_0013a568;
auVar21._24_8_ = DAT_0013a568;
auVar20 = vpcmpeqd_avx2(in_ZMM4._0_32_,in_ZMM4._0_32_);
auVar24._8_8_ = DAT_0013a570;
auVar24._0_8_ = DAT_0013a570;
auVar24._16_8_ = DAT_0013a570;
auVar24._24_8_ = DAT_0013a570;
auVar15._8_8_ = DAT_0013a578;
auVar15._0_8_ = DAT_0013a578;
auVar15._16_8_ = DAT_0013a578;
auVar15._24_8_ = DAT_0013a578;
auVar32._2_2_ = DAT_0013a5d2;
auVar32._0_2_ = DAT_0013a5d2;
auVar32._4_2_ = DAT_0013a5d2;
auVar32._6_2_ = DAT_0013a5d2;
auVar32._8_2_ = DAT_0013a5d2;
auVar32._10_2_ = DAT_0013a5d2;
auVar32._12_2_ = DAT_0013a5d2;
auVar32._14_2_ = DAT_0013a5d2;
auVar32._16_2_ = DAT_0013a5d2;
auVar32._18_2_ = DAT_0013a5d2;
auVar32._20_2_ = DAT_0013a5d2;
auVar32._22_2_ = DAT_0013a5d2;
auVar32._24_2_ = DAT_0013a5d2;
auVar32._26_2_ = DAT_0013a5d2;
auVar32._28_2_ = DAT_0013a5d2;
auVar32._30_2_ = DAT_0013a5d2;
do {
auVar6 = vfmadd231ss_fma(auVar17._0_16_,
ZEXT416(*(uint *)(PTR_ggml_table_f32_f16_00148f68 +
(ulong)*(ushort *)(param_4 + 2 + lVar12) * 4)),
ZEXT416(*(uint *)(PTR_ggml_table_f32_f16_00148f68 +
(ulong)*(ushort *)(pauVar9[-1] + 0x1e) * 4)));
auVar17 = ZEXT1664(auVar6);
auVar6 = *(int1 (*) [16])(param_4 + 8 + lVar12);
auVar29 = vpsrlw_avx(auVar6,4);
auVar31._0_16_ = ZEXT116(0) * auVar29 + ZEXT116(1) * auVar6;
auVar31._16_16_ = ZEXT116(0) * SUB4816((int1 [48])0x0,0) + ZEXT116(1) * auVar29;
auVar14 = vpermq_avx2(ZEXT432(*(uint *)(param_4 + 4 + lVar12)),0x44);
auVar14 = vpshufb_avx2(auVar14,_DAT_0013a360);
auVar14 = vpor_avx2(auVar14,auVar21);
auVar14 = vpcmpeqb_avx2(auVar14,auVar20);
auVar14 = vpand_avx2(auVar14,auVar24);
auVar14 = vpternlogq_avx512vl(auVar14,auVar31,auVar15,0xf8);
auVar14 = vpmaddubsw_avx2(auVar14,*pauVar9);
auVar14 = vpmaddwd_avx2(auVar14,auVar32);
fVar16 = *(float *)(PTR_ggml_table_f32_f16_00148f68 +
(ulong)*(ushort *)(param_4 + lVar12) * 4) *
*(float *)(PTR_ggml_table_f32_f16_00148f68 +
(ulong)*(ushort *)(pauVar9[-1] + 0x1c) * 4);
auVar14 = vcvtdq2ps_avx(auVar14);
auVar27._4_4_ = fVar16;
auVar27._0_4_ = fVar16;
auVar27._8_4_ = fVar16;
auVar27._12_4_ = fVar16;
auVar27._16_4_ = fVar16;
auVar27._20_4_ = fVar16;
auVar27._24_4_ = fVar16;
auVar27._28_4_ = fVar16;
auVar6 = vfmadd231ps_fma(auVar19._0_32_,auVar14,auVar27);
auVar19 = ZEXT1664(auVar6);
auVar14 = ZEXT1632(auVar6);
pauVar9 = (int1 (*) [32])(pauVar9[1] + 4);
lVar12 = lVar12 + 0x18;
uVar8 = uVar7;
} while ((ulong)uVar7 * 0x18 != lVar12);
}
auVar29._0_4_ = auVar14._16_4_ + auVar14._0_4_;
auVar29._4_4_ = auVar14._20_4_ + auVar14._4_4_;
auVar29._8_4_ = auVar14._24_4_ + auVar14._8_4_;
auVar29._12_4_ = auVar14._28_4_ + auVar14._12_4_;
auVar6 = vshufpd_avx(auVar29,auVar29,1);
auVar18._0_4_ = auVar29._0_4_ + auVar6._0_4_;
auVar18._4_4_ = auVar29._4_4_ + auVar6._4_4_;
auVar18._8_4_ = auVar29._8_4_ + auVar6._8_4_;
auVar18._12_4_ = auVar29._12_4_ + auVar6._12_4_;
auVar6 = vhaddps_avx(auVar18,auVar18);
fVar16 = auVar17._0_4_ + auVar6._0_4_;
if ((int)uVar8 < (int)uVar7) {
uVar10 = (ulong)uVar8;
lVar12 = param_4 + uVar10 * 0x18 + 8;
auVar6._8_8_ = 0;
auVar6._0_8_ = DAT_00136818;
auVar14 = vpmovsxbd_avx2(auVar6);
auVar20._4_4_ = DAT_0013a32c;
auVar20._0_4_ = DAT_0013a32c;
auVar20._8_4_ = DAT_0013a32c;
auVar20._12_4_ = DAT_0013a32c;
auVar20._16_4_ = DAT_0013a32c;
auVar20._20_4_ = DAT_0013a32c;
auVar20._24_4_ = DAT_0013a32c;
auVar20._28_4_ = DAT_0013a32c;
auVar22._4_4_ = DAT_0013a334;
auVar22._0_4_ = DAT_0013a334;
auVar22._8_4_ = DAT_0013a334;
auVar22._12_4_ = DAT_0013a334;
auVar22._16_4_ = DAT_0013a334;
auVar22._20_4_ = DAT_0013a334;
auVar22._24_4_ = DAT_0013a334;
auVar22._28_4_ = DAT_0013a334;
lVar13 = param_6 + uVar10 * 0x24 + 0x14;
auVar23._4_4_ = DAT_001396f0;
auVar23._0_4_ = DAT_001396f0;
auVar23._8_4_ = DAT_001396f0;
auVar23._12_4_ = DAT_001396f0;
auVar23._16_4_ = DAT_001396f0;
auVar23._20_4_ = DAT_001396f0;
auVar23._24_4_ = DAT_001396f0;
auVar23._28_4_ = DAT_001396f0;
auVar25._4_4_ = DAT_0013613c;
auVar25._0_4_ = DAT_0013613c;
auVar25._8_4_ = DAT_0013613c;
auVar25._12_4_ = DAT_0013613c;
auVar25._16_4_ = DAT_0013613c;
auVar25._20_4_ = DAT_0013613c;
auVar25._24_4_ = DAT_0013613c;
auVar25._28_4_ = DAT_0013613c;
do {
puVar1 = (ushort *)(param_4 + uVar10 * 0x18);
uVar2 = *(int4 *)(puVar1 + 2);
auVar28._4_4_ = uVar2;
auVar28._0_4_ = uVar2;
auVar28._8_4_ = uVar2;
auVar28._12_4_ = uVar2;
auVar28._16_4_ = uVar2;
auVar28._20_4_ = uVar2;
auVar28._24_4_ = uVar2;
auVar28._28_4_ = uVar2;
auVar19 = ZEXT1664((int1 [16])0x0);
lVar11 = 0;
auVar17 = ZEXT1664((int1 [16])0x0);
auVar21 = auVar14;
auVar24 = auVar14;
do {
auVar15 = vpsrlvd_avx2(auVar28,auVar21);
auVar31 = vpslld_avx2(auVar15,4);
auVar15 = vpaddd_avx2(auVar24,auVar22);
auVar27 = vpsrlvd_avx2(auVar28,auVar15);
auVar3._8_8_ = 0;
auVar3._0_8_ = *(ulong *)(lVar12 + lVar11);
auVar32 = vpmovzxbd_avx2(auVar3);
auVar15 = vpand_avx2(auVar32,auVar23);
auVar15 = vpternlogd_avx512vl(auVar15,auVar31,auVar20,0xf8);
auVar32 = vpsrld_avx2(auVar32,4);
auVar32 = vpternlogd_avx512vl(auVar32,auVar27,auVar20,0xf8);
auVar4._8_8_ = 0;
auVar4._0_8_ = *(ulong *)(lVar13 + -0x10 + lVar11);
auVar6 = vpmovsxbw_avx(auVar4);
auVar29 = vpmovdw_avx512vl(auVar15);
auVar33._8_8_ = 0;
auVar33._0_8_ = auVar29._0_8_;
auVar6 = vpmaddwd_avx(auVar33,auVar6);
auVar15 = vpaddd_avx2(ZEXT1632(auVar6),auVar19._0_32_);
auVar19 = ZEXT3264(auVar15);
auVar5._8_8_ = 0;
auVar5._0_8_ = *(ulong *)(lVar13 + lVar11);
auVar6 = vpmovsxbw_avx(auVar5);
auVar29 = vpmovdw_avx512vl(auVar32);
auVar30._8_8_ = 0;
auVar30._0_8_ = auVar29._0_8_;
auVar6 = vpmaddwd_avx(auVar30,auVar6);
auVar32 = vpaddd_avx2(ZEXT1632(auVar6),auVar17._0_32_);
auVar17 = ZEXT3264(auVar32);
lVar11 = lVar11 + 8;
auVar21 = vpaddd_avx2(auVar21,auVar25);
auVar24 = vpaddd_avx2(auVar24,auVar25);
} while (lVar11 != 0x10);
auVar6 = vphaddd_avx(auVar15._16_16_,auVar15._0_16_);
auVar6 = vphaddd_avx(auVar6,auVar6);
auVar6 = vphaddd_avx(auVar6,auVar6);
auVar29 = vphaddd_avx(auVar32._16_16_,auVar32._0_16_);
auVar29 = vphaddd_avx(auVar29,auVar29);
auVar29 = vphaddd_avx(auVar29,auVar29);
auVar26._0_4_ = (float)(auVar29._0_4_ + auVar6._0_4_);
auVar26._4_12_ = in_register_000015c4;
auVar6 = vfmadd231ss_fma(ZEXT416((uint)(*(float *)(PTR_ggml_table_f32_f16_00148f68 +
(ulong)puVar1[1] * 4) *
*(float *)(PTR_ggml_table_f32_f16_00148f68 +
(ulong)*(ushort *)
(param_6 + 2 + uVar10 * 0x24) * 4
))),
ZEXT416((uint)(*(float *)(PTR_ggml_table_f32_f16_00148f68 +
(ulong)*puVar1 * 4) *
*(float *)(PTR_ggml_table_f32_f16_00148f68 +
(ulong)*(ushort *)
(param_6 + uVar10 * 0x24) * 4))),
auVar26);
fVar16 = auVar6._0_4_ + fVar16;
uVar10 = uVar10 + 1;
lVar12 = lVar12 + 0x18;
lVar13 = lVar13 + 0x24;
} while ((int)uVar10 < (int)uVar7);
}
*param_2 = fVar16;
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c"
,0xba2,
"void ggml_vec_dot_q5_1_q8_1(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)"
);
}
/* WARNING: Subroutine does not return */
__assert_fail("n % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c"
,0xba0,
"void ggml_vec_dot_q5_1_q8_1(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)"
);
}
|
|
17,284
|
ftxui::focusCursorBar(std::shared_ptr<ftxui::Node>)
|
Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/dom/frame.cpp
|
Element focusCursorBar(Element child) {
return std::make_shared<FocusCursor>(unpack(std::move(child)),
Screen::Cursor::Bar);
}
|
O1
|
cpp
|
ftxui::focusCursorBar(std::shared_ptr<ftxui::Node>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq (%rsi), %rcx
leaq 0x38(%rsp), %rax
movq %rcx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq 0x8(%rsi), %rdx
movq %rcx, 0x8(%rsi)
movq %rdx, 0x8(%rax)
movq %rcx, (%rsi)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x22c33
movl $0x70, %edi
callq 0xb3e0
movq %rax, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x20d56(%rip), %rax # 0x59b68
movq %rax, (%r14)
movq %r14, %r15
addq $0x10, %r15
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rax, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x10(%rsp), %rdx
movq %rdx, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
xorl %edi, %edi
movq %rdi, 0x10(%rsp)
leaq 0x48(%rsp), %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
movq %rdx, 0x10(%rsi)
movaps %xmm0, 0x20(%rsp)
movq %rdi, 0x30(%rsp)
movq %r15, %rdi
callq 0x39388
leaq 0x20bf8(%rip), %rax # 0x59a68
movq %rax, 0x10(%r14)
leaq 0x48(%rsp), %rdi
callq 0x151c0
leaq 0x20d33(%rip), %rax # 0x59bb8
movq %rax, 0x10(%r14)
movl $0x6, 0x6c(%r14)
leaq 0x20(%rsp), %rdi
callq 0x151c0
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
movq %rsp, %rdi
callq 0x151c0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x38eb9
callq 0x14c7c
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x151c0
leaq 0x20(%rsp), %rdi
callq 0x151c0
movl $0x70, %esi
movq %r14, %rdi
callq 0xb400
jmp 0x38eef
movq %rax, %rbx
movq %rsp, %rdi
callq 0x151c0
jmp 0x38efc
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x38f0b
callq 0x14c7c
movq %rbx, %rdi
callq 0xb780
|
_ZN5ftxui14focusCursorBarESt10shared_ptrINS_4NodeEE:
push r15
push r14
push rbx
sub rsp, 60h
mov rbx, rdi
mov rcx, [rsi]
lea rax, [rsp+78h+var_40]
mov [rax], rcx
xor ecx, ecx
mov [rax+8], rcx
mov rdx, [rsi+8]
mov [rsi+8], rcx
mov [rax+8], rdx
mov [rsi], rcx
mov rdi, rsp
mov rsi, rax
call _ZN5ftxui6unpackIJSt10shared_ptrINS_4NodeEEEEESt6vectorIS3_SaIS3_EEDpT_; ftxui::unpack<std::shared_ptr<ftxui::Node>>(std::shared_ptr<ftxui::Node>)
mov edi, 70h ; 'p'; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rax, 100000001h
mov [r14+8], rax
lea rax, off_59B68
mov [r14], rax
mov r15, r14
add r15, 10h
mov rax, qword ptr [rsp+78h+var_78]
mov rcx, qword ptr [rsp+78h+var_78+8]
mov qword ptr [rsp+78h+var_58], rax
mov qword ptr [rsp+78h+var_58+8], rcx
mov rdx, [rsp+78h+var_68]
mov [rsp+78h+var_48], rdx
xorps xmm0, xmm0
movaps [rsp+78h+var_78], xmm0
xor edi, edi
mov [rsp+78h+var_68], rdi
lea rsi, [rsp+78h+var_30]
mov [rsi], rax
mov [rsi+8], rcx
mov [rsi+10h], rdx
movaps [rsp+78h+var_58], xmm0
mov [rsp+78h+var_48], rdi
mov rdi, r15
call _ZN5ftxui12_GLOBAL__N_16SelectC2ESt6vectorISt10shared_ptrINS_4NodeEESaIS5_EE; ftxui::`anonymous namespace'::Select::Select(std::vector<std::shared_ptr<ftxui::Node>>)
lea rax, off_59A68
mov [r14+10h], rax
lea rdi, [rsp+78h+var_30]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
lea rax, off_59BB8
mov [r14+10h], rax
mov dword ptr [r14+6Ch], 6
lea rdi, [rsp+78h+var_58]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov [rbx], r15
mov [rbx+8], r14
mov rdi, rsp
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov rdi, [rsp+78h+var_38]
test rdi, rdi
jz short loc_38EB9
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_38EB9:
mov rax, rbx
add rsp, 60h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_40]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
lea rdi, [rsp+arg_18]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov esi, 70h ; 'p'; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_38EEF
mov rbx, rax
loc_38EEF:
mov rdi, rsp
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
jmp short loc_38EFC
mov rbx, rax
loc_38EFC:
mov rdi, [rsp+arg_38]
test rdi, rdi
jz short loc_38F0B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_38F0B:
mov rdi, rbx
call __Unwind_Resume
|
_QWORD * ftxui::focusCursorBar(_QWORD *a1, long long *a2)
{
volatile signed __int32 *v2; // rdx
long long v3; // r14
int v4; // r8d
int v5; // r9d
__int128 v7; // [rsp+0h] [rbp-78h] BYREF
long long v8; // [rsp+10h] [rbp-68h]
__int128 v9; // [rsp+20h] [rbp-58h] BYREF
long long v10; // [rsp+30h] [rbp-48h]
long long v11; // [rsp+38h] [rbp-40h] BYREF
volatile signed __int32 *v12; // [rsp+40h] [rbp-38h]
__int128 v13; // [rsp+48h] [rbp-30h] BYREF
long long v14; // [rsp+58h] [rbp-20h]
v11 = *a2;
v12 = 0LL;
v2 = (volatile signed __int32 *)a2[1];
a2[1] = 0LL;
v12 = v2;
*a2 = 0LL;
ftxui::unpack<std::shared_ptr<ftxui::Node>>((long long)&v7, &v11);
v3 = operator new(0x70uLL);
*(_QWORD *)(v3 + 8) = 0x100000001LL;
*(_QWORD *)v3 = off_59B68;
v13 = v7;
v14 = v8;
v9 = 0LL;
v10 = 0LL;
ftxui::`anonymous namespace'::Select::Select(v3 + 16, (unsigned int)&v13, v8, DWORD2(v7), v4, v5, 0LL, 0LL, 0LL);
*(_QWORD *)(v3 + 16) = off_59A68;
std::vector<std::shared_ptr<ftxui::Node>>::~vector((void **)&v13);
*(_QWORD *)(v3 + 16) = off_59BB8;
*(_DWORD *)(v3 + 108) = 6;
std::vector<std::shared_ptr<ftxui::Node>>::~vector((void **)&v9);
*a1 = v3 + 16;
a1[1] = v3;
std::vector<std::shared_ptr<ftxui::Node>>::~vector((void **)&v7);
if ( v12 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v12);
return a1;
}
|
focusCursorBar:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV RBX,RDI
MOV RCX,qword ptr [RSI]
LEA RAX,[RSP + 0x38]
MOV qword ptr [RAX],RCX
XOR ECX,ECX
MOV qword ptr [RAX + 0x8],RCX
MOV RDX,qword ptr [RSI + 0x8]
MOV qword ptr [RSI + 0x8],RCX
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RSI],RCX
LAB_00138de5:
MOV RDI,RSP
MOV RSI,RAX
CALL 0x00122c33
LAB_00138df0:
MOV EDI,0x70
CALL 0x0010b3e0
MOV R14,RAX
MOV RAX,0x100000001
MOV qword ptr [R14 + 0x8],RAX
LEA RAX,[0x159b68]
MOV qword ptr [R14],RAX
MOV R15,R14
ADD R15,0x10
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RCX
MOV RDX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RDX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
XOR EDI,EDI
MOV qword ptr [RSP + 0x10],RDI
LEA RSI,[RSP + 0x48]
MOV qword ptr [RSI],RAX
MOV qword ptr [RSI + 0x8],RCX
MOV qword ptr [RSI + 0x10],RDX
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV qword ptr [RSP + 0x30],RDI
LAB_00138e61:
MOV RDI,R15
CALL 0x00139388
LAB_00138e69:
LEA RAX,[0x159a68]
MOV qword ptr [R14 + 0x10],RAX
LEA RDI,[RSP + 0x48]
CALL 0x001151c0
LEA RAX,[0x159bb8]
MOV qword ptr [R14 + 0x10],RAX
MOV dword ptr [R14 + 0x6c],0x6
LEA RDI,[RSP + 0x20]
CALL 0x001151c0
MOV qword ptr [RBX],R15
MOV qword ptr [RBX + 0x8],R14
MOV RDI,RSP
CALL 0x001151c0
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x00138eb9
CALL 0x00114c7c
LAB_00138eb9:
MOV RAX,RBX
ADD RSP,0x60
POP RBX
POP R14
POP R15
RET
|
/* ftxui::focusCursorBar(std::shared_ptr<ftxui::Node>) */
ftxui * __thiscall ftxui::focusCursorBar(ftxui *this,int8 *param_2)
{
int8 *puVar1;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 local_40;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_38;
int8 local_30;
int8 local_28;
int8 local_20;
local_40 = *param_2;
local_38 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_2[1];
param_2[1] = 0;
*param_2 = 0;
/* try { // try from 00138de5 to 00138def has its CatchHandler @ 00138ef9 */
unpack<std::shared_ptr<ftxui::Node>>((ftxui *)&local_78,&local_40);
/* try { // try from 00138df0 to 00138df9 has its CatchHandler @ 00138eec */
puVar1 = (int8 *)operator_new(0x70);
local_20 = local_68;
local_28 = uStack_70;
local_30 = local_78;
puVar1[1] = 0x100000001;
*puVar1 = &PTR___Sp_counted_ptr_inplace_00159b68;
local_78 = 0;
uStack_70 = 0;
local_68 = 0;
local_58 = 0;
uStack_50 = 0;
local_48 = 0;
/* try { // try from 00138e61 to 00138e68 has its CatchHandler @ 00138ec6 */
(anonymous_namespace)::Select::Select((Select *)(puVar1 + 2));
puVar1[2] = &PTR__Node_00159a68;
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::~vector
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
&local_30);
puVar1[2] = &PTR__Node_00159bb8;
*(int4 *)((long)puVar1 + 0x6c) = 6;
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::~vector
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
&local_58);
*(Select **)this = (Select *)(puVar1 + 2);
*(int8 **)(this + 8) = puVar1;
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::~vector
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
&local_78);
if (local_38 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_38);
}
return this;
}
|
|
17,285
|
my_coll_parser_scan_reset_before
|
eloqsql/strings/ctype-uca.c
|
static int
my_coll_parser_scan_reset_before(MY_COLL_RULE_PARSER *p)
{
MY_COLL_LEXEM *lexem= my_coll_parser_curr(p);
if (!lex_cmp(lexem, C_STRING_WITH_LEN("[before primary]")) ||
!lex_cmp(lexem, C_STRING_WITH_LEN("[before 1]")))
{
p->rule.before_level= 1;
}
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[before secondary]")) ||
!lex_cmp(lexem, C_STRING_WITH_LEN("[before 2]")))
{
p->rule.before_level= 2;
}
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[before tertiary]")) ||
!lex_cmp(lexem, C_STRING_WITH_LEN("[before 3]")))
{
p->rule.before_level= 3;
}
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[before quaternary]")) ||
!lex_cmp(lexem, C_STRING_WITH_LEN("[before 4]")))
{
p->rule.before_level= 4;
}
else
{
p->rule.before_level= 0;
return 0; /* Don't scan thr next character */
}
return my_coll_parser_scan(p);
}
|
O0
|
c
|
my_coll_parser_scan_reset_before:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x57d80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2d8e7(%rip), %rsi # 0x861bb
movl $0x10, %edx
callq 0x58500
cmpl $0x0, %eax
je 0x588fd
movq -0x18(%rbp), %rdi
leaq 0x2d8de(%rip), %rsi # 0x861cc
movl $0xa, %edx
callq 0x58500
cmpl $0x0, %eax
jne 0x58911
movq -0x10(%rbp), %rax
movq $0x1, 0xe0(%rax)
jmp 0x58a01
movq -0x18(%rbp), %rdi
leaq 0x2d8bb(%rip), %rsi # 0x861d7
movl $0x12, %edx
callq 0x58500
cmpl $0x0, %eax
je 0x58945
movq -0x18(%rbp), %rdi
leaq 0x2d8b4(%rip), %rsi # 0x861ea
movl $0xa, %edx
callq 0x58500
cmpl $0x0, %eax
jne 0x58959
movq -0x10(%rbp), %rax
movq $0x2, 0xe0(%rax)
jmp 0x589ff
movq -0x18(%rbp), %rdi
leaq 0x2d891(%rip), %rsi # 0x861f5
movl $0x11, %edx
callq 0x58500
cmpl $0x0, %eax
je 0x5898d
movq -0x18(%rbp), %rdi
leaq 0x2d889(%rip), %rsi # 0x86207
movl $0xa, %edx
callq 0x58500
cmpl $0x0, %eax
jne 0x5899e
movq -0x10(%rbp), %rax
movq $0x3, 0xe0(%rax)
jmp 0x589fd
movq -0x18(%rbp), %rdi
leaq 0x2d869(%rip), %rsi # 0x86212
movl $0x13, %edx
callq 0x58500
cmpl $0x0, %eax
je 0x589d2
movq -0x18(%rbp), %rdi
leaq 0x2d863(%rip), %rsi # 0x86226
movl $0xa, %edx
callq 0x58500
cmpl $0x0, %eax
jne 0x589e3
movq -0x10(%rbp), %rax
movq $0x4, 0xe0(%rax)
jmp 0x589fb
movq -0x10(%rbp), %rax
movq $0x0, 0xe0(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x58a0d
jmp 0x589fd
jmp 0x589ff
jmp 0x58a01
movq -0x10(%rbp), %rdi
callq 0x58560
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_coll_parser_scan_reset_before:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
lea rsi, aBeforePrimary; "[before primary]"
mov edx, 10h
call lex_cmp
cmp eax, 0
jz short loc_588FD
mov rdi, [rbp+var_18]
lea rsi, aBefore1; "[before 1]"
mov edx, 0Ah
call lex_cmp
cmp eax, 0
jnz short loc_58911
loc_588FD:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 1
jmp loc_58A01
loc_58911:
mov rdi, [rbp+var_18]
lea rsi, aBeforeSecondar; "[before secondary]"
mov edx, 12h
call lex_cmp
cmp eax, 0
jz short loc_58945
mov rdi, [rbp+var_18]
lea rsi, aBefore2; "[before 2]"
mov edx, 0Ah
call lex_cmp
cmp eax, 0
jnz short loc_58959
loc_58945:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 2
jmp loc_589FF
loc_58959:
mov rdi, [rbp+var_18]
lea rsi, aBeforeTertiary; "[before tertiary]"
mov edx, 11h
call lex_cmp
cmp eax, 0
jz short loc_5898D
mov rdi, [rbp+var_18]
lea rsi, aBefore3; "[before 3]"
mov edx, 0Ah
call lex_cmp
cmp eax, 0
jnz short loc_5899E
loc_5898D:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 3
jmp short loc_589FD
loc_5899E:
mov rdi, [rbp+var_18]
lea rsi, aBeforeQuaterna; "[before quaternary]"
mov edx, 13h
call lex_cmp
cmp eax, 0
jz short loc_589D2
mov rdi, [rbp+var_18]
lea rsi, aBefore4; "[before 4]"
mov edx, 0Ah
call lex_cmp
cmp eax, 0
jnz short loc_589E3
loc_589D2:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 4
jmp short loc_589FB
loc_589E3:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 0
mov [rbp+var_4], 0
jmp short loc_58A0D
loc_589FB:
jmp short $+2
loc_589FD:
jmp short $+2
loc_589FF:
jmp short $+2
loc_58A01:
mov rdi, [rbp+var_10]
call my_coll_parser_scan
mov [rbp+var_4], eax
loc_58A0D:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long my_coll_parser_scan_reset_before(long long a1)
{
long long v2; // [rsp+8h] [rbp-18h]
v2 = my_coll_parser_curr(a1);
if ( !(unsigned int)lex_cmp(v2, (long long)"[before primary]", 0x10uLL)
|| !(unsigned int)lex_cmp(v2, (long long)"[before 1]", 0xAuLL) )
{
*(_QWORD *)(a1 + 224) = 1LL;
return (unsigned int)my_coll_parser_scan(a1);
}
if ( !(unsigned int)lex_cmp(v2, (long long)"[before secondary]", 0x12uLL)
|| !(unsigned int)lex_cmp(v2, (long long)"[before 2]", 0xAuLL) )
{
*(_QWORD *)(a1 + 224) = 2LL;
return (unsigned int)my_coll_parser_scan(a1);
}
if ( !(unsigned int)lex_cmp(v2, (long long)"[before tertiary]", 0x11uLL)
|| !(unsigned int)lex_cmp(v2, (long long)"[before 3]", 0xAuLL) )
{
*(_QWORD *)(a1 + 224) = 3LL;
return (unsigned int)my_coll_parser_scan(a1);
}
if ( !(unsigned int)lex_cmp(v2, (long long)"[before quaternary]", 0x13uLL)
|| !(unsigned int)lex_cmp(v2, (long long)"[before 4]", 0xAuLL) )
{
*(_QWORD *)(a1 + 224) = 4LL;
return (unsigned int)my_coll_parser_scan(a1);
}
*(_QWORD *)(a1 + 224) = 0LL;
return 0;
}
|
my_coll_parser_scan_reset_before:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00157d80
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x1861bb]
MOV EDX,0x10
CALL 0x00158500
CMP EAX,0x0
JZ 0x001588fd
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x1861cc]
MOV EDX,0xa
CALL 0x00158500
CMP EAX,0x0
JNZ 0x00158911
LAB_001588fd:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x1
JMP 0x00158a01
LAB_00158911:
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x1861d7]
MOV EDX,0x12
CALL 0x00158500
CMP EAX,0x0
JZ 0x00158945
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x1861ea]
MOV EDX,0xa
CALL 0x00158500
CMP EAX,0x0
JNZ 0x00158959
LAB_00158945:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x2
JMP 0x001589ff
LAB_00158959:
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x1861f5]
MOV EDX,0x11
CALL 0x00158500
CMP EAX,0x0
JZ 0x0015898d
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x186207]
MOV EDX,0xa
CALL 0x00158500
CMP EAX,0x0
JNZ 0x0015899e
LAB_0015898d:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x3
JMP 0x001589fd
LAB_0015899e:
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x186212]
MOV EDX,0x13
CALL 0x00158500
CMP EAX,0x0
JZ 0x001589d2
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x186226]
MOV EDX,0xa
CALL 0x00158500
CMP EAX,0x0
JNZ 0x001589e3
LAB_001589d2:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x4
JMP 0x001589fb
LAB_001589e3:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00158a0d
LAB_001589fb:
JMP 0x001589fd
LAB_001589fd:
JMP 0x001589ff
LAB_001589ff:
JMP 0x00158a01
LAB_00158a01:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00158560
MOV dword ptr [RBP + -0x4],EAX
LAB_00158a0d:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_coll_parser_scan_reset_before(long param_1)
{
int iVar1;
int4 uVar2;
int8 uVar3;
uVar3 = my_coll_parser_curr(param_1);
iVar1 = lex_cmp(uVar3,"[before primary]",0x10);
if ((iVar1 == 0) || (iVar1 = lex_cmp(uVar3,"[before 1]",10), iVar1 == 0)) {
*(int8 *)(param_1 + 0xe0) = 1;
}
else {
iVar1 = lex_cmp(uVar3,"[before secondary]",0x12);
if ((iVar1 == 0) || (iVar1 = lex_cmp(uVar3,"[before 2]",10), iVar1 == 0)) {
*(int8 *)(param_1 + 0xe0) = 2;
}
else {
iVar1 = lex_cmp(uVar3,"[before tertiary]",0x11);
if ((iVar1 == 0) || (iVar1 = lex_cmp(uVar3,"[before 3]",10), iVar1 == 0)) {
*(int8 *)(param_1 + 0xe0) = 3;
}
else {
iVar1 = lex_cmp(uVar3,"[before quaternary]",0x13);
if ((iVar1 != 0) && (iVar1 = lex_cmp(uVar3,"[before 4]",10), iVar1 != 0)) {
*(int8 *)(param_1 + 0xe0) = 0;
return 0;
}
*(int8 *)(param_1 + 0xe0) = 4;
}
}
}
uVar2 = my_coll_parser_scan(param_1);
return uVar2;
}
|
|
17,286
|
reset_root_defaults
|
eloqsql/mysys/my_alloc.c
|
void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
size_t pre_alloc_size __attribute__((unused)))
{
DBUG_ENTER("reset_root_defaults");
DBUG_ASSERT(alloc_root_inited(mem_root));
mem_root->block_size= (((block_size - ALLOC_ROOT_MIN_BLOCK_SIZE) & ~1) |
(mem_root->block_size & 1));
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
size_t size= pre_alloc_size + ALIGN_SIZE(sizeof(USED_MEM));
if (!mem_root->pre_alloc || mem_root->pre_alloc->size != size)
{
USED_MEM *mem, **prev= &mem_root->free;
/*
Free unused blocks, so that consequent calls
to reset_root_defaults won't eat away memory.
*/
while (*prev)
{
mem= *prev;
if (mem->size == size)
{
/* We found a suitable block, no need to do anything else */
mem_root->pre_alloc= mem;
DBUG_VOID_RETURN;
}
if (mem->left + ALIGN_SIZE(sizeof(USED_MEM)) == mem->size)
{
/* remove block from the list and free it */
*prev= mem->next;
my_free(mem);
}
else
prev= &mem->next;
}
/* Allocate new prealloc block and add it to the end of free list */
if ((mem= (USED_MEM *) my_malloc(mem_root->m_psi_key, size,
MYF(MALLOC_FLAG(mem_root->
block_size)))))
{
mem->size= size;
mem->left= pre_alloc_size;
mem->next= *prev;
*prev= mem_root->pre_alloc= mem;
TRASH_MEM(mem);
}
else
{
mem_root->pre_alloc= 0;
}
}
}
else
#endif
mem_root->pre_alloc= 0;
DBUG_VOID_RETURN;
}
|
O3
|
c
|
reset_root_defaults:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
andq $-0x2, %rsi
movq 0x20(%rdi), %rax
andl $0x1, %eax
leaq (%rsi,%rax), %rdx
addq $-0x28, %rdx
movq %rdx, 0x20(%rdi)
testq %r14, %r14
je 0x9cc84
leaq 0x18(%r14), %r15
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x9cc13
cmpq %r15, 0x10(%rax)
je 0x9cc92
movq (%rbx), %rdi
movq %rbx, %r12
testq %rdi, %rdi
je 0x9cc55
movq %rbx, %r12
movq 0x10(%rdi), %rax
cmpq %r15, %rax
je 0x9cc8e
movq 0x8(%rdi), %rcx
addq $0x18, %rcx
cmpq %rax, %rcx
jne 0x9cc45
movq (%rdi), %rax
movq %rax, (%r12)
callq 0x9ffde
jmp 0x9cc48
movq %rdi, %r12
movq (%r12), %rdi
testq %rdi, %rdi
jne 0x9cc21
movq 0x20(%rbx), %rdx
movl 0x38(%rbx), %edi
andl $0x1, %edx
shll $0x10, %edx
movq %r15, %rsi
callq 0x9fdb1
testq %rax, %rax
je 0x9cc84
movq %r15, 0x10(%rax)
movq %r14, 0x8(%rax)
movq (%r12), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rbx)
movq %rax, (%r12)
jmp 0x9cc92
movq $0x0, 0x10(%rbx)
jmp 0x9cc92
movq %rdi, 0x10(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
reset_root_defaults:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rdx
mov rbx, rdi
and rsi, 0FFFFFFFFFFFFFFFEh
mov rax, [rdi+20h]
and eax, 1
lea rdx, [rsi+rax]
add rdx, 0FFFFFFFFFFFFFFD8h
mov [rdi+20h], rdx
test r14, r14
jz loc_9CC84
lea r15, [r14+18h]
mov rax, [rbx+10h]
test rax, rax
jz short loc_9CC13
cmp [rax+10h], r15
jz short loc_9CC92
loc_9CC13:
mov rdi, [rbx]
mov r12, rbx
test rdi, rdi
jz short loc_9CC55
mov r12, rbx
loc_9CC21:
mov rax, [rdi+10h]
cmp rax, r15
jz short loc_9CC8E
mov rcx, [rdi+8]
add rcx, 18h
cmp rcx, rax
jnz short loc_9CC45
mov rax, [rdi]
mov [r12], rax
call my_free
jmp short loc_9CC48
loc_9CC45:
mov r12, rdi
loc_9CC48:
mov rdi, [r12]
test rdi, rdi
jnz short loc_9CC21
mov rdx, [rbx+20h]
loc_9CC55:
mov edi, [rbx+38h]
and edx, 1
shl edx, 10h
mov rsi, r15
call my_malloc
test rax, rax
jz short loc_9CC84
mov [rax+10h], r15
mov [rax+8], r14
mov rcx, [r12]
mov [rax], rcx
mov [rbx+10h], rax
mov [r12], rax
jmp short loc_9CC92
loc_9CC84:
mov qword ptr [rbx+10h], 0
jmp short loc_9CC92
loc_9CC8E:
mov [rbx+10h], rdi
loc_9CC92:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
_QWORD * reset_root_defaults(long long a1, long long a2, long long a3)
{
_QWORD *result; // rax
unsigned long long v6; // rdx
_QWORD *v7; // r15
_QWORD *v8; // rdi
_QWORD *v9; // r12
result = (_QWORD *)(*(_QWORD *)(a1 + 32) & 1LL);
v6 = (unsigned long long)result + (a2 & 0xFFFFFFFFFFFFFFFELL) - 40;
*(_QWORD *)(a1 + 32) = v6;
if ( !a3 )
{
LABEL_14:
*(_QWORD *)(a1 + 16) = 0LL;
return result;
}
v7 = (_QWORD *)(a3 + 24);
result = *(_QWORD **)(a1 + 16);
if ( result && (_QWORD *)result[2] == v7 )
return result;
v8 = *(_QWORD **)a1;
v9 = (_QWORD *)a1;
if ( !*(_QWORD *)a1 )
{
LABEL_12:
result = (_QWORD *)my_malloc(*(unsigned int *)(a1 + 56), a3 + 24, (unsigned __int8)(v6 & 1) << 16);
if ( result )
{
result[2] = v7;
result[1] = a3;
*result = *v9;
*(_QWORD *)(a1 + 16) = result;
*v9 = result;
return result;
}
goto LABEL_14;
}
v9 = (_QWORD *)a1;
while ( 1 )
{
result = (_QWORD *)v8[2];
if ( result == v7 )
break;
if ( (_QWORD *)(v8[1] + 24LL) == result )
{
*v9 = *v8;
my_free(v8);
}
else
{
v9 = v8;
}
v8 = (_QWORD *)*v9;
if ( !*v9 )
{
v6 = *(_QWORD *)(a1 + 32);
goto LABEL_12;
}
}
*(_QWORD *)(a1 + 16) = v8;
return result;
}
|
reset_root_defaults:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RDX
MOV RBX,RDI
AND RSI,-0x2
MOV RAX,qword ptr [RDI + 0x20]
AND EAX,0x1
LEA RDX,[RSI + RAX*0x1]
ADD RDX,-0x28
MOV qword ptr [RDI + 0x20],RDX
TEST R14,R14
JZ 0x0019cc84
LEA R15,[R14 + 0x18]
MOV RAX,qword ptr [RBX + 0x10]
TEST RAX,RAX
JZ 0x0019cc13
CMP qword ptr [RAX + 0x10],R15
JZ 0x0019cc92
LAB_0019cc13:
MOV RDI,qword ptr [RBX]
MOV R12,RBX
TEST RDI,RDI
JZ 0x0019cc55
MOV R12,RBX
LAB_0019cc21:
MOV RAX,qword ptr [RDI + 0x10]
CMP RAX,R15
JZ 0x0019cc8e
MOV RCX,qword ptr [RDI + 0x8]
ADD RCX,0x18
CMP RCX,RAX
JNZ 0x0019cc45
MOV RAX,qword ptr [RDI]
MOV qword ptr [R12],RAX
CALL 0x0019ffde
JMP 0x0019cc48
LAB_0019cc45:
MOV R12,RDI
LAB_0019cc48:
MOV RDI,qword ptr [R12]
TEST RDI,RDI
JNZ 0x0019cc21
MOV RDX,qword ptr [RBX + 0x20]
LAB_0019cc55:
MOV EDI,dword ptr [RBX + 0x38]
AND EDX,0x1
SHL EDX,0x10
MOV RSI,R15
CALL 0x0019fdb1
TEST RAX,RAX
JZ 0x0019cc84
MOV qword ptr [RAX + 0x10],R15
MOV qword ptr [RAX + 0x8],R14
MOV RCX,qword ptr [R12]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBX + 0x10],RAX
MOV qword ptr [R12],RAX
JMP 0x0019cc92
LAB_0019cc84:
MOV qword ptr [RBX + 0x10],0x0
JMP 0x0019cc92
LAB_0019cc8e:
MOV qword ptr [RBX + 0x10],RDI
LAB_0019cc92:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void reset_root_defaults(long *param_1,ulong param_2,long param_3)
{
long lVar1;
long *plVar2;
long lVar3;
long *plVar4;
long *plVar5;
lVar3 = (param_2 & 0xfffffffffffffffe) + (ulong)((uint)param_1[4] & 1) + -0x28;
param_1[4] = lVar3;
if (param_3 != 0) {
lVar1 = param_3 + 0x18;
if ((param_1[2] != 0) && (*(long *)(param_1[2] + 0x10) == lVar1)) {
return;
}
plVar2 = (long *)*param_1;
plVar4 = param_1;
plVar5 = param_1;
if (plVar2 != (long *)0x0) {
do {
if (plVar2[2] == lVar1) {
param_1[2] = (long)plVar2;
return;
}
plVar5 = plVar2;
if (plVar2[1] + 0x18 == plVar2[2]) {
*plVar4 = *plVar2;
my_free();
plVar5 = plVar4;
}
plVar2 = (long *)*plVar5;
plVar4 = plVar5;
} while (plVar2 != (long *)0x0);
lVar3 = param_1[4];
}
plVar2 = (long *)my_malloc((int)param_1[7],lVar1,((uint)lVar3 & 1) << 0x10);
if (plVar2 != (long *)0x0) {
plVar2[2] = lVar1;
plVar2[1] = param_3;
*plVar2 = *plVar5;
param_1[2] = (long)plVar2;
*plVar5 = (long)plVar2;
return;
}
}
param_1[2] = 0;
return;
}
|
|
17,287
|
js_os_waitpid
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_os_waitpid(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int pid, status, options, ret;
JSValue obj;
if (JS_ToInt32(ctx, &pid, argv[0]))
return JS_EXCEPTION;
if (JS_ToInt32(ctx, &options, argv[1]))
return JS_EXCEPTION;
ret = waitpid(pid, &status, options);
if (ret < 0) {
ret = -errno;
status = 0;
}
obj = JS_NewArray(ctx);
if (JS_IsException(obj))
return obj;
JS_DefinePropertyValueUint32(ctx, obj, 0, JS_NewInt32(ctx, ret),
JS_PROP_C_W_E);
JS_DefinePropertyValueUint32(ctx, obj, 1, JS_NewInt32(ctx, status),
JS_PROP_C_W_E);
return obj;
}
|
O0
|
c
|
js_os_waitpid:
subq $0xd8, %rsp
movq %rsi, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
movq %rdi, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq %r8, 0x60(%rsp)
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0x5c(%rsp), %rsi
callq 0x38f20
cmpl $0x0, %eax
je 0x1c66e
movl $0x0, 0x88(%rsp)
movq $0x6, 0x90(%rsp)
jmp 0x1c836
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
leaq 0x54(%rsp), %rsi
callq 0x38f20
cmpl $0x0, %eax
je 0x1c6ab
movl $0x0, 0x88(%rsp)
movq $0x6, 0x90(%rsp)
jmp 0x1c836
movl 0x5c(%rsp), %edi
movl 0x54(%rsp), %edx
leaq 0x58(%rsp), %rsi
callq 0xe740
movl %eax, 0x50(%rsp)
cmpl $0x0, 0x50(%rsp)
jge 0x1c6e0
callq 0xe0b0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, 0x50(%rsp)
movl $0x0, 0x58(%rsp)
movq 0x70(%rsp), %rdi
callq 0x2a520
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x10390
cmpl $0x0, %eax
je 0x1c73b
movq 0x40(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x1c836
movq 0x70(%rsp), %rdi
movl 0x50(%rsp), %eax
movq %rdi, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
movl 0xbc(%rsp), %eax
movl %eax, 0xc8(%rsp)
movq $0x0, 0xd0(%rsp)
movq 0xc8(%rsp), %rcx
movq 0xd0(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
movq %rsp, %rax
movl $0x7, (%rax)
xorl %ecx, %ecx
callq 0x37370
movq 0x70(%rsp), %rdi
movl 0x58(%rsp), %eax
movq %rdi, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0xa8(%rsp)
movq $0x0, 0xb0(%rsp)
movq 0xa8(%rsp), %rcx
movq 0xb0(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
movl $0x1, %ecx
movl $0x7, (%rsp)
callq 0x37370
movq 0x40(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x88(%rsp), %rax
movq 0x90(%rsp), %rdx
addq $0xd8, %rsp
retq
nop
|
js_os_waitpid:
sub rsp, 0D8h
mov [rsp+0D8h+var_60], rsi
mov [rsp+0D8h+var_58], rdx
mov [rsp+0D8h+var_68], rdi
mov [rsp+0D8h+var_6C], ecx
mov [rsp+0D8h+var_78], r8
mov rdi, [rsp+0D8h+var_68]
mov rax, [rsp+0D8h+var_78]
mov rdx, [rax]
mov rcx, [rax+8]
lea rsi, [rsp+0D8h+var_7C]
call JS_ToInt32
cmp eax, 0
jz short loc_1C66E
mov dword ptr [rsp+0D8h+var_50], 0
mov [rsp+0D8h+var_48], 6
jmp loc_1C836
loc_1C66E:
mov rdi, [rsp+0D8h+var_68]
mov rax, [rsp+0D8h+var_78]
mov rdx, [rax+10h]
mov rcx, [rax+18h]
lea rsi, [rsp+0D8h+var_84]
call JS_ToInt32
cmp eax, 0
jz short loc_1C6AB
mov dword ptr [rsp+0D8h+var_50], 0
mov [rsp+0D8h+var_48], 6
jmp loc_1C836
loc_1C6AB:
mov edi, [rsp+0D8h+var_7C]
mov edx, [rsp+0D8h+var_84]
lea rsi, [rsp+0D8h+var_80]
call _waitpid
mov [rsp+0D8h+var_88], eax
cmp [rsp+0D8h+var_88], 0
jge short loc_1C6E0
call ___errno_location
mov rcx, rax
xor eax, eax
sub eax, [rcx]
mov [rsp+0D8h+var_88], eax
mov [rsp+0D8h+var_80], 0
loc_1C6E0:
mov rdi, [rsp+0D8h+var_68]
call JS_NewArray
mov [rsp+0D8h+var_A8], rax
mov [rsp+0D8h+var_A0], rdx
mov rax, [rsp+0D8h+var_A8]
mov [rsp+0D8h+var_98], rax
mov rax, [rsp+0D8h+var_A0]
mov [rsp+0D8h+var_90], rax
mov rdi, [rsp+0D8h+var_98]
mov rsi, [rsp+0D8h+var_90]
call JS_IsException_0
cmp eax, 0
jz short loc_1C73B
mov rax, [rsp+0D8h+var_98]
mov [rsp+0D8h+var_50], rax
mov rax, [rsp+0D8h+var_90]
mov [rsp+0D8h+var_48], rax
jmp loc_1C836
loc_1C73B:
mov rdi, [rsp+0D8h+var_68]
mov eax, [rsp+0D8h+var_88]
mov [rsp+0D8h+var_18], rdi
mov [rsp+0D8h+var_1C], eax
mov eax, [rsp+0D8h+var_1C]
mov dword ptr [rsp+0D8h+var_10], eax
mov [rsp+0D8h+var_8], 0
mov rcx, [rsp+0D8h+var_10]
mov rax, [rsp+0D8h+var_8]
mov [rsp+0D8h+var_B8], rcx
mov [rsp+0D8h+var_B0], rax
mov rsi, [rsp+0D8h+var_98]
mov rdx, [rsp+0D8h+var_90]
mov r8, [rsp+0D8h+var_B8]
mov r9, [rsp+0D8h+var_B0]
mov rax, rsp
mov dword ptr [rax], 7
xor ecx, ecx
call JS_DefinePropertyValueUint32
mov rdi, [rsp+0D8h+var_68]
mov eax, [rsp+0D8h+var_80]
mov [rsp+0D8h+var_38], rdi
mov [rsp+0D8h+var_3C], eax
mov eax, [rsp+0D8h+var_3C]
mov dword ptr [rsp+0D8h+var_30], eax
mov [rsp+0D8h+var_28], 0
mov rcx, [rsp+0D8h+var_30]
mov rax, [rsp+0D8h+var_28]
mov [rsp+0D8h+var_C8], rcx
mov [rsp+0D8h+var_C0], rax
mov rsi, [rsp+0D8h+var_98]
mov rdx, [rsp+0D8h+var_90]
mov r8, [rsp+0D8h+var_C8]
mov r9, [rsp+0D8h+var_C0]
mov ecx, 1
mov [rsp+0D8h+var_D8], 7
call JS_DefinePropertyValueUint32
mov rax, [rsp+0D8h+var_98]
mov [rsp+0D8h+var_50], rax
mov rax, [rsp+0D8h+var_90]
mov [rsp+0D8h+var_48], rax
loc_1C836:
mov rax, [rsp+0D8h+var_50]
mov rdx, [rsp+0D8h+var_48]
add rsp, 0D8h
retn
|
long long js_os_waitpid(long long a1, long long a2, long long a3, int a4, _QWORD *a5)
{
long long v5; // rdx
long long v7; // [rsp+30h] [rbp-A8h]
long long v8; // [rsp+48h] [rbp-90h]
int v9; // [rsp+50h] [rbp-88h]
unsigned int v10; // [rsp+54h] [rbp-84h] BYREF
int v11; // [rsp+58h] [rbp-80h] BYREF
unsigned int v12; // [rsp+5Ch] [rbp-7Ch] BYREF
_QWORD *v13; // [rsp+60h] [rbp-78h]
int v14; // [rsp+6Ch] [rbp-6Ch]
long long v15; // [rsp+70h] [rbp-68h]
long long v16; // [rsp+78h] [rbp-60h]
long long v17; // [rsp+80h] [rbp-58h]
long long v18; // [rsp+88h] [rbp-50h]
long long v19; // [rsp+90h] [rbp-48h]
int v20; // [rsp+9Ch] [rbp-3Ch]
long long v21; // [rsp+A0h] [rbp-38h]
long long v22; // [rsp+A8h] [rbp-30h]
long long v23; // [rsp+B0h] [rbp-28h]
int v24; // [rsp+BCh] [rbp-1Ch]
long long v25; // [rsp+C0h] [rbp-18h]
long long v26; // [rsp+C8h] [rbp-10h]
long long v27; // [rsp+D0h] [rbp-8h]
v16 = a2;
v17 = a3;
v15 = a1;
v14 = a4;
v13 = a5;
if ( (unsigned int)JS_ToInt32(a1, &v12, *a5, a5[1]) )
{
LODWORD(v18) = 0;
v19 = 6LL;
}
else if ( (unsigned int)JS_ToInt32(v15, &v10, v13[2], v13[3]) )
{
LODWORD(v18) = 0;
v19 = 6LL;
}
else
{
v9 = waitpid(v12, &v11, v10);
if ( v9 < 0 )
{
v9 = -*(_DWORD *)__errno_location();
v11 = 0;
}
v7 = JS_NewArray(v15);
v8 = v5;
if ( !JS_IsException_0(v7, v5) )
{
v25 = v15;
v24 = v9;
LODWORD(v26) = v9;
v27 = 0LL;
JS_DefinePropertyValueUint32(v15, v7, v8, 0, v9, 0, 7);
v21 = v15;
v20 = v11;
LODWORD(v22) = v11;
v23 = 0LL;
JS_DefinePropertyValueUint32(v15, v7, v8, 1, v11, 0, 7);
}
v18 = v7;
v19 = v8;
}
return v18;
}
|
js_os_waitpid:
SUB RSP,0xd8
MOV qword ptr [RSP + 0x78],RSI
MOV qword ptr [RSP + 0x80],RDX
MOV qword ptr [RSP + 0x70],RDI
MOV dword ptr [RSP + 0x6c],ECX
MOV qword ptr [RSP + 0x60],R8
MOV RDI,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x5c]
CALL 0x00138f20
CMP EAX,0x0
JZ 0x0011c66e
MOV dword ptr [RSP + 0x88],0x0
MOV qword ptr [RSP + 0x90],0x6
JMP 0x0011c836
LAB_0011c66e:
MOV RDI,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RAX + 0x18]
LEA RSI,[RSP + 0x54]
CALL 0x00138f20
CMP EAX,0x0
JZ 0x0011c6ab
MOV dword ptr [RSP + 0x88],0x0
MOV qword ptr [RSP + 0x90],0x6
JMP 0x0011c836
LAB_0011c6ab:
MOV EDI,dword ptr [RSP + 0x5c]
MOV EDX,dword ptr [RSP + 0x54]
LEA RSI,[RSP + 0x58]
CALL 0x0010e740
MOV dword ptr [RSP + 0x50],EAX
CMP dword ptr [RSP + 0x50],0x0
JGE 0x0011c6e0
CALL 0x0010e0b0
MOV RCX,RAX
XOR EAX,EAX
SUB EAX,dword ptr [RCX]
MOV dword ptr [RSP + 0x50],EAX
MOV dword ptr [RSP + 0x58],0x0
LAB_0011c6e0:
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x0012a520
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00110390
CMP EAX,0x0
JZ 0x0011c73b
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x90],RAX
JMP 0x0011c836
LAB_0011c73b:
MOV RDI,qword ptr [RSP + 0x70]
MOV EAX,dword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0xc0],RDI
MOV dword ptr [RSP + 0xbc],EAX
MOV EAX,dword ptr [RSP + 0xbc]
MOV dword ptr [RSP + 0xc8],EAX
MOV qword ptr [RSP + 0xd0],0x0
MOV RCX,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x20],RCX
MOV qword ptr [RSP + 0x28],RAX
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
MOV R8,qword ptr [RSP + 0x20]
MOV R9,qword ptr [RSP + 0x28]
MOV RAX,RSP
MOV dword ptr [RAX],0x7
XOR ECX,ECX
CALL 0x00137370
MOV RDI,qword ptr [RSP + 0x70]
MOV EAX,dword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xa0],RDI
MOV dword ptr [RSP + 0x9c],EAX
MOV EAX,dword ptr [RSP + 0x9c]
MOV dword ptr [RSP + 0xa8],EAX
MOV qword ptr [RSP + 0xb0],0x0
MOV RCX,qword ptr [RSP + 0xa8]
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x18],RAX
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
MOV R8,qword ptr [RSP + 0x10]
MOV R9,qword ptr [RSP + 0x18]
MOV ECX,0x1
MOV dword ptr [RSP],0x7
CALL 0x00137370
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x90],RAX
LAB_0011c836:
MOV RAX,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
ADD RSP,0xd8
RET
|
int1 [16]
js_os_waitpid(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
int iVar1;
int *piVar2;
int1 auVar5 [16];
int local_88;
int local_84;
int local_80;
__pid_t local_7c;
int8 *local_78;
int4 local_6c;
int8 local_68;
int8 local_60;
int8 local_58;
int4 local_50;
int4 uStack_4c;
int8 local_48;
int local_3c;
int8 local_38;
int local_30;
int4 uStack_2c;
int8 local_28;
int local_1c;
int8 local_18;
int local_10;
int4 uStack_c;
int8 local_8;
int8 uVar3;
int8 uVar4;
local_78 = param_5;
local_6c = param_4;
local_68 = param_1;
local_60 = param_2;
local_58 = param_3;
iVar1 = JS_ToInt32(param_1,&local_7c,*param_5,param_5[1]);
if (iVar1 == 0) {
iVar1 = JS_ToInt32(local_68,&local_84,local_78[2],local_78[3]);
if (iVar1 == 0) {
local_88 = waitpid(local_7c,&local_80,local_84);
if (local_88 < 0) {
piVar2 = __errno_location();
local_88 = -*piVar2;
local_80 = 0;
}
auVar5 = JS_NewArray(local_68);
uVar4 = auVar5._8_8_;
uVar3 = auVar5._0_8_;
iVar1 = JS_IsException(uVar3,uVar4);
local_50 = auVar5._0_4_;
uStack_4c = auVar5._4_4_;
local_48 = uVar4;
if (iVar1 == 0) {
local_18 = local_68;
local_1c = local_88;
local_10 = local_88;
local_8 = 0;
JS_DefinePropertyValueUint32(local_68,uVar3,uVar4,0,CONCAT44(uStack_c,local_88),0,7);
local_38 = local_68;
local_3c = local_80;
local_30 = local_80;
local_28 = 0;
JS_DefinePropertyValueUint32(local_68,uVar3,uVar4,1,CONCAT44(uStack_2c,local_80),0,7);
}
}
else {
local_50 = 0;
local_48 = 6;
}
}
else {
local_50 = 0;
local_48 = 6;
}
auVar5._4_4_ = uStack_4c;
auVar5._0_4_ = local_50;
auVar5._8_8_ = local_48;
return auVar5;
}
|
|
17,288
|
js_os_waitpid
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_os_waitpid(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int pid, status, options, ret;
JSValue obj;
if (JS_ToInt32(ctx, &pid, argv[0]))
return JS_EXCEPTION;
if (JS_ToInt32(ctx, &options, argv[1]))
return JS_EXCEPTION;
ret = waitpid(pid, &status, options);
if (ret < 0) {
ret = -errno;
status = 0;
}
obj = JS_NewArray(ctx);
if (JS_IsException(obj))
return obj;
JS_DefinePropertyValueUint32(ctx, obj, 0, JS_NewInt32(ctx, ret),
JS_PROP_C_W_E);
JS_DefinePropertyValueUint32(ctx, obj, 1, JS_NewInt32(ctx, status),
JS_PROP_C_W_E);
return obj;
}
|
O1
|
c
|
js_os_waitpid:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r15
movq %rdi, %rbx
movq (%r8), %rdx
movq 0x8(%r8), %rcx
leaq 0x1c(%rsp), %rsi
callq 0x279b0
movl $0x6, %r14d
testl %eax, %eax
jne 0x1a889
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x279b0
testl %eax, %eax
je 0x1a8a4
xorl %r15d, %r15d
xorl %ecx, %ecx
movl %r15d, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %edx
leaq 0x14(%rsp), %rsi
callq 0xe750
movl %eax, %ebp
testl %eax, %eax
jns 0x1a8cb
callq 0xe0b0
xorl %ecx, %ecx
xorl %ebp, %ebp
subl (%rax), %ebp
movl %ecx, 0x14(%rsp)
movabsq $-0x100000000, %r12 # imm = 0xFFFFFFFF00000000
movq %rbx, %rdi
callq 0xf6ed
movq %rax, %r15
movq %rdx, %r14
cmpl $0x6, %r14d
je 0x1a925
movl %ebp, %r8d
movl $0x7, %ebp
movl %ebp, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x26bc5
movl 0x14(%rsp), %r8d
movl %ebp, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x1, %ecx
xorl %r9d, %r9d
callq 0x26bc5
movq %r15, %rcx
andq %r12, %rcx
jmp 0x1a88e
|
js_os_waitpid:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov r15, r8
mov rbx, rdi
mov rdx, [r8]
mov rcx, [r8+8]
lea rsi, [rsp+48h+var_2C]
call JS_ToInt32
mov r14d, 6
test eax, eax
jnz short loc_1A889
mov rdx, [r15+10h]
mov rcx, [r15+18h]
lea rsi, [rsp+48h+var_30]
mov rdi, rbx
call JS_ToInt32
test eax, eax
jz short loc_1A8A4
loc_1A889:
xor r15d, r15d
xor ecx, ecx
loc_1A88E:
mov eax, r15d
or rax, rcx
mov rdx, r14
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_1A8A4:
mov edi, [rsp+48h+var_2C]
mov edx, [rsp+48h+var_30]
lea rsi, [rsp+48h+var_34]
call _waitpid
mov ebp, eax
test eax, eax
jns short loc_1A8CB
call ___errno_location
xor ecx, ecx
xor ebp, ebp
sub ebp, [rax]
mov [rsp+48h+var_34], ecx
loc_1A8CB:
mov r12, 0FFFFFFFF00000000h
mov rdi, rbx
call JS_NewArray
mov r15, rax
mov r14, rdx
cmp r14d, 6
jz short loc_1A925
mov r8d, ebp
mov ebp, 7
mov [rsp+48h+var_48], ebp
mov rdi, rbx
mov rsi, r15
mov rdx, r14
xor ecx, ecx
xor r9d, r9d
call JS_DefinePropertyValueUint32
mov r8d, [rsp+48h+var_34]
mov [rsp+48h+var_48], ebp
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov ecx, 1
xor r9d, r9d
call JS_DefinePropertyValueUint32
loc_1A925:
mov rcx, r15
and rcx, r12
jmp loc_1A88E
|
unsigned long long js_os_waitpid(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
long long v7; // r15
unsigned long long v8; // rcx
long long v10; // rdi
int v11; // ebp
long long v12; // rax
int v13; // edx
int v14; // r14d
int v15; // [rsp+14h] [rbp-34h] BYREF
unsigned int v16; // [rsp+18h] [rbp-30h] BYREF
_DWORD v17[11]; // [rsp+1Ch] [rbp-2Ch] BYREF
if ( (unsigned int)JS_ToInt32(a1, v17, *a5, a5[1]) || (unsigned int)JS_ToInt32(a1, &v16, a5[2], a5[3]) )
{
LODWORD(v7) = 0;
v8 = 0LL;
}
else
{
v10 = v17[0];
v11 = waitpid(v17[0], &v15, v16);
if ( v11 < 0 )
{
v11 = -*(_DWORD *)__errno_location(v10);
v15 = 0;
}
v12 = JS_NewArray(a1);
v7 = v12;
v14 = v13;
if ( v13 != 6 )
{
JS_DefinePropertyValueUint32(a1, v12, v13, 0, v11, 0, 7);
JS_DefinePropertyValueUint32(a1, v7, v14, 1, v15, 0, 7);
}
v8 = v7 & 0xFFFFFFFF00000000LL;
}
return v8 | (unsigned int)v7;
}
|
js_os_waitpid:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV R15,R8
MOV RBX,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
LEA RSI,[RSP + 0x1c]
CALL 0x001279b0
MOV R14D,0x6
TEST EAX,EAX
JNZ 0x0011a889
MOV RDX,qword ptr [R15 + 0x10]
MOV RCX,qword ptr [R15 + 0x18]
LEA RSI,[RSP + 0x18]
MOV RDI,RBX
CALL 0x001279b0
TEST EAX,EAX
JZ 0x0011a8a4
LAB_0011a889:
XOR R15D,R15D
XOR ECX,ECX
LAB_0011a88e:
MOV EAX,R15D
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0011a8a4:
MOV EDI,dword ptr [RSP + 0x1c]
MOV EDX,dword ptr [RSP + 0x18]
LEA RSI,[RSP + 0x14]
CALL 0x0010e750
MOV EBP,EAX
TEST EAX,EAX
JNS 0x0011a8cb
CALL 0x0010e0b0
XOR ECX,ECX
XOR EBP,EBP
SUB EBP,dword ptr [RAX]
MOV dword ptr [RSP + 0x14],ECX
LAB_0011a8cb:
MOV R12,-0x100000000
MOV RDI,RBX
CALL 0x0010f6ed
MOV R15,RAX
MOV R14,RDX
CMP R14D,0x6
JZ 0x0011a925
MOV R8D,EBP
MOV EBP,0x7
MOV dword ptr [RSP],EBP
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
XOR ECX,ECX
XOR R9D,R9D
CALL 0x00126bc5
MOV R8D,dword ptr [RSP + 0x14]
MOV dword ptr [RSP],EBP
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV ECX,0x1
XOR R9D,R9D
CALL 0x00126bc5
LAB_0011a925:
MOV RCX,R15
AND RCX,R12
JMP 0x0011a88e
|
int1 [16] js_os_waitpid(int8 param_1)
{
int iVar1;
int *piVar2;
ulong uVar3;
int8 *in_R8;
int1 auVar4 [16];
int1 auVar5 [16];
int local_34;
int local_30;
__pid_t local_2c;
iVar1 = JS_ToInt32(param_1,&local_2c,*in_R8,in_R8[1]);
if (iVar1 == 0) {
iVar1 = JS_ToInt32(param_1,&local_30,in_R8[2]);
if (iVar1 == 0) {
iVar1 = waitpid(local_2c,&local_34,local_30);
if (iVar1 < 0) {
piVar2 = __errno_location();
iVar1 = -*piVar2;
local_34 = 0;
}
auVar5 = JS_NewArray(param_1);
uVar3 = auVar5._0_8_;
if (auVar5._8_4_ != 6) {
JS_DefinePropertyValueUint32(param_1,uVar3,auVar5._8_8_,0,iVar1,0,7);
JS_DefinePropertyValueUint32(param_1,uVar3,auVar5._8_8_,1,local_34,0,7);
}
uVar3 = uVar3 & 0xffffffff00000000;
goto LAB_0011a88e;
}
}
auVar5 = ZEXT816(6) << 0x40;
uVar3 = 0;
LAB_0011a88e:
auVar4._0_8_ = auVar5._0_8_ & 0xffffffff | uVar3;
auVar4._8_8_ = auVar5._8_8_;
return auVar4;
}
|
|
17,289
|
js_os_waitpid
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_os_waitpid(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int pid, status, options, ret;
JSValue obj;
if (JS_ToInt32(ctx, &pid, argv[0]))
return JS_EXCEPTION;
if (JS_ToInt32(ctx, &options, argv[1]))
return JS_EXCEPTION;
ret = waitpid(pid, &status, options);
if (ret < 0) {
ret = -errno;
status = 0;
}
obj = JS_NewArray(ctx);
if (JS_IsException(obj))
return obj;
JS_DefinePropertyValueUint32(ctx, obj, 0, JS_NewInt32(ctx, ret),
JS_PROP_C_W_E);
JS_DefinePropertyValueUint32(ctx, obj, 1, JS_NewInt32(ctx, status),
JS_PROP_C_W_E);
return obj;
}
|
O2
|
c
|
js_os_waitpid:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r15
movq %rdi, %rbx
movq (%r8), %rdx
movq 0x8(%r8), %rcx
leaq 0x1c(%rsp), %rsi
callq 0x215d7
pushq $0x6
popq %r14
testl %eax, %eax
jne 0x15510
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x215d7
testl %eax, %eax
je 0x1552b
xorl %r15d, %r15d
xorl %ecx, %ecx
movl %r15d, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %edx
leaq 0x14(%rsp), %rsi
callq 0xe770
movl %eax, %ebp
testl %eax, %eax
jns 0x15551
callq 0xe0b0
xorl %ebp, %ebp
subl (%rax), %ebp
andl $0x0, 0x14(%rsp)
movabsq $-0x100000000, %r12 # imm = 0xFFFFFFFF00000000
movq %rbx, %rdi
callq 0x1b2bb
movq %rax, %r15
movq %rdx, %r14
cmpl $0x6, %r14d
je 0x155a7
movl %ebp, %r8d
pushq $0x7
popq %rbp
movl %ebp, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x20972
movl 0x14(%rsp), %r8d
movl %ebp, (%rsp)
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x20972
movq %r15, %rcx
andq %r12, %rcx
jmp 0x15515
|
js_os_waitpid:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov r15, r8
mov rbx, rdi
mov rdx, [r8]
mov rcx, [r8+8]
lea rsi, [rsp+48h+var_2C]
call JS_ToInt32
push 6
pop r14
test eax, eax
jnz short loc_15510
mov rdx, [r15+10h]
mov rcx, [r15+18h]
lea rsi, [rsp+48h+var_30]
mov rdi, rbx
call JS_ToInt32
test eax, eax
jz short loc_1552B
loc_15510:
xor r15d, r15d
xor ecx, ecx
loc_15515:
mov eax, r15d
or rax, rcx
mov rdx, r14
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_1552B:
mov edi, [rsp+48h+var_2C]
mov edx, [rsp+48h+var_30]
lea rsi, [rsp+48h+var_34]
call _waitpid
mov ebp, eax
test eax, eax
jns short loc_15551
call ___errno_location
xor ebp, ebp
sub ebp, [rax]
and [rsp+48h+var_34], 0
loc_15551:
mov r12, 0FFFFFFFF00000000h
mov rdi, rbx
call JS_NewArray
mov r15, rax
mov r14, rdx
cmp r14d, 6
jz short loc_155A7
mov r8d, ebp
push 7
pop rbp
mov [rsp+48h+var_48], ebp
mov rdi, rbx
mov rsi, r15
mov rdx, r14
xor ecx, ecx
xor r9d, r9d
call JS_DefinePropertyValueUint32
mov r8d, [rsp+48h+var_34]
mov [rsp+48h+var_48], ebp
push 1
pop rcx
mov rdi, rbx
mov rsi, r15
mov rdx, r14
xor r9d, r9d
call JS_DefinePropertyValueUint32
loc_155A7:
mov rcx, r15
and rcx, r12
jmp loc_15515
|
unsigned long long js_os_waitpid(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
long long v7; // r15
unsigned long long v8; // rcx
long long v10; // rdi
int v11; // ebp
long long v12; // rax
int v13; // edx
int v14; // r14d
int v15; // [rsp+14h] [rbp-34h] BYREF
unsigned int v16; // [rsp+18h] [rbp-30h] BYREF
_DWORD v17[11]; // [rsp+1Ch] [rbp-2Ch] BYREF
if ( (unsigned int)JS_ToInt32(a1, v17, *a5, a5[1]) || (unsigned int)JS_ToInt32(a1, &v16, a5[2], a5[3]) )
{
LODWORD(v7) = 0;
v8 = 0LL;
}
else
{
v10 = v17[0];
v11 = waitpid(v17[0], &v15, v16);
if ( v11 < 0 )
{
v11 = -*(_DWORD *)__errno_location(v10);
v15 = 0;
}
v12 = JS_NewArray(a1);
v7 = v12;
v14 = v13;
if ( v13 != 6 )
{
JS_DefinePropertyValueUint32(a1, v12, v13, 0, v11, 0, 7);
JS_DefinePropertyValueUint32(a1, v7, v14, 1, v15, 0, 7);
}
v8 = v7 & 0xFFFFFFFF00000000LL;
}
return v8 | (unsigned int)v7;
}
|
js_os_waitpid:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV R15,R8
MOV RBX,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
LEA RSI,[RSP + 0x1c]
CALL 0x001215d7
PUSH 0x6
POP R14
TEST EAX,EAX
JNZ 0x00115510
MOV RDX,qword ptr [R15 + 0x10]
MOV RCX,qword ptr [R15 + 0x18]
LEA RSI,[RSP + 0x18]
MOV RDI,RBX
CALL 0x001215d7
TEST EAX,EAX
JZ 0x0011552b
LAB_00115510:
XOR R15D,R15D
XOR ECX,ECX
LAB_00115515:
MOV EAX,R15D
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0011552b:
MOV EDI,dword ptr [RSP + 0x1c]
MOV EDX,dword ptr [RSP + 0x18]
LEA RSI,[RSP + 0x14]
CALL 0x0010e770
MOV EBP,EAX
TEST EAX,EAX
JNS 0x00115551
CALL 0x0010e0b0
XOR EBP,EBP
SUB EBP,dword ptr [RAX]
AND dword ptr [RSP + 0x14],0x0
LAB_00115551:
MOV R12,-0x100000000
MOV RDI,RBX
CALL 0x0011b2bb
MOV R15,RAX
MOV R14,RDX
CMP R14D,0x6
JZ 0x001155a7
MOV R8D,EBP
PUSH 0x7
POP RBP
MOV dword ptr [RSP],EBP
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
XOR ECX,ECX
XOR R9D,R9D
CALL 0x00120972
MOV R8D,dword ptr [RSP + 0x14]
MOV dword ptr [RSP],EBP
PUSH 0x1
POP RCX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
XOR R9D,R9D
CALL 0x00120972
LAB_001155a7:
MOV RCX,R15
AND RCX,R12
JMP 0x00115515
|
int1 [16] js_os_waitpid(int8 param_1)
{
int iVar1;
int *piVar2;
ulong uVar3;
int8 *in_R8;
int1 auVar4 [16];
int1 auVar5 [16];
int local_34;
int local_30;
__pid_t local_2c;
iVar1 = JS_ToInt32(param_1,&local_2c,*in_R8,in_R8[1]);
if (iVar1 == 0) {
iVar1 = JS_ToInt32(param_1,&local_30,in_R8[2],in_R8[3]);
if (iVar1 == 0) {
iVar1 = waitpid(local_2c,&local_34,local_30);
if (iVar1 < 0) {
piVar2 = __errno_location();
iVar1 = -*piVar2;
local_34 = 0;
}
auVar5 = JS_NewArray(param_1);
uVar3 = auVar5._0_8_;
if (auVar5._8_4_ != 6) {
JS_DefinePropertyValueUint32(param_1,uVar3,auVar5._8_8_,0,iVar1,0,7);
JS_DefinePropertyValueUint32(param_1,uVar3,auVar5._8_8_,1,local_34,0,7);
}
uVar3 = uVar3 & 0xffffffff00000000;
goto LAB_00115515;
}
}
auVar5 = ZEXT816(6) << 0x40;
uVar3 = 0;
LAB_00115515:
auVar4._0_8_ = auVar5._0_8_ & 0xffffffff | uVar3;
auVar4._8_8_ = auVar5._8_8_;
return auVar4;
}
|
|
17,290
|
SchemaConverter::format_grammar[abi:cxx11]()
|
monkey531[P]llama/common/json-schema-to-grammar.cpp
|
std::string format_grammar() {
std::stringstream ss;
for (const auto & kv : _rules) {
ss << kv.first << " ::= " << kv.second << std::endl;
}
return ss.str();
}
|
O0
|
cpp
|
SchemaConverter::format_grammar[abi:cxx11]():
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq 0x1e8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x5d550
movq 0x28(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x1a7070
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x1a5b00
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1a70a0
testb $0x1, %al
jne 0x1a483f
jmp 0x1a48d2
leaq 0x50(%rsp), %rdi
callq 0x1a5b50
movq %rax, 0x40(%rsp)
leaq 0x70(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x5d540
movq %rax, 0x10(%rsp)
jmp 0x1a4864
movq 0x10(%rsp), %rdi
leaq 0x797f3(%rip), %rsi # 0x21e063
callq 0x5da30
movq %rax, 0x8(%rsp)
jmp 0x1a487c
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
addq $0x20, %rsi
callq 0x5d540
movq %rax, (%rsp)
jmp 0x1a4895
movq (%rsp), %rdi
movq 0x109718(%rip), %rsi # 0x2adfb8
callq 0x5e190
jmp 0x1a48a7
jmp 0x1a48a9
leaq 0x50(%rsp), %rdi
callq 0x1a69d0
jmp 0x1a4827
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x5d670
jmp 0x1a48fa
movq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x5dc90
jmp 0x1a48e3
leaq 0x60(%rsp), %rdi
callq 0x5d670
movq 0x20(%rsp), %rax
addq $0x1f8, %rsp # imm = 0x1F8
retq
movq 0x38(%rsp), %rdi
callq 0x5dbc0
nopw %cs:(%rax,%rax)
nop
|
_ZN15SchemaConverter14format_grammarB5cxx11Ev:
sub rsp, 1F8h
mov [rsp+1F8h+var_1E0], rdi
mov rax, rdi
mov [rsp+1F8h+var_1D8], rax
mov [rsp+1F8h+var_8], rdi
mov [rsp+1F8h+var_10], rsi
mov rax, [rsp+1F8h+var_10]
mov [rsp+1F8h+var_1D0], rax
lea rdi, [rsp+1F8h+var_198]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
mov rax, [rsp+1F8h+var_1D0]
add rax, 28h ; '('
mov [rsp+1F8h+var_1A0], rax
mov rdi, [rsp+1F8h+var_1A0]
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEE5beginEv; std::map<std::string,std::string>::begin(void)
mov [rsp+1F8h+var_1A8], rax
mov rdi, [rsp+1F8h+var_1A0]
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEE3endEv; std::map<std::string,std::string>::end(void)
mov [rsp+1F8h+var_1B0], rax
loc_1A4827:
lea rdi, [rsp+1F8h+var_1A8]
lea rsi, [rsp+1F8h+var_1B0]
call _ZStneRKSt17_Rb_tree_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_EESB_; std::operator!=(std::_Rb_tree_iterator<std::pair<std::string const,std::string>> const&,std::_Rb_tree_iterator<std::pair<std::string const,std::string>> const&)
test al, 1
jnz short loc_1A483F
jmp loc_1A48D2
loc_1A483F:
lea rdi, [rsp+1F8h+var_1A8]
call _ZNKSt17_Rb_tree_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_EEdeEv; std::_Rb_tree_iterator<std::pair<std::string const,std::string>>::operator*(void)
mov [rsp+1F8h+var_1B8], rax
lea rdi, [rsp+1F8h+var_188]
mov rsi, [rsp+1F8h+var_1B8]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rsp+1F8h+var_1E8], rax
jmp short $+2
loc_1A4864:
mov rdi, [rsp+1F8h+var_1E8]
lea rsi, asc_21E063; " ::= "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+1F8h+var_1F0], rax
jmp short $+2
loc_1A487C:
mov rdi, [rsp+1F8h+var_1F0]
mov rsi, [rsp+1F8h+var_1B8]
add rsi, 20h ; ' '
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rsp+1F8h+var_1F8], rax
jmp short $+2
loc_1A4895:
mov rdi, [rsp+1F8h+var_1F8]
mov rsi, cs:_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6__ptr
call __ZNSolsEPFRSoS_E; std::ostream::operator<<(std::ostream & (*)(std::ostream &))
jmp short $+2
loc_1A48A7:
jmp short $+2
loc_1A48A9:
lea rdi, [rsp+1F8h+var_1A8]
call _ZNSt17_Rb_tree_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_EEppEv; std::_Rb_tree_iterator<std::pair<std::string const,std::string>>::operator++(void)
jmp loc_1A4827
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, [rsp+arg_58]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
jmp short loc_1A48FA
loc_1A48D2:
mov rdi, [rsp+1F8h+var_1E0]
lea rsi, [rsp+1F8h+var_198]
call __ZNKSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEE3strEv; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(void)
jmp short $+2
loc_1A48E3:
lea rdi, [rsp+1F8h+var_198]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rax, [rsp+1F8h+var_1D8]
add rsp, 1F8h
retn
loc_1A48FA:
mov rdi, [rsp+arg_30]
call __Unwind_Resume
|
long long SchemaConverter::format_grammar[abi:cxx11](long long a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-1F8h]
long long v4; // [rsp+8h] [rbp-1F0h]
long long v5; // [rsp+10h] [rbp-1E8h]
long long v6; // [rsp+40h] [rbp-1B8h]
long long v7; // [rsp+48h] [rbp-1B0h] BYREF
_QWORD v8[2]; // [rsp+50h] [rbp-1A8h] BYREF
_BYTE v9[16]; // [rsp+60h] [rbp-198h] BYREF
_BYTE v10[376]; // [rsp+70h] [rbp-188h] BYREF
long long v11; // [rsp+1E8h] [rbp-10h]
long long v12; // [rsp+1F0h] [rbp-8h]
v12 = a1;
v11 = a2;
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v9);
v8[1] = a2 + 40;
v8[0] = std::map<std::string,std::string>::begin(a2 + 40);
v7 = std::map<std::string,std::string>::end(a2 + 40);
while ( (std::operator!=(v8, &v7) & 1) != 0 )
{
v6 = std::_Rb_tree_iterator<std::pair<std::string const,std::string>>::operator*(v8);
v5 = std::operator<<<char>(v10, v6);
v4 = std::operator<<<std::char_traits<char>>(v5, " ::= ");
v3 = std::operator<<<char>(v4, v6 + 32);
std::ostream::operator<<(v3, &std::endl<char,std::char_traits<char>>);
std::_Rb_tree_iterator<std::pair<std::string const,std::string>>::operator++(v8);
}
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(a1, v9);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v9);
return a1;
}
| |||
17,291
|
SchemaConverter::format_grammar[abi:cxx11]()
|
monkey531[P]llama/common/json-schema-to-grammar.cpp
|
std::string format_grammar() {
std::stringstream ss;
for (const auto & kv : _rules) {
ss << kv.first << " ::= " << kv.second << std::endl;
}
return ss.str();
}
|
O2
|
cpp
|
SchemaConverter::format_grammar[abi:cxx11]():
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x24640
movq 0x40(%r14), %r12
addq $0x30, %r14
leaq 0x18(%rsp), %r15
leaq 0x2d63f(%rip), %r13 # 0xba687
cmpq %r14, %r12
je 0x8d087
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x247b0
movq %rax, %rdi
movq %r13, %rsi
callq 0x24880
leaq 0x40(%r12), %rsi
movq %rax, %rdi
callq 0x247b0
movq %rax, %rdi
callq 0x24450
movq %r12, %rdi
callq 0x24630
movq %rax, %r12
jmp 0x8d048
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x24d90
leaq 0x8(%rsp), %rdi
callq 0x24690
movq %rbx, %rax
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x8d0b4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x24690
movq %rbx, %rdi
callq 0x24f60
nop
|
_ZN15SchemaConverter14format_grammarB5cxx11Ev:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 190h
mov r14, rsi
mov rbx, rdi
lea rdi, [rsp+1B8h+var_1B0]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
mov r12, [r14+40h]
add r14, 30h ; '0'
lea r15, [rsp+1B8h+var_1A0]
lea r13, asc_BA687; " ::= "
loc_8D048:
cmp r12, r14
jz short loc_8D087
lea rsi, [r12+20h]
mov rdi, r15
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov rdi, rax
mov rsi, r13
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
lea rsi, [r12+40h]
mov rdi, rax
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
mov rdi, r12
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov r12, rax
jmp short loc_8D048
loc_8D087:
lea rsi, [rsp+1B8h+var_198]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
lea rdi, [rsp+1B8h+var_1B0]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rax, rbx
add rsp, 190h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
jmp short $+2
loc_8D0B4:
mov rbx, rax
lea rdi, [rsp+arg_0]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rdi, rbx
call __Unwind_Resume
|
long long SchemaConverter::format_grammar[abi:cxx11](long long a1, long long a2)
{
long long i; // r12
long long v3; // rax
long long v4; // rax
long long v5; // rax
_BYTE v7[16]; // [rsp+8h] [rbp-1B0h] BYREF
_BYTE v8[8]; // [rsp+18h] [rbp-1A0h] BYREF
_BYTE v9[408]; // [rsp+20h] [rbp-198h] BYREF
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v7);
for ( i = *(_QWORD *)(a2 + 64); i != a2 + 48; i = std::_Rb_tree_increment(i) )
{
v3 = std::operator<<<char>(v8, i + 32);
v4 = std::operator<<<std::char_traits<char>>(v3, " ::= ");
v5 = std::operator<<<char>(v4, i + 64);
std::endl<char,std::char_traits<char>>(v5);
}
std::stringbuf::str(a1, v9);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v7);
return a1;
}
|
format_grammar[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x190
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RSP + 0x8]
CALL 0x00124640
MOV R12,qword ptr [R14 + 0x40]
ADD R14,0x30
LEA R15,[RSP + 0x18]
LEA R13,[0x1ba687]
LAB_0018d048:
CMP R12,R14
JZ 0x0018d087
LEA RSI,[R12 + 0x20]
LAB_0018d052:
MOV RDI,R15
CALL 0x001247b0
MOV RDI,RAX
MOV RSI,R13
CALL 0x00124880
LEA RSI,[R12 + 0x40]
MOV RDI,RAX
CALL 0x001247b0
MOV RDI,RAX
CALL 0x00124450
MOV RDI,R12
CALL 0x00124630
MOV R12,RAX
JMP 0x0018d048
LAB_0018d087:
LEA RSI,[RSP + 0x20]
LAB_0018d08c:
MOV RDI,RBX
CALL 0x00124d90
LAB_0018d094:
LEA RDI,[RSP + 0x8]
CALL 0x00124690
MOV RAX,RBX
ADD RSP,0x190
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* SchemaConverter::format_grammar[abi:cxx11]() */
void SchemaConverter::format_grammar_abi_cxx11_(void)
{
ostream *poVar1;
_Rb_tree_node_base *p_Var2;
long in_RSI;
stringstream local_1b0 [16];
ostream local_1a0 [376];
std::__cxx11::stringstream::stringstream(local_1b0);
for (p_Var2 = *(_Rb_tree_node_base **)(in_RSI + 0x40);
p_Var2 != (_Rb_tree_node_base *)(in_RSI + 0x30);
p_Var2 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var2)) {
/* try { // try from 0018d052 to 0018d079 has its CatchHandler @ 0018d0b4 */
poVar1 = std::operator<<(local_1a0,(string *)(p_Var2 + 0x20));
poVar1 = std::operator<<(poVar1," ::= ");
poVar1 = std::operator<<(poVar1,(string *)(p_Var2 + 0x40));
std::endl<char,std::char_traits<char>>(poVar1);
}
/* try { // try from 0018d08c to 0018d093 has its CatchHandler @ 0018d0b2 */
std::__cxx11::stringbuf::str();
std::__cxx11::stringstream::~stringstream(local_1b0);
return;
}
|
|
17,292
|
ma_alloc_dynamic
|
eloqsql/libmariadb/libmariadb/ma_array.c
|
unsigned char *ma_alloc_dynamic(DYNAMIC_ARRAY *array)
{
if (array->elements == array->max_element)
{
char *new_ptr;
if (!(new_ptr=(char*) realloc(array->buffer,(array->max_element+
array->alloc_increment)*
array->size_of_element)))
return 0;
array->buffer=new_ptr;
array->max_element+=array->alloc_increment;
}
return (unsigned char *)array->buffer+(array->elements++ * array->size_of_element);
}
|
O0
|
c
|
ma_alloc_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x67ea2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x360c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x67e86
movq $0x0, -0x8(%rbp)
jmp 0x67ec9
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x8(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rdx)
movq -0x10(%rbp), %rdx
imull 0x14(%rdx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_alloc_dynamic:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
cmp eax, [rcx+0Ch]
jnz short loc_67EA2
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
mov rcx, [rbp+var_10]
add eax, [rcx+10h]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov esi, eax
call _realloc
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_67E86
mov [rbp+var_8], 0
jmp short loc_67EC9
loc_67E86:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+10h]
mov rax, [rbp+var_10]
add ecx, [rax+0Ch]
mov [rax+0Ch], ecx
loc_67EA2:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+8]
mov esi, ecx
add esi, 1
mov [rdx+8], esi
mov rdx, [rbp+var_10]
imul ecx, [rdx+14h]
mov ecx, ecx
add rax, rcx
mov [rbp+var_8], rax
loc_67EC9:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
|
long long ma_alloc_dynamic(long long *a1)
{
long long v1; // rax
int v2; // ecx
long long v4; // [rsp+8h] [rbp-18h]
if ( *((_DWORD *)a1 + 2) != *((_DWORD *)a1 + 3) )
goto LABEL_5;
v4 = realloc(*a1, (unsigned int)(*((_DWORD *)a1 + 5) * (*((_DWORD *)a1 + 4) + *((_DWORD *)a1 + 3))));
if ( v4 )
{
*a1 = v4;
*((_DWORD *)a1 + 3) += *((_DWORD *)a1 + 4);
LABEL_5:
v1 = *a1;
v2 = *((_DWORD *)a1 + 2);
*((_DWORD *)a1 + 2) = v2 + 1;
return (unsigned int)(*((_DWORD *)a1 + 5) * v2) + v1;
}
return 0LL;
}
|
ma_alloc_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0xc]
JNZ 0x00167ea2
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV ESI,EAX
CALL 0x001360c0
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00167e86
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00167ec9
LAB_00167e86:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
ADD ECX,dword ptr [RAX + 0xc]
MOV dword ptr [RAX + 0xc],ECX
LAB_00167ea2:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x8]
MOV ESI,ECX
ADD ESI,0x1
MOV dword ptr [RDX + 0x8],ESI
MOV RDX,qword ptr [RBP + -0x10]
IMUL ECX,dword ptr [RDX + 0x14]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
LAB_00167ec9:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
long ma_alloc_dynamic(long *param_1)
{
long lVar1;
void *pvVar2;
if ((int)param_1[1] == *(int *)((long)param_1 + 0xc)) {
pvVar2 = realloc((void *)*param_1,
(ulong)(uint)((*(int *)((long)param_1 + 0xc) + (int)param_1[2]) *
*(int *)((long)param_1 + 0x14)));
if (pvVar2 == (void *)0x0) {
return 0;
}
*param_1 = (long)pvVar2;
*(int *)((long)param_1 + 0xc) = (int)param_1[2] + *(int *)((long)param_1 + 0xc);
}
lVar1 = param_1[1];
*(int *)(param_1 + 1) = (int)lVar1 + 1;
return *param_1 + (ulong)(uint)((int)lVar1 * *(int *)((long)param_1 + 0x14));
}
|
|
17,293
|
Create_func_sysconst_test::create_builder(THD*)
|
eloqsql/plugin/func_test/plugin.cc
|
Item* Create_func_sysconst_test::create_builder(THD *thd)
{
return new (thd->mem_root) Item_func_sysconst_test(thd);
}
|
O0
|
cpp
|
Create_func_sysconst_test::create_builder(THD*):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq %rsi, -0x40(%rbp)
movl $0xa8, %edi
callq 0xb3a0
movq %rax, %rcx
movq %rcx, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x30(%rbp)
je 0xbbba
movq -0x38(%rbp), %rdi
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0xb630
jmp 0xbbb0
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xbbba
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xbbd8
jmp 0xbbe5
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0xb510
jmp 0xbbe7
movq -0x20(%rbp), %rdi
callq 0xb6a0
|
_ZN25Create_func_sysconst_test14create_builderEP3THD:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rsi, [rax+28h]
mov [rbp+var_40], rsi
mov edi, 0A8h
call __ZN4ItemnwEmP11st_mem_root; Item::operator new(ulong,st_mem_root *)
mov rcx, rax
mov [rbp+var_38], rcx
mov [rbp+var_11], 0
xor eax, eax
cmp rcx, 0
mov [rbp+var_30], rax
jz short loc_BBBA
mov rdi, [rbp+var_38]
mov [rbp+var_11], 1
mov rsi, [rbp+var_10]
call __ZN23Item_func_sysconst_testC2EP3THD; Item_func_sysconst_test::Item_func_sysconst_test(THD *)
jmp short $+2
loc_BBB0:
mov rax, [rbp+var_38]
mov [rbp+var_30], rax
jmp short $+2
loc_BBBA:
mov rax, [rbp+var_30]
add rsp, 40h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
test [rbp+var_11], 1
jnz short loc_BBD8
jmp short loc_BBE5
loc_BBD8:
mov rsi, [rbp+var_40]
mov rdi, [rbp+var_38]
call __ZN4ItemdlEPvP11st_mem_root; Item::operator delete(void *,st_mem_root *)
loc_BBE5:
jmp short $+2
loc_BBE7:
mov rdi, [rbp+var_20]
call __Unwind_Resume
|
long long Create_func_sysconst_test::create_builder(long long a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-38h]
long long v4; // [rsp+10h] [rbp-30h]
v3 = Item::operator new(168LL);
v4 = 0LL;
if ( v3 )
{
Item_func_sysconst_test::Item_func_sysconst_test(v3, a2);
return v3;
}
return v4;
}
|
create_builder:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x40],RSI
MOV EDI,0xa8
CALL 0x0010b3a0
MOV RCX,RAX
MOV qword ptr [RBP + -0x38],RCX
MOV byte ptr [RBP + -0x11],0x0
XOR EAX,EAX
CMP RCX,0x0
MOV qword ptr [RBP + -0x30],RAX
JZ 0x0010bbba
MOV RDI,qword ptr [RBP + -0x38]
MOV byte ptr [RBP + -0x11],0x1
MOV RSI,qword ptr [RBP + -0x10]
LAB_0010bba9:
CALL 0x0010b630
LAB_0010bbae:
JMP 0x0010bbb0
LAB_0010bbb0:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0010bbba
LAB_0010bbba:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
|
/* Create_func_sysconst_test::create_builder(THD*) */
Item_func_sysconst_test * __thiscall
Create_func_sysconst_test::create_builder(Create_func_sysconst_test *this,THD *param_1)
{
Item_func_sysconst_test *this_00;
Item_func_sysconst_test *local_38;
this_00 = (Item_func_sysconst_test *)Item::operator_new(0xa8,*(st_mem_root **)(param_1 + 0x28));
local_38 = (Item_func_sysconst_test *)0x0;
if (this_00 != (Item_func_sysconst_test *)0x0) {
/* try { // try from 0010bba9 to 0010bbad has its CatchHandler @ 0010bbc4 */
Item_func_sysconst_test::Item_func_sysconst_test(this_00,param_1);
local_38 = this_00;
}
return local_38;
}
|
|
17,294
|
google::protobuf::internal::LogMessage::Finish()
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/common.cc
|
void LogMessage::Finish() {
bool suppress = false;
if (level_ != LOGLEVEL_FATAL) {
suppress = log_silencer_count_ > 0;
}
if (!suppress) {
log_handler_(level_, filename_, line_, message_);
}
if (level_ == LOGLEVEL_FATAL) {
#if PROTOBUF_USE_EXCEPTIONS
throw FatalException(filename_, line_, message_);
#else
abort();
#endif
}
}
|
O0
|
cpp
|
google::protobuf::internal::LogMessage::Finish():
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x2f(%rsp)
cmpl $0x3, (%rax)
je 0x19a705
leaq 0x371b44(%rip), %rdi # 0x50c238
callq 0x950b0
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x19a727
movq 0x10(%rsp), %rcx
movq 0x36e158(%rip), %rax # 0x508870
movl (%rcx), %edi
movq 0x8(%rcx), %rsi
movl 0x10(%rcx), %edx
addq $0x18, %rcx
callq *%rax
movq 0x10(%rsp), %rax
cmpl $0x3, (%rax)
jne 0x19a78f
movl $0x38, %edi
callq 0x8e630
movq 0x10(%rsp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rcx), %rsi
movl 0x10(%rcx), %edx
addq $0x18, %rcx
callq 0x19ad60
jmp 0x19a75d
movq 0x8(%rsp), %rdi
leaq 0x3614df(%rip), %rsi # 0x4fbc48
leaq 0x190(%rip), %rdx # 0x19a900
callq 0x90860
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x93710
jmp 0x19a794
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x90db0
nop
|
_ZN6google8protobuf8internal10LogMessage6FinishEv:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov rax, [rsp+38h+var_8]
mov [rsp+38h+var_28], rax
mov [rsp+38h+var_9], 0
cmp dword ptr [rax], 3
jz short loc_19A705
lea rdi, _ZN6google8protobuf8internalL19log_silencer_count_E; google::protobuf::internal::log_silencer_count_
call __ZNKSt13__atomic_baseIiEcviEv; std::__atomic_base<int>::operator int(void)
cmp eax, 0
setnle al
and al, 1
mov [rsp+38h+var_9], al
loc_19A705:
test [rsp+38h+var_9], 1
jnz short loc_19A727
mov rcx, [rsp+38h+var_28]
mov rax, cs:_ZN6google8protobuf8internalL12log_handler_B5cxx11E; google::protobuf::internal::log_handler_
mov edi, [rcx]
mov rsi, [rcx+8]
mov edx, [rcx+10h]
add rcx, 18h
call rax ; google::protobuf::internal::DefaultLogHandler(google::protobuf::LogLevel,char const*,int,std::string const&); google::protobuf::internal::DefaultLogHandler(google::protobuf::LogLevel,char const*,int,std::string const&)
loc_19A727:
mov rax, [rsp+38h+var_28]
cmp dword ptr [rax], 3
jnz short loc_19A78F
mov edi, 38h ; '8'; thrown_size
call ___cxa_allocate_exception
mov rcx, [rsp+38h+var_28]
mov rdi, rax
mov rax, rdi
mov [rsp+38h+var_30], rax
mov rsi, [rcx+8]
mov edx, [rcx+10h]
add rcx, 18h
call _ZN6google8protobuf14FatalExceptionC2EPKciRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::FatalException::FatalException(char const*,int,std::string const&)
jmp short $+2
loc_19A75D:
mov rdi, [rsp+38h+var_30]; void *
lea rsi, _ZTIN6google8protobuf14FatalExceptionE; lptinfo
lea rdx, _ZN6google8protobuf14FatalExceptionD2Ev; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+38h+var_30]; void *
mov rcx, rax
mov eax, edx
mov [rsp+38h+var_18], rcx
mov [rsp+38h+var_1C], eax
call ___cxa_free_exception
jmp short loc_19A794
loc_19A78F:
add rsp, 38h
retn
loc_19A794:
mov rdi, [rsp+38h+var_18]
call __Unwind_Resume
|
google::protobuf::internal::LogMessage * google::protobuf::internal::LogMessage::Finish(
google::protobuf::internal::LogMessage *this)
{
google::protobuf::internal::LogMessage *result; // rax
int v2; // r8d
int v3; // r9d
void *exception; // [rsp+8h] [rbp-30h]
bool v5; // [rsp+2Fh] [rbp-9h]
v5 = 0;
if ( *(_DWORD *)this != 3 )
v5 = (int)std::__atomic_base<int>::operator int(&google::protobuf::internal::log_silencer_count_) > 0;
if ( !v5 )
google::protobuf::internal::log_handler_[abi:cxx11](
*(_DWORD *)this,
*((const char **)this + 1),
*((_DWORD *)this + 4),
(long long)this + 24);
result = this;
if ( *(_DWORD *)this == 3 )
{
exception = __cxa_allocate_exception(0x38uLL);
google::protobuf::FatalException::FatalException(
(_DWORD)exception,
*((_QWORD *)this + 1),
*((_DWORD *)this + 4),
(_DWORD)this + 24,
v2,
v3);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'google::protobuf::FatalException,
google::protobuf::FatalException::~FatalException);
}
return result;
}
|
__cxx_global_var_init:
PUSH RAX
LEA RDI,[0x60bc00]
CALL 0x00194bf0
MOV RDI,qword ptr [0x00601f20]
LEA RSI,[0x60bc00]
LEA RDX,[0x607fe0]
CALL 0x00193580
POP RAX
RET
|
int8 __cxx_global_var_init(void)
{
int8 in_RAX;
std::ios_base::Init::Init((Init *)&std::__ioinit);
__cxa_atexit(PTR__Init_00601f20,&std::__ioinit,&__dso_handle);
return in_RAX;
}
|
|
17,295
|
pagecache_unlock_by_link
|
eloqsql/storage/maria/ma_pagecache.c
|
void pagecache_unlock_by_link(PAGECACHE *pagecache,
PAGECACHE_BLOCK_LINK *block,
enum pagecache_page_lock lock,
enum pagecache_page_pin pin,
LSN first_REDO_LSN_for_page,
LSN lsn, my_bool was_changed,
my_bool any)
{
DBUG_ENTER("pagecache_unlock_by_link");
DBUG_PRINT("enter", ("block: %p fd: %u page: %lu changed: %d %s %s",
block, (uint) block->hash_link->file.file,
(ulong) block->hash_link->pageno, was_changed,
page_cache_page_lock_str[lock],
page_cache_page_pin_str[pin]));
/*
We do not allow any lock/pin increasing here and page can't be
unpinned because we use direct link.
*/
DBUG_ASSERT(pin != PAGECACHE_PIN);
DBUG_ASSERT(pin != PAGECACHE_PIN_LEFT_UNPINNED);
DBUG_ASSERT(lock != PAGECACHE_LOCK_READ);
DBUG_ASSERT(lock != PAGECACHE_LOCK_WRITE);
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
if (pin == PAGECACHE_PIN_LEFT_UNPINNED &&
lock == PAGECACHE_LOCK_READ_UNLOCK)
{
if (make_lock_and_pin(pagecache, block, lock, pin, FALSE))
DBUG_ASSERT(0); /* should not happend */
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_VOID_RETURN;
}
/*
As soon as we keep lock cache can be used, and we have lock because want
unlock.
*/
DBUG_ASSERT(pagecache->can_be_used);
inc_counter_for_resize_op(pagecache);
if (was_changed)
{
if (first_REDO_LSN_for_page != LSN_IMPOSSIBLE)
{
/*
LOCK_READ_UNLOCK is ok here as the page may have first locked
with WRITE lock that was temporarly converted to READ lock before
it's unpinned
*/
DBUG_ASSERT(lock == PAGECACHE_LOCK_WRITE_UNLOCK ||
lock == PAGECACHE_LOCK_READ_UNLOCK);
DBUG_ASSERT(pin == PAGECACHE_UNPIN);
pagecache_set_block_rec_lsn(block, first_REDO_LSN_for_page);
}
if (lsn != LSN_IMPOSSIBLE)
check_and_set_lsn(pagecache, lsn, block);
/*
Reset error flag. Mark also that page is active; This may not have
been the case if there was an error reading the page
*/
block->status= (block->status & ~PCBLOCK_ERROR) | PCBLOCK_READ;
}
/* if we lock for write we must link the block to changed blocks */
DBUG_ASSERT((block->status & PCBLOCK_DIRECT_W) == 0 ||
(lock == PAGECACHE_LOCK_WRITE_UNLOCK ||
lock == PAGECACHE_LOCK_WRITE_TO_READ ||
lock == PAGECACHE_LOCK_LEFT_WRITELOCKED));
/*
If was_changed then status should be PCBLOCK_DIRECT_W or marked
as dirty
*/
DBUG_ASSERT(!was_changed || (block->status & PCBLOCK_DIRECT_W) ||
(block->status & PCBLOCK_CHANGED));
if ((block->status & PCBLOCK_DIRECT_W) &&
(lock == PAGECACHE_LOCK_WRITE_UNLOCK ||
lock == PAGECACHE_LOCK_WRITE_TO_READ))
{
if (!(block->status & PCBLOCK_CHANGED) && was_changed)
link_to_changed_list(pagecache, block);
block->status&= ~PCBLOCK_DIRECT_W;
DBUG_PRINT("info", ("Drop PCBLOCK_DIRECT_W for block: %p", block));
}
if (make_lock_and_pin(pagecache, block, lock, pin, any))
DBUG_ASSERT(0); /* should not happend */
/*
Link the block into the LRU chain if it's the last submitted request
for the block and block will not be pinned.
See NOTE for pagecache_unlock about registering requests.
*/
if (pin != PAGECACHE_PIN_LEFT_PINNED)
unreg_request(pagecache, block, 1);
dec_counter_for_resize_op(pagecache);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
pagecache_unlock_by_link:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb 0x18(%rbp), %al
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
jmp 0x3dcb6
jmp 0x3dcb8
jmp 0x3dcba
jmp 0x3dcbc
jmp 0x3dcbe
jmp 0x3dcc0
jmp 0x3dcc2
jmp 0x3dcc4
jmp 0x3dcc6
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
leaq 0x1157b6(%rip), %rsi # 0x15348e
movl $0xd47, %edx # imm = 0xD47
callq 0x3ca50
cmpl $0x1, -0x18(%rbp)
jne 0x3dd23
cmpl $0x5, -0x14(%rbp)
jne 0x3dd23
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
xorl %r8d, %r8d
callq 0x3d810
cmpb $0x0, %al
je 0x3dd0e
jmp 0x3dd0a
jmp 0x3dd0c
jmp 0x3dd0e
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x3cac0
jmp 0x3de35
jmp 0x3dd25
jmp 0x3dd27
movq -0x8(%rbp), %rdi
callq 0x3ce00
cmpb $0x0, 0x10(%rbp)
je 0x3dd83
cmpq $0x0, -0x20(%rbp)
je 0x3dd52
jmp 0x3dd3f
jmp 0x3dd41
jmp 0x3dd43
jmp 0x3dd45
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3d630
cmpq $0x0, -0x28(%rbp)
je 0x3dd6a
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x3d670
movq -0x10(%rbp), %rax
movzwl 0x74(%rax), %eax
andl $-0x2, %eax
orl $0x2, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x74(%rax)
jmp 0x3dd85
jmp 0x3dd87
jmp 0x3dd89
jmp 0x3dd8b
movq -0x10(%rbp), %rax
movzwl 0x74(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x3dde0
cmpl $0x6, -0x14(%rbp)
je 0x3dda7
cmpl $0x7, -0x14(%rbp)
jne 0x3dde0
movq -0x10(%rbp), %rax
movzwl 0x74(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x3ddcd
movsbl 0x10(%rbp), %eax
cmpl $0x0, %eax
je 0x3ddcd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3d780
movq -0x10(%rbp), %rax
movzwl 0x74(%rax), %ecx
andl $-0x41, %ecx
movw %cx, 0x74(%rax)
jmp 0x3ddde
jmp 0x3dde0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movsbl 0x18(%rbp), %r8d
callq 0x3d810
cmpb $0x0, %al
je 0x3de02
jmp 0x3ddfe
jmp 0x3de00
jmp 0x3de02
cmpl $0x0, -0x18(%rbp)
je 0x3de1a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x3d9b0
movq -0x8(%rbp), %rdi
callq 0x3db30
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x3cac0
jmp 0x3de35
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
pagecache_unlock_by_link:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, [rbp+arg_8]
mov al, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
mov [rbp+var_20], r8
mov [rbp+var_28], r9
jmp short $+2
loc_3DCB6:
jmp short $+2
loc_3DCB8:
jmp short $+2
loc_3DCBA:
jmp short $+2
loc_3DCBC:
jmp short $+2
loc_3DCBE:
jmp short $+2
loc_3DCC0:
jmp short $+2
loc_3DCC2:
jmp short $+2
loc_3DCC4:
jmp short $+2
loc_3DCC6:
mov rdi, [rbp+var_8]
add rdi, 0C8h
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0D47h
call inline_mysql_mutex_lock_0
cmp [rbp+var_18], 1
jnz short loc_3DD23
cmp [rbp+var_14], 5
jnz short loc_3DD23
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
mov ecx, [rbp+var_18]
xor r8d, r8d
call make_lock_and_pin
cmp al, 0
jz short loc_3DD0E
jmp short $+2
loc_3DD0A:
jmp short $+2
loc_3DD0C:
jmp short $+2
loc_3DD0E:
mov rdi, [rbp+var_8]
add rdi, 0C8h
call inline_mysql_mutex_unlock_0
jmp loc_3DE35
loc_3DD23:
jmp short $+2
loc_3DD25:
jmp short $+2
loc_3DD27:
mov rdi, [rbp+var_8]
call inc_counter_for_resize_op
cmp [rbp+arg_0], 0
jz short loc_3DD83
cmp [rbp+var_20], 0
jz short loc_3DD52
jmp short $+2
loc_3DD3F:
jmp short $+2
loc_3DD41:
jmp short $+2
loc_3DD43:
jmp short $+2
loc_3DD45:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call pagecache_set_block_rec_lsn
loc_3DD52:
cmp [rbp+var_28], 0
jz short loc_3DD6A
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_10]
call check_and_set_lsn
loc_3DD6A:
mov rax, [rbp+var_10]
movzx eax, word ptr [rax+74h]
and eax, 0FFFFFFFEh
or eax, 2
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+74h], cx
loc_3DD83:
jmp short $+2
loc_3DD85:
jmp short $+2
loc_3DD87:
jmp short $+2
loc_3DD89:
jmp short $+2
loc_3DD8B:
mov rax, [rbp+var_10]
movzx eax, word ptr [rax+74h]
and eax, 40h
cmp eax, 0
jz short loc_3DDE0
cmp [rbp+var_14], 6
jz short loc_3DDA7
cmp [rbp+var_14], 7
jnz short loc_3DDE0
loc_3DDA7:
mov rax, [rbp+var_10]
movzx eax, word ptr [rax+74h]
and eax, 20h
cmp eax, 0
jnz short loc_3DDCD
movsx eax, [rbp+arg_0]
cmp eax, 0
jz short loc_3DDCD
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call link_to_changed_list
loc_3DDCD:
mov rax, [rbp+var_10]
movzx ecx, word ptr [rax+74h]
and ecx, 0FFFFFFBFh
mov [rax+74h], cx
jmp short $+2
loc_3DDDE:
jmp short $+2
loc_3DDE0:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
mov ecx, [rbp+var_18]
movsx r8d, [rbp+arg_8]
call make_lock_and_pin
cmp al, 0
jz short loc_3DE02
jmp short $+2
loc_3DDFE:
jmp short $+2
loc_3DE00:
jmp short $+2
loc_3DE02:
cmp [rbp+var_18], 0
jz short loc_3DE1A
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, 1
call unreg_request
loc_3DE1A:
mov rdi, [rbp+var_8]
call dec_counter_for_resize_op
mov rdi, [rbp+var_8]
add rdi, 0C8h
call inline_mysql_mutex_unlock_0
jmp short $+2
loc_3DE35:
add rsp, 30h
pop rbp
retn
|
long long pagecache_unlock_by_link(
_QWORD *a1,
long long a2,
int a3,
int a4,
long long a5,
long long a6,
char a7,
char a8)
{
inline_mysql_mutex_lock_0(
(long long)(a1 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xD47u);
if ( a4 == 1 && a3 == 5 )
{
make_lock_and_pin((long long)a1, a2, 5, 1, 0);
return inline_mysql_mutex_unlock_0((long long)(a1 + 25));
}
else
{
inc_counter_for_resize_op((long long)a1);
if ( a7 )
{
if ( a5 )
pagecache_set_block_rec_lsn(a2, a5);
if ( a6 )
check_and_set_lsn((long long)a1, a6, a2);
*(_WORD *)(a2 + 116) = *(_WORD *)(a2 + 116) & 0xFFFC | 2;
}
if ( (*(_WORD *)(a2 + 116) & 0x40) != 0 && (a3 == 6 || a3 == 7) )
{
if ( (*(_WORD *)(a2 + 116) & 0x20) == 0 && a7 )
link_to_changed_list(a1, a2);
*(_WORD *)(a2 + 116) &= ~0x40u;
}
make_lock_and_pin((long long)a1, a2, a3, a4, a8);
if ( a4 )
unreg_request(a1, a2, 1);
dec_counter_for_resize_op((long long)a1);
return inline_mysql_mutex_unlock_0((long long)(a1 + 25));
}
}
|
pagecache_unlock_by_link:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,byte ptr [RBP + 0x18]
MOV AL,byte ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x18],ECX
MOV qword ptr [RBP + -0x20],R8
MOV qword ptr [RBP + -0x28],R9
JMP 0x0013dcb6
LAB_0013dcb6:
JMP 0x0013dcb8
LAB_0013dcb8:
JMP 0x0013dcba
LAB_0013dcba:
JMP 0x0013dcbc
LAB_0013dcbc:
JMP 0x0013dcbe
LAB_0013dcbe:
JMP 0x0013dcc0
LAB_0013dcc0:
JMP 0x0013dcc2
LAB_0013dcc2:
JMP 0x0013dcc4
LAB_0013dcc4:
JMP 0x0013dcc6
LAB_0013dcc6:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
LEA RSI,[0x25348e]
MOV EDX,0xd47
CALL 0x0013ca50
CMP dword ptr [RBP + -0x18],0x1
JNZ 0x0013dd23
CMP dword ptr [RBP + -0x14],0x5
JNZ 0x0013dd23
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x18]
XOR R8D,R8D
CALL 0x0013d810
CMP AL,0x0
JZ 0x0013dd0e
JMP 0x0013dd0a
LAB_0013dd0a:
JMP 0x0013dd0c
LAB_0013dd0c:
JMP 0x0013dd0e
LAB_0013dd0e:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
CALL 0x0013cac0
JMP 0x0013de35
LAB_0013dd23:
JMP 0x0013dd25
LAB_0013dd25:
JMP 0x0013dd27
LAB_0013dd27:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0013ce00
CMP byte ptr [RBP + 0x10],0x0
JZ 0x0013dd83
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0013dd52
JMP 0x0013dd3f
LAB_0013dd3f:
JMP 0x0013dd41
LAB_0013dd41:
JMP 0x0013dd43
LAB_0013dd43:
JMP 0x0013dd45
LAB_0013dd45:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0013d630
LAB_0013dd52:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0013dd6a
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x10]
CALL 0x0013d670
LAB_0013dd6a:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX + 0x74]
AND EAX,0xfffffffe
OR EAX,0x2
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x74],CX
LAB_0013dd83:
JMP 0x0013dd85
LAB_0013dd85:
JMP 0x0013dd87
LAB_0013dd87:
JMP 0x0013dd89
LAB_0013dd89:
JMP 0x0013dd8b
LAB_0013dd8b:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX + 0x74]
AND EAX,0x40
CMP EAX,0x0
JZ 0x0013dde0
CMP dword ptr [RBP + -0x14],0x6
JZ 0x0013dda7
CMP dword ptr [RBP + -0x14],0x7
JNZ 0x0013dde0
LAB_0013dda7:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX + 0x74]
AND EAX,0x20
CMP EAX,0x0
JNZ 0x0013ddcd
MOVSX EAX,byte ptr [RBP + 0x10]
CMP EAX,0x0
JZ 0x0013ddcd
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0013d780
LAB_0013ddcd:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,word ptr [RAX + 0x74]
AND ECX,0xffffffbf
MOV word ptr [RAX + 0x74],CX
JMP 0x0013ddde
LAB_0013ddde:
JMP 0x0013dde0
LAB_0013dde0:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x18]
MOVSX R8D,byte ptr [RBP + 0x18]
CALL 0x0013d810
CMP AL,0x0
JZ 0x0013de02
JMP 0x0013ddfe
LAB_0013ddfe:
JMP 0x0013de00
LAB_0013de00:
JMP 0x0013de02
LAB_0013de02:
CMP dword ptr [RBP + -0x18],0x0
JZ 0x0013de1a
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x1
CALL 0x0013d9b0
LAB_0013de1a:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0013db30
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
CALL 0x0013cac0
JMP 0x0013de35
LAB_0013de35:
ADD RSP,0x30
POP RBP
RET
|
void pagecache_unlock_by_link
(long param_1,long param_2,int param_3,int param_4,long param_5,long param_6,
char param_7,char param_8)
{
inline_mysql_mutex_lock
(param_1 + 200,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xd47);
if ((param_4 == 1) && (param_3 == 5)) {
make_lock_and_pin(param_1,param_2,5,1,0);
inline_mysql_mutex_unlock(param_1 + 200);
}
else {
inc_counter_for_resize_op(param_1);
if (param_7 != '\0') {
if (param_5 != 0) {
pagecache_set_block_rec_lsn(param_2,param_5);
}
if (param_6 != 0) {
check_and_set_lsn(param_1,param_6,param_2);
}
*(ushort *)(param_2 + 0x74) = *(ushort *)(param_2 + 0x74) & 0xfffe | 2;
}
if (((*(ushort *)(param_2 + 0x74) & 0x40) != 0) && ((param_3 == 6 || (param_3 == 7)))) {
if (((*(ushort *)(param_2 + 0x74) & 0x20) == 0) && (param_7 != '\0')) {
link_to_changed_list(param_1,param_2);
}
*(ushort *)(param_2 + 0x74) = *(ushort *)(param_2 + 0x74) & 0xffbf;
}
make_lock_and_pin(param_1,param_2,param_3,param_4,(int)param_8);
if (param_4 != 0) {
unreg_request(param_1,param_2,1);
}
dec_counter_for_resize_op(param_1);
inline_mysql_mutex_unlock(param_1 + 200);
}
return;
}
|
|
17,296
|
mysql_stmt_reset_start
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
int STDCALL
mysql_stmt_reset_start(my_bool *ret, MYSQL_STMT *stmt)
{
MK_ASYNC_START_BODY(
mysql_stmt_reset,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
},
TRUE,
r_my_bool,
/* If stmt->mysql==NULL then we will not block so can call directly. */
if (!stmt->mysql)
{
*ret= mysql_stmt_reset(stmt);
return 0;
})
}
|
O3
|
c
|
mysql_stmt_reset_start:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x2c9c2
movq 0x480(%rax), %rax
movq 0x28(%rax), %r15
leaq -0x20(%rbp), %rdx
movq %r14, (%rdx)
movb $0x1, 0x14(%r15)
leaq 0x38(%r15), %rdi
leaq 0x9f(%rip), %rsi # 0x2ca47
callq 0x2da54
movw $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x2c9cc
movb $0x1, 0x15(%r15)
movl (%r15), %eax
jmp 0x2ca3c
movq %r14, %rdi
callq 0x2214c
jmp 0x2ca38
js 0x2c9d4
movb 0x8(%r15), %al
jmp 0x2ca38
movq 0x38(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1c0ce(%rip), %rax # 0x48ac0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x1c0b3(%rip), %rax # 0x48ad0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, %al
movb %al, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
mysql_stmt_reset_start:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+38h]
test rax, rax
jz short loc_2C9C2
mov rax, [rax+480h]
mov r15, [rax+28h]
lea rdx, [rbp+var_20]
mov [rdx], r14
mov byte ptr [r15+14h], 1
lea rdi, [r15+38h]
lea rsi, mysql_stmt_reset_start_internal
call my_context_spawn
mov word ptr [r15+14h], 0
test eax, eax
jle short loc_2C9CC
mov byte ptr [r15+15h], 1
mov eax, [r15]
jmp short loc_2CA3C
loc_2C9C2:
mov rdi, r14
call mysql_stmt_reset
jmp short loc_2CA38
loc_2C9CC:
js short loc_2C9D4
mov al, [r15+8]
jmp short loc_2CA38
loc_2C9D4:
mov rax, [r14+38h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov al, 1
loc_2CA38:
mov [rbx], al
xor eax, eax
loc_2CA3C:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long mysql_stmt_reset_start(char *a1, long long a2)
{
long long v2; // rax
long long v3; // rax
_BYTE *v4; // r15
int v5; // eax
char v7; // al
long long v8[4]; // [rsp+0h] [rbp-20h] BYREF
v8[0] = v2;
v3 = *(_QWORD *)(a2 + 56);
if ( v3 )
{
v4 = *(_BYTE **)(*(_QWORD *)(v3 + 1152) + 40LL);
v8[0] = a2;
v4[20] = 1;
v5 = my_context_spawn(v4 + 56, mysql_stmt_reset_start_internal, v8);
*((_WORD *)v4 + 10) = 0;
if ( v5 > 0 )
{
v4[21] = 1;
return *(unsigned int *)v4;
}
if ( v5 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
v7 = 1;
}
else
{
v7 = v4[8];
}
}
else
{
v7 = mysql_stmt_reset(a2);
}
*a1 = v7;
return 0LL;
}
|
mysql_stmt_reset_start:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x38]
TEST RAX,RAX
JZ 0x0012c9c2
MOV RAX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RAX + 0x28]
LEA RDX,[RBP + -0x20]
MOV qword ptr [RDX],R14
MOV byte ptr [R15 + 0x14],0x1
LEA RDI,[R15 + 0x38]
LEA RSI,[0x12ca47]
CALL 0x0012da54
MOV word ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x0012c9cc
MOV byte ptr [R15 + 0x15],0x1
MOV EAX,dword ptr [R15]
JMP 0x0012ca3c
LAB_0012c9c2:
MOV RDI,R14
CALL 0x0012214c
JMP 0x0012ca38
LAB_0012c9cc:
JS 0x0012c9d4
MOV AL,byte ptr [R15 + 0x8]
JMP 0x0012ca38
LAB_0012c9d4:
MOV RAX,qword ptr [R14 + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x148ac0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x148ad0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV AL,0x1
LAB_0012ca38:
MOV byte ptr [RBX],AL
XOR EAX,EAX
LAB_0012ca3c:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_stmt_reset_start(int1 *param_1,long param_2)
{
int4 *puVar1;
int1 uVar2;
int iVar3;
if (*(long *)(param_2 + 0x38) == 0) {
uVar2 = mysql_stmt_reset(param_2);
}
else {
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(puVar1 + 5) = 1;
iVar3 = my_context_spawn(puVar1 + 0xe,mysql_stmt_reset_start_internal);
*(int2 *)(puVar1 + 5) = 0;
if (0 < iVar3) {
*(int1 *)((long)puVar1 + 0x15) = 1;
return *puVar1;
}
if (iVar3 < 0) {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_00148b10,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
uVar2 = 1;
}
else {
uVar2 = *(int1 *)(puVar1 + 2);
}
}
*param_1 = uVar2;
return 0;
}
|
|
17,297
|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key() const
|
llama.cpp/common/json.hpp
|
const typename object_t::key_type& key() const
{
JSON_ASSERT(m_object != nullptr);
if (JSON_HEDLEY_LIKELY(m_object->is_object()))
{
return m_it.object_iterator->first;
}
JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xc3035
movq %rdi, %r14
cmpb $0x1, (%rax)
jne 0xc2fd7
movq 0x8(%r14), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x20650
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x57e8b(%rip), %rsi # 0x11ae7f
leaq 0x57ead(%rip), %rdx # 0x11aea8
leaq 0x8(%rsp), %rdi
callq 0x288ec
movq (%r14), %rcx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcf, %esi
callq 0x8a58e
xorl %ebp, %ebp
leaq 0x9cfda(%rip), %rsi # 0x160000
leaq -0x4c6d5(%rip), %rdx # 0x76958
movq %rbx, %rdi
callq 0x20a50
leaq 0x5659c(%rip), %rdi # 0x1195d8
leaq 0x565d0(%rip), %rdx # 0x119613
leaq 0x5c8ee(%rip), %rcx # 0x11f938
movl $0x3519, %esi # imm = 0x3519
xorl %eax, %eax
callq 0x20e60
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xc3070
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
testb %bpl, %bpl
jne 0xc307a
jmp 0xc3082
movq %rax, %r14
movq %rbx, %rdi
callq 0x20ef0
movq %r14, %rdi
callq 0x20af0
|
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyEv:
push rbp; void *
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov rax, [rdi]
test rax, rax
jz short loc_C3035
mov r14, rdi
cmp byte ptr [rax], 1
jnz short loc_C2FD7
mov rax, [r14+8]
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_C2FD7:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aCannotUseKeyFo; "cannot use key() for non-object iterato"...
lea rdx, aCannotUseKeyFo+29h; ""
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rcx, [r14]
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 0CFh; int
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_C3035:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 3519h
xor eax, eax
call _ggml_abort
mov r14, rax
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_C3070
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C3070:
test bpl, bpl
jnz short loc_C307A
jmp short loc_C3082
mov r14, rax
loc_C307A:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_C3082:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::key(
_QWORD *a1)
{
void *v1; // rbx
char v2; // bp
void *v3; // r15
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
long long v6; // rax
long long v7; // r14
void *v8[2]; // [rsp+8h] [rbp-40h] BYREF
long long v9; // [rsp+18h] [rbp-30h] BYREF
if ( !*a1 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
13593LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
v7 = v6;
if ( v8[0] != v3 )
operator delete(v8[0], v9 + 1);
if ( v2 )
__cxa_free_exception(v1);
_Unwind_Resume(v7);
}
if ( *(_BYTE *)*a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v8[0] = &v9;
std::string::_M_construct<char const*>((long long)v8, "cannot use key() for non-object iterators", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
207,
v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return a1[1];
}
|
key:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001c3035
MOV R14,RDI
CMP byte ptr [RAX],0x1
JNZ 0x001c2fd7
MOV RAX,qword ptr [R14 + 0x8]
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001c2fd7:
MOV EDI,0x20
CALL 0x00120650
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_001c2fed:
LEA RSI,[0x21ae7f]
LEA RDX,[0x21aea8]
LEA RDI,[RSP + 0x8]
CALL 0x001288ec
MOV RCX,qword ptr [R14]
MOV BPL,0x1
LAB_001c300b:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xcf
CALL 0x0018a58e
XOR EBP,EBP
LEA RSI,[0x260000]
LEA RDX,[0x176958]
MOV RDI,RBX
CALL 0x00120a50
LAB_001c3035:
LEA RDI,[0x2195d8]
LEA RDX,[0x219613]
LEA RCX,[0x21f938]
MOV ESI,0x3519
XOR EAX,EAX
CALL 0x00120e60
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::key() const */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::key(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
int8 uVar1;
int1 *local_40 [2];
int1 local_30 [16];
if (*(char **)this == (char *)0x0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x3519,
"GGML_ASSERT(%s) failed","m_object != nullptr");
}
if (**(char **)this == '\x01') {
return *(int8 *)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40[0] = local_30;
/* try { // try from 001c2fed to 001c3004 has its CatchHandler @ 001c3077 */
std::__cxx11::string::_M_construct<char_const*>
(local_40,"cannot use key() for non-object iterators","");
/* try { // try from 001c300b to 001c3034 has its CatchHandler @ 001c3056 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0xcf,local_40,*(int8 *)this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&invalid_iterator::typeinfo,exception::~exception);
}
|
|
17,298
|
my_error
|
eloqsql/mysys/my_error.c
|
void my_error(uint nr, myf MyFlags, ...)
{
const char *format;
va_list args;
char ebuff[ERRMSGSIZE];
DBUG_ENTER("my_error");
DBUG_PRINT("my", ("nr: %d MyFlags: %lu errno: %d", nr, MyFlags, errno));
if (!(format = my_get_err_msg(nr)))
(void) my_snprintf(ebuff, sizeof(ebuff), "Unknown error %d", nr);
else
{
va_start(args,MyFlags);
(void) my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, ebuff,
sizeof(ebuff), format, args);
va_end(args);
}
(*error_handler_hook)(nr, ebuff, MyFlags);
DBUG_VOID_RETURN;
}
|
O3
|
c
|
my_error:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x2e0, %rsp # imm = 0x2E0
movq %rsi, %rbx
movl %edi, %r14d
movq %rdx, -0x2e0(%rbp)
movq %rcx, -0x2d8(%rbp)
movq %r8, -0x2d0(%rbp)
movq %r9, -0x2c8(%rbp)
testb %al, %al
je 0x2acf3
movaps %xmm0, -0x2c0(%rbp)
movaps %xmm1, -0x2b0(%rbp)
movaps %xmm2, -0x2a0(%rbp)
movaps %xmm3, -0x290(%rbp)
movaps %xmm4, -0x280(%rbp)
movaps %xmm5, -0x270(%rbp)
movaps %xmm6, -0x260(%rbp)
movaps %xmm7, -0x250(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
callq 0x2ac3c
testq %rax, %rax
je 0x2ad4e
leaq -0x2f0(%rbp), %rcx
leaq -0x240(%rbp), %r8
movq %rcx, 0x10(%r8)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%r8)
movabsq $0x3000000010, %rcx # imm = 0x3000000010
movq %rcx, (%r8)
leaq 0x337b78(%rip), %rdi # 0x3628b0
leaq -0x220(%rbp), %rsi
movl $0x200, %edx # imm = 0x200
movq %rax, %rcx
callq 0x59134
jmp 0x2ad6b
leaq 0x32462(%rip), %rdx # 0x5d1b7
leaq -0x220(%rbp), %rdi
movl $0x200, %esi # imm = 0x200
movl %r14d, %ecx
xorl %eax, %eax
callq 0x5a316
leaq 0x2c460e(%rip), %rax # 0x2ef380
leaq -0x220(%rbp), %rsi
movl %r14d, %edi
movq %rbx, %rdx
callq *(%rax)
movq %fs:0x28, %rax
cmpq -0x18(%rbp), %rax
jne 0x2ad9c
addq $0x2e0, %rsp # imm = 0x2E0
popq %rbx
popq %r14
popq %rbp
retq
callq 0x24390
|
my_error:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 2E0h
mov rbx, rsi
mov r14d, edi
mov [rbp+var_2E0], rdx
mov [rbp+var_2D8], rcx
mov [rbp+var_2D0], r8
mov [rbp+var_2C8], r9
test al, al
jz short loc_2ACF3
movaps [rbp+var_2C0], xmm0
movaps [rbp+var_2B0], xmm1
movaps [rbp+var_2A0], xmm2
movaps [rbp+var_290], xmm3
movaps [rbp+var_280], xmm4
movaps [rbp+var_270], xmm5
movaps [rbp+var_260], xmm6
movaps [rbp+var_250], xmm7
loc_2ACF3:
mov rax, fs:28h
mov [rbp+var_18], rax
call my_get_err_msg
test rax, rax
jz short loc_2AD4E
lea rcx, [rbp+var_2F0]
lea r8, [rbp+var_240]
mov [r8+10h], rcx
lea rcx, [rbp+arg_0]
mov [r8+8], rcx
mov rcx, 3000000010h
mov [r8], rcx
lea rdi, my_charset_utf8mb3_general_ci
lea rsi, [rbp+var_220]
mov edx, 200h
mov rcx, rax
call my_vsnprintf_ex
jmp short loc_2AD6B
loc_2AD4E:
lea rdx, aUnknownErrorD; "Unknown error %d"
lea rdi, [rbp+var_220]
mov esi, 200h
mov ecx, r14d
xor eax, eax
call my_snprintf
loc_2AD6B:
lea rax, error_handler_hook
lea rsi, [rbp+var_220]
mov edi, r14d
mov rdx, rbx
call qword ptr [rax]
mov rax, fs:28h
cmp rax, [rbp+var_18]
jnz short loc_2AD9C
add rsp, 2E0h
pop rbx
pop r14
pop rbp
retn
loc_2AD9C:
call ___stack_chk_fail
|
unsigned long long my_error(unsigned int a1, __int16 a2, ...)
{
_BYTE *err_msg; // rax
int v3; // r8d
int v4; // r9d
va_list va; // [rsp+B0h] [rbp-240h] BYREF
_BYTE v7[520]; // [rsp+D0h] [rbp-220h] BYREF
unsigned long long v8; // [rsp+2D8h] [rbp-18h]
va_start(va, a2);
va_arg(va, _QWORD);
va_arg(va, _QWORD);
va_arg(va, _QWORD);
va_arg(va, _QWORD);
va_end(va);
v8 = __readfsqword(0x28u);
err_msg = my_get_err_msg(a1);
if ( err_msg )
{
va_start(va, a2);
my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, v7, 512LL, err_msg, va);
}
else
{
my_snprintf((unsigned int)v7, 512, (unsigned int)"Unknown error %d", a1, v3, v4);
}
error_handler_hook(a1, (long long)v7, a2);
return __readfsqword(0x28u);
}
|
my_error:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x2e0
MOV RBX,RSI
MOV R14D,EDI
MOV qword ptr [RBP + -0x2e0],RDX
MOV qword ptr [RBP + -0x2d8],RCX
MOV qword ptr [RBP + -0x2d0],R8
MOV qword ptr [RBP + -0x2c8],R9
TEST AL,AL
JZ 0x0012acf3
MOVAPS xmmword ptr [RBP + -0x2c0],XMM0
MOVAPS xmmword ptr [RBP + -0x2b0],XMM1
MOVAPS xmmword ptr [RBP + -0x2a0],XMM2
MOVAPS xmmword ptr [RBP + -0x290],XMM3
MOVAPS xmmword ptr [RBP + -0x280],XMM4
MOVAPS xmmword ptr [RBP + -0x270],XMM5
MOVAPS xmmword ptr [RBP + -0x260],XMM6
MOVAPS xmmword ptr [RBP + -0x250],XMM7
LAB_0012acf3:
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
CALL 0x0012ac3c
TEST RAX,RAX
JZ 0x0012ad4e
LEA RCX,[RBP + -0x2f0]
LEA R8,[RBP + -0x240]
MOV qword ptr [R8 + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [R8 + 0x8],RCX
MOV RCX,0x3000000010
MOV qword ptr [R8],RCX
LEA RDI,[0x4628b0]
LEA RSI,[RBP + -0x220]
MOV EDX,0x200
MOV RCX,RAX
CALL 0x00159134
JMP 0x0012ad6b
LAB_0012ad4e:
LEA RDX,[0x15d1b7]
LEA RDI,[RBP + -0x220]
MOV ESI,0x200
MOV ECX,R14D
XOR EAX,EAX
CALL 0x0015a316
LAB_0012ad6b:
LEA RAX,[0x3ef380]
LEA RSI,[RBP + -0x220]
MOV EDI,R14D
MOV RDX,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x0012ad9c
ADD RSP,0x2e0
POP RBX
POP R14
POP RBP
RET
LAB_0012ad9c:
CALL 0x00124390
|
void my_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
long lVar1;
long in_FS_OFFSET;
int1 local_2f8 [16];
int8 local_2e8;
int8 local_2e0;
int8 local_2d8;
int8 local_2d0;
int8 local_2c8;
int8 local_2b8;
int8 local_2a8;
int8 local_298;
int8 local_288;
int8 local_278;
int8 local_268;
int8 local_258;
int8 local_248;
int1 *local_240;
int1 *local_238;
int1 local_228 [520];
long local_20;
if (in_AL != '\0') {
local_2c8 = param_1;
local_2b8 = param_2;
local_2a8 = param_3;
local_298 = param_4;
local_288 = param_5;
local_278 = param_6;
local_268 = param_7;
local_258 = param_8;
}
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_2e8 = param_11;
local_2e0 = param_12;
local_2d8 = param_13;
local_2d0 = param_14;
lVar1 = my_get_err_msg();
if (lVar1 == 0) {
my_snprintf(local_228,0x200,"Unknown error %d",param_9);
}
else {
local_238 = local_2f8;
local_240 = &stack0x00000008;
local_248 = 0x3000000010;
my_vsnprintf_ex(my_charset_utf8mb3_general_ci,local_228,0x200,lVar1);
}
(*(code *)error_handler_hook)(param_9,local_228,param_10);
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
17,299
|
js_inner_module_linking
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_inner_module_linking(JSContext *ctx, JSModuleDef *m,
JSModuleDef **pstack_top, int index)
{
int i;
JSImportEntry *mi;
JSModuleDef *m1;
JSVarRef **var_refs, *var_ref;
JSObject *p;
BOOL is_c_module;
JSValue ret_val;
if (js_check_stack_overflow(ctx->rt, 0)) {
JS_ThrowStackOverflow(ctx);
return -1;
}
#ifdef DUMP_MODULE_RESOLVE
if (check_dump_flag(ctx->rt, DUMP_MODULE_RESOLVE)) {
char buf1[ATOM_GET_STR_BUF_SIZE];
printf("js_inner_module_linking '%s':\n", JS_AtomGetStr(ctx, buf1, sizeof(buf1), m->module_name));
}
#endif
if (m->status == JS_MODULE_STATUS_LINKING ||
m->status == JS_MODULE_STATUS_LINKED ||
m->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
m->status == JS_MODULE_STATUS_EVALUATED)
return index;
assert(m->status == JS_MODULE_STATUS_UNLINKED);
m->status = JS_MODULE_STATUS_LINKING;
m->dfs_index = index;
m->dfs_ancestor_index = index;
index++;
/* push 'm' on stack */
m->stack_prev = *pstack_top;
*pstack_top = m;
for(i = 0; i < m->req_module_entries_count; i++) {
JSReqModuleEntry *rme = &m->req_module_entries[i];
m1 = rme->module;
index = js_inner_module_linking(ctx, m1, pstack_top, index);
if (index < 0)
goto fail;
assert(m1->status == JS_MODULE_STATUS_LINKING ||
m1->status == JS_MODULE_STATUS_LINKED ||
m1->status == JS_MODULE_STATUS_EVALUATING_ASYNC ||
m1->status == JS_MODULE_STATUS_EVALUATED);
if (m1->status == JS_MODULE_STATUS_LINKING) {
m->dfs_ancestor_index = min_int(m->dfs_ancestor_index,
m1->dfs_ancestor_index);
}
}
#ifdef DUMP_MODULE_RESOLVE
if (check_dump_flag(ctx->rt, DUMP_MODULE_RESOLVE)) {
char buf1[ATOM_GET_STR_BUF_SIZE];
printf("instantiating module '%s':\n", JS_AtomGetStr(ctx, buf1, sizeof(buf1), m->module_name));
}
#endif
/* check the indirect exports */
for(i = 0; i < m->export_entries_count; i++) {
JSExportEntry *me = &m->export_entries[i];
if (me->export_type == JS_EXPORT_TYPE_INDIRECT &&
me->local_name != JS_ATOM__star_) {
JSResolveResultEnum ret;
JSExportEntry *res_me;
JSModuleDef *res_m, *m1;
m1 = m->req_module_entries[me->u.req_module_idx].module;
ret = js_resolve_export(ctx, &res_m, &res_me, m1, me->local_name);
if (ret != JS_RESOLVE_RES_FOUND) {
js_resolve_export_throw_error(ctx, ret, m, me->export_name);
goto fail;
}
}
}
#ifdef DUMP_MODULE_RESOLVE
if (check_dump_flag(ctx->rt, DUMP_MODULE_RESOLVE)) {
printf("exported bindings:\n");
for(i = 0; i < m->export_entries_count; i++) {
JSExportEntry *me = &m->export_entries[i];
printf(" name="); print_atom(ctx, me->export_name);
printf(" local="); print_atom(ctx, me->local_name);
printf(" type=%d idx=%d\n", me->export_type, me->u.local.var_idx);
}
}
#endif
is_c_module = (m->init_func != NULL);
if (!is_c_module) {
p = JS_VALUE_GET_OBJ(m->func_obj);
var_refs = p->u.func.var_refs;
for(i = 0; i < m->import_entries_count; i++) {
mi = &m->import_entries[i];
#ifdef DUMP_MODULE_RESOLVE
if (check_dump_flag(ctx->rt, DUMP_MODULE_RESOLVE)) {
printf("import var_idx=%d name=", mi->var_idx);
print_atom(ctx, mi->import_name);
printf(": ");
}
#endif
m1 = m->req_module_entries[mi->req_module_idx].module;
if (mi->import_name == JS_ATOM__star_) {
JSValue val;
/* name space import */
val = JS_GetModuleNamespace(ctx, m1);
if (JS_IsException(val))
goto fail;
set_value(ctx, &var_refs[mi->var_idx]->value, val);
module_trace(ctx, "namespace\n");
} else {
JSResolveResultEnum ret;
JSExportEntry *res_me;
JSModuleDef *res_m;
JSObject *p1;
ret = js_resolve_export(ctx, &res_m,
&res_me, m1, mi->import_name);
if (ret != JS_RESOLVE_RES_FOUND) {
js_resolve_export_throw_error(ctx, ret, m1, mi->import_name);
goto fail;
}
if (res_me->local_name == JS_ATOM__star_) {
JSValue val;
JSModuleDef *m2;
/* name space import from */
m2 = res_m->req_module_entries[res_me->u.req_module_idx].module;
val = JS_GetModuleNamespace(ctx, m2);
if (JS_IsException(val))
goto fail;
var_ref = js_create_module_var(ctx, TRUE);
if (!var_ref) {
JS_FreeValue(ctx, val);
goto fail;
}
set_value(ctx, &var_ref->value, val);
var_refs[mi->var_idx] = var_ref;
module_trace(ctx, "namespace from\n");
} else {
var_ref = res_me->u.local.var_ref;
if (!var_ref) {
p1 = JS_VALUE_GET_OBJ(res_m->func_obj);
var_ref = p1->u.func.var_refs[res_me->u.local.var_idx];
}
var_ref->header.ref_count++;
var_refs[mi->var_idx] = var_ref;
module_trace(ctx, "local export (var_ref=%p)\n", var_ref);
}
}
}
/* keep the exported variables in the module export entries (they
are used when the eval function is deleted and cannot be
initialized before in case imports are exported) */
for(i = 0; i < m->export_entries_count; i++) {
JSExportEntry *me = &m->export_entries[i];
if (me->export_type == JS_EXPORT_TYPE_LOCAL) {
var_ref = var_refs[me->u.local.var_idx];
var_ref->header.ref_count++;
me->u.local.var_ref = var_ref;
}
}
/* initialize the global variables */
ret_val = JS_Call(ctx, m->func_obj, JS_TRUE, 0, NULL);
if (JS_IsException(ret_val))
goto fail;
JS_FreeValue(ctx, ret_val);
}
assert(m->dfs_ancestor_index <= m->dfs_index);
if (m->dfs_index == m->dfs_ancestor_index) {
for(;;) {
/* pop m1 from stack */
m1 = *pstack_top;
*pstack_top = m1->stack_prev;
m1->status = JS_MODULE_STATUS_LINKED;
if (m1 == m)
break;
}
}
#ifdef DUMP_MODULE_RESOLVE
if (check_dump_flag(ctx->rt, DUMP_MODULE_RESOLVE)) {
printf("js_inner_module_linking done\n");
}
#endif
return index;
fail:
return -1;
}
|
O1
|
c
|
js_inner_module_linking:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0x18(%rdi), %rax
cmpq %rbp, 0xe8(%rax)
jbe 0x486ac
leaq 0x5abb0(%rip), %rsi # 0xa324e
xorl %eax, %eax
callq 0x24b39
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x486cf
movl %ecx, %r8d
movq %rsi, %r15
movl 0x80(%rsi), %eax
movl %eax, %ecx
shrl $0x18, %ecx
cmpl $0x5, %ecx
ja 0x486de
movl $0x36, %esi
btl %ecx, %esi
jae 0x486de
movl %r8d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, -0x30(%rbp)
andl $0xffffff, %eax # imm = 0xFFFFFF
orl $0x1000000, %eax # imm = 0x1000000
movl %eax, 0x80(%r15)
movl %r8d, 0x84(%r15)
movl %r8d, 0x88(%r15)
incl %r8d
movq (%rdx), %rax
movq %rax, 0x90(%r15)
movq %r15, (%rdx)
cmpl $0x0, 0x20(%r15)
jle 0x48791
movl $0x8, %r14d
xorl %r12d, %r12d
movq 0x18(%r15), %rax
movq (%rax,%r14), %r13
movq -0x30(%rbp), %rdi
movq %r13, %rsi
movq %rdx, %rbx
movl %r8d, %ecx
callq 0x48679
movl %eax, %r8d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %r8d, %r8d
js 0x486cf
movzbl 0x83(%r13), %ecx
shll $0x18, %ecx
cmpl $0x1000000, %ecx # imm = 0x1000000
jne 0x48775
movl 0x88(%r15), %ecx
movl 0x88(%r13), %edx
cmpl %edx, %ecx
cmovll %ecx, %edx
movl %edx, 0x88(%r15)
testl %r8d, %r8d
js 0x486cf
movq %rbx, %rdx
incq %r12
movslq 0x20(%r15), %rax
addq $0x10, %r14
cmpq %rax, %r12
jl 0x48721
movl %r8d, -0x34(%rbp)
movq %rdx, -0x70(%rbp)
cmpl $0x0, 0x30(%r15)
jle 0x4882b
movl $0x18, %r14d
xorl %r12d, %r12d
movq 0x28(%r15), %r13
cmpl $0x1, -0x8(%r13,%r14)
jne 0x48811
movl -0x4(%r13,%r14), %r8d
cmpl $0x7e, %r8d
je 0x48811
movq 0x18(%r15), %rax
movslq -0x18(%r13,%r14), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rcx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x477da
testl %eax, %eax
je 0x4880b
movl (%r13,%r14), %ecx
movq %rbx, %rdi
movl %eax, %ebx
movl %eax, %esi
movq %r15, %rdx
callq 0x47845
movl %ebx, %eax
movl $0x5, %ecx
jmp 0x4880d
xorl %ecx, %ecx
testl %eax, %eax
jne 0x48813
xorl %ecx, %ecx
testl %ecx, %ecx
jne 0x486a5
incq %r12
movslq 0x30(%r15), %rax
addq $0x20, %r14
cmpq %rax, %r12
jl 0x487ad
cmpq $0x0, 0x78(%r15)
je 0x48871
movl 0x84(%r15), %eax
cmpl 0x88(%r15), %eax
movq -0x70(%rbp), %rdx
jne 0x48869
movl -0x34(%rbp), %esi
movq (%rdx), %rax
movq 0x90(%rax), %rcx
movq %rcx, (%rdx)
movb $0x2, 0x83(%rax)
cmpq %r15, %rax
jne 0x48849
movl %esi, %eax
jmp 0x486cf
movl -0x34(%rbp), %eax
jmp 0x486cf
movq 0x68(%r15), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, 0x50(%r15)
movq -0x30(%rbp), %r12
jle 0x48a32
xorl %r14d, %r14d
xorl %ecx, %ecx
movq %rcx, -0x48(%rbp)
movq 0x18(%r15), %rax
movq 0x48(%r15), %rdx
movslq 0x8(%rdx,%r14), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %r13
movq %rdx, %rbx
movl 0x4(%rdx,%r14), %r8d
movq %r12, %rdi
cmpl $0x7e, %r8d
jne 0x488ff
movq %r13, %rsi
callq 0x34b53
cmpl $0x6, %edx
je 0x486a5
movslq (%rbx,%r14), %rcx
movq -0x40(%rbp), %rsi
movq (%rsi,%rcx,8), %rdi
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rcx
movq %rax, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq 0x18(%r12), %rdi
movq %rcx, %rdx
callq 0x21922
movq -0x48(%rbp), %rcx
jmp 0x489b0
leaq -0x50(%rbp), %rsi
leaq -0x68(%rbp), %rdx
movq %r13, %rcx
callq 0x477da
testl %eax, %eax
je 0x48931
movl 0x4(%rbx,%r14), %ecx
movq %r12, %rdi
movl %eax, %esi
movq %r13, %rdx
callq 0x47845
movl $0x5, %r12d
movq -0x48(%rbp), %rcx
jmp 0x489a3
movq -0x68(%rbp), %rax
cmpl $0x7e, 0x14(%rax)
jne 0x48972
movq -0x50(%rbp), %rcx
movq 0x18(%rcx), %rcx
movslq (%rax), %rax
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rsi
movq %r12, %rdi
callq 0x34b53
movq %rdx, %r13
movl $0x5, %r12d
cmpl $0x6, %r13d
jne 0x489c6
xorl %eax, %eax
testb %al, %al
movq -0x48(%rbp), %rcx
jne 0x489a0
jmp 0x489a3
movq 0x8(%rax), %rcx
testq %rcx, %rcx
jne 0x4898e
movq -0x50(%rbp), %rcx
movq 0x68(%rcx), %rcx
movq 0x38(%rcx), %rcx
movslq (%rax), %rax
movq (%rcx,%rax,8), %rcx
incl (%rcx)
movslq (%rbx,%r14), %rax
movq -0x40(%rbp), %rdx
movq %rcx, (%rdx,%rax,8)
movq -0x48(%rbp), %rcx
xorl %r12d, %r12d
testl %r12d, %r12d
movq -0x30(%rbp), %r12
jne 0x486a5
incq %rcx
movslq 0x50(%r15), %rax
addq $0xc, %r14
cmpq %rax, %rcx
jl 0x48891
jmp 0x48a32
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x112d7
testq %rax, %rax
je 0x48a19
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %rax, %r12
movq -0x58(%rbp), %rax
movq %rax, 0x20(%r12)
movq %r13, 0x28(%r12)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x21922
movslq (%rbx,%r14), %rax
movq -0x40(%rbp), %rcx
movq %r12, (%rcx,%rax,8)
xorl %r12d, %r12d
movb $0x1, %al
jmp 0x48968
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x58(%rbp), %rsi
movq %r13, %rdx
callq 0x21922
jmp 0x48966
cmpl $0x0, 0x30(%r15)
jle 0x48a6e
movl $0x10, %eax
xorl %ecx, %ecx
movq -0x40(%rbp), %rdi
movq 0x28(%r15), %rdx
cmpl $0x0, (%rdx,%rax)
jne 0x48a5e
movslq -0x10(%rdx,%rax), %rsi
movq (%rdi,%rsi,8), %rsi
incl (%rsi)
movq %rsi, -0x8(%rdx,%rax)
incq %rcx
movslq 0x30(%r15), %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jl 0x48a44
movq 0x68(%r15), %rsi
movq 0x70(%r15), %rdx
movl $0x0, -0x68(%rbp)
movq $0x3, -0x60(%rbp)
movups -0x68(%rbp), %xmm0
movups %xmm0, (%rsp)
movl $0x2, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x1, %ecx
movl $0x1, %r8d
movq %r12, %rdi
xorl %r9d, %r9d
callq 0x2c526
movq %rax, %rsi
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x6, %edx
je 0x486cf
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x21922
jmp 0x48832
|
js_inner_module_linking:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rax, [rdi+18h]
cmp [rax+0E8h], rbp
jbe short loc_486AC
lea rsi, aMaximumCallSta; "Maximum call stack size exceeded"
xor eax, eax
call JS_ThrowRangeError
loc_486A5:
mov eax, 0FFFFFFFFh
jmp short loc_486CF
loc_486AC:
mov r8d, ecx
mov r15, rsi
mov eax, [rsi+80h]
mov ecx, eax
shr ecx, 18h
cmp ecx, 5
ja short loc_486DE
mov esi, 36h ; '6'
bt esi, ecx
jnb short loc_486DE
mov eax, r8d
loc_486CF:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_486DE:
mov [rbp+var_30], rdi
and eax, 0FFFFFFh
or eax, 1000000h
mov [r15+80h], eax
mov [r15+84h], r8d
mov [r15+88h], r8d
inc r8d
mov rax, [rdx]
mov [r15+90h], rax
mov [rdx], r15
cmp dword ptr [r15+20h], 0
jle short loc_48791
mov r14d, 8
xor r12d, r12d
loc_48721:
mov rax, [r15+18h]
mov r13, [rax+r14]
mov rdi, [rbp+var_30]
mov rsi, r13
mov rbx, rdx
mov ecx, r8d
call js_inner_module_linking
mov r8d, eax
mov eax, 0FFFFFFFFh
test r8d, r8d
js short loc_486CF
movzx ecx, byte ptr [r13+83h]
shl ecx, 18h
cmp ecx, 1000000h
jnz short loc_48775
mov ecx, [r15+88h]
mov edx, [r13+88h]
cmp ecx, edx
cmovl edx, ecx
mov [r15+88h], edx
loc_48775:
test r8d, r8d
js loc_486CF
mov rdx, rbx
inc r12
movsxd rax, dword ptr [r15+20h]
add r14, 10h
cmp r12, rax
jl short loc_48721
loc_48791:
mov [rbp+var_34], r8d
mov [rbp+var_70], rdx
cmp dword ptr [r15+30h], 0
jle loc_4882B
mov r14d, 18h
xor r12d, r12d
loc_487AD:
mov r13, [r15+28h]
cmp dword ptr [r13+r14-8], 1
jnz short loc_48811
mov r8d, [r13+r14-4]
cmp r8d, 7Eh ; '~'
jz short loc_48811
mov rax, [r15+18h]
movsxd rcx, dword ptr [r13+r14-18h]
shl rcx, 4
mov rcx, [rax+rcx+8]
mov rbx, [rbp+var_30]
mov rdi, rbx
lea rsi, [rbp+var_50]
lea rdx, [rbp+var_68]
call js_resolve_export
test eax, eax
jz short loc_4880B
mov ecx, [r13+r14+0]
mov rdi, rbx
mov ebx, eax
mov esi, eax
mov rdx, r15
call js_resolve_export_throw_error
mov eax, ebx
mov ecx, 5
jmp short loc_4880D
loc_4880B:
xor ecx, ecx
loc_4880D:
test eax, eax
jnz short loc_48813
loc_48811:
xor ecx, ecx
loc_48813:
test ecx, ecx
jnz loc_486A5
inc r12
movsxd rax, dword ptr [r15+30h]
add r14, 20h ; ' '
cmp r12, rax
jl short loc_487AD
loc_4882B:
cmp qword ptr [r15+78h], 0
jz short loc_48871
loc_48832:
mov eax, [r15+84h]
cmp eax, [r15+88h]
mov rdx, [rbp+var_70]
jnz short loc_48869
mov esi, [rbp+var_34]
loc_48849:
mov rax, [rdx]
mov rcx, [rax+90h]
mov [rdx], rcx
mov byte ptr [rax+83h], 2
cmp rax, r15
jnz short loc_48849
mov eax, esi
jmp loc_486CF
loc_48869:
mov eax, [rbp+var_34]
jmp loc_486CF
loc_48871:
mov rax, [r15+68h]
mov rax, [rax+38h]
mov [rbp+var_40], rax
cmp dword ptr [r15+50h], 0
mov r12, [rbp+var_30]
jle loc_48A32
xor r14d, r14d
xor ecx, ecx
loc_48891:
mov [rbp+var_48], rcx
mov rax, [r15+18h]
mov rdx, [r15+48h]
movsxd rcx, dword ptr [rdx+r14+8]
shl rcx, 4
mov r13, [rax+rcx+8]
mov rbx, rdx
mov r8d, [rdx+r14+4]
mov rdi, r12
cmp r8d, 7Eh ; '~'
jnz short loc_488FF
mov rsi, r13
call JS_GetModuleNamespace
cmp edx, 6
jz loc_486A5
movsxd rcx, dword ptr [rbx+r14]
mov rsi, [rbp+var_40]
mov rdi, [rsi+rcx*8]
mov rsi, [rdi+20h]
mov rcx, [rdi+28h]
mov [rdi+20h], rax
mov [rdi+28h], rdx
mov rdi, [r12+18h]
mov rdx, rcx
call JS_FreeValueRT
mov rcx, [rbp+var_48]
jmp loc_489B0
loc_488FF:
lea rsi, [rbp+var_50]
lea rdx, [rbp+var_68]
mov rcx, r13
call js_resolve_export
test eax, eax
jz short loc_48931
mov ecx, [rbx+r14+4]
mov rdi, r12
mov esi, eax
mov rdx, r13
call js_resolve_export_throw_error
mov r12d, 5
mov rcx, [rbp+var_48]
jmp short loc_489A3
loc_48931:
mov rax, qword ptr [rbp+var_68]
cmp dword ptr [rax+14h], 7Eh ; '~'
jnz short loc_48972
mov rcx, [rbp+var_50]
mov rcx, [rcx+18h]
movsxd rax, dword ptr [rax]
shl rax, 4
mov rsi, [rcx+rax+8]
mov rdi, r12
call JS_GetModuleNamespace
mov r13, rdx
mov r12d, 5
cmp r13d, 6
jnz short loc_489C6
loc_48966:
xor eax, eax
loc_48968:
test al, al
mov rcx, [rbp+var_48]
jnz short loc_489A0
jmp short loc_489A3
loc_48972:
mov rcx, [rax+8]
test rcx, rcx
jnz short loc_4898E
mov rcx, [rbp+var_50]
mov rcx, [rcx+68h]
mov rcx, [rcx+38h]
movsxd rax, dword ptr [rax]
mov rcx, [rcx+rax*8]
loc_4898E:
inc dword ptr [rcx]
movsxd rax, dword ptr [rbx+r14]
mov rdx, [rbp+var_40]
mov [rdx+rax*8], rcx
mov rcx, [rbp+var_48]
loc_489A0:
xor r12d, r12d
loc_489A3:
test r12d, r12d
mov r12, [rbp+var_30]
jnz loc_486A5
loc_489B0:
inc rcx
movsxd rax, dword ptr [r15+50h]
add r14, 0Ch
cmp rcx, rax
jl loc_48891
jmp short loc_48A32
loc_489C6:
mov [rbp+var_58], rax
mov rdi, [rbp+var_30]
mov esi, 1
call js_create_module_var
test rax, rax
jz short loc_48A19
mov rsi, [rax+20h]
mov rdx, [rax+28h]
mov r12, rax
mov rax, [rbp+var_58]
mov [r12+20h], rax
mov [r12+28h], r13
mov rax, [rbp+var_30]
mov rdi, [rax+18h]
call JS_FreeValueRT
movsxd rax, dword ptr [rbx+r14]
mov rcx, [rbp+var_40]
mov [rcx+rax*8], r12
xor r12d, r12d
mov al, 1
jmp loc_48968
loc_48A19:
mov rax, [rbp+var_30]
mov rdi, [rax+18h]
mov rsi, [rbp+var_58]
mov rdx, r13
call JS_FreeValueRT
jmp loc_48966
loc_48A32:
cmp dword ptr [r15+30h], 0
jle short loc_48A6E
mov eax, 10h
xor ecx, ecx
mov rdi, [rbp+var_40]
loc_48A44:
mov rdx, [r15+28h]
cmp dword ptr [rdx+rax], 0
jnz short loc_48A5E
movsxd rsi, dword ptr [rdx+rax-10h]
mov rsi, [rdi+rsi*8]
inc dword ptr [rsi]
mov [rdx+rax-8], rsi
loc_48A5E:
inc rcx
movsxd rdx, dword ptr [r15+30h]
add rax, 20h ; ' '
cmp rcx, rdx
jl short loc_48A44
loc_48A6E:
mov rsi, [r15+68h]
mov rdx, [r15+70h]
mov dword ptr [rbp+var_68], 0
mov qword ptr [rbp+var_68+8], 3
movups xmm0, [rbp+var_68]
movups [rsp+90h+var_90], xmm0
mov [rsp+90h+var_78], 2
mov [rsp+90h+var_80], 0
mov ecx, 1
mov r8d, 1
mov rdi, r12
xor r9d, r9d
call JS_CallInternal
mov rsi, rax
mov eax, 0FFFFFFFFh
cmp edx, 6
jz loc_486CF
mov rax, [rbp+var_30]
mov rdi, [rax+18h]
call JS_FreeValueRT
jmp loc_48832
|
long long js_inner_module_linking(
long long a1,
long long a2,
long long *a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long result; // rax
unsigned int v16; // eax
int v17; // esi
int v18; // r8d
long long v19; // r14
long long v20; // r12
long long v21; // r13
long long *v22; // rbx
int v23; // edx
long long v24; // r14
long long v25; // r12
long long v26; // r13
long long v27; // r8
long long v28; // rbx
int v29; // eax
long long v30; // rdi
int v31; // ebx
int v32; // ecx
unsigned int v33; // esi
long long v34; // rax
long long v35; // r12
long long v36; // r14
long long v37; // rcx
long long v38; // rax
long long v39; // rdx
long long v40; // rcx
long long v41; // r13
long long v42; // rbx
long long v43; // r8
long long ModuleNamespace; // rax
long long v45; // rdx
long long v46; // rdi
_DWORD *v47; // rsi
long long v48; // rcx
long long v49; // rcx
int v50; // eax
int v51; // r12d
_DWORD *v52; // rax
long long v53; // rdx
long long v54; // r13
char v55; // al
_DWORD *v56; // rcx
bool v57; // zf
long long module_var; // rax
_DWORD *v59; // rsi
long long v60; // rdx
long long v61; // r12
long long v62; // rax
long long v63; // rcx
long long v64; // rdi
long long v65; // rdx
_DWORD *v66; // rsi
long long v67; // rsi
long long v68; // rdx
long long v69; // rdx
_DWORD *v70; // rsi
char v71; // [rsp+0h] [rbp-90h]
long long *v72; // [rsp+20h] [rbp-70h]
__m128 v73; // [rsp+28h] [rbp-68h] BYREF
_DWORD *v74; // [rsp+38h] [rbp-58h]
long long v75; // [rsp+40h] [rbp-50h] BYREF
long long v76; // [rsp+48h] [rbp-48h]
long long v77; // [rsp+50h] [rbp-40h]
unsigned int v78; // [rsp+5Ch] [rbp-34h]
long long v79; // [rsp+60h] [rbp-30h]
long long savedregs; // [rsp+90h] [rbp+0h] BYREF
if ( *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) > (unsigned long long)&savedregs )
{
JS_ThrowRangeError(
a1,
(long long)"Maximum call stack size exceeded",
(long long)a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v71);
return 0xFFFFFFFFLL;
}
v16 = *(_DWORD *)(a2 + 128);
if ( HIBYTE(v16) <= 5u )
{
v17 = 54;
if ( _bittest(&v17, HIBYTE(v16)) )
return (unsigned int)a4;
}
v79 = a1;
*(_DWORD *)(a2 + 128) = v16 & 0xFFFFFF | 0x1000000;
*(_DWORD *)(a2 + 132) = a4;
*(_DWORD *)(a2 + 136) = a4;
v18 = a4 + 1;
*(_QWORD *)(a2 + 144) = *a3;
*a3 = a2;
if ( *(int *)(a2 + 32) <= 0 )
{
LABEL_16:
v78 = v18;
v72 = a3;
if ( *(int *)(a2 + 48) > 0 )
{
v24 = 24LL;
v25 = 0LL;
do
{
v26 = *(_QWORD *)(a2 + 40);
if ( *(_DWORD *)(v26 + v24 - 8) != 1 )
goto LABEL_24;
v27 = *(unsigned int *)(v26 + v24 - 4);
if ( (_DWORD)v27 == 126 )
goto LABEL_24;
v28 = v79;
v29 = js_resolve_export(
v79,
(long long)&v75,
(long long)&v73,
*(_QWORD *)(*(_QWORD *)(a2 + 24) + 16LL * *(int *)(v26 + v24 - 24) + 8),
v27);
if ( v29 )
{
v30 = v28;
v31 = v29;
js_resolve_export_throw_error(
v30,
v29,
a2,
*(_DWORD *)(v26 + v24),
a7,
a8,
a9,
a10,
*(double *)a11.m128_u64,
*(double *)a12.m128_u64,
a13,
a14);
v29 = v31;
v32 = 5;
}
else
{
v32 = 0;
}
if ( !v29 )
LABEL_24:
v32 = 0;
if ( v32 )
return 0xFFFFFFFFLL;
++v25;
v24 += 32LL;
}
while ( v25 < *(int *)(a2 + 48) );
}
if ( *(_QWORD *)(a2 + 120) )
goto LABEL_28;
v77 = *(_QWORD *)(*(_QWORD *)(a2 + 104) + 56LL);
v35 = v79;
if ( *(int *)(a2 + 80) <= 0 )
{
LABEL_55:
if ( *(int *)(a2 + 48) > 0 )
{
v62 = 16LL;
v63 = 0LL;
v64 = v77;
do
{
v65 = *(_QWORD *)(a2 + 40);
if ( !*(_DWORD *)(v65 + v62) )
{
v66 = *(_DWORD **)(v64 + 8LL * *(int *)(v65 + v62 - 16));
++*v66;
*(_QWORD *)(v65 + v62 - 8) = v66;
}
++v63;
v62 += 32LL;
}
while ( v63 < *(int *)(a2 + 48) );
}
v67 = *(_QWORD *)(a2 + 104);
v68 = *(_QWORD *)(a2 + 112);
v73.m128_i32[0] = 0;
v73.m128_u64[1] = 3LL;
v70 = (_DWORD *)JS_CallInternal(v35, v67, v68, 1LL, 1LL, 0LL, v73, a8, a9, a10, a11, a12, a13, a14, 0, 3, 0LL, 2u);
result = 0xFFFFFFFFLL;
if ( (_DWORD)v69 == 6 )
return result;
JS_FreeValueRT(*(_QWORD *)(v79 + 24), v70, v69);
LABEL_28:
if ( *(_DWORD *)(a2 + 132) != *(_DWORD *)(a2 + 136) )
return v78;
v33 = v78;
do
{
v34 = *v72;
*v72 = *(_QWORD *)(*v72 + 144);
*(_BYTE *)(v34 + 131) = 2;
}
while ( v34 != a2 );
return v33;
}
v36 = 0LL;
v37 = 0LL;
while ( 1 )
{
v76 = v37;
v38 = *(_QWORD *)(a2 + 24);
v39 = *(_QWORD *)(a2 + 72);
v40 = 16LL * *(int *)(v39 + v36 + 8);
v41 = *(_QWORD *)(v38 + v40 + 8);
v42 = v39;
v43 = *(unsigned int *)(v39 + v36 + 4);
if ( (_DWORD)v43 != 126 )
break;
ModuleNamespace = JS_GetModuleNamespace(
v35,
*(_QWORD *)(v38 + v40 + 8),
*(double *)a7.m128_u64,
a8,
a9,
a10,
*(double *)a11.m128_u64,
*(double *)a12.m128_u64,
a13,
a14);
if ( (_DWORD)v45 == 6 )
return 0xFFFFFFFFLL;
v46 = *(_QWORD *)(v77 + 8LL * *(int *)(v42 + v36));
v47 = *(_DWORD **)(v46 + 32);
v48 = *(_QWORD *)(v46 + 40);
*(_QWORD *)(v46 + 32) = ModuleNamespace;
*(_QWORD *)(v46 + 40) = v45;
JS_FreeValueRT(*(_QWORD *)(v35 + 24), v47, v48);
v49 = v76;
LABEL_50:
v37 = v49 + 1;
v36 += 12LL;
if ( v37 >= *(int *)(a2 + 80) )
goto LABEL_55;
}
v50 = js_resolve_export(v35, (long long)&v75, (long long)&v73, *(_QWORD *)(v38 + v40 + 8), v43);
if ( v50 )
{
js_resolve_export_throw_error(
v35,
v50,
v41,
*(_DWORD *)(v42 + v36 + 4),
a7,
a8,
a9,
a10,
*(double *)a11.m128_u64,
*(double *)a12.m128_u64,
a13,
a14);
v51 = 5;
v49 = v76;
goto LABEL_49;
}
if ( *(_DWORD *)(v73.m128_u64[0] + 20) != 126 )
{
v56 = *(_DWORD **)(v73.m128_u64[0] + 8);
if ( !v56 )
v56 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(v75 + 104) + 56LL) + 8LL * *(int *)v73.m128_u64[0]);
++*v56;
*(_QWORD *)(v77 + 8LL * *(int *)(v42 + v36)) = v56;
v49 = v76;
goto LABEL_48;
}
v52 = (_DWORD *)JS_GetModuleNamespace(
v35,
*(_QWORD *)(*(_QWORD *)(v75 + 24) + 16LL * *(int *)v73.m128_u64[0] + 8),
*(double *)a7.m128_u64,
a8,
a9,
a10,
*(double *)a11.m128_u64,
*(double *)a12.m128_u64,
a13,
a14);
v54 = v53;
v51 = 5;
if ( (_DWORD)v53 != 6 )
{
v74 = v52;
module_var = js_create_module_var(v79, 1);
if ( module_var )
{
v59 = *(_DWORD **)(module_var + 32);
v60 = *(_QWORD *)(module_var + 40);
v61 = module_var;
*(_QWORD *)(module_var + 32) = v74;
*(_QWORD *)(module_var + 40) = v54;
JS_FreeValueRT(*(_QWORD *)(v79 + 24), v59, v60);
*(_QWORD *)(v77 + 8LL * *(int *)(v42 + v36)) = v61;
v51 = 0;
v55 = 1;
LABEL_43:
v49 = v76;
if ( !v55 )
{
LABEL_49:
v57 = v51 == 0;
v35 = v79;
if ( !v57 )
return 0xFFFFFFFFLL;
goto LABEL_50;
}
LABEL_48:
v51 = 0;
goto LABEL_49;
}
JS_FreeValueRT(*(_QWORD *)(v79 + 24), v74, v54);
}
v55 = 0;
goto LABEL_43;
}
v19 = 8LL;
v20 = 0LL;
while ( 1 )
{
v21 = *(_QWORD *)(*(_QWORD *)(a2 + 24) + v19);
v22 = a3;
v18 = js_inner_module_linking(v79, v21, a3, (unsigned int)v18);
result = 0xFFFFFFFFLL;
if ( v18 < 0 )
return result;
if ( *(unsigned __int8 *)(v21 + 131) << 24 == 0x1000000 )
{
v23 = *(_DWORD *)(v21 + 136);
if ( *(_DWORD *)(a2 + 136) < v23 )
v23 = *(_DWORD *)(a2 + 136);
*(_DWORD *)(a2 + 136) = v23;
}
a3 = v22;
++v20;
v19 += 16LL;
if ( v20 >= *(int *)(a2 + 32) )
goto LABEL_16;
}
}
|
js_inner_module_linking:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RAX + 0xe8],RBP
JBE 0x001486ac
LEA RSI,[0x1a324e]
XOR EAX,EAX
CALL 0x00124b39
LAB_001486a5:
MOV EAX,0xffffffff
JMP 0x001486cf
LAB_001486ac:
MOV R8D,ECX
MOV R15,RSI
MOV EAX,dword ptr [RSI + 0x80]
MOV ECX,EAX
SHR ECX,0x18
CMP ECX,0x5
JA 0x001486de
MOV ESI,0x36
BT ESI,ECX
JNC 0x001486de
MOV EAX,R8D
LAB_001486cf:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001486de:
MOV qword ptr [RBP + -0x30],RDI
AND EAX,0xffffff
OR EAX,0x1000000
MOV dword ptr [R15 + 0x80],EAX
MOV dword ptr [R15 + 0x84],R8D
MOV dword ptr [R15 + 0x88],R8D
INC R8D
MOV RAX,qword ptr [RDX]
MOV qword ptr [R15 + 0x90],RAX
MOV qword ptr [RDX],R15
CMP dword ptr [R15 + 0x20],0x0
JLE 0x00148791
MOV R14D,0x8
XOR R12D,R12D
LAB_00148721:
MOV RAX,qword ptr [R15 + 0x18]
MOV R13,qword ptr [RAX + R14*0x1]
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R13
MOV RBX,RDX
MOV ECX,R8D
CALL 0x00148679
MOV R8D,EAX
MOV EAX,0xffffffff
TEST R8D,R8D
JS 0x001486cf
MOVZX ECX,byte ptr [R13 + 0x83]
SHL ECX,0x18
CMP ECX,0x1000000
JNZ 0x00148775
MOV ECX,dword ptr [R15 + 0x88]
MOV EDX,dword ptr [R13 + 0x88]
CMP ECX,EDX
CMOVL EDX,ECX
MOV dword ptr [R15 + 0x88],EDX
LAB_00148775:
TEST R8D,R8D
JS 0x001486cf
MOV RDX,RBX
INC R12
MOVSXD RAX,dword ptr [R15 + 0x20]
ADD R14,0x10
CMP R12,RAX
JL 0x00148721
LAB_00148791:
MOV dword ptr [RBP + -0x34],R8D
MOV qword ptr [RBP + -0x70],RDX
CMP dword ptr [R15 + 0x30],0x0
JLE 0x0014882b
MOV R14D,0x18
XOR R12D,R12D
LAB_001487ad:
MOV R13,qword ptr [R15 + 0x28]
CMP dword ptr [R13 + R14*0x1 + -0x8],0x1
JNZ 0x00148811
MOV R8D,dword ptr [R13 + R14*0x1 + -0x4]
CMP R8D,0x7e
JZ 0x00148811
MOV RAX,qword ptr [R15 + 0x18]
MOVSXD RCX,dword ptr [R13 + R14*0x1 + -0x18]
SHL RCX,0x4
MOV RCX,qword ptr [RAX + RCX*0x1 + 0x8]
MOV RBX,qword ptr [RBP + -0x30]
MOV RDI,RBX
LEA RSI,[RBP + -0x50]
LEA RDX,[RBP + -0x68]
CALL 0x001477da
TEST EAX,EAX
JZ 0x0014880b
MOV ECX,dword ptr [R13 + R14*0x1]
MOV RDI,RBX
MOV EBX,EAX
MOV ESI,EAX
MOV RDX,R15
CALL 0x00147845
MOV EAX,EBX
MOV ECX,0x5
JMP 0x0014880d
LAB_0014880b:
XOR ECX,ECX
LAB_0014880d:
TEST EAX,EAX
JNZ 0x00148813
LAB_00148811:
XOR ECX,ECX
LAB_00148813:
TEST ECX,ECX
JNZ 0x001486a5
INC R12
MOVSXD RAX,dword ptr [R15 + 0x30]
ADD R14,0x20
CMP R12,RAX
JL 0x001487ad
LAB_0014882b:
CMP qword ptr [R15 + 0x78],0x0
JZ 0x00148871
LAB_00148832:
MOV EAX,dword ptr [R15 + 0x84]
CMP EAX,dword ptr [R15 + 0x88]
MOV RDX,qword ptr [RBP + -0x70]
JNZ 0x00148869
MOV ESI,dword ptr [RBP + -0x34]
LAB_00148849:
MOV RAX,qword ptr [RDX]
MOV RCX,qword ptr [RAX + 0x90]
MOV qword ptr [RDX],RCX
MOV byte ptr [RAX + 0x83],0x2
CMP RAX,R15
JNZ 0x00148849
MOV EAX,ESI
JMP 0x001486cf
LAB_00148869:
MOV EAX,dword ptr [RBP + -0x34]
JMP 0x001486cf
LAB_00148871:
MOV RAX,qword ptr [R15 + 0x68]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x40],RAX
CMP dword ptr [R15 + 0x50],0x0
MOV R12,qword ptr [RBP + -0x30]
JLE 0x00148a32
XOR R14D,R14D
XOR ECX,ECX
LAB_00148891:
MOV qword ptr [RBP + -0x48],RCX
MOV RAX,qword ptr [R15 + 0x18]
MOV RDX,qword ptr [R15 + 0x48]
MOVSXD RCX,dword ptr [RDX + R14*0x1 + 0x8]
SHL RCX,0x4
MOV R13,qword ptr [RAX + RCX*0x1 + 0x8]
MOV RBX,RDX
MOV R8D,dword ptr [RDX + R14*0x1 + 0x4]
MOV RDI,R12
CMP R8D,0x7e
JNZ 0x001488ff
MOV RSI,R13
CALL 0x00134b53
CMP EDX,0x6
JZ 0x001486a5
MOVSXD RCX,dword ptr [RBX + R14*0x1]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RSI + RCX*0x8]
MOV RSI,qword ptr [RDI + 0x20]
MOV RCX,qword ptr [RDI + 0x28]
MOV qword ptr [RDI + 0x20],RAX
MOV qword ptr [RDI + 0x28],RDX
MOV RDI,qword ptr [R12 + 0x18]
MOV RDX,RCX
CALL 0x00121922
MOV RCX,qword ptr [RBP + -0x48]
JMP 0x001489b0
LAB_001488ff:
LEA RSI,[RBP + -0x50]
LEA RDX,[RBP + -0x68]
MOV RCX,R13
CALL 0x001477da
TEST EAX,EAX
JZ 0x00148931
MOV ECX,dword ptr [RBX + R14*0x1 + 0x4]
MOV RDI,R12
MOV ESI,EAX
MOV RDX,R13
CALL 0x00147845
MOV R12D,0x5
MOV RCX,qword ptr [RBP + -0x48]
JMP 0x001489a3
LAB_00148931:
MOV RAX,qword ptr [RBP + -0x68]
CMP dword ptr [RAX + 0x14],0x7e
JNZ 0x00148972
MOV RCX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RCX + 0x18]
MOVSXD RAX,dword ptr [RAX]
SHL RAX,0x4
MOV RSI,qword ptr [RCX + RAX*0x1 + 0x8]
MOV RDI,R12
CALL 0x00134b53
MOV R13,RDX
MOV R12D,0x5
CMP R13D,0x6
JNZ 0x001489c6
LAB_00148966:
XOR EAX,EAX
LAB_00148968:
TEST AL,AL
MOV RCX,qword ptr [RBP + -0x48]
JNZ 0x001489a0
JMP 0x001489a3
LAB_00148972:
MOV RCX,qword ptr [RAX + 0x8]
TEST RCX,RCX
JNZ 0x0014898e
MOV RCX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RCX + 0x68]
MOV RCX,qword ptr [RCX + 0x38]
MOVSXD RAX,dword ptr [RAX]
MOV RCX,qword ptr [RCX + RAX*0x8]
LAB_0014898e:
INC dword ptr [RCX]
MOVSXD RAX,dword ptr [RBX + R14*0x1]
MOV RDX,qword ptr [RBP + -0x40]
MOV qword ptr [RDX + RAX*0x8],RCX
MOV RCX,qword ptr [RBP + -0x48]
LAB_001489a0:
XOR R12D,R12D
LAB_001489a3:
TEST R12D,R12D
MOV R12,qword ptr [RBP + -0x30]
JNZ 0x001486a5
LAB_001489b0:
INC RCX
MOVSXD RAX,dword ptr [R15 + 0x50]
ADD R14,0xc
CMP RCX,RAX
JL 0x00148891
JMP 0x00148a32
LAB_001489c6:
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV ESI,0x1
CALL 0x001112d7
TEST RAX,RAX
JZ 0x00148a19
MOV RSI,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RAX + 0x28]
MOV R12,RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [R12 + 0x20],RAX
MOV qword ptr [R12 + 0x28],R13
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x18]
CALL 0x00121922
MOVSXD RAX,dword ptr [RBX + R14*0x1]
MOV RCX,qword ptr [RBP + -0x40]
MOV qword ptr [RCX + RAX*0x8],R12
XOR R12D,R12D
MOV AL,0x1
JMP 0x00148968
LAB_00148a19:
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RBP + -0x58]
MOV RDX,R13
CALL 0x00121922
JMP 0x00148966
LAB_00148a32:
CMP dword ptr [R15 + 0x30],0x0
JLE 0x00148a6e
MOV EAX,0x10
XOR ECX,ECX
MOV RDI,qword ptr [RBP + -0x40]
LAB_00148a44:
MOV RDX,qword ptr [R15 + 0x28]
CMP dword ptr [RDX + RAX*0x1],0x0
JNZ 0x00148a5e
MOVSXD RSI,dword ptr [RDX + RAX*0x1 + -0x10]
MOV RSI,qword ptr [RDI + RSI*0x8]
INC dword ptr [RSI]
MOV qword ptr [RDX + RAX*0x1 + -0x8],RSI
LAB_00148a5e:
INC RCX
MOVSXD RDX,dword ptr [R15 + 0x30]
ADD RAX,0x20
CMP RCX,RDX
JL 0x00148a44
LAB_00148a6e:
MOV RSI,qword ptr [R15 + 0x68]
MOV RDX,qword ptr [R15 + 0x70]
MOV dword ptr [RBP + -0x68],0x0
MOV qword ptr [RBP + -0x60],0x3
MOVUPS XMM0,xmmword ptr [RBP + -0x68]
MOVUPS xmmword ptr [RSP],XMM0
MOV dword ptr [RSP + 0x18],0x2
MOV qword ptr [RSP + 0x10],0x0
MOV ECX,0x1
MOV R8D,0x1
MOV RDI,R12
XOR R9D,R9D
CALL 0x0012c526
MOV RSI,RAX
MOV EAX,0xffffffff
CMP EDX,0x6
JZ 0x001486cf
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x18]
CALL 0x00121922
JMP 0x00148832
|
int js_inner_module_linking(long param_1,long param_2,long *param_3,int param_4)
{
long lVar1;
int8 uVar2;
int8 uVar3;
int *piVar4;
bool bVar5;
int iVar6;
uint uVar7;
int *piVar8;
long lVar9;
long lVar10;
long lVar11;
int1 auVar12 [12];
int1 auVar13 [16];
int4 local_70;
int4 uStack_6c;
int8 uStack_68;
int8 local_60;
long local_58;
long local_50;
long local_48;
int local_3c;
long local_38;
if (&stack0xfffffffffffffff8 < *(int1 **)(*(long *)(param_1 + 0x18) + 0xe8)) {
JS_ThrowRangeError(param_1,"Maximum call stack size exceeded");
LAB_001486a5:
local_3c = -1;
}
else {
uVar7 = *(uint *)(param_2 + 0x80) >> 0x18;
if ((5 < uVar7) || (local_3c = param_4, (0x36U >> (uVar7 & 0x1f) & 1) == 0)) {
*(uint *)(param_2 + 0x80) = *(uint *)(param_2 + 0x80) & 0xffffff | 0x1000000;
*(int *)(param_2 + 0x84) = param_4;
*(int *)(param_2 + 0x88) = param_4;
param_4 = param_4 + 1;
*(long *)(param_2 + 0x90) = *param_3;
*param_3 = param_2;
local_38 = param_1;
if (0 < *(int *)(param_2 + 0x20)) {
lVar10 = 8;
lVar9 = 0;
do {
lVar11 = *(long *)(*(long *)(param_2 + 0x18) + lVar10);
param_4 = js_inner_module_linking(local_38,lVar11,param_3,param_4);
if (param_4 < 0) {
return -1;
}
if (*(char *)(lVar11 + 0x83) == '\x01') {
iVar6 = *(int *)(lVar11 + 0x88);
if (*(int *)(param_2 + 0x88) < *(int *)(lVar11 + 0x88)) {
iVar6 = *(int *)(param_2 + 0x88);
}
*(int *)(param_2 + 0x88) = iVar6;
}
if (param_4 < 0) {
return -1;
}
lVar9 = lVar9 + 1;
lVar10 = lVar10 + 0x10;
} while (lVar9 < *(int *)(param_2 + 0x20));
}
local_3c = param_4;
if (0 < *(int *)(param_2 + 0x30)) {
lVar10 = 0x18;
lVar9 = 0;
do {
lVar1 = local_38;
lVar11 = *(long *)(param_2 + 0x28);
if (((*(int *)(lVar11 + -8 + lVar10) == 1) && (*(int *)(lVar11 + -4 + lVar10) != 0x7e)) &&
(iVar6 = js_resolve_export(local_38,&local_58,&local_70), iVar6 != 0)) {
js_resolve_export_throw_error(lVar1,iVar6,param_2,*(int4 *)(lVar11 + lVar10));
iVar6 = 5;
}
else {
iVar6 = 0;
}
if (iVar6 != 0) goto LAB_001486a5;
lVar9 = lVar9 + 1;
lVar10 = lVar10 + 0x20;
} while (lVar9 < *(int *)(param_2 + 0x30));
}
if (*(long *)(param_2 + 0x78) == 0) {
local_48 = *(long *)(*(long *)(param_2 + 0x68) + 0x38);
lVar9 = local_38;
if (0 < *(int *)(param_2 + 0x50)) {
lVar11 = 0;
lVar10 = 0;
do {
lVar1 = *(long *)(param_2 + 0x48);
uVar2 = *(int8 *)
(*(long *)(param_2 + 0x18) + 8 + (long)*(int *)(lVar1 + 8 + lVar11) * 0x10);
local_50 = lVar10;
if (*(int *)(lVar1 + 4 + lVar11) == 0x7e) {
auVar13 = JS_GetModuleNamespace(lVar9,uVar2);
if (auVar13._8_4_ == 6) goto LAB_001486a5;
lVar10 = *(long *)(local_48 + (long)*(int *)(lVar1 + lVar11) * 8);
uVar2 = *(int8 *)(lVar10 + 0x20);
*(int1 (*) [16])(lVar10 + 0x20) = auVar13;
JS_FreeValueRT(*(int8 *)(lVar9 + 0x18),uVar2,*(int8 *)(lVar10 + 0x28));
}
else {
iVar6 = js_resolve_export(lVar9,&local_58,&local_70,uVar2);
if (iVar6 == 0) {
piVar4 = (int *)CONCAT44(uStack_6c,local_70);
if (piVar4[5] == 0x7e) {
auVar13 = JS_GetModuleNamespace
(lVar9,*(int8 *)
(*(long *)(local_58 + 0x18) + 8 + (long)*piVar4 * 0x10
));
iVar6 = 5;
if (auVar13._8_4_ == 6) {
LAB_00148966:
bVar5 = false;
}
else {
local_60 = auVar13._0_8_;
lVar9 = js_create_module_var(local_38,1);
if (lVar9 == 0) {
JS_FreeValueRT(*(int8 *)(local_38 + 0x18),local_60,auVar13._8_8_);
goto LAB_00148966;
}
uVar2 = *(int8 *)(lVar9 + 0x20);
uVar3 = *(int8 *)(lVar9 + 0x28);
*(int8 *)(lVar9 + 0x20) = local_60;
*(long *)(lVar9 + 0x28) = auVar13._8_8_;
JS_FreeValueRT(*(int8 *)(local_38 + 0x18),uVar2,uVar3);
*(long *)(local_48 + (long)*(int *)(lVar1 + lVar11) * 8) = lVar9;
iVar6 = 0;
bVar5 = true;
}
if (!bVar5) goto LAB_001489a3;
}
else {
piVar8 = *(int **)(piVar4 + 2);
if (piVar8 == (int *)0x0) {
piVar8 = *(int **)(*(long *)(*(long *)(local_58 + 0x68) + 0x38) +
(long)*piVar4 * 8);
}
*piVar8 = *piVar8 + 1;
*(int **)(local_48 + (long)*(int *)(lVar1 + lVar11) * 8) = piVar8;
}
iVar6 = 0;
}
else {
js_resolve_export_throw_error(lVar9,iVar6,uVar2,*(int4 *)(lVar1 + 4 + lVar11))
;
iVar6 = 5;
}
LAB_001489a3:
lVar9 = local_38;
if (iVar6 != 0) goto LAB_001486a5;
}
lVar10 = local_50 + 1;
lVar11 = lVar11 + 0xc;
} while (lVar10 < *(int *)(param_2 + 0x50));
}
if (0 < *(int *)(param_2 + 0x30)) {
lVar10 = 0x10;
lVar11 = 0;
do {
lVar1 = *(long *)(param_2 + 0x28);
if (*(int *)(lVar1 + lVar10) == 0) {
piVar4 = *(int **)(local_48 + (long)*(int *)(lVar1 + -0x10 + lVar10) * 8);
*piVar4 = *piVar4 + 1;
*(int **)(lVar1 + -8 + lVar10) = piVar4;
}
lVar11 = lVar11 + 1;
lVar10 = lVar10 + 0x20;
} while (lVar11 < *(int *)(param_2 + 0x30));
}
local_70 = 0;
uStack_68 = 3;
auVar12 = JS_CallInternal(lVar9,*(int8 *)(param_2 + 0x68),
*(int8 *)(param_2 + 0x70),1,1,0,0,3,0,2);
if (auVar12._8_4_ == 6) {
return -1;
}
JS_FreeValueRT(*(int8 *)(local_38 + 0x18),auVar12._0_8_);
}
if (*(int *)(param_2 + 0x84) == *(int *)(param_2 + 0x88)) {
do {
lVar9 = *param_3;
*param_3 = *(long *)(lVar9 + 0x90);
*(int1 *)(lVar9 + 0x83) = 2;
} while (lVar9 != param_2);
}
}
}
return local_3c;
}
|
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.