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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
57,700
|
thr_timer_init
|
eloqsql/mysys/thr_timer.c
|
void thr_timer_init(thr_timer_t *timer_data, void(*function)(void*),
void *arg)
{
DBUG_ENTER("thr_timer_init");
bzero(timer_data, sizeof(*timer_data));
timer_data->func= function;
timer_data->func_arg= arg;
timer_data->expired= 1; /* Not active */
DBUG_VOID_RETURN;
}
|
O3
|
c
|
thr_timer_init:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rsi, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movb $0x1, 0x18(%rdi)
popq %rbp
retq
|
thr_timer_init:
push rbp
mov rbp, rsp
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
mov [rdi+20h], rsi
mov [rdi+28h], rdx
mov byte ptr [rdi+18h], 1
pop rbp
retn
|
void thr_timer_init(long long a1, long long a2, long long a3)
{
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 32) = a2;
*(_QWORD *)(a1 + 40) = a3;
*(_BYTE *)(a1 + 24) = 1;
}
|
thr_timer_init:
PUSH RBP
MOV RBP,RSP
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x20],RSI
MOV qword ptr [RDI + 0x28],RDX
MOV byte ptr [RDI + 0x18],0x1
POP RBP
RET
|
void thr_timer_init(int8 *param_1,int8 param_2,int8 param_3)
{
param_1[4] = 0;
param_1[5] = 0;
param_1[2] = 0;
param_1[3] = 0;
*param_1 = 0;
param_1[1] = 0;
param_1[4] = param_2;
param_1[5] = param_3;
*(int1 *)(param_1 + 3) = 1;
return;
}
|
|
57,701
|
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;
}
|
O3
|
c
|
my_strnncollsp_latin1_de:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
addq %rsi, %rdx
addq %rcx, %r8
xorl %edi, %edi
leaq 0x16ba31(%rip), %rax # 0x1a7d10
leaq 0x16b92a(%rip), %r9 # 0x1a7c10
xorl %r10d, %r10d
cmpq %rdx, %rsi
jb 0x3c2f3
testb %dil, %dil
je 0x3c343
cmpq %r8, %rcx
jb 0x3c2fd
testb %r10b, %r10b
je 0x3c34f
testb %dil, %dil
je 0x3c309
movl %edi, %r11d
xorl %edi, %edi
jmp 0x3c318
movzbl (%rsi), %r11d
movb (%r11,%rax), %dil
incq %rsi
movb (%r11,%r9), %r11b
testb %r10b, %r10b
je 0x3c325
movl %r10d, %ebx
xorl %r10d, %r10d
jmp 0x3c333
movzbl (%rcx), %ebx
movb (%rbx,%rax), %r10b
incq %rcx
movb (%rbx,%r9), %bl
cmpb %bl, %r11b
je 0x3c2e9
movzbl %bl, %ecx
movzbl %r11b, %eax
subl %ecx, %eax
jmp 0x3c389
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testb %r10b, %r10b
jne 0x3c389
jmp 0x3c372
movl $0x1, %eax
testb %dil, %dil
jne 0x3c389
cmpq %rdx, %rsi
jae 0x3c372
subq %rsi, %rdx
movq %rsi, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x35961
xorl %eax, %eax
cmpq %r8, %rcx
jae 0x3c389
subq %rcx, %r8
movq %rcx, %rdi
movq %r8, %rsi
callq 0x35961
negl %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
my_strnncollsp_latin1_de:
push rbp
mov rbp, rsp
push rbx
push rax
add rdx, rsi
add r8, rcx
xor edi, edi
lea rax, combo2map
lea r9, combo1map
xor r10d, r10d
loc_3C2E9:
cmp rsi, rdx
jb short loc_3C2F3
test dil, dil
jz short loc_3C343
loc_3C2F3:
cmp rcx, r8
jb short loc_3C2FD
test r10b, r10b
jz short loc_3C34F
loc_3C2FD:
test dil, dil
jz short loc_3C309
mov r11d, edi
xor edi, edi
jmp short loc_3C318
loc_3C309:
movzx r11d, byte ptr [rsi]
mov dil, [r11+rax]
inc rsi
mov r11b, [r11+r9]
loc_3C318:
test r10b, r10b
jz short loc_3C325
mov ebx, r10d
xor r10d, r10d
jmp short loc_3C333
loc_3C325:
movzx ebx, byte ptr [rcx]
mov r10b, [rbx+rax]
inc rcx
mov bl, [rbx+r9]
loc_3C333:
cmp r11b, bl
jz short loc_3C2E9
movzx ecx, bl
movzx eax, r11b
sub eax, ecx
jmp short loc_3C389
loc_3C343:
mov eax, 0FFFFFFFFh
test r10b, r10b
jnz short loc_3C389
jmp short loc_3C372
loc_3C34F:
mov eax, 1
test dil, dil
jnz short loc_3C389
cmp rsi, rdx
jnb short loc_3C372
sub rdx, rsi
mov rdi, rsi
mov rsi, rdx
add rsp, 8
pop rbx
pop rbp
jmp my_strnncollsp_padspace_bin
loc_3C372:
xor eax, eax
cmp rcx, r8
jnb short loc_3C389
sub r8, rcx
mov rdi, rcx
mov rsi, r8
call my_strnncollsp_padspace_bin
neg eax
loc_3C389:
add rsp, 8
pop rbx
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; // rdx
unsigned __int8 *v6; // r8
unsigned __int8 v7; // di
unsigned __int8 v8; // r10
unsigned __int8 v9; // r11
long long v10; // r11
unsigned __int8 v11; // bl
long long v12; // rbx
long long result; // rax
v5 = &a2[a3];
v6 = &a4[a5];
v7 = 0;
v8 = 0;
while ( 1 )
{
if ( a2 >= v5 && !v7 )
{
result = 0xFFFFFFFFLL;
if ( v8 )
return result;
goto LABEL_19;
}
if ( a4 >= v6 && !v8 )
break;
if ( v7 )
{
v9 = v7;
v7 = 0;
}
else
{
v10 = *a2;
v7 = combo2map[v10];
++a2;
v9 = combo1map[v10];
}
if ( v8 )
{
v11 = v8;
v8 = 0;
}
else
{
v12 = *a4;
v8 = combo2map[v12];
++a4;
v11 = combo1map[v12];
}
if ( v9 != v11 )
return v9 - (unsigned int)v11;
}
result = 1LL;
if ( v7 )
return result;
if ( a2 < v5 )
return my_strnncollsp_padspace_bin((long long)a2, v5 - a2);
LABEL_19:
result = 0LL;
if ( a4 < v6 )
return (unsigned int)-my_strnncollsp_padspace_bin((long long)a4, v6 - a4);
return result;
}
|
my_strnncollsp_latin1_de:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
ADD RDX,RSI
ADD R8,RCX
XOR EDI,EDI
LEA RAX,[0x2a7d10]
LEA R9,[0x2a7c10]
XOR R10D,R10D
LAB_0013c2e9:
CMP RSI,RDX
JC 0x0013c2f3
TEST DIL,DIL
JZ 0x0013c343
LAB_0013c2f3:
CMP RCX,R8
JC 0x0013c2fd
TEST R10B,R10B
JZ 0x0013c34f
LAB_0013c2fd:
TEST DIL,DIL
JZ 0x0013c309
MOV R11D,EDI
XOR EDI,EDI
JMP 0x0013c318
LAB_0013c309:
MOVZX R11D,byte ptr [RSI]
MOV DIL,byte ptr [R11 + RAX*0x1]
INC RSI
MOV R11B,byte ptr [R11 + R9*0x1]
LAB_0013c318:
TEST R10B,R10B
JZ 0x0013c325
MOV EBX,R10D
XOR R10D,R10D
JMP 0x0013c333
LAB_0013c325:
MOVZX EBX,byte ptr [RCX]
MOV R10B,byte ptr [RBX + RAX*0x1]
INC RCX
MOV BL,byte ptr [RBX + R9*0x1]
LAB_0013c333:
CMP R11B,BL
JZ 0x0013c2e9
MOVZX ECX,BL
MOVZX EAX,R11B
SUB EAX,ECX
JMP 0x0013c389
LAB_0013c343:
MOV EAX,0xffffffff
TEST R10B,R10B
JNZ 0x0013c389
JMP 0x0013c372
LAB_0013c34f:
MOV EAX,0x1
TEST DIL,DIL
JNZ 0x0013c389
CMP RSI,RDX
JNC 0x0013c372
SUB RDX,RSI
MOV RDI,RSI
MOV RSI,RDX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00135961
LAB_0013c372:
XOR EAX,EAX
CMP RCX,R8
JNC 0x0013c389
SUB R8,RCX
MOV RDI,RCX
MOV RSI,R8
CALL 0x00135961
NEG EAX
LAB_0013c389:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
ulong my_strnncollsp_latin1_de
(int8 param_1,byte *param_2,long param_3,byte *param_4,long param_5)
{
int iVar1;
ulong uVar2;
byte *pbVar3;
byte bVar4;
byte bVar5;
byte *pbVar6;
byte bVar7;
byte bVar8;
pbVar3 = param_2 + param_3;
pbVar6 = param_4 + param_5;
bVar5 = 0;
bVar7 = 0;
do {
if ((pbVar3 <= param_2) && (bVar5 == 0)) {
if (bVar7 != 0) {
return 0xffffffff;
}
LAB_0013c372:
if (pbVar6 <= param_4) {
return 0;
}
iVar1 = my_strnncollsp_padspace_bin(param_4,(long)pbVar6 - (long)param_4);
return (ulong)(uint)-iVar1;
}
if ((pbVar6 <= param_4) && (bVar7 == 0)) {
if (bVar5 != 0) {
return 1;
}
if (param_2 < pbVar3) {
uVar2 = my_strnncollsp_padspace_bin(param_2,(long)pbVar3 - (long)param_2);
return uVar2;
}
goto LAB_0013c372;
}
if (bVar5 == 0) {
bVar8 = *param_2;
bVar5 = combo2map[bVar8];
param_2 = param_2 + 1;
bVar8 = combo1map[bVar8];
}
else {
bVar8 = bVar5;
bVar5 = 0;
}
if (bVar7 == 0) {
bVar4 = *param_4;
bVar7 = combo2map[bVar4];
param_4 = param_4 + 1;
bVar4 = combo1map[bVar4];
}
else {
bVar4 = bVar7;
bVar7 = 0;
}
if (bVar8 != bVar4) {
return (ulong)((uint)bVar8 - (uint)bVar4);
}
} while( true );
}
|
|
57,702
|
psi_prlock_rdlock
|
eloqsql/mysys/my_thr_init.c
|
ATTRIBUTE_COLD
int psi_prlock_rdlock(mysql_prlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_rdwait)
(&state, that->m_psi, PSI_RWLOCK_READLOCK, file, line);
int result= rw_pr_rdlock(&that->m_prlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, result);
return result;
}
|
O0
|
c
|
psi_prlock_rdlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1b96e6(%rip), %rax # 0x214320
movq (%rax), %rax
movq 0x1a0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x68(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5b330
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x5ac8d
leaq 0x1b96a6(%rip), %rax # 0x214320
movq (%rax), %rax
movq 0x1a8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
psi_prlock_rdlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1A0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+68h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
xor edx, edx
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call rw_pr_rdlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_5AC8D
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1A8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_5AC8D:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
|
long long psi_prlock_rdlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = ((long long ( *)(_BYTE *, _QWORD, _QWORD, long long, _QWORD))PSI_server[52])(
v6,
*(_QWORD *)(a1 + 104),
0LL,
a2,
a3);
v4 = rw_pr_rdlock(v9);
if ( v5 )
((void ( *)(long long, _QWORD))PSI_server[53])(v5, v4);
return v4;
}
|
psi_prlock_rdlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
LEA RAX,[0x314320]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1a0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x68]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
XOR EDX,EDX
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0015b330
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x0015ac8d
LEA RAX,[0x314320]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1a8]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_0015ac8d:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4 psi_prlock_rdlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
long local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1a0))
(local_50,*(int8 *)(param_1 + 0x68),0,param_2,param_3);
uVar1 = rw_pr_rdlock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1a8))(lVar2,uVar1);
}
return uVar1;
}
|
|
57,703
|
main
|
navaro[P]qoraal-tictactoe/src/main.c
|
int main( void )
{
#if !defined CFG_OS_THREADX
main_init() ;
#endif
/* Start the scheduler. */
os_sys_start ();
/*
* Dependinmg on the RTOS, if you get here it will most likely be in a
* threading context. So alternatively, main_thread can be called from here.
*/
/*
* For the demo, we wait for the wait for the web server to shutdown or the
* shell to be exited with the "exit" command.
*/
console_wait_for_exit (QORAAL_SERVICE_WWW) ;
svc_service_stop_timeout (svc_service_get(QORAAL_SERVICE_WWW), 1200) ;
qoraal_stop_default () ;
platform_stop () ;
// for( ;; ) os_thread_sleep (32768);
}
|
O3
|
c
|
main:
pushq %rbp
movq %rsp, %rbp
callq 0x10e2c
callq 0x14c9d
movl $0x2, %edi
callq 0x1bb3e
movl $0x2, %edi
callq 0x16900
movl %eax, %edi
movl $0x4b0, %esi # imm = 0x4B0
callq 0x17276
callq 0x141f3
callq 0x1bcb3
xorl %eax, %eax
popq %rbp
retq
|
main:
push rbp
mov rbp, rsp
call main_init
call os_sys_start
mov edi, 2
call console_wait_for_exit
mov edi, 2
call svc_service_get
mov edi, eax
mov esi, 4B0h
call svc_service_stop_timeout
call qoraal_stop_default
call platform_stop
xor eax, eax
pop rbp
retn
|
int main(int argc, const char **argv, const char **envp)
{
unsigned int v3; // eax
main_init(argc, argv, envp);
os_sys_start();
console_wait_for_exit(2LL);
v3 = svc_service_get(2LL);
svc_service_stop_timeout(v3, 1200LL);
qoraal_stop_default();
platform_stop();
return 0;
}
|
main:
PUSH RBP
MOV RBP,RSP
CALL 0x00110e2c
CALL 0x00114c9d
MOV EDI,0x2
CALL 0x0011bb3e
MOV EDI,0x2
CALL 0x00116900
MOV EDI,EAX
MOV ESI,0x4b0
CALL 0x00117276
CALL 0x001141f3
CALL 0x0011bcb3
XOR EAX,EAX
POP RBP
RET
|
int8 main(void)
{
int4 uVar1;
main_init();
os_sys_start();
console_wait_for_exit(2);
uVar1 = svc_service_get(2);
svc_service_stop_timeout(uVar1,0x4b0);
qoraal_stop_default();
platform_stop();
return 0;
}
|
|
57,704
|
void OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointStencils<double>(OpenSubdiv::v3_6_0::Far::SparseMatrix<double> const&, int const*, int)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp
|
void
PatchTableBuilder::LocalPointHelper::appendLocalPointStencils(
SparseMatrix<REAL> const & conversionMatrix,
Index const sourcePoints[],
int sourcePointOffset) {
//
// Resize the StencilTable members to accomodate all rows and elements from
// the given set of points represented by the matrix
//
StencilTableReal<REAL>* stencilTable = _stencilTable.Get<REAL>();
int numNewStencils = conversionMatrix.GetNumRows();
int numNewElements = conversionMatrix.GetNumElements();
size_t numOldStencils = stencilTable->_sizes.size();
size_t numOldElements = stencilTable->_indices.size();
// Assign the sizes for the new stencils:
stencilTable->_sizes.resize(numOldStencils + numNewStencils);
int * newSizes = &stencilTable->_sizes[numOldStencils];
for (int i = 0; i < numNewStencils; ++i) {
newSizes[i] = conversionMatrix.GetRowSize(i);
}
// Assign remapped indices for the stencils:
stencilTable->_indices.resize(numOldElements + numNewElements);
int const * mtxIndices = &conversionMatrix.GetColumns()[0];
int * newIndices = &stencilTable->_indices[numOldElements];
for (int i = 0; i < numNewElements; ++i) {
newIndices[i] = sourcePoints[mtxIndices[i]] + sourcePointOffset;
}
// Copy the stencil weights direct from the matrix elements:
stencilTable->_weights.resize(numOldElements + numNewElements);
REAL const * mtxWeights = &conversionMatrix.GetElements()[0];
REAL * newWeights = &stencilTable->_weights[numOldElements];
std::memcpy(newWeights, mtxWeights, numNewElements * sizeof(REAL));
}
|
O0
|
cpp
|
void OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointStencils<double>(OpenSubdiv::v3_6_0::Far::SparseMatrix<double> const&, int const*, int):
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0xc9ca0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcf430
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc5060
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0xd7ae0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0xd7ae0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x38(%rbp), %rsi
movslq -0x2c(%rbp), %rax
addq %rax, %rsi
callq 0xc9aa0
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x38(%rbp), %rsi
callq 0xc7140
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x151305
movq -0x10(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0xc9730
movl %eax, %edx
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x1512d9
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq -0x40(%rbp), %rsi
movslq -0x30(%rbp), %rax
addq %rax, %rsi
callq 0xc9aa0
movq -0x10(%rbp), %rdi
callq 0xcf610
movl %edx, -0x70(%rbp)
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x70(%rbp), %eax
movl %eax, -0x60(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0xcabf0
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq -0x40(%rbp), %rsi
callq 0xc7140
movq %rax, -0x80(%rbp)
movl $0x0, -0x84(%rbp)
movl -0x84(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x1513ac
movq -0x18(%rbp), %rax
movq -0x58(%rbp), %rcx
movslq -0x84(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
addl -0x1c(%rbp), %edx
movq -0x80(%rbp), %rax
movslq -0x84(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x151369
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
movq -0x40(%rbp), %rsi
movslq -0x30(%rbp), %rax
addq %rax, %rsi
callq 0xcad80
movq -0x10(%rbp), %rdi
callq 0xd65d0
movl %edx, -0xa8(%rbp)
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl -0xa8(%rbp), %eax
movl %eax, -0x98(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
callq 0xc5f50
movq %rax, -0x90(%rbp)
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
movq -0x40(%rbp), %rsi
callq 0xd6c50
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rdi
movq -0x90(%rbp), %rsi
movslq -0x30(%rbp), %rdx
shlq $0x2, %rdx
callq 0xcb1d0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
|
_ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelper24appendLocalPointStencilsIfEEvRKNS1_12SparseMatrixIT_EEPKii:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov rdi, [rbp+var_8]
add rdi, 48h ; 'H'
call __ZNK10OpenSubdiv6v3_6_03Far10PatchTable15StencilTablePtr3GetIfEEPNS1_16StencilTableRealIT_EEv; OpenSubdiv::v3_6_0::Far::PatchTable::StencilTablePtr::Get<float>(void)
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
call __ZNK10OpenSubdiv6v3_6_03Far12SparseMatrixIfE10GetNumRowsEv; OpenSubdiv::v3_6_0::Far::SparseMatrix<float>::GetNumRows(void)
mov [rbp+var_2C], eax
mov rdi, [rbp+var_10]
call __ZNK10OpenSubdiv6v3_6_03Far12SparseMatrixIfE14GetNumElementsEv; OpenSubdiv::v3_6_0::Far::SparseMatrix<float>::GetNumElements(void)
mov [rbp+var_30], eax
mov rdi, [rbp+var_28]
add rdi, 10h
call __ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov [rbp+var_38], rax
mov rdi, [rbp+var_28]
add rdi, 40h ; '@'
call __ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov [rbp+var_40], rax
mov rdi, [rbp+var_28]
add rdi, 10h
mov rsi, [rbp+var_38]
movsxd rax, [rbp+var_2C]
add rsi, rax
call __ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
mov rdi, [rbp+var_28]
add rdi, 10h
mov rsi, [rbp+var_38]
call __ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov [rbp+var_48], rax
mov [rbp+var_4C], 0
loc_1512D9:
mov eax, [rbp+var_4C]
cmp eax, [rbp+var_2C]
jge short loc_151305
mov rdi, [rbp+var_10]
mov esi, [rbp+var_4C]
call __ZNK10OpenSubdiv6v3_6_03Far12SparseMatrixIfE10GetRowSizeEi; OpenSubdiv::v3_6_0::Far::SparseMatrix<float>::GetRowSize(int)
mov edx, eax
mov rax, [rbp+var_48]
movsxd rcx, [rbp+var_4C]
mov [rax+rcx*4], edx
mov eax, [rbp+var_4C]
add eax, 1
mov [rbp+var_4C], eax
jmp short loc_1512D9
loc_151305:
mov rdi, [rbp+var_28]
add rdi, 40h ; '@'
mov rsi, [rbp+var_40]
movsxd rax, [rbp+var_30]
add rsi, rax
call __ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
mov rdi, [rbp+var_10]
call __ZNK10OpenSubdiv6v3_6_03Far12SparseMatrixIfE10GetColumnsEv; OpenSubdiv::v3_6_0::Far::SparseMatrix<float>::GetColumns(void)
mov [rbp+var_70], edx
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov [rbp+var_68], rax
mov eax, [rbp+var_70]
mov [rbp+var_60], eax
lea rdi, [rbp+var_68]
xor esi, esi
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](int)
mov [rbp+var_58], rax
mov rdi, [rbp+var_28]
add rdi, 40h ; '@'
mov rsi, [rbp+var_40]
call __ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov [rbp+var_80], rax
mov [rbp+var_84], 0
loc_151369:
mov eax, [rbp+var_84]
cmp eax, [rbp+var_30]
jge short loc_1513AC
mov rax, [rbp+var_18]
mov rcx, [rbp+var_58]
movsxd rdx, [rbp+var_84]
movsxd rcx, dword ptr [rcx+rdx*4]
mov edx, [rax+rcx*4]
add edx, [rbp+var_1C]
mov rax, [rbp+var_80]
movsxd rcx, [rbp+var_84]
mov [rax+rcx*4], edx
mov eax, [rbp+var_84]
add eax, 1
mov [rbp+var_84], eax
jmp short loc_151369
loc_1513AC:
mov rdi, [rbp+var_28]
add rdi, 58h ; 'X'
mov rsi, [rbp+var_40]
movsxd rax, [rbp+var_30]
add rsi, rax
call __ZNSt6vectorIfSaIfEE6resizeEm; std::vector<float>::resize(ulong)
mov rdi, [rbp+var_10]
call __ZNK10OpenSubdiv6v3_6_03Far12SparseMatrixIfE11GetElementsEv; OpenSubdiv::v3_6_0::Far::SparseMatrix<float>::GetElements(void)
mov [rbp+var_A8], edx
mov [rbp+var_B0], rax
mov rax, [rbp+var_B0]
mov [rbp+var_A0], rax
mov eax, [rbp+var_A8]
mov [rbp+var_98], eax
lea rdi, [rbp+var_A0]
xor esi, esi
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIfEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<float>::operator[](int)
mov [rbp+var_90], rax
mov rdi, [rbp+var_28]
add rdi, 58h ; 'X'
mov rsi, [rbp+var_40]
call __ZNSt6vectorIfSaIfEEixEm; std::vector<float>::operator[](ulong)
mov [rbp+var_B8], rax
mov rdi, [rbp+var_B8]
mov rsi, [rbp+var_90]
movsxd rdx, [rbp+var_30]
shl rdx, 2
call _memcpy
add rsp, 0C0h
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointStencils<float>(
long long a1,
long long a2,
long long a3,
int a4)
{
long long Columns; // rax
int v5; // edx
int v6; // edx
long long v8; // [rsp+8h] [rbp-B8h]
long long Elements; // [rsp+20h] [rbp-A0h] BYREF
int v10; // [rsp+28h] [rbp-98h]
long long v11; // [rsp+30h] [rbp-90h]
int j; // [rsp+3Ch] [rbp-84h]
long long v13; // [rsp+40h] [rbp-80h]
long long v14; // [rsp+48h] [rbp-78h]
int v15; // [rsp+50h] [rbp-70h]
long long v16; // [rsp+58h] [rbp-68h] BYREF
int v17; // [rsp+60h] [rbp-60h]
long long v18; // [rsp+68h] [rbp-58h]
unsigned int i; // [rsp+74h] [rbp-4Ch]
long long v20; // [rsp+78h] [rbp-48h]
long long v21; // [rsp+80h] [rbp-40h]
long long v22; // [rsp+88h] [rbp-38h]
int NumElements; // [rsp+90h] [rbp-30h]
int NumRows; // [rsp+94h] [rbp-2Ch]
long long v25; // [rsp+98h] [rbp-28h]
int v26; // [rsp+A4h] [rbp-1Ch]
long long v27; // [rsp+A8h] [rbp-18h]
long long v28; // [rsp+B0h] [rbp-10h]
long long v29; // [rsp+B8h] [rbp-8h]
v29 = a1;
v28 = a2;
v27 = a3;
v26 = a4;
v25 = OpenSubdiv::v3_6_0::Far::PatchTable::StencilTablePtr::Get<float>(a1 + 72);
NumRows = OpenSubdiv::v3_6_0::Far::SparseMatrix<float>::GetNumRows(a2);
NumElements = OpenSubdiv::v3_6_0::Far::SparseMatrix<float>::GetNumElements(a2);
v22 = std::vector<int>::size(v25 + 16);
v21 = std::vector<int>::size(v25 + 64);
std::vector<int>::resize(v25 + 16, NumRows + v22);
v20 = std::vector<int>::operator[](v25 + 16, v22);
for ( i = 0; (int)i < NumRows; ++i )
*(_DWORD *)(v20 + 4LL * (int)i) = OpenSubdiv::v3_6_0::Far::SparseMatrix<float>::GetRowSize(v28, i);
std::vector<int>::resize(v25 + 64, NumElements + v21);
Columns = OpenSubdiv::v3_6_0::Far::SparseMatrix<float>::GetColumns(v28);
v15 = v5;
v14 = Columns;
v16 = Columns;
v17 = v5;
v18 = OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](&v16, 0LL);
v13 = std::vector<int>::operator[](v25 + 64, v21);
for ( j = 0; j < NumElements; ++j )
*(_DWORD *)(v13 + 4LL * j) = v26 + *(_DWORD *)(v27 + 4LL * *(int *)(v18 + 4LL * j));
std::vector<float>::resize(v25 + 88, NumElements + v21);
Elements = OpenSubdiv::v3_6_0::Far::SparseMatrix<float>::GetElements(v28);
v10 = v6;
v11 = OpenSubdiv::v3_6_0::Vtr::ConstArray<float>::operator[](&Elements, 0LL);
v8 = std::vector<float>::operator[](v25 + 88, v21);
return memcpy(v8, v11, 4LL * NumElements);
}
| |||
57,705
|
void OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointStencils<double>(OpenSubdiv::v3_6_0::Far::SparseMatrix<double> const&, int const*, int)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp
|
void
PatchTableBuilder::LocalPointHelper::appendLocalPointStencils(
SparseMatrix<REAL> const & conversionMatrix,
Index const sourcePoints[],
int sourcePointOffset) {
//
// Resize the StencilTable members to accomodate all rows and elements from
// the given set of points represented by the matrix
//
StencilTableReal<REAL>* stencilTable = _stencilTable.Get<REAL>();
int numNewStencils = conversionMatrix.GetNumRows();
int numNewElements = conversionMatrix.GetNumElements();
size_t numOldStencils = stencilTable->_sizes.size();
size_t numOldElements = stencilTable->_indices.size();
// Assign the sizes for the new stencils:
stencilTable->_sizes.resize(numOldStencils + numNewStencils);
int * newSizes = &stencilTable->_sizes[numOldStencils];
for (int i = 0; i < numNewStencils; ++i) {
newSizes[i] = conversionMatrix.GetRowSize(i);
}
// Assign remapped indices for the stencils:
stencilTable->_indices.resize(numOldElements + numNewElements);
int const * mtxIndices = &conversionMatrix.GetColumns()[0];
int * newIndices = &stencilTable->_indices[numOldElements];
for (int i = 0; i < numNewElements; ++i) {
newIndices[i] = sourcePoints[mtxIndices[i]] + sourcePointOffset;
}
// Copy the stencil weights direct from the matrix elements:
stencilTable->_weights.resize(numOldElements + numNewElements);
REAL const * mtxWeights = &conversionMatrix.GetElements()[0];
REAL * newWeights = &stencilTable->_weights[numOldElements];
std::memcpy(newWeights, mtxWeights, numNewElements * sizeof(REAL));
}
|
O1
|
cpp
|
void OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointStencils<double>(OpenSubdiv::v3_6_0::Far::SparseMatrix<double> const&, int const*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq 0x48(%rdi), %rax
movslq (%rsi), %r14
movq %rsi, (%rsp)
movslq 0x8(%rsi), %rbx
leaq 0x10(%rax), %rdi
movq 0x18(%rax), %r13
movq 0x48(%rax), %r12
subq 0x10(%rax), %r13
movq %r13, %rsi
sarq $0x2, %rsi
subq 0x40(%rax), %r12
movq %rax, 0x8(%rsp)
addq $0x40, %rax
movq %rax, 0x18(%rsp)
movq %r12, %rax
sarq $0x2, %rax
movq %rax, 0x20(%rsp)
addq %r14, %rsi
callq 0x39690
testq %r14, %r14
jle 0x6fa67
movq 0x8(%rsp), %rax
addq 0x10(%rax), %r13
movq (%rsp), %rax
movq 0x10(%rax), %rax
xorl %ecx, %ecx
movl 0x4(%rax,%rcx,4), %edx
subl (%rax,%rcx,4), %edx
movl %edx, (%r13,%rcx,4)
incq %rcx
cmpq %rcx, %r14
jne 0x6fa53
movq 0x20(%rsp), %r13
leaq (%rbx,%r13), %rsi
movq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rsi, 0x10(%rsp)
callq 0x39690
testl %ebx, %ebx
jle 0x6faa9
movq (%rsp), %rax
movq 0x28(%rax), %rax
addq (%r14), %r12
xorl %ecx, %ecx
movslq (%rax,%rcx,4), %rdx
movl (%r15,%rdx,4), %edx
addl %ebp, %edx
movl %edx, (%r12,%rcx,4)
incq %rcx
cmpq %rcx, %rbx
jne 0x6fa93
movq 0x8(%rsp), %r14
leaq 0x58(%r14), %rdi
movq 0x10(%rsp), %rsi
callq 0x3a2e0
movq (%rsp), %rax
movq 0x40(%rax), %rsi
shlq $0x3, %r13
addq 0x58(%r14), %r13
shlq $0x3, %rbx
movq %r13, %rdi
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39ad0
nop
|
_ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelper24appendLocalPointStencilsIdEEvRKNS1_12SparseMatrixIT_EEPKii:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, ecx
mov r15, rdx
mov rax, [rdi+48h]
movsxd r14, dword ptr [rsi]
mov [rsp+58h+var_58], rsi
movsxd rbx, dword ptr [rsi+8]
lea rdi, [rax+10h]
mov r13, [rax+18h]
mov r12, [rax+48h]
sub r13, [rax+10h]
mov rsi, r13
sar rsi, 2
sub r12, [rax+40h]
mov [rsp+58h+var_50], rax
add rax, 40h ; '@'
mov [rsp+58h+var_40], rax
mov rax, r12
sar rax, 2
mov [rsp+58h+var_38], rax
add rsi, r14
call __ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
test r14, r14
jle short loc_6FA67
mov rax, [rsp+58h+var_50]
add r13, [rax+10h]
mov rax, [rsp+58h+var_58]
mov rax, [rax+10h]
xor ecx, ecx
loc_6FA53:
mov edx, [rax+rcx*4+4]
sub edx, [rax+rcx*4]
mov [r13+rcx*4+0], edx
inc rcx
cmp r14, rcx
jnz short loc_6FA53
loc_6FA67:
mov r13, [rsp+58h+var_38]
lea rsi, [rbx+r13]
mov r14, [rsp+58h+var_40]
mov rdi, r14
mov [rsp+58h+var_48], rsi
call __ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
test ebx, ebx
jle short loc_6FAA9
mov rax, [rsp+58h+var_58]
mov rax, [rax+28h]
add r12, [r14]
xor ecx, ecx
loc_6FA93:
movsxd rdx, dword ptr [rax+rcx*4]
mov edx, [r15+rdx*4]
add edx, ebp
mov [r12+rcx*4], edx
inc rcx
cmp rbx, rcx
jnz short loc_6FA93
loc_6FAA9:
mov r14, [rsp+58h+var_50]
lea rdi, [r14+58h]
mov rsi, [rsp+58h+var_48]
call __ZNSt6vectorIdSaIdEE6resizeEm; std::vector<double>::resize(ulong)
mov rax, [rsp+58h+var_58]
mov rsi, [rax+40h]
shl r13, 3
add r13, [r14+58h]
shl rbx, 3
mov rdi, r13
mov rdx, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memcpy
|
long long OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointStencils<double>(
long long a1,
int *a2,
long long a3,
int a4)
{
_QWORD *v6; // rax
long long v7; // r14
long long v8; // rbx
long long v9; // r13
long long v10; // r12
long long v11; // r13
long long v12; // rax
long long i; // rcx
long long v14; // rax
long long v15; // r12
long long j; // rcx
long long v17; // rcx
long long v18; // r8
long long v19; // r9
_QWORD *v21; // [rsp+8h] [rbp-50h]
_QWORD *v22; // [rsp+18h] [rbp-40h]
long long v23; // [rsp+20h] [rbp-38h]
v6 = *(_QWORD **)(a1 + 72);
v7 = *a2;
v8 = a2[2];
v9 = v6[3] - v6[2];
v10 = v6[9] - v6[8];
v21 = v6;
v22 = v6 + 8;
v23 = v10 >> 2;
std::vector<int>::resize(v6 + 2, v7 + (v9 >> 2));
if ( v7 > 0 )
{
v11 = v21[2] + v9;
v12 = *((_QWORD *)a2 + 2);
for ( i = 0LL; i != v7; ++i )
*(_DWORD *)(v11 + 4 * i) = *(_DWORD *)(v12 + 4 * i + 4) - *(_DWORD *)(v12 + 4 * i);
}
std::vector<int>::resize(v22, v8 + v23);
if ( (int)v8 > 0 )
{
v14 = *((_QWORD *)a2 + 5);
v15 = *v22 + v10;
for ( j = 0LL; j != v8; ++j )
*(_DWORD *)(v15 + 4 * j) = a4 + *(_DWORD *)(a3 + 4LL * *(int *)(v14 + 4 * j));
}
std::vector<double>::resize(v21 + 11, v8 + v23);
return memcpy(v21[11] + 8 * v23, *((_QWORD *)a2 + 8), 8 * v8, v17, v18, v19);
}
|
appendLocalPointStencils<double>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,ECX
MOV R15,RDX
MOV RAX,qword ptr [RDI + 0x48]
MOVSXD R14,dword ptr [RSI]
MOV qword ptr [RSP],RSI
MOVSXD RBX,dword ptr [RSI + 0x8]
LEA RDI,[RAX + 0x10]
MOV R13,qword ptr [RAX + 0x18]
MOV R12,qword ptr [RAX + 0x48]
SUB R13,qword ptr [RAX + 0x10]
MOV RSI,R13
SAR RSI,0x2
SUB R12,qword ptr [RAX + 0x40]
MOV qword ptr [RSP + 0x8],RAX
ADD RAX,0x40
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,R12
SAR RAX,0x2
MOV qword ptr [RSP + 0x20],RAX
ADD RSI,R14
CALL 0x00139690
TEST R14,R14
JLE 0x0016fa67
MOV RAX,qword ptr [RSP + 0x8]
ADD R13,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX + 0x10]
XOR ECX,ECX
LAB_0016fa53:
MOV EDX,dword ptr [RAX + RCX*0x4 + 0x4]
SUB EDX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [R13 + RCX*0x4],EDX
INC RCX
CMP R14,RCX
JNZ 0x0016fa53
LAB_0016fa67:
MOV R13,qword ptr [RSP + 0x20]
LEA RSI,[RBX + R13*0x1]
MOV R14,qword ptr [RSP + 0x18]
MOV RDI,R14
MOV qword ptr [RSP + 0x10],RSI
CALL 0x00139690
TEST EBX,EBX
JLE 0x0016faa9
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX + 0x28]
ADD R12,qword ptr [R14]
XOR ECX,ECX
LAB_0016fa93:
MOVSXD RDX,dword ptr [RAX + RCX*0x4]
MOV EDX,dword ptr [R15 + RDX*0x4]
ADD EDX,EBP
MOV dword ptr [R12 + RCX*0x4],EDX
INC RCX
CMP RBX,RCX
JNZ 0x0016fa93
LAB_0016faa9:
MOV R14,qword ptr [RSP + 0x8]
LEA RDI,[R14 + 0x58]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x0013a2e0
MOV RAX,qword ptr [RSP]
MOV RSI,qword ptr [RAX + 0x40]
SHL R13,0x3
ADD R13,qword ptr [R14 + 0x58]
SHL RBX,0x3
MOV RDI,R13
MOV RDX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00139ad0
|
/* void
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointStencils<double>(OpenSubdiv::v3_6_0::Far::SparseMatrix<double>
const&, int const*, int) */
void __thiscall
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointStencils<double>
(LocalPointHelper *this,SparseMatrix *param_1,int *param_2,int param_3)
{
ulong uVar1;
int iVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
long lVar9;
long lVar10;
long lVar11;
lVar3 = *(long *)(this + 0x48);
lVar11 = (long)*(int *)param_1;
iVar2 = *(int *)(param_1 + 8);
lVar8 = (long)iVar2;
lVar10 = *(long *)(lVar3 + 0x18) - *(long *)(lVar3 + 0x10);
lVar9 = *(long *)(lVar3 + 0x48) - *(long *)(lVar3 + 0x40);
lVar5 = lVar9 >> 2;
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(lVar3 + 0x10),(lVar10 >> 2) + lVar11);
if (0 < lVar11) {
lVar7 = *(long *)(lVar3 + 0x10);
lVar4 = *(long *)(param_1 + 0x10);
lVar6 = 0;
do {
*(int *)(lVar10 + lVar7 + lVar6 * 4) =
*(int *)(lVar4 + 4 + lVar6 * 4) - *(int *)(lVar4 + lVar6 * 4);
lVar6 = lVar6 + 1;
} while (lVar11 != lVar6);
}
uVar1 = lVar8 + lVar5;
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(lVar3 + 0x40),uVar1);
if (0 < iVar2) {
lVar10 = *(long *)(param_1 + 0x28);
lVar11 = *(long *)(lVar3 + 0x40);
lVar7 = 0;
do {
*(int *)(lVar9 + lVar11 + lVar7 * 4) = param_2[*(int *)(lVar10 + lVar7 * 4)] + param_3;
lVar7 = lVar7 + 1;
} while (lVar8 != lVar7);
}
std::vector<double,std::allocator<double>>::resize
((vector<double,std::allocator<double>> *)(lVar3 + 0x58),uVar1);
memcpy((void *)(lVar5 * 8 + *(long *)(lVar3 + 0x58)),*(void **)(param_1 + 0x40),lVar8 << 3);
return;
}
|
|
57,706
|
void OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointStencils<double>(OpenSubdiv::v3_6_0::Far::SparseMatrix<double> const&, int const*, int)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp
|
void
PatchTableBuilder::LocalPointHelper::appendLocalPointStencils(
SparseMatrix<REAL> const & conversionMatrix,
Index const sourcePoints[],
int sourcePointOffset) {
//
// Resize the StencilTable members to accomodate all rows and elements from
// the given set of points represented by the matrix
//
StencilTableReal<REAL>* stencilTable = _stencilTable.Get<REAL>();
int numNewStencils = conversionMatrix.GetNumRows();
int numNewElements = conversionMatrix.GetNumElements();
size_t numOldStencils = stencilTable->_sizes.size();
size_t numOldElements = stencilTable->_indices.size();
// Assign the sizes for the new stencils:
stencilTable->_sizes.resize(numOldStencils + numNewStencils);
int * newSizes = &stencilTable->_sizes[numOldStencils];
for (int i = 0; i < numNewStencils; ++i) {
newSizes[i] = conversionMatrix.GetRowSize(i);
}
// Assign remapped indices for the stencils:
stencilTable->_indices.resize(numOldElements + numNewElements);
int const * mtxIndices = &conversionMatrix.GetColumns()[0];
int * newIndices = &stencilTable->_indices[numOldElements];
for (int i = 0; i < numNewElements; ++i) {
newIndices[i] = sourcePoints[mtxIndices[i]] + sourcePointOffset;
}
// Copy the stencil weights direct from the matrix elements:
stencilTable->_weights.resize(numOldElements + numNewElements);
REAL const * mtxWeights = &conversionMatrix.GetElements()[0];
REAL * newWeights = &stencilTable->_weights[numOldElements];
std::memcpy(newWeights, mtxWeights, numNewElements * sizeof(REAL));
}
|
O2
|
cpp
|
void OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointStencils<double>(OpenSubdiv::v3_6_0::Far::SparseMatrix<double> const&, int const*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq 0x48(%rdi), %r14
movslq (%rsi), %rbx
movslq 0x8(%rsi), %rax
movq %rax, 0x20(%rsp)
leaq 0x10(%r14), %rdi
movq 0x18(%r14), %r15
movq 0x48(%r14), %rax
subq 0x10(%r14), %r15
movq %r15, %rsi
sarq $0x2, %rsi
leaq 0x40(%r14), %rcx
movq %rcx, 0x18(%rsp)
subq 0x40(%r14), %rax
movq %rax, 0x8(%rsp)
addq %rbx, %rsi
callq 0x514b0
addq 0x10(%r14), %r15
movq %r13, 0x10(%rsp)
movq 0x10(%r13), %rax
xorl %ecx, %ecx
testl %ebx, %ebx
movl $0x0, %edx
cmovgl %ebx, %edx
cmpq %rcx, %rdx
je 0x81973
movl 0x4(%rax,%rcx,4), %esi
subl (%rax,%rcx,4), %esi
movl %esi, (%r15,%rcx,4)
incq %rcx
jmp 0x8195e
movq 0x8(%rsp), %r15
sarq $0x2, %r15
movq 0x20(%rsp), %rbx
addq %rbx, %r15
movq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x514b0
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq (%r13), %rcx
movq 0x8(%rsp), %r13
addq %r13, %rcx
xorl %edx, %edx
testl %ebx, %ebx
movl $0x0, %esi
cmovgl %ebx, %esi
cmpq %rdx, %rsi
je 0x819cc
movslq (%rax,%rdx,4), %rdi
movl (%r12,%rdi,4), %edi
addl %ebp, %edi
movl %edi, (%rcx,%rdx,4)
incq %rdx
jmp 0x819b5
leaq 0x58(%r14), %rdi
movq %r15, %rsi
callq 0x51a70
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rsi
addq 0x58(%r14), %r13
shlq $0x2, %rbx
movq %r13, %rdi
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x51bd0
|
_ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelper24appendLocalPointStencilsIfEEvRKNS1_12SparseMatrixIT_EEPKii:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, ecx
mov r12, rdx
mov r13, rsi
mov r14, [rdi+48h]
movsxd rbx, dword ptr [rsi]
movsxd rax, dword ptr [rsi+8]
mov [rsp+58h+var_38], rax
lea rdi, [r14+10h]
mov r15, [r14+18h]
mov rax, [r14+48h]
sub r15, [r14+10h]
mov rsi, r15
sar rsi, 2
lea rcx, [r14+40h]
mov [rsp+58h+var_40], rcx
sub rax, [r14+40h]
mov [rsp+58h+var_50], rax
add rsi, rbx
call __ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
add r15, [r14+10h]
mov [rsp+58h+var_48], r13
mov rax, [r13+10h]
xor ecx, ecx
test ebx, ebx
mov edx, 0
cmovg edx, ebx
loc_8195E:
cmp rdx, rcx
jz short loc_81973
mov esi, [rax+rcx*4+4]
sub esi, [rax+rcx*4]
mov [r15+rcx*4], esi
inc rcx
jmp short loc_8195E
loc_81973:
mov r15, [rsp+58h+var_50]
sar r15, 2
mov rbx, [rsp+58h+var_38]
add r15, rbx
mov r13, [rsp+58h+var_40]
mov rdi, r13
mov rsi, r15
call __ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
mov rax, [rsp+58h+var_48]
mov rax, [rax+28h]
mov rcx, [r13+0]
mov r13, [rsp+58h+var_50]
add rcx, r13
xor edx, edx
test ebx, ebx
mov esi, 0
cmovg esi, ebx
loc_819B5:
cmp rsi, rdx
jz short loc_819CC
movsxd rdi, dword ptr [rax+rdx*4]
mov edi, [r12+rdi*4]
add edi, ebp
mov [rcx+rdx*4], edi
inc rdx
jmp short loc_819B5
loc_819CC:
lea rdi, [r14+58h]
mov rsi, r15
call __ZNSt6vectorIfSaIfEE6resizeEm; std::vector<float>::resize(ulong)
mov rax, [rsp+58h+var_48]
mov rsi, [rax+40h]
add r13, [r14+58h]
shl rbx, 2
mov rdi, r13
mov rdx, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memcpy
|
long long OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointStencils<float>(
long long a1,
int *a2,
long long a3,
int a4)
{
_QWORD *v6; // r14
long long v7; // rbx
long long v8; // r15
long long v9; // r15
long long v10; // rax
long long v11; // rcx
long long v12; // rdx
long long v13; // rax
long long v14; // rcx
long long v15; // rdx
long long v16; // rsi
long long v17; // rcx
long long v18; // r8
long long v19; // r9
long long v21; // [rsp+8h] [rbp-50h]
_QWORD *v23; // [rsp+18h] [rbp-40h]
long long v24; // [rsp+20h] [rbp-38h]
v6 = *(_QWORD **)(a1 + 72);
v7 = *a2;
v24 = a2[2];
v8 = v6[3] - v6[2];
v23 = v6 + 8;
v21 = v6[9] - v6[8];
std::vector<int>::resize(v6 + 2, v7 + (v8 >> 2));
v9 = v6[2] + v8;
v10 = *((_QWORD *)a2 + 2);
v11 = 0LL;
v12 = 0LL;
if ( (int)v7 > 0 )
v12 = (unsigned int)v7;
while ( v12 != v11 )
{
*(_DWORD *)(v9 + 4 * v11) = *(_DWORD *)(v10 + 4 * v11 + 4) - *(_DWORD *)(v10 + 4 * v11);
++v11;
}
std::vector<int>::resize(v23, v24 + (v21 >> 2));
v13 = *((_QWORD *)a2 + 5);
v14 = v21 + *v23;
v15 = 0LL;
v16 = 0LL;
if ( (int)v24 > 0 )
v16 = (unsigned int)v24;
while ( v16 != v15 )
{
*(_DWORD *)(v14 + 4 * v15) = a4 + *(_DWORD *)(a3 + 4LL * *(int *)(v13 + 4 * v15));
++v15;
}
std::vector<float>::resize(v6 + 11, v24 + (v21 >> 2));
return memcpy(v6[11] + v21, *((_QWORD *)a2 + 8), 4 * v24, v17, v18, v19);
}
|
appendLocalPointStencils<float>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,ECX
MOV R12,RDX
MOV R13,RSI
MOV R14,qword ptr [RDI + 0x48]
MOVSXD RBX,dword ptr [RSI]
MOVSXD RAX,dword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[R14 + 0x10]
MOV R15,qword ptr [R14 + 0x18]
MOV RAX,qword ptr [R14 + 0x48]
SUB R15,qword ptr [R14 + 0x10]
MOV RSI,R15
SAR RSI,0x2
LEA RCX,[R14 + 0x40]
MOV qword ptr [RSP + 0x18],RCX
SUB RAX,qword ptr [R14 + 0x40]
MOV qword ptr [RSP + 0x8],RAX
ADD RSI,RBX
CALL 0x001514b0
ADD R15,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x10],R13
MOV RAX,qword ptr [R13 + 0x10]
XOR ECX,ECX
TEST EBX,EBX
MOV EDX,0x0
CMOVG EDX,EBX
LAB_0018195e:
CMP RDX,RCX
JZ 0x00181973
MOV ESI,dword ptr [RAX + RCX*0x4 + 0x4]
SUB ESI,dword ptr [RAX + RCX*0x4]
MOV dword ptr [R15 + RCX*0x4],ESI
INC RCX
JMP 0x0018195e
LAB_00181973:
MOV R15,qword ptr [RSP + 0x8]
SAR R15,0x2
MOV RBX,qword ptr [RSP + 0x20]
ADD R15,RBX
MOV R13,qword ptr [RSP + 0x18]
MOV RDI,R13
MOV RSI,R15
CALL 0x001514b0
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [R13]
MOV R13,qword ptr [RSP + 0x8]
ADD RCX,R13
XOR EDX,EDX
TEST EBX,EBX
MOV ESI,0x0
CMOVG ESI,EBX
LAB_001819b5:
CMP RSI,RDX
JZ 0x001819cc
MOVSXD RDI,dword ptr [RAX + RDX*0x4]
MOV EDI,dword ptr [R12 + RDI*0x4]
ADD EDI,EBP
MOV dword ptr [RCX + RDX*0x4],EDI
INC RDX
JMP 0x001819b5
LAB_001819cc:
LEA RDI,[R14 + 0x58]
MOV RSI,R15
CALL 0x00151a70
MOV RAX,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RAX + 0x40]
ADD R13,qword ptr [R14 + 0x58]
SHL RBX,0x2
MOV RDI,R13
MOV RDX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00151bd0
|
/* void
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointStencils<float>(OpenSubdiv::v3_6_0::Far::SparseMatrix<float>
const&, int const*, int) */
void __thiscall
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointStencils<float>
(LocalPointHelper *this,SparseMatrix *param_1,int *param_2,int param_3)
{
uint uVar1;
uint uVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
ulong uVar7;
ulong uVar8;
long lVar9;
ulong uVar10;
lVar3 = *(long *)(this + 0x48);
uVar1 = *(uint *)param_1;
uVar2 = *(uint *)(param_1 + 8);
lVar9 = *(long *)(lVar3 + 0x18) - *(long *)(lVar3 + 0x10);
lVar6 = *(long *)(lVar3 + 0x48) - *(long *)(lVar3 + 0x40);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(lVar3 + 0x10),(lVar9 >> 2) + (long)(int)uVar1);
lVar4 = *(long *)(lVar3 + 0x10);
lVar5 = *(long *)(param_1 + 0x10);
uVar7 = 0;
uVar8 = 0;
if (0 < (int)uVar1) {
uVar8 = (ulong)uVar1;
}
for (; uVar8 != uVar7; uVar7 = uVar7 + 1) {
*(int *)(lVar9 + lVar4 + uVar7 * 4) =
*(int *)(lVar5 + 4 + uVar7 * 4) - *(int *)(lVar5 + uVar7 * 4);
}
uVar10 = (lVar6 >> 2) + (long)(int)uVar2;
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(lVar3 + 0x40),uVar10);
lVar4 = *(long *)(param_1 + 0x28);
lVar5 = *(long *)(lVar3 + 0x40);
uVar7 = 0;
uVar8 = 0;
if (0 < (int)uVar2) {
uVar8 = (ulong)uVar2;
}
for (; uVar8 != uVar7; uVar7 = uVar7 + 1) {
*(int *)(lVar5 + lVar6 + uVar7 * 4) = param_2[*(int *)(lVar4 + uVar7 * 4)] + param_3;
}
std::vector<float,std::allocator<float>>::resize
((vector<float,std::allocator<float>> *)(lVar3 + 0x58),uVar10);
memcpy((void *)(lVar6 + *(long *)(lVar3 + 0x58)),*(void **)(param_1 + 0x40),(long)(int)uVar2 << 2)
;
return;
}
|
|
57,707
|
common_chat_params_init_deepseek_r1(minja::chat_template const&, common_chat_inputs const&)
|
monkey531[P]llama/common/chat.cpp
|
static common_chat_params common_chat_params_init_deepseek_r1(const common_chat_template & tmpl, const struct common_chat_inputs & inputs) {
common_chat_params data;
data.grammar_lazy = inputs.tool_choice != "required";
data.grammar = build_grammar([&](const common_grammar_builder & builder) {
std::vector<std::string> tool_rules;
foreach_function(inputs.tools, [&](const json & tool) {
const auto & function = tool["function"];
std::string name = function["name"];
auto parameters = function["parameters"];
auto args_rule = builder.add_schema(name + "-args", parameters);
tool_rules.push_back(builder.add_rule(name + "-call",
"\"<｜tool▁call▁begin｜>function<｜tool▁sep｜>" + name + "\\n```json\\n\" " + args_rule + " \"```<｜tool▁call▁end｜>\""));
});
data.grammar_triggers.push_back({"<｜tool▁calls▁begin｜>", /* .at_start = */ false});
data.preserved_tokens = {
"<｜tool▁sep｜>",
"<｜tool▁call▁end｜>",
};
builder.add_rule("root", "\"<｜tool▁calls▁begin｜>\" (" + string_join(tool_rules, " | ") + ")" + (inputs.parallel_tool_calls ? "*" : "") + " space");
}, grammar_options);
data.prompt = tmpl.apply(inputs.messages, inputs.tools.empty() ? json() : inputs.tools, inputs.add_generation_prompt);
data.format = COMMON_CHAT_FORMAT_DEEPSEEK_R1;
return data;
}
|
O1
|
cpp
|
common_chat_params_init_deepseek_r1(minja::chat_template const&, common_chat_inputs const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x0, (%rdi)
xorl %eax, %eax
movb %al, 0x8(%rdi)
movq %rax, 0x10(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movb %al, 0x28(%rdi)
movb %al, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x70(%rdi)
movq %rax, 0x80(%rdi)
leaq 0x20(%rdx), %rdi
leaq 0x1eedf(%rip), %rsi # 0xf2755
callq 0xa63ed
movb %al, 0x38(%rbx)
leaq 0x10(%rsp), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %r14, (%rsi)
movq %rbx, 0x8(%rsi)
leaq 0xd447(%rip), %rax # 0xe0ce2
movq %rax, 0x18(%rsi)
leaq 0xdad8(%rip), %rax # 0xe137e
movq %rax, 0x10(%rsi)
leaq 0x250e7(%rip), %rdx # 0xf8998
leaq 0x38(%rsp), %rdi
callq 0xbc68e
leaq 0x18(%rbx), %rdi
leaq 0x38(%rsp), %r12
movq %r12, %rsi
callq 0x1bac0
movq (%r12), %rdi
leaq 0x48(%rsp), %r12
cmpq %r12, %rdi
je 0xd38e7
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xd3900
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movzbl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0xd392a
movq 0x18(%r14), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0xd392e
leaq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0x5dd4c
jmp 0xd393c
testl %eax, %eax
jne 0xd391a
movb $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movzbl 0x68(%r14), %r8d
leaq 0x58(%rsp), %r9
movb $0x0, (%r9)
movq $0x0, 0x8(%r9)
movl $0x1, (%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0xa2aac
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x807d4
movb 0x8(%rbx), %al
leaq 0x68(%rsp), %rdi
movb (%rdi), %cl
movb %cl, 0x8(%rbx)
movb %al, (%rdi)
movq 0x10(%rbx), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rdi)
callq 0x5e2ac
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0xd39b8
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1b8f0
leaq 0x58(%rsp), %rdi
callq 0x5e2ac
leaq 0x10(%rsp), %rdi
callq 0x5e2ac
movl $0x5, (%rbx)
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0xd3a39
jmp 0xd3a49
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0xd3a07
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1b8f0
jmp 0xd3a07
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x5e2ac
leaq 0x10(%rsp), %rdi
callq 0x5e2ac
jmp 0xd3a39
movq %rax, %r14
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xd3a39
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x7f26e
movq %r14, %rdi
callq 0x1bfd0
movq %rax, %rdi
callq 0x229a1
|
_ZL35common_chat_params_init_deepseek_r1RKN5minja13chat_templateERK18common_chat_inputs:
push r15
push r14
push r12
push rbx
sub rsp, 78h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov dword ptr [rdi], 0
xor eax, eax
mov [rdi+8], al
mov [rdi+10h], rax
lea rcx, [rdi+28h]
mov [rdi+18h], rcx
mov [rdi+20h], rax
mov [rdi+28h], al
mov [rdi+38h], al
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+50h], xmm0
movups xmmword ptr [rdi+60h], xmm0
movups xmmword ptr [rdi+70h], xmm0
mov [rdi+80h], rax
lea rdi, [rdx+20h]
lea rsi, aRequired; "required"
call _ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
mov [rbx+38h], al
lea rsi, [rsp+98h+var_88]
xorps xmm0, xmm0
movaps xmmword ptr [rsi], xmm0
movaps xmmword ptr [rsi+10h], xmm0
mov [rsi], r14
mov [rsi+8], rbx
lea rax, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZL35common_chat_params_init_deepseek_r1RKN5minja13chat_templateERK18common_chat_inputsE3$_0E9_M_invokeERKSt9_Any_dataS2_; std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_invoke(std::_Any_data const&,common_grammar_builder const&)
mov [rsi+18h], rax
lea rax, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZL35common_chat_params_init_deepseek_r1RKN5minja13chat_templateERK18common_chat_inputsE3$_0E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation; std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsi+10h], rax
lea rdx, _ZL15grammar_options; grammar_options
lea rdi, [rsp+98h+var_60]
call _Z13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_options; build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)
lea rdi, [rbx+18h]
lea r12, [rsp+98h+var_60]
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r12]; void *
lea r12, [rsp+98h+var_50]
cmp rdi, r12
jz short loc_D38E7
mov rsi, [rsp+98h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D38E7:
mov rax, [rsp+98h+var_78]
test rax, rax
jz short loc_D3900
lea rdi, [rsp+98h+var_88]
mov rsi, rdi
mov edx, 3
call rax
loc_D3900:
movzx eax, byte ptr [r14+10h]
lea ecx, [rax-1]
cmp ecx, 2
jnb short loc_D392A
mov rax, [r14+18h]
mov rcx, [rax]
cmp rcx, [rax+8]
jz short loc_D392E
loc_D391A:
lea rsi, [r14+10h]
lea rdi, [rsp+98h+var_88]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
jmp short loc_D393C
loc_D392A:
test eax, eax
jnz short loc_D391A
loc_D392E:
mov [rsp+98h+var_88], 0
mov [rsp+98h+var_80], 0
loc_D393C:
movzx r8d, byte ptr [r14+68h]
lea r9, [rsp+98h+var_40]
mov byte ptr [r9], 0
mov qword ptr [r9+8], 0
mov [rsp+98h+var_98], 1
lea rdi, [rsp+98h+var_60]
lea rcx, [rsp+98h+var_88]
mov rsi, r15
mov rdx, r14
call _ZNK5minja13chat_template5applyERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEESH_bSH_b; minja::chat_template::apply(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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&,bool,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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&,bool)
lea rdi, [rsp+98h+var_30]
lea rsi, [rsp+98h+var_60]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
mov al, [rbx+8]
lea rdi, [rsp+98h+var_30]
mov cl, [rdi]
mov [rbx+8], cl
mov [rdi], al
mov rax, [rbx+10h]
mov rcx, [rdi+8]
mov [rbx+10h], rcx
mov [rdi+8], rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+98h+var_60]; void *
cmp rdi, r12
jz short loc_D39B8
mov rsi, [rsp+98h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D39B8:
lea rdi, [rsp+98h+var_40]
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()
lea rdi, [rsp+98h+var_88]
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 dword ptr [rbx], 5
mov rax, rbx
add rsp, 78h
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
jmp short loc_D3A39
jmp short loc_D3A49
mov r14, rax
mov rdi, [rsp+98h+var_60]; void *
cmp rdi, r12
jz short loc_D3A07
mov rsi, [rsp+98h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D3A07
mov r14, rax
loc_D3A07:
lea rdi, [rsp+98h+var_40]
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()
lea rdi, [rsp+98h+var_88]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_D3A39
mov r14, rax
mov rax, [rsp+98h+var_78]
test rax, rax
jz short loc_D3A39
lea rdi, [rsp+98h+var_88]
mov rsi, rdi
mov edx, 3
call rax
loc_D3A39:
mov rdi, rbx; this
call _ZN18common_chat_paramsD2Ev; common_chat_params::~common_chat_params()
mov rdi, r14
call __Unwind_Resume
loc_D3A49:
mov rdi, rax
call __clang_call_terminate
|
const minja::chat_template * common_chat_params_init_deepseek_r1(
const minja::chat_template *a1,
const common_chat_inputs *a2,
long long a3)
{
long long v4; // rcx
int v5; // r8d
int v6; // r9d
int v7; // r8d
char v8; // al
long long v9; // rax
long long v11; // [rsp+10h] [rbp-88h] BYREF
const minja::chat_template *v12; // [rsp+18h] [rbp-80h]
long long ( *v13)(); // [rsp+20h] [rbp-78h]
long long ( *v14)(); // [rsp+28h] [rbp-70h]
void *v15[2]; // [rsp+38h] [rbp-60h] BYREF
_QWORD v16[2]; // [rsp+48h] [rbp-50h] BYREF
unsigned __int8 v17[8]; // [rsp+58h] [rbp-40h] BYREF
long long v18; // [rsp+60h] [rbp-38h]
char v19[8]; // [rsp+68h] [rbp-30h] BYREF
long long v20; // [rsp+70h] [rbp-28h]
*(_DWORD *)a1 = 0;
*((_BYTE *)a1 + 8) = 0;
*((_QWORD *)a1 + 2) = 0LL;
*((_QWORD *)a1 + 3) = (char *)a1 + 40;
*((_QWORD *)a1 + 4) = 0LL;
*((_BYTE *)a1 + 40) = 0;
*((_BYTE *)a1 + 56) = 0;
*((_OWORD *)a1 + 4) = 0LL;
*((_OWORD *)a1 + 5) = 0LL;
*((_OWORD *)a1 + 6) = 0LL;
*((_OWORD *)a1 + 7) = 0LL;
*((_QWORD *)a1 + 16) = 0LL;
*((_BYTE *)a1 + 56) = ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_(
a3 + 32,
(long long)"required");
v11 = a3;
v12 = a1;
v14 = std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_invoke;
v13 = std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_manager;
build_grammar[abi:cxx11]((long long)v15, (long long)&v11, grammar_options, v4, v5, v6);
std::string::operator=((char *)a1 + 24, v15);
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
if ( v13 )
((void ( *)(long long *, long long *, long long))v13)(&v11, &v11, 3LL);
if ( (unsigned int)*(unsigned __int8 *)(a3 + 16) - 1 >= 2 )
{
if ( *(_BYTE *)(a3 + 16) )
goto LABEL_7;
}
else if ( **(_QWORD **)(a3 + 24) != *(_QWORD *)(*(_QWORD *)(a3 + 24) + 8LL) )
{
LABEL_7:
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(
(unsigned __int8 *)&v11,
(unsigned __int8 *)(a3 + 16));
goto LABEL_10;
}
LOBYTE(v11) = 0;
v12 = 0LL;
LABEL_10:
v7 = *(unsigned __int8 *)(a3 + 104);
v17[0] = 0;
v18 = 0LL;
minja::chat_template::apply((long long)v15, a2, (unsigned __int8 *)a3, (unsigned __int8 *)&v11, v7, v17, 1);
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_(v19);
v8 = *((_BYTE *)a1 + 8);
*((_BYTE *)a1 + 8) = v19[0];
v19[0] = v8;
v9 = *((_QWORD *)a1 + 2);
*((_QWORD *)a1 + 2) = v20;
v20 = v9;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v19);
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
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(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>::data::~data(&v11);
*(_DWORD *)a1 = 5;
return a1;
}
|
common_chat_params_init_deepseek_r1:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV dword ptr [RDI],0x0
XOR EAX,EAX
MOV byte ptr [RDI + 0x8],AL
MOV qword ptr [RDI + 0x10],RAX
LEA RCX,[RDI + 0x28]
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],RAX
MOV byte ptr [RDI + 0x28],AL
MOV byte ptr [RDI + 0x38],AL
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x50],XMM0
MOVUPS xmmword ptr [RDI + 0x60],XMM0
MOVUPS xmmword ptr [RDI + 0x70],XMM0
MOV qword ptr [RDI + 0x80],RAX
LEA RDI,[RDX + 0x20]
LEA RSI,[0x1f2755]
CALL 0x001a63ed
MOV byte ptr [RBX + 0x38],AL
LEA RSI,[RSP + 0x10]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSI],XMM0
MOVAPS xmmword ptr [RSI + 0x10],XMM0
MOV qword ptr [RSI],R14
MOV qword ptr [RSI + 0x8],RBX
LEA RAX,[0x1e0ce2]
MOV qword ptr [RSI + 0x18],RAX
LEA RAX,[0x1e137e]
MOV qword ptr [RSI + 0x10],RAX
LAB_001d38aa:
LEA RDX,[0x1f8998]
LEA RDI,[RSP + 0x38]
CALL 0x001bc68e
LEA RDI,[RBX + 0x18]
LEA R12,[RSP + 0x38]
MOV RSI,R12
CALL 0x0011bac0
MOV RDI,qword ptr [R12]
LEA R12,[RSP + 0x48]
CMP RDI,R12
JZ 0x001d38e7
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x0011b8f0
LAB_001d38e7:
MOV RAX,qword ptr [RSP + 0x20]
TEST RAX,RAX
JZ 0x001d3900
LAB_001d38f1:
LEA RDI,[RSP + 0x10]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001d3900:
MOVZX EAX,byte ptr [R14 + 0x10]
LEA ECX,[RAX + -0x1]
CMP ECX,0x2
JNC 0x001d392a
MOV RAX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RAX]
CMP RCX,qword ptr [RAX + 0x8]
JZ 0x001d392e
LAB_001d391a:
LEA RSI,[R14 + 0x10]
LEA RDI,[RSP + 0x10]
CALL 0x0015dd4c
JMP 0x001d393c
LAB_001d392a:
TEST EAX,EAX
JNZ 0x001d391a
LAB_001d392e:
MOV byte ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
LAB_001d393c:
MOVZX R8D,byte ptr [R14 + 0x68]
LEA R9,[RSP + 0x58]
MOV byte ptr [R9],0x0
MOV qword ptr [R9 + 0x8],0x0
LAB_001d3952:
MOV dword ptr [RSP],0x1
LEA RDI,[RSP + 0x38]
LEA RCX,[RSP + 0x10]
MOV RSI,R15
MOV RDX,R14
CALL 0x001a2aac
LAB_001d396e:
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x38]
CALL 0x001807d4
MOV AL,byte ptr [RBX + 0x8]
LEA RDI,[RSP + 0x68]
MOV CL,byte ptr [RDI]
MOV byte ptr [RBX + 0x8],CL
MOV byte ptr [RDI],AL
MOV RAX,qword ptr [RBX + 0x10]
MOV RCX,qword ptr [RDI + 0x8]
MOV qword ptr [RBX + 0x10],RCX
MOV qword ptr [RDI + 0x8],RAX
CALL 0x0015e2ac
MOV RDI,qword ptr [RSP + 0x38]
CMP RDI,R12
JZ 0x001d39b8
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x0011b8f0
LAB_001d39b8:
LEA RDI,[RSP + 0x58]
CALL 0x0015e2ac
LEA RDI,[RSP + 0x10]
CALL 0x0015e2ac
MOV dword ptr [RBX],0x5
MOV RAX,RBX
ADD RSP,0x78
POP RBX
POP R12
POP R14
POP R15
RET
|
/* common_chat_params_init_deepseek_r1(minja::chat_template const&, common_chat_inputs const&) */
chat_template *
common_chat_params_init_deepseek_r1(chat_template *param_1,common_chat_inputs *param_2)
{
int8 uVar1;
chat_template cVar2;
ulong in_RDX;
ulong local_88;
chat_template *pcStack_80;
code *local_78;
code *pcStack_70;
long *local_60 [2];
long local_50 [2];
data local_40 [8];
int8 local_38;
chat_template local_30 [8];
int8 local_28;
*(int4 *)param_1 = 0;
param_1[8] = (chat_template)0x0;
*(int8 *)(param_1 + 0x10) = 0;
*(chat_template **)(param_1 + 0x18) = param_1 + 0x28;
*(int8 *)(param_1 + 0x20) = 0;
param_1[0x28] = (chat_template)0x0;
param_1[0x38] = (chat_template)0x0;
*(int8 *)(param_1 + 0x40) = 0;
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)(param_1 + 0x50) = 0;
*(int8 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x60) = 0;
*(int8 *)(param_1 + 0x68) = 0;
*(int8 *)(param_1 + 0x70) = 0;
*(int8 *)(param_1 + 0x78) = 0;
*(int8 *)(param_1 + 0x80) = 0;
cVar2 = (chat_template)
_ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
(in_RDX + 0x20,"required");
param_1[0x38] = cVar2;
pcStack_70 = std::
_Function_handler<void(common_grammar_builder_const&),common_chat_params_init_deepseek_r1(minja::chat_template_const&,common_chat_inputs_const&)::$_0>
::_M_invoke;
local_78 = std::
_Function_handler<void(common_grammar_builder_const&),common_chat_params_init_deepseek_r1(minja::chat_template_const&,common_chat_inputs_const&)::$_0>
::_M_manager;
/* try { // try from 001d38aa to 001d38ba has its CatchHandler @ 001d3a1d */
local_88 = in_RDX;
pcStack_80 = param_1;
build_grammar_abi_cxx11_((function *)local_60,(common_grammar_options *)&local_88);
std::__cxx11::string::operator=((string *)(param_1 + 0x18),(string *)local_60);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
if (local_78 != (code *)0x0) {
/* try { // try from 001d38f1 to 001d38ff has its CatchHandler @ 001d39e6 */
(*local_78)(&local_88,&local_88,3);
}
if (*(byte *)(in_RDX + 0x10) - 1 < 2) {
if (**(long **)(in_RDX + 0x18) == (*(long **)(in_RDX + 0x18))[1]) {
LAB_001d392e:
local_88 = local_88 & 0xffffffffffffff00;
pcStack_80 = (chat_template *)0x0;
goto LAB_001d393c;
}
}
else if (*(byte *)(in_RDX + 0x10) == 0) goto LAB_001d392e;
/* try { // try from 001d391a to 001d3927 has its CatchHandler @ 001d39e1 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)&local_88,(basic_json *)(in_RDX + 0x10));
LAB_001d393c:
local_40[0] = (data)0x0;
local_38 = 0;
/* try { // try from 001d3952 to 001d396d has its CatchHandler @ 001d3a04 */
minja::chat_template::apply
((basic_json *)local_60,(basic_json *)param_2,SUB81(in_RDX,0),(basic_json *)&local_88,
*(bool *)(in_RDX + 0x68));
/* try { // try from 001d396e to 001d397c has its CatchHandler @ 001d39e8 */
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
(local_30,local_60);
cVar2 = param_1[8];
param_1[8] = local_30[0];
uVar1 = *(int8 *)(param_1 + 0x10);
*(int8 *)(param_1 + 0x10) = local_28;
local_30[0] = cVar2;
local_28 = uVar1;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_30);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_88);
*(int4 *)param_1 = 5;
return param_1;
}
|
|
57,708
|
ft_parse
|
eloqsql/storage/myisam/ft_parser.c
|
int ft_parse(TREE *wtree, uchar *doc, int doclen,
struct st_mysql_ftparser *parser,
MYSQL_FTPARSER_PARAM *param, MEM_ROOT *mem_root)
{
MY_FT_PARSER_PARAM my_param;
DBUG_ENTER("ft_parse");
DBUG_ASSERT(parser);
my_param.wtree= wtree;
my_param.mem_root= mem_root;
param->mysql_parse= ft_parse_internal;
param->mysql_add_word= ft_add_word;
param->mysql_ftparam= &my_param;
param->cs= wtree->custom_arg;
param->doc= (char*) doc;
param->length= doclen;
param->mode= MYSQL_FTPARSER_SIMPLE_MODE;
DBUG_RETURN(parser->parse(param));
}
|
O0
|
c
|
ft_parse:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0xa3251
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
leaq 0x74(%rip), %rcx # 0xa32e0
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
leaq 0x116(%rip), %rcx # 0xa3390
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
leaq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x230(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
ft_parse:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
jmp short $+2
loc_A3251:
mov rax, [rbp+var_8]
mov [rbp+var_40], rax
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
lea rcx, ft_parse_internal
mov [rax], rcx
mov rax, [rbp+var_28]
lea rcx, ft_add_word
mov [rax+8], rcx
mov rax, [rbp+var_28]
lea rcx, [rbp+var_40]
mov [rax+18h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+230h]
mov rax, [rbp+var_28]
mov [rax+20h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_28]
mov [rax+28h], rcx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_28]
mov [rax+30h], ecx
mov rax, [rbp+var_28]
mov dword ptr [rax+38h], 0
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov rdi, [rbp+var_28]
call rax
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
add rsp, 50h
pop rbp
retn
|
long long ft_parse(long long a1, long long a2, int a3, long long a4, _QWORD *a5, long long a6)
{
_QWORD v7[3]; // [rsp+10h] [rbp-40h] BYREF
_QWORD *v8; // [rsp+28h] [rbp-28h]
long long v9; // [rsp+30h] [rbp-20h]
int v10; // [rsp+3Ch] [rbp-14h]
long long v11; // [rsp+40h] [rbp-10h]
long long v12; // [rsp+48h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v8 = a5;
v7[2] = a6;
v7[0] = a1;
v7[1] = a6;
*a5 = ft_parse_internal;
v8[1] = ft_add_word;
v8[3] = v7;
v8[4] = *(_QWORD *)(v12 + 560);
v8[5] = v11;
*((_DWORD *)v8 + 12) = v10;
*((_DWORD *)v8 + 14) = 0;
return (*(unsigned int ( **)(_QWORD *))(v9 + 8))(v8);
}
|
ft_parse:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
JMP 0x001a3251
LAB_001a3251:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[0x1a32e0]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[0x1a3390]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RBP + -0x40]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x230]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x20],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x28],RCX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x30],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x38],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x28]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
ADD RSP,0x50
POP RBP
RET
|
int4
ft_parse(long param_1,int8 param_2,int4 param_3,long param_4,int8 *param_5,
int8 param_6)
{
int4 uVar1;
long local_48;
int8 local_40;
int8 local_38;
int8 *local_30;
long local_28;
int4 local_1c;
int8 local_18;
long local_10;
*param_5 = ft_parse_internal;
param_5[1] = ft_add_word;
param_5[3] = &local_48;
param_5[4] = *(int8 *)(param_1 + 0x230);
param_5[5] = param_2;
*(int4 *)(param_5 + 6) = param_3;
*(int4 *)(param_5 + 7) = 0;
local_48 = param_1;
local_40 = param_6;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
uVar1 = (**(code **)(param_4 + 8))(param_5);
return uVar1;
}
|
|
57,709
|
add_global_var
|
bluesky950520[P]quickjs/quickjs.c
|
static JSGlobalVar *add_global_var(JSContext *ctx, JSFunctionDef *s,
JSAtom name)
{
JSGlobalVar *hf;
if (js_resize_array(ctx, (void **)&s->global_vars,
sizeof(s->global_vars[0]),
&s->global_var_size, s->global_var_count + 1))
return NULL;
hf = &s->global_vars[s->global_var_count++];
hf->cpool_idx = -1;
hf->force_init = FALSE;
hf->is_lexical = FALSE;
hf->is_const = FALSE;
hf->scope_level = s->scope_level;
hf->var_name = JS_DupAtom(ctx, name);
return hf;
}
|
O1
|
c
|
add_global_var:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x124(%rsi), %r8d
cmpl %r8d, 0x128(%rsi)
jle 0x65231
movq 0x130(%r15), %rcx
movslq 0x124(%r15), %rdx
leal 0x1(%rdx), %eax
movl %eax, 0x124(%r15)
shlq $0x4, %rdx
movl $0xffffffff, (%rcx,%rdx) # imm = 0xFFFFFFFF
andb $-0x8, 0x4(%rcx,%rdx)
leaq (%rcx,%rdx), %rax
movl 0xe8(%r15), %esi
movl %esi, 0x8(%rcx,%rdx)
cmpl $0xe0, %ebx
jl 0x65228
movq 0x18(%r14), %rcx
movq 0x68(%rcx), %rcx
movl %ebx, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl %ebx, 0xc(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x130(%r15), %rsi
leaq 0x128(%r15), %rcx
incl %r8d
movq %r14, %rdi
movl $0x10, %edx
callq 0x434ef
testl %eax, %eax
je 0x651d9
xorl %eax, %eax
jmp 0x6522b
|
add_global_var:
push r15
push r14
push rbx
mov ebx, edx
mov r15, rsi
mov r14, rdi
mov r8d, [rsi+124h]
cmp [rsi+128h], r8d
jle short loc_65231
loc_651D9:
mov rcx, [r15+130h]
movsxd rdx, dword ptr [r15+124h]
lea eax, [rdx+1]
mov [r15+124h], eax
shl rdx, 4
mov dword ptr [rcx+rdx], 0FFFFFFFFh
and byte ptr [rcx+rdx+4], 0F8h
lea rax, [rcx+rdx]
mov esi, [r15+0E8h]
mov [rcx+rdx+8], esi
cmp ebx, 0E0h
jl short loc_65228
mov rcx, [r14+18h]
mov rcx, [rcx+68h]
mov edx, ebx
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
loc_65228:
mov [rax+0Ch], ebx
loc_6522B:
pop rbx
pop r14
pop r15
retn
loc_65231:
lea rsi, [r15+130h]
lea rcx, [r15+128h]
inc r8d
mov rdi, r14
mov edx, 10h
call js_realloc_array
test eax, eax
jz short loc_651D9
xor eax, eax
jmp short loc_6522B
|
long long add_global_var(long long a1, long long a2, int a3)
{
int v4; // r8d
long long v5; // rcx
long long v6; // rdx
long long result; // rax
_DWORD *v8; // rcx
v4 = *(_DWORD *)(a2 + 292);
if ( *(_DWORD *)(a2 + 296) <= v4
&& (unsigned int)js_realloc_array(a1, (long long *)(a2 + 304), 0x10u, (_DWORD *)(a2 + 296), v4 + 1) )
{
return 0LL;
}
v5 = *(_QWORD *)(a2 + 304);
v6 = *(int *)(a2 + 292);
*(_DWORD *)(a2 + 292) = v6 + 1;
v6 *= 16LL;
*(_DWORD *)(v5 + v6) = -1;
*(_BYTE *)(v5 + v6 + 4) &= 0xF8u;
result = v5 + v6;
*(_DWORD *)(v5 + v6 + 8) = *(_DWORD *)(a2 + 232);
if ( a3 >= 224 )
{
v8 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * (unsigned int)a3);
++*v8;
}
*(_DWORD *)(result + 12) = a3;
return result;
}
| |||
57,710
|
add_global_var
|
bluesky950520[P]quickjs/quickjs.c
|
static JSGlobalVar *add_global_var(JSContext *ctx, JSFunctionDef *s,
JSAtom name)
{
JSGlobalVar *hf;
if (js_resize_array(ctx, (void **)&s->global_vars,
sizeof(s->global_vars[0]),
&s->global_var_size, s->global_var_count + 1))
return NULL;
hf = &s->global_vars[s->global_var_count++];
hf->cpool_idx = -1;
hf->force_init = FALSE;
hf->is_lexical = FALSE;
hf->is_const = FALSE;
hf->scope_level = s->scope_level;
hf->var_name = JS_DupAtom(ctx, name);
return hf;
}
|
O2
|
c
|
add_global_var:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
addq $0x130, %rsi # imm = 0x130
leaq 0x128(%r15), %rcx
movl 0x124(%r15), %r8d
incl %r8d
pushq $0x10
popq %rdx
callq 0x3b0ef
testl %eax, %eax
je 0x56427
xorl %eax, %eax
jmp 0x56476
movq 0x130(%r15), %rcx
movslq 0x124(%r15), %rdx
leal 0x1(%rdx), %eax
movl %eax, 0x124(%r15)
shlq $0x4, %rdx
orl $-0x1, (%rcx,%rdx)
andb $-0x8, 0x4(%rcx,%rdx)
leaq (%rcx,%rdx), %rax
movl 0xe8(%r15), %esi
movl %esi, 0x8(%rcx,%rdx)
cmpl $0xe0, %ebx
jl 0x56473
movq 0x18(%r14), %rcx
movq 0x68(%rcx), %rcx
movl %ebx, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl %ebx, 0xc(%rax)
popq %rbx
popq %r14
popq %r15
retq
|
add_global_var:
push r15
push r14
push rbx
mov ebx, edx
mov r15, rsi
mov r14, rdi
add rsi, 130h
lea rcx, [r15+128h]
mov r8d, [r15+124h]
inc r8d
push 10h
pop rdx
call js_resize_array
test eax, eax
jz short loc_56427
xor eax, eax
jmp short loc_56476
loc_56427:
mov rcx, [r15+130h]
movsxd rdx, dword ptr [r15+124h]
lea eax, [rdx+1]
mov [r15+124h], eax
shl rdx, 4
or dword ptr [rcx+rdx], 0FFFFFFFFh
and byte ptr [rcx+rdx+4], 0F8h
lea rax, [rcx+rdx]
mov esi, [r15+0E8h]
mov [rcx+rdx+8], esi
cmp ebx, 0E0h
jl short loc_56473
mov rcx, [r14+18h]
mov rcx, [rcx+68h]
mov edx, ebx
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
loc_56473:
mov [rax+0Ch], ebx
loc_56476:
pop rbx
pop r14
pop r15
retn
|
long long add_global_var(long long a1, long long a2, int a3)
{
long long result; // rax
long long v5; // rcx
long long v6; // rdx
_DWORD *v7; // rcx
if ( (unsigned int)js_resize_array(a1, a2 + 304, 16LL, (_DWORD *)(a2 + 296), *(_DWORD *)(a2 + 292) + 1) )
return 0LL;
v5 = *(_QWORD *)(a2 + 304);
v6 = *(int *)(a2 + 292);
*(_DWORD *)(a2 + 292) = v6 + 1;
v6 *= 16LL;
*(_DWORD *)(v5 + v6) = -1;
*(_BYTE *)(v5 + v6 + 4) &= 0xF8u;
result = v5 + v6;
*(_DWORD *)(v5 + v6 + 8) = *(_DWORD *)(a2 + 232);
if ( a3 >= 224 )
{
v7 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * (unsigned int)a3);
++*v7;
}
*(_DWORD *)(result + 12) = a3;
return result;
}
|
add_global_var:
PUSH R15
PUSH R14
PUSH RBX
MOV EBX,EDX
MOV R15,RSI
MOV R14,RDI
ADD RSI,0x130
LEA RCX,[R15 + 0x128]
MOV R8D,dword ptr [R15 + 0x124]
INC R8D
PUSH 0x10
POP RDX
CALL 0x0013b0ef
TEST EAX,EAX
JZ 0x00156427
XOR EAX,EAX
JMP 0x00156476
LAB_00156427:
MOV RCX,qword ptr [R15 + 0x130]
MOVSXD RDX,dword ptr [R15 + 0x124]
LEA EAX,[RDX + 0x1]
MOV dword ptr [R15 + 0x124],EAX
SHL RDX,0x4
OR dword ptr [RCX + RDX*0x1],0xffffffff
AND byte ptr [RCX + RDX*0x1 + 0x4],0xf8
LEA RAX,[RCX + RDX*0x1]
MOV ESI,dword ptr [R15 + 0xe8]
MOV dword ptr [RCX + RDX*0x1 + 0x8],ESI
CMP EBX,0xe0
JL 0x00156473
MOV RCX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV EDX,EBX
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
LAB_00156473:
MOV dword ptr [RAX + 0xc],EBX
LAB_00156476:
POP RBX
POP R14
POP R15
RET
|
long add_global_var(long param_1,long param_2,uint param_3)
{
byte *pbVar1;
long lVar2;
int *piVar3;
int iVar4;
long lVar5;
long lVar6;
iVar4 = js_resize_array(param_1,param_2 + 0x130,0x10,param_2 + 0x128,*(int *)(param_2 + 0x124) + 1
);
if (iVar4 == 0) {
lVar2 = *(long *)(param_2 + 0x130);
iVar4 = *(int *)(param_2 + 0x124);
*(int *)(param_2 + 0x124) = iVar4 + 1;
lVar6 = (long)iVar4 * 0x10;
*(int4 *)(lVar2 + lVar6) = 0xffffffff;
pbVar1 = (byte *)(lVar2 + 4 + lVar6);
*pbVar1 = *pbVar1 & 0xf8;
lVar5 = lVar2 + lVar6;
*(int4 *)(lVar2 + 8 + lVar6) = *(int4 *)(param_2 + 0xe8);
if (0xdf < (int)param_3) {
piVar3 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (ulong)param_3 * 8);
*piVar3 = *piVar3 + 1;
}
*(uint *)(lVar5 + 0xc) = param_3;
}
else {
lVar5 = 0;
}
return lVar5;
}
|
|
57,711
|
fmt::v11::basic_string_view<char>::compare(fmt::v11::basic_string_view<char>) const
|
zkingston[P]unknot/build_O0/_deps/fmt-src/include/fmt/base.h
|
FMT_CONSTEXPR auto compare(basic_string_view other) const -> int {
int result =
detail::compare(data_, other.data_, min_of(size_, other.size_));
if (result != 0) return result;
return size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
}
|
O0
|
c
|
fmt::v11::basic_string_view<char>::compare(fmt::v11::basic_string_view<char>) const:
subq $0x48, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0xab320
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0xbe380
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0xbe334
movl 0x24(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0xbe376
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x38(%rsp), %rax
jne 0xbe34c
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0xbe36e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x38(%rsp), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
|
_ZNK3fmt3v1117basic_string_viewIcE7compareES2_:
sub rsp, 48h
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_10], rdx
mov [rsp+48h+var_20], rdi
mov rax, [rsp+48h+var_20]
mov [rsp+48h+var_40], rax
mov rcx, [rax]
mov [rsp+48h+var_38], rcx
mov rcx, [rsp+48h+var_18]
mov [rsp+48h+var_30], rcx
mov rdi, [rax+8]
mov rsi, [rsp+48h+var_10]
call _ZN3fmt3v116min_ofImEET_S2_S2_; fmt::v11::min_of<ulong>(ulong,ulong)
mov rdi, [rsp+48h+var_38]
mov rsi, [rsp+48h+var_30]
mov rdx, rax
call _ZN3fmt3v116detail7compareIcEEiPKT_S5_m; fmt::v11::detail::compare<char>(char const*,char const*,ulong)
mov [rsp+48h+var_24], eax
cmp [rsp+48h+var_24], 0
jz short loc_BE334
mov eax, [rsp+48h+var_24]
mov [rsp+48h+var_4], eax
jmp short loc_BE376
loc_BE334:
mov rax, [rsp+48h+var_40]
mov rax, [rax+8]
cmp rax, [rsp+48h+var_10]
jnz short loc_BE34C
xor eax, eax
mov [rsp+48h+var_44], eax
jmp short loc_BE36E
loc_BE34C:
mov rax, [rsp+48h+var_40]
mov rdx, [rax+8]
mov rsi, [rsp+48h+var_10]
mov eax, 1
mov ecx, 0FFFFFFFFh
cmp rdx, rsi
cmovb eax, ecx
mov [rsp+48h+var_44], eax
loc_BE36E:
mov eax, [rsp+48h+var_44]
mov [rsp+48h+var_4], eax
loc_BE376:
mov eax, [rsp+48h+var_4]
add rsp, 48h
retn
|
long long fmt::v11::basic_string_view<char>::compare(long long *a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rax
unsigned int v4; // eax
long long v7; // [rsp+10h] [rbp-38h]
unsigned int v8; // [rsp+24h] [rbp-24h]
v7 = *a1;
v3 = fmt::v11::min_of<unsigned long>(a1[1], a3);
v8 = fmt::v11::detail::compare<char>(v7, a2, v3);
if ( v8 )
{
return v8;
}
else if ( a1[1] == a3 )
{
return 0;
}
else
{
v4 = 1;
if ( a1[1] < a3 )
v4 = -1;
return v4;
}
}
|
compare:
SUB RSP,0x48
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RAX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0x10],RCX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x18],RCX
MOV RDI,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x001ab320
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,RAX
CALL 0x001be380
MOV dword ptr [RSP + 0x24],EAX
CMP dword ptr [RSP + 0x24],0x0
JZ 0x001be334
MOV EAX,dword ptr [RSP + 0x24]
MOV dword ptr [RSP + 0x44],EAX
JMP 0x001be376
LAB_001be334:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RSP + 0x38]
JNZ 0x001be34c
XOR EAX,EAX
MOV dword ptr [RSP + 0x4],EAX
JMP 0x001be36e
LAB_001be34c:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RSP + 0x38]
MOV EAX,0x1
MOV ECX,0xffffffff
CMP RDX,RSI
CMOVC EAX,ECX
MOV dword ptr [RSP + 0x4],EAX
LAB_001be36e:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x44],EAX
LAB_001be376:
MOV EAX,dword ptr [RSP + 0x44]
ADD RSP,0x48
RET
|
/* fmt::v11::basic_string_view<char>::compare(fmt::v11::basic_string_view<char>) const */
int fmt::v11::basic_string_view<char>::compare(int8 *param_1,char *param_2,ulong param_3)
{
char *pcVar1;
ulong uVar2;
int local_44;
int local_4;
pcVar1 = (char *)*param_1;
uVar2 = min_of<unsigned_long>(param_1[1],param_3);
local_4 = detail::compare<char>(pcVar1,param_2,uVar2);
if (local_4 == 0) {
if (param_1[1] == param_3) {
local_44 = 0;
}
else {
local_44 = 1;
if ((ulong)param_1[1] < param_3) {
local_44 = -1;
}
}
local_4 = local_44;
}
return local_4;
}
|
|
57,712
|
LefDefParser::lefiNonDefault::layerWidth(int) const
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiNonDefault.cpp
|
double
lefiNonDefault::layerWidth(int index) const
{
char msg[160];
if (index < 0 || index >= numLayers_) {
sprintf(msg, "ERROR (LEFPARS-1402): The index number %d given for the NONDEFAULT LAYER is invalid.\nValid index is from 0 to %d", index, numLayers_);
lefiError(0, 1402, msg);
return 0.0;
}
return width_[index];
}
|
O3
|
cpp
|
LefDefParser::lefiNonDefault::layerWidth(int) const:
movl %esi, %edx
testl %esi, %esi
setns %al
movl 0x10(%rdi), %ecx
cmpl %esi, %ecx
setg %sil
testb %sil, %al
je 0x1fe33
movq 0x20(%rdi), %rax
movl %edx, %ecx
movsd (%rax,%rcx,8), %xmm0
retq
pushq %rbx
subq $0xa0, %rsp
leaq 0x2fabd(%rip), %rsi # 0x4f8ff
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2050
xorl %edi, %edi
movl $0x57a, %esi # imm = 0x57A
movq %rbx, %rdx
callq 0x27ae8
xorps %xmm0, %xmm0
addq $0xa0, %rsp
popq %rbx
retq
|
_ZNK12LefDefParser14lefiNonDefault10layerWidthEi:
mov edx, esi
test esi, esi
setns al
mov ecx, [rdi+10h]
cmp ecx, esi
setnle sil
test al, sil
jz short loc_1FE33
mov rax, [rdi+20h]
mov ecx, edx
movsd xmm0, qword ptr [rax+rcx*8]
retn
loc_1FE33:
push rbx
sub rsp, 0A0h
lea rsi, aErrorLefpars14_3; "ERROR (LEFPARS-1402): The index number "...
mov rbx, rsp
mov rdi, rbx
xor eax, eax
call _sprintf
xor edi, edi; this
mov esi, 57Ah; int
mov rdx, rbx; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
xorps xmm0, xmm0
add rsp, 0A0h
pop rbx
retn
|
double LefDefParser::lefiNonDefault::layerWidth(LefDefParser::lefiNonDefault *this, signed int a2)
{
int v2; // ecx
const char *v4; // rcx
_BYTE v5[168]; // [rsp-A8h] [rbp-A8h] BYREF
v2 = *((_DWORD *)this + 4);
if ( v2 > a2 && a2 >= 0 )
return *(double *)(*((_QWORD *)this + 4) + 8LL * (unsigned int)a2);
sprintf(
v5,
"ERROR (LEFPARS-1402): The index number %d given for the NONDEFAULT LAYER is invalid.\nValid index is from 0 to %d",
a2,
v2);
LefDefParser::lefiError(0LL, 1402, (int)v5, v4);
return 0.0;
}
|
layerWidth:
MOV EDX,ESI
TEST ESI,ESI
SETNS AL
MOV ECX,dword ptr [RDI + 0x10]
CMP ECX,ESI
SETG SIL
TEST AL,SIL
JZ 0x0011fe33
MOV RAX,qword ptr [RDI + 0x20]
MOV ECX,EDX
MOVSD XMM0,qword ptr [RAX + RCX*0x8]
RET
LAB_0011fe33:
PUSH RBX
SUB RSP,0xa0
LEA RSI,[0x14f8ff]
MOV RBX,RSP
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00102050
XOR EDI,EDI
MOV ESI,0x57a
MOV RDX,RBX
CALL 0x00127ae8
XORPS XMM0,XMM0
ADD RSP,0xa0
POP RBX
RET
|
/* LefDefParser::lefiNonDefault::layerWidth(int) const */
int8 __thiscall LefDefParser::lefiNonDefault::layerWidth(lefiNonDefault *this,int param_1)
{
char acStack_a8 [160];
if (-1 < param_1 && param_1 < *(int *)(this + 0x10)) {
return *(int8 *)(*(long *)(this + 0x20) + (ulong)(uint)param_1 * 8);
}
sprintf(acStack_a8,
"ERROR (LEFPARS-1402): The index number %d given for the NONDEFAULT LAYER is invalid.\nValid index is from 0 to %d"
);
lefiError(0,0x57a,acStack_a8);
return 0;
}
|
|
57,713
|
Catch::TestRegistry::getAllTestsSorted(Catch::IConfig const&) const
|
AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.cpp
|
std::vector<TestCaseHandle> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
if( m_sortedFunctions.empty() )
enforceNoDuplicateTestCases( m_handles );
if( m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
m_sortedFunctions = sortTests( config, m_handles );
m_currentSortOrder = config.runOrder();
}
return m_sortedFunctions;
}
|
O3
|
cpp
|
Catch::TestRegistry::getAllTestsSorted(Catch::IConfig const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rdi), %rax
cmpq 0x78(%rdi), %rax
jne 0x6235b
leaq 0x50(%rbx), %rdi
callq 0x61ef8
leaq 0x70(%rbx), %r15
movl 0x68(%rbx), %ebp
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
cmpl %eax, %ebp
jne 0x6237c
movq 0x70(%rbx), %rax
cmpq 0x78(%rbx), %rax
jne 0x623f1
leaq 0x50(%rbx), %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x61b21
movq 0x70(%rbx), %rdi
movq 0x80(%rbx), %rsi
movaps (%r12), %xmm0
movups %xmm0, 0x70(%rbx)
movq 0x10(%r12), %rax
movq %rax, 0x80(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
testq %rdi, %rdi
je 0x623e2
subq %rdi, %rsi
callq 0x17150
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x623e2
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x17150
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
movl %eax, 0x68(%rbx)
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZNK5Catch12TestRegistry17getAllTestsSortedERKNS_7IConfigE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov r14, rsi
mov rbx, rdi
mov rax, [rdi+70h]
cmp rax, [rdi+78h]
jnz short loc_6235B
lea rdi, [rbx+50h]
call _ZN5Catch27enforceNoDuplicateTestCasesERKSt6vectorINS_14TestCaseHandleESaIS1_EE; Catch::enforceNoDuplicateTestCases(std::vector<Catch::TestCaseHandle> const&)
loc_6235B:
lea r15, [rbx+70h]
mov ebp, [rbx+68h]
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+80h]
cmp ebp, eax
jnz short loc_6237C
mov rax, [rbx+70h]
cmp rax, [rbx+78h]
jnz short loc_623F1
loc_6237C:
lea rdx, [rbx+50h]
mov r12, rsp
mov rdi, r12
mov rsi, r14
call _ZN5Catch9sortTestsERKNS_7IConfigERKSt6vectorINS_14TestCaseHandleESaIS4_EE; Catch::sortTests(Catch::IConfig const&,std::vector<Catch::TestCaseHandle> const&)
mov rdi, [rbx+70h]; void *
mov rsi, [rbx+80h]
movaps xmm0, xmmword ptr [r12]
movups xmmword ptr [rbx+70h], xmm0
mov rax, [r12+10h]
mov [rbx+80h], rax
xorps xmm0, xmm0
movaps xmmword ptr [r12], xmm0
mov qword ptr [r12+10h], 0
test rdi, rdi
jz short loc_623E2
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [rsp+48h+var_48]; void *
test rdi, rdi
jz short loc_623E2
mov rsi, [rsp+48h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_623E2:
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+80h]
mov [rbx+68h], eax
loc_623F1:
mov rax, r15
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long Catch::TestRegistry::getAllTestsSorted(
Catch::TestRegistry *this,
const Catch::IConfig *a2,
double a3)
{
int v5; // ebp
void *v6; // rdi
unsigned long long v7; // rsi
__int128 v9; // [rsp+0h] [rbp-48h] BYREF
long long v10; // [rsp+10h] [rbp-38h]
if ( *((_QWORD *)this + 14) == *((_QWORD *)this + 15) )
Catch::enforceNoDuplicateTestCases((long long)this + 80, a3);
v5 = *((_DWORD *)this + 26);
if ( v5 != (*(unsigned int ( **)(const Catch::IConfig *))(*(_QWORD *)a2 + 128LL))(a2)
|| *((_QWORD *)this + 14) == *((_QWORD *)this + 15) )
{
Catch::sortTests(&v9, a2, (_QWORD *)this + 10, a3);
v6 = (void *)*((_QWORD *)this + 14);
v7 = *((_QWORD *)this + 16);
*((_OWORD *)this + 7) = v9;
*((_QWORD *)this + 16) = v10;
v9 = 0LL;
v10 = 0LL;
if ( v6 )
{
v7 -= (unsigned long long)v6;
operator delete(v6, v7);
if ( (_QWORD)v9 )
{
v7 = v10 - v9;
operator delete((void *)v9, v10 - v9);
}
}
*((_DWORD *)this + 26) = (*(long long ( **)(const Catch::IConfig *, unsigned long long))(*(_QWORD *)a2 + 128LL))(
a2,
v7);
}
return (long long)this + 112;
}
|
getAllTestsSorted:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x70]
CMP RAX,qword ptr [RDI + 0x78]
JNZ 0x0016235b
LEA RDI,[RBX + 0x50]
CALL 0x00161ef8
LAB_0016235b:
LEA R15,[RBX + 0x70]
MOV EBP,dword ptr [RBX + 0x68]
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x80]
CMP EBP,EAX
JNZ 0x0016237c
MOV RAX,qword ptr [RBX + 0x70]
CMP RAX,qword ptr [RBX + 0x78]
JNZ 0x001623f1
LAB_0016237c:
LEA RDX,[RBX + 0x50]
MOV R12,RSP
MOV RDI,R12
MOV RSI,R14
CALL 0x00161b21
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,qword ptr [RBX + 0x80]
MOVAPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RBX + 0x70],XMM0
MOV RAX,qword ptr [R12 + 0x10]
MOV qword ptr [RBX + 0x80],RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R12],XMM0
MOV qword ptr [R12 + 0x10],0x0
TEST RDI,RDI
JZ 0x001623e2
SUB RSI,RDI
CALL 0x00117150
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x001623e2
MOV RSI,qword ptr [RSP + 0x10]
SUB RSI,RDI
CALL 0x00117150
LAB_001623e2:
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x80]
MOV dword ptr [RBX + 0x68],EAX
LAB_001623f1:
MOV RAX,R15
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* Catch::TestRegistry::getAllTestsSorted(Catch::IConfig const&) const */
TestRegistry * __thiscall
Catch::TestRegistry::getAllTestsSorted(TestRegistry *this,IConfig *param_1)
{
int iVar1;
void *pvVar2;
long lVar3;
int iVar4;
int4 uVar5;
void *local_48;
int8 uStack_40;
long local_38;
if (*(long *)(this + 0x70) == *(long *)(this + 0x78)) {
enforceNoDuplicateTestCases((vector *)(this + 0x50));
}
iVar1 = *(int *)(this + 0x68);
iVar4 = (**(code **)(*(long *)param_1 + 0x80))(param_1);
if ((iVar1 != iVar4) || (*(long *)(this + 0x70) == *(long *)(this + 0x78))) {
sortTests((Catch *)&local_48,param_1,(vector *)(this + 0x50));
pvVar2 = *(void **)(this + 0x70);
lVar3 = *(long *)(this + 0x80);
*(void **)(this + 0x70) = local_48;
*(int8 *)(this + 0x78) = uStack_40;
*(long *)(this + 0x80) = local_38;
local_48 = (void *)0x0;
uStack_40 = 0;
local_38 = 0;
if (pvVar2 != (void *)0x0) {
operator_delete(pvVar2,lVar3 - (long)pvVar2);
if (local_48 != (void *)0x0) {
operator_delete(local_48,local_38 - (long)local_48);
}
}
uVar5 = (**(code **)(*(long *)param_1 + 0x80))(param_1);
*(int4 *)(this + 0x68) = uVar5;
}
return this + 0x70;
}
|
|
57,714
|
QuaternionNormalize
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h
|
RMAPI Quaternion QuaternionNormalize(Quaternion q)
{
Quaternion result = { 0 };
float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w);
if (length == 0.0f) length = 1.0f;
float ilength = 1.0f/length;
result.x = q.x*ilength;
result.y = q.y*ilength;
result.z = q.z*ilength;
result.w = q.w*ilength;
return result;
}
|
O0
|
c
|
QuaternionNormalize:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0xa2d0
movss -0x20(%rbp), %xmm0
movss -0x20(%rbp), %xmm2
movss -0x1c(%rbp), %xmm1
mulss -0x1c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x18(%rbp), %xmm1
movss -0x18(%rbp), %xmm2
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x14(%rbp), %xmm0
movss -0x14(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0xaa30
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xc04d8
jp 0xc04d8
movss 0xe3c21(%rip), %xmm0 # 0x1a40f4
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm1
movss 0xe3c0f(%rip), %xmm0 # 0x1a40f4
divss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x20(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x1c(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x14(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
QuaternionNormalize:
push rbp
mov rbp, rsp
sub rsp, 30h
movlpd [rbp+var_20], xmm0
movlpd [rbp+var_18], xmm1
lea rdi, [rbp+var_10]
xor esi, esi
mov edx, 10h
call _memset
movss xmm0, dword ptr [rbp+var_20]
movss xmm2, dword ptr [rbp+var_20]
movss xmm1, dword ptr [rbp+var_20+4]
mulss xmm1, dword ptr [rbp+var_20+4]
mulss xmm0, xmm2
addss xmm0, xmm1
movss xmm1, dword ptr [rbp+var_18]
movss xmm2, dword ptr [rbp+var_18]
mulss xmm1, xmm2
addss xmm1, xmm0
movss xmm0, dword ptr [rbp+var_18+4]
movss xmm2, dword ptr [rbp+var_18+4]
mulss xmm0, xmm2
addss xmm0, xmm1
call _sqrtf
movss [rbp+var_24], xmm0
movss xmm0, [rbp+var_24]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jnz short loc_C04D8
jp short loc_C04D8
movss xmm0, cs:dword_1A40F4
movss [rbp+var_24], xmm0
loc_C04D8:
movss xmm1, [rbp+var_24]
movss xmm0, cs:dword_1A40F4
divss xmm0, xmm1
movss [rbp+var_28], xmm0
movss xmm0, dword ptr [rbp+var_20]
movss xmm1, [rbp+var_28]
mulss xmm0, xmm1
movss dword ptr [rbp+var_10], xmm0
movss xmm0, dword ptr [rbp+var_20+4]
movss xmm1, [rbp+var_28]
mulss xmm0, xmm1
movss dword ptr [rbp+var_10+4], xmm0
movss xmm0, dword ptr [rbp+var_18]
movss xmm1, [rbp+var_28]
mulss xmm0, xmm1
movss dword ptr [rbp+var_8], xmm0
movss xmm0, dword ptr [rbp+var_18+4]
movss xmm1, [rbp+var_28]
mulss xmm0, xmm1
movss dword ptr [rbp+var_8+4], xmm0
movsd xmm0, [rbp+var_10]
movsd xmm1, [rbp+var_8]
add rsp, 30h
pop rbp
retn
|
double QuaternionNormalize(double a1, double a2)
{
double v2; // xmm0_8
float v4; // [rsp+Ch] [rbp-24h]
double v6; // [rsp+20h] [rbp-10h] BYREF
memset(&v6, 0LL, 16LL);
v2 = sqrtf(
(float)(*((float *)&a2 + 1) * *((float *)&a2 + 1))
+ (float)((float)(*(float *)&a2 * *(float *)&a2)
+ (float)((float)(*(float *)&a1 * *(float *)&a1) + (float)(*((float *)&a1 + 1) * *((float *)&a1 + 1)))));
v4 = *(float *)&v2;
if ( *(float *)&v2 == 0.0 )
v4 = 1.0;
*(float *)&v6 = *(float *)&a1 * (float)(1.0 / v4);
*((float *)&v6 + 1) = *((float *)&a1 + 1) * (float)(1.0 / v4);
return v6;
}
|
QuaternionNormalize:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOVLPD qword ptr [RBP + -0x20],XMM0
MOVLPD qword ptr [RBP + -0x18],XMM1
LEA RDI,[RBP + -0x10]
XOR ESI,ESI
MOV EDX,0x10
CALL 0x0010a2d0
MOVSS XMM0,dword ptr [RBP + -0x20]
MOVSS XMM2,dword ptr [RBP + -0x20]
MOVSS XMM1,dword ptr [RBP + -0x1c]
MULSS XMM1,dword ptr [RBP + -0x1c]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS XMM1,dword ptr [RBP + -0x18]
MOVSS XMM2,dword ptr [RBP + -0x18]
MULSS XMM1,XMM2
ADDSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x14]
MOVSS XMM2,dword ptr [RBP + -0x14]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
CALL 0x0010aa30
MOVSS dword ptr [RBP + -0x24],XMM0
MOVSS XMM0,dword ptr [RBP + -0x24]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JNZ 0x001c04d8
JP 0x001c04d8
MOVSS XMM0,dword ptr [0x002a40f4]
MOVSS dword ptr [RBP + -0x24],XMM0
LAB_001c04d8:
MOVSS XMM1,dword ptr [RBP + -0x24]
MOVSS XMM0,dword ptr [0x002a40f4]
DIVSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x28],XMM0
MOVSS XMM0,dword ptr [RBP + -0x20]
MOVSS XMM1,dword ptr [RBP + -0x28]
MULSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x10],XMM0
MOVSS XMM0,dword ptr [RBP + -0x1c]
MOVSS XMM1,dword ptr [RBP + -0x28]
MULSS XMM0,XMM1
MOVSS dword ptr [RBP + -0xc],XMM0
MOVSS XMM0,dword ptr [RBP + -0x18]
MOVSS XMM1,dword ptr [RBP + -0x28]
MULSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x8],XMM0
MOVSS XMM0,dword ptr [RBP + -0x14]
MOVSS XMM1,dword ptr [RBP + -0x28]
MULSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSD XMM0,qword ptr [RBP + -0x10]
MOVSD XMM1,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
int1 [16] QuaternionNormalize(int8 param_1,int8 param_2)
{
int1 auVar1 [16];
float local_2c;
float local_28;
float fStack_24;
float local_20;
float fStack_1c;
int1 local_18 [16];
memset(local_18,0,0x10);
local_28 = (float)param_1;
fStack_24 = (float)((ulong)param_1 >> 0x20);
local_20 = (float)param_2;
fStack_1c = (float)((ulong)param_2 >> 0x20);
local_2c = sqrtf(fStack_1c * fStack_1c +
local_20 * local_20 + local_28 * local_28 + fStack_24 * fStack_24);
if ((local_2c == 0.0) && (!NAN(local_2c))) {
local_2c = DAT_002a40f4;
}
local_2c = DAT_002a40f4 / local_2c;
auVar1._4_4_ = fStack_24 * local_2c;
auVar1._0_4_ = local_28 * local_2c;
auVar1._8_4_ = local_20 * local_2c;
auVar1._12_4_ = fStack_1c * local_2c;
return auVar1;
}
|
|
57,715
|
QuaternionNormalize
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h
|
RMAPI Quaternion QuaternionNormalize(Quaternion q)
{
Quaternion result = { 0 };
float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w);
if (length == 0.0f) length = 1.0f;
float ilength = 1.0f/length;
result.x = q.x*ilength;
result.y = q.y*ilength;
result.z = q.z*ilength;
result.w = q.w*ilength;
return result;
}
|
O2
|
c
|
QuaternionNormalize:
movaps %xmm0, %xmm2
mulps %xmm0, %xmm2
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
movaps %xmm0, %xmm3
mulss %xmm0, %xmm3
addss %xmm2, %xmm3
movaps %xmm1, %xmm2
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
mulss %xmm1, %xmm1
addss %xmm3, %xmm1
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
mulss %xmm2, %xmm2
addss %xmm1, %xmm2
sqrtss %xmm2, %xmm1
movss 0x6024b(%rip), %xmm2 # 0xb969c
xorps %xmm3, %xmm3
cmpeqss %xmm1, %xmm3
movaps %xmm3, %xmm4
andps %xmm2, %xmm3
divss %xmm1, %xmm2
andnps %xmm2, %xmm4
orps %xmm4, %xmm3
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
mulps %xmm3, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
retq
|
QuaternionNormalize:
movaps xmm2, xmm0
mulps xmm2, xmm0
shufps xmm2, xmm2, 55h ; 'U'
movaps xmm3, xmm0
mulss xmm3, xmm0
addss xmm3, xmm2
movaps xmm2, xmm1
movlhps xmm0, xmm1
mulss xmm1, xmm1
addss xmm1, xmm3
shufps xmm2, xmm2, 55h ; 'U'
mulss xmm2, xmm2
addss xmm2, xmm1
sqrtss xmm1, xmm2
movss xmm2, cs:dword_B969C
xorps xmm3, xmm3
cmpeqss xmm3, xmm1
movaps xmm4, xmm3
andps xmm3, xmm2
divss xmm2, xmm1
andnps xmm4, xmm2
orps xmm3, xmm4
shufps xmm3, xmm3, 0
mulps xmm0, xmm3
movaps xmm1, xmm0
unpckhpd xmm1, xmm0
retn
|
__m128 QuaternionNormalize(__m128 a1, __m128 a2)
{
__m128 v2; // xmm2
float v3; // xmm3_4
__m128 v4; // xmm0
__m128 v5; // xmm1
__m128 v6; // xmm2
__m128 v7; // xmm4
__m128 v8; // xmm3
v2 = _mm_mul_ps(a1, a1);
v3 = (float)(a1.m128_f32[0] * a1.m128_f32[0]) + _mm_shuffle_ps(v2, v2, 85).m128_f32[0];
v4 = _mm_movelh_ps(a1, a2);
v2.m128_f32[0] = _mm_shuffle_ps(a2, a2, 85).m128_f32[0];
v5.m128_f32[0] = fsqrt((float)(v2.m128_f32[0] * v2.m128_f32[0]) + (float)((float)(a2.m128_f32[0] * a2.m128_f32[0]) + v3));
v6 = (__m128)0x3F800000u;
v7 = _mm_cmpeq_ss((__m128)0LL, v5);
v6.m128_f32[0] = 1.0 / v5.m128_f32[0];
v8 = _mm_or_ps(_mm_and_ps(v7, (__m128)0x3F800000u), _mm_andnot_ps(v7, v6));
return _mm_mul_ps(v4, _mm_shuffle_ps(v8, v8, 0));
}
|
QuaternionNormalize:
MOVAPS XMM2,XMM0
MULPS XMM2,XMM0
SHUFPS XMM2,XMM2,0x55
MOVAPS XMM3,XMM0
MULSS XMM3,XMM0
ADDSS XMM3,XMM2
MOVAPS XMM2,XMM1
MOVLHPS XMM0,XMM1
MULSS XMM1,XMM1
ADDSS XMM1,XMM3
SHUFPS XMM2,XMM2,0x55
MULSS XMM2,XMM2
ADDSS XMM2,XMM1
SQRTSS XMM1,XMM2
MOVSS XMM2,dword ptr [0x001b969c]
XORPS XMM3,XMM3
CMPEQSS XMM3,XMM1
MOVAPS XMM4,XMM3
ANDPS XMM3,XMM2
DIVSS XMM2,XMM1
ANDNPS XMM4,XMM2
ORPS XMM3,XMM4
SHUFPS XMM3,XMM3,0x0
MULPS XMM0,XMM3
MOVAPS XMM1,XMM0
UNPCKHPD XMM1,XMM0
RET
|
int8 QuaternionNormalize(int8 param_1,int8 param_2)
{
uint uVar1;
float fVar2;
float fVar3;
float fVar4;
fVar3 = (float)((ulong)param_1 >> 0x20);
fVar2 = (float)param_1;
fVar4 = (float)((ulong)param_2 >> 0x20);
fVar4 = SQRT(fVar4 * fVar4 + (float)param_2 * (float)param_2 + fVar2 * fVar2 + fVar3 * fVar3);
uVar1 = -(uint)(fVar4 == 0.0);
fVar4 = (float)(uVar1 & (uint)DAT_001b969c | ~uVar1 & (uint)(DAT_001b969c / fVar4));
return CONCAT44(fVar3 * fVar4,fVar2 * fVar4);
}
|
|
57,716
|
js_os_readlink
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_os_readlink(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
const char *path;
char buf[PATH_MAX];
int err;
ssize_t res;
path = JS_ToCString(ctx, argv[0]);
if (!path)
return JS_EXCEPTION;
res = readlink(path, buf, sizeof(buf) - 1);
if (res < 0) {
buf[0] = '\0';
err = errno;
} else {
buf[res] = '\0';
err = 0;
}
JS_FreeCString(ctx, path);
return make_string_error(ctx, buf, err);
}
|
O2
|
c
|
js_os_readlink:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp # imm = 0x1000
movq %rdi, %rbx
movq (%r8), %rsi
movq 0x8(%r8), %rdx
callq 0x11a6c
testq %rax, %rax
je 0x1499d
movq %rax, %r14
movq %rsp, %rsi
movl $0xfff, %edx # imm = 0xFFF
movq %rax, %rdi
callq 0xe1b0
testq %rax, %rax
js 0x149a4
movb $0x0, (%rsp,%rax)
xorl %ebp, %ebp
jmp 0x149af
pushq $0x6
popq %rdx
xorl %eax, %eax
jmp 0x149c7
movb $0x0, (%rsp)
callq 0xe0b0
movl (%rax), %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b057
movq %rsp, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x157bc
addq $0x1000, %rsp # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
retq
|
js_os_readlink:
push rbp
push r14
push rbx
sub rsp, 1000h
mov rbx, rdi
mov rsi, [r8]
mov rdx, [r8+8]
call JS_ToCString
test rax, rax
jz short loc_1499D
mov r14, rax
mov rsi, rsp
mov edx, 0FFFh
mov rdi, rax
call _readlink
test rax, rax
js short loc_149A4
mov [rsp+rax+1018h+var_1018], 0
xor ebp, ebp
jmp short loc_149AF
loc_1499D:
push 6
pop rdx
xor eax, eax
jmp short loc_149C7
loc_149A4:
mov [rsp+1018h+var_1018], 0
call ___errno_location
mov ebp, [rax]
loc_149AF:
mov rdi, rbx
mov rsi, r14
call JS_FreeCString
mov rsi, rsp
mov rdi, rbx
mov edx, ebp
call make_string_error
loc_149C7:
add rsp, 1000h
pop rbx
pop r14
pop rbp
retn
|
long long js_os_readlink(long long a1, long long a2, long long a3, long long a4, long long *a5)
{
long long v6; // rax
long long v7; // r14
long long v8; // rdi
long long v9; // rax
unsigned int v10; // ebp
_BYTE v12[4120]; // [rsp+0h] [rbp-1018h] BYREF
v6 = JS_ToCString(a1, *a5, a5[1]);
if ( !v6 )
return 0LL;
v7 = v6;
v8 = v6;
v9 = readlink(v6, v12, 4095LL);
if ( v9 < 0 )
{
v12[0] = 0;
v10 = *(_DWORD *)__errno_location(v8);
}
else
{
v12[v9] = 0;
v10 = 0;
}
JS_FreeCString(a1, v7);
return make_string_error(a1, v12, v10);
}
|
js_os_readlink:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x1000
MOV RBX,RDI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
CALL 0x00111a6c
TEST RAX,RAX
JZ 0x0011499d
MOV R14,RAX
MOV RSI,RSP
MOV EDX,0xfff
MOV RDI,RAX
CALL 0x0010e1b0
TEST RAX,RAX
JS 0x001149a4
MOV byte ptr [RSP + RAX*0x1],0x0
XOR EBP,EBP
JMP 0x001149af
LAB_0011499d:
PUSH 0x6
POP RDX
XOR EAX,EAX
JMP 0x001149c7
LAB_001149a4:
MOV byte ptr [RSP],0x0
CALL 0x0010e0b0
MOV EBP,dword ptr [RAX]
LAB_001149af:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011b057
MOV RSI,RSP
MOV RDI,RBX
MOV EDX,EBP
CALL 0x001157bc
LAB_001149c7:
ADD RSP,0x1000
POP RBX
POP R14
POP RBP
RET
|
int8 js_os_readlink(int8 param_1)
{
char *__path;
ssize_t sVar1;
int *piVar2;
int8 uVar3;
int iVar4;
int8 *in_R8;
char local_1018 [4096];
__path = (char *)JS_ToCString(param_1,*in_R8,in_R8[1]);
if (__path == (char *)0x0) {
uVar3 = 0;
}
else {
sVar1 = readlink(__path,local_1018,0xfff);
if (sVar1 < 0) {
local_1018[0] = '\0';
piVar2 = __errno_location();
iVar4 = *piVar2;
}
else {
local_1018[sVar1] = '\0';
iVar4 = 0;
}
JS_FreeCString(param_1,__path);
uVar3 = make_string_error(param_1,local_1018,iVar4);
}
return uVar3;
}
|
|
57,717
|
LefDefParser::defiPinProp::clear()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiPinProp.cpp
|
void defiPinProp::clear() {
int i;
for (i = 0; i < numProps_; i++) {
free(propNames_[i]);
free(propValues_[i]);
propDValues_[i] = 0;
}
numProps_ = 0;
isPin_ = 0;
}
|
O0
|
cpp
|
LefDefParser::defiPinProp::clear():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x409f5
movq (%rsp), %rax
movq 0x28(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x72a0
movq (%rsp), %rax
movq 0x30(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x72a0
movq (%rsp), %rax
movq 0x38(%rax), %rax
movslq 0xc(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4099a
movq (%rsp), %rax
movl $0x0, 0x20(%rax)
movb $0x0, (%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
|
_ZN12LefDefParser11defiPinProp5clearEv:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rax, [rsp+18h+var_8]
mov [rsp+18h+var_18], rax
mov [rsp+18h+var_C], 0
loc_4099A:
mov rcx, [rsp+18h+var_18]
mov eax, [rsp+18h+var_C]
cmp eax, [rcx+20h]
jge short loc_409F5
mov rax, [rsp+18h+var_18]
mov rax, [rax+28h]
movsxd rcx, [rsp+18h+var_C]
mov rdi, [rax+rcx*8]
call _free
mov rax, [rsp+18h+var_18]
mov rax, [rax+30h]
movsxd rcx, [rsp+18h+var_C]
mov rdi, [rax+rcx*8]
call _free
mov rax, [rsp+18h+var_18]
mov rax, [rax+38h]
movsxd rcx, [rsp+18h+var_C]
xorps xmm0, xmm0
movsd qword ptr [rax+rcx*8], xmm0
mov eax, [rsp+18h+var_C]
add eax, 1
mov [rsp+18h+var_C], eax
jmp short loc_4099A
loc_409F5:
mov rax, [rsp+18h+var_18]
mov dword ptr [rax+20h], 0
mov byte ptr [rax], 0
add rsp, 18h
retn
|
LefDefParser::defiPinProp * LefDefParser::defiPinProp::clear(LefDefParser::defiPinProp *this)
{
LefDefParser::defiPinProp *result; // rax
int i; // [rsp+Ch] [rbp-Ch]
for ( i = 0; i < *((_DWORD *)this + 8); ++i )
{
free(*(_QWORD *)(*((_QWORD *)this + 5) + 8LL * i));
free(*(_QWORD *)(*((_QWORD *)this + 6) + 8LL * i));
*(_QWORD *)(*((_QWORD *)this + 7) + 8LL * i) = 0LL;
}
result = this;
*((_DWORD *)this + 8) = 0;
*(_BYTE *)this = 0;
return result;
}
|
clear:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV dword ptr [RSP + 0xc],0x0
LAB_0014099a:
MOV RCX,qword ptr [RSP]
MOV EAX,dword ptr [RSP + 0xc]
CMP EAX,dword ptr [RCX + 0x20]
JGE 0x001409f5
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX + 0x28]
MOVSXD RCX,dword ptr [RSP + 0xc]
MOV RDI,qword ptr [RAX + RCX*0x8]
CALL 0x001072a0
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX + 0x30]
MOVSXD RCX,dword ptr [RSP + 0xc]
MOV RDI,qword ptr [RAX + RCX*0x8]
CALL 0x001072a0
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX + 0x38]
MOVSXD RCX,dword ptr [RSP + 0xc]
XORPS XMM0,XMM0
MOVSD qword ptr [RAX + RCX*0x8],XMM0
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x0014099a
LAB_001409f5:
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX + 0x20],0x0
MOV byte ptr [RAX],0x0
ADD RSP,0x18
RET
|
/* LefDefParser::defiPinProp::clear() */
void __thiscall LefDefParser::defiPinProp::clear(defiPinProp *this)
{
int local_c;
for (local_c = 0; local_c < *(int *)(this + 0x20); local_c = local_c + 1) {
free(*(void **)(*(long *)(this + 0x28) + (long)local_c * 8));
free(*(void **)(*(long *)(this + 0x30) + (long)local_c * 8));
*(int8 *)(*(long *)(this + 0x38) + (long)local_c * 8) = 0;
}
*(int4 *)(this + 0x20) = 0;
*this = (defiPinProp)0x0;
return;
}
|
|
57,718
|
LefDefParser::defiPinProp::clear()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiPinProp.cpp
|
void defiPinProp::clear() {
int i;
for (i = 0; i < numProps_; i++) {
free(propNames_[i]);
free(propValues_[i]);
propDValues_[i] = 0;
}
numProps_ = 0;
isPin_ = 0;
}
|
O3
|
cpp
|
LefDefParser::defiPinProp::clear():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
jle 0x27af0
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x7220
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x7220
movq 0x38(%rbx), %rax
movq $0x0, (%rax,%r14,8)
incq %r14
movslq 0x20(%rbx), %rax
cmpq %rax, %r14
jl 0x27abe
movl $0x0, 0x20(%rbx)
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_ZN12LefDefParser11defiPinProp5clearEv:
push r14
push rbx
push rax
mov rbx, rdi
cmp dword ptr [rdi+20h], 0
jle short loc_27AF0
xor r14d, r14d
loc_27ABE:
mov rax, [rbx+28h]
mov rdi, [rax+r14*8]
call _free
mov rax, [rbx+30h]
mov rdi, [rax+r14*8]
call _free
mov rax, [rbx+38h]
mov qword ptr [rax+r14*8], 0
inc r14
movsxd rax, dword ptr [rbx+20h]
cmp r14, rax
jl short loc_27ABE
loc_27AF0:
mov dword ptr [rbx+20h], 0
mov byte ptr [rbx], 0
add rsp, 8
pop rbx
pop r14
retn
|
long long LefDefParser::defiPinProp::clear(LefDefParser::defiPinProp *this)
{
long long v1; // r14
long long result; // rax
if ( *((int *)this + 8) > 0 )
{
v1 = 0LL;
do
{
free(*(void **)(*((_QWORD *)this + 5) + 8 * v1));
free(*(void **)(*((_QWORD *)this + 6) + 8 * v1));
*(_QWORD *)(*((_QWORD *)this + 7) + 8 * v1++) = 0LL;
result = *((int *)this + 8);
}
while ( v1 < result );
}
*((_DWORD *)this + 8) = 0;
*(_BYTE *)this = 0;
return result;
}
|
clear:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP dword ptr [RDI + 0x20],0x0
JLE 0x00127af0
XOR R14D,R14D
LAB_00127abe:
MOV RAX,qword ptr [RBX + 0x28]
MOV RDI,qword ptr [RAX + R14*0x8]
CALL 0x00107220
MOV RAX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RAX + R14*0x8]
CALL 0x00107220
MOV RAX,qword ptr [RBX + 0x38]
MOV qword ptr [RAX + R14*0x8],0x0
INC R14
MOVSXD RAX,dword ptr [RBX + 0x20]
CMP R14,RAX
JL 0x00127abe
LAB_00127af0:
MOV dword ptr [RBX + 0x20],0x0
MOV byte ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* LefDefParser::defiPinProp::clear() */
void __thiscall LefDefParser::defiPinProp::clear(defiPinProp *this)
{
long lVar1;
if (0 < *(int *)(this + 0x20)) {
lVar1 = 0;
do {
free(*(void **)(*(long *)(this + 0x28) + lVar1 * 8));
free(*(void **)(*(long *)(this + 0x30) + lVar1 * 8));
*(int8 *)(*(long *)(this + 0x38) + lVar1 * 8) = 0;
lVar1 = lVar1 + 1;
} while (lVar1 < *(int *)(this + 0x20));
}
*(int4 *)(this + 0x20) = 0;
*this = (defiPinProp)0x0;
return;
}
|
|
57,719
|
js_std_file_getline
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_std_file_getline(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
FILE *f = js_std_file_get(ctx, this_val);
int c;
DynBuf dbuf;
JSValue obj;
if (!f)
return JS_EXCEPTION;
js_std_dbuf_init(ctx, &dbuf);
for(;;) {
c = fgetc(f);
if (c == EOF) {
if (dbuf.size == 0) {
/* EOF */
dbuf_free(&dbuf);
return JS_NULL;
} else {
break;
}
}
if (c == '\n')
break;
if (dbuf_putc(&dbuf, c)) {
dbuf_free(&dbuf);
return JS_ThrowOutOfMemory(ctx);
}
}
obj = JS_NewStringLen(ctx, (const char *)dbuf.buf, dbuf.size);
dbuf_free(&dbuf);
return obj;
}
|
O0
|
c
|
js_std_file_getline:
subq $0x98, %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 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0x13a80
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x13582
movl $0x0, 0x88(%rsp)
movq $0x6, 0x90(%rsp)
jmp 0x13674
movq 0x70(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x14750
movq 0x58(%rsp), %rdi
callq 0xe390
movl %eax, 0x54(%rsp)
cmpl $-0x1, 0x54(%rsp)
jne 0x135d6
cmpq $0x0, 0x28(%rsp)
jne 0x135d4
leaq 0x20(%rsp), %rdi
callq 0x1e930
movl $0x0, 0x88(%rsp)
movq $0x2, 0x90(%rsp)
jmp 0x13674
jmp 0x13620
cmpl $0xa, 0x54(%rsp)
jne 0x135df
jmp 0x13620
movl 0x54(%rsp), %eax
leaq 0x20(%rsp), %rdi
movzbl %al, %esi
callq 0x1e6d0
cmpl $0x0, %eax
je 0x1361b
leaq 0x20(%rsp), %rdi
callq 0x1e930
movq 0x70(%rsp), %rdi
callq 0x21c10
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
jmp 0x13674
jmp 0x13591
movq 0x70(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x28270
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1e930
movq 0x10(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x88(%rsp), %rax
movq 0x90(%rsp), %rdx
addq $0x98, %rsp
retq
nopl (%rax)
|
js_std_file_getline:
sub rsp, 98h
mov [rsp+98h+var_20], rsi
mov [rsp+98h+var_18], rdx
mov [rsp+98h+var_28], rdi
mov [rsp+98h+var_2C], ecx
mov [rsp+98h+var_38], r8
mov rdi, [rsp+98h+var_28]
mov rsi, [rsp+98h+var_20]
mov rdx, [rsp+98h+var_18]
call js_std_file_get
mov [rsp+98h+var_40], rax
cmp [rsp+98h+var_40], 0
jnz short loc_13582
mov dword ptr [rsp+98h+var_10], 0
mov [rsp+98h+var_8], 6
jmp loc_13674
loc_13582:
mov rdi, [rsp+98h+var_28]
lea rsi, [rsp+98h+var_78]
call js_std_dbuf_init
loc_13591:
mov rdi, [rsp+98h+var_40]
call _fgetc
mov [rsp+98h+var_44], eax
cmp [rsp+98h+var_44], 0FFFFFFFFh
jnz short loc_135D6
cmp [rsp+98h+var_70], 0
jnz short loc_135D4
lea rdi, [rsp+98h+var_78]
call dbuf_free
mov dword ptr [rsp+98h+var_10], 0
mov [rsp+98h+var_8], 2
jmp loc_13674
loc_135D4:
jmp short loc_13620
loc_135D6:
cmp [rsp+98h+var_44], 0Ah
jnz short loc_135DF
jmp short loc_13620
loc_135DF:
mov eax, [rsp+98h+var_44]
lea rdi, [rsp+98h+var_78]
movzx esi, al
call dbuf_putc
cmp eax, 0
jz short loc_1361B
lea rdi, [rsp+98h+var_78]
call dbuf_free
mov rdi, [rsp+98h+var_28]
call JS_ThrowOutOfMemory
mov [rsp+98h+var_10], rax
mov [rsp+98h+var_8], rdx
jmp short loc_13674
loc_1361B:
jmp loc_13591
loc_13620:
mov rdi, [rsp+98h+var_28]
mov rsi, [rsp+98h+var_78]
mov rdx, [rsp+98h+var_70]
call JS_NewStringLen
mov [rsp+98h+var_98], rax
mov [rsp+98h+var_90], rdx
mov rax, [rsp+98h+var_98]
mov [rsp+98h+var_88], rax
mov rax, [rsp+98h+var_90]
mov [rsp+98h+var_80], rax
lea rdi, [rsp+98h+var_78]
call dbuf_free
mov rax, [rsp+98h+var_88]
mov [rsp+98h+var_10], rax
mov rax, [rsp+98h+var_80]
mov [rsp+98h+var_8], rax
loc_13674:
mov rax, [rsp+98h+var_10]
mov rdx, [rsp+98h+var_8]
add rsp, 98h
retn
|
long long js_std_file_getline(long long a1, long long a2, long long a3, int a4, long long a5)
{
long long v5; // rdx
long long v6; // rdx
long long v8; // [rsp+0h] [rbp-98h]
long long v9; // [rsp+18h] [rbp-80h]
long long v10; // [rsp+20h] [rbp-78h] BYREF
long long v11; // [rsp+28h] [rbp-70h]
int v12; // [rsp+54h] [rbp-44h]
long long v13; // [rsp+58h] [rbp-40h]
long long v14; // [rsp+60h] [rbp-38h]
int v15; // [rsp+6Ch] [rbp-2Ch]
long long v16; // [rsp+70h] [rbp-28h]
long long v17; // [rsp+78h] [rbp-20h]
long long v18; // [rsp+80h] [rbp-18h]
long long v19; // [rsp+88h] [rbp-10h]
long long v20; // [rsp+90h] [rbp-8h]
v17 = a2;
v18 = a3;
v16 = a1;
v15 = a4;
v14 = a5;
v13 = js_std_file_get(a1, a2, a3);
if ( v13 )
{
js_std_dbuf_init(v16, &v10);
while ( 1 )
{
v12 = fgetc(v13);
if ( v12 == -1 )
break;
if ( v12 == 10 )
goto LABEL_12;
if ( (unsigned int)dbuf_putc(&v10, (unsigned __int8)v12) )
{
dbuf_free(&v10);
v19 = JS_ThrowOutOfMemory(v16);
v20 = v5;
return v19;
}
}
if ( !v11 )
{
dbuf_free(&v10);
LODWORD(v19) = 0;
v20 = 2LL;
return v19;
}
LABEL_12:
v8 = JS_NewStringLen(v16, v10, v11);
v9 = v6;
dbuf_free(&v10);
v19 = v8;
v20 = v9;
}
else
{
LODWORD(v19) = 0;
v20 = 6LL;
}
return v19;
}
|
js_std_file_getline:
SUB RSP,0x98
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 RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
CALL 0x00113a80
MOV qword ptr [RSP + 0x58],RAX
CMP qword ptr [RSP + 0x58],0x0
JNZ 0x00113582
MOV dword ptr [RSP + 0x88],0x0
MOV qword ptr [RSP + 0x90],0x6
JMP 0x00113674
LAB_00113582:
MOV RDI,qword ptr [RSP + 0x70]
LEA RSI,[RSP + 0x20]
CALL 0x00114750
LAB_00113591:
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x0010e390
MOV dword ptr [RSP + 0x54],EAX
CMP dword ptr [RSP + 0x54],-0x1
JNZ 0x001135d6
CMP qword ptr [RSP + 0x28],0x0
JNZ 0x001135d4
LEA RDI,[RSP + 0x20]
CALL 0x0011e930
MOV dword ptr [RSP + 0x88],0x0
MOV qword ptr [RSP + 0x90],0x2
JMP 0x00113674
LAB_001135d4:
JMP 0x00113620
LAB_001135d6:
CMP dword ptr [RSP + 0x54],0xa
JNZ 0x001135df
JMP 0x00113620
LAB_001135df:
MOV EAX,dword ptr [RSP + 0x54]
LEA RDI,[RSP + 0x20]
MOVZX ESI,AL
CALL 0x0011e6d0
CMP EAX,0x0
JZ 0x0011361b
LEA RDI,[RSP + 0x20]
CALL 0x0011e930
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x00121c10
MOV qword ptr [RSP + 0x88],RAX
MOV qword ptr [RSP + 0x90],RDX
JMP 0x00113674
LAB_0011361b:
JMP 0x00113591
LAB_00113620:
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x00128270
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x18],RAX
LEA RDI,[RSP + 0x20]
CALL 0x0011e930
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x90],RAX
LAB_00113674:
MOV RAX,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
ADD RSP,0x98
RET
|
int1 [16]
js_std_file_getline(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 param_5)
{
int iVar1;
int1 auVar2 [16];
int8 local_78;
long local_70;
uint local_44;
FILE *local_40;
int8 local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_40 = (FILE *)js_std_file_get(param_1,param_2,param_3);
if (local_40 == (FILE *)0x0) {
local_10 = 0;
local_8 = 6;
}
else {
js_std_dbuf_init(local_28,&local_78);
do {
local_44 = fgetc(local_40);
if (local_44 == 0xffffffff) {
if (local_70 == 0) {
dbuf_free(&local_78);
local_10 = 0;
local_8 = 2;
}
else {
LAB_00113620:
auVar2 = JS_NewStringLen(local_28,local_78,local_70);
dbuf_free(&local_78);
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
local_8 = auVar2._8_8_;
}
goto LAB_00113674;
}
if (local_44 == 10) goto LAB_00113620;
iVar1 = dbuf_putc(&local_78,local_44 & 0xff);
} while (iVar1 == 0);
dbuf_free(&local_78);
auVar2 = JS_ThrowOutOfMemory(local_28);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
LAB_00113674:
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
|
|
57,720
|
js_std_file_getline
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_std_file_getline(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
FILE *f = js_std_file_get(ctx, this_val);
int c;
DynBuf dbuf;
JSValue obj;
if (!f)
return JS_EXCEPTION;
js_std_dbuf_init(ctx, &dbuf);
for(;;) {
c = fgetc(f);
if (c == EOF) {
if (dbuf.size == 0) {
/* EOF */
dbuf_free(&dbuf);
return JS_NULL;
} else {
break;
}
}
if (c == '\n')
break;
if (dbuf_putc(&dbuf, c)) {
dbuf_free(&dbuf);
return JS_ThrowOutOfMemory(ctx);
}
}
obj = JS_NewStringLen(ctx, (const char *)dbuf.buf, dbuf.size);
dbuf_free(&dbuf);
return obj;
}
|
O2
|
c
|
js_std_file_getline:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x113c6
testq %rax, %rax
je 0x111f5
movq %rax, %r14
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11a50
movq %r14, %rdi
callq 0xe3a0
cmpl $0xa, %eax
je 0x11215
cmpl $-0x1, %eax
je 0x111ff
movzbl %al, %esi
movq %r15, %rdi
callq 0x15d33
testl %eax, %eax
je 0x111af
movq %rsp, %rdi
callq 0x15e89
movq %rbx, %rdi
callq 0x171e0
movq %rax, %r14
movq %rdx, %rbx
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
jmp 0x11243
pushq $0x6
popq %rbx
xorl %r14d, %r14d
xorl %ecx, %ecx
jmp 0x11243
movq 0x8(%rsp), %rdx
testq %rdx, %rdx
jne 0x1121a
movq %rsp, %rdi
callq 0x15e89
pushq $0x2
jmp 0x111f7
movq 0x8(%rsp), %rdx
movq %rsp, %r15
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x1a2ea
movq %rax, %r14
movq %rdx, %rbx
movq %r15, %rdi
callq 0x15e89
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %r14, %rcx
movl %r14d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
js_std_file_getline:
push r15
push r14
push rbx
sub rsp, 30h
mov rbx, rdi
call js_std_file_get
test rax, rax
jz short loc_111F5
mov r14, rax
mov r15, rsp
mov rdi, rbx
mov rsi, r15
call js_std_dbuf_init
loc_111AF:
mov rdi, r14
call _fgetc
cmp eax, 0Ah
jz short loc_11215
cmp eax, 0FFFFFFFFh
jz short loc_111FF
movzx esi, al
mov rdi, r15
call dbuf_putc
test eax, eax
jz short loc_111AF
mov rdi, rsp
call dbuf_free
mov rdi, rbx
call JS_ThrowOutOfMemory
mov r14, rax
mov rbx, rdx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
jmp short loc_11243
loc_111F5:
push 6
loc_111F7:
pop rbx
xor r14d, r14d
xor ecx, ecx
jmp short loc_11243
loc_111FF:
mov rdx, [rsp+48h+var_40]
test rdx, rdx
jnz short loc_1121A
mov rdi, rsp
call dbuf_free
push 2
jmp short loc_111F7
loc_11215:
mov rdx, [rsp+48h+var_40]
loc_1121A:
mov r15, rsp
mov rsi, [r15]
mov rdi, rbx
call JS_NewStringLen
mov r14, rax
mov rbx, rdx
mov rdi, r15
call dbuf_free
mov rcx, 0FFFFFFFF00000000h
and rcx, r14
loc_11243:
mov eax, r14d
or rax, rcx
mov rdx, rbx
add rsp, 30h
pop rbx
pop r14
pop r15
retn
|
unsigned long long js_std_file_getline(long long a1)
{
long long v1; // rax
long long v2; // r14
int v3; // eax
long long v4; // rax
long long v5; // r14
unsigned long long v6; // rcx
long long v7; // rdx
long long v9; // [rsp+0h] [rbp-48h] BYREF
long long v10; // [rsp+8h] [rbp-40h]
v1 = js_std_file_get(a1);
if ( v1 )
{
v2 = v1;
js_std_dbuf_init(a1, &v9);
while ( 1 )
{
v3 = fgetc(v2);
if ( v3 == 10 )
{
v7 = v10;
goto LABEL_11;
}
if ( v3 == -1 )
break;
if ( (unsigned int)dbuf_putc(&v9, (unsigned __int8)v3) )
{
dbuf_free(&v9);
v4 = JS_ThrowOutOfMemory(a1);
LODWORD(v5) = v4;
v6 = v4 & 0xFFFFFFFF00000000LL;
return v6 | (unsigned int)v5;
}
}
v7 = v10;
if ( !v10 )
{
dbuf_free(&v9);
goto LABEL_7;
}
LABEL_11:
v5 = JS_NewStringLen(a1, v9, v7);
dbuf_free(&v9);
v6 = v5 & 0xFFFFFFFF00000000LL;
}
else
{
LABEL_7:
LODWORD(v5) = 0;
v6 = 0LL;
}
return v6 | (unsigned int)v5;
}
|
js_std_file_getline:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
CALL 0x001113c6
TEST RAX,RAX
JZ 0x001111f5
MOV R14,RAX
MOV R15,RSP
MOV RDI,RBX
MOV RSI,R15
CALL 0x00111a50
LAB_001111af:
MOV RDI,R14
CALL 0x0010e3a0
CMP EAX,0xa
JZ 0x00111215
CMP EAX,-0x1
JZ 0x001111ff
MOVZX ESI,AL
MOV RDI,R15
CALL 0x00115d33
TEST EAX,EAX
JZ 0x001111af
MOV RDI,RSP
CALL 0x00115e89
MOV RDI,RBX
CALL 0x001171e0
MOV R14,RAX
MOV RBX,RDX
MOV RCX,-0x100000000
AND RCX,RAX
JMP 0x00111243
LAB_001111f5:
PUSH 0x6
LAB_001111f7:
POP RBX
XOR R14D,R14D
XOR ECX,ECX
JMP 0x00111243
LAB_001111ff:
MOV RDX,qword ptr [RSP + 0x8]
TEST RDX,RDX
JNZ 0x0011121a
MOV RDI,RSP
CALL 0x00115e89
PUSH 0x2
JMP 0x001111f7
LAB_00111215:
MOV RDX,qword ptr [RSP + 0x8]
LAB_0011121a:
MOV R15,RSP
MOV RSI,qword ptr [R15]
MOV RDI,RBX
CALL 0x0011a2ea
MOV R14,RAX
MOV RBX,RDX
MOV RDI,R15
CALL 0x00115e89
MOV RCX,-0x100000000
AND RCX,R14
LAB_00111243:
MOV EAX,R14D
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
int1 [16] js_std_file_getline(int8 param_1)
{
uint uVar1;
int iVar2;
FILE *__stream;
ulong uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
ulong uStack_50;
int8 local_48;
long local_40;
__stream = (FILE *)js_std_file_get();
if (__stream == (FILE *)0x0) {
uStack_50 = 6;
LAB_001111f7:
auVar4._8_8_ = 0;
auVar4._0_8_ = uStack_50;
auVar4 = auVar4 << 0x40;
uVar3 = 0;
}
else {
js_std_dbuf_init(param_1,&local_48);
do {
uVar1 = fgetc(__stream);
if (uVar1 == 10) {
LAB_0011121a:
auVar4 = JS_NewStringLen(param_1,local_48,local_40);
dbuf_free(&local_48);
uVar3 = auVar4._0_8_ & 0xffffffff00000000;
goto LAB_00111243;
}
if (uVar1 == 0xffffffff) {
if (local_40 != 0) goto LAB_0011121a;
dbuf_free(&local_48);
uStack_50 = 2;
goto LAB_001111f7;
}
iVar2 = dbuf_putc(&local_48,uVar1 & 0xff);
} while (iVar2 == 0);
dbuf_free(&local_48);
auVar4 = JS_ThrowOutOfMemory(param_1);
uVar3 = auVar4._0_8_ & 0xffffffff00000000;
}
LAB_00111243:
auVar5._0_8_ = auVar4._0_8_ & 0xffffffff | uVar3;
auVar5._8_8_ = auVar4._8_8_;
return auVar5;
}
|
|
57,721
|
my_wc_mb_tis620
|
eloqsql/strings/ctype-tis620.c
|
static
int my_wc_mb_tis620(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc,
uchar *str,
uchar *end __attribute__((unused)))
{
const uchar *pl;
if (str >= end)
return MY_CS_TOOSMALL;
pl= uni_to_cs[(wc>>8) & 0xFF];
str[0]= pl ? pl[wc & 0xFF] : '\0';
return (!str[0] && wc) ? MY_CS_ILUNI : 1;
}
|
O3
|
c
|
my_wc_mb_tis620:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x3aba6
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq %rsi, %rbx
movzbl %bh, %eax
leaq 0x2ae5d1(%rip), %rcx # 0x2e9150
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x3ab90
movzbl %bl, %ecx
movb (%rax,%rcx), %al
jmp 0x3ab92
xorl %eax, %eax
movb %al, (%rdx)
testb %al, %al
setne %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
movzbl %cl, %eax
popq %rbx
popq %rbp
retq
|
my_wc_mb_tis620:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_3ABA6
push rbp
mov rbp, rsp
push rbx
mov rbx, rsi
movzx eax, bh
lea rcx, uni_to_cs_0
mov rax, [rcx+rax*8]
test rax, rax
jz short loc_3AB90
movzx ecx, bl
mov al, [rax+rcx]
jmp short loc_3AB92
loc_3AB90:
xor eax, eax
loc_3AB92:
mov [rdx], al
test al, al
setnz al
test rbx, rbx
setz cl
or cl, al
movzx eax, cl
pop rbx
pop rbp
locret_3ABA6:
retn
|
long long my_wc_mb_tis620(long long a1, long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rax
char v6; // al
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = (long long)*(&uni_to_cs_0 + BYTE1(a2));
if ( v5 )
v6 = *(_BYTE *)(v5 + (unsigned __int8)a2);
else
v6 = 0;
*a3 = v6;
return (v6 != 0) | (unsigned __int8)(a2 == 0);
}
return result;
}
|
my_wc_mb_tis620:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0013aba6
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV RBX,RSI
MOVZX EAX,BH
LEA RCX,[0x3e9150]
MOV RAX,qword ptr [RCX + RAX*0x8]
TEST RAX,RAX
JZ 0x0013ab90
MOVZX ECX,BL
MOV AL,byte ptr [RAX + RCX*0x1]
JMP 0x0013ab92
LAB_0013ab90:
XOR EAX,EAX
LAB_0013ab92:
MOV byte ptr [RDX],AL
TEST AL,AL
SETNZ AL
TEST RBX,RBX
SETZ CL
OR CL,AL
MOVZX EAX,CL
POP RBX
POP RBP
LAB_0013aba6:
RET
|
ulong my_wc_mb_tis620(int8 param_1,ulong param_2,char *param_3,char *param_4)
{
char cVar1;
ulong uVar2;
uVar2 = 0xffffff9b;
if (param_3 < param_4) {
if (*(long *)(uni_to_cs + (param_2 >> 8 & 0xff) * 8) == 0) {
cVar1 = '\0';
}
else {
cVar1 = *(char *)(*(long *)(uni_to_cs + (param_2 >> 8 & 0xff) * 8) + (param_2 & 0xff));
}
*param_3 = cVar1;
uVar2 = (ulong)(param_2 == 0 || cVar1 != '\0');
}
return uVar2;
}
|
|
57,722
|
utf8_encode_len
|
bluesky950520[P]quickjs/cutils.c
|
size_t utf8_encode_len(uint32_t c)
{
if (c < 0x80)
return 1;
if (c < 0x800)
return 2;
if (c < 0x10000)
return 3;
if (c < 0x110000)
return 4;
return 3;
}
|
O0
|
c
|
utf8_encode_len:
movl %edi, -0xc(%rsp)
cmpl $0x80, -0xc(%rsp)
jae 0x1e989
movq $0x1, -0x8(%rsp)
jmp 0x1e9d1
cmpl $0x800, -0xc(%rsp) # imm = 0x800
jae 0x1e99e
movq $0x2, -0x8(%rsp)
jmp 0x1e9d1
cmpl $0x10000, -0xc(%rsp) # imm = 0x10000
jae 0x1e9b3
movq $0x3, -0x8(%rsp)
jmp 0x1e9d1
cmpl $0x110000, -0xc(%rsp) # imm = 0x110000
jae 0x1e9c8
movq $0x4, -0x8(%rsp)
jmp 0x1e9d1
movq $0x3, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
|
utf8_encode_len:
mov [rsp+var_C], edi
cmp [rsp+var_C], 80h
jnb short loc_1E989
mov [rsp+var_8], 1
jmp short loc_1E9D1
loc_1E989:
cmp [rsp+var_C], 800h
jnb short loc_1E99E
mov [rsp+var_8], 2
jmp short loc_1E9D1
loc_1E99E:
cmp [rsp+var_C], 10000h
jnb short loc_1E9B3
mov [rsp+var_8], 3
jmp short loc_1E9D1
loc_1E9B3:
cmp [rsp+var_C], 110000h
jnb short loc_1E9C8
mov [rsp+var_8], 4
jmp short loc_1E9D1
loc_1E9C8:
mov [rsp+var_8], 3
loc_1E9D1:
mov rax, [rsp+var_8]
retn
|
long long utf8_encode_len(unsigned int a1)
{
if ( a1 < 0x80 )
return 1LL;
if ( a1 < 0x800 )
return 2LL;
if ( a1 < 0x10000 )
return 3LL;
if ( a1 >= 0x110000 )
return 3LL;
return 4LL;
}
|
utf8_encode_len:
MOV dword ptr [RSP + -0xc],EDI
CMP dword ptr [RSP + -0xc],0x80
JNC 0x0011e989
MOV qword ptr [RSP + -0x8],0x1
JMP 0x0011e9d1
LAB_0011e989:
CMP dword ptr [RSP + -0xc],0x800
JNC 0x0011e99e
MOV qword ptr [RSP + -0x8],0x2
JMP 0x0011e9d1
LAB_0011e99e:
CMP dword ptr [RSP + -0xc],0x10000
JNC 0x0011e9b3
MOV qword ptr [RSP + -0x8],0x3
JMP 0x0011e9d1
LAB_0011e9b3:
CMP dword ptr [RSP + -0xc],0x110000
JNC 0x0011e9c8
MOV qword ptr [RSP + -0x8],0x4
JMP 0x0011e9d1
LAB_0011e9c8:
MOV qword ptr [RSP + -0x8],0x3
LAB_0011e9d1:
MOV RAX,qword ptr [RSP + -0x8]
RET
|
int8 utf8_encode_len(uint param_1)
{
int8 local_8;
if (param_1 < 0x80) {
local_8 = 1;
}
else if (param_1 < 0x800) {
local_8 = 2;
}
else if (param_1 < 0x10000) {
local_8 = 3;
}
else if (param_1 < 0x110000) {
local_8 = 4;
}
else {
local_8 = 3;
}
return local_8;
}
|
|
57,723
|
utf8_encode_len
|
bluesky950520[P]quickjs/cutils.c
|
size_t utf8_encode_len(uint32_t c)
{
if (c < 0x80)
return 1;
if (c < 0x800)
return 2;
if (c < 0x10000)
return 3;
if (c < 0x110000)
return 4;
return 3;
}
|
O1
|
c
|
utf8_encode_len:
movl $0x1, %eax
cmpl $0x80, %edi
jb 0x1b682
movl $0x2, %eax
cmpl $0x800, %edi # imm = 0x800
jb 0x1b682
movl $0x3, %eax
cmpl $0x10000, %edi # imm = 0x10000
jb 0x1b682
xorl %eax, %eax
cmpl $0x110000, %edi # imm = 0x110000
adcq $0x3, %rax
retq
|
utf8_encode_len:
mov eax, 1
cmp edi, 80h
jb short locret_1B682
mov eax, 2
cmp edi, 800h
jb short locret_1B682
mov eax, 3
cmp edi, 10000h
jb short locret_1B682
xor eax, eax
cmp edi, 110000h
adc rax, 3
locret_1B682:
retn
|
long long utf8_encode_len(unsigned int a1)
{
long long result; // rax
result = 1LL;
if ( a1 >= 0x80 )
{
result = 2LL;
if ( a1 >= 0x800 )
{
result = 3LL;
if ( a1 >= 0x10000 )
return (a1 < 0x110000) + 3LL;
}
}
return result;
}
|
utf8_encode_len:
MOV EAX,0x1
CMP EDI,0x80
JC 0x0011b682
MOV EAX,0x2
CMP EDI,0x800
JC 0x0011b682
MOV EAX,0x3
CMP EDI,0x10000
JC 0x0011b682
XOR EAX,EAX
CMP EDI,0x110000
ADC RAX,0x3
LAB_0011b682:
RET
|
char utf8_encode_len(uint param_1)
{
char cVar1;
cVar1 = '\x01';
if (((0x7f < param_1) && (cVar1 = '\x02', 0x7ff < param_1)) && (cVar1 = '\x03', 0xffff < param_1))
{
cVar1 = (param_1 < 0x110000) + '\x03';
}
return cVar1;
}
|
|
57,724
|
utf8_encode_len
|
bluesky950520[P]quickjs/cutils.c
|
size_t utf8_encode_len(uint32_t c)
{
if (c < 0x80)
return 1;
if (c < 0x800)
return 2;
if (c < 0x10000)
return 3;
if (c < 0x110000)
return 4;
return 3;
}
|
O2
|
c
|
utf8_encode_len:
cmpl $0x80, %edi
jae 0x15eba
pushq $0x1
jmp 0x15ed0
cmpl $0x800, %edi # imm = 0x800
jae 0x15ec6
pushq $0x2
jmp 0x15ed0
cmpl $0x10000, %edi # imm = 0x10000
jae 0x15ed2
pushq $0x3
popq %rax
retq
xorl %eax, %eax
cmpl $0x110000, %edi # imm = 0x110000
adcq $0x3, %rax
retq
|
utf8_encode_len:
cmp edi, 80h
jnb short loc_15EBA
push 1
jmp short loc_15ED0
loc_15EBA:
cmp edi, 800h
jnb short loc_15EC6
push 2
jmp short loc_15ED0
loc_15EC6:
cmp edi, 10000h
jnb short loc_15ED2
push 3
loc_15ED0:
pop rax
retn
loc_15ED2:
xor eax, eax
cmp edi, 110000h
adc rax, 3
retn
|
long long utf8_encode_len(unsigned int a1)
{
if ( a1 < 0x80 )
return 1LL;
if ( a1 < 0x800 )
return 2LL;
if ( a1 < 0x10000 )
return 3LL;
return (a1 < 0x110000) + 3LL;
}
|
utf8_encode_len:
CMP EDI,0x80
JNC 0x00115eba
PUSH 0x1
JMP 0x00115ed0
LAB_00115eba:
CMP EDI,0x800
JNC 0x00115ec6
PUSH 0x2
JMP 0x00115ed0
LAB_00115ec6:
CMP EDI,0x10000
JNC 0x00115ed2
PUSH 0x3
LAB_00115ed0:
POP RAX
RET
LAB_00115ed2:
XOR EAX,EAX
CMP EDI,0x110000
ADC RAX,0x3
RET
|
char utf8_encode_len(uint param_1)
{
char cVar1;
if (param_1 < 0x80) {
cVar1 = '\x01';
}
else if (param_1 < 0x800) {
cVar1 = '\x02';
}
else {
if (0xffff < param_1) {
return (param_1 < 0x110000) + '\x03';
}
cVar1 = '\x03';
}
return cVar1;
}
|
|
57,725
|
utf8_encode_len
|
bluesky950520[P]quickjs/cutils.c
|
size_t utf8_encode_len(uint32_t c)
{
if (c < 0x80)
return 1;
if (c < 0x800)
return 2;
if (c < 0x10000)
return 3;
if (c < 0x110000)
return 4;
return 3;
}
|
O3
|
c
|
utf8_encode_len:
movl $0x1, %eax
cmpl $0x80, %edi
jb 0x1bfb3
movl $0x2, %eax
cmpl $0x800, %edi # imm = 0x800
jb 0x1bfb3
movl $0x3, %eax
cmpl $0x10000, %edi # imm = 0x10000
jb 0x1bfb3
xorl %eax, %eax
cmpl $0x110000, %edi # imm = 0x110000
adcq $0x3, %rax
retq
|
utf8_encode_len:
mov eax, 1
cmp edi, 80h
jb short locret_1BFB3
mov eax, 2
cmp edi, 800h
jb short locret_1BFB3
mov eax, 3
cmp edi, offset loc_10000
jb short locret_1BFB3
xor eax, eax
cmp edi, 110000h
adc rax, 3
locret_1BFB3:
retn
|
long long utf8_encode_len(unsigned int a1)
{
long long result; // rax
result = 1LL;
if ( a1 >= 0x80 )
{
result = 2LL;
if ( a1 >= 0x800 )
{
result = 3LL;
if ( a1 >= (unsigned int)&loc_10000 )
return (a1 < 0x110000) + 3LL;
}
}
return result;
}
|
utf8_encode_len:
MOV EAX,0x1
CMP EDI,0x80
JC 0x0011bfb3
MOV EAX,0x2
CMP EDI,0x800
JC 0x0011bfb3
MOV EAX,0x3
CMP EDI,0x10000
JC 0x0011bfb3
XOR EAX,EAX
CMP EDI,0x110000
ADC RAX,0x3
LAB_0011bfb3:
RET
|
char utf8_encode_len(uint param_1)
{
char cVar1;
cVar1 = '\x01';
if (((0x7f < param_1) && (cVar1 = '\x02', 0x7ff < param_1)) && (cVar1 = '\x03', 0xffff < param_1))
{
cVar1 = (param_1 < 0x110000) + '\x03';
}
return cVar1;
}
|
|
57,726
|
mysql_stmt_close
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
my_bool STDCALL mysql_stmt_close(MYSQL_STMT *stmt)
{
my_bool rc= 1;
if (stmt)
{
if (stmt->mysql && stmt->mysql->net.pvio)
mysql_stmt_internal_reset(stmt, 1);
rc= net_stmt_close(stmt, 1);
free(stmt->extension);
free(stmt);
}
return(rc);
}
|
O0
|
c
|
mysql_stmt_close:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, -0x9(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2f228
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x2f1fe
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, (%rax)
je 0x2f1fe
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2e0f0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2e300
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x340(%rax), %rdi
callq 0x13520
movq -0x8(%rbp), %rdi
callq 0x13520
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
mysql_stmt_close:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_9], 1
cmp [rbp+var_8], 0
jz short loc_2F228
mov rax, [rbp+var_8]
cmp qword ptr [rax+38h], 0
jz short loc_2F1FE
mov rax, [rbp+var_8]
mov rax, [rax+38h]
cmp qword ptr [rax], 0
jz short loc_2F1FE
mov rdi, [rbp+var_8]
mov esi, 1
call mysql_stmt_internal_reset
loc_2F1FE:
mov rdi, [rbp+var_8]
mov esi, 1
call net_stmt_close
mov [rbp+var_9], al
mov rax, [rbp+var_8]
mov rdi, [rax+340h]
call _free
mov rdi, [rbp+var_8]
call _free
loc_2F228:
mov al, [rbp+var_9]
add rsp, 10h
pop rbp
retn
|
char mysql_stmt_close(long long a1)
{
char v2; // [rsp+7h] [rbp-9h]
v2 = 1;
if ( a1 )
{
if ( *(_QWORD *)(a1 + 56) && **(_QWORD **)(a1 + 56) )
mysql_stmt_internal_reset(a1, 1);
v2 = net_stmt_close(a1, 1);
free(*(_QWORD *)(a1 + 832));
free(a1);
}
return v2;
}
|
mysql_stmt_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],0x1
CMP qword ptr [RBP + -0x8],0x0
JZ 0x0012f228
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x38],0x0
JZ 0x0012f1fe
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x38]
CMP qword ptr [RAX],0x0
JZ 0x0012f1fe
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x1
CALL 0x0012e0f0
LAB_0012f1fe:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x1
CALL 0x0012e300
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x340]
CALL 0x00113520
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00113520
LAB_0012f228:
MOV AL,byte ptr [RBP + -0x9]
ADD RSP,0x10
POP RBP
RET
|
int1 mysql_stmt_close(void *param_1)
{
int1 local_11;
local_11 = 1;
if (param_1 != (void *)0x0) {
if ((*(long *)((long)param_1 + 0x38) != 0) && (**(long **)((long)param_1 + 0x38) != 0)) {
mysql_stmt_internal_reset(param_1,1);
}
local_11 = net_stmt_close(param_1,1);
free(*(void **)((long)param_1 + 0x340));
free(param_1);
}
return local_11;
}
|
|
57,727
|
JS_ThrowError
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ThrowError(JSContext *ctx, JSErrorEnum error_num,
const char *fmt, va_list ap)
{
JSRuntime *rt = ctx->rt;
JSStackFrame *sf;
BOOL add_backtrace;
/* the backtrace is added later if called from a bytecode function */
sf = rt->current_stack_frame;
add_backtrace = !rt->in_out_of_memory &&
(!sf || (JS_GetFunctionBytecode(sf->cur_func) == NULL));
return JS_ThrowError2(ctx, error_num, fmt, ap, add_backtrace);
}
|
O0
|
c
|
JS_ThrowError:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x108(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x100(%rax), %ecx
shll $0x18, %ecx
sarl $0x18, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x3(%rsp)
jne 0x2d1c5
movb $0x1, %al
cmpq $0x0, 0x8(%rsp)
movb %al, 0x2(%rsp)
je 0x2d1bd
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x5fcc0
cmpq $0x0, %rax
sete %al
movb %al, 0x2(%rsp)
movb 0x2(%rsp), %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
movzbl %al, %eax
andl $0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0x4(%rsp), %r8d
callq 0x48830
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nopl (%rax)
|
JS_ThrowError:
sub rsp, 48h
mov [rsp+48h+var_18], rdi
mov [rsp+48h+var_1C], esi
mov [rsp+48h+var_28], rdx
mov [rsp+48h+var_30], rcx
mov rax, [rsp+48h+var_18]
mov rax, [rax+18h]
mov [rsp+48h+var_38], rax
mov rax, [rsp+48h+var_38]
mov rax, [rax+108h]
mov [rsp+48h+var_40], rax
mov rax, [rsp+48h+var_38]
mov ecx, [rax+100h]
shl ecx, 18h
sar ecx, 18h
xor eax, eax
cmp ecx, 0
mov [rsp+48h+var_45], al
jnz short loc_2D1C5
mov al, 1
cmp [rsp+48h+var_40], 0
mov [rsp+48h+var_46], al
jz short loc_2D1BD
mov rax, [rsp+48h+var_40]
mov rdi, [rax+8]
mov rsi, [rax+10h]
call JS_GetFunctionBytecode
cmp rax, 0
setz al
mov [rsp+48h+var_46], al
loc_2D1BD:
mov al, [rsp+48h+var_46]
mov [rsp+48h+var_45], al
loc_2D1C5:
mov al, [rsp+48h+var_45]
movzx eax, al
and eax, 1
mov [rsp+48h+var_44], eax
mov rdi, [rsp+48h+var_18]
mov esi, [rsp+48h+var_1C]
mov rdx, [rsp+48h+var_28]
mov rcx, [rsp+48h+var_30]
mov r8d, [rsp+48h+var_44]
call JS_ThrowError2
mov [rsp+48h+var_10], rax
mov [rsp+48h+var_8], rdx
mov rax, [rsp+48h+var_10]
mov rdx, [rsp+48h+var_8]
add rsp, 48h
retn
|
long long JS_ThrowError(long long a1, unsigned int a2, long long a3, long long a4)
{
bool v5; // [rsp+2h] [rbp-46h]
bool v6; // [rsp+3h] [rbp-45h]
long long v7; // [rsp+8h] [rbp-40h]
long long v8; // [rsp+10h] [rbp-38h]
v8 = *(_QWORD *)(a1 + 24);
v7 = *(_QWORD *)(v8 + 264);
v6 = 0;
if ( !(unsigned __int8)*(_DWORD *)(v8 + 256) )
{
v5 = 1;
if ( v7 )
v5 = JS_GetFunctionBytecode(*(_QWORD *)(v7 + 8), *(_QWORD *)(v7 + 16)) == 0;
v6 = v5;
}
return JS_ThrowError2(a1, a2, a3, a4, v6);
}
|
JS_ThrowError:
SUB RSP,0x48
MOV qword ptr [RSP + 0x30],RDI
MOV dword ptr [RSP + 0x2c],ESI
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x18],RCX
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x108]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RAX + 0x100]
SHL ECX,0x18
SAR ECX,0x18
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RSP + 0x3],AL
JNZ 0x0012d1c5
MOV AL,0x1
CMP qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x2],AL
JZ 0x0012d1bd
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RAX + 0x10]
CALL 0x0015fcc0
CMP RAX,0x0
SETZ AL
MOV byte ptr [RSP + 0x2],AL
LAB_0012d1bd:
MOV AL,byte ptr [RSP + 0x2]
MOV byte ptr [RSP + 0x3],AL
LAB_0012d1c5:
MOV AL,byte ptr [RSP + 0x3]
MOVZX EAX,AL
AND EAX,0x1
MOV dword ptr [RSP + 0x4],EAX
MOV RDI,qword ptr [RSP + 0x30]
MOV ESI,dword ptr [RSP + 0x2c]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x18]
MOV R8D,dword ptr [RSP + 0x4]
CALL 0x00148830
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
int1 [16]
JS_ThrowError(long param_1,int4 param_2,int8 param_3,int8 param_4)
{
int1 auVar1 [16];
long lVar2;
int1 local_46;
int1 local_45;
lVar2 = *(long *)(*(long *)(param_1 + 0x18) + 0x108);
local_45 = false;
if ((char)*(int4 *)(*(long *)(param_1 + 0x18) + 0x100) == '\0') {
local_46 = true;
if (lVar2 != 0) {
lVar2 = JS_GetFunctionBytecode(*(int8 *)(lVar2 + 8),*(int8 *)(lVar2 + 0x10));
local_46 = lVar2 == 0;
}
local_45 = local_46;
}
auVar1 = JS_ThrowError2(param_1,param_2,param_3,param_4,local_45);
return auVar1;
}
|
|
57,728
|
JS_ThrowError
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ThrowError(JSContext *ctx, JSErrorEnum error_num,
const char *fmt, va_list ap)
{
JSRuntime *rt = ctx->rt;
JSStackFrame *sf;
BOOL add_backtrace;
/* the backtrace is added later if called from a bytecode function */
sf = rt->current_stack_frame;
add_backtrace = !rt->in_out_of_memory &&
(!sf || (JS_GetFunctionBytecode(sf->cur_func) == NULL));
return JS_ThrowError2(ctx, error_num, fmt, ap, add_backtrace);
}
|
O1
|
c
|
JS_ThrowError:
movq 0x18(%rdi), %rax
xorl %r8d, %r8d
cmpb $0x0, 0x100(%rax)
jne 0x2fdef
movq 0x108(%rax), %rax
testq %rax, %rax
je 0x224c6
movsd 0x8(%rax), %xmm0
movl 0x10(%rax), %eax
movsd %xmm0, -0x8(%rsp)
movl $0x1, %r8d
cmpl $-0x1, %eax
jne 0x2fdef
movq -0x8(%rsp), %rax
movzwl 0x6(%rax), %r9d
cmpq $0x38, %r9
ja 0x2fdef
movabsq $0x110000000012000, %r10 # imm = 0x110000000012000
btq %r9, %r10
jae 0x2fdef
xorl %r8d, %r8d
cmpq $0x0, 0x30(%rax)
sete %r8b
jmp 0x2fdef
movl $0x1, %r8d
jmp 0x2fdef
|
JS_ThrowError:
mov rax, [rdi+18h]
xor r8d, r8d
cmp byte ptr [rax+100h], 0
jnz JS_ThrowError2
mov rax, [rax+108h]
test rax, rax
jz short loc_224C6
movsd xmm0, qword ptr [rax+8]
mov eax, [rax+10h]
movsd [rsp+var_8], xmm0
mov r8d, 1
cmp eax, 0FFFFFFFFh
jnz JS_ThrowError2
mov rax, [rsp+var_8]
movzx r9d, word ptr [rax+6]
cmp r9, 38h ; '8'
ja JS_ThrowError2
mov r10, 110000000012000h
bt r10, r9
jnb JS_ThrowError2
xor r8d, r8d
cmp qword ptr [rax+30h], 0
setz r8b
jmp JS_ThrowError2
loc_224C6:
mov r8d, 1
jmp JS_ThrowError2
|
long long JS_ThrowError(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // r8
long long v6; // rax
unsigned long long v7; // r9
long long v8; // r10
long long v10; // [rsp+0h] [rbp-8h]
v4 = *(_QWORD *)(a1 + 24);
v5 = 0LL;
if ( !*(_BYTE *)(v4 + 256) )
{
v6 = *(_QWORD *)(v4 + 264);
if ( !v6 )
return JS_ThrowError2(a1, a2, a3, a4, 1LL);
v10 = *(_QWORD *)(v6 + 8);
v5 = 1LL;
if ( *(_DWORD *)(v6 + 16) == -1 )
{
v7 = *(unsigned __int16 *)(v10 + 6);
if ( v7 <= 0x38 )
{
v8 = 0x110000000012000LL;
if ( _bittest64(&v8, v7) )
return JS_ThrowError2(a1, a2, a3, a4, *(_QWORD *)(v10 + 48) == 0LL);
}
}
}
return JS_ThrowError2(a1, a2, a3, a4, v5);
}
|
JS_ThrowError:
MOV RAX,qword ptr [RDI + 0x18]
XOR R8D,R8D
CMP byte ptr [RAX + 0x100],0x0
JNZ 0x0012fdef
MOV RAX,qword ptr [RAX + 0x108]
TEST RAX,RAX
JZ 0x001224c6
MOVSD XMM0,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX + 0x10]
MOVSD qword ptr [RSP + -0x8],XMM0
MOV R8D,0x1
CMP EAX,-0x1
JNZ 0x0012fdef
MOV RAX,qword ptr [RSP + -0x8]
MOVZX R9D,word ptr [RAX + 0x6]
CMP R9,0x38
JA 0x0012fdef
MOV R10,0x110000000012000
BT R10,R9
JNC 0x0012fdef
XOR R8D,R8D
CMP qword ptr [RAX + 0x30],0x0
SETZ R8B
JMP 0x0012fdef
LAB_001224c6:
MOV R8D,0x1
JMP 0x0012fdef
|
void JS_ThrowError(long param_1,int4 param_2,char *param_3,__gnuc_va_list param_4)
{
long lVar1;
int4 uVar2;
ulong uVar3;
int1 auVar4 [16];
char acStack_128 [264];
uVar2 = 0;
if (*(char *)(*(long *)(param_1 + 0x18) + 0x100) == '\0') {
lVar1 = *(long *)(*(long *)(param_1 + 0x18) + 0x108);
if (lVar1 == 0) {
JS_ThrowError2();
return;
}
uVar2 = 1;
if (((*(int *)(lVar1 + 0x10) == -1) &&
(uVar3 = (ulong)*(ushort *)(*(long *)(lVar1 + 8) + 6), uVar3 < 0x39)) &&
((0x110000000012000U >> (uVar3 & 0x3f) & 1) != 0)) {
JS_ThrowError2();
return;
}
}
vsnprintf(acStack_128,0x100,param_3,param_4);
auVar4 = JS_MakeError(param_1,param_2,acStack_128,uVar2);
if (auVar4._8_4_ == 6) {
auVar4 = ZEXT816(2) << 0x40;
}
lVar1 = *(long *)(param_1 + 0x18);
JS_FreeValueRT(lVar1,*(int8 *)(lVar1 + 0xf0),*(int8 *)(lVar1 + 0xf8));
*(int1 (*) [16])(lVar1 + 0xf0) = auVar4;
return;
}
|
|
57,729
|
JS_ThrowError
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ThrowError(JSContext *ctx, JSErrorEnum error_num,
const char *fmt, va_list ap)
{
JSRuntime *rt = ctx->rt;
JSStackFrame *sf;
BOOL add_backtrace;
/* the backtrace is added later if called from a bytecode function */
sf = rt->current_stack_frame;
add_backtrace = !rt->in_out_of_memory &&
(!sf || (JS_GetFunctionBytecode(sf->cur_func) == NULL));
return JS_ThrowError2(ctx, error_num, fmt, ap, add_backtrace);
}
|
O2
|
c
|
JS_ThrowError:
movq 0x18(%rdi), %rax
xorl %r8d, %r8d
cmpb $0x0, 0x100(%rax)
jne 0x28557
movq 0x108(%rax), %rax
pushq $0x1
popq %r8
testq %rax, %rax
je 0x28557
cmpl $-0x1, 0x10(%rax)
jne 0x28557
movq 0x8(%rax), %rax
movzwl 0x6(%rax), %r9d
cmpq $0x38, %r9
ja 0x28557
movabsq $0x110000000012000, %r10 # imm = 0x110000000012000
btq %r9, %r10
jae 0x28557
xorl %r8d, %r8d
cmpq $0x0, 0x30(%rax)
sete %r8b
jmp 0x28557
|
JS_ThrowError:
mov rax, [rdi+18h]
xor r8d, r8d
cmp byte ptr [rax+100h], 0
jnz JS_ThrowError2
mov rax, [rax+108h]
push 1
pop r8
test rax, rax
jz JS_ThrowError2
cmp dword ptr [rax+10h], 0FFFFFFFFh
jnz JS_ThrowError2
mov rax, [rax+8]
movzx r9d, word ptr [rax+6]
cmp r9, 38h ; '8'
ja JS_ThrowError2
mov r10, 110000000012000h
bt r10, r9
jnb JS_ThrowError2
xor r8d, r8d
cmp qword ptr [rax+30h], 0
setz r8b
jmp JS_ThrowError2
|
long long JS_ThrowError(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // r8
long long v6; // rax
long long v7; // rax
unsigned long long v8; // r9
long long v9; // r10
v4 = *(_QWORD *)(a1 + 24);
v5 = 0LL;
if ( !*(_BYTE *)(v4 + 256)
&& (v6 = *(_QWORD *)(v4 + 264), v5 = 1LL, v6)
&& *(_DWORD *)(v6 + 16) == -1
&& (v7 = *(_QWORD *)(v6 + 8), v8 = *(unsigned __int16 *)(v7 + 6), v8 <= 0x38)
&& (v9 = 0x110000000012000LL, _bittest64(&v9, v8)) )
{
return JS_ThrowError2(a1, a2, a3, a4, *(_QWORD *)(v7 + 48) == 0LL);
}
else
{
return JS_ThrowError2(a1, a2, a3, a4, v5);
}
}
|
JS_ThrowError:
MOV RAX,qword ptr [RDI + 0x18]
XOR R8D,R8D
CMP byte ptr [RAX + 0x100],0x0
JNZ 0x00128557
MOV RAX,qword ptr [RAX + 0x108]
PUSH 0x1
POP R8
TEST RAX,RAX
JZ 0x00128557
CMP dword ptr [RAX + 0x10],-0x1
JNZ 0x00128557
MOV RAX,qword ptr [RAX + 0x8]
MOVZX R9D,word ptr [RAX + 0x6]
CMP R9,0x38
JA 0x00128557
MOV R10,0x110000000012000
BT R10,R9
JNC 0x00128557
XOR R8D,R8D
CMP qword ptr [RAX + 0x30],0x0
SETZ R8B
JMP 0x00128557
|
void JS_ThrowError(long param_1,int4 param_2,char *param_3,__gnuc_va_list param_4)
{
long lVar1;
int8 uVar2;
ulong uVar3;
int1 auVar4 [16];
char acStack_128 [264];
uVar2 = 0;
if (*(char *)(*(long *)(param_1 + 0x18) + 0x100) == '\0') {
lVar1 = *(long *)(*(long *)(param_1 + 0x18) + 0x108);
uVar2 = 1;
if ((lVar1 != 0) && (*(int *)(lVar1 + 0x10) == -1)) {
uVar3 = (ulong)*(ushort *)(*(long *)(lVar1 + 8) + 6);
if ((uVar3 < 0x39) && ((0x110000000012000U >> (uVar3 & 0x3f) & 1) != 0)) {
JS_ThrowError2();
return;
}
}
}
vsnprintf(acStack_128,0x100,param_3,param_4);
auVar4 = JS_MakeError(param_1,param_2,acStack_128,uVar2);
if (auVar4._8_4_ == 6) {
auVar4 = ZEXT816(2) << 0x40;
}
JS_Throw(param_1,auVar4._0_8_,auVar4._8_8_);
return;
}
|
|
57,730
|
nglog::ColoredWriteToStderrOrStdout(_IO_FILE*, nglog::LogSeverity, char const*, unsigned long)
|
ng-log[P]ng-log/src/logging.cc
|
static void ColoredWriteToStderrOrStdout(FILE* output, LogSeverity severity,
const char* message, size_t len) {
bool is_stdout = (output == stdout);
const GLogColor color = (LogDestination::terminal_supports_color() &&
((!is_stdout && FLAGS_colorlogtostderr) ||
(is_stdout && FLAGS_colorlogtostdout)))
? SeverityToColor(severity)
: COLOR_DEFAULT;
// Avoid using cerr from this module since we may get called during
// exit code, and cerr may be partially or fully destroyed by then.
if (COLOR_DEFAULT == color) {
fwrite(message, len, 1, output);
return;
}
#ifdef NGLOG_OS_WINDOWS
const HANDLE output_handle =
GetStdHandle(is_stdout ? STD_OUTPUT_HANDLE : STD_ERROR_HANDLE);
// Gets the current text color.
CONSOLE_SCREEN_BUFFER_INFO buffer_info;
GetConsoleScreenBufferInfo(output_handle, &buffer_info);
const WORD old_color_attrs = buffer_info.wAttributes;
// We need to flush the stream buffers into the console before each
// SetConsoleTextAttribute call lest it affect the text that is already
// printed but has not yet reached the console.
fflush(output);
SetConsoleTextAttribute(output_handle,
GetColorAttribute(color) | FOREGROUND_INTENSITY);
fwrite(message, len, 1, output);
fflush(output);
// Restores the text color.
SetConsoleTextAttribute(output_handle, old_color_attrs);
#else
fprintf(output, "\033[0;3%sm", GetAnsiColorCode(color));
fwrite(message, len, 1, output);
fprintf(output, "\033[m"); // Resets the terminal to default.
#endif // NGLOG_OS_WINDOWS
}
|
O2
|
cpp
|
nglog::ColoredWriteToStderrOrStdout(_IO_FILE*, nglog::LogSeverity, char const*, unsigned long):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
cmpb $0x1, 0x24209(%rip) # 0x32cd0
jne 0xeb09
movq 0x21440(%rip), %rax # 0x2ff10
cmpq %rbx, (%rax)
je 0xeae3
leaq 0x23fea(%rip), %rax # 0x32ac6
cmpb $0x0, (%rax)
jne 0xeaef
jmp 0xeb09
leaq 0x23fde(%rip), %rax # 0x32ac8
cmpb $0x1, (%rax)
jne 0xeb09
leal -0x2(%rsi), %eax
cmpl $0x2, %eax
jb 0xeb25
testl %esi, %esi
je 0xeb09
cmpl $0x1, %esi
jne 0xeb61
leaq 0x11c14(%rip), %rdx # 0x2071b
jmp 0xeb2c
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a70
leaq 0x11111(%rip), %rdx # 0x1fc3d
leaq 0x1144c(%rip), %rsi # 0x1ff7f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7820
pushq $0x1
popq %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x7a70
leaq 0x1142f(%rip), %rdi # 0x1ff88
pushq $0x3
popq %rsi
movq %r12, %rdx
jmp 0xeb12
leaq 0x11424(%rip), %rdi # 0x1ff8c
leaq 0x10eeb(%rip), %rsi # 0x1fa5a
leaq 0x1141c(%rip), %rcx # 0x1ff92
movl $0xeb, %edx
callq 0x7390
|
_ZN5nglogL28ColoredWriteToStderrOrStdoutEP8_IO_FILENS_11LogSeverityEPKcm:
push r15
push r14
push r12
push rbx
push rax
mov r14, rcx
mov r15, rdx
mov rbx, rdi
cmp cs:_ZN5nglog14LogDestination24terminal_supports_color_E, 1; nglog::LogDestination::terminal_supports_color_
jnz short loc_EB09
mov rax, cs:stdout_ptr
cmp [rax], rbx
jz short loc_EAE3
lea rax, _ZN3fLB22FLAGS_colorlogtostderrE; fLB::FLAGS_colorlogtostderr
cmp byte ptr [rax], 0
jnz short loc_EAEF
jmp short loc_EB09
loc_EAE3:
lea rax, _ZN3fLB22FLAGS_colorlogtostdoutE; fLB::FLAGS_colorlogtostdout
cmp byte ptr [rax], 1
jnz short loc_EB09
loc_EAEF:
lea eax, [rsi-2]
cmp eax, 2
jb short loc_EB25
test esi, esi
jz short loc_EB09
cmp esi, 1
jnz short loc_EB61
lea rdx, aDc3+2; "3"
jmp short loc_EB2C
loc_EB09:
push 1
pop rdx
mov rdi, r15
mov rsi, r14
loc_EB12:
mov rcx, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp _fwrite
loc_EB25:
lea rdx, aProcSelfFd1+0Eh; "1"
loc_EB2C:
lea rsi, a03Sm; "\x1B[0;3%sm"
mov rdi, rbx
xor eax, eax
call _fprintf
push 1
pop r12
mov rdi, r15
mov rsi, r14
mov rdx, r12
mov rcx, rbx
call _fwrite
lea rdi, aM; "\x1B[m"
push 3
pop rsi
mov rdx, r12
jmp short loc_EB12
loc_EB61:
lea rdi, aFalse; "false"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aGlogcolorNglog; "GLogColor nglog::SeverityToColor(LogSev"...
mov edx, 0EBh
call ___assert_fail
|
long long nglog::ColoredWriteToStderrOrStdout(long long a1, int a2, const char *a3, long long a4)
{
const char *v7; // rdx
const char *v8; // rdi
long long v9; // rsi
if ( nglog::LogDestination::terminal_supports_color_ != 1 )
goto LABEL_10;
if ( stdout == a1 )
{
if ( fLB::FLAGS_colorlogtostdout != 1 )
goto LABEL_10;
}
else if ( !fLB::FLAGS_colorlogtostderr )
{
goto LABEL_10;
}
if ( (unsigned int)(a2 - 2) < 2 )
{
v7 = "1";
LABEL_13:
fprintf(a1, "\x1B[0;3%sm", v7);
fwrite(a3, a4, 1LL, a1);
v8 = "\x1B[m";
v9 = 3LL;
return fwrite(v8, v9, 1LL, a1);
}
if ( a2 )
{
if ( a2 != 1 )
__assert_fail(
"false",
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",
235LL,
"GLogColor nglog::SeverityToColor(LogSeverity)");
v7 = "3";
goto LABEL_13;
}
LABEL_10:
v8 = a3;
v9 = a4;
return fwrite(v8, v9, 1LL, a1);
}
|
ColoredWriteToStderrOrStdout:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV R15,RDX
MOV RBX,RDI
CMP byte ptr [0x00132cd0],0x1
JNZ 0x0010eb09
MOV RAX,qword ptr [0x0012ff10]
CMP qword ptr [RAX],RBX
JZ 0x0010eae3
LEA RAX,[0x132ac6]
CMP byte ptr [RAX],0x0
JNZ 0x0010eaef
JMP 0x0010eb09
LAB_0010eae3:
LEA RAX,[0x132ac8]
CMP byte ptr [RAX],0x1
JNZ 0x0010eb09
LAB_0010eaef:
LEA EAX,[RSI + -0x2]
CMP EAX,0x2
JC 0x0010eb25
TEST ESI,ESI
JZ 0x0010eb09
CMP ESI,0x1
JNZ 0x0010eb61
LEA RDX,[0x12071b]
JMP 0x0010eb2c
LAB_0010eb09:
PUSH 0x1
POP RDX
MOV RDI,R15
MOV RSI,R14
LAB_0010eb12:
MOV RCX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x00107a70
LAB_0010eb25:
LEA RDX,[0x11fc3d]
LAB_0010eb2c:
LEA RSI,[0x11ff7f]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00107820
PUSH 0x1
POP R12
MOV RDI,R15
MOV RSI,R14
MOV RDX,R12
MOV RCX,RBX
CALL 0x00107a70
LEA RDI,[0x11ff88]
PUSH 0x3
POP RSI
MOV RDX,R12
JMP 0x0010eb12
LAB_0010eb61:
LEA RDI,[0x11ff8c]
LEA RSI,[0x11fa5a]
LEA RCX,[0x11ff92]
MOV EDX,0xeb
CALL 0x00107390
|
/* nglog::ColoredWriteToStderrOrStdout(_IO_FILE*, nglog::LogSeverity, char const*, unsigned long) */
void nglog::ColoredWriteToStderrOrStdout
(FILE *param_1,int param_2,int *param_3,size_t param_4)
{
char *pcVar1;
size_t sStack_30;
sStack_30 = param_4;
if (LogDestination::terminal_supports_color_ == '\x01') {
if (*(FILE **)PTR_stdout_0012ff10 == param_1) {
if (fLB::FLAGS_colorlogtostdout != '\x01') goto LAB_0010eb12;
}
else if (fLB::FLAGS_colorlogtostderr == '\0') goto LAB_0010eb12;
if (param_2 - 2U < 2) {
pcVar1 = "1";
}
else {
if (param_2 == 0) goto LAB_0010eb12;
if (param_2 != 1) {
/* WARNING: Subroutine does not return */
__assert_fail("false",
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",0xeb,
"GLogColor nglog::SeverityToColor(LogSeverity)");
}
pcVar1 = "3";
}
fprintf(param_1,"\x1b[0;3%sm",pcVar1);
fwrite(param_3,param_4,1,param_1);
param_3 = &DAT_0011ff88;
sStack_30 = 3;
}
LAB_0010eb12:
fwrite(param_3,sStack_30,1,param_1);
return;
}
|
|
57,731
|
ma_service_thread_control_end
|
eloqsql/storage/maria/ma_servicethread.c
|
void ma_service_thread_control_end(MA_SERVICE_THREAD_CONTROL *control)
{
DBUG_ENTER("ma_service_thread_control_end");
DBUG_PRINT("init", ("control %p", control));
DBUG_ASSERT(control->inited);
mysql_mutex_lock(control->LOCK_control);
if (!control->killed)
{
DBUG_PRINT("info",("killing Maria background thread"));
control->killed= TRUE; /* kill it */
mysql_cond_broadcast(control->COND_control);
mysql_mutex_unlock(control->LOCK_control);
DBUG_PRINT("info", ("waiting for Maria background thread to die"));
pthread_join(control->thread, NULL);
}
else
mysql_mutex_unlock(control->LOCK_control);
mysql_mutex_destroy(control->LOCK_control);
mysql_cond_destroy(control->COND_control);
control->inited= FALSE;
DBUG_VOID_RETURN;
}
|
O0
|
c
|
ma_service_thread_control_end:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x6880e
jmp 0x68810
jmp 0x68812
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0xb7553(%rip), %rsi # 0x11fd74
movl $0x3e, %edx
callq 0x688b0
movq -0x8(%rbp), %rax
cmpb $0x0, 0x8(%rax)
jne 0x6886f
jmp 0x68837
jmp 0x68839
movq -0x8(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x68920
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x68980
jmp 0x6885d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x272f0
jmp 0x6887c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x68980
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x689e0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x68a30
movq -0x8(%rbp), %rax
movb $0x0, 0x9(%rax)
jmp 0x688a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_service_thread_control_end:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_6880E:
jmp short $+2
loc_68810:
jmp short $+2
loc_68812:
mov rax, [rbp+var_8]
mov rdi, [rax+10h]
lea rsi, aWorkspaceLlm4b_16; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 3Eh ; '>'
call inline_mysql_mutex_lock_9
mov rax, [rbp+var_8]
cmp byte ptr [rax+8], 0
jnz short loc_6886F
jmp short $+2
loc_68837:
jmp short $+2
loc_68839:
mov rax, [rbp+var_8]
mov byte ptr [rax+8], 1
mov rax, [rbp+var_8]
mov rdi, [rax+18h]
call inline_mysql_cond_broadcast_1
mov rax, [rbp+var_8]
mov rdi, [rax+10h]
call inline_mysql_mutex_unlock_9
jmp short $+2
loc_6885D:
mov rax, [rbp+var_8]
mov rdi, [rax]
xor eax, eax
mov esi, eax
call _pthread_join
jmp short loc_6887C
loc_6886F:
mov rax, [rbp+var_8]
mov rdi, [rax+10h]
call inline_mysql_mutex_unlock_9
loc_6887C:
mov rax, [rbp+var_8]
mov rdi, [rax+10h]
call inline_mysql_mutex_destroy_4
mov rax, [rbp+var_8]
mov rdi, [rax+18h]
call inline_mysql_cond_destroy_2
mov rax, [rbp+var_8]
mov byte ptr [rax+9], 0
jmp short $+2
loc_688A0:
add rsp, 10h
pop rbp
retn
|
long long ma_service_thread_control_end(long long a1)
{
long long result; // rax
inline_mysql_mutex_lock_9(
*(_QWORD *)(a1 + 16),
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_servicethread.c",
62LL);
if ( *(_BYTE *)(a1 + 8) )
{
inline_mysql_mutex_unlock_9(*(_QWORD *)(a1 + 16));
}
else
{
*(_BYTE *)(a1 + 8) = 1;
inline_mysql_cond_broadcast_1(*(_QWORD *)(a1 + 24));
inline_mysql_mutex_unlock_9(*(_QWORD *)(a1 + 16));
pthread_join(*(_QWORD *)a1, 0LL);
}
inline_mysql_mutex_destroy_4(*(_QWORD *)(a1 + 16));
inline_mysql_cond_destroy_2(*(_QWORD *)(a1 + 24));
result = a1;
*(_BYTE *)(a1 + 9) = 0;
return result;
}
|
ma_service_thread_control_end:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0016880e
LAB_0016880e:
JMP 0x00168810
LAB_00168810:
JMP 0x00168812
LAB_00168812:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x10]
LEA RSI,[0x21fd74]
MOV EDX,0x3e
CALL 0x001688b0
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x8],0x0
JNZ 0x0016886f
JMP 0x00168837
LAB_00168837:
JMP 0x00168839
LAB_00168839:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x8],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x18]
CALL 0x00168920
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x00168980
JMP 0x0016885d
LAB_0016885d:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001272f0
JMP 0x0016887c
LAB_0016886f:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x00168980
LAB_0016887c:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x001689e0
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x18]
CALL 0x00168a30
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x9],0x0
JMP 0x001688a0
LAB_001688a0:
ADD RSP,0x10
POP RBP
RET
|
void ma_service_thread_control_end(pthread_t *param_1)
{
inline_mysql_mutex_lock
(param_1[2],"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_servicethread.c",
0x3e);
if ((char)param_1[1] == '\0') {
*(int1 *)(param_1 + 1) = 1;
inline_mysql_cond_broadcast(param_1[3]);
inline_mysql_mutex_unlock(param_1[2]);
pthread_join(*param_1,(void **)0x0);
}
else {
inline_mysql_mutex_unlock(param_1[2]);
}
inline_mysql_mutex_destroy(param_1[2]);
inline_mysql_cond_destroy(param_1[3]);
*(int1 *)((long)param_1 + 9) = 0;
return;
}
|
|
57,732
|
minja::VariableExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!context->contains(name)) {
return Value();
}
return context->at(name);
}
|
O3
|
cpp
|
minja::VariableExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r12
addq $0x20, %r14
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x47318
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x20(%rax)
movl %eax, %ebp
leaq 0x48(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x426e2
movq %r12, %rdi
callq 0x4f2d0
movq -0x8(%r12), %rdi
testq %rdi, %rdi
je 0x5eb4f
callq 0x348da
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x5eb5e
callq 0x348da
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5eb6d
callq 0x348da
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5eba3
movq 0x8441a(%rip), %rax # 0xe2f98
cmpb $0x0, (%rax)
je 0x5eb8e
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x5eb98
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x5eba3
movq (%rdi), %rax
callq *0x18(%rax)
testb %bpl, %bpl
je 0x5ec3a
movq (%r15), %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x47318
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x18(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x53ab2
leaq 0x48(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x426e2
movq %r14, %rdi
callq 0x4f2d0
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x5ebfb
callq 0x348da
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x5ec0a
callq 0x348da
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5ec19
callq 0x348da
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5ec8d
movq 0x8436e(%rip), %rax # 0xe2f98
cmpb $0x0, (%rax)
je 0x5ec78
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x5ec82
leaq 0x40(%rbx), %r14
movq $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movb $0x0, 0x40(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x426e2
movq %r14, %rdi
movl $0x1, %esi
callq 0x426e2
jmp 0x5ec8d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x5ec8d
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5eca1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x42656
movq %rbx, %rdi
callq 0x1ad30
|
_ZNK5minja12VariableExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov r12, [rdx]
add r14, 20h ; ' '
lea r13, [rsp+88h+var_80]
mov rdi, r13
mov rsi, r14
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rax, [r12]
mov rdi, r12
mov rsi, r13
call qword ptr [rax+20h]
mov ebp, eax
lea r12, [rsp+88h+var_40]
mov rdi, r12
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r12-8]
test rdi, rdi
jz short loc_5EB4F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5EB4F:
mov rdi, [rsp+88h+var_58]
test rdi, rdi
jz short loc_5EB5E
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5EB5E:
mov rdi, [rsp+88h+var_68]
test rdi, rdi
jz short loc_5EB6D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5EB6D:
mov rdi, [rsp+88h+var_78]
test rdi, rdi
jz short loc_5EBA3
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_5EB8E
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_5EB98
loc_5EB8E:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_5EB98:
cmp eax, 1
jnz short loc_5EBA3
mov rax, [rdi]
call qword ptr [rax+18h]
loc_5EBA3:
test bpl, bpl
jz loc_5EC3A
mov r15, [r15]
lea r12, [rsp+88h+var_80]
mov rdi, r12
mov rsi, r14
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rax, [r15]
mov rdi, r15
mov rsi, r12
call qword ptr [rax+18h]
mov rdi, rbx; this
mov rsi, rax; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
lea r14, [rsp+88h+var_40]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_5EBFB
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5EBFB:
mov rdi, [rsp+88h+var_58]
test rdi, rdi
jz short loc_5EC0A
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5EC0A:
mov rdi, [rsp+88h+var_68]
test rdi, rdi
jz short loc_5EC19
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5EC19:
mov rdi, [rsp+88h+var_78]
test rdi, rdi
jz short loc_5EC8D
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_5EC78
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_5EC82
loc_5EC3A:
lea r14, [rbx+40h]
mov qword ptr [rbx+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+30h], xmm0
mov byte ptr [rbx+40h], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_5EC8D
loc_5EC78:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_5EC82:
cmp eax, 1
jnz short loc_5EC8D
mov rax, [rdi]
call qword ptr [rax+18h]
loc_5EC8D:
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_5ECA1:
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
|
minja::Value * minja::VariableExpr::do_evaluate(minja::Value *this, long long a2, long long *a3)
{
long long v5; // r12
char v6; // bp
long long v7; // rdi
signed __int32 v8; // eax
long long v9; // r15
const minja::Value *v10; // rax
long long v11; // rdi
signed __int32 v12; // eax
__int128 v14; // [rsp+8h] [rbp-80h] BYREF
volatile signed __int32 *v15; // [rsp+20h] [rbp-68h]
volatile signed __int32 *v16; // [rsp+30h] [rbp-58h]
volatile signed __int32 *v17; // [rsp+40h] [rbp-48h]
void **v18[8]; // [rsp+48h] [rbp-40h] BYREF
v5 = *a3;
minja::Value::Value(&v14);
v6 = (*(long long ( **)(long long, __int128 *))(*(_QWORD *)v5 + 32LL))(v5, &v14);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v18);
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(v18);
if ( v17 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v17);
if ( v16 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v16);
if ( v15 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v15);
v7 = *((_QWORD *)&v14 + 1);
if ( *((_QWORD *)&v14 + 1) )
{
if ( _libc_single_threaded )
{
v8 = *(_DWORD *)(*((_QWORD *)&v14 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v14 + 1) + 12LL) = v8 - 1;
}
else
{
v8 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v14 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v8 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v7 + 24LL))(v7, 0LL);
}
if ( v6 )
{
v9 = *a3;
minja::Value::Value(&v14);
v10 = (const minja::Value *)(*(long long ( **)(long long, __int128 *))(*(_QWORD *)v9 + 24LL))(v9, &v14);
minja::Value::Value(this, v10);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v18);
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(v18);
if ( v17 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v17);
if ( v16 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v16);
if ( v15 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v15);
v11 = *((_QWORD *)&v14 + 1);
if ( *((_QWORD *)&v14 + 1) )
{
if ( _libc_single_threaded )
{
v12 = *(_DWORD *)(*((_QWORD *)&v14 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v14 + 1) + 12LL) = v12 - 1;
}
else
{
v12 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v14 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v12 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v11 + 24LL))(v11, 0LL);
}
}
else
{
*((_QWORD *)this + 9) = 0LL;
*(_OWORD *)this = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_BYTE *)this + 64) = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
}
return this;
}
|
do_evaluate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV R12,qword ptr [RDX]
ADD R14,0x20
LEA R13,[RSP + 0x8]
MOV RDI,R13
MOV RSI,R14
CALL 0x00147318
MOV RAX,qword ptr [R12]
LAB_0015eb1e:
MOV RDI,R12
MOV RSI,R13
CALL qword ptr [RAX + 0x20]
LAB_0015eb27:
MOV EBP,EAX
LEA R12,[RSP + 0x48]
MOV RDI,R12
XOR ESI,ESI
CALL 0x001426e2
MOV RDI,R12
CALL 0x0014f2d0
MOV RDI,qword ptr [R12 + -0x8]
TEST RDI,RDI
JZ 0x0015eb4f
CALL 0x001348da
LAB_0015eb4f:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x0015eb5e
CALL 0x001348da
LAB_0015eb5e:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x0015eb6d
CALL 0x001348da
LAB_0015eb6d:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0015eba3
MOV RAX,qword ptr [0x001e2f98]
CMP byte ptr [RAX],0x0
JZ 0x0015eb8e
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0015eb98
LAB_0015eb8e:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0015eb98:
CMP EAX,0x1
JNZ 0x0015eba3
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0015eba3:
TEST BPL,BPL
JZ 0x0015ec3a
MOV R15,qword ptr [R15]
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R14
CALL 0x00147318
MOV RAX,qword ptr [R15]
LAB_0015ebc2:
MOV RDI,R15
MOV RSI,R12
CALL qword ptr [RAX + 0x18]
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00153ab2
LAB_0015ebd6:
LEA R14,[RSP + 0x48]
MOV RDI,R14
XOR ESI,ESI
CALL 0x001426e2
MOV RDI,R14
CALL 0x0014f2d0
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x0015ebfb
CALL 0x001348da
LAB_0015ebfb:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x0015ec0a
CALL 0x001348da
LAB_0015ec0a:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x0015ec19
CALL 0x001348da
LAB_0015ec19:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0015ec8d
MOV RAX,qword ptr [0x001e2f98]
CMP byte ptr [RAX],0x0
JZ 0x0015ec78
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0015ec82
LAB_0015ec3a:
LEA R14,[RBX + 0x40]
MOV qword ptr [RBX + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV byte ptr [RBX + 0x40],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x001426e2
MOV RDI,R14
MOV ESI,0x1
CALL 0x001426e2
JMP 0x0015ec8d
LAB_0015ec78:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0015ec82:
CMP EAX,0x1
JNZ 0x0015ec8d
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0015ec8d:
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::VariableExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
shared_ptr * minja::VariableExpr::do_evaluate(shared_ptr *param_1)
{
int *piVar1;
long *plVar2;
char cVar3;
int iVar4;
Value *pVVar5;
int8 *in_RDX;
long in_RSI;
bool bVar6;
Value local_80 [8];
long *local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
data local_40 [16];
plVar2 = (long *)*in_RDX;
Value::Value(local_80,(string *)(in_RSI + 0x20));
/* try { // try from 0015eb1e to 0015eb26 has its CatchHandler @ 0015eca1 */
cVar3 = (**(code **)(*plVar2 + 0x20))(plVar2,local_80);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_001e2f98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar4 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar4 + -1;
}
if (iVar4 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
if (cVar3 == '\0') {
bVar6 = (bool)((char)param_1 + '@');
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x38) = 0;
param_1[0x40] = (shared_ptr)0x0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
}
else {
plVar2 = (long *)*in_RDX;
Value::Value(local_80,(string *)(in_RSI + 0x20));
/* try { // try from 0015ebc2 to 0015ebd5 has its CatchHandler @ 0015ec9f */
pVVar5 = (Value *)(**(code **)(*plVar2 + 0x18))(plVar2,local_80);
Value::Value((Value *)param_1,pVVar5);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_001e2f98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar4 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar4 + -1;
}
if (iVar4 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
}
return param_1;
}
|
|
57,733
|
my_hash_sort_simple_nopad
|
eloqsql/strings/ctype-simple.c
|
void my_hash_sort_simple_nopad(CHARSET_INFO *cs,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
register const uchar *sort_order=cs->sort_order;
const uchar *end= key + len;
register ulong m1= *nr1, m2= *nr2;
for (; key < (uchar*) end ; key++)
{
MY_HASH_ADD(m1, m2, (uint) sort_order[(uint) *key]);
}
*nr1= m1;
*nr2= m2;
}
|
O0
|
c
|
my_hash_sort_simple_nopad:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x4c8e4
jmp 0x4c892
movq -0x40(%rbp), %rax
andq $0x3f, %rax
addq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdx
movzbl (%rdx), %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x40(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x48(%rbp)
jmp 0x4c8d6
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4c886
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
|
my_hash_sort_simple_nopad:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_8]
mov rax, [rax+58h]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_40], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_48], rax
loc_4C886:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_38]
jnb short loc_4C8E4
jmp short $+2
loc_4C892:
mov rax, [rbp+var_40]
and rax, 3Fh
add rax, [rbp+var_48]
mov rcx, [rbp+var_30]
mov rdx, [rbp+var_10]
movzx edx, byte ptr [rdx]
mov edx, edx
movzx ecx, byte ptr [rcx+rdx]
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_40]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_40]
mov [rbp+var_40], rax
mov rax, [rbp+var_48]
add rax, 3
mov [rbp+var_48], rax
jmp short $+2
loc_4C8D6:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_4C886
loc_4C8E4:
mov rcx, [rbp+var_40]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_48]
mov rax, [rbp+var_28]
mov [rax], rcx
pop rbp
retn
|
_QWORD * my_hash_sort_simple_nopad(long long a1, unsigned __int8 *a2, long long a3, long long *a4, _QWORD *a5)
{
_QWORD *result; // rax
long long v6; // [rsp+0h] [rbp-48h]
long long v7; // [rsp+8h] [rbp-40h]
unsigned __int8 *v8; // [rsp+38h] [rbp-10h]
v8 = a2;
v7 = *a4;
v6 = *a5;
while ( v8 < &a2[a3] )
{
v7 ^= (v7 << 8) + *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v8) * (v6 + (v7 & 0x3F));
v6 += 3LL;
++v8;
}
*a4 = v7;
result = a5;
*a5 = v6;
return result;
}
|
my_hash_sort_simple_nopad:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
LAB_0014c886:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x0014c8e4
JMP 0x0014c892
LAB_0014c892:
MOV RAX,qword ptr [RBP + -0x40]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x10]
MOVZX EDX,byte ptr [RDX]
MOV EDX,EDX
MOVZX ECX,byte ptr [RCX + RDX*0x1]
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x40]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x3
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0014c8d6
LAB_0014c8d6:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0014c886
LAB_0014c8e4:
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
POP RBP
RET
|
void my_hash_sort_simple_nopad(long param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
long local_50;
ulong local_48;
byte *local_18;
local_48 = *param_4;
local_50 = *param_5;
for (local_18 = param_2; local_18 < param_2 + param_3; local_18 = local_18 + 1) {
local_48 = ((local_48 & 0x3f) + local_50) *
(ulong)*(byte *)(*(long *)(param_1 + 0x58) + (ulong)*local_18) + local_48 * 0x100 ^
local_48;
local_50 = local_50 + 3;
}
*param_4 = local_48;
*param_5 = local_50;
return;
}
|
|
57,734
|
my_hash_sort_simple_nopad
|
eloqsql/strings/ctype-simple.c
|
void my_hash_sort_simple_nopad(CHARSET_INFO *cs,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
register const uchar *sort_order=cs->sort_order;
const uchar *end= key + len;
register ulong m1= *nr1, m2= *nr2;
for (; key < (uchar*) end ; key++)
{
MY_HASH_ADD(m1, m2, (uint) sort_order[(uint) *key]);
}
*nr1= m1;
*nr2= m2;
}
|
O3
|
c
|
my_hash_sort_simple_nopad:
movq (%rcx), %rax
movq (%r8), %r9
testq %rdx, %rdx
jle 0x3d528
pushq %rbp
movq %rsp, %rbp
movq 0x58(%rdi), %rdi
addq %rsi, %rdx
movl %eax, %r10d
andl $0x3f, %r10d
addq %r9, %r10
movzbl (%rsi), %r11d
movzbl (%rdi,%r11), %r11d
imulq %r10, %r11
movq %rax, %r10
shlq $0x8, %r10
addq %r11, %r10
xorq %r10, %rax
addq $0x3, %r9
incq %rsi
cmpq %rdx, %rsi
jb 0x3d4f7
popq %rbp
movq %rax, (%rcx)
movq %r9, (%r8)
retq
|
my_hash_sort_simple_nopad:
mov rax, [rcx]
mov r9, [r8]
test rdx, rdx
jle short loc_3D528
push rbp
mov rbp, rsp
mov rdi, [rdi+58h]
add rdx, rsi
loc_3D4F7:
mov r10d, eax
and r10d, 3Fh
add r10, r9
movzx r11d, byte ptr [rsi]
movzx r11d, byte ptr [rdi+r11]
imul r11, r10
mov r10, rax
shl r10, 8
add r10, r11
xor rax, r10
add r9, 3
inc rsi
cmp rsi, rdx
jb short loc_3D4F7
pop rbp
loc_3D528:
mov [rcx], rax
mov [r8], r9
retn
|
long long my_hash_sort_simple_nopad(long long a1, unsigned __int8 *a2, long long a3, long long *a4, long long *a5)
{
long long result; // rax
long long v6; // r9
long long v7; // rdi
unsigned __int8 *v8; // rdx
result = *a4;
v6 = *a5;
if ( a3 > 0 )
{
v7 = *(_QWORD *)(a1 + 88);
v8 = &a2[a3];
do
{
result ^= (v6 + (result & 0x3F)) * *(unsigned __int8 *)(v7 + *a2) + (result << 8);
v6 += 3LL;
++a2;
}
while ( a2 < v8 );
}
*a4 = result;
*a5 = v6;
return result;
}
|
my_hash_sort_simple_nopad:
MOV RAX,qword ptr [RCX]
MOV R9,qword ptr [R8]
TEST RDX,RDX
JLE 0x0013d528
PUSH RBP
MOV RBP,RSP
MOV RDI,qword ptr [RDI + 0x58]
ADD RDX,RSI
LAB_0013d4f7:
MOV R10D,EAX
AND R10D,0x3f
ADD R10,R9
MOVZX R11D,byte ptr [RSI]
MOVZX R11D,byte ptr [RDI + R11*0x1]
IMUL R11,R10
MOV R10,RAX
SHL R10,0x8
ADD R10,R11
XOR RAX,R10
ADD R9,0x3
INC RSI
CMP RSI,RDX
JC 0x0013d4f7
POP RBP
LAB_0013d528:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],R9
RET
|
void my_hash_sort_simple_nopad(long param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
ulong uVar1;
byte *pbVar2;
long lVar3;
uVar1 = *param_4;
lVar3 = *param_5;
if (0 < param_3) {
pbVar2 = param_2 + param_3;
do {
uVar1 = uVar1 ^ uVar1 * 0x100 +
(ulong)*(byte *)(*(long *)(param_1 + 0x58) + (ulong)*param_2) *
((ulong)((uint)uVar1 & 0x3f) + lVar3);
lVar3 = lVar3 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar2);
}
*param_4 = uVar1;
*param_5 = lVar3;
return;
}
|
|
57,735
|
resolve_charset
|
eloqsql/mysys/charset.c
|
my_bool resolve_charset(const char *cs_name,
CHARSET_INFO *default_cs,
CHARSET_INFO **cs,
myf flags)
{
*cs= get_charset_by_csname(cs_name, MY_CS_PRIMARY, flags);
if (*cs == NULL)
{
*cs= default_cs;
return TRUE;
}
return FALSE;
}
|
O3
|
c
|
resolve_charset:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
leaq -0xc8(%rbp), %rdi
movb $0x0, (%rdi)
leaq -0x12f0(%rip), %rax # 0x91d7a
movq %rax, 0x80(%rdi)
leaq -0x12ef(%rip), %rax # 0x91d89
movq %rax, 0x88(%rdi)
leaq -0x12e2(%rip), %rax # 0x91da4
movq %rax, 0x90(%rdi)
leaq 0xceea(%rip), %rax # 0x9ff7e
movq %rax, 0x98(%rdi)
leaq 0x2f264e(%rip), %rax # 0x3856f0
movq (%rax), %rax
movq %rax, 0xa0(%rdi)
leaq -0x12f1(%rip), %rax # 0x91dc2
movq %rax, 0xa8(%rdi)
movl $0x20, %edx
callq 0x92ebc
movq %rax, %rcx
testq %rax, %rax
sete %al
cmovneq %rcx, %r14
movq %r14, (%rbx)
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x930ef
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x29250
|
resolve_charset:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 0C0h
mov rbx, rdx
mov r14, rsi
mov rsi, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
lea rdi, [rbp+var_C8]
mov byte ptr [rdi], 0
lea rax, my_once_alloc_c
mov [rdi+80h], rax
lea rax, my_malloc_c
mov [rdi+88h], rax
lea rax, my_realloc_c
mov [rdi+90h], rax
lea rax, my_free
mov [rdi+98h], rax
lea rax, my_charset_error_reporter
mov rax, [rax]
mov [rdi+0A0h], rax
lea rax, add_collation
mov [rdi+0A8h], rax
mov edx, 20h ; ' '
call my_charset_get_by_name
mov rcx, rax
test rax, rax
setz al
cmovnz r14, rcx
mov [rbx], r14
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_930EF
add rsp, 0C0h
pop rbx
pop r14
pop rbp
retn
loc_930EF:
call ___stack_chk_fail
|
bool resolve_charset(long long a1, long long a2, long long *a3, long long a4)
{
long long v6; // rcx
bool result; // al
char v8[128]; // [rsp+8h] [rbp-C8h] BYREF
long long ( *v9)(long long); // [rsp+88h] [rbp-48h]
long long ( *v10)(long long); // [rsp+90h] [rbp-40h]
long long ( *v11)(long long, long long, long long, long long, long long, long long); // [rsp+98h] [rbp-38h]
long long ( *v12)(_QWORD); // [rsp+A0h] [rbp-30h]
long long ( *v13)(); // [rsp+A8h] [rbp-28h]
long long ( *v14)(unsigned int *); // [rsp+B0h] [rbp-20h]
unsigned long long v15; // [rsp+B8h] [rbp-18h]
v15 = __readfsqword(0x28u);
v8[0] = 0;
v9 = my_once_alloc_c;
v10 = my_malloc_c;
v11 = my_realloc_c;
v12 = my_free;
v13 = my_charset_error_reporter;
v14 = add_collation;
v6 = my_charset_get_by_name((long long)v8, a1, 0x20u, a4);
result = v6 == 0;
if ( v6 )
a2 = v6;
*a3 = a2;
return result;
}
|
resolve_charset:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0xc0
MOV RBX,RDX
MOV R14,RSI
MOV RSI,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
LEA RDI,[RBP + -0xc8]
MOV byte ptr [RDI],0x0
LEA RAX,[0x191d7a]
MOV qword ptr [RDI + 0x80],RAX
LEA RAX,[0x191d89]
MOV qword ptr [RDI + 0x88],RAX
LEA RAX,[0x191da4]
MOV qword ptr [RDI + 0x90],RAX
LEA RAX,[0x19ff7e]
MOV qword ptr [RDI + 0x98],RAX
LEA RAX,[0x4856f0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDI + 0xa0],RAX
LEA RAX,[0x191dc2]
MOV qword ptr [RDI + 0xa8],RAX
MOV EDX,0x20
CALL 0x00192ebc
MOV RCX,RAX
TEST RAX,RAX
SETZ AL
CMOVNZ R14,RCX
MOV qword ptr [RBX],R14
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x001930ef
ADD RSP,0xc0
POP RBX
POP R14
POP RBP
RET
LAB_001930ef:
CALL 0x00129250
|
bool resolve_charset(int8 param_1,long param_2,long *param_3)
{
long lVar1;
long in_FS_OFFSET;
int1 local_d0 [128];
code *local_50;
code *local_48;
code *local_40;
code *local_38;
int *local_30;
code *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_d0[0] = 0;
local_50 = my_once_alloc_c;
local_48 = my_malloc_c;
local_40 = my_realloc_c;
local_38 = my_free;
local_30 = my_charset_error_reporter;
local_28 = add_collation;
lVar1 = my_charset_get_by_name(local_d0,param_1,0x20);
if (lVar1 != 0) {
param_2 = lVar1;
}
*param_3 = param_2;
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return lVar1 == 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
57,736
|
fmt::v10::detail::umul128(unsigned long, unsigned long)
|
AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback {
#if FMT_USE_INT128
auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
#elif defined(_MSC_VER) && defined(_M_X64)
auto hi = uint64_t();
auto lo = _umul128(x, y, &hi);
return {hi, lo};
#else
const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
uint64_t a = x >> 32;
uint64_t b = x & mask;
uint64_t c = y >> 32;
uint64_t d = y & mask;
uint64_t ac = a * c;
uint64_t bc = b * c;
uint64_t ad = a * d;
uint64_t bd = b * d;
uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
(intermediate << 32) + (bd & mask)};
#endif
}
|
O0
|
c
|
fmt::v10::detail::umul128(unsigned long, unsigned long):
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
mulq %rcx
movq %rdx, 0x8(%rsp)
movq %rax, (%rsp)
movq (%rsp), %rdx
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x8c190
jmp 0x8c109
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x1b6b0
|
_ZN3fmt3v106detail7umul128Emm:
sub rsp, 38h
mov [rsp+38h+var_18], rdi
mov [rsp+38h+var_20], rsi
mov rax, [rsp+38h+var_18]
mov rcx, [rsp+38h+var_20]
mul rcx
mov [rsp+38h+var_30], rdx
mov [rsp+38h+var_38], rax
mov rdx, [rsp+38h+var_38]; unsigned __int64
mov rsi, [rsp+38h+var_30]; unsigned __int64
lea rdi, [rsp+38h+var_10]; this
call _ZN3fmt3v106detail16uint128_fallbackC2Emm; fmt::v10::detail::uint128_fallback::uint128_fallback(ulong,ulong)
jmp short $+2
loc_8C109:
mov rax, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_8]
add rsp, 38h
retn
mov rdi, rax
call __clang_call_terminate
|
long long fmt::v10::detail::umul128(unsigned long long this, unsigned long long a2)
{
long long v3; // [rsp+28h] [rbp-10h] BYREF
fmt::v10::detail::uint128_fallback::uint128_fallback(
(fmt::v10::detail::uint128_fallback *)&v3,
(a2 * (unsigned __int128)this) >> 64,
a2 * this);
return v3;
}
|
umul128:
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x18]
MUL RCX
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP],RAX
MOV RDX,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
LAB_0018c0fd:
LEA RDI,[RSP + 0x28]
CALL 0x0018c190
JMP 0x0018c109
LAB_0018c109:
MOV RAX,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
/* fmt::v10::detail::umul128(unsigned long, unsigned long) */
int1 [16] fmt::v10::detail::umul128(ulong param_1,ulong param_2)
{
int1 auVar1 [16];
int1 auVar2 [16];
int1 auVar3 [16];
ulong local_38;
ulong local_30;
uint128_fallback local_10 [16];
auVar1._8_8_ = 0;
auVar1._0_8_ = param_1;
auVar2._8_8_ = 0;
auVar2._0_8_ = param_2;
local_38 = SUB168(auVar1 * auVar2,0);
local_30 = SUB168(auVar1 * auVar2,8);
/* try { // try from 0018c0fd to 0018c106 has its CatchHandler @ 0018c118 */
uint128_fallback::uint128_fallback(local_10,local_30,local_38);
auVar3[0] = local_10[0];
auVar3[1] = local_10[1];
auVar3[2] = local_10[2];
auVar3[3] = local_10[3];
auVar3[4] = local_10[4];
auVar3[5] = local_10[5];
auVar3[6] = local_10[6];
auVar3[7] = local_10[7];
auVar3[8] = local_10[8];
auVar3[9] = local_10[9];
auVar3[10] = local_10[10];
auVar3[0xb] = local_10[0xb];
auVar3[0xc] = local_10[0xc];
auVar3[0xd] = local_10[0xd];
auVar3[0xe] = local_10[0xe];
auVar3[0xf] = local_10[0xf];
return auVar3;
}
|
|
57,737
|
my_tosort_utf16
|
eloqsql/strings/ctype-ucs2.c
|
static inline void
my_tosort_utf16(MY_UNICASE_INFO *uni_plane, my_wc_t *wc)
{
if (*wc <= uni_plane->maxchar)
{
MY_UNICASE_CHARACTER *page;
if ((page= uni_plane->page[*wc >> 8]))
*wc= page[*wc & 0xFF].sort;
}
else
{
*wc= MY_CS_REPLACEMENT_CHARACTER;
}
}
|
O0
|
c
|
my_tosort_utf16:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
ja 0xf2bf4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x8, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xf2bf2
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
andq $0xff, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xf2bff
movq -0x10(%rbp), %rax
movq $0xfffd, (%rax) # imm = 0xFFFD
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_tosort_utf16:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_8]
cmp rax, [rcx]
ja short loc_F2BF4
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
shr rcx, 8
mov rax, [rax+rcx*8]
mov [rbp+var_18], rax
cmp rax, 0
jz short loc_F2BF2
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
and rcx, 0FFh
imul rcx, 0Ch
add rax, rcx
mov eax, [rax+8]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], rcx
loc_F2BF2:
jmp short loc_F2BFF
loc_F2BF4:
mov rax, [rbp+var_10]
mov qword ptr [rax], 0FFFDh
loc_F2BFF:
pop rbp
retn
|
_QWORD * my_tosort_utf16(_QWORD *a1, _QWORD *a2)
{
_QWORD *result; // rax
_QWORD *v3; // [rsp+0h] [rbp-18h]
if ( *a2 > *a1 )
{
result = a2;
*a2 = 65533LL;
}
else
{
result = *(_QWORD **)(a1[1] + 8LL * (*a2 >> 8));
v3 = result;
if ( result )
{
result = a2;
*a2 = *((unsigned int *)v3 + 3 * (unsigned __int8)*a2 + 2);
}
}
return result;
}
|
my_tosort_utf16:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX]
JA 0x001f2bf4
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
SHR RCX,0x8
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JZ 0x001f2bf2
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
AND RCX,0xff
IMUL RCX,RCX,0xc
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
LAB_001f2bf2:
JMP 0x001f2bff
LAB_001f2bf4:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],0xfffd
LAB_001f2bff:
POP RBP
RET
|
void my_tosort_utf16(ulong *param_1,ulong *param_2)
{
long lVar1;
if (*param_1 < *param_2) {
*param_2 = 0xfffd;
}
else {
lVar1 = *(long *)(param_1[1] + (*param_2 >> 8) * 8);
if (lVar1 != 0) {
*param_2 = (ulong)*(uint *)(lVar1 + (*param_2 & 0xff) * 0xc + 8);
}
}
return;
}
|
|
57,738
|
void ImPlot::PlotShaded<signed char>(char const*, signed char const*, int, double, double, double, int, int, int)
|
zkingston[P]unknot/build_O1/_deps/implot-src/implot_items.cpp
|
void PlotShaded(const char* label_id, const T* values, int count, double y_ref, double xscale, double x0, ImPlotShadedFlags flags, int offset, int stride) {
if (!(y_ref > -DBL_MAX))
y_ref = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO).Y.Min;
if (!(y_ref < DBL_MAX))
y_ref = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO).Y.Max;
GetterXY<IndexerLin,IndexerIdx<T>> getter1(IndexerLin(xscale,x0),IndexerIdx<T>(values,count,offset,stride),count);
GetterXY<IndexerLin,IndexerConst> getter2(IndexerLin(xscale,x0),IndexerConst(y_ref),count);
PlotShadedEx(label_id, getter1, getter2, flags);
}
|
O1
|
cpp
|
void ImPlot::PlotShaded<signed char>(char const*, signed char const*, int, double, double, double, int, int, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %ebp
movl %r8d, %r13d
movl %ecx, 0x4(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
ucomisd 0x1c523f(%rip), %xmm0 # 0x29a3e0
ja 0xd51bf
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0xc068d
movsd 0x10(%rbx), %xmm0
movsd 0x1c5221(%rip), %xmm1 # 0x29a3e8
ucomisd %xmm0, %xmm1
ja 0xd51e9
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0xc068d
movsd 0x18(%rbx), %xmm0
testl %r15d, %r15d
je 0xd51ff
movl %r13d, %eax
cltd
idivl %r15d
leal (%rdx,%r15), %eax
cltd
idivl %r15d
jmp 0xd5201
xorl %edx, %edx
leaq 0x18(%rsp), %rsi
movsd 0x8(%rsp), %xmm2
movsd %xmm2, (%rsi)
movsd 0x10(%rsp), %xmm1
movsd %xmm1, 0x8(%rsi)
movq %r12, 0x10(%rsi)
movl %r15d, 0x18(%rsi)
movl %edx, 0x1c(%rsi)
movl %ebp, 0x20(%rsi)
movl %r15d, 0x28(%rsi)
leaq 0x48(%rsp), %rdx
movsd %xmm2, (%rdx)
movsd %xmm1, 0x8(%rdx)
movsd %xmm0, 0x10(%rdx)
movl %r15d, 0x18(%rdx)
movq %r14, %rdi
movl 0x4(%rsp), %ecx
callq 0xd525f
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN6ImPlot10PlotShadedIfEEvPKcPKT_idddiii:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov ebp, r9d
mov r13d, r8d
mov [rsp+98h+var_94], ecx
movsd [rsp+98h+var_88], xmm2
movsd [rsp+98h+var_90], xmm1
mov r15d, edx
mov r12, rsi
mov r14, rdi
ucomisd xmm0, cs:qword_29A3E0
ja short loc_D51BF
lea rbx, [rsp+98h+var_80]
mov rdi, rbx; this
mov esi, 0FFFFFFFFh; int
mov edx, 0FFFFFFFFh; int
call _ZN6ImPlot13GetPlotLimitsEii; ImPlot::GetPlotLimits(int,int)
movsd xmm0, qword ptr [rbx+10h]
loc_D51BF:
movsd xmm1, cs:qword_29A3E8
ucomisd xmm1, xmm0
ja short loc_D51E9
lea rbx, [rsp+98h+var_80]
mov rdi, rbx; this
mov esi, 0FFFFFFFFh; int
mov edx, 0FFFFFFFFh; int
call _ZN6ImPlot13GetPlotLimitsEii; ImPlot::GetPlotLimits(int,int)
movsd xmm0, qword ptr [rbx+18h]
loc_D51E9:
test r15d, r15d
jz short loc_D51FF
mov eax, r13d
cdq
idiv r15d
lea eax, [rdx+r15]
cdq
idiv r15d
jmp short loc_D5201
loc_D51FF:
xor edx, edx
loc_D5201:
lea rsi, [rsp+98h+var_80]
movsd xmm2, [rsp+98h+var_90]
movsd qword ptr [rsi], xmm2
movsd xmm1, [rsp+98h+var_88]
movsd qword ptr [rsi+8], xmm1
mov [rsi+10h], r12
mov [rsi+18h], r15d
mov [rsi+1Ch], edx
mov [rsi+20h], ebp
mov [rsi+28h], r15d
lea rdx, [rsp+98h+var_50]
movsd qword ptr [rdx], xmm2
movsd qword ptr [rdx+8], xmm1
movsd qword ptr [rdx+10h], xmm0
mov [rdx+18h], r15d
mov rdi, r14
mov ecx, [rsp+98h+var_94]
call _ZN6ImPlot12PlotShadedExINS_8GetterXYINS_10IndexerLinENS_10IndexerIdxIfEEEENS1_IS2_NS_12IndexerConstEEEEEvPKcRKT_RKT0_i; ImPlot::PlotShadedEx<ImPlot::GetterXY<ImPlot::IndexerLin,ImPlot::IndexerIdx<float>>,ImPlot::GetterXY<ImPlot::IndexerLin,ImPlot::IndexerConst>>(char const*,ImPlot::GetterXY<ImPlot::IndexerLin,ImPlot::IndexerIdx<float>> const&,ImPlot::GetterXY<ImPlot::IndexerLin,ImPlot::IndexerConst> const&,int)
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ImPlot::PlotShaded<float>(
long long a1,
long long a2,
signed int a3,
unsigned int a4,
int a5,
int a6,
double a7,
double a8,
double a9)
{
int v12; // edx
double v15[2]; // [rsp+18h] [rbp-80h] BYREF
double v16; // [rsp+28h] [rbp-70h]
double v17; // [rsp+30h] [rbp-68h]
int v18; // [rsp+38h] [rbp-60h]
int v19; // [rsp+40h] [rbp-58h]
double v20[3]; // [rsp+48h] [rbp-50h] BYREF
int v21; // [rsp+60h] [rbp-38h]
if ( a7 <= -1.797693134862316e308 )
{
ImPlot::GetPlotLimits((ImPlot *)v15, (const char *)0xFFFFFFFFLL, -1);
a7 = v16;
}
if ( a7 >= 1.797693134862316e308 )
{
ImPlot::GetPlotLimits((ImPlot *)v15, (const char *)0xFFFFFFFFLL, -1);
a7 = v17;
}
if ( a3 )
v12 = (a5 % a3 + a3) % a3;
else
v12 = 0;
v15[0] = a8;
v15[1] = a9;
v16 = *(double *)&a2;
v17 = COERCE_DOUBLE(__PAIR64__(v12, a3));
v18 = a6;
v19 = a3;
v20[0] = a8;
v20[1] = a9;
v20[2] = a7;
v21 = a3;
return ImPlot::PlotShadedEx<ImPlot::GetterXY<ImPlot::IndexerLin,ImPlot::IndexerIdx<float>>,ImPlot::GetterXY<ImPlot::IndexerLin,ImPlot::IndexerConst>>(
a1,
v15,
v20,
a4);
}
|
PlotShaded<float>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV EBP,R9D
MOV R13D,R8D
MOV dword ptr [RSP + 0x4],ECX
MOVSD qword ptr [RSP + 0x10],XMM2
MOVSD qword ptr [RSP + 0x8],XMM1
MOV R15D,EDX
MOV R12,RSI
MOV R14,RDI
UCOMISD XMM0,qword ptr [0x0039a3e0]
JA 0x001d51bf
LEA RBX,[RSP + 0x18]
MOV RDI,RBX
MOV ESI,0xffffffff
MOV EDX,0xffffffff
CALL 0x001c068d
MOVSD XMM0,qword ptr [RBX + 0x10]
LAB_001d51bf:
MOVSD XMM1,qword ptr [0x0039a3e8]
UCOMISD XMM1,XMM0
JA 0x001d51e9
LEA RBX,[RSP + 0x18]
MOV RDI,RBX
MOV ESI,0xffffffff
MOV EDX,0xffffffff
CALL 0x001c068d
MOVSD XMM0,qword ptr [RBX + 0x18]
LAB_001d51e9:
TEST R15D,R15D
JZ 0x001d51ff
MOV EAX,R13D
CDQ
IDIV R15D
LEA EAX,[RDX + R15*0x1]
CDQ
IDIV R15D
JMP 0x001d5201
LAB_001d51ff:
XOR EDX,EDX
LAB_001d5201:
LEA RSI,[RSP + 0x18]
MOVSD XMM2,qword ptr [RSP + 0x8]
MOVSD qword ptr [RSI],XMM2
MOVSD XMM1,qword ptr [RSP + 0x10]
MOVSD qword ptr [RSI + 0x8],XMM1
MOV qword ptr [RSI + 0x10],R12
MOV dword ptr [RSI + 0x18],R15D
MOV dword ptr [RSI + 0x1c],EDX
MOV dword ptr [RSI + 0x20],EBP
MOV dword ptr [RSI + 0x28],R15D
LEA RDX,[RSP + 0x48]
MOVSD qword ptr [RDX],XMM2
MOVSD qword ptr [RDX + 0x8],XMM1
MOVSD qword ptr [RDX + 0x10],XMM0
MOV dword ptr [RDX + 0x18],R15D
MOV RDI,R14
MOV ECX,dword ptr [RSP + 0x4]
CALL 0x001d525f
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* void ImPlot::PlotShaded<float>(char const*, float const*, int, double, double, double, int, int,
int) */
void ImPlot::PlotShaded<float>
(char *param_1,float *param_2,int param_3,double param_4,double param_5,
double param_6,int param_7,int param_8,int param_9)
{
double local_80;
double local_78;
float *local_70;
int local_68;
int iStack_64;
int local_60;
int local_58;
double local_50;
double local_48;
double local_40;
int local_38;
if (param_4 <= DAT_0039a3e0) {
GetPlotLimits((ImPlot *)&local_80,-1,-1);
param_4 = (double)local_70;
}
if (DAT_0039a3e8 <= param_4) {
GetPlotLimits((ImPlot *)&local_80,-1,-1);
param_4 = (double)CONCAT44(iStack_64,local_68);
}
if (param_3 == 0) {
iStack_64 = 0;
}
else {
iStack_64 = (param_8 % param_3 + param_3) % param_3;
}
local_80 = param_5;
local_78 = param_6;
local_70 = param_2;
local_68 = param_3;
local_60 = param_9;
local_58 = param_3;
local_50 = param_5;
local_48 = param_6;
local_40 = param_4;
local_38 = param_3;
PlotShadedEx<ImPlot::GetterXY<ImPlot::IndexerLin,ImPlot::IndexerIdx<float>>,ImPlot::GetterXY<ImPlot::IndexerLin,ImPlot::IndexerConst>>
(param_1,(GetterXY *)&local_80,(GetterXY *)&local_50,param_7);
return;
}
|
|
57,739
|
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>::insert(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&)
|
monkey531[P]llama/common/json.hpp
|
iterator insert(const_iterator pos, const basic_json& val)
{
// insert only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
// check if iterator pos fits to this JSON value
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
// insert to array and return iterator
return insert_iterator(pos, val);
}
JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::insert(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
cmpb $0x2, (%rsi)
jne 0xac982
movq (%rdx), %rsi
cmpq %r14, %rsi
jne 0xac9de
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
movups 0x8(%rdx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x18(%rdx), %rdx
movq %rdx, 0x18(%rax)
movq %r14, %rsi
movq %rax, %rdx
callq 0xaca84
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1b460
movq %rax, %rbx
movq %r14, %rdi
callq 0x5f83e
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x47742(%rip), %rsi # 0xf40e8
movq %rsp, %rdi
callq 0xacb1f
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x135, %esi # imm = 0x135
movq %r14, %rcx
callq 0x5f5e6
xorl %ebp, %ebp
leaq 0x8054b(%rip), %rsi # 0x12cf18
leaq -0x51054(%rip), %rdx # 0x5b980
movq %rbx, %rdi
callq 0x1bf40
jmp 0xaca38
movl $0x20, %edi
callq 0x1b460
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x43725(%rip), %rsi # 0xf0120
leaq 0x43741(%rip), %rdx # 0xf0143
movq %rsp, %rdi
callq 0x23388
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0xca, %esi
movq %r14, %rcx
callq 0x5f37e
xorl %ebp, %ebp
leaq 0x804af(%rip), %rsi # 0x12ced8
leaq -0x510b0(%rip), %rdx # 0x5b980
movq %rbx, %rdi
callq 0x1bf40
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0xaca59
jmp 0xaca6e
jmp 0xaca68
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaca6e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b900
jmp 0xaca6e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xaca7b
movq %rbx, %rdi
callq 0x1b690
movq %r14, %rdi
callq 0x1bfd0
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6insertENS0_6detail9iter_implIKSD_EERSG_:
push rbp; char
push r15; int
push r14; int
push rbx; int
sub rsp, 48h
mov r14, rsi
cmp byte ptr [rsi], 2
jnz short loc_AC982
mov rsi, [rdx]
cmp rsi, r14
jnz loc_AC9DE
mov rbx, rdi
lea rax, [rsp+68h+var_40]
mov [rax], rsi
movups xmm0, xmmword ptr [rdx+8]
movups xmmword ptr [rax+8], xmm0
mov rdx, [rdx+18h]
mov [rax+18h], rdx
mov rsi, r14
mov rdx, rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE15insert_iteratorIJRKSD_EEENS0_6detail9iter_implISD_EENSI_ISF_EEDpOT_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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&>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, rbx
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_AC982:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+68h+var_48]
mov [rdx], rax
lea rsi, aCannotUseInser; "cannot use insert() with "
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA26_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(char const(&)[26],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 135h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_ACA38
loc_AC9DE:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+68h+var_58]
mov [r15-10h], r15
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdx, aIteratorDoesNo+23h; ""
mov rdi, rsp
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 bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 0CAh; int
mov rcx, r14
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_ACA38:
mov r14, rax
mov rdi, [rsp+68h+var_68]
cmp rdi, r15
jnz short loc_ACA59
jmp short loc_ACA6E
jmp short loc_ACA68
mov r14, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_ACA6E
loc_ACA59:
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_ACA6E
loc_ACA68:
mov r14, rax
mov bpl, 1
loc_ACA6E:
test bpl, bpl
jz short loc_ACA7B
mov rdi, rbx; void *
call ___cxa_free_exception
loc_ACA7B:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::insert(
long long a1,
unsigned __int8 *a2,
long long a3)
{
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v5; // rbx
_QWORD v6[2]; // [rsp+0h] [rbp-68h] BYREF
_QWORD v7[3]; // [rsp+10h] [rbp-58h] BYREF
unsigned __int8 *v8; // [rsp+28h] [rbp-40h] BYREF
__int128 v9; // [rsp+30h] [rbp-38h]
long long v10; // [rsp+40h] [rbp-28h]
if ( *a2 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v7[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>::type_name(a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(
v6,
"cannot use insert() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
309,
v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if ( *(unsigned __int8 **)a3 != a2 )
{
v5 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v6[0] = v7;
std::string::_M_construct<char const*>(v6, "iterator does not fit current value", (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_(
v5,
202,
v6);
__cxa_throw(
v5,
(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);
}
v8 = *(unsigned __int8 **)a3;
v9 = *(_OWORD *)(a3 + 8);
v10 = *(_QWORD *)(a3 + 24);
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>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&>(
a1,
a2,
&v8);
return a1;
}
|
insert:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
CMP byte ptr [RSI],0x2
JNZ 0x001ac982
MOV RSI,qword ptr [RDX]
CMP RSI,R14
JNZ 0x001ac9de
MOV RBX,RDI
LEA RAX,[RSP + 0x28]
MOV qword ptr [RAX],RSI
MOVUPS XMM0,xmmword ptr [RDX + 0x8]
MOVUPS xmmword ptr [RAX + 0x8],XMM0
MOV RDX,qword ptr [RDX + 0x18]
MOV qword ptr [RAX + 0x18],RDX
MOV RSI,R14
MOV RDX,RAX
CALL 0x001aca84
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001ac982:
MOV EDI,0x20
CALL 0x0011b460
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015f83e
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_001ac99f:
LEA RSI,[0x1f40e8]
MOV RDI,RSP
CALL 0x001acb1f
MOV BPL,0x1
LAB_001ac9b1:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x135
MOV RCX,R14
CALL 0x0015f5e6
XOR EBP,EBP
LEA RSI,[0x22cf18]
LEA RDX,[0x15b980]
MOV RDI,RBX
CALL 0x0011bf40
LAB_001ac9de:
MOV EDI,0x20
CALL 0x0011b460
MOV RBX,RAX
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
LAB_001ac9f4:
LEA RSI,[0x1f0120]
LEA RDX,[0x1f0143]
MOV RDI,RSP
CALL 0x00123388
MOV BPL,0x1
LAB_001aca0d:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0xca
MOV RCX,R14
CALL 0x0015f37e
XOR EBP,EBP
LEA RSI,[0x22ced8]
LEA RDX,[0x15b980]
MOV RDI,RBX
CALL 0x0011bf40
|
/* 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>::insert(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
* __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::insert(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_2,long *param_3)
{
int8 uVar1;
int1 *local_68 [2];
int1 local_58 [16];
char *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>
*local_40;
int4 local_38;
int4 uStack_34;
int4 uStack_30;
int4 uStack_2c;
long local_28;
if (*param_2 !=
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar1 = __cxa_allocate_exception(0x20);
local_48 = (char *)type_name(param_2);
/* try { // try from 001ac99f to 001ac9ad has its CatchHandler @ 001aca68 */
detail::concat<std::__cxx11::string,char_const(&)[26],char_const*>
((detail *)local_68,"cannot use insert() with ",&local_48);
/* try { // try from 001ac9b1 to 001ac9db has its CatchHandler @ 001aca48 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x135,local_68,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
local_40 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*param_3;
if (local_40 == param_2) {
local_38 = (int4)param_3[1];
uStack_34 = *(int4 *)((long)param_3 + 0xc);
uStack_30 = (int4)param_3[2];
uStack_2c = *(int4 *)((long)param_3 + 0x14);
local_28 = param_3[3];
insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&>
(this,param_2,&local_40);
return this;
}
uVar1 = __cxa_allocate_exception(0x20);
local_68[0] = local_58;
/* try { // try from 001ac9f4 to 001aca09 has its CatchHandler @ 001aca46 */
std::__cxx11::string::_M_construct<char_const*>(local_68,"iterator does not fit current value","")
;
/* try { // try from 001aca0d to 001aca37 has its CatchHandler @ 001aca38 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0xca,local_68,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::invalid_iterator::typeinfo,detail::exception::~exception);
}
|
|
57,740
|
int google::protobuf::(anonymous namespace)::FlatAllocation<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, google::protobuf::SourceCodeInfo, google::protobuf::FileDescriptorTables, google::protobuf::MessageOptions, google::protobuf::FieldOptions, google::protobuf::EnumOptions, google::protobuf::EnumValueOptions, google::protobuf::ExtensionRangeOptions, google::protobuf::OneofOptions, google::protobuf::ServiceOptions, google::protobuf::MethodOptions, google::protobuf::FileOptions>::BeginOffset<google::protobuf::FileDescriptorTables>() const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc
|
int BeginOffset() const {
constexpr int type_index = FindTypeIndex<U, T...>();
// Avoid a negative value here to keep it compiling when type_index == 0
constexpr int prev_type_index = type_index == 0 ? 0 : type_index - 1;
using PrevType =
typename std::tuple_element<prev_type_index, std::tuple<T...>>::type;
// Ensure the types are properly aligned.
static_assert(EffectiveAlignof<PrevType>() >= EffectiveAlignof<U>(), "");
return type_index == 0 ? RoundUpTo<kMaxAlign>(sizeof(FlatAllocation))
: ends_.template Get<PrevType>();
}
|
O0
|
cpp
|
int google::protobuf::(anonymous namespace)::FlatAllocation<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, google::protobuf::SourceCodeInfo, google::protobuf::FileDescriptorTables, google::protobuf::MessageOptions, google::protobuf::FieldOptions, google::protobuf::EnumOptions, google::protobuf::EnumValueOptions, google::protobuf::ExtensionRangeOptions, google::protobuf::OneofOptions, google::protobuf::ServiceOptions, google::protobuf::MethodOptions, google::protobuf::FileOptions>::BeginOffset<google::protobuf::FileDescriptorTables>() const:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0xc, 0xc(%rsp)
movl $0xb, 0x8(%rsp)
callq 0x27fef0
movslq (%rax), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
|
_ZNK6google8protobuf12_GLOBAL__N_114FlatAllocationIJcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE11BeginOffsetISJ_EEiv:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rdi, [rsp+18h+var_8]
mov [rsp+18h+var_C], 0Ch
mov [rsp+18h+var_10], 0Bh
call _ZNK6google8protobuf12_GLOBAL__N_17TypeMapINS1_4IntTEJcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_14SourceCodeInfoENS0_20FileDescriptorTablesENS0_14MessageOptionsENS0_12FieldOptionsENS0_11EnumOptionsENS0_16EnumValueOptionsENS0_21ExtensionRangeOptionsENS0_12OneofOptionsENS0_14ServiceOptionsENS0_13MethodOptionsENS0_11FileOptionsEEE3GetISJ_EERKiv; google::protobuf::`anonymous namespace'::TypeMap<google::protobuf::`anonymous namespace'::IntT,char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::Get<google::protobuf::MethodOptions>(void)
movsxd rax, dword ptr [rax]
add rsp, 18h
retn
|
long long google::protobuf::`anonymous namespace'::FlatAllocation<char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::BeginOffset<google::protobuf::FileOptions>(
long long a1)
{
return *(int *)google::protobuf::`anonymous namespace'::TypeMap<google::protobuf::`anonymous namespace'::IntT,char,std::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>::Get<google::protobuf::MethodOptions>(a1);
}
|
operator++:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RAX]
CALL 0x00121a10
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],RCX
ADD RSP,0x18
RET
|
/* std::_Rb_tree_iterator<std::pair<int const, std::__cxx11::string > >::TEMPNAMEPLACEHOLDERVALUE()
*/
void __thiscall
std::_Rb_tree_iterator<std::pair<int_const,std::__cxx11::string>>::operator++
(_Rb_tree_iterator<std::pair<int_const,std::__cxx11::string>> *this)
{
int8 uVar1;
uVar1 = std::_Rb_tree_increment(*(_Rb_tree_node_base **)this);
*(int8 *)this = uVar1;
return;
}
|
|
57,741
|
ps_fetch_int64
|
eloqsql/libmariadb/libmariadb/ma_stmt_codec.c
|
static
void ps_fetch_int64(MYSQL_BIND *r_param, const MYSQL_FIELD * const field,
unsigned char **row)
{
switch(r_param->buffer_type)
{
/* case MYSQL_TYPE_TINY:
ps_fetch_from_1_to_8_bytes(r_param, field, row, 1);
break;
case MYSQL_TYPE_YEAR:
case MYSQL_TYPE_SHORT:
ps_fetch_from_1_to_8_bytes(r_param, field, row, 2);
break;
case MYSQL_TYPE_INT24:
case MYSQL_TYPE_LONG:
ps_fetch_from_1_to_8_bytes(r_param, field, row, 4);
break; */
case MYSQL_TYPE_LONGLONG:
ps_fetch_from_1_to_8_bytes(r_param, field, row, 8);
break;
default:
{
longlong sval= (longlong)sint8korr(*row);
longlong lval= field->flags & UNSIGNED_FLAG ? (longlong)(ulonglong) sval : (longlong)sval;
convert_from_long(r_param, field, lval, field->flags & UNSIGNED_FLAG);
(*row) += 8;
}
break;
}
}
|
O0
|
c
|
ps_fetch_int64:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
subl $0x8, %eax
jne 0x3c32d
jmp 0x3c312
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x8, %ecx
callq 0x3aec0
jmp 0x3c406
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x18, %ecx
addl %ecx, %eax
movl %eax, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x4(%rcx), %ecx
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
movzbl 0x5(%rdx), %edx
shll $0x8, %edx
addl %edx, %ecx
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
movzbl 0x6(%rdx), %edx
shll $0x10, %edx
addl %edx, %ecx
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
movzbl 0x7(%rdx), %edx
shll $0x18, %edx
addl %edx, %ecx
movl %ecx, %ecx
shlq $0x20, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x3c3ca
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x3c3d2
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
andl $0x20, %eax
movsbl %al, %ecx
callq 0x3cbd0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
ps_fetch_int64:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov eax, [rax+60h]
sub eax, 8
jnz short loc_3C32D
jmp short $+2
loc_3C312:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov ecx, 8
call ps_fetch_from_1_to_8_bytes
jmp loc_3C406
loc_3C32D:
mov rax, [rbp+var_18]
mov rax, [rax]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
add eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+3]
shl ecx, 18h
add eax, ecx
mov eax, eax
mov rcx, [rbp+var_18]
mov rcx, [rcx]
movzx ecx, byte ptr [rcx+4]
mov rdx, [rbp+var_18]
mov rdx, [rdx]
movzx edx, byte ptr [rdx+5]
shl edx, 8
add ecx, edx
mov rdx, [rbp+var_18]
mov rdx, [rdx]
movzx edx, byte ptr [rdx+6]
shl edx, 10h
add ecx, edx
mov rdx, [rbp+var_18]
mov rdx, [rdx]
movzx edx, byte ptr [rdx+7]
shl edx, 18h
add ecx, edx
mov ecx, ecx
shl rcx, 20h
add rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov eax, [rax+64h]
and eax, 20h
cmp eax, 0
jz short loc_3C3CA
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
jmp short loc_3C3D2
loc_3C3CA:
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
loc_3C3D2:
mov rax, [rbp+var_30]
mov [rbp+var_28], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_28]
mov rax, [rbp+var_10]
mov eax, [rax+64h]
and eax, 20h
movsx ecx, al
call convert_from_long
mov rax, [rbp+var_18]
mov rcx, [rax]
add rcx, 8
mov [rax], rcx
loc_3C406:
add rsp, 30h
pop rbp
retn
|
_BYTE ** ps_fetch_int64(long long a1, long long a2, _BYTE **a3)
{
_BYTE **result; // rax
if ( *(_DWORD *)(a1 + 96) == 8 )
return ps_fetch_from_1_to_8_bytes(a1, a2, a3, 8u);
convert_from_long(
a1,
a2,
((unsigned long long)(((unsigned __int8)(*a3)[7] << 24)
+ ((unsigned __int8)(*a3)[6] << 16)
+ ((unsigned __int8)(*a3)[5] << 8)
+ (unsigned int)(unsigned __int8)(*a3)[4]) << 32)
+ ((unsigned __int8)(*a3)[3] << 24)
+ ((unsigned __int8)(*a3)[2] << 16)
+ ((unsigned __int8)(*a3)[1] << 8)
+ (unsigned int)(unsigned __int8)**a3,
*(_BYTE *)(a2 + 100) & 0x20);
result = a3;
*a3 += 8;
return result;
}
|
ps_fetch_int64:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x60]
SUB EAX,0x8
JNZ 0x0013c32d
JMP 0x0013c312
LAB_0013c312:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,0x8
CALL 0x0013aec0
JMP 0x0013c406
LAB_0013c32d:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x3]
SHL ECX,0x18
ADD EAX,ECX
MOV EAX,EAX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOVZX ECX,byte ptr [RCX + 0x4]
MOV RDX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RDX]
MOVZX EDX,byte ptr [RDX + 0x5]
SHL EDX,0x8
ADD ECX,EDX
MOV RDX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RDX]
MOVZX EDX,byte ptr [RDX + 0x6]
SHL EDX,0x10
ADD ECX,EDX
MOV RDX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RDX]
MOVZX EDX,byte ptr [RDX + 0x7]
SHL EDX,0x18
ADD ECX,EDX
MOV ECX,ECX
SHL RCX,0x20
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x64]
AND EAX,0x20
CMP EAX,0x0
JZ 0x0013c3ca
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0013c3d2
LAB_0013c3ca:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
LAB_0013c3d2:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x64]
AND EAX,0x20
MOVSX ECX,AL
CALL 0x0013cbd0
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
ADD RCX,0x8
MOV qword ptr [RAX],RCX
LAB_0013c406:
ADD RSP,0x30
POP RBP
RET
|
void ps_fetch_int64(long param_1,long param_2,long *param_3)
{
if (*(int *)(param_1 + 0x60) == 8) {
ps_fetch_from_1_to_8_bytes(param_1,param_2,param_3,8);
}
else {
convert_from_long(param_1,param_2,
CONCAT44((uint)*(byte *)(*param_3 + 4) + (uint)*(byte *)(*param_3 + 5) * 0x100
+ (uint)*(byte *)(*param_3 + 6) * 0x10000 +
(uint)*(byte *)(*param_3 + 7) * 0x1000000,
(uint)*(byte *)*param_3 + (uint)*(byte *)(*param_3 + 1) * 0x100 +
(uint)*(byte *)(*param_3 + 2) * 0x10000 +
(uint)*(byte *)(*param_3 + 3) * 0x1000000),
(byte)*(int4 *)(param_2 + 100) & 0x20);
*param_3 = *param_3 + 8;
}
return;
}
|
|
57,742
|
moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent, moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::~ImplicitProducer()
|
angrymouse[P]emittra/include/concurrentqueue.h
|
~ImplicitProducer()
{
// Note that since we're in the destructor we can assume that all enqueue/dequeue operations
// completed already; this means that all undequeued elements are placed contiguously across
// contiguous blocks, and that only the first and last remaining blocks can be only partially
// empty (all other remaining blocks must be completely full).
#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
// Unregister ourselves for thread termination notification
if (!this->inactive.load(std::memory_order_relaxed)) {
details::ThreadExitNotifier::unsubscribe(&threadExitListener);
}
#endif
// Destroy all remaining elements!
auto tail = this->tailIndex.load(std::memory_order_relaxed);
auto index = this->headIndex.load(std::memory_order_relaxed);
Block* block = nullptr;
assert(index == tail || details::circular_less_than(index, tail));
bool forceFreeLastBlock = index != tail; // If we enter the loop, then the last (tail) block will not be freed
while (index != tail) {
if ((index & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 || block == nullptr) {
if (block != nullptr) {
// Free the old block
this->parent->add_block_to_free_list(block);
}
block = get_block_index_entry_for_index(index)->value.load(std::memory_order_relaxed);
}
((*block)[index])->~T();
++index;
}
// Even if the queue is empty, there's still one block that's not on the free list
// (unless the head index reached the end of it, in which case the tail will be poised
// to create a new block).
if (this->tailBlock != nullptr && (forceFreeLastBlock || (tail & static_cast<index_t>(BLOCK_SIZE - 1)) != 0)) {
this->parent->add_block_to_free_list(this->tailBlock);
}
// Destroy block index
auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);
if (localBlockIndex != nullptr) {
for (size_t i = 0; i != localBlockIndex->capacity; ++i) {
localBlockIndex->index[i]->~BlockIndexEntry();
}
do {
auto prev = localBlockIndex->prev;
localBlockIndex->~BlockIndexHeader();
(Traits::free)(localBlockIndex);
localBlockIndex = prev;
} while (localBlockIndex != nullptr);
}
}
|
O0
|
c
|
moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent, moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::~ImplicitProducer():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x17a70
movq 0x8(%rsp), %rdi
movl $0x68, %esi
callq 0x42e0
addq $0x18, %rsp
retq
nopl (%rax)
|
_ZN10moodycamel15ConcurrentQueueIN7emittra7Emittra11QueuedEventENS_28ConcurrentQueueDefaultTraitsEE16ImplicitProducerD0Ev:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rdi, [rsp+18h+var_8]
mov [rsp+18h+var_10], rdi
call _ZN10moodycamel15ConcurrentQueueIN7emittra7Emittra11QueuedEventENS_28ConcurrentQueueDefaultTraitsEE16ImplicitProducerD2Ev; moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent,moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::~ImplicitProducer()
mov rdi, [rsp+18h+var_10]; void *
mov esi, 68h ; 'h'; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
add rsp, 18h
retn
|
void moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent,moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::~ImplicitProducer(
_QWORD *a1)
{
moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent,moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::~ImplicitProducer(a1);
operator delete(a1, 0x68uLL);
}
|
~ImplicitProducer:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00117a70
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x68
CALL 0x001042e0
ADD RSP,0x18
RET
|
/* moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent,
moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::~ImplicitProducer() */
void __thiscall
moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent,moodycamel::ConcurrentQueueDefaultTraits>
::ImplicitProducer::~ImplicitProducer(ImplicitProducer *this)
{
~ImplicitProducer(this);
operator_delete(this,0x68);
return;
}
|
|
57,743
|
moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent, moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::~ImplicitProducer()
|
angrymouse[P]emittra/include/concurrentqueue.h
|
~ImplicitProducer()
{
// Note that since we're in the destructor we can assume that all enqueue/dequeue operations
// completed already; this means that all undequeued elements are placed contiguously across
// contiguous blocks, and that only the first and last remaining blocks can be only partially
// empty (all other remaining blocks must be completely full).
#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
// Unregister ourselves for thread termination notification
if (!this->inactive.load(std::memory_order_relaxed)) {
details::ThreadExitNotifier::unsubscribe(&threadExitListener);
}
#endif
// Destroy all remaining elements!
auto tail = this->tailIndex.load(std::memory_order_relaxed);
auto index = this->headIndex.load(std::memory_order_relaxed);
Block* block = nullptr;
assert(index == tail || details::circular_less_than(index, tail));
bool forceFreeLastBlock = index != tail; // If we enter the loop, then the last (tail) block will not be freed
while (index != tail) {
if ((index & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 || block == nullptr) {
if (block != nullptr) {
// Free the old block
this->parent->add_block_to_free_list(block);
}
block = get_block_index_entry_for_index(index)->value.load(std::memory_order_relaxed);
}
((*block)[index])->~T();
++index;
}
// Even if the queue is empty, there's still one block that's not on the free list
// (unless the head index reached the end of it, in which case the tail will be poised
// to create a new block).
if (this->tailBlock != nullptr && (forceFreeLastBlock || (tail & static_cast<index_t>(BLOCK_SIZE - 1)) != 0)) {
this->parent->add_block_to_free_list(this->tailBlock);
}
// Destroy block index
auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);
if (localBlockIndex != nullptr) {
for (size_t i = 0; i != localBlockIndex->capacity; ++i) {
localBlockIndex->index[i]->~BlockIndexEntry();
}
do {
auto prev = localBlockIndex->prev;
localBlockIndex->~BlockIndexHeader();
(Traits::free)(localBlockIndex);
localBlockIndex = prev;
} while (localBlockIndex != nullptr);
}
}
|
O3
|
c
|
moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent, moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::~ImplicitProducer():
pushq %rbx
movq %rdi, %rbx
callq 0x839a
movl $0x68, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x32b0
nop
|
_ZN10moodycamel15ConcurrentQueueIN7emittra7Emittra11QueuedEventENS_28ConcurrentQueueDefaultTraitsEE16ImplicitProducerD0Ev:
push rbx
mov rbx, rdi
call _ZN10moodycamel15ConcurrentQueueIN7emittra7Emittra11QueuedEventENS_28ConcurrentQueueDefaultTraitsEE16ImplicitProducerD2Ev; moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent,moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::~ImplicitProducer()
mov esi, 68h ; 'h'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
|
void moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent,moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::~ImplicitProducer(
_QWORD *a1)
{
moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent,moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::~ImplicitProducer(a1);
operator delete(a1, 0x68uLL);
}
|
~ImplicitProducer:
PUSH RBX
MOV RBX,RDI
CALL 0x0010839a
MOV ESI,0x68
MOV RDI,RBX
POP RBX
JMP 0x001032b0
|
/* moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent,
moodycamel::ConcurrentQueueDefaultTraits>::ImplicitProducer::~ImplicitProducer() */
void __thiscall
moodycamel::ConcurrentQueue<emittra::Emittra::QueuedEvent,moodycamel::ConcurrentQueueDefaultTraits>
::ImplicitProducer::~ImplicitProducer(ImplicitProducer *this)
{
~ImplicitProducer(this);
operator_delete(this,0x68);
return;
}
|
|
57,744
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_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>>::start_array(unsigned long)
|
monkey531[P]llama/common/./json.hpp
|
bool start_array(std::size_t len)
{
ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
}
return true;
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_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>>::start_array(unsigned long):
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movb $0x2, 0x7f(%rsp)
leaq 0x7f(%rsp), %rsi
callq 0xc3dc0
movq 0x20(%rsp), %rdi
movq %rax, 0x80(%rsp)
leaq 0x80(%rsp), %rsi
callq 0xc3d90
xorl %eax, %eax
cmpq $-0x1, 0x88(%rsp)
movb %al, 0x2a(%rsp)
je 0xc3a3f
movq 0x18(%rsp), %rdi
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rdi
callq 0xb98c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
seta %al
movb %al, 0x2a(%rsp)
movb 0x2a(%rsp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc3a50
jmp 0xc3b2d
movb $0x1, 0x2b(%rsp)
movl $0x20, %edi
callq 0x50540
movq %rax, 0x8(%rsp)
movq 0x88(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xb9ba0
jmp 0xc3a78
leaq 0x10bb57(%rip), %rsi # 0x1cf5d6
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0xbe250
jmp 0xc3a90
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq 0x8(%rsp), %rdi
movq (%rax), %rcx
movl $0x198, %esi # imm = 0x198
leaq 0x58(%rsp), %rdx
callq 0xb9940
jmp 0xc3ab7
movq 0x8(%rsp), %rdi
movb $0x0, 0x2b(%rsp)
leaq 0x18e718(%rip), %rsi # 0x2521e0
leaq -0xab8f(%rip), %rdx # 0xb8f40
callq 0x508f0
jmp 0xc3b43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xc3b18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xc3b0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x510c0
leaq 0x38(%rsp), %rdi
callq 0x510c0
testb $0x1, 0x2b(%rsp)
jne 0xc3b21
jmp 0xc3b2b
movq 0x8(%rsp), %rdi
callq 0x50c40
jmp 0xc3b39
movb $0x1, %al
andb $0x1, %al
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x50940
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail19json_sax_dom_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE11start_arrayEm:
sub rsp, 98h
mov qword ptr [rsp+98h+var_8], rdi; char
mov [rsp+98h+var_10], rsi; int
mov rdi, qword ptr [rsp+98h+var_8]
mov qword ptr [rsp+98h+var_80], rdi; char
mov rax, rdi
add rax, 8
mov qword ptr [rsp+98h+var_78], rax; int
mov [rsp+98h+var_19], 2
lea rsi, [rsp+98h+var_19]
call _ZN8nlohmann16json_abi_v3_11_36detail19json_sax_dom_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueINS1_7value_tEEEPSF_OT_; nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t &&)
mov rdi, qword ptr [rsp+98h+var_78]
mov qword ptr [rsp+98h+var_18], rax; int
lea rsi, [rsp+98h+var_18]
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE9push_backEOSE_; 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> *>>::push_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> *&&)
xor eax, eax
cmp [rsp+98h+var_10], 0FFFFFFFFFFFFFFFFh
mov [rsp+98h+var_6E], al
jz short loc_C3A3F
mov rdi, qword ptr [rsp+98h+var_80]
mov rax, [rsp+98h+var_10]
mov qword ptr [rsp+98h+var_88], rax; int
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_IhSaIhEEvE8max_sizeEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::max_size(void)
mov rcx, rax
mov rax, qword ptr [rsp+98h+var_88]
cmp rax, rcx
setnbe al
mov [rsp+98h+var_6E], al
loc_C3A3F:
mov al, [rsp+98h+var_6E]
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_C3A50
jmp loc_C3B2D
loc_C3A50:
mov [rsp+98h+var_6D], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov [rsp+98h+var_90], rax; int
mov rsi, [rsp+98h+var_10]; unsigned __int64
lea rdi, [rsp+98h+var_60]; this
call _ZNSt7__cxx119to_stringEm; std::to_string(ulong)
jmp short $+2
loc_C3A78:
lea rsi, aExcessiveArray; "excessive array size: "
lea rdi, [rsp+98h+var_40]
lea rdx, [rsp+98h+var_60]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA23_KcS8_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[23],std::string>(char const(&)[23],std::string &&)
jmp short $+2
loc_C3A90:
mov rdi, qword ptr [rsp+98h+var_80]
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, [rsp+98h+var_90]; int
mov rcx, [rax]
mov esi, 198h
lea rdx, [rsp+98h+var_40]
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
jmp short $+2
loc_C3AB7:
mov rdi, [rsp+98h+var_90]; void *
mov [rsp+98h+var_6D], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail12out_of_rangeD2Ev; void (*)(void *)
call ___cxa_throw
jmp short loc_C3B43
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
jmp short loc_C3B18
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
jmp short loc_C3B0E
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_C3B0E:
lea rdi, [rsp+arg_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_C3B18:
test [rsp+arg_23], 1
jnz short loc_C3B21
jmp short loc_C3B2B
loc_C3B21:
mov rdi, [rsp+arg_0]; void *
call ___cxa_free_exception
loc_C3B2B:
jmp short loc_C3B39
loc_C3B2D:
mov al, 1
and al, 1
add rsp, 98h
retn
loc_C3B39:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
loc_C3B43:
nop word ptr [rax+rax+00000000h]
nop dword ptr [rax]
|
char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_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>>::start_array(
long long a1,
unsigned long long a2)
{
long long *v2; // rax
long long *v3; // rax
nlohmann::json_abi_v3_11_3::detail::out_of_range *exception; // [rsp+8h] [rbp-90h]
unsigned long long v6; // [rsp+10h] [rbp-88h]
bool v7; // [rsp+2Ah] [rbp-6Eh]
_BYTE v8[32]; // [rsp+38h] [rbp-60h] BYREF
_BYTE v9[39]; // [rsp+58h] [rbp-40h] BYREF
char v10; // [rsp+7Fh] [rbp-19h] BYREF
int v11[2]; // [rsp+80h] [rbp-18h] BYREF
unsigned long long v12; // [rsp+88h] [rbp-10h]
char v13[8]; // [rsp+90h] [rbp-8h]
*(_QWORD *)v13 = a1;
v12 = a2;
v10 = 2;
*(_QWORD *)v11 = nlohmann::json_abi_v3_11_3::detail::json_sax_dom_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<nlohmann::json_abi_v3_11_3::detail::value_t>(
a1,
&v10);
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> *>>::push_back(
a1 + 8,
v11);
v7 = 0;
if ( v12 != -1LL )
{
v6 = v12;
v2 = (long 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> *,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);
v7 = v6 > 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>::max_size(*v2);
}
if ( v7 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::out_of_range *)__cxa_allocate_exception(0x20uLL);
std::to_string((std::__cxx11 *)v8, v12);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[23],std::string>(
(long long)v9,
(long long)"excessive array size: ",
(nlohmann::json_abi_v3_11_3::detail *)v8);
v3 = (long 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> *,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);
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
408,
(long long)v9,
*v3);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::out_of_range::~out_of_range);
}
return 1;
}
|
start_array:
SUB RSP,0x98
MOV qword ptr [RSP + 0x90],RDI
MOV qword ptr [RSP + 0x88],RSI
MOV RDI,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,RDI
ADD RAX,0x8
MOV qword ptr [RSP + 0x20],RAX
MOV byte ptr [RSP + 0x7f],0x2
LEA RSI,[RSP + 0x7f]
CALL 0x001c3dc0
MOV RDI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x80],RAX
LEA RSI,[RSP + 0x80]
CALL 0x001c3d90
XOR EAX,EAX
CMP qword ptr [RSP + 0x88],-0x1
MOV byte ptr [RSP + 0x2a],AL
JZ 0x001c3a3f
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x10],RAX
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RAX]
CALL 0x001b98c0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
CMP RAX,RCX
SETA AL
MOV byte ptr [RSP + 0x2a],AL
LAB_001c3a3f:
MOV AL,byte ptr [RSP + 0x2a]
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x001c3a50
JMP 0x001c3b2d
LAB_001c3a50:
MOV byte ptr [RSP + 0x2b],0x1
MOV EDI,0x20
CALL 0x00150540
MOV qword ptr [RSP + 0x8],RAX
MOV RSI,qword ptr [RSP + 0x88]
LAB_001c3a6c:
LEA RDI,[RSP + 0x38]
CALL 0x001b9ba0
JMP 0x001c3a78
LAB_001c3a78:
LEA RSI,[0x2cf5d6]
LEA RDI,[RSP + 0x58]
LEA RDX,[RSP + 0x38]
CALL 0x001be250
JMP 0x001c3a90
LAB_001c3a90:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RAX]
LAB_001c3aa6:
MOV ESI,0x198
LEA RDX,[RSP + 0x58]
CALL 0x001b9940
JMP 0x001c3ab7
LAB_001c3ab7:
MOV RDI,qword ptr [RSP + 0x8]
MOV byte ptr [RSP + 0x2b],0x0
LEA RSI,[0x3521e0]
LEA RDX,[0x1b8f40]
CALL 0x001508f0
LAB_001c3b2d:
MOV AL,0x1
AND AL,0x1
ADD RSP,0x98
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_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> >::start_array(unsigned long) */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_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>>
::start_array(json_sax_dom_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,ulong param_1)
{
bool bVar1;
ulong uVar2;
int8 *puVar3;
ulong uVar4;
int7 uVar6;
int8 uVar5;
__cxx11 local_60 [32];
detail local_40 [39];
value_t local_19;
basic_json *local_18;
ulong local_10;
json_sax_dom_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_8;
local_19 = 2;
local_10 = param_1;
local_8 = this;
local_18 = handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(this,&local_19);
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>*>>
::push_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_18);
uVar2 = local_10;
uVar6 = 0;
bVar1 = false;
if (local_10 != 0xffffffffffffffff) {
puVar3 = (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>
::max_size((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar3);
bVar1 = uVar4 < uVar2;
uVar6 = (int7)(uVar2 >> 8);
}
if (!bVar1) {
return CONCAT71(uVar6,1);
}
uVar5 = __cxa_allocate_exception(0x20);
/* try { // try from 001c3a6c to 001c3a75 has its CatchHandler @ 001c3ad6 */
std::__cxx11::to_string(local_60,local_10);
/* try { // try from 001c3a78 to 001c3a8d has its CatchHandler @ 001c3ae6 */
concat<std::__cxx11::string,char_const(&)[23],std::__cxx11::string>
(local_40,"excessive array size: ",(string *)local_60);
puVar3 = (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));
/* try { // try from 001c3aa6 to 001c3ad3 has its CatchHandler @ 001c3af6 */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar5,0x198,local_40,*puVar3);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,&out_of_range::typeinfo,out_of_range::~out_of_range);
}
|
|
57,745
|
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::FVarLevel(OpenSubdiv::v3_6_0::Vtr::internal::Level const&)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/fvarLevel.cpp
|
FVarLevel::FVarLevel(Level const& level) :
_level(level),
_isLinear(false),
_hasLinearBoundaries(false),
_hasDependentSharpness(false),
_valueCount(0) {
}
|
O0
|
cpp
|
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::FVarLevel(OpenSubdiv::v3_6_0::Vtr::internal::Level const&):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0xd6070
movq -0x18(%rbp), %rdi
movb $0x0, 0xc(%rdi)
movb $0x0, 0xd(%rdi)
movb $0x0, 0xe(%rdi)
movl $0x0, 0x10(%rdi)
addq $0x18, %rdi
callq 0xd2780
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xc51e0
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0xcfaa0
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0xd2780
movq -0x18(%rbp), %rdi
addq $0x78, %rdi
callq 0xcfaa0
movq -0x18(%rbp), %rdi
addq $0x90, %rdi
callq 0xd2780
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
callq 0xd3a60
movq -0x18(%rbp), %rdi
addq $0xc0, %rdi
callq 0xcaf50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZN10OpenSubdiv6v3_6_03Vtr8internal9FVarLevelC2ERKNS2_5LevelE:
push rbp; Alternative name is 'OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::FVarLevel(OpenSubdiv::v3_6_0::Vtr::internal::Level const&)'
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]
mov [rbp+var_18], rdi
mov rax, [rbp+var_10]
mov [rdi], rax
add rdi, 8; this
call __ZN10OpenSubdiv6v3_6_03Sdc7OptionsC2Ev; OpenSubdiv::v3_6_0::Sdc::Options::Options(void)
mov rdi, [rbp+var_18]
mov byte ptr [rdi+0Ch], 0
mov byte ptr [rdi+0Dh], 0
mov byte ptr [rdi+0Eh], 0
mov dword ptr [rdi+10h], 0
add rdi, 18h
call __ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov rdi, [rbp+var_18]
add rdi, 30h ; '0'
call __ZNSt6vectorIN10OpenSubdiv6v3_6_03Vtr8internal9FVarLevel4ETagESaIS5_EEC2Ev; std::vector<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ETag>::vector(void)
mov rdi, [rbp+var_18]
add rdi, 48h ; 'H'
call __ZNSt6vectorItSaItEEC2Ev; std::vector<ushort>::vector(void)
mov rdi, [rbp+var_18]
add rdi, 60h ; '`'
call __ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov rdi, [rbp+var_18]
add rdi, 78h ; 'x'
call __ZNSt6vectorItSaItEEC2Ev; std::vector<ushort>::vector(void)
mov rdi, [rbp+var_18]
add rdi, 90h
call __ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov rdi, [rbp+var_18]
add rdi, 0A8h
call __ZNSt6vectorIN10OpenSubdiv6v3_6_03Vtr8internal9FVarLevel8ValueTagESaIS5_EEC2Ev; std::vector<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ValueTag>::vector(void)
mov rdi, [rbp+var_18]
add rdi, 0C0h
call __ZNSt6vectorIN10OpenSubdiv6v3_6_03Vtr8internal9FVarLevel13CreaseEndPairESaIS5_EEC2Ev; std::vector<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::CreaseEndPair>::vector(void)
add rsp, 20h
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::FVarLevel(
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel *this,
const OpenSubdiv::v3_6_0::Vtr::internal::Level *a2)
{
*(_QWORD *)this = a2;
OpenSubdiv::v3_6_0::Sdc::Options::Options((OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel *)((char *)this + 8));
*((_BYTE *)this + 12) = 0;
*((_BYTE *)this + 13) = 0;
*((_BYTE *)this + 14) = 0;
*((_DWORD *)this + 4) = 0;
std::vector<int>::vector((char *)this + 24);
std::vector<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ETag>::vector((char *)this + 48);
std::vector<unsigned short>::vector((char *)this + 72);
std::vector<int>::vector((char *)this + 96);
std::vector<unsigned short>::vector((char *)this + 120);
std::vector<int>::vector((char *)this + 144);
std::vector<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ValueTag>::vector((char *)this + 168);
return std::vector<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::CreaseEndPair>::vector((char *)this + 192);
}
|
FVarLevel:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RDI],RAX
ADD RDI,0x8
CALL 0x001d6070
MOV RDI,qword ptr [RBP + -0x18]
MOV byte ptr [RDI + 0xc],0x0
MOV byte ptr [RDI + 0xd],0x0
MOV byte ptr [RDI + 0xe],0x0
MOV dword ptr [RDI + 0x10],0x0
ADD RDI,0x18
CALL 0x001d2780
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x30
CALL 0x001c51e0
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x48
CALL 0x001cfaa0
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x60
CALL 0x001d2780
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x78
CALL 0x001cfaa0
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x90
CALL 0x001d2780
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0xa8
CALL 0x001d3a60
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0xc0
CALL 0x001caf50
ADD RSP,0x20
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::FVarLevel(OpenSubdiv::v3_6_0::Vtr::internal::Level
const&) */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::FVarLevel(FVarLevel *this,Level *param_1)
{
*(Level **)this = param_1;
Sdc::Options::Options((Options *)(this + 8));
this[0xc] = (FVarLevel)0x0;
this[0xd] = (FVarLevel)0x0;
this[0xe] = (FVarLevel)0x0;
*(int4 *)(this + 0x10) = 0;
std::vector<int,std::allocator<int>>::vector((vector<int,std::allocator<int>> *)(this + 0x18));
std::
vector<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ETag,std::allocator<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ETag>>
::vector((vector<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ETag,std::allocator<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ETag>>
*)(this + 0x30));
std::vector<unsigned_short,std::allocator<unsigned_short>>::vector
((vector<unsigned_short,std::allocator<unsigned_short>> *)(this + 0x48));
std::vector<int,std::allocator<int>>::vector((vector<int,std::allocator<int>> *)(this + 0x60));
std::vector<unsigned_short,std::allocator<unsigned_short>>::vector
((vector<unsigned_short,std::allocator<unsigned_short>> *)(this + 0x78));
std::vector<int,std::allocator<int>>::vector((vector<int,std::allocator<int>> *)(this + 0x90));
std::
vector<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ValueTag,std::allocator<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ValueTag>>
::vector((vector<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ValueTag,std::allocator<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::ValueTag>>
*)(this + 0xa8));
std::
vector<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::CreaseEndPair,std::allocator<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::CreaseEndPair>>
::vector((vector<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::CreaseEndPair,std::allocator<OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::CreaseEndPair>>
*)(this + 0xc0));
return;
}
|
|
57,746
|
ggml_view_3d
|
llama.cpp/ggml/src/ggml.c
|
struct ggml_tensor * ggml_view_3d(
struct ggml_context * ctx,
struct ggml_tensor * a,
int64_t ne0,
int64_t ne1,
int64_t ne2,
size_t nb1,
size_t nb2,
size_t offset) {
const int64_t ne[3] = { ne0, ne1, ne2 };
struct ggml_tensor * result = ggml_view_impl(ctx, a, 3, ne, offset);
result->nb[1] = nb1;
result->nb[2] = nb2;
result->nb[3] = result->nb[2]*ne2;
return result;
}
|
O3
|
c
|
ggml_view_3d:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %r9, %rbx
movq %r8, %r14
movq 0x40(%rsp), %r15
movq 0x48(%rsp), %r8
movq %rsp, %rax
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %r14, 0x10(%rax)
movl $0x3, %edx
movq %rax, %rcx
callq 0x1be7d
movq %rbx, 0x38(%rax)
movq %r15, 0x40(%rax)
imulq %r14, %r15
movq %r15, 0x48(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
ggml_view_3d:
push r15
push r14
push rbx
sub rsp, 20h
mov rbx, r9
mov r14, r8
mov r15, [rsp+38h+arg_0]
mov r8, [rsp+38h+arg_8]
mov rax, rsp
mov [rax], rdx
mov [rax+8], rcx
mov [rax+10h], r14
mov edx, 3
mov rcx, rax
call ggml_view_impl
mov [rax+38h], rbx
mov [rax+40h], r15
imul r15, r14
mov [rax+48h], r15
add rsp, 20h
pop rbx
pop r14
pop r15
retn
|
_QWORD * ggml_view_3d(
long long a1,
unsigned int *a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8)
{
_QWORD *result; // rax
_QWORD v11[7]; // [rsp+0h] [rbp-38h] BYREF
v11[0] = a3;
v11[1] = a4;
v11[2] = a5;
result = (_QWORD *)ggml_view_impl(a1, a2, 3u, v11, a8);
result[7] = a6;
result[8] = a7;
result[9] = a5 * a7;
return result;
}
|
ggml_view_3d:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RBX,R9
MOV R14,R8
MOV R15,qword ptr [RSP + 0x40]
MOV R8,qword ptr [RSP + 0x48]
MOV RAX,RSP
MOV qword ptr [RAX],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RAX + 0x10],R14
MOV EDX,0x3
MOV RCX,RAX
CALL 0x0011be7d
MOV qword ptr [RAX + 0x38],RBX
MOV qword ptr [RAX + 0x40],R15
IMUL R15,R14
MOV qword ptr [RAX + 0x48],R15
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
|
void ggml_view_3d(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
long param_5,int8 param_6,long param_7,int8 param_8)
{
long lVar1;
int8 local_38;
int8 local_30;
long local_28;
local_38 = param_3;
local_30 = param_4;
local_28 = param_5;
lVar1 = ggml_view_impl(param_1,param_2,3,&local_38,param_8);
*(int8 *)(lVar1 + 0x38) = param_6;
*(long *)(lVar1 + 0x40) = param_7;
*(long *)(lVar1 + 0x48) = param_7 * param_5;
return;
}
|
|
57,747
|
minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&)
|
llama.cpp/common/minja/minja.hpp
|
Value(const std::shared_ptr<CallableType> & callable) : object_(std::make_shared<ObjectType>()), callable_(callable) {}
|
O3
|
cpp
|
minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x30, %edi
callq 0x20210
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x937d3(%rip), %rcx # 0x160430
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, 0x28(%rbx)
movq %rcx, 0x20(%rbx)
movq (%r14), %rax
movq %rax, 0x30(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0xcccab
movq 0x952fb(%rip), %rcx # 0x161f98
cmpb $0x0, (%rcx)
je 0xccca7
incl 0x8(%rax)
jmp 0xcccab
lock
incl 0x8(%rax)
leaq 0x40(%rbx), %r14
movb $0x0, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x84b96
movq %r14, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x84b96
movq %rax, %r14
leaq 0x18(%rbx), %rdi
callq 0x7028e
movq %rbx, %rdi
callq 0xbd102
movq %r14, %rdi
callq 0x20af0
|
_ZN5minja5ValueC2ERKSt10shared_ptrISt8functionIFS0_RKS1_INS_7ContextEERNS_14ArgumentsValueEEEE:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
mov rcx, 100000001h
mov [rax+8], rcx
lea rcx, _ZTVSt23_Sp_counted_ptr_inplaceIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEESaIvELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>,std::allocator<void>,(__gnu_cxx::_Lock_policy)2>
add rcx, 10h
mov [rax], rcx
mov rcx, rax
add rcx, 10h
xorps xmm0, xmm0
movups xmmword ptr [rax+10h], xmm0
mov qword ptr [rax+20h], 0
mov [rbx+28h], rax
mov [rbx+20h], rcx
mov rax, [r14]
mov [rbx+30h], rax
mov rax, [r14+8]
mov [rbx+38h], rax
test rax, rax
jz short loc_CCCAB
mov rcx, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rcx], 0
jz short loc_CCCA7
inc dword ptr [rax+8]
jmp short loc_CCCAB
loc_CCCA7:
lock inc dword ptr [rax+8]
loc_CCCAB:
lea r14, [rbx+40h]
mov byte ptr [rbx+40h], 0
mov qword ptr [rbx+48h], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
add rsp, 8
pop rbx
pop r14
jmp _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 r14, rax
lea rdi, [rbx+18h]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, rbx
call _ZNSt23enable_shared_from_thisIN5minja5ValueEED2Ev; std::enable_shared_from_this<minja::Value>::~enable_shared_from_this()
mov rdi, r14
call __Unwind_Resume
|
long long minja::Value::Value(long long a1, _QWORD *a2)
{
long long v2; // rax
long long result; // rax
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v2 = operator new(0x30uLL);
*(_QWORD *)(v2 + 8) = 0x100000001LL;
*(_QWORD *)v2 = &`vtable for'std::_Sp_counted_ptr_inplace<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>,std::allocator<void>,(__gnu_cxx::_Lock_policy)2>
+ 2;
*(_OWORD *)(v2 + 16) = 0LL;
*(_QWORD *)(v2 + 32) = 0LL;
*(_QWORD *)(a1 + 40) = v2;
*(_QWORD *)(a1 + 32) = v2 + 16;
*(_QWORD *)(a1 + 48) = *a2;
result = a2[1];
*(_QWORD *)(a1 + 56) = result;
if ( result )
{
if ( _libc_single_threaded )
++*(_DWORD *)(result + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(result + 8));
}
*(_BYTE *)(a1 + 64) = 0;
*(_QWORD *)(a1 + 72) = 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 *)(a1 + 64));
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a1 + 64));
return result;
}
|
Value:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
LAB_001ccc3e:
MOV EDI,0x30
CALL 0x00120210
LAB_001ccc48:
MOV RCX,0x100000001
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x260430]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
MOV RCX,RAX
ADD RCX,0x10
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOV qword ptr [RAX + 0x20],0x0
MOV qword ptr [RBX + 0x28],RAX
MOV qword ptr [RBX + 0x20],RCX
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX + 0x30],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RBX + 0x38],RAX
TEST RAX,RAX
JZ 0x001cccab
MOV RCX,qword ptr [0x00261f98]
CMP byte ptr [RCX],0x0
JZ 0x001ccca7
INC dword ptr [RAX + 0x8]
JMP 0x001cccab
LAB_001ccca7:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001cccab:
LEA R14,[RBX + 0x40]
MOV byte ptr [RBX + 0x40],0x0
MOV qword ptr [RBX + 0x48],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x00184b96
MOV RDI,R14
MOV ESI,0x1
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00184b96
|
/* minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context>
const&, minja::ArgumentsValue&)> > const&) */
void __thiscall minja::Value::Value(Value *this,shared_ptr *param_1)
{
long lVar1;
int8 *puVar2;
bool bVar3;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
/* try { // try from 001ccc3e to 001ccc47 has its CatchHandler @ 001cccdc */
puVar2 = (int8 *)operator_new(0x30);
puVar2[1] = 0x100000001;
*puVar2 = &PTR___Sp_counted_base_00260440;
puVar2[2] = 0;
puVar2[3] = 0;
puVar2[4] = 0;
*(int8 **)(this + 0x28) = puVar2;
*(int8 **)(this + 0x20) = puVar2 + 2;
*(int8 *)(this + 0x30) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x38) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_00261f98 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
bVar3 = (bool)((char)this + '@');
this[0x40] = (Value)0x0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar3);
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(bVar3);
return;
}
|
|
57,748
|
mysql_client_plugin_init
|
eloqsql/build_O0/libmariadb/libmariadb/ma_client_plugin.c
|
int mysql_client_plugin_init()
{
MYSQL mysql;
struct st_mysql_client_plugin **builtin;
va_list unused;
LINT_INIT_STRUCT(unused);
if (initialized)
return 0;
memset(&mysql, 0, sizeof(mysql)); /* dummy mysql for set_mysql_extended_error */
pthread_mutex_init(&LOCK_load_client_plugin, NULL);
ma_init_alloc_root(&mem_root, 128, 128);
memset(&plugin_list, 0, sizeof(plugin_list));
initialized= 1;
pthread_mutex_lock(&LOCK_load_client_plugin);
for (builtin= mysql_client_builtins; *builtin; builtin++)
add_plugin(&mysql, *builtin, 0, 0, unused);
pthread_mutex_unlock(&LOCK_load_client_plugin);
load_env_plugins(&mysql);
return 0;
}
|
O0
|
c
|
mysql_client_plugin_init:
pushq %rbp
movq %rsp, %rbp
subq $0x540, %rsp # imm = 0x540
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
leaq -0x530(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x17330
cmpb $0x0, 0x208de(%rip) # 0x65b70
je 0x452a3
movl $0x0, -0x504(%rbp)
jmp 0x45374
leaq -0x500(%rbp), %rdi
xorl %esi, %esi
movl $0x4f8, %edx # imm = 0x4F8
callq 0x17330
leaq 0x208bb(%rip), %rdi # 0x65b78
xorl %eax, %eax
movl %eax, %esi
callq 0x178a0
leaq 0x208d3(%rip), %rdi # 0x65ba0
movl $0x80, %edx
movq %rdx, %rsi
callq 0x2f470
leaq 0x208ff(%rip), %rdi # 0x65be0
xorl %esi, %esi
movl $0x40, %edx
callq 0x17330
movb $0x1, 0x2087c(%rip) # 0x65b70
leaq 0x2087d(%rip), %rdi # 0x65b78
callq 0x17880
leaq 0x1ed69(%rip), %rax # 0x64070
movq %rax, -0x510(%rbp)
movq -0x510(%rbp), %rax
cmpq $0x0, (%rax)
je 0x45352
movq -0x510(%rbp), %rax
movq (%rax), %rsi
leaq -0x530(%rbp), %r8
leaq -0x500(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x453b0
movq -0x510(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x510(%rbp)
jmp 0x4530e
leaq 0x2081f(%rip), %rdi # 0x65b78
callq 0x17430
leaq -0x500(%rbp), %rdi
callq 0x455e0
movl $0x0, -0x504(%rbp)
movl -0x504(%rbp), %eax
movl %eax, -0x534(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x453a1
movl -0x534(%rbp), %eax
addq $0x540, %rsp # imm = 0x540
popq %rbp
retq
callq 0x17690
nopw %cs:(%rax,%rax)
|
mysql_client_plugin_init:
push rbp
mov rbp, rsp
sub rsp, 540h
mov rax, fs:28h
mov [rbp+var_8], rax
lea rdi, [rbp+var_530]
xor esi, esi
mov edx, 18h
call _memset
cmp cs:initialized, 0
jz short loc_452A3
mov [rbp+var_504], 0
jmp loc_45374
loc_452A3:
lea rdi, [rbp+var_500]
xor esi, esi
mov edx, 4F8h
call _memset
lea rdi, LOCK_load_client_plugin
xor eax, eax
mov esi, eax
call _pthread_mutex_init
lea rdi, mem_root
mov edx, 80h
mov rsi, rdx
call ma_init_alloc_root
lea rdi, plugin_list
xor esi, esi
mov edx, 40h ; '@'
call _memset
mov cs:initialized, 1
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_lock
lea rax, mysql_client_builtins
mov [rbp+var_510], rax
loc_4530E:
mov rax, [rbp+var_510]
cmp qword ptr [rax], 0
jz short loc_45352
mov rax, [rbp+var_510]
mov rsi, [rax]
lea r8, [rbp+var_530]
lea rdi, [rbp+var_500]
xor eax, eax
mov edx, eax
xor ecx, ecx
call add_plugin
mov rax, [rbp+var_510]
add rax, 8
mov [rbp+var_510], rax
jmp short loc_4530E
loc_45352:
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_unlock
lea rdi, [rbp+var_500]
call load_env_plugins
mov [rbp+var_504], 0
loc_45374:
mov eax, [rbp+var_504]
mov [rbp+var_534], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_453A1
mov eax, [rbp+var_534]
add rsp, 540h
pop rbp
retn
loc_453A1:
call ___stack_chk_fail
|
long long mysql_client_plugin_init()
{
_BYTE v1[32]; // [rsp+10h] [rbp-530h] BYREF
_QWORD *i; // [rsp+30h] [rbp-510h]
_BYTE v4[1272]; // [rsp+40h] [rbp-500h] BYREF
unsigned long long v5; // [rsp+538h] [rbp-8h]
v5 = __readfsqword(0x28u);
memset(v1, 0LL, 24LL);
if ( initialized )
{
return 0;
}
else
{
memset(v4, 0LL, sizeof(v4));
pthread_mutex_init(&LOCK_load_client_plugin, 0LL);
ma_init_alloc_root(mem_root, 128LL, 128LL);
memset(&plugin_list, 0LL, 64LL);
initialized = 1;
pthread_mutex_lock(&LOCK_load_client_plugin);
for ( i = &mysql_client_builtins; *i; ++i )
add_plugin(v4, *i, 0LL, 0LL, v1);
pthread_mutex_unlock(&LOCK_load_client_plugin);
load_env_plugins(v4);
return 0;
}
}
|
mysql_client_plugin_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x540
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
LEA RDI,[RBP + -0x530]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x00117330
CMP byte ptr [0x00165b70],0x0
JZ 0x001452a3
MOV dword ptr [RBP + -0x504],0x0
JMP 0x00145374
LAB_001452a3:
LEA RDI,[RBP + -0x500]
XOR ESI,ESI
MOV EDX,0x4f8
CALL 0x00117330
LEA RDI,[0x165b78]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001178a0
LEA RDI,[0x165ba0]
MOV EDX,0x80
MOV RSI,RDX
CALL 0x0012f470
LEA RDI,[0x165be0]
XOR ESI,ESI
MOV EDX,0x40
CALL 0x00117330
MOV byte ptr [0x00165b70],0x1
LEA RDI,[0x165b78]
CALL 0x00117880
LEA RAX,[0x164070]
MOV qword ptr [RBP + -0x510],RAX
LAB_0014530e:
MOV RAX,qword ptr [RBP + -0x510]
CMP qword ptr [RAX],0x0
JZ 0x00145352
MOV RAX,qword ptr [RBP + -0x510]
MOV RSI,qword ptr [RAX]
LEA R8,[RBP + -0x530]
LEA RDI,[RBP + -0x500]
XOR EAX,EAX
MOV EDX,EAX
XOR ECX,ECX
CALL 0x001453b0
MOV RAX,qword ptr [RBP + -0x510]
ADD RAX,0x8
MOV qword ptr [RBP + -0x510],RAX
JMP 0x0014530e
LAB_00145352:
LEA RDI,[0x165b78]
CALL 0x00117430
LEA RDI,[RBP + -0x500]
CALL 0x001455e0
MOV dword ptr [RBP + -0x504],0x0
LAB_00145374:
MOV EAX,dword ptr [RBP + -0x504]
MOV dword ptr [RBP + -0x534],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001453a1
MOV EAX,dword ptr [RBP + -0x534]
ADD RSP,0x540
POP RBP
RET
LAB_001453a1:
CALL 0x00117690
|
int4 mysql_client_plugin_init(void)
{
long in_FS_OFFSET;
int1 local_538 [32];
int **local_518;
int4 local_50c;
int1 local_508 [1272];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
memset(local_538,0,0x18);
if (initialized == '\0') {
memset(local_508,0,0x4f8);
pthread_mutex_init((pthread_mutex_t *)LOCK_load_client_plugin,(pthread_mutexattr_t *)0x0);
ma_init_alloc_root(mem_root);
memset(plugin_list,0,0x40);
initialized = '\x01';
pthread_mutex_lock((pthread_mutex_t *)LOCK_load_client_plugin);
for (local_518 = &mysql_client_builtins; *local_518 != (int *)0x0;
local_518 = local_518 + 1) {
add_plugin(local_508,*local_518,0,0,local_538);
}
pthread_mutex_unlock((pthread_mutex_t *)LOCK_load_client_plugin);
load_env_plugins(local_508);
}
local_50c = 0;
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return 0;
}
|
|
57,749
|
fmt::v10::detail::compare(fmt::v10::detail::bigint const&, fmt::v10::detail::bigint const&)
|
AlayaLite/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/core.h
|
constexpr auto size() const noexcept -> size_t { return size_; }
|
O3
|
c
|
fmt::v10::detail::compare(fmt::v10::detail::bigint const&, fmt::v10::detail::bigint const&):
movq 0x10(%rdi), %r9
testq %r9, %r9
je 0x4812a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rdi, %rbx
movq 0x8(%rdi), %r10
movq %rdx, %r11
shrq $0x20, %r11
shlq $0x20, %rcx
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movl (%r10,%r12,4), %r8d
movq %r8, %rax
mulq %rsi
movq %rdx, %rdi
movl %r14d, %r13d
addq %rax, %r13
adcq $0x0, %rdi
movq %r11, %rbp
imulq %r8, %rbp
movq %rcx, %rax
mulq %r8
addq %rbp, %rdx
movq %rdi, %r8
shldq $0x20, %r13, %rdi
shrq $0x20, %r8
shrdq $0x20, %r15, %r14
shrq $0x20, %r15
addq %rax, %r14
adcq %rdx, %r15
addq %rdi, %r14
adcq %r8, %r15
movl %r13d, (%r10,%r12,4)
incq %r12
cmpq %r12, %r9
jne 0x48086
movq %r14, %rax
orq %r15, %rax
je 0x4811c
leaq 0x1(%r9), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x480fc
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %r9
leaq 0x1(%r9), %rsi
movq 0x8(%rbx), %rax
movq %rsi, 0x10(%rbx)
movl %r14d, (%rax,%r9,4)
shrdq $0x20, %r15, %r14
shrq $0x20, %r15
movq %r14, %rax
orq %r15, %rax
movq %rsi, %r9
jne 0x480e2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN3fmt3v106detail6bigint8multiplyIoTnNSt9enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS5_oEE5valueEiE4typeELi0EEEvS5_:
mov r9, [rdi+10h]
test r9, r9
jz locret_4812A
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rcx, rdx
mov rbx, rdi
mov r10, [rdi+8]
mov r11, rdx
shr r11, 20h
shl rcx, 20h
xor r14d, r14d
xor r15d, r15d
xor r12d, r12d
loc_48086:
mov r8d, [r10+r12*4]
mov rax, r8
mul rsi
mov rdi, rdx
mov r13d, r14d
add r13, rax
adc rdi, 0
mov rbp, r11
imul rbp, r8
mov rax, rcx
mul r8
add rdx, rbp
mov r8, rdi
shld rdi, r13, 20h
shr r8, 20h
shrd r14, r15, 20h
shr r15, 20h
add r14, rax
adc r15, rdx
add r14, rdi
adc r15, r8
mov [r10+r12*4], r13d
inc r12
cmp r9, r12
jnz short loc_48086
mov rax, r14
or rax, r15
jz short loc_4811C
loc_480E2:
lea rsi, [r9+1]
cmp [rbx+18h], rsi
jnb short loc_480FC
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov r9, [rbx+10h]
lea rsi, [r9+1]
loc_480FC:
mov rax, [rbx+8]
mov [rbx+10h], rsi
mov [rax+r9*4], r14d
shrd r14, r15, 20h
shr r15, 20h
mov rax, r14
or rax, r15
mov r9, rsi
jnz short loc_480E2
loc_4811C:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_4812A:
retn
|
long long ZN3fmt3v106detail6bigint8multiplyIoTnNSt9enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS5_oEE5valueEiE4typeELi0EEEvS5_(
long long a1,
unsigned long long a2,
unsigned long long a3)
{
long long v3; // r9
long long v4; // r10
long long v5; // r12
signed __int128 v6; // kr10_16
unsigned __int128 v7; // kr00_16
long long result; // rax
long long v9; // rsi
long long v10; // rax
unsigned long long v11; // r14
unsigned __int128 v12; // rt0
v3 = *(_QWORD *)(a1 + 16);
if ( v3 )
{
v4 = *(_QWORD *)(a1 + 8);
v5 = 0LL;
v6 = 0uLL;
do
{
v7 = a2 * (unsigned __int128)*(unsigned int *)(v4 + 4 * v5) + (unsigned int)v6;
v6 = (v7 >> 32)
+ __PAIR128__(HIDWORD(a3), a3 << 32) * *(unsigned int *)(v4 + 4 * v5)
+ ((unsigned __int128)v6 >> 32);
*(_DWORD *)(v4 + 4 * v5++) = v7;
}
while ( v3 != v5 );
result = *((_QWORD *)&v6 + 1) | v6;
if ( v6 != 0 )
{
do
{
v9 = v3 + 1;
if ( *(_QWORD *)(a1 + 24) < (unsigned long long)(v3 + 1) )
{
(**(void ( ***)(long long))a1)(a1);
v3 = *(_QWORD *)(a1 + 16);
v9 = v3 + 1;
}
v10 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 16) = v9;
*(_DWORD *)(v10 + 4 * v3) = v6;
v12 = v6;
v11 = v6 >> 32;
result = HIDWORD(*((_QWORD *)&v6 + 1)) | v11;
v3 = v9;
v6 = __PAIR128__(HIDWORD(*((_QWORD *)&v6 + 1)), v11);
}
while ( v12 >> 32 != 0 );
}
}
return result;
}
|
_ZN3fmt3v106detail6bigint8multiplyIoTnNSt9enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS5_oEE5valueEiE4typeELi0EEEvS5_:
MOV R9,qword ptr [RDI + 0x10]
TEST R9,R9
JZ 0x0014812a
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RCX,RDX
MOV RBX,RDI
MOV R10,qword ptr [RDI + 0x8]
MOV R11,RDX
SHR R11,0x20
SHL RCX,0x20
XOR R14D,R14D
XOR R15D,R15D
XOR R12D,R12D
LAB_00148086:
MOV R8D,dword ptr [R10 + R12*0x4]
MOV RAX,R8
MUL RSI
MOV RDI,RDX
MOV R13D,R14D
ADD R13,RAX
ADC RDI,0x0
MOV RBP,R11
IMUL RBP,R8
MOV RAX,RCX
MUL R8
ADD RDX,RBP
MOV R8,RDI
SHLD RDI,R13,0x20
SHR R8,0x20
SHRD R14,R15,0x20
SHR R15,0x20
ADD R14,RAX
ADC R15,RDX
ADD R14,RDI
ADC R15,R8
MOV dword ptr [R10 + R12*0x4],R13D
INC R12
CMP R9,R12
JNZ 0x00148086
MOV RAX,R14
OR RAX,R15
JZ 0x0014811c
LAB_001480e2:
LEA RSI,[R9 + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x001480fc
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV R9,qword ptr [RBX + 0x10]
LEA RSI,[R9 + 0x1]
LAB_001480fc:
MOV RAX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV dword ptr [RAX + R9*0x4],R14D
SHRD R14,R15,0x20
SHR R15,0x20
MOV RAX,R14
OR RAX,R15
MOV R9,RSI
JNZ 0x001480e2
LAB_0014811c:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_0014812a:
RET
|
void _ZN3fmt3v106detail6bigint8multiplyIoTnNSt9enable_ifIXoosr3std7is_sameIT_mEE5valuesr3std7is_sameIS5_oEE5valueEiE4typeELi0EEEvS5_
(int8 *param_1,ulong param_2,ulong param_3)
{
long lVar1;
int1 auVar2 [16];
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
ulong uVar9;
ulong uVar10;
ulong uVar11;
uVar10 = param_1[2];
if (uVar10 != 0) {
lVar1 = param_1[1];
auVar7 = ZEXT816(0);
uVar11 = 0;
do {
uVar9 = CONCAT44(0,*(uint *)(lVar1 + uVar11 * 4));
auVar2._8_8_ = 0;
auVar2._0_8_ = uVar9;
auVar4._8_8_ = 0;
auVar4._0_8_ = param_2;
auVar6._8_8_ = 0;
auVar6._0_8_ = auVar7._0_8_ & 0xffffffff;
auVar6 = auVar2 * auVar4 + auVar6;
auVar3._8_8_ = 0;
auVar3._0_8_ = param_3 << 0x20;
auVar5._8_8_ = 0;
auVar5._0_8_ = uVar9;
auVar8._8_8_ = SUB168(auVar3 * auVar5,8) + (param_3 >> 0x20) * uVar9;
auVar8._0_8_ = SUB168(auVar3 * auVar5,0);
auVar7 = (auVar6 >> 0x20) + (auVar7 >> 0x20) + auVar8;
*(int *)(lVar1 + uVar11 * 4) = auVar6._0_4_;
uVar11 = uVar11 + 1;
} while (uVar10 != uVar11);
if (auVar7._0_8_ != 0 || auVar7._8_8_ != 0) {
do {
uVar9 = auVar7._0_8_;
uVar11 = uVar10 + 1;
if ((ulong)param_1[3] < uVar11) {
(**(code **)*param_1)(param_1);
uVar10 = param_1[2];
uVar11 = uVar10 + 1;
}
param_1[2] = uVar11;
*(int *)(param_1[1] + uVar10 * 4) = auVar7._0_4_;
auVar3 = auVar7 & (int1 [16])0xffffffff;
auVar2 = auVar7 >> 0x20;
auVar7 = auVar7 >> 0x20;
uVar10 = uVar11;
} while ((uVar9 >> 0x20 != 0 || auVar3 != (int1 [16])0x0) || auVar2._8_8_ != 0);
}
}
return;
}
|
|
57,750
|
Elevetor::qt_static_metacall(QObject*, QMetaObject::Call, int, void**)
|
LeafBlue[P]myElevetor/build_O1/myElevetor_autogen/EWIEGA46WW/moc_elevetor.cpp
|
void Elevetor::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
auto *_t = static_cast<Elevetor *>(_o);
(void)_t;
switch (_id) {
case 0: _t->send_update((*reinterpret_cast< std::add_pointer_t<Elevetor&>>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
{
using _t = void (Elevetor::*)(Elevetor & );
if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&Elevetor::send_update)) {
*result = 0;
return;
}
}
}
}
|
O1
|
cpp
|
Elevetor::qt_static_metacall(QObject*, QMetaObject::Call, int, void**):
cmpl $0x5, %esi
je 0x493a
testl %esi, %esi
jne 0x4939
testl %edx, %edx
je 0x495b
retq
movq 0x8(%rcx), %rax
movq (%rax), %rdx
cmpq 0xb668(%rip), %rdx # 0xffb0
jne 0x4939
cmpq $0x0, 0x8(%rax)
jne 0x4939
movq (%rcx), %rax
movl $0x0, (%rax)
retq
subq $0x18, %rsp
movq 0x8(%rcx), %rax
movq %rsp, %rcx
movq $0x0, (%rcx)
movq %rax, 0x8(%rcx)
leaq 0xb080(%rip), %rsi # 0xf9f8
xorl %edx, %edx
callq 0x4180
addq $0x18, %rsp
retq
|
_ZN8Elevetor18qt_static_metacallEP7QObjectN11QMetaObject4CallEiPPv:
cmp esi, 5
jz short loc_493A
test esi, esi
jnz short locret_4939
test edx, edx
jz short loc_495B
locret_4939:
retn
loc_493A:
mov rax, [rcx+8]
mov rdx, [rax]
cmp rdx, cs:_ZN8Elevetor11send_updateERS__ptr
jnz short locret_4939
cmp qword ptr [rax+8], 0
jnz short locret_4939
mov rax, [rcx]
mov dword ptr [rax], 0
retn
loc_495B:
sub rsp, 18h
mov rax, [rcx+8]
mov rcx, rsp; int
mov qword ptr [rcx], 0
mov [rcx+8], rax
lea rsi, _ZN8Elevetor16staticMetaObjectE; QObject *
xor edx, edx; QMetaObject *
call __ZN11QMetaObject8activateEP7QObjectPKS_iPPv; QMetaObject::activate(QObject *,QMetaObject const*,int,void **)
add rsp, 18h
retn
|
void Elevetor::qt_static_metacall(QMetaObject *a1, int a2, int a3, long long a4, void **a5)
{
long long v5; // rax
long long v6; // rax
_QWORD v7[3]; // [rsp-18h] [rbp-18h] BYREF
if ( a2 == 5 )
{
v5 = *(_QWORD *)(a4 + 8);
if ( *(long long ( **)(Elevetor *__hidden, Elevetor *))v5 == Elevetor::send_update && !*(_QWORD *)(v5 + 8) )
**(_DWORD **)a4 = 0;
}
else if ( !a2 && !a3 )
{
v6 = *(_QWORD *)(a4 + 8);
v7[0] = 0LL;
v7[1] = v6;
QMetaObject::activate(a1, (QObject *)&Elevetor::staticMetaObject, 0LL, (int)v7, a5);
}
}
|
qt_static_metacall:
CMP ESI,0x5
JZ 0x0010493a
TEST ESI,ESI
JNZ 0x00104939
TEST EDX,EDX
JZ 0x0010495b
LAB_00104939:
RET
LAB_0010493a:
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,qword ptr [RAX]
CMP RDX,qword ptr [0x0010ffb0]
JNZ 0x00104939
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x00104939
MOV RAX,qword ptr [RCX]
MOV dword ptr [RAX],0x0
RET
LAB_0010495b:
SUB RSP,0x18
MOV RAX,qword ptr [RCX + 0x8]
MOV RCX,RSP
MOV qword ptr [RCX],0x0
MOV qword ptr [RCX + 0x8],RAX
LEA RSI,[0x10f9f8]
XOR EDX,EDX
CALL 0x00104180
ADD RSP,0x18
RET
|
/* Elevetor::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) */
void Elevetor::qt_static_metacall(QObject *param_1,int param_2,int param_3,int8 *param_4)
{
void *local_18;
int8 local_10;
if (param_2 == 5) {
if ((*(int **)param_4[1] == PTR_send_update_0010ffb0) && (((long *)param_4[1])[1] == 0)) {
*(int4 *)*param_4 = 0;
return;
}
}
else if ((param_2 == 0) && (param_3 == 0)) {
local_10 = param_4[1];
local_18 = (void *)0x0;
QMetaObject::activate(param_1,(QMetaObject *)staticMetaObject,0,&local_18);
return;
}
return;
}
|
|
57,751
|
my_tell
|
eloqsql/mysys/my_seek.c
|
my_off_t my_tell(File fd, myf MyFlags)
{
os_off_t pos;
DBUG_ENTER("my_tell");
DBUG_PRINT("my",("fd: %d MyFlags: %lu",fd, MyFlags));
DBUG_ASSERT(fd >= 0);
#if defined (HAVE_TELL) && !defined (_WIN32) && !defined(_AIX)
pos= tell(fd);
#else
pos= my_seek(fd, 0L, MY_SEEK_CUR,0);
#endif
if (pos == (os_off_t) -1)
{
my_errno= errno;
if (MyFlags & MY_WME)
my_error(EE_CANT_SEEK, MYF(0), my_filename(fd), my_errno);
DBUG_PRINT("error", ("tell: %llu errno: %d", (ulonglong) pos, my_errno));
}
DBUG_PRINT("exit",("pos: %llu", (ulonglong) pos));
DBUG_RETURN((my_off_t) pos);
}
|
O0
|
c
|
my_tell:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xfc9e1
jmp 0xfc9e3
jmp 0xfc9e5
movl -0x4(%rbp), %edi
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
movq %rcx, %rsi
callq 0xfc910
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0xfca53
callq 0x29700
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
callq 0xfdd30
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0xfca4d
movl -0x4(%rbp), %edi
callq 0x10b180
movq %rax, -0x28(%rbp)
callq 0xfdd30
movq -0x28(%rbp), %rdx
movl (%rax), %ecx
movl $0x21, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0xf76a0
jmp 0xfca4f
jmp 0xfca51
jmp 0xfca53
jmp 0xfca55
jmp 0xfca57
jmp 0xfca59
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
my_tell:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
jmp short $+2
loc_FC9E1:
jmp short $+2
loc_FC9E3:
jmp short $+2
loc_FC9E5:
mov edi, [rbp+var_4]
xor eax, eax
mov ecx, eax
mov edx, 1
mov rsi, rcx
call my_seek
mov [rbp+var_18], rax
cmp [rbp+var_18], 0FFFFFFFFFFFFFFFFh
jnz short loc_FCA53
call ___errno_location
mov eax, [rax]
mov [rbp+var_1C], eax
call _my_thread_var
mov ecx, [rbp+var_1C]
mov [rax], ecx
mov rax, [rbp+var_10]
and rax, 10h
cmp rax, 0
jz short loc_FCA4D
mov edi, [rbp+var_4]
call my_filename
mov [rbp+var_28], rax
call _my_thread_var
mov rdx, [rbp+var_28]
mov ecx, [rax]
mov edi, 21h ; '!'
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_FCA4D:
jmp short $+2
loc_FCA4F:
jmp short $+2
loc_FCA51:
jmp short $+2
loc_FCA53:
jmp short $+2
loc_FCA55:
jmp short $+2
loc_FCA57:
jmp short $+2
loc_FCA59:
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
add rsp, 30h
pop rbp
retn
|
long long my_tell(unsigned int a1, char a2)
{
unsigned int *v2; // rax
long long v4; // [rsp+8h] [rbp-28h]
int v5; // [rsp+14h] [rbp-1Ch]
long long v6; // [rsp+18h] [rbp-18h]
v6 = my_seek(a1, 0LL, 1u, 0);
if ( v6 == -1 )
{
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a1, 0LL) = v5;
if ( (a2 & 0x10) != 0 )
{
v4 = my_filename(a1);
v2 = (unsigned int *)my_thread_var(a1, 0LL);
my_error(0x21u, 0LL, v4, *v2);
}
}
return v6;
}
|
my_tell:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x001fc9e1
LAB_001fc9e1:
JMP 0x001fc9e3
LAB_001fc9e3:
JMP 0x001fc9e5
LAB_001fc9e5:
MOV EDI,dword ptr [RBP + -0x4]
XOR EAX,EAX
MOV ECX,EAX
MOV EDX,0x1
MOV RSI,RCX
CALL 0x001fc910
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],-0x1
JNZ 0x001fca53
CALL 0x00129700
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
CALL 0x001fdd30
MOV ECX,dword ptr [RBP + -0x1c]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x10
CMP RAX,0x0
JZ 0x001fca4d
MOV EDI,dword ptr [RBP + -0x4]
CALL 0x0020b180
MOV qword ptr [RBP + -0x28],RAX
CALL 0x001fdd30
MOV RDX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX]
MOV EDI,0x21
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x001f76a0
LAB_001fca4d:
JMP 0x001fca4f
LAB_001fca4f:
JMP 0x001fca51
LAB_001fca51:
JMP 0x001fca53
LAB_001fca53:
JMP 0x001fca55
LAB_001fca55:
JMP 0x001fca57
LAB_001fca57:
JMP 0x001fca59
LAB_001fca59:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x30
POP RBP
RET
|
long my_tell(int4 param_1,ulong param_2)
{
int iVar1;
long lVar2;
int *piVar3;
int8 uVar4;
int4 *puVar5;
lVar2 = my_seek(param_1,0,1);
if (lVar2 == -1) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((param_2 & 0x10) != 0) {
uVar4 = my_filename(param_1);
puVar5 = (int4 *)_my_thread_var();
my_error(0x21,0,uVar4,*puVar5);
}
}
return lVar2;
}
|
|
57,752
|
nlohmann::json_abi_v3_11_3::detail::serializer<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>>::hex_bytes(unsigned char)
|
monkey531[P]llama/common/./json.hpp
|
static std::string hex_bytes(std::uint8_t byte)
{
std::string result = "FF";
constexpr const char* nibble_to_hex = "0123456789ABCDEF";
result[0] = nibble_to_hex[byte / 16];
result[1] = nibble_to_hex[byte % 16];
return result;
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::serializer<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>>::hex_bytes(unsigned char):
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x531c0(%rip), %rsi # 0xbbe85
leaq 0x531bb(%rip), %rdx # 0xbbe87
callq 0x5abde
movl %ebx, %eax
shrl $0x4, %eax
leaq 0x57297(%rip), %rcx # 0xbff74
movb (%rax,%rcx), %al
movq (%r14), %rdx
movb %al, (%rdx)
andl $0xf, %ebx
movb (%rbx,%rcx), %al
movq (%r14), %rcx
movb %al, 0x1(%rcx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9hex_bytesEh:
push r14
push rbx
push rax
mov ebx, esi
mov r14, rdi
lea rax, [rdi+10h]
mov [rdi], rax
lea rsi, aInvalidStringS_0+41h; "FF"
lea rdx, aInvalidStringS_0+43h; ""
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 eax, ebx
shr eax, 4
lea rcx, a0123456789abcd; "0123456789ABCDEF"
mov al, [rax+rcx]
mov rdx, [r14]
mov [rdx], al
and ebx, 0Fh
mov al, [rbx+rcx]
mov rcx, [r14]
mov [rcx+1], al
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
|
_QWORD * nlohmann::json_abi_v3_11_3::detail::serializer<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>>::hex_bytes(
_QWORD *a1,
unsigned int a2)
{
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "FF", (long long)"");
*(_BYTE *)*a1 = a0123456789abcd[a2 >> 4];
*(_BYTE *)(*a1 + 1LL) = a0123456789abcd[a2 & 0xF];
return a1;
}
|
hex_bytes:
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
LEA RSI,[0x1bbe85]
LEA RDX,[0x1bbe87]
CALL 0x0015abde
MOV EAX,EBX
SHR EAX,0x4
LEA RCX,[0x1bff74]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV RDX,qword ptr [R14]
MOV byte ptr [RDX],AL
AND EBX,0xf
MOV AL,byte ptr [RBX + RCX*0x1]
MOV RCX,qword ptr [R14]
MOV byte ptr [RCX + 0x1],AL
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* nlohmann::json_abi_v3_11_3::detail::serializer<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> >::hex_bytes(unsigned char) */
serializer<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>>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
serializer<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>>
::hex_bytes(serializer<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,uchar param_1)
{
int7 in_register_00000031;
*(serializer<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 = this + 0x10;
std::__cxx11::string::_M_construct<char_const*>(this,"FF","");
**(char **)this = "0123456789ABCDEF"[(CONCAT71(in_register_00000031,param_1) & 0xffffffff) >> 4];
*(char *)(*(long *)this + 1) =
"0123456789ABCDEF"[(uint)CONCAT71(in_register_00000031,param_1) & 0xf];
return this;
}
|
|
57,753
|
spell_sindragosa_instability_aura::Register()
|
SylCore-WoTLK/src/server/scripts/Northrend/IcecrownCitadel/boss_sindragosa.cpp
|
void Register() override
{
AfterEffectRemove += AuraEffectRemoveFn(spell_sindragosa_instability_aura::OnRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
}
|
O3
|
cpp
|
spell_sindragosa_instability_aura::Register():
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8e(%rip), %rsi # 0x68b324
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x4, %r8d
movl $0x1, %r9d
callq 0xee5a76
leaq 0x112ad4e(%rip), %rax # 0x17b6008
movq %rax, (%r14)
movzwl 0xa(%r14), %ebp
movb 0x8(%r14), %r12b
leaq 0x118(%rbx), %r15
movl $0x38, %edi
callq 0x10a2258
movw %bp, 0x1a(%rax)
movb %r12b, 0x18(%rax)
leaq 0x1098f8a(%rip), %rcx # 0x1724270
movq %rcx, 0x10(%rax)
movups 0x10(%r14), %xmm0
movups %xmm0, 0x20(%rax)
movl 0x20(%r14), %ecx
movl %ecx, 0x30(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x45c2d0
incq 0x128(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN33spell_sindragosa_instability_aura8RegisterEv:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 30h
mov rbx, rdi
lea rsi, _ZN33spell_sindragosa_instability_aura8OnRemoveEPK10AuraEffect21AuraEffectHandleModes; spell_sindragosa_instability_aura::OnRemove(AuraEffect const*,AuraEffectHandleModes)
lea r14, [rsp+58h+var_50]
mov rdi, r14
xor edx, edx
xor ecx, ecx
mov r8d, 4
mov r9d, 1
call _ZN10AuraScript18EffectApplyHandlerC2EMS_FvPK10AuraEffect21AuraEffectHandleModesEhtS4_; AuraScript::EffectApplyHandler::EffectApplyHandler(void (AuraScript::*)(AuraEffect const*,AuraEffectHandleModes),uchar,ushort,AuraEffectHandleModes)
lea rax, off_17B6008
mov [r14], rax
movzx ebp, word ptr [r14+0Ah]
mov r12b, [r14+8]
lea r15, [rbx+118h]
mov edi, 38h ; '8'; unsigned __int64
call _Znwm; operator new(ulong)
mov [rax+1Ah], bp
mov [rax+18h], r12b
lea rcx, off_1724270
mov [rax+10h], rcx
movups xmm0, xmmword ptr [r14+10h]
movups xmmword ptr [rax+20h], xmm0
mov ecx, [r14+20h]
mov [rax+30h], ecx
mov rdi, rax; this
mov rsi, r15; std::__detail::_List_node_base *
call __ZNSt8__detail15_List_node_base7_M_hookEPS0_; std::__detail::_List_node_base::_M_hook(std::__detail::_List_node_base*)
inc qword ptr [rbx+128h]
add rsp, 30h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long spell_sindragosa_instability_aura::Register(spell_sindragosa_instability_aura *this)
{
__int16 v1; // bp
char v2; // r12
long long v3; // rax
long long result; // rax
void ( **v5)(_SpellScript::EffectHook *__hidden); // [rsp+8h] [rbp-50h] BYREF
char v6; // [rsp+10h] [rbp-48h]
__int16 v7; // [rsp+12h] [rbp-46h]
__int128 v8; // [rsp+18h] [rbp-40h]
int v9; // [rsp+28h] [rbp-30h]
AuraScript::EffectApplyHandler::EffectApplyHandler(
&v5,
spell_sindragosa_instability_aura::OnRemove,
0LL,
0LL,
4LL,
1LL);
v5 = off_17B6008;
v1 = v7;
v2 = v6;
v3 = operator new(0x38uLL);
*(_WORD *)(v3 + 26) = v1;
*(_BYTE *)(v3 + 24) = v2;
*(_QWORD *)(v3 + 16) = off_1724270;
*(_OWORD *)(v3 + 32) = v8;
*(_DWORD *)(v3 + 48) = v9;
result = std::__detail::_List_node_base::_M_hook(
(std::__detail::_List_node_base *)v3,
(spell_sindragosa_instability_aura *)((char *)this + 280));
++*((_QWORD *)this + 37);
return result;
}
|
OnQuestAccept:
CMP dword ptr [RCX + 0x244],0x16bd
JNZ 0x0068b2c8
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,qword ptr [RDX + 0x4f8]
MOV RDI,RSI
XOR ESI,ESI
CALL 0x00b97f5e
MOV R15,RAX
MOV RDI,RBX
MOV ESI,0x37
CALL 0x00b96762
MOV RCX,qword ptr [R14]
MOV RDI,R14
MOV RSI,R15
MOV EDX,EAX
CALL qword ptr [RCX + 0x58]
POP RBX
POP R14
POP R15
LAB_0068b2c8:
MOV AL,0x1
RET
|
/* npc_cork_gizelton::OnQuestAccept(Player*, Creature*, Quest const*) */
int4 __thiscall
npc_cork_gizelton::OnQuestAccept
(npc_cork_gizelton *this,Player *param_1,Creature *param_2,Quest *param_3)
{
long *plVar1;
int8 uVar2;
int4 uVar3;
if (*(int *)(param_3 + 0x244) == 0x16bd) {
plVar1 = *(long **)(param_2 + 0x4f8);
uVar2 = Object::GetGuidValue((Object *)param_1,0);
uVar3 = Object::GetUInt32Value((Object *)param_1,0x37);
(**(code **)(*plVar1 + 0x58))(plVar1,uVar2,uVar3);
}
return 1;
}
|
|
57,754
|
minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling)
|
monkey531[P]llama/common/minja.hpp
|
std::string consumeToken(const std::string & token, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
if (std::distance(it, end) >= (int64_t) token.size() && std::string(it, it + token.size()) == token) {
it += token.size();
return token;
}
it = start;
return "";
}
|
O1
|
cpp
|
minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq %rax, (%rsp)
movq %rsi, %rdi
movl %ecx, %esi
callq 0x8660c
movq 0x18(%r15), %rbp
movq 0x20(%r15), %rsi
subq %rsi, %rbp
movq 0x8(%r14), %r13
cmpq %r13, %rbp
jl 0x85d56
leaq (%rsi,%r13), %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x71746
movq 0x8(%r12), %rdx
cmpq 0x8(%r14), %rdx
jne 0x85d56
testq %rdx, %rdx
je 0x85dd0
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x1b940
testl %eax, %eax
sete %r12b
jmp 0x85d59
xorl %r12d, %r12d
cmpq %r13, %rbp
jl 0x85d79
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x85d79
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b900
testb %r12b, %r12b
je 0x85d9d
movq 0x8(%r14), %rdx
addq %rdx, 0x20(%r15)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x238f0
jmp 0x85dbe
movq (%rsp), %rax
movq %rax, 0x20(%r15)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x63a9d(%rip), %rdx # 0xe9850
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2367c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r12b
jmp 0x85d59
|
_ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rax, [rsi+20h]
mov [rsp+58h+var_58], rax
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
mov rbp, [r15+18h]
mov rsi, [r15+20h]
sub rbp, rsi
mov r13, [r14+8]
cmp rbp, r13
jl short loc_85D56
lea rdx, [rsi+r13]
lea rax, [rsp+58h+var_40]
mov [rax-10h], rax
lea r12, [rsp+58h+var_50]
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
mov rdx, [r12+8]
cmp rdx, [r14+8]
jnz short loc_85D56
test rdx, rdx
jz loc_85DD0
mov rsi, [r14]
mov rdi, [rsp+58h+var_50]
call _bcmp
test eax, eax
setz r12b
jmp short loc_85D59
loc_85D56:
xor r12d, r12d
loc_85D59:
cmp rbp, r13
jl short loc_85D79
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_85D79
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_85D79:
test r12b, r12b
jz short loc_85D9D
mov rdx, [r14+8]
add [r15+20h], rdx
lea rax, [rbx+10h]
mov [rbx], rax
mov rsi, [r14]
add rdx, rsi
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
jmp short loc_85DBE
loc_85D9D:
mov rax, [rsp+58h+var_58]
mov [r15+20h], rax
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aProcessingRequ+19h; ""
mov rdi, rbx
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_85DBE:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_85DD0:
mov r12b, 1
jmp short loc_85D59
|
_QWORD * minja::Parser::consumeToken(_QWORD *a1, long long a2, _BYTE **a3, unsigned int a4)
{
_BYTE *v6; // rsi
long long v7; // rbp
_BYTE *v8; // r13
bool v9; // r12
_BYTE *v10; // rdx
long long v12; // [rsp+0h] [rbp-58h]
_QWORD *v13; // [rsp+8h] [rbp-50h] BYREF
_BYTE *v14; // [rsp+10h] [rbp-48h]
_QWORD v15[8]; // [rsp+18h] [rbp-40h] BYREF
v12 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v6 = *(_BYTE **)(a2 + 32);
v7 = *(_QWORD *)(a2 + 24) - (_QWORD)v6;
v8 = a3[1];
if ( v7 >= (long long)v8
&& (v13 = v15,
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(
&v13,
v6,
(long long)&v8[(_QWORD)v6]),
v14 == a3[1]) )
{
if ( v14 )
v9 = (unsigned int)bcmp(v13, *a3) == 0;
else
v9 = 1;
}
else
{
v9 = 0;
}
if ( v7 >= (long long)v8 && v13 != v15 )
operator delete(v13, v15[0] + 1LL);
if ( v9 )
{
v10 = a3[1];
*(_QWORD *)(a2 + 32) += v10;
*a1 = a1 + 2;
std::string::_M_construct<char *>(a1, *a3, (long long)&v10[(_QWORD)*a3]);
}
else
{
*(_QWORD *)(a2 + 32) = v12;
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "", (long long)"");
}
return a1;
}
|
consumeToken:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x20]
MOV qword ptr [RSP],RAX
MOV RDI,RSI
MOV ESI,ECX
CALL 0x0018660c
MOV RBP,qword ptr [R15 + 0x18]
MOV RSI,qword ptr [R15 + 0x20]
SUB RBP,RSI
MOV R13,qword ptr [R14 + 0x8]
CMP RBP,R13
JL 0x00185d56
LEA RDX,[RSI + R13*0x1]
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x00171746
MOV RDX,qword ptr [R12 + 0x8]
CMP RDX,qword ptr [R14 + 0x8]
JNZ 0x00185d56
TEST RDX,RDX
JZ 0x00185dd0
MOV RSI,qword ptr [R14]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011b940
TEST EAX,EAX
SETZ R12B
JMP 0x00185d59
LAB_00185d56:
XOR R12D,R12D
LAB_00185d59:
CMP RBP,R13
JL 0x00185d79
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00185d79
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b900
LAB_00185d79:
TEST R12B,R12B
JZ 0x00185d9d
MOV RDX,qword ptr [R14 + 0x8]
ADD qword ptr [R15 + 0x20],RDX
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RSI,qword ptr [R14]
ADD RDX,RSI
MOV RDI,RBX
CALL 0x001238f0
JMP 0x00185dbe
LAB_00185d9d:
MOV RAX,qword ptr [RSP]
MOV qword ptr [R15 + 0x20],RAX
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RDX,[0x1e9850]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x0012367c
LAB_00185dbe:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00185dd0:
MOV R12B,0x1
JMP 0x00185d59
|
/* minja::Parser::consumeToken(std::__cxx11::string const&, minja::SpaceHandling) */
long * minja::Parser::consumeToken(long *param_1,Parser *param_2,long *param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
long lVar3;
long lVar4;
int iVar5;
bool bVar6;
long *local_50;
size_t local_48;
long local_40 [2];
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
lVar2 = *(long *)(param_2 + 0x18);
lVar3 = *(long *)(param_2 + 0x20);
lVar4 = param_3[1];
if (lVar4 <= lVar2 - lVar3) {
local_50 = local_40;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(&local_50,lVar3,lVar3 + lVar4);
if (local_48 == param_3[1]) {
if (local_48 == 0) {
bVar6 = true;
}
else {
iVar5 = bcmp(local_50,(void *)*param_3,local_48);
bVar6 = iVar5 == 0;
}
goto LAB_00185d59;
}
}
bVar6 = false;
LAB_00185d59:
if ((lVar4 <= lVar2 - lVar3) && (local_50 != local_40)) {
operator_delete(local_50,local_40[0] + 1);
}
if (bVar6) {
lVar2 = param_3[1];
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + lVar2;
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char*>(param_1,*param_3,lVar2 + *param_3);
}
else {
*(int8 *)(param_2 + 0x20) = uVar1;
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char_const*>(param_1,"");
}
return param_1;
}
|
|
57,755
|
minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling)
|
monkey531[P]llama/common/minja.hpp
|
std::string consumeToken(const std::string & token, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
if (std::distance(it, end) >= (int64_t) token.size() && std::string(it, it + token.size()) == token) {
it += token.size();
return token;
}
it = start;
return "";
}
|
O2
|
cpp
|
minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %r13
movq %rsi, %rdi
movl %ecx, %esi
callq 0x61fbe
movq 0x18(%r15), %rax
movq 0x20(%r15), %rsi
subq %rsi, %rax
movq 0x8(%r14), %rdx
cmpq %rdx, %rax
jl 0x61741
addq %rsi, %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x52ed2
movq %r12, %rdi
movq %r14, %rsi
callq 0x3b048
movl %eax, %ebp
movq %r12, %rdi
callq 0x24208
testb %bpl, %bpl
je 0x61741
movq 0x8(%r14), %rax
addq %rax, 0x20(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23c40
jmp 0x61759
movq %r13, 0x20(%r15)
leaq 0x49104(%rip), %rsi # 0xaa850
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x26cb4
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov r13, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
mov rax, [r15+18h]
mov rsi, [r15+20h]
sub rax, rsi
mov rdx, [r14+8]
cmp rax, rdx
jl short loc_61741
add rdx, rsi
lea rax, [rsp+58h+var_40]
mov [rax-10h], rax
lea r12, [rsp+58h+var_50]
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
mov rdi, r12
mov rsi, r14
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
mov ebp, eax
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jz short loc_61741
mov rax, [r14+8]
add [r15+20h], rax
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
jmp short loc_61759
loc_61741:
mov [r15+20h], r13
lea rsi, aProcessingRequ+19h; ""
lea rdx, [rsp+58h+var_50]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
loc_61759:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_QWORD * minja::Parser::consumeToken(_QWORD *a1, long long a2, _QWORD *a3, unsigned int a4)
{
long long v6; // r13
_BYTE *v7; // rsi
long long v8; // rdx
bool v9; // bp
_QWORD v11[2]; // [rsp+8h] [rbp-50h] BYREF
char v12; // [rsp+18h] [rbp-40h] BYREF
v6 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v7 = *(_BYTE **)(a2 + 32);
v8 = a3[1];
if ( *(_QWORD *)(a2 + 24) - (_QWORD)v7 >= v8
&& (v11[0] = &v12,
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(
(long long)v11,
v7,
(long long)&v7[v8]),
v9 = std::operator==<char>(v11, a3),
std::string::~string(v11),
v9) )
{
*(_QWORD *)(a2 + 32) += a3[1];
std::string::basic_string(a1);
}
else
{
*(_QWORD *)(a2 + 32) = v6;
std::string::basic_string<std::allocator<char>>(a1, (long long)"");
}
return a1;
}
|
consumeToken:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV R13,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x00161fbe
MOV RAX,qword ptr [R15 + 0x18]
MOV RSI,qword ptr [R15 + 0x20]
SUB RAX,RSI
MOV RDX,qword ptr [R14 + 0x8]
CMP RAX,RDX
JL 0x00161741
ADD RDX,RSI
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x00152ed2
MOV RDI,R12
MOV RSI,R14
CALL 0x0013b048
MOV EBP,EAX
MOV RDI,R12
CALL 0x00124208
TEST BPL,BPL
JZ 0x00161741
MOV RAX,qword ptr [R14 + 0x8]
ADD qword ptr [R15 + 0x20],RAX
MOV RDI,RBX
MOV RSI,R14
CALL 0x00123c40
JMP 0x00161759
LAB_00161741:
MOV qword ptr [R15 + 0x20],R13
LEA RSI,[0x1aa850]
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00126cb4
LAB_00161759:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::Parser::consumeToken(std::__cxx11::string const&, minja::SpaceHandling) */
string * minja::Parser::consumeToken
(string *param_1,Parser *param_2,string *param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
char cVar3;
int1 *local_50 [2];
int1 local_40 [16];
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
lVar2 = *(long *)(param_2 + 0x20);
if (*(long *)(param_3 + 8) <= *(long *)(param_2 + 0x18) - lVar2) {
local_50[0] = local_40;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
((string *)local_50,lVar2,*(long *)(param_3 + 8) + lVar2);
cVar3 = std::operator==((string *)local_50,param_3);
std::__cxx11::string::~string((string *)local_50);
if (cVar3 != '\0') {
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + *(long *)(param_3 + 8);
std::__cxx11::string::string(param_1,param_3);
return param_1;
}
}
*(int8 *)(param_2 + 0x20) = uVar1;
std::__cxx11::string::string<std::allocator<char>>(param_1,"",(allocator *)local_50);
return param_1;
}
|
|
57,756
|
my_message_stderr
|
eloqsql/mysys/my_mess.c
|
void my_message_stderr(uint error __attribute__((unused)),
const char *str, myf MyFlags)
{
DBUG_ENTER("my_message_stderr");
DBUG_PRINT("enter",("message: %s",str));
(void) fflush(stdout);
if (MyFlags & (ME_NOTE | ME_ERROR_LOG_ONLY))
DBUG_VOID_RETURN;
if (MyFlags & ME_BELL)
(void) fputc('\007', stderr);
if (my_progname)
{
(void)fputs(my_progname,stderr); (void)fputs(": ",stderr);
}
(void)fputs(str,stderr);
(void)fputc('\n',stderr);
(void)fflush(stderr);
DBUG_VOID_RETURN;
}
|
O3
|
c
|
my_message_stderr:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq 0x2c7d1c(%rip), %rax # 0x2effa8
movq (%rax), %rdi
callq 0x24400
testl $0x480, %r14d # imm = 0x480
je 0x282a2
popq %rbx
popq %r14
popq %rbp
retq
testb $0x4, %r14b
je 0x282bc
movq 0x2c7d21(%rip), %rax # 0x2effd0
movq (%rax), %rsi
movl $0x7, %edi
callq 0x24460
leaq 0x33e9dd(%rip), %rax # 0x366ca0
movq (%rax), %rdi
testq %rdi, %rdi
je 0x282d0
callq 0x246f0
movq 0x2c7cf9(%rip), %r14 # 0x2effd0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x243d0
movq (%r14), %rsi
movl $0xa, %edi
callq 0x24460
movq (%r14), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x24400
nop
|
my_message_stderr:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rdx
mov rbx, rsi
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
test r14d, 480h
jz short loc_282A2
pop rbx
pop r14
pop rbp
retn
loc_282A2:
test r14b, 4
jz short loc_282BC
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov edi, 7
call _fputc
loc_282BC:
lea rax, my_progname
mov rdi, [rax]
test rdi, rdi
jz short loc_282D0
call my_message_stderr_cold_1
loc_282D0:
mov r14, cs:stderr_ptr
mov rsi, [r14]
mov rdi, rbx
call _fputs
mov rsi, [r14]
mov edi, 0Ah
call _fputc
mov rdi, [r14]
pop rbx
pop r14
pop rbp
jmp _fflush
|
long long my_message_stderr(long long a1, long long a2, __int16 a3)
{
long long result; // rax
result = fflush(stdout);
if ( (a3 & 0x480) == 0 )
{
if ( (a3 & 4) != 0 )
fputc(7LL, stderr);
if ( my_progname )
my_message_stderr_cold_1((long long)my_progname);
fputs(a2, stderr);
fputc(10LL, stderr);
return fflush(stderr);
}
return result;
}
|
my_message_stderr:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RDX
MOV RBX,RSI
MOV RAX,qword ptr [0x003effa8]
MOV RDI,qword ptr [RAX]
CALL 0x00124400
TEST R14D,0x480
JZ 0x001282a2
POP RBX
POP R14
POP RBP
RET
LAB_001282a2:
TEST R14B,0x4
JZ 0x001282bc
MOV RAX,qword ptr [0x003effd0]
MOV RSI,qword ptr [RAX]
MOV EDI,0x7
CALL 0x00124460
LAB_001282bc:
LEA RAX,[0x466ca0]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x001282d0
CALL 0x001246f0
LAB_001282d0:
MOV R14,qword ptr [0x003effd0]
MOV RSI,qword ptr [R14]
MOV RDI,RBX
CALL 0x001243d0
MOV RSI,qword ptr [R14]
MOV EDI,0xa
CALL 0x00124460
MOV RDI,qword ptr [R14]
POP RBX
POP R14
POP RBP
JMP 0x00124400
|
void my_message_stderr(int8 param_1,char *param_2,ulong param_3)
{
int *puVar1;
fflush(*(FILE **)PTR_stdout_003effa8);
if ((param_3 & 0x480) != 0) {
return;
}
if ((param_3 & 4) != 0) {
fputc(7,*(FILE **)PTR_stderr_003effd0);
}
if (my_progname != 0) {
my_message_stderr_cold_1();
}
puVar1 = PTR_stderr_003effd0;
fputs(param_2,*(FILE **)PTR_stderr_003effd0);
fputc(10,*(FILE **)puVar1);
fflush(*(FILE **)puVar1);
return;
}
|
|
57,757
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::reset()
|
monkey531[P]llama/common/json.hpp
|
void reset() noexcept
{
token_buffer.clear();
token_string.clear();
token_string.push_back(char_traits<char_type>::to_char_type(current));
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::reset():
pushq %rax
movq %rdi, %rax
movq $0x0, 0x58(%rdi)
movq 0x50(%rdi), %rcx
movb $0x0, (%rcx)
addq $0x38, %rdi
movq 0x38(%rax), %rcx
cmpq %rcx, 0x40(%rax)
je 0x59cc7
movq %rcx, 0x40(%rax)
movb 0x14(%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
callq 0x59b7c
popq %rax
retq
movq %rax, %rdi
callq 0x21a05
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5resetEv:
push rax
mov rax, rdi
mov qword ptr [rdi+58h], 0
mov rcx, [rdi+50h]
mov byte ptr [rcx], 0
add rdi, 38h ; '8'
mov rcx, [rax+38h]
cmp [rax+40h], rcx
jz short loc_59CC7
mov [rax+40h], rcx
loc_59CC7:
mov al, [rax+14h]
lea rsi, [rsp+8+var_1]
mov [rsi], al
call _ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
pop rax
retn
mov rdi, rax
call __clang_call_terminate
|
void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> 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>>>::reset(
long long a1)
{
long long v2; // rdi
long long v3; // rcx
char v4; // [rsp+1h] [rbp-1h] BYREF
*(_QWORD *)(a1 + 88) = 0LL;
**(_BYTE **)(a1 + 80) = 0;
v2 = a1 + 56;
v3 = *(_QWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 64) != v3 )
*(_QWORD *)(a1 + 64) = v3;
v4 = *(_BYTE *)(a1 + 20);
std::vector<char>::emplace_back<char>(v2, &v4);
}
|
reset:
PUSH RAX
MOV RAX,RDI
MOV qword ptr [RDI + 0x58],0x0
MOV RCX,qword ptr [RDI + 0x50]
MOV byte ptr [RCX],0x0
ADD RDI,0x38
MOV RCX,qword ptr [RAX + 0x38]
CMP qword ptr [RAX + 0x40],RCX
JZ 0x00159cc7
MOV qword ptr [RAX + 0x40],RCX
LAB_00159cc7:
MOV AL,byte ptr [RAX + 0x14]
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],AL
LAB_00159cd1:
CALL 0x00159b7c
POP RAX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::reset() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::reset(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)
{
int8 in_RAX;
int8 uStack_8;
*(int8 *)(this + 0x58) = 0;
**(int1 **)(this + 0x50) = 0;
if (*(long *)(this + 0x40) != *(long *)(this + 0x38)) {
*(long *)(this + 0x40) = *(long *)(this + 0x38);
}
uStack_8 = CONCAT17(this[0x14],(int7)in_RAX);
/* try { // try from 00159cd1 to 00159cd5 has its CatchHandler @ 00159cd8 */
std::vector<char,std::allocator<char>>::emplace_back<char>
((vector<char,std::allocator<char>> *)(this + 0x38),(char *)((long)&uStack_8 + 7));
return uStack_8;
}
|
|
57,758
|
resize_key_cache
|
eloqsql/mysys/mf_keycache.c
|
int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
size_t use_mem, uint division_limit, uint age_threshold,
uint changed_blocks_hash_size)
{
int blocks= -1;
if (keycache->key_cache_inited)
{
pthread_mutex_lock(&keycache->op_lock);
if ((uint) keycache->param_partitions != keycache->partitions && use_mem)
blocks= repartition_key_cache_internal(keycache,
key_cache_block_size, use_mem,
division_limit, age_threshold,
changed_blocks_hash_size,
(uint) keycache->param_partitions,
0);
else
{
blocks= keycache->interface_funcs->resize(keycache->keycache_cb,
key_cache_block_size,
use_mem, division_limit,
age_threshold,
changed_blocks_hash_size);
if (keycache->partitions)
keycache->partitions=
((PARTITIONED_KEY_CACHE_CB *)(keycache->keycache_cb))->partitions;
}
keycache->key_cache_mem_size=
keycache->partitions ?
((PARTITIONED_KEY_CACHE_CB *)(keycache->keycache_cb))->key_cache_mem_size :
((SIMPLE_KEY_CACHE_CB *)(keycache->keycache_cb))->key_cache_mem_size;
keycache->can_be_used= (blocks >= 0);
pthread_mutex_unlock(&keycache->op_lock);
}
return blocks;
}
|
O3
|
c
|
resize_key_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpb $0x0, 0x48(%rdi)
je 0x98471
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movl %r9d, -0x2c(%rbp)
addq $0x58, %rdi
movq %rdi, -0x38(%rbp)
callq 0x29220
testq %r14, %r14
je 0x98479
movl 0x38(%rbx), %eax
cmpl %eax, 0x4c(%rbx)
je 0x98479
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %r13d, %ecx
movl %r12d, %r8d
movl -0x2c(%rbp), %r9d
pushq $0x0
pushq %rax
callq 0x984eb
addq $0x10, %rsp
movl %eax, %r15d
movl 0x4c(%rbx), %eax
jmp 0x984a7
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
jmp 0x984d2
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rax
movl %r15d, %esi
movq %r14, %rdx
movl %r13d, %ecx
movl %r12d, %r8d
movl -0x2c(%rbp), %r9d
callq *0x8(%rax)
movl %eax, %r15d
cmpl $0x0, 0x4c(%rbx)
je 0x984e4
movq 0x8(%rbx), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x4c(%rbx)
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leaq 0x8(,%rcx,8), %rax
movq 0x8(%rbx), %rcx
movq (%rcx,%rax), %rax
movq %rax, 0x50(%rbx)
testl %r15d, %r15d
setns 0x49(%rbx)
movq -0x38(%rbp), %rdi
callq 0x291e0
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %eax
jmp 0x984b6
|
resize_key_cache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
cmp byte ptr [rdi+48h], 0
jz short loc_98471
mov r12d, r8d
mov r13d, ecx
mov r14, rdx
mov r15d, esi
mov rbx, rdi
mov [rbp+var_2C], r9d
add rdi, 58h ; 'X'
mov [rbp+var_38], rdi
call _pthread_mutex_lock
test r14, r14
jz short loc_98479
mov eax, [rbx+38h]
cmp [rbx+4Ch], eax
jz short loc_98479
mov rdi, rbx
mov esi, r15d
mov rdx, r14
mov ecx, r13d
mov r8d, r12d
mov r9d, [rbp+var_2C]
push 0
push rax
call repartition_key_cache_internal
add rsp, 10h
mov r15d, eax
mov eax, [rbx+4Ch]
jmp short loc_984A7
loc_98471:
mov r15d, 0FFFFFFFFh
jmp short loc_984D2
loc_98479:
mov rdi, [rbx+8]
mov rax, [rbx+10h]
mov esi, r15d
mov rdx, r14
mov ecx, r13d
mov r8d, r12d
mov r9d, [rbp+var_2C]
call qword ptr [rax+8]
mov r15d, eax
cmp dword ptr [rbx+4Ch], 0
jz short loc_984E4
mov rax, [rbx+8]
mov eax, [rax+1Ch]
mov [rbx+4Ch], eax
loc_984A7:
xor ecx, ecx
test eax, eax
setnz cl
lea rax, ds:8[rcx*8]
loc_984B6:
mov rcx, [rbx+8]
mov rax, [rcx+rax]
mov [rbx+50h], rax
test r15d, r15d
setns byte ptr [rbx+49h]
mov rdi, [rbp+var_38]
call _pthread_mutex_unlock
loc_984D2:
mov eax, r15d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_984E4:
mov eax, 8
jmp short loc_984B6
|
long long resize_key_cache(
long long a1,
unsigned int a2,
long long a3,
unsigned int a4,
unsigned int a5,
unsigned int a6)
{
int v9; // eax
unsigned int v10; // r15d
int v11; // eax
long long v12; // rax
if ( *(_BYTE *)(a1 + 72) )
{
pthread_mutex_lock(a1 + 88);
if ( !a3 || (v9 = *(_DWORD *)(a1 + 56), *(_DWORD *)(a1 + 76) == v9) )
{
v10 = (*(long long ( **)(_QWORD, _QWORD, long long, _QWORD, _QWORD, _QWORD))(*(_QWORD *)(a1 + 16) + 8LL))(
*(_QWORD *)(a1 + 8),
a2,
a3,
a4,
a5,
a6);
if ( !*(_DWORD *)(a1 + 76) )
{
v12 = 8LL;
goto LABEL_9;
}
v11 = *(_DWORD *)(*(_QWORD *)(a1 + 8) + 28LL);
*(_DWORD *)(a1 + 76) = v11;
}
else
{
v10 = repartition_key_cache_internal(a1, a2, a3, a4, a5, a6, v9, 0);
v11 = *(_DWORD *)(a1 + 76);
}
v12 = 8LL * (v11 != 0) + 8;
LABEL_9:
*(_QWORD *)(a1 + 80) = *(_QWORD *)(*(_QWORD *)(a1 + 8) + v12);
*(_BYTE *)(a1 + 73) = (v10 & 0x80000000) == 0;
pthread_mutex_unlock(a1 + 88);
return v10;
}
return (unsigned int)-1;
}
|
resize_key_cache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
CMP byte ptr [RDI + 0x48],0x0
JZ 0x00198471
MOV R12D,R8D
MOV R13D,ECX
MOV R14,RDX
MOV R15D,ESI
MOV RBX,RDI
MOV dword ptr [RBP + -0x2c],R9D
ADD RDI,0x58
MOV qword ptr [RBP + -0x38],RDI
CALL 0x00129220
TEST R14,R14
JZ 0x00198479
MOV EAX,dword ptr [RBX + 0x38]
CMP dword ptr [RBX + 0x4c],EAX
JZ 0x00198479
MOV RDI,RBX
MOV ESI,R15D
MOV RDX,R14
MOV ECX,R13D
MOV R8D,R12D
MOV R9D,dword ptr [RBP + -0x2c]
PUSH 0x0
PUSH RAX
CALL 0x001984eb
ADD RSP,0x10
MOV R15D,EAX
MOV EAX,dword ptr [RBX + 0x4c]
JMP 0x001984a7
LAB_00198471:
MOV R15D,0xffffffff
JMP 0x001984d2
LAB_00198479:
MOV RDI,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RBX + 0x10]
MOV ESI,R15D
MOV RDX,R14
MOV ECX,R13D
MOV R8D,R12D
MOV R9D,dword ptr [RBP + -0x2c]
CALL qword ptr [RAX + 0x8]
MOV R15D,EAX
CMP dword ptr [RBX + 0x4c],0x0
JZ 0x001984e4
MOV RAX,qword ptr [RBX + 0x8]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBX + 0x4c],EAX
LAB_001984a7:
XOR ECX,ECX
TEST EAX,EAX
SETNZ CL
LEA RAX,[0x8 + RCX*0x8]
LAB_001984b6:
MOV RCX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RCX + RAX*0x1]
MOV qword ptr [RBX + 0x50],RAX
TEST R15D,R15D
SETNS byte ptr [RBX + 0x49]
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001291e0
LAB_001984d2:
MOV EAX,R15D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001984e4:
MOV EAX,0x8
JMP 0x001984b6
|
int resize_key_cache(long param_1,int4 param_2,long param_3,int4 param_4,
int4 param_5,int4 param_6)
{
int iVar1;
int iVar2;
long lVar3;
if (*(char *)(param_1 + 0x48) == '\0') {
return -1;
}
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x58));
if ((param_3 == 0) || (*(int *)(param_1 + 0x4c) == *(int *)(param_1 + 0x38))) {
iVar1 = (**(code **)(*(long *)(param_1 + 0x10) + 8))
(*(int8 *)(param_1 + 8),param_2,param_3,param_4,param_5,param_6);
if (*(int *)(param_1 + 0x4c) == 0) {
lVar3 = 8;
goto LAB_001984b6;
}
iVar2 = *(int *)(*(long *)(param_1 + 8) + 0x1c);
*(int *)(param_1 + 0x4c) = iVar2;
}
else {
iVar1 = repartition_key_cache_internal
(param_1,param_2,param_3,param_4,param_5,param_6,*(int *)(param_1 + 0x38),0);
iVar2 = *(int *)(param_1 + 0x4c);
}
lVar3 = (ulong)(iVar2 != 0) * 8 + 8;
LAB_001984b6:
*(int8 *)(param_1 + 0x50) = *(int8 *)(*(long *)(param_1 + 8) + lVar3);
*(bool *)(param_1 + 0x49) = -1 < iVar1;
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x58));
return iVar1;
}
|
|
57,759
|
lock_table_resurrect(dict_table_t*, trx_t*, lock_mode)
|
eloqsql/storage/innobase/lock/lock0lock.cc
|
void lock_table_resurrect(dict_table_t *table, trx_t *trx, lock_mode mode)
{
ut_ad(trx->is_recovered);
ut_ad(mode == LOCK_X || mode == LOCK_IX);
if (lock_table_has(trx, table, mode))
return;
{
/* This is executed at server startup while no connections
are alowed. Do not bother with lock elision. */
LockMutexGuard g{SRW_LOCK_CALL};
ut_ad(!lock_table_other_has_incompatible(trx, LOCK_WAIT, table, mode));
trx->mutex_lock();
lock_table_create(table, mode, trx);
}
trx->mutex_unlock();
}
|
O0
|
cpp
|
lock_table_resurrect(dict_table_t*, trx_t*, lock_mode):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
jmp 0x1113ca5
jmp 0x1113ca7
jmp 0x1113ca9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1113aa0
cmpq $0x0, %rax
je 0x1113cc1
jmp 0x1113d0d
leaq -0x15(%rbp), %rdi
leaq 0x377362(%rip), %rsi # 0x148b02e
movl $0xe02, %edx # imm = 0xE02
callq 0x10161b0
jmp 0x1113cd8
jmp 0x1113cda
movq -0x10(%rbp), %rdi
callq 0x109d440
jmp 0x1113ce5
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x11135d0
jmp 0x1113cfb
leaq -0x15(%rbp), %rdi
callq 0x10161e0
movq -0x10(%rbp), %rdi
callq 0x109d540
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x10161e0
movq -0x20(%rbp), %rdi
callq 0x775a20
nopw %cs:(%rax,%rax)
|
_Z20lock_table_resurrectP12dict_table_tP5trx_t9lock_mode:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
jmp short $+2
loc_1113CA5:
jmp short $+2
loc_1113CA7:
jmp short $+2
loc_1113CA9:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_8]
mov edx, [rbp+var_14]
call _ZL14lock_table_hasPK5trx_tPK12dict_table_t9lock_mode; lock_table_has(trx_t const*,dict_table_t const*,lock_mode)
cmp rax, 0
jz short loc_1113CC1
jmp short loc_1113D0D
loc_1113CC1:
lea rdi, [rbp+var_15]; this
lea rsi, aWorkspaceLlm4b_249; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0E02h; unsigned int
call _ZN14LockMutexGuardC2EPKcj; LockMutexGuard::LockMutexGuard(char const*,uint)
jmp short $+2
loc_1113CD8:
jmp short $+2
loc_1113CDA:
mov rdi, [rbp+var_10]; this
call _ZN5trx_t10mutex_lockEv; trx_t::mutex_lock(void)
jmp short $+2
loc_1113CE5:
mov rdi, [rbp+var_8]; dict_table_t *
mov esi, [rbp+var_14]; unsigned int
mov rdx, [rbp+var_10]; trx_t *
xor eax, eax
mov ecx, eax; ib_lock_t *
call _Z17lock_table_createP12dict_table_tjP5trx_tP9ib_lock_t; lock_table_create(dict_table_t *,uint,trx_t *,ib_lock_t *)
jmp short $+2
loc_1113CFB:
lea rdi, [rbp+var_15]; this
call _ZN14LockMutexGuardD2Ev; LockMutexGuard::~LockMutexGuard()
mov rdi, [rbp+var_10]; this
call _ZN5trx_t12mutex_unlockEv; trx_t::mutex_unlock(void)
loc_1113D0D:
add rsp, 30h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
lea rdi, [rbp+var_15]; this
call _ZN14LockMutexGuardD2Ev; LockMutexGuard::~LockMutexGuard()
mov rdi, [rbp+var_20]
call __Unwind_Resume
|
ib_lock_t * lock_table_resurrect(dict_table_t *a1, trx_t *a2, unsigned int a3)
{
ib_lock_t *result; // rax
char v4; // [rsp+1Bh] [rbp-15h] BYREF
unsigned int v5; // [rsp+1Ch] [rbp-14h]
trx_t *v6; // [rsp+20h] [rbp-10h]
dict_table_t *v7; // [rsp+28h] [rbp-8h]
v7 = a1;
v6 = a2;
v5 = a3;
result = lock_table_has((long long)a2, (long long)a1, a3);
if ( !result )
{
LockMutexGuard::LockMutexGuard(
(LockMutexGuard *)&v4,
"/workspace/llm4binary/github2025/eloqsql/storage/innobase/lock/lock0lock.cc",
0xE02u);
trx_t::mutex_lock(v6);
lock_table_create(v7, v5, v6, 0LL);
LockMutexGuard::~LockMutexGuard((LockMutexGuard *)&v4);
return (ib_lock_t *)trx_t::mutex_unlock(v6);
}
return result;
}
|
allocate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV EDX,EAX
MOV ECX,0xffffffff
XOR R8D,R8D
MOV R9D,0x1
CALL 0x01113cd0
ADD RSP,0x10
POP RBP
RET
|
/* ut_allocator<std::_Rb_tree_node<std::pair<void const* const, buf_pool_t::chunk_t*> >,
true>::allocate(unsigned long) */
void __thiscall
ut_allocator<std::_Rb_tree_node<std::pair<void_const*const,buf_pool_t::chunk_t*>>,true>::allocate
(ut_allocator<std::_Rb_tree_node<std::pair<void_const*const,buf_pool_t::chunk_t*>>,true>
*this,ulong param_1)
{
allocate(this,param_1,(_Rb_tree_node *)0x0,0xffffffff,false,true);
return;
}
|
|
57,760
|
minja::error_location_suffix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
|
monkey531[P]llama/common/minja.hpp
|
static std::string error_location_suffix(const std::string & source, size_t pos) {
auto get_line = [&](size_t line) {
auto start = source.begin();
for (size_t i = 1; i < line; ++i) {
start = std::find(start, source.end(), '\n') + 1;
}
auto end = std::find(start, source.end(), '\n');
return std::string(start, end);
};
auto start = source.begin();
auto end = source.end();
auto it = start + pos;
auto line = std::count(start, it, '\n') + 1;
auto max_line = std::count(start, end, '\n') + 1;
auto col = pos - std::string(start, it).rfind('\n');
std::ostringstream out;
out << " at row " << line << ", column " << col << ":\n";
if (line > 1) out << get_line(line - 1) << "\n";
out << get_line(line) << "\n";
out << std::string(col - 1, ' ') << "^\n";
if (line < max_line) out << get_line(line + 1) << "\n";
return out.str();
}
|
O3
|
cpp
|
minja::error_location_suffix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdx, %r8
movq %rsi, %r14
movq %rdi, 0x38(%rsp)
movq (%rsi), %rsi
movq 0x8(%r14), %rax
testq %rdx, %rdx
je 0x2341f
xorl %ecx, %ecx
xorl %r12d, %r12d
xorl %edx, %edx
cmpb $0xa, (%rsi,%rcx)
sete %dl
addq %rdx, %r12
incq %rcx
cmpq %rcx, %r8
jne 0x23409
jmp 0x23422
xorl %r12d, %r12d
leaq (%rsi,%r8), %rdx
testq %rax, %rax
movq %r8, 0x28(%rsp)
je 0x2344c
xorl %ecx, %ecx
xorl %r15d, %r15d
xorl %edi, %edi
cmpb $0xa, (%rsi,%rcx)
sete %dil
addq %rdi, %r15
incq %rcx
cmpq %rcx, %rax
jne 0x23435
jmp 0x2344f
xorl %r15d, %r15d
leaq 0x50(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x5bc0a
movq %rbx, %rdi
movl $0xa, %esi
movq $-0x1, %rdx
callq 0x18d10
movq %rax, %r13
movq (%rbx), %rdi
cmpq %rbp, %rdi
je 0x23491
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x18880
leaq 0x8832c(%rip), %rsi # 0xab7d1
movl $0x8, %edx
movq %rbx, %rdi
callq 0x18770
movq 0x28(%rsp), %rbx
leaq 0x1(%r12), %rsi
leaq 0x40(%rsp), %rdi
movq %rsi, 0x30(%rsp)
callq 0x18650
movq %rax, %rbp
leaq 0x878c5(%rip), %rsi # 0xaad9a
movl $0x9, %edx
movq %rax, %rdi
callq 0x18770
subq %r13, %rbx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x18480
leaq 0x8e664(%rip), %rsi # 0xb1b5b
movl $0x2, %edx
movq %rax, %rdi
callq 0x18770
testq %r12, %r12
jle 0x235b3
movq (%r14), %r13
cmpq $0x1, %r12
jne 0x2351b
movq %r13, %rsi
jmp 0x23547
leaq -0x1(%r12), %rbp
movq (%r14), %rsi
addq 0x8(%r14), %rsi
movb $0xa, 0x7(%rsp)
movq %r13, %rdi
leaq 0x7(%rsp), %rdx
callq 0x5bdc2
movq %rax, %r13
incq %r13
decq %rbp
jne 0x23520
movq (%r14), %rsi
addq 0x8(%r14), %rsi
leaq 0x7(%rsp), %rdx
movb $0xa, (%rdx)
movq %r13, %rdi
callq 0x5bdc2
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5bc0a
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x18770
leaq 0x84855(%rip), %rsi # 0xa7de4
movl $0x1, %edx
movq %rax, %rdi
callq 0x18770
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x235b3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
movq (%r14), %r13
cmpq $0x2, 0x30(%rsp)
jb 0x235f7
movq %rbx, 0x28(%rsp)
leaq 0x7(%rsp), %rbp
movq %r12, %rbx
movq (%r14), %rsi
addq 0x8(%r14), %rsi
movb $0xa, 0x7(%rsp)
movq %r13, %rdi
movq %rbp, %rdx
callq 0x5bdc2
movq %rax, %r13
incq %r13
decq %rbx
jne 0x235cb
movq (%r14), %rsi
movq 0x28(%rsp), %rbx
jmp 0x235fa
movq %r13, %rsi
addq 0x8(%r14), %rsi
leaq 0x7(%rsp), %rdx
movb $0xa, (%rdx)
movq %r13, %rdi
callq 0x5bdc2
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5bc0a
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x18770
leaq 0x847a2(%rip), %rsi # 0xa7de4
movl $0x1, %edx
movq %rax, %rdi
callq 0x18770
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x23666
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
decq %rbx
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
movq %rbx, %rsi
movl $0x20, %edx
callq 0x187a0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x18770
leaq 0x88141(%rip), %rsi # 0xab7da
movl $0x2, %edx
movq %rax, %rdi
callq 0x18770
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x236bd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
cmpq %r15, %r12
jge 0x23769
movq (%r14), %r15
cmpq $-0x3, %r12
ja 0x23700
leaq 0x7(%rsp), %r13
movq 0x30(%rsp), %rbx
movq (%r14), %rsi
addq 0x8(%r14), %rsi
movb $0xa, 0x7(%rsp)
movq %r15, %rdi
movq %r13, %rdx
callq 0x5bdc2
movq %rax, %r15
incq %r15
decq %rbx
jne 0x236d9
movq (%r14), %rsi
jmp 0x23703
movq %r15, %rsi
addq 0x8(%r14), %rsi
leaq 0x7(%rsp), %rdx
movb $0xa, (%rdx)
movq %r15, %rdi
callq 0x5bdc2
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
movq %r15, %rsi
movq %rax, %rdx
callq 0x5bc0a
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x18770
leaq 0x8469f(%rip), %rsi # 0xa7de4
movl $0x1, %edx
movq %rax, %rdi
callq 0x18770
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x23769
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdi
callq 0x18a40
movq 0xb8809(%rip), %rsi # 0xdbf88
leaq 0x40(%rsp), %rdi
callq 0x183a0
leaq 0xb0(%rsp), %rdi
callq 0x18200
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x237d2
jmp 0x237d2
jmp 0x237b6
jmp 0x237d2
jmp 0x237d2
jmp 0x237b6
jmp 0x237b6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x237d5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x237d5
movq %rax, %rbx
movq 0xb87ac(%rip), %rsi # 0xdbf88
leaq 0x40(%rsp), %rdi
callq 0x183a0
leaq 0xb0(%rsp), %rdi
callq 0x18200
movq %rbx, %rdi
callq 0x18bb0
|
_ZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1B8h
mov r8, rdx
mov r14, rsi
mov [rsp+1E8h+var_1B0], rdi
mov rsi, [rsi]
mov rax, [r14+8]
test rdx, rdx
jz short loc_2341F
xor ecx, ecx
xor r12d, r12d
loc_23409:
xor edx, edx
cmp byte ptr [rsi+rcx], 0Ah
setz dl
add r12, rdx
inc rcx
cmp r8, rcx
jnz short loc_23409
jmp short loc_23422
loc_2341F:
xor r12d, r12d
loc_23422:
lea rdx, [rsi+r8]
test rax, rax
mov [rsp+1E8h+var_1C0], r8
jz short loc_2344C
xor ecx, ecx
xor r15d, r15d
loc_23435:
xor edi, edi
cmp byte ptr [rsi+rcx], 0Ah
setz dil
add r15, rdi
inc rcx
cmp rax, rcx
jnz short loc_23435
jmp short loc_2344F
loc_2344C:
xor r15d, r15d
loc_2344F:
lea rbp, [rsp+1E8h+var_198]
mov [rbp-10h], rbp
lea rbx, [rsp+1E8h+var_1A8]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
mov rdi, rbx
mov esi, 0Ah
mov rdx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5rfindEcm; std::string::rfind(char,ulong)
mov r13, rax
mov rdi, [rbx]; void *
cmp rdi, rbp
jz short loc_23491
mov rsi, [rsp+1E8h+var_198]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_23491:
lea rbx, [rsp+1E8h+var_1A8]
mov rdi, rbx
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rsi, aAtRow; " at row "
mov edx, 8
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, [rsp+1E8h+var_1C0]
lea rsi, [r12+1]
lea rdi, [rsp+1E8h+var_1A8]
mov [rsp+1E8h+var_1B8], rsi
call __ZNSo9_M_insertIlEERSoT_; std::ostream::_M_insert<long>(long)
mov rbp, rax
lea rsi, aColumn; ", column "
mov edx, 9
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)
sub rbx, r13
mov rdi, rbp
mov rsi, rbx
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
lea rsi, aJsonSchemaConv+1Dh; ":\n"
mov edx, 2
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)
test r12, r12
jle loc_235B3
mov r13, [r14]
cmp r12, 1
jnz short loc_2351B
mov rsi, r13
jmp short loc_23547
loc_2351B:
lea rbp, [r12-1]
loc_23520:
mov rsi, [r14]
add rsi, [r14+8]
mov [rsp+1E8h+var_1E1], 0Ah
mov rdi, r13
lea rdx, [rsp+1E8h+var_1E1]
call _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS0_5__ops16_Iter_equals_valIS2_EEET_SE_SE_T0_St26random_access_iterator_tag; std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>,std::random_access_iterator_tag)
mov r13, rax
inc r13
dec rbp
jnz short loc_23520
mov rsi, [r14]
loc_23547:
add rsi, [r14+8]
lea rdx, [rsp+1E8h+var_1E1]
mov byte ptr [rdx], 0Ah
mov rdi, r13
call _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS0_5__ops16_Iter_equals_valIS2_EEET_SE_SE_T0_St26random_access_iterator_tag; std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>,std::random_access_iterator_tag)
lea rbp, [rsp+1E8h+var_1D0]
mov [rbp-10h], rbp
lea rdi, [rsp+1E8h+var_1E0]
mov rsi, r13
mov rdx, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
mov rsi, [rsp+1E8h+var_1E0]
mov rdx, [rsp+1E8h+var_1D8]
lea rdi, [rsp+1E8h+var_1A8]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aEndIndexOutOfB+18h; "\n"
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)
mov rdi, [rsp+1E8h+var_1E0]; void *
cmp rdi, rbp
jz short loc_235B3
mov rsi, [rsp+1E8h+var_1D0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_235B3:
mov r13, [r14]
cmp [rsp+1E8h+var_1B8], 2
jb short loc_235F7
mov [rsp+1E8h+var_1C0], rbx
lea rbp, [rsp+1E8h+var_1E1]
mov rbx, r12
loc_235CB:
mov rsi, [r14]
add rsi, [r14+8]
mov [rsp+1E8h+var_1E1], 0Ah
mov rdi, r13
mov rdx, rbp
call _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS0_5__ops16_Iter_equals_valIS2_EEET_SE_SE_T0_St26random_access_iterator_tag; std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>,std::random_access_iterator_tag)
mov r13, rax
inc r13
dec rbx
jnz short loc_235CB
mov rsi, [r14]
mov rbx, [rsp+1E8h+var_1C0]
jmp short loc_235FA
loc_235F7:
mov rsi, r13
loc_235FA:
add rsi, [r14+8]
lea rdx, [rsp+1E8h+var_1E1]
mov byte ptr [rdx], 0Ah
mov rdi, r13
call _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS0_5__ops16_Iter_equals_valIS2_EEET_SE_SE_T0_St26random_access_iterator_tag; std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>,std::random_access_iterator_tag)
lea rbp, [rsp+1E8h+var_1D0]
mov [rbp-10h], rbp
lea rdi, [rsp+1E8h+var_1E0]
mov rsi, r13
mov rdx, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
mov rsi, [rsp+1E8h+var_1E0]
mov rdx, [rsp+1E8h+var_1D8]
lea rdi, [rsp+1E8h+var_1A8]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aEndIndexOutOfB+18h; "\n"
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)
mov rdi, [rsp+1E8h+var_1E0]; void *
cmp rdi, rbp
jz short loc_23666
mov rsi, [rsp+1E8h+var_1D0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_23666:
dec rbx
lea rdi, [rsp+1E8h+var_1E0]
mov [rdi], rbp
mov rsi, rbx
mov edx, 20h ; ' '
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov rsi, [rsp+1E8h+var_1E0]
mov rdx, [rsp+1E8h+var_1D8]
lea rdi, [rsp+1E8h+var_1A8]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, asc_AB7DA; "^\n"
mov edx, 2
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)
mov rdi, [rsp+1E8h+var_1E0]; void *
cmp rdi, rbp
jz short loc_236BD
mov rsi, [rsp+1E8h+var_1D0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_236BD:
cmp r12, r15
jge loc_23769
mov r15, [r14]
cmp r12, 0FFFFFFFFFFFFFFFDh
ja short loc_23700
lea r13, [rsp+1E8h+var_1E1]
mov rbx, [rsp+1E8h+var_1B8]
loc_236D9:
mov rsi, [r14]
add rsi, [r14+8]
mov [rsp+1E8h+var_1E1], 0Ah
mov rdi, r15
mov rdx, r13
call _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS0_5__ops16_Iter_equals_valIS2_EEET_SE_SE_T0_St26random_access_iterator_tag; std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>,std::random_access_iterator_tag)
mov r15, rax
inc r15
dec rbx
jnz short loc_236D9
mov rsi, [r14]
jmp short loc_23703
loc_23700:
mov rsi, r15
loc_23703:
add rsi, [r14+8]
lea rdx, [rsp+1E8h+var_1E1]
mov byte ptr [rdx], 0Ah
mov rdi, r15
call _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS0_5__ops16_Iter_equals_valIS2_EEET_SE_SE_T0_St26random_access_iterator_tag; std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>,std::random_access_iterator_tag)
lea rdi, [rsp+1E8h+var_1E0]
mov [rdi], rbp
mov rsi, r15
mov rdx, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
mov rsi, [rsp+1E8h+var_1E0]
mov rdx, [rsp+1E8h+var_1D8]
lea rdi, [rsp+1E8h+var_1A8]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aEndIndexOutOfB+18h; "\n"
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)
mov rdi, [rsp+1E8h+var_1E0]; void *
cmp rdi, rbp
jz short loc_23769
mov rsi, [rsp+1E8h+var_1D0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_23769:
lea rsi, [rsp+1E8h+var_1A0]
mov rdi, [rsp+1E8h+var_1B0]
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1E8h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+1E8h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
add rsp, 1B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_237D2
jmp short loc_237D2
jmp short loc_237B6
jmp short loc_237D2
jmp short loc_237D2
jmp short loc_237B6
jmp short $+2
loc_237B6:
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, rbp
jz short loc_237D5
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_237D5
loc_237D2:
mov rbx, rax
loc_237D5:
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_38]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+arg_A8]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
|
void minja::error_location_suffix(long long a1, long long *a2, long long a3)
{
long long v4; // rsi
long long v5; // rax
long long v6; // rcx
long long v7; // r12
long long v8; // rcx
long long v9; // r15
long long v10; // r13
long long v11; // rbp
long long v12; // rbx
long long v13; // rax
long long v14; // r13
long long v15; // rsi
long long v16; // rbp
long long v17; // rsi
long long v18; // rsi
long long v19; // rax
long long v20; // rax
long long v21; // r13
long long v22; // rbx
long long v23; // rsi
long long v24; // rsi
long long v25; // rsi
long long v26; // rax
long long v27; // rax
long long v28; // rax
long long v29; // r15
unsigned long long v30; // rbx
long long v31; // rsi
long long v32; // rsi
long long v33; // rsi
long long v34; // rax
long long v35; // rax
char v36; // [rsp+7h] [rbp-1E1h] BYREF
void *v37; // [rsp+8h] [rbp-1E0h] BYREF
long long v38; // [rsp+10h] [rbp-1D8h]
_QWORD v39[2]; // [rsp+18h] [rbp-1D0h] BYREF
long long v40; // [rsp+28h] [rbp-1C0h]
unsigned long long v41; // [rsp+30h] [rbp-1B8h]
long long v42; // [rsp+38h] [rbp-1B0h]
_QWORD *v43; // [rsp+40h] [rbp-1A8h] BYREF
char v44[8]; // [rsp+48h] [rbp-1A0h] BYREF
_QWORD v45[12]; // [rsp+50h] [rbp-198h] BYREF
char v46[312]; // [rsp+B0h] [rbp-138h] BYREF
v42 = a1;
v4 = *a2;
v5 = a2[1];
if ( a3 )
{
v6 = 0LL;
v7 = 0LL;
do
v7 += *(_BYTE *)(v4 + v6++) == 10;
while ( a3 != v6 );
}
else
{
v7 = 0LL;
}
v40 = a3;
if ( v5 )
{
v8 = 0LL;
v9 = 0LL;
do
v9 += *(_BYTE *)(v4 + v8++) == 10;
while ( v5 != v8 );
}
else
{
v9 = 0LL;
}
v43 = v45;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(&v43, v4, v4 + a3);
v10 = std::string::rfind(&v43, 10LL, -1LL);
if ( v43 != v45 )
operator delete(v43, v45[0] + 1LL);
std::ostringstream::basic_ostringstream(&v43);
std::__ostream_insert<char,std::char_traits<char>>(&v43, " at row ", 8LL);
v41 = v7 + 1;
v11 = std::ostream::_M_insert<long>(&v43);
std::__ostream_insert<char,std::char_traits<char>>(v11, ", column ", 9LL);
v12 = v40 - v10;
v13 = std::ostream::_M_insert<unsigned long>(v11, v40 - v10);
std::__ostream_insert<char,std::char_traits<char>>(v13, ":\n", 2LL);
if ( v7 > 0 )
{
v14 = *a2;
if ( v7 == 1 )
{
v15 = *a2;
}
else
{
v16 = v7 - 1;
do
{
v17 = a2[1] + *a2;
v36 = 10;
v14 = std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(
v14,
v17,
&v36)
+ 1;
--v16;
}
while ( v16 );
v15 = *a2;
}
v18 = a2[1] + v15;
v36 = 10;
v19 = std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(
v14,
v18,
&v36);
v37 = v39;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(&v37, v14, v19);
v20 = std::__ostream_insert<char,std::char_traits<char>>(&v43, v37, v38);
std::__ostream_insert<char,std::char_traits<char>>(v20, "\n", 1LL);
if ( v37 != v39 )
operator delete(v37, v39[0] + 1LL);
}
v21 = *a2;
if ( v41 < 2 )
{
v24 = *a2;
}
else
{
v40 = v12;
v22 = v7;
do
{
v23 = a2[1] + *a2;
v36 = 10;
v21 = std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(
v21,
v23,
&v36)
+ 1;
--v22;
}
while ( v22 );
v24 = *a2;
v12 = v40;
}
v25 = a2[1] + v24;
v36 = 10;
v26 = std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(
v21,
v25,
&v36);
v37 = v39;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(&v37, v21, v26);
v27 = std::__ostream_insert<char,std::char_traits<char>>(&v43, v37, v38);
std::__ostream_insert<char,std::char_traits<char>>(v27, "\n", 1LL);
if ( v37 != v39 )
operator delete(v37, v39[0] + 1LL);
v37 = v39;
std::string::_M_construct(&v37, v12 - 1, 32LL);
v28 = std::__ostream_insert<char,std::char_traits<char>>(&v43, v37, v38);
std::__ostream_insert<char,std::char_traits<char>>(v28, "^\n", 2LL);
if ( v37 != v39 )
operator delete(v37, v39[0] + 1LL);
if ( v7 < v9 )
{
v29 = *a2;
if ( (unsigned long long)v7 > 0xFFFFFFFFFFFFFFFDLL )
{
v32 = *a2;
}
else
{
v30 = v41;
do
{
v31 = a2[1] + *a2;
v36 = 10;
v29 = std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(
v29,
v31,
&v36)
+ 1;
--v30;
}
while ( v30 );
v32 = *a2;
}
v33 = a2[1] + v32;
v36 = 10;
v34 = std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(
v29,
v33,
&v36);
v37 = v39;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(&v37, v29, v34);
v35 = std::__ostream_insert<char,std::char_traits<char>>(&v43, v37, v38);
std::__ostream_insert<char,std::char_traits<char>>(v35, "\n", 1LL);
if ( v37 != v39 )
operator delete(v37, v39[0] + 1LL);
}
std::stringbuf::str(v42, v44);
std::ostringstream::~ostringstream(&v43, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v46);
}
|
error_location_suffix:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1b8
MOV R8,RDX
MOV R14,RSI
MOV qword ptr [RSP + 0x38],RDI
MOV RSI,qword ptr [RSI]
MOV RAX,qword ptr [R14 + 0x8]
TEST RDX,RDX
JZ 0x0012341f
XOR ECX,ECX
XOR R12D,R12D
LAB_00123409:
XOR EDX,EDX
CMP byte ptr [RSI + RCX*0x1],0xa
SETZ DL
ADD R12,RDX
INC RCX
CMP R8,RCX
JNZ 0x00123409
JMP 0x00123422
LAB_0012341f:
XOR R12D,R12D
LAB_00123422:
LEA RDX,[RSI + R8*0x1]
TEST RAX,RAX
MOV qword ptr [RSP + 0x28],R8
JZ 0x0012344c
XOR ECX,ECX
XOR R15D,R15D
LAB_00123435:
XOR EDI,EDI
CMP byte ptr [RSI + RCX*0x1],0xa
SETZ DIL
ADD R15,RDI
INC RCX
CMP RAX,RCX
JNZ 0x00123435
JMP 0x0012344f
LAB_0012344c:
XOR R15D,R15D
LAB_0012344f:
LEA RBP,[RSP + 0x50]
MOV qword ptr [RBP + -0x10],RBP
LEA RBX,[RSP + 0x40]
MOV RDI,RBX
CALL 0x0015bc0a
MOV RDI,RBX
MOV ESI,0xa
MOV RDX,-0x1
CALL 0x00118d10
MOV R13,RAX
MOV RDI,qword ptr [RBX]
CMP RDI,RBP
JZ 0x00123491
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x001186a0
LAB_00123491:
LEA RBX,[RSP + 0x40]
MOV RDI,RBX
CALL 0x00118880
LAB_0012349e:
LEA RSI,[0x1ab7d1]
MOV EDX,0x8
MOV RDI,RBX
CALL 0x00118770
MOV RBX,qword ptr [RSP + 0x28]
LEA RSI,[R12 + 0x1]
LEA RDI,[RSP + 0x40]
MOV qword ptr [RSP + 0x30],RSI
CALL 0x00118650
MOV RBP,RAX
LEA RSI,[0x1aad9a]
MOV EDX,0x9
MOV RDI,RAX
CALL 0x00118770
SUB RBX,R13
MOV RDI,RBP
MOV RSI,RBX
CALL 0x00118480
LEA RSI,[0x1b1b5b]
MOV EDX,0x2
MOV RDI,RAX
CALL 0x00118770
TEST R12,R12
JLE 0x001235b3
MOV R13,qword ptr [R14]
CMP R12,0x1
JNZ 0x0012351b
MOV RSI,R13
JMP 0x00123547
LAB_0012351b:
LEA RBP,[R12 + -0x1]
LAB_00123520:
MOV RSI,qword ptr [R14]
ADD RSI,qword ptr [R14 + 0x8]
MOV byte ptr [RSP + 0x7],0xa
MOV RDI,R13
LEA RDX,[RSP + 0x7]
CALL 0x0015bdc2
MOV R13,RAX
INC R13
DEC RBP
JNZ 0x00123520
MOV RSI,qword ptr [R14]
LAB_00123547:
ADD RSI,qword ptr [R14 + 0x8]
LEA RDX,[RSP + 0x7]
MOV byte ptr [RDX],0xa
MOV RDI,R13
CALL 0x0015bdc2
LEA RBP,[RSP + 0x18]
MOV qword ptr [RBP + -0x10],RBP
LAB_00123564:
LEA RDI,[RSP + 0x8]
MOV RSI,R13
MOV RDX,RAX
CALL 0x0015bc0a
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_0012357e:
LEA RDI,[RSP + 0x40]
CALL 0x00118770
LEA RSI,[0x1a7de4]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00118770
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,RBP
JZ 0x001235b3
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001186a0
LAB_001235b3:
MOV R13,qword ptr [R14]
CMP qword ptr [RSP + 0x30],0x2
JC 0x001235f7
MOV qword ptr [RSP + 0x28],RBX
LEA RBP,[RSP + 0x7]
MOV RBX,R12
LAB_001235cb:
MOV RSI,qword ptr [R14]
ADD RSI,qword ptr [R14 + 0x8]
MOV byte ptr [RSP + 0x7],0xa
MOV RDI,R13
MOV RDX,RBP
CALL 0x0015bdc2
MOV R13,RAX
INC R13
DEC RBX
JNZ 0x001235cb
MOV RSI,qword ptr [R14]
MOV RBX,qword ptr [RSP + 0x28]
JMP 0x001235fa
LAB_001235f7:
MOV RSI,R13
LAB_001235fa:
ADD RSI,qword ptr [R14 + 0x8]
LEA RDX,[RSP + 0x7]
MOV byte ptr [RDX],0xa
MOV RDI,R13
CALL 0x0015bdc2
LEA RBP,[RSP + 0x18]
MOV qword ptr [RBP + -0x10],RBP
LAB_00123617:
LEA RDI,[RSP + 0x8]
MOV RSI,R13
MOV RDX,RAX
CALL 0x0015bc0a
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_00123631:
LEA RDI,[RSP + 0x40]
CALL 0x00118770
LEA RSI,[0x1a7de4]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00118770
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,RBP
JZ 0x00123666
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001186a0
LAB_00123666:
DEC RBX
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI],RBP
LAB_00123671:
MOV RSI,RBX
MOV EDX,0x20
CALL 0x001187a0
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_00123688:
LEA RDI,[RSP + 0x40]
CALL 0x00118770
LEA RSI,[0x1ab7da]
MOV EDX,0x2
MOV RDI,RAX
CALL 0x00118770
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,RBP
JZ 0x001236bd
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001186a0
LAB_001236bd:
CMP R12,R15
JGE 0x00123769
MOV R15,qword ptr [R14]
CMP R12,-0x3
JA 0x00123700
LEA R13,[RSP + 0x7]
MOV RBX,qword ptr [RSP + 0x30]
LAB_001236d9:
MOV RSI,qword ptr [R14]
ADD RSI,qword ptr [R14 + 0x8]
MOV byte ptr [RSP + 0x7],0xa
MOV RDI,R15
MOV RDX,R13
CALL 0x0015bdc2
MOV R15,RAX
INC R15
DEC RBX
JNZ 0x001236d9
MOV RSI,qword ptr [R14]
JMP 0x00123703
LAB_00123700:
MOV RSI,R15
LAB_00123703:
ADD RSI,qword ptr [R14 + 0x8]
LEA RDX,[RSP + 0x7]
MOV byte ptr [RDX],0xa
MOV RDI,R15
CALL 0x0015bdc2
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI],RBP
LAB_0012371f:
MOV RSI,R15
MOV RDX,RAX
CALL 0x0015bc0a
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_00123734:
LEA RDI,[RSP + 0x40]
CALL 0x00118770
LEA RSI,[0x1a7de4]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00118770
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,RBP
JZ 0x00123769
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001186a0
LAB_00123769:
LEA RSI,[RSP + 0x48]
LAB_0012376e:
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x00118a40
LAB_00123778:
MOV RSI,qword ptr [0x001dbf88]
LEA RDI,[RSP + 0x40]
CALL 0x001183a0
LEA RDI,[RSP + 0xb0]
CALL 0x00118200
ADD RSP,0x1b8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::error_location_suffix(std::__cxx11::string const&, unsigned long) */
void __thiscall minja::error_location_suffix(minja *this,string *param_1,ulong param_2)
{
long lVar1;
ostream *poVar2;
int8 uVar3;
ulong uVar4;
long lVar5;
ulong uVar6;
long lVar7;
ulong uVar8;
long lVar9;
int1 local_1e1;
long *local_1e0;
long local_1d8;
long local_1d0 [2];
ulong local_1c0;
ulong local_1b8;
minja *local_1b0;
long *local_1a8 [2];
long local_198 [12];
ios_base local_138 [264];
lVar1 = *(long *)param_1;
if (param_2 == 0) {
uVar8 = 0;
}
else {
uVar4 = 0;
uVar8 = 0;
do {
uVar8 = uVar8 + (*(char *)(lVar1 + uVar4) == '\n');
uVar4 = uVar4 + 1;
} while (param_2 != uVar4);
}
if (*(long *)(param_1 + 8) == 0) {
lVar9 = 0;
}
else {
lVar5 = 0;
lVar9 = 0;
do {
lVar9 = lVar9 + (ulong)(*(char *)(lVar1 + lVar5) == '\n');
lVar5 = lVar5 + 1;
} while (*(long *)(param_1 + 8) != lVar5);
}
local_1c0 = param_2;
local_1b0 = this;
local_1a8[0] = local_198;
std::__cxx11::string::_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(local_1a8,lVar1,lVar1 + param_2);
lVar1 = std::__cxx11::string::rfind((char)local_1a8,10);
if (local_1a8[0] != local_198) {
operator_delete(local_1a8[0],local_198[0] + 1);
}
std::__cxx11::ostringstream::ostringstream((ostringstream *)local_1a8);
/* try { // try from 0012349e to 00123503 has its CatchHandler @ 001237d2 */
std::__ostream_insert<char,std::char_traits<char>>((ostream *)local_1a8," at row ",8);
uVar4 = local_1c0;
local_1b8 = uVar8 + 1;
poVar2 = std::ostream::_M_insert<long>((long)local_1a8);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,", column ",9);
uVar4 = uVar4 - lVar1;
poVar2 = std::ostream::_M_insert<unsigned_long>((ulong)poVar2);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,":\n",2);
if (0 < (long)uVar8) {
lVar1 = *(long *)param_1;
lVar5 = lVar1;
if (uVar8 != 1) {
lVar7 = uVar8 - 1;
do {
local_1e1 = 10;
lVar5 = std::
__find_if<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,__gnu_cxx::__ops::_Iter_equals_val<char_const>>
(lVar5,*(long *)param_1 + *(long *)(param_1 + 8),&local_1e1);
lVar5 = lVar5 + 1;
lVar7 = lVar7 + -1;
} while (lVar7 != 0);
lVar1 = *(long *)param_1;
}
local_1e1 = 10;
uVar3 = std::
__find_if<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,__gnu_cxx::__ops::_Iter_equals_val<char_const>>
(lVar5,lVar1 + *(long *)(param_1 + 8));
/* try { // try from 00123564 to 00123573 has its CatchHandler @ 001237aa */
local_1e0 = local_1d0;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(&local_1e0,lVar5,uVar3);
/* try { // try from 0012357e to 0012359b has its CatchHandler @ 001237b2 */
poVar2 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_1a8,(char *)local_1e0,local_1d8);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"\n",1);
if (local_1e0 != local_1d0) {
operator_delete(local_1e0,local_1d0[0] + 1);
}
}
lVar1 = *(long *)param_1;
lVar5 = lVar1;
if (1 < local_1b8) {
uVar6 = uVar8;
local_1c0 = uVar4;
do {
local_1e1 = 10;
lVar5 = std::
__find_if<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,__gnu_cxx::__ops::_Iter_equals_val<char_const>>
(lVar5,*(long *)param_1 + *(long *)(param_1 + 8),&local_1e1);
lVar5 = lVar5 + 1;
uVar6 = uVar6 - 1;
} while (uVar6 != 0);
lVar1 = *(long *)param_1;
uVar4 = local_1c0;
}
local_1e1 = 10;
uVar3 = std::
__find_if<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,__gnu_cxx::__ops::_Iter_equals_val<char_const>>
(lVar5,lVar1 + *(long *)(param_1 + 8));
/* try { // try from 00123617 to 00123626 has its CatchHandler @ 001237b0 */
local_1e0 = local_1d0;
std::__cxx11::string::_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(&local_1e0,lVar5,uVar3);
/* try { // try from 00123631 to 0012364e has its CatchHandler @ 001237b6 */
poVar2 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_1a8,(char *)local_1e0,local_1d8);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"\n",1);
if (local_1e0 != local_1d0) {
operator_delete(local_1e0,local_1d0[0] + 1);
}
local_1e0 = local_1d0;
/* try { // try from 00123671 to 0012367d has its CatchHandler @ 001237ae */
std::__cxx11::string::_M_construct((ulong)&local_1e0,(char)uVar4 + -1);
/* try { // try from 00123688 to 001236a5 has its CatchHandler @ 001237b4 */
poVar2 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_1a8,(char *)local_1e0,local_1d8);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"^\n",2);
if (local_1e0 != local_1d0) {
operator_delete(local_1e0,local_1d0[0] + 1);
}
if ((long)uVar8 < lVar9) {
lVar1 = *(long *)param_1;
lVar9 = lVar1;
if (uVar8 < 0xfffffffffffffffe) {
uVar8 = local_1b8;
do {
local_1e1 = 10;
lVar9 = std::
__find_if<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,__gnu_cxx::__ops::_Iter_equals_val<char_const>>
(lVar9,*(long *)param_1 + *(long *)(param_1 + 8),&local_1e1);
lVar9 = lVar9 + 1;
uVar8 = uVar8 - 1;
} while (uVar8 != 0);
lVar1 = *(long *)param_1;
}
local_1e1 = 10;
uVar3 = std::
__find_if<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,__gnu_cxx::__ops::_Iter_equals_val<char_const>>
(lVar9,lVar1 + *(long *)(param_1 + 8));
local_1e0 = local_1d0;
/* try { // try from 0012371f to 00123729 has its CatchHandler @ 001237a8 */
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(&local_1e0,lVar9,uVar3);
/* try { // try from 00123734 to 00123751 has its CatchHandler @ 001237ac */
poVar2 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_1a8,(char *)local_1e0,local_1d8);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"\n",1);
if (local_1e0 != local_1d0) {
operator_delete(local_1e0,local_1d0[0] + 1);
}
}
/* try { // try from 0012376e to 00123777 has its CatchHandler @ 001237d2 */
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream((ostringstream *)local_1a8);
std::ios_base::~ios_base(local_138);
return;
}
|
|
57,761
|
js_function_bind
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_function_bind(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSBoundFunction *bf;
JSValue func_obj, name1, len_val;
JSObject *p;
int arg_count, i, ret;
if (check_function(ctx, this_val))
return JS_EXCEPTION;
func_obj = JS_NewObjectProtoClass(ctx, ctx->function_proto,
JS_CLASS_BOUND_FUNCTION);
if (JS_IsException(func_obj))
return JS_EXCEPTION;
p = JS_VALUE_GET_OBJ(func_obj);
p->is_constructor = JS_IsConstructor(ctx, this_val);
arg_count = max_int(0, argc - 1);
bf = js_malloc(ctx, sizeof(*bf) + arg_count * sizeof(JSValue));
if (!bf)
goto exception;
bf->func_obj = js_dup(this_val);
bf->this_val = js_dup(argv[0]);
bf->argc = arg_count;
for(i = 0; i < arg_count; i++) {
bf->argv[i] = js_dup(argv[i + 1]);
}
p->u.bound_function = bf;
/* XXX: the spec could be simpler by only using GetOwnProperty */
ret = JS_GetOwnProperty(ctx, NULL, this_val, JS_ATOM_length);
if (ret < 0)
goto exception;
if (!ret) {
len_val = js_int32(0);
} else {
len_val = JS_GetProperty(ctx, this_val, JS_ATOM_length);
if (JS_IsException(len_val))
goto exception;
if (JS_VALUE_GET_TAG(len_val) == JS_TAG_INT) {
/* most common case */
int len1 = JS_VALUE_GET_INT(len_val);
if (len1 <= arg_count)
len1 = 0;
else
len1 -= arg_count;
len_val = js_int32(len1);
} else if (JS_VALUE_GET_NORM_TAG(len_val) == JS_TAG_FLOAT64) {
double d = JS_VALUE_GET_FLOAT64(len_val);
if (isnan(d)) {
d = 0.0;
} else {
d = trunc(d);
if (d <= (double)arg_count)
d = 0.0;
else
d -= (double)arg_count; /* also converts -0 to +0 */
}
len_val = js_number(d);
} else {
JS_FreeValue(ctx, len_val);
len_val = js_int32(0);
}
}
JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_length,
len_val, JS_PROP_CONFIGURABLE);
name1 = JS_GetProperty(ctx, this_val, JS_ATOM_name);
if (JS_IsException(name1))
goto exception;
if (!JS_IsString(name1)) {
JS_FreeValue(ctx, name1);
name1 = JS_AtomToString(ctx, JS_ATOM_empty_string);
}
name1 = JS_ConcatString3(ctx, "bound ", name1, "");
if (JS_IsException(name1))
goto exception;
JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_name, name1,
JS_PROP_CONFIGURABLE);
return func_obj;
exception:
JS_FreeValue(ctx, func_obj);
return JS_EXCEPTION;
}
|
O1
|
c
|
js_function_bind:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbp
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
callq 0x415b1
movl $0x6, %ebx
testl %eax, %eax
jne 0x718cd
movq 0x48(%r14), %rsi
movq 0x50(%r14), %rdx
movq %r14, %rdi
movl $0xe, %ecx
callq 0x20f05
movq %rax, 0x20(%rsp)
cmpl $0x6, %edx
jne 0x718e4
xorl %ebp, %ebp
movq %rbp, %rax
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %rsi
movq %r13, 0x8(%rsp)
cmpl $-0x1, %r12d
movq %rdx, 0x18(%rsp)
jne 0x71905
movq 0x8(%rsp), %rax
movb 0x5(%rax), %al
andb $0x10, %al
jmp 0x71907
xorl %eax, %eax
movb 0x5(%rsi), %cl
andb $-0x11, %cl
orb %al, %cl
movq %rsi, 0x30(%rsp)
movb %cl, 0x5(%rsi)
cmpl $0x2, %r15d
movl $0x1, %eax
cmovgel %r15d, %eax
movq %rax, 0x28(%rsp)
leal -0x1(%rax), %esi
movq %rsi, 0x10(%rsp)
shlq $0x4, %rsi
addq $0x28, %rsi
movq %r14, %rdi
callq 0xede6
testq %rax, %rax
je 0x71b2a
movq %r13, 0x8(%rsp)
cmpl $-0x9, %r12d
jb 0x7195c
movq 0x8(%rsp), %rcx
incl (%rcx)
movq %r13, (%rax)
movq %r12, 0x8(%rax)
movq (%rbp), %rcx
movq 0x8(%rbp), %rdx
movq %rcx, 0x8(%rsp)
cmpl $-0x9, %edx
jb 0x7197c
movq 0x8(%rsp), %rsi
incl (%rsi)
movq %rcx, 0x10(%rax)
movq %rdx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movl %ecx, 0x20(%rax)
cmpl $0x2, %r15d
jl 0x719cb
movl 0x10(%rsp), %ecx
shlq $0x4, %rcx
xorl %edx, %edx
movq 0x10(%rbp,%rdx), %rsi
movq 0x18(%rbp,%rdx), %rdi
movq %rsi, 0x8(%rsp)
cmpl $-0x9, %edi
jb 0x719b8
movq 0x8(%rsp), %r8
incl (%r8)
movq %rsi, 0x28(%rax,%rdx)
movq %rdi, 0x30(%rax,%rdx)
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x7199c
movq 0x30(%rsp), %rcx
movq %rax, 0x30(%rcx)
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
movl $0x32, %r8d
callq 0x23bb0
testl %eax, %eax
js 0x71b2a
je 0x71a89
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl $0x32, %ecx
movq %r13, %r8
movq %r12, %r9
pushq $0x0
pushq $0x0
callq 0x22fa3
addq $0x10, %rsp
cmpl $0x6, %edx
je 0x71b2a
cmpl $0x7, %edx
je 0x71a40
testl %edx, %edx
jne 0x71a7d
movl %eax, %r8d
subl 0x10(%rsp), %r8d
xorl %r9d, %r9d
cmpl %eax, 0x28(%rsp)
cmovgl %r9d, %r8d
jmp 0x71a8f
movq %rax, %xmm0
ucomisd %xmm0, %xmm0
jp 0x71b6c
callq 0xe140
cvtsi2sdl 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
xorpd %xmm2, %xmm2
jae 0x71a6c
subsd %xmm1, %xmm0
movapd %xmm0, %xmm2
movapd %xmm2, %xmm0
callq 0x1c9fb
movq %rax, %r8
movq %rdx, %r9
jmp 0x71a8f
movq 0x18(%r14), %rdi
movq %rax, %rsi
callq 0x1d8c6
xorl %r8d, %r8d
xorl %r9d, %r9d
movq 0x20(%rsp), %rbp
subq $0x8, %rsp
movq %r14, %rdi
movq %rbp, %rsi
movq 0x20(%rsp), %rdx
movl $0x32, %ecx
pushq $0x1
callq 0x26abb
addq $0x10, %rsp
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl $0x37, %ecx
movq %r13, %r8
movq %r12, %r9
pushq $0x0
pushq $0x0
callq 0x22fa3
addq $0x10, %rsp
movq %rdx, %rcx
cmpl $-0x7, %ecx
je 0x71b08
cmpl $0x6, %ecx
je 0x71b2a
movq 0x18(%r14), %rdi
movq %rax, %rsi
movq %rcx, %rdx
callq 0x1d8c6
movq 0x18(%r14), %rax
movq 0x68(%rax), %rax
movq 0x178(%rax), %rax
incl (%rax)
movq $-0x7, %rcx
leaq 0x2ffeb(%rip), %rsi # 0xa1afa
leaq 0x29aca(%rip), %r8 # 0x9b5e0
movq %r14, %rdi
movq %rax, %rdx
callq 0x41f02
movq %rdx, %r9
cmpl $0x6, %r9d
jne 0x71b42
movq 0x20(%rsp), %rsi
movq 0x18(%r14), %rdi
movq 0x18(%rsp), %rdx
callq 0x1d8c6
jmp 0x718cd
subq $0x8, %rsp
movq %r14, %rdi
movq %rbp, %rsi
movq 0x20(%rsp), %rbx
movq %rbx, %rdx
movl $0x37, %ecx
movq %rax, %r8
pushq $0x1
callq 0x26abb
addq $0x10, %rsp
jmp 0x718cf
xorpd %xmm2, %xmm2
jmp 0x71a6c
|
js_function_bind:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbp, r8
mov r15d, ecx
mov r12, rdx
mov r13, rsi
mov r14, rdi
call check_function
mov ebx, 6
test eax, eax
jnz short loc_718CD
mov rsi, [r14+48h]
mov rdx, [r14+50h]
mov rdi, r14
mov ecx, 0Eh
call JS_NewObjectProtoClass
mov [rsp+68h+var_48], rax
cmp edx, 6
jnz short loc_718E4
loc_718CD:
xor ebp, ebp
loc_718CF:
mov rax, rbp
mov rdx, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_718E4:
mov rsi, [rsp+68h+var_48]
mov [rsp+68h+var_60], r13
cmp r12d, 0FFFFFFFFh
mov [rsp+68h+var_50], rdx
jnz short loc_71905
mov rax, [rsp+68h+var_60]
mov al, [rax+5]
and al, 10h
jmp short loc_71907
loc_71905:
xor eax, eax
loc_71907:
mov cl, [rsi+5]
and cl, 0EFh
or cl, al
mov [rsp+68h+var_38], rsi
mov [rsi+5], cl
cmp r15d, 2
mov eax, 1
cmovge eax, r15d
mov [rsp+68h+var_40], rax
lea esi, [rax-1]
mov [rsp+68h+var_58], rsi
shl rsi, 4
add rsi, 28h ; '('
mov rdi, r14
call js_malloc
test rax, rax
jz loc_71B2A
mov [rsp+68h+var_60], r13
cmp r12d, 0FFFFFFF7h
jb short loc_7195C
mov rcx, [rsp+68h+var_60]
inc dword ptr [rcx]
loc_7195C:
mov [rax], r13
mov [rax+8], r12
mov rcx, [rbp+0]
mov rdx, [rbp+8]
mov [rsp+68h+var_60], rcx
cmp edx, 0FFFFFFF7h
jb short loc_7197C
mov rsi, [rsp+68h+var_60]
inc dword ptr [rsi]
loc_7197C:
mov [rax+10h], rcx
mov [rax+18h], rdx
mov rcx, [rsp+68h+var_58]
mov [rax+20h], ecx
cmp r15d, 2
jl short loc_719CB
mov ecx, dword ptr [rsp+68h+var_58]
shl rcx, 4
xor edx, edx
loc_7199C:
mov rsi, [rbp+rdx+10h]
mov rdi, [rbp+rdx+18h]
mov [rsp+68h+var_60], rsi
cmp edi, 0FFFFFFF7h
jb short loc_719B8
mov r8, [rsp+68h+var_60]
inc dword ptr [r8]
loc_719B8:
mov [rax+rdx+28h], rsi
mov [rax+rdx+30h], rdi
add rdx, 10h
cmp rcx, rdx
jnz short loc_7199C
loc_719CB:
mov rcx, [rsp+68h+var_38]
mov [rcx+30h], rax
mov rdi, r14
xor esi, esi
mov rdx, r13
mov rcx, r12
mov r8d, 32h ; '2'
call JS_GetOwnProperty
test eax, eax
js loc_71B2A
jz loc_71A89
mov rdi, r14
mov rsi, r13
mov rdx, r12
mov ecx, 32h ; '2'
mov r8, r13
mov r9, r12
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
cmp edx, 6
jz loc_71B2A
cmp edx, 7
jz short loc_71A40
test edx, edx
jnz short loc_71A7D
mov r8d, eax
sub r8d, dword ptr [rsp+68h+var_58]
xor r9d, r9d
cmp dword ptr [rsp+68h+var_40], eax
cmovg r8d, r9d
jmp short loc_71A8F
loc_71A40:
movq xmm0, rax
ucomisd xmm0, xmm0
jp loc_71B6C
call _trunc
cvtsi2sd xmm1, dword ptr [rsp+68h+var_58]
ucomisd xmm1, xmm0
xorpd xmm2, xmm2
jnb short loc_71A6C
subsd xmm0, xmm1
movapd xmm2, xmm0
loc_71A6C:
movapd xmm0, xmm2
call js_number
mov r8, rax
mov r9, rdx
jmp short loc_71A8F
loc_71A7D:
mov rdi, [r14+18h]
mov rsi, rax
call JS_FreeValueRT
loc_71A89:
xor r8d, r8d
xor r9d, r9d
loc_71A8F:
mov rbp, [rsp+68h+var_48]
sub rsp, 8
mov rdi, r14
mov rsi, rbp
mov rdx, [rsp+70h+var_50]
mov ecx, 32h ; '2'
push 1
call JS_DefinePropertyValue
add rsp, 10h
mov rdi, r14
mov rsi, r13
mov rdx, r12
mov ecx, 37h ; '7'
mov r8, r13
mov r9, r12
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov rcx, rdx
cmp ecx, 0FFFFFFF9h
jz short loc_71B08
cmp ecx, 6
jz short loc_71B2A
mov rdi, [r14+18h]
mov rsi, rax
mov rdx, rcx
call JS_FreeValueRT
mov rax, [r14+18h]
mov rax, [rax+68h]
mov rax, [rax+178h]
inc dword ptr [rax]
mov rcx, 0FFFFFFFFFFFFFFF9h
loc_71B08:
lea rsi, aBound; "bound "
lea r8, aIncludeQuickjs+1Bh; ""
mov rdi, r14
mov rdx, rax
call JS_ConcatString3
mov r9, rdx
cmp r9d, 6
jnz short loc_71B42
loc_71B2A:
mov rsi, [rsp+68h+var_48]
mov rdi, [r14+18h]
mov rdx, [rsp+68h+var_50]
call JS_FreeValueRT
jmp loc_718CD
loc_71B42:
sub rsp, 8
mov rdi, r14
mov rsi, rbp
mov rbx, [rsp+70h+var_50]
mov rdx, rbx
mov ecx, 37h ; '7'
mov r8, rax
push 1
call JS_DefinePropertyValue
add rsp, 10h
jmp loc_718CF
loc_71B6C:
xorpd xmm2, xmm2
jmp loc_71A6C
|
unsigned long long js_function_bind(
long long *a1,
long long a2,
long long a3,
int a4,
_QWORD *a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v18; // rdx
unsigned long long v19; // rbp
char v21; // al
int v22; // eax
long long v23; // rax
long long v24; // r9
__m128 v25; // xmm4
__m128 v26; // xmm5
_DWORD *v27; // rcx
long long v28; // rdx
long long v29; // rdx
long long v30; // rsi
long long v31; // rdi
int OwnProperty; // eax
__m128 v33; // xmm4
__m128 v34; // xmm5
_DWORD *PropertyInternal2; // rax
long long v36; // rdx
long long v37; // r8
long long v38; // r9
__m128 v39; // xmm0
long long v40; // rdx
_DWORD *v41; // rax
long long v42; // rdx
long long v43; // r9
__m128 v44; // xmm4
__m128 v45; // xmm5
long long v46; // rcx
_DWORD *v47; // rax
long long v48; // rdx
__m128 v49; // xmm4
__m128 v50; // xmm5
long long v51; // [rsp+10h] [rbp-58h]
long long v52; // [rsp+18h] [rbp-50h]
unsigned long long v53; // [rsp+20h] [rbp-48h]
int v54; // [rsp+28h] [rbp-40h]
if ( (unsigned int)check_function((long long)a1, a2, a3, a6, a7, a8, a9, a10, a11, a12, a13) )
return 0LL;
v53 = JS_NewObjectProtoClass((long long)a1, a1[9], a1[10], 0xEu);
if ( (_DWORD)v18 == 6 )
return 0LL;
v52 = v18;
if ( (_DWORD)a3 == -1 )
v21 = *(_BYTE *)(a2 + 5) & 0x10;
else
v21 = 0;
*(_BYTE *)(v53 + 5) = v21 | *(_BYTE *)(v53 + 5) & 0xEF;
v22 = 1;
if ( a4 >= 2 )
v22 = a4;
v54 = v22;
v51 = (unsigned int)(v22 - 1);
v23 = js_malloc((long long)a1, 16 * v51 + 40);
if ( !v23 )
goto LABEL_37;
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
++*(_DWORD *)a2;
*(_QWORD *)v23 = a2;
*(_QWORD *)(v23 + 8) = a3;
v27 = (_DWORD *)*a5;
v28 = a5[1];
if ( (unsigned int)v28 >= 0xFFFFFFF7 )
++*(_DWORD *)*a5;
*(_QWORD *)(v23 + 16) = v27;
*(_QWORD *)(v23 + 24) = v28;
*(_DWORD *)(v23 + 32) = v51;
if ( a4 >= 2 )
{
v29 = 0LL;
do
{
v30 = a5[v29 + 2];
v31 = a5[v29 + 3];
if ( (unsigned int)v31 >= 0xFFFFFFF7 )
++*(_DWORD *)a5[v29 + 2];
*(_QWORD *)(v23 + v29 * 8 + 40) = v30;
*(_QWORD *)(v23 + v29 * 8 + 48) = v31;
v29 += 2LL;
}
while ( 2LL * (unsigned int)v51 != v29 );
}
*(_QWORD *)(v53 + 48) = v23;
OwnProperty = JS_GetOwnProperty((long long)a1, 0LL, a2, a3, 50LL, v24, a6, a7, a8, a9, v25, v26, a12, a13);
if ( OwnProperty < 0 )
goto LABEL_37;
if ( OwnProperty )
{
PropertyInternal2 = (_DWORD *)JS_GetPropertyInternal2((long long)a1, a2, a3, 0x32u, a2, a3, 0LL, 0);
switch ( (_DWORD)v36 )
{
case 6:
goto LABEL_37;
case 7:
v39 = (__m128)(unsigned long long)PropertyInternal2;
*(double *)v39.m128_u64 = trunc(a1, a2, v36);
*(double *)a7.m128_u64 = (double)(int)v51;
a8 = 0LL;
if ( (double)(int)v51 < *(double *)v39.m128_u64 )
{
*(double *)v39.m128_u64 = *(double *)v39.m128_u64 - *(double *)a7.m128_u64;
a8 = v39;
}
a6 = a8;
v37 = js_number(*(double *)a8.m128_u64);
v38 = v40;
goto LABEL_33;
case 0:
v37 = (unsigned int)((_DWORD)PropertyInternal2 - v51);
v38 = 0LL;
if ( v54 > (int)PropertyInternal2 )
v37 = 0LL;
goto LABEL_33;
}
JS_FreeValueRT(a1[3], PropertyInternal2, v36);
}
v37 = 0LL;
v38 = 0LL;
LABEL_33:
v19 = v53;
JS_DefinePropertyValue(
(long long)a1,
v53,
v52,
50LL,
(_DWORD *)v37,
v38,
*(double *)a6.m128_u64,
a7,
a8,
a9,
v33,
v34,
a12,
a13,
1);
v41 = (_DWORD *)JS_GetPropertyInternal2((long long)a1, a2, a3, 0x37u, a2, a3, 0LL, 0);
v46 = v42;
if ( (_DWORD)v42 == -7 )
goto LABEL_36;
if ( (_DWORD)v42 != 6 )
{
JS_FreeValueRT(a1[3], v41, v42);
v41 = *(_DWORD **)(*(_QWORD *)(a1[3] + 104) + 376LL);
++*v41;
v46 = -7LL;
LABEL_36:
v47 = JS_ConcatString3(
(long long)a1,
(long long)"bound ",
v41,
v46,
(long long)"",
v43,
a6,
a7,
a8,
a9,
v44,
v45,
a12,
a13);
if ( (_DWORD)v48 != 6 )
{
JS_DefinePropertyValue(
(long long)a1,
v53,
v52,
55LL,
v47,
v48,
*(double *)a6.m128_u64,
a7,
a8,
a9,
v49,
v50,
a12,
a13,
1);
return v19;
}
}
LABEL_37:
JS_FreeValueRT(a1[3], (_DWORD *)v53, v52);
return 0LL;
}
|
js_function_bind:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBP,R8
MOV R15D,ECX
MOV R12,RDX
MOV R13,RSI
MOV R14,RDI
CALL 0x001415b1
MOV EBX,0x6
TEST EAX,EAX
JNZ 0x001718cd
MOV RSI,qword ptr [R14 + 0x48]
MOV RDX,qword ptr [R14 + 0x50]
MOV RDI,R14
MOV ECX,0xe
CALL 0x00120f05
MOV qword ptr [RSP + 0x20],RAX
CMP EDX,0x6
JNZ 0x001718e4
LAB_001718cd:
XOR EBP,EBP
LAB_001718cf:
MOV RAX,RBP
MOV RDX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001718e4:
MOV RSI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],R13
CMP R12D,-0x1
MOV qword ptr [RSP + 0x18],RDX
JNZ 0x00171905
MOV RAX,qword ptr [RSP + 0x8]
MOV AL,byte ptr [RAX + 0x5]
AND AL,0x10
JMP 0x00171907
LAB_00171905:
XOR EAX,EAX
LAB_00171907:
MOV CL,byte ptr [RSI + 0x5]
AND CL,0xef
OR CL,AL
MOV qword ptr [RSP + 0x30],RSI
MOV byte ptr [RSI + 0x5],CL
CMP R15D,0x2
MOV EAX,0x1
CMOVGE EAX,R15D
MOV qword ptr [RSP + 0x28],RAX
LEA ESI,[RAX + -0x1]
MOV qword ptr [RSP + 0x10],RSI
SHL RSI,0x4
ADD RSI,0x28
MOV RDI,R14
CALL 0x0010ede6
TEST RAX,RAX
JZ 0x00171b2a
MOV qword ptr [RSP + 0x8],R13
CMP R12D,-0x9
JC 0x0017195c
MOV RCX,qword ptr [RSP + 0x8]
INC dword ptr [RCX]
LAB_0017195c:
MOV qword ptr [RAX],R13
MOV qword ptr [RAX + 0x8],R12
MOV RCX,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
MOV qword ptr [RSP + 0x8],RCX
CMP EDX,-0x9
JC 0x0017197c
MOV RSI,qword ptr [RSP + 0x8]
INC dword ptr [RSI]
LAB_0017197c:
MOV qword ptr [RAX + 0x10],RCX
MOV qword ptr [RAX + 0x18],RDX
MOV RCX,qword ptr [RSP + 0x10]
MOV dword ptr [RAX + 0x20],ECX
CMP R15D,0x2
JL 0x001719cb
MOV ECX,dword ptr [RSP + 0x10]
SHL RCX,0x4
XOR EDX,EDX
LAB_0017199c:
MOV RSI,qword ptr [RBP + RDX*0x1 + 0x10]
MOV RDI,qword ptr [RBP + RDX*0x1 + 0x18]
MOV qword ptr [RSP + 0x8],RSI
CMP EDI,-0x9
JC 0x001719b8
MOV R8,qword ptr [RSP + 0x8]
INC dword ptr [R8]
LAB_001719b8:
MOV qword ptr [RAX + RDX*0x1 + 0x28],RSI
MOV qword ptr [RAX + RDX*0x1 + 0x30],RDI
ADD RDX,0x10
CMP RCX,RDX
JNZ 0x0017199c
LAB_001719cb:
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RCX + 0x30],RAX
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R13
MOV RCX,R12
MOV R8D,0x32
CALL 0x00123bb0
TEST EAX,EAX
JS 0x00171b2a
JZ 0x00171a89
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
MOV ECX,0x32
MOV R8,R13
MOV R9,R12
PUSH 0x0
PUSH 0x0
CALL 0x00122fa3
ADD RSP,0x10
CMP EDX,0x6
JZ 0x00171b2a
CMP EDX,0x7
JZ 0x00171a40
TEST EDX,EDX
JNZ 0x00171a7d
MOV R8D,EAX
SUB R8D,dword ptr [RSP + 0x10]
XOR R9D,R9D
CMP dword ptr [RSP + 0x28],EAX
CMOVG R8D,R9D
JMP 0x00171a8f
LAB_00171a40:
MOVQ XMM0,RAX
UCOMISD XMM0,XMM0
JP 0x00171b6c
CALL 0x0010e140
CVTSI2SD XMM1,dword ptr [RSP + 0x10]
UCOMISD XMM1,XMM0
XORPD XMM2,XMM2
JNC 0x00171a6c
SUBSD XMM0,XMM1
MOVAPD XMM2,XMM0
LAB_00171a6c:
MOVAPD XMM0,XMM2
CALL 0x0011c9fb
MOV R8,RAX
MOV R9,RDX
JMP 0x00171a8f
LAB_00171a7d:
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,RAX
CALL 0x0011d8c6
LAB_00171a89:
XOR R8D,R8D
XOR R9D,R9D
LAB_00171a8f:
MOV RBP,qword ptr [RSP + 0x20]
SUB RSP,0x8
MOV RDI,R14
MOV RSI,RBP
MOV RDX,qword ptr [RSP + 0x20]
MOV ECX,0x32
PUSH 0x1
CALL 0x00126abb
ADD RSP,0x10
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
MOV ECX,0x37
MOV R8,R13
MOV R9,R12
PUSH 0x0
PUSH 0x0
CALL 0x00122fa3
ADD RSP,0x10
MOV RCX,RDX
CMP ECX,-0x7
JZ 0x00171b08
CMP ECX,0x6
JZ 0x00171b2a
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,RAX
MOV RDX,RCX
CALL 0x0011d8c6
MOV RAX,qword ptr [R14 + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RAX + 0x178]
INC dword ptr [RAX]
MOV RCX,-0x7
LAB_00171b08:
LEA RSI,[0x1a1afa]
LEA R8,[0x19b5e0]
MOV RDI,R14
MOV RDX,RAX
CALL 0x00141f02
MOV R9,RDX
CMP R9D,0x6
JNZ 0x00171b42
LAB_00171b2a:
MOV RSI,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [R14 + 0x18]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x0011d8c6
JMP 0x001718cd
LAB_00171b42:
SUB RSP,0x8
MOV RDI,R14
MOV RSI,RBP
MOV RBX,qword ptr [RSP + 0x20]
MOV RDX,RBX
MOV ECX,0x37
MOV R8,RAX
PUSH 0x1
CALL 0x00126abb
ADD RSP,0x10
JMP 0x001718cf
LAB_00171b6c:
XORPD XMM2,XMM2
JMP 0x00171a6c
|
int1 [16]
js_function_bind(long param_1,int *param_2,int8 param_3,int param_4,int8 *param_5)
{
int *piVar1;
int8 uVar2;
byte bVar3;
int iVar4;
int iVar5;
long lVar6;
int8 *puVar7;
int8 uVar8;
long lVar9;
uint uVar10;
double dVar11;
double dVar12;
int1 auVar13 [12];
int1 auVar14 [16];
int1 auVar15 [16];
iVar4 = check_function();
if (iVar4 != 0) goto LAB_001718cd;
auVar14 = JS_NewObjectProtoClass
(param_1,*(int8 *)(param_1 + 0x48),*(int8 *)(param_1 + 0x50),0xe);
uVar8 = auVar14._8_8_;
lVar6 = auVar14._0_8_;
if (auVar14._8_4_ == 6) goto LAB_001718cd;
if ((uint)param_3 == 0xffffffff) {
bVar3 = *(byte *)((long)param_2 + 5) & 0x10;
}
else {
bVar3 = 0;
}
*(byte *)(lVar6 + 5) = *(byte *)(lVar6 + 5) & 0xef | bVar3;
iVar4 = 1;
if (1 < param_4) {
iVar4 = param_4;
}
uVar10 = iVar4 - 1;
puVar7 = (int8 *)js_malloc(param_1,(ulong)uVar10 * 0x10 + 0x28);
if (puVar7 != (int8 *)0x0) {
if (0xfffffff6 < (uint)param_3) {
*param_2 = *param_2 + 1;
}
*puVar7 = param_2;
puVar7[1] = param_3;
piVar1 = (int *)*param_5;
uVar2 = param_5[1];
if (0xfffffff6 < (uint)uVar2) {
*piVar1 = *piVar1 + 1;
}
puVar7[2] = piVar1;
puVar7[3] = uVar2;
*(uint *)(puVar7 + 4) = uVar10;
if (1 < param_4) {
lVar9 = 0;
do {
piVar1 = *(int **)((long)param_5 + lVar9 + 0x10);
uVar2 = *(int8 *)((long)param_5 + lVar9 + 0x18);
if (0xfffffff6 < (uint)uVar2) {
*piVar1 = *piVar1 + 1;
}
*(int **)((long)puVar7 + lVar9 + 0x28) = piVar1;
*(int8 *)((long)puVar7 + lVar9 + 0x30) = uVar2;
lVar9 = lVar9 + 0x10;
} while ((ulong)uVar10 << 4 != lVar9);
}
*(int8 **)(lVar6 + 0x30) = puVar7;
iVar5 = JS_GetOwnProperty(param_1,0,param_2,param_3,0x32);
if (-1 < iVar5) {
if (iVar5 == 0) {
LAB_00171a89:
auVar15 = ZEXT816(0);
}
else {
auVar13 = JS_GetPropertyInternal2(param_1,param_2,param_3,0x32,param_2,param_3,0,0);
iVar5 = auVar13._8_4_;
dVar12 = auVar13._0_8_;
if (iVar5 == 6) goto LAB_00171b2a;
if (iVar5 == 7) {
if (NAN(dVar12)) {
dVar12 = 0.0;
}
else {
dVar11 = trunc(dVar12);
dVar12 = 0.0;
if ((double)(int)uVar10 < dVar11) {
dVar12 = dVar11 - (double)(int)uVar10;
}
}
auVar15 = js_number(dVar12);
}
else {
if (iVar5 != 0) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),dVar12);
goto LAB_00171a89;
}
auVar15 = ZEXT416(auVar13._0_4_ - uVar10);
if (auVar13._0_4_ < iVar4) {
auVar15 = ZEXT816(0);
}
}
}
JS_DefinePropertyValue(param_1,lVar6,uVar8,0x32,auVar15._0_8_,auVar15._8_8_,1);
auVar15 = JS_GetPropertyInternal2(param_1,param_2,param_3,0x37,param_2,param_3,0,0);
if (auVar15._8_4_ != -7) {
if (auVar15._8_4_ == 6) goto LAB_00171b2a;
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar15._0_8_,auVar15._8_8_);
piVar1 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + 0x178);
*piVar1 = *piVar1 + 1;
auVar15._8_8_ = 0xfffffffffffffff9;
auVar15._0_8_ = piVar1;
}
auVar15 = JS_ConcatString3(param_1,"bound ",auVar15._0_8_,auVar15._8_8_,"");
if (auVar15._8_4_ != 6) {
JS_DefinePropertyValue(param_1,lVar6,uVar8,0x37,auVar15._0_8_,auVar15._8_8_,1);
return auVar14;
}
}
}
LAB_00171b2a:
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),lVar6,uVar8);
LAB_001718cd:
return ZEXT816(6) << 0x40;
}
|
|
57,762
|
void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, 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>::string_t&)
|
monkey531[P]llama/common/json.hpp
|
inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
{
if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
{
JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
}
s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
}
|
O1
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, 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>::string_t&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0x8939a
movq 0x8(%r14), %rax
movq %rsi, %rdi
movq %rax, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1b4b0
movl $0x20, %edi
callq 0x1b430
movq %rax, %rbx
movq %r14, %rdi
callq 0x60036
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x697ef(%rip), %rsi # 0xf2bad
leaq 0x10(%rsp), %rdi
callq 0x8858f
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x883c0
xorl %ebp, %ebp
leaq 0xa3b2f(%rip), %rsi # 0x12cf18
leaq -0x2d278(%rip), %rdx # 0x5c178
movq %rbx, %rdi
callq 0x1bf20
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8941e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b8e0
jmp 0x8941e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8942b
movq %rbx, %rdi
callq 0x1b670
movq %r14, %rdi
callq 0x1bfb0
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEvRKT_RNSG_8string_tE:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 3
jnz short loc_8939A
mov rax, [r14+8]
mov rdi, rsi
mov rsi, rax
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
loc_8939A:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aTypeMustBeStri; "type must be string, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8941E
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8941E
mov r14, rax
mov bpl, 1
loc_8941E:
test bpl, bpl
jz short loc_8942B
mov rdi, rbx; void *
call ___cxa_free_exception
loc_8942B:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
long long a1,
long long a2)
{
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v4; // [rsp+8h] [rbp-40h] BYREF
_QWORD v5[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 3 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v4 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v5,
(long long)"type must be string, but is ",
&v4);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
v5);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return std::string::_M_assign(a2, *(_QWORD *)(a1 + 8));
}
|
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x3
JNZ 0x0018939a
MOV RAX,qword ptr [R14 + 0x8]
MOV RDI,RSI
MOV RSI,RAX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP 0x0011b4b0
LAB_0018939a:
MOV EDI,0x20
CALL 0x0011b430
MOV RBX,RAX
MOV RDI,R14
CALL 0x00160036
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001893b7:
LEA RSI,[0x1f2bad]
LEA RDI,[RSP + 0x10]
CALL 0x0018858f
MOV BPL,0x1
LAB_001893cb:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x001883c0
XOR EBP,EBP
LEA RSI,[0x22cf18]
LEA RDX,[0x15c178]
MOV RDI,RBX
CALL 0x0011bf20
|
/* void
nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::string_t&) */
void nlohmann::json_abi_v3_11_3::detail::
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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 *param_1,string_t *param_2)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*param_1 == (basic_json)0x3) {
std::__cxx11::string::_M_assign((string *)param_2);
return;
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (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>
::type_name((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
/* try { // try from 001893b7 to 001893c7 has its CatchHandler @ 00189418 */
concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be string, but is ",&local_40);
/* try { // try from 001893cb to 001893f7 has its CatchHandler @ 001893f8 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&type_error::typeinfo,exception::~exception);
}
|
|
57,763
|
my_aes_get_size
|
eloqsql/mysys_ssl/my_crypt.cc
|
unsigned int my_aes_get_size(enum my_aes_mode mode __attribute__((unused)), unsigned int source_length)
{
#ifdef HAVE_EncryptAes128Ctr
if (mode == MY_AES_CTR)
return source_length;
#ifdef HAVE_EncryptAes128Gcm
if (mode == MY_AES_GCM)
return source_length + MY_AES_BLOCK_SIZE;
#endif
#endif
return (source_length / MY_AES_BLOCK_SIZE + 1) * MY_AES_BLOCK_SIZE;
}
|
O3
|
cpp
|
my_aes_get_size:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
cmpl $0x2, %edi
je 0xd7b53
cmpl $0x3, %edi
je 0xd7b50
andl $-0x10, %eax
addl $0x10, %eax
popq %rbp
retq
|
my_aes_get_size:
push rbp
mov rbp, rsp
mov eax, esi
cmp edi, 2
jz short loc_D7B53
cmp edi, 3
jz short loc_D7B50
and eax, 0FFFFFFF0h
loc_D7B50:
add eax, 10h
loc_D7B53:
pop rbp
retn
|
long long my_aes_get_size(int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( a1 != 2 )
{
if ( a1 != 3 )
LODWORD(result) = a2 & 0xFFFFFFF0;
return (unsigned int)(result + 16);
}
return result;
}
|
my_aes_get_size:
PUSH RBP
MOV RBP,RSP
MOV EAX,ESI
CMP EDI,0x2
JZ 0x001d7b53
CMP EDI,0x3
JZ 0x001d7b50
AND EAX,0xfffffff0
LAB_001d7b50:
ADD EAX,0x10
LAB_001d7b53:
POP RBP
RET
|
uint my_aes_get_size(int param_1,uint param_2)
{
if (param_1 != 2) {
if (param_1 != 3) {
param_2 = param_2 & 0xfffffff0;
}
param_2 = param_2 + 0x10;
}
return param_2;
}
|
|
57,764
|
ma_write_keypage
|
eloqsql/storage/maria/ma_page.c
|
my_bool _ma_write_keypage(MARIA_PAGE *page, enum pagecache_page_lock lock,
int level)
{
MARIA_SHARE *share= page->info->s;
uint block_size= share->block_size;
uchar *buff= page->buff;
my_bool res;
MARIA_PINNED_PAGE page_link;
DBUG_ENTER("_ma_write_keypage");
/*
The following ensures that for transactional tables we have logged
all changes that changes the page size (as the logging code sets
page->org_size)
*/
DBUG_ASSERT(!share->now_transactional || page->size == page->org_size);
#ifdef EXTRA_DEBUG /* Safety check */
{
uint page_length, nod_flag;
page_length= _ma_get_page_used(share, buff);
nod_flag= _ma_test_if_nod(share, buff);
DBUG_ASSERT(page->size == page_length);
DBUG_ASSERT(page->size <= share->max_index_block_size);
DBUG_ASSERT(page->flag == _ma_get_keypage_flag(share, buff));
if (page->pos < share->base.keystart ||
page->pos+block_size > share->state.state.key_file_length ||
(page->pos & (maria_block_size-1)))
{
DBUG_PRINT("error",("Trying to write inside key status region: "
"key_start: %lu length: %lu page_pos: %lu",
(long) share->base.keystart,
(long) share->state.state.key_file_length,
(long) page->pos));
my_errno=EINVAL;
DBUG_ASSERT(0);
DBUG_RETURN(1);
}
DBUG_PRINT("page",("write page at: %lu",(ulong) (page->pos / block_size)));
DBUG_DUMP("buff", buff, page_length);
DBUG_ASSERT(page_length >= share->keypage_header + nod_flag +
page->keyinfo->minlength || maria_in_recovery);
}
#endif
/* Verify that keynr is correct */
DBUG_ASSERT(_ma_get_keynr(share, buff) == page->keyinfo->key_nr);
#if defined(EXTRA_DEBUG) && defined(HAVE_valgrind) && defined(WHEN_DEBUGGING)
MEM_CHECK_DEFINED(buff, block_size);
#endif
page_cleanup(share, page);
{
PAGECACHE_BLOCK_LINK **link;
enum pagecache_page_pin pin;
if (lock == PAGECACHE_LOCK_LEFT_WRITELOCKED)
{
pin= PAGECACHE_PIN_LEFT_PINNED;
link= &page_link.link;
}
else if (lock == PAGECACHE_LOCK_WRITE_UNLOCK)
{
pin= PAGECACHE_UNPIN;
/*
We unlock this page so link should be 0 to prevent it usage
even accidentally
*/
link= NULL;
}
else
{
pin= PAGECACHE_PIN;
link= &page_link.link;
}
res= pagecache_write(share->pagecache,
&share->kfile,
(pgcache_page_no_t) (page->pos / block_size),
level, buff, share->page_type,
lock, pin, PAGECACHE_WRITE_DELAY, link,
LSN_IMPOSSIBLE);
}
if (lock == PAGECACHE_LOCK_WRITE)
{
/* It was not locked before, we have to unlock it when we unpin pages */
page_link.unlock= PAGECACHE_LOCK_WRITE_UNLOCK;
page_link.changed= 1;
push_dynamic(&page->info->pinned_pages, (void*) &page_link);
}
DBUG_RETURN(res);
}
|
O3
|
c
|
ma_write_keypage:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ecx
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rdi), %r8
movq (%rax), %r9
movl 0x7bc(%r9), %r12d
leaq -0x38(%rbp), %r11
xorl %r10d, %r10d
cmpl $0x2, %esi
je 0x6fc32
cmpl $0x6, %r14d
jne 0x6fc37
movl $0x3, %r15d
xorl %r11d, %r11d
jmp 0x6fc3d
xorl %r15d, %r15d
jmp 0x6fc3d
movl $0x2, %r15d
movq 0x600(%r9), %rdi
leaq 0x750(%r9), %rsi
movq 0x18(%rbx), %rax
xorl %edx, %edx
divq %r12
movl 0x7d4(%r9), %r9d
movl 0x80(%rdi), %r12d
subq $0x8, %rsp
movq %rax, %rdx
pushq %r12
pushq %r10
pushq $0x0
pushq %r11
pushq %r10
pushq %r15
pushq %r14
callq 0x3ce66
addq $0x40, %rsp
movl %eax, %r15d
cmpl $0x4, %r14d
jne 0x6fca5
leaq -0x38(%rbp), %rsi
movl $0x6, 0x8(%rsi)
movb $0x1, 0x10(%rsi)
movl $0x2e8, %edi # imm = 0x2E8
addq (%rbx), %rdi
callq 0x92312
movl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
_ma_write_keypage:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov ecx, edx
mov r14d, esi
mov rbx, rdi
mov rax, [rdi]
mov r8, [rdi+10h]
mov r9, [rax]
mov r12d, [r9+7BCh]
lea r11, [rbp+var_38]
xor r10d, r10d
cmp esi, 2
jz short loc_6FC32
cmp r14d, 6
jnz short loc_6FC37
mov r15d, 3
xor r11d, r11d
jmp short loc_6FC3D
loc_6FC32:
xor r15d, r15d
jmp short loc_6FC3D
loc_6FC37:
mov r15d, 2
loc_6FC3D:
mov rdi, [r9+600h]
lea rsi, [r9+750h]
mov rax, [rbx+18h]
xor edx, edx
div r12
mov r9d, [r9+7D4h]
mov r12d, [rdi+80h]
sub rsp, 8
mov rdx, rax
push r12
push r10
push 0
push r11
push r10
push r15
push r14
call pagecache_write_part
add rsp, 40h
mov r15d, eax
cmp r14d, 4
jnz short loc_6FCA5
lea rsi, [rbp+var_38]
mov dword ptr [rsi+8], 6
mov byte ptr [rsi+10h], 1
mov edi, 2E8h
add rdi, [rbx]
call insert_dynamic
loc_6FCA5:
mov eax, r15d
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long ma_write_keypage(long long **a1, unsigned int a2, int a3)
{
long long v3; // r9
_QWORD *v4; // r11
unsigned int v5; // r15d
unsigned int v6; // r15d
_BYTE v8[8]; // [rsp+8h] [rbp-38h] BYREF
int v9; // [rsp+10h] [rbp-30h]
char v10; // [rsp+18h] [rbp-28h]
v4 = v8;
if ( a2 == 2 )
{
v5 = 0;
}
else if ( a2 == 6 )
{
v5 = 3;
v4 = 0LL;
}
else
{
v5 = 2;
}
v3 = **a1;
v6 = pagecache_write_part(
*(__m128i **)(v3 + 1536),
(char *)(v3 + 1872),
(unsigned long long)a1[3] / *(unsigned int *)(v3 + 1980),
a3,
(char *)a1[2],
*(_DWORD *)(v3 + 2004),
a2,
v5,
0,
v4,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(v3 + 1536) + 128LL));
if ( a2 == 4 )
{
v9 = 6;
v10 = 1;
insert_dynamic(*a1 + 93, v8);
}
return v6;
}
|
_ma_write_keypage:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV ECX,EDX
MOV R14D,ESI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x10]
MOV R9,qword ptr [RAX]
MOV R12D,dword ptr [R9 + 0x7bc]
LEA R11,[RBP + -0x38]
XOR R10D,R10D
CMP ESI,0x2
JZ 0x0016fc32
CMP R14D,0x6
JNZ 0x0016fc37
MOV R15D,0x3
XOR R11D,R11D
JMP 0x0016fc3d
LAB_0016fc32:
XOR R15D,R15D
JMP 0x0016fc3d
LAB_0016fc37:
MOV R15D,0x2
LAB_0016fc3d:
MOV RDI,qword ptr [R9 + 0x600]
LEA RSI,[R9 + 0x750]
MOV RAX,qword ptr [RBX + 0x18]
XOR EDX,EDX
DIV R12
MOV R9D,dword ptr [R9 + 0x7d4]
MOV R12D,dword ptr [RDI + 0x80]
SUB RSP,0x8
MOV RDX,RAX
PUSH R12
PUSH R10
PUSH 0x0
PUSH R11
PUSH R10
PUSH R15
PUSH R14
CALL 0x0013ce66
ADD RSP,0x40
MOV R15D,EAX
CMP R14D,0x4
JNZ 0x0016fca5
LEA RSI,[RBP + -0x38]
MOV dword ptr [RSI + 0x8],0x6
MOV byte ptr [RSI + 0x10],0x1
MOV EDI,0x2e8
ADD RDI,qword ptr [RBX]
CALL 0x00192312
LAB_0016fca5:
MOV EAX,R15D
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int4 _ma_write_keypage(long *param_1,int param_2,int4 param_3)
{
long lVar1;
int4 uVar2;
int1 *puVar3;
int8 uVar4;
int1 local_40 [8];
int4 local_38;
int1 local_30;
lVar1 = *(long *)*param_1;
puVar3 = local_40;
if (param_2 == 2) {
uVar4 = 0;
}
else if (param_2 == 6) {
uVar4 = 3;
puVar3 = (int1 *)0x0;
}
else {
uVar4 = 2;
}
uVar2 = pagecache_write_part
(*(long *)(lVar1 + 0x600),lVar1 + 0x750,
(ulong)param_1[3] / (ulong)*(uint *)(lVar1 + 0x7bc),param_3,param_1[2],
*(int4 *)(lVar1 + 0x7d4),param_2,uVar4,0,puVar3,0,0,
*(int4 *)(*(long *)(lVar1 + 0x600) + 0x80));
if (param_2 == 4) {
local_38 = 6;
local_30 = 1;
insert_dynamic(*param_1 + 0x2e8);
}
return uVar2;
}
|
|
57,765
|
inline_mysql_start_table_lock_wait
|
eloqsql/include/mysql/psi/mysql_table.h
|
static inline struct PSI_table_locker *
inline_mysql_start_table_lock_wait(PSI_table_locker_state *state,
struct PSI_table *psi,
enum PSI_table_lock_operation op,
ulong flags, const char *src_file, uint src_line)
{
if (psi_likely(psi != NULL))
{
struct PSI_table_locker *locker;
locker= PSI_TABLE_CALL(start_table_lock_wait)
(state, psi, op, flags, src_file, src_line);
return locker;
}
return NULL;
}
|
O0
|
c
|
inline_mysql_start_table_lock_wait:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xc41f7
leaq 0x1c513a(%rip), %rax # 0x289300
movq (%rax), %rax
movq 0x1e0(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl -0x34(%rbp), %r9d
callq *%rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc41ff
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
|
inline_mysql_start_table_lock_wait:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_34], r9d
cmp [rbp+var_18], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_C41F7
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1E0h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9d, [rbp+var_34]
call rax
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
jmp short loc_C41FF
loc_C41F7:
mov [rbp+var_8], 0
loc_C41FF:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
long long inline_mysql_start_table_lock_wait(
long long a1,
long long a2,
unsigned int a3,
long long a4,
long long a5,
unsigned int a6)
{
if ( a2 )
return ((long long ( *)(long long, long long, _QWORD, long long, long long, _QWORD))PSI_server[60])(
a1,
a2,
a3,
a4,
a5,
a6);
else
return 0LL;
}
|
inline_mysql_start_table_lock_wait:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x34],R9D
CMP qword ptr [RBP + -0x18],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001c41f7
LEA RAX,[0x389300]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1e0]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9D,dword ptr [RBP + -0x34]
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001c41ff
LAB_001c41f7:
MOV qword ptr [RBP + -0x8],0x0
LAB_001c41ff:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8
inline_mysql_start_table_lock_wait
(int8 param_1,long param_2,int4 param_3,int8 param_4,int8 param_5,
int4 param_6)
{
int8 local_10;
if (param_2 == 0) {
local_10 = 0;
}
else {
local_10 = (**(code **)(PSI_server + 0x1e0))(param_1,param_2,param_3,param_4,param_5,param_6);
}
return local_10;
}
|
|
57,766
|
ma_ft_erase
|
eloqsql/storage/maria/ma_ft_update.c
|
static int _ma_ft_erase(MARIA_HA *info, uint keynr, uchar *keybuf,
FT_WORD *wlist, my_off_t filepos)
{
uint err=0;
DBUG_ENTER("_ma_ft_erase");
for (; wlist->pos; wlist++)
{
MARIA_KEY key;
_ma_ft_make_key(info, &key, keynr, keybuf, wlist, filepos);
if (_ma_ck_delete(info, &key))
err=1;
}
DBUG_RETURN(err);
}
|
O0
|
c
|
ma_ft_erase:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8ce10
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq -0x50(%rbp), %rsi
callq 0x8cc30
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x87870
cmpb $0x0, %al
je 0x8ce00
movl $0x1, -0x2c(%rbp)
jmp 0x8ce02
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x8cdc2
jmp 0x8ce12
movl -0x2c(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ma_ft_erase:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_2C], 0
loc_8CDC2:
mov rax, [rbp+var_20]
cmp qword ptr [rax], 0
jz short loc_8CE10
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_20]
mov r9, [rbp+var_28]
lea rsi, [rbp+var_50]
call _ma_ft_make_key
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_50]
call _ma_ck_delete
cmp al, 0
jz short loc_8CE00
mov [rbp+var_2C], 1
loc_8CE00:
jmp short $+2
loc_8CE02:
mov rax, [rbp+var_20]
add rax, 18h
mov [rbp+var_20], rax
jmp short loc_8CDC2
loc_8CE10:
jmp short $+2
loc_8CE12:
mov eax, [rbp+var_2C]
mov [rbp+var_54], eax
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
|
long long ma_ft_erase(long long *a1, unsigned int a2, _BYTE *a3, _QWORD *a4, long long a5)
{
long long v6[4]; // [rsp+10h] [rbp-50h] BYREF
unsigned int v7; // [rsp+34h] [rbp-2Ch]
long long v8; // [rsp+38h] [rbp-28h]
_QWORD *v9; // [rsp+40h] [rbp-20h]
_BYTE *v10; // [rsp+48h] [rbp-18h]
unsigned int v11; // [rsp+54h] [rbp-Ch]
long long *v12; // [rsp+58h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v8 = a5;
v7 = 0;
while ( *v9 )
{
ma_ft_make_key(v12, (long long)v6, v11, v10, (long long)v9, v8);
if ( ma_ck_delete(v12, v6) )
v7 = 1;
v9 += 3;
}
return v7;
}
|
_ma_ft_erase:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV dword ptr [RBP + -0x2c],0x0
LAB_0018cdc2:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX],0x0
JZ 0x0018ce10
MOV RDI,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x20]
MOV R9,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x50]
CALL 0x0018cc30
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x50]
CALL 0x00187870
CMP AL,0x0
JZ 0x0018ce00
MOV dword ptr [RBP + -0x2c],0x1
LAB_0018ce00:
JMP 0x0018ce02
LAB_0018ce02:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0018cdc2
LAB_0018ce10:
JMP 0x0018ce12
LAB_0018ce12:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x54],EAX
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4
_ma_ft_erase(int8 param_1,int4 param_2,int8 param_3,long *param_4,
int8 param_5)
{
char cVar1;
int1 local_58 [36];
int4 local_34;
int8 local_30;
long *local_28;
int8 local_20;
int4 local_14;
int8 local_10;
local_34 = 0;
local_30 = param_5;
local_20 = param_3;
local_14 = param_2;
local_10 = param_1;
for (local_28 = param_4; *local_28 != 0; local_28 = local_28 + 3) {
_ma_ft_make_key(local_10,local_58,local_14,local_20,local_28,local_30);
cVar1 = _ma_ck_delete(local_10,local_58);
if (cVar1 != '\0') {
local_34 = 1;
}
}
return local_34;
}
|
|
57,767
|
my_wc_mb_euc_jp
|
eloqsql/strings/ctype-ujis.c
|
static int
my_wc_mb_euc_jp(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_eucjp[wc])) /* JIS-X-0208 */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, jp);
return 2;
}
if ((jp= unicode_to_jisx0212_eucjp[wc])) /* JIS-X-0212 */
{
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_euc_jp:
cmpl $0x7f, %esi
jg 0xc9b2e
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xc9b63
movb %sil, (%rdx)
movl $0x1, %eax
retq
xorl %eax, %eax
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0xc9b63
leaq 0x24d070(%rip), %rdi # 0x316bb0
movzwl (%rdi,%rsi,2), %edi
testw %di, %di
je 0xc9b64
leaq 0x2(%rdx), %rsi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rsi
ja 0xc9b63
rolw $0x8, %di
movw %di, (%rdx)
movl $0x2, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq 0x26d040(%rip), %rdi # 0x336bb0
movzwl (%rdi,%rsi,2), %ebx
testw %bx, %bx
je 0xc9b97
leaq 0x3(%rdx), %rsi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rsi
ja 0xc9bc2
movb $-0x71, (%rdx)
movb %bh, 0x1(%rdx)
movb %bl, 0x2(%rdx)
movl $0x3, %eax
jmp 0xc9bc2
leaq -0xff61(%rsi), %rdi
cmpq $0x3e, %rdi
ja 0xc9bc2
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0xc9bc2
movb $-0x72, (%rdx)
addb $0x40, %sil
movb %sil, 0x1(%rdx)
movl $0x2, %eax
popq %rbx
popq %rbp
retq
|
my_wc_mb_euc_jp:
cmp esi, 7Fh
jg short loc_C9B2E
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_C9B63
mov [rdx], sil
mov eax, 1
retn
loc_C9B2E:
xor eax, eax
cmp rsi, 0FFFFh
ja short locret_C9B63
lea rdi, unicode_to_jisx0208_eucjp
movzx edi, word ptr [rdi+rsi*2]
test di, di
jz short loc_C9B64
lea rsi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rsi, rcx
ja short locret_C9B63
rol di, 8
mov [rdx], di
mov eax, 2
locret_C9B63:
retn
loc_C9B64:
push rbp
mov rbp, rsp
push rbx
lea rdi, unicode_to_jisx0212_eucjp
movzx ebx, word ptr [rdi+rsi*2]
test bx, bx
jz short loc_C9B97
lea rsi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rsi, rcx
ja short loc_C9BC2
mov byte ptr [rdx], 8Fh
mov [rdx+1], bh
mov [rdx+2], bl
mov eax, 3
jmp short loc_C9BC2
loc_C9B97:
lea rdi, [rsi-0FF61h]
cmp rdi, 3Eh ; '>'
ja short loc_C9BC2
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_C9BC2
mov byte ptr [rdx], 8Eh
add sil, 40h ; '@'
mov [rdx+1], sil
mov eax, 2
loc_C9BC2:
pop rbx
pop rbp
retn
|
long long my_wc_mb_euc_jp(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_eucjp[a2];
if ( v5 )
{
result = 4294967194LL;
if ( a3 + 2 <= a4 )
{
*(_WORD *)a3 = __ROL2__(v5, 8);
return 2LL;
}
}
else
{
v6 = unicode_to_jisx0212_eucjp[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_euc_jp:
CMP ESI,0x7f
JG 0x001c9b2e
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001c9b63
MOV byte ptr [RDX],SIL
MOV EAX,0x1
RET
LAB_001c9b2e:
XOR EAX,EAX
CMP RSI,0xffff
JA 0x001c9b63
LEA RDI,[0x416bb0]
MOVZX EDI,word ptr [RDI + RSI*0x2]
TEST DI,DI
JZ 0x001c9b64
LEA RSI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RSI,RCX
JA 0x001c9b63
ROL DI,0x8
MOV word ptr [RDX],DI
MOV EAX,0x2
LAB_001c9b63:
RET
LAB_001c9b64:
PUSH RBP
MOV RBP,RSP
PUSH RBX
LEA RDI,[0x436bb0]
MOVZX EBX,word ptr [RDI + RSI*0x2]
TEST BX,BX
JZ 0x001c9b97
LEA RSI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RSI,RCX
JA 0x001c9bc2
MOV byte ptr [RDX],0x8f
MOV byte ptr [RDX + 0x1],BH
MOV byte ptr [RDX + 0x2],BL
MOV EAX,0x3
JMP 0x001c9bc2
LAB_001c9b97:
LEA RDI,[RSI + -0xff61]
CMP RDI,0x3e
JA 0x001c9bc2
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x001c9bc2
MOV byte ptr [RDX],0x8e
ADD SIL,0x40
MOV byte ptr [RDX + 0x1],SIL
MOV EAX,0x2
LAB_001c9bc2:
POP RBX
POP RBP
RET
|
int8 my_wc_mb_euc_jp(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_eucjp + param_2 * 2);
if (uVar1 == 0) {
sVar2 = *(short *)(unicode_to_jisx0212_eucjp + 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;
}
|
|
57,768
|
rak_record_print
|
fabiosvm[P]rak/src/record.c
|
void rak_record_print(RakRecord *rec)
{
printf("{");
int len = rak_record_len(rec);
for (int i = 0; i < len; ++i)
{
if (i > 0) printf(", ");
RakRecordField field = rak_record_get(rec, i);
rak_string_print(field.name);
printf(": ");
rak_value_print(field.val);
}
printf("}");
}
|
O1
|
c
|
rak_record_print:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x7b, %edi
callq 0x2040
movslq 0xc(%rbx), %rax
testq %rax, %rax
jle 0x7ee4
shlq $0x3, %rax
leaq (%rax,%rax,2), %rbp
leaq 0x29ff(%rip), %r14 # 0xa898
xorl %r15d, %r15d
testq %r15, %r15
je 0x7eaf
leaq 0x2176(%rip), %rdi # 0xa01e
xorl %eax, %eax
callq 0x2090
movq 0x10(%rbx), %rax
movq (%rax,%r15), %rdi
movq 0x8(%rax,%r15), %r12
movq 0x10(%rax,%r15), %r13
callq 0x83e4
movq %r14, %rdi
xorl %eax, %eax
callq 0x2090
movq %r12, %rdi
movq %r13, %rsi
callq 0x86c9
addq $0x18, %r15
cmpq %r15, %rbp
jne 0x7e9c
movl $0x7d, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
|
rak_record_print:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov edi, 7Bh ; '{'
call _putchar
movsxd rax, dword ptr [rbx+0Ch]
test rax, rax
jle short loc_7EE4
shl rax, 3
lea rbp, [rax+rax*2]
lea r14, asc_A898; ": "
xor r15d, r15d
loc_7E9C:
test r15, r15
jz short loc_7EAF
lea rdi, off_A01E
xor eax, eax
call _printf
loc_7EAF:
mov rax, [rbx+10h]
mov rdi, [rax+r15]
mov r12, [rax+r15+8]
mov r13, [rax+r15+10h]
call rak_string_print
mov rdi, r14
xor eax, eax
call _printf
mov rdi, r12
mov rsi, r13
call rak_value_print
add r15, 18h
cmp rbp, r15
jnz short loc_7E9C
loc_7EE4:
mov edi, 7Dh ; '}'
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _putchar
|
long long rak_record_print(long long a1)
{
long long v1; // rax
long long v2; // rbp
long long v3; // r15
long long v4; // rax
long long v5; // r12
long long v6; // r13
putchar(123LL);
v1 = *(int *)(a1 + 12);
if ( v1 > 0 )
{
v2 = 24 * v1;
v3 = 0LL;
do
{
if ( v3 )
printf((const char *)&off_A01E);
v4 = *(_QWORD *)(a1 + 16);
v5 = *(_QWORD *)(v4 + v3 + 8);
v6 = *(_QWORD *)(v4 + v3 + 16);
rak_string_print(*(_QWORD *)(v4 + v3));
printf(": ");
rak_value_print(v5, v6);
v3 += 24LL;
}
while ( v2 != v3 );
}
return putchar(125LL);
}
|
rak_record_print:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV EDI,0x7b
CALL 0x00102040
MOVSXD RAX,dword ptr [RBX + 0xc]
TEST RAX,RAX
JLE 0x00107ee4
SHL RAX,0x3
LEA RBP,[RAX + RAX*0x2]
LEA R14,[0x10a898]
XOR R15D,R15D
LAB_00107e9c:
TEST R15,R15
JZ 0x00107eaf
LEA RDI,[0x10a01e]
XOR EAX,EAX
CALL 0x00102090
LAB_00107eaf:
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RAX + R15*0x1]
MOV R12,qword ptr [RAX + R15*0x1 + 0x8]
MOV R13,qword ptr [RAX + R15*0x1 + 0x10]
CALL 0x001083e4
MOV RDI,R14
XOR EAX,EAX
CALL 0x00102090
MOV RDI,R12
MOV RSI,R13
CALL 0x001086c9
ADD R15,0x18
CMP RBP,R15
JNZ 0x00107e9c
LAB_00107ee4:
MOV EDI,0x7d
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00102040
|
void rak_record_print(long param_1)
{
int iVar1;
long lVar2;
int8 uVar3;
int8 uVar4;
long lVar5;
putchar(0x7b);
iVar1 = *(int *)(param_1 + 0xc);
if (0 < (long)iVar1) {
lVar5 = 0;
do {
if (lVar5 != 0) {
printf(", ");
}
lVar2 = *(long *)(param_1 + 0x10);
uVar3 = *(int8 *)(lVar2 + 8 + lVar5);
uVar4 = *(int8 *)(lVar2 + 0x10 + lVar5);
rak_string_print(*(int8 *)(lVar2 + lVar5));
printf(": ");
rak_value_print(uVar3,uVar4);
lVar5 = lVar5 + 0x18;
} while ((long)iVar1 * 0x18 != lVar5);
}
putchar(0x7d);
return;
}
|
|
57,769
|
rak_record_print
|
fabiosvm[P]rak/src/record.c
|
void rak_record_print(RakRecord *rec)
{
printf("{");
int len = rak_record_len(rec);
for (int i = 0; i < len; ++i)
{
if (i > 0) printf(", ");
RakRecordField field = rak_record_get(rec, i);
rak_string_print(field.name);
printf(": ");
rak_value_print(field.val);
}
printf("}");
}
|
O2
|
c
|
rak_record_print:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x7b
popq %rdi
callq 0x2040
movl 0xc(%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
imulq $0x18, %rax, %rbp
leaq 0x333f(%rip), %r14 # 0x98ed
xorl %r15d, %r15d
cmpq %r15, %rbp
je 0x65fb
testq %r15, %r15
je 0x65c9
leaq 0x2a5c(%rip), %rdi # 0x901e
xorl %eax, %eax
callq 0x2090
movq 0x10(%rbx), %rax
movq (%rax,%r15), %rdi
movq 0x8(%rax,%r15), %r12
movq 0x10(%rax,%r15), %r13
callq 0x6a2d
movq %r14, %rdi
xorl %eax, %eax
callq 0x2090
movq %r12, %rdi
movq %r13, %rsi
callq 0x6ca0
addq $0x18, %r15
jmp 0x65b1
pushq $0x7d
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
nopl (%rax)
|
rak_record_print:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
push 7Bh ; '{'
pop rdi
call _putchar
mov eax, [rbx+0Ch]
xor ecx, ecx
test eax, eax
cmovle eax, ecx
imul rbp, rax, 18h
lea r14, asc_98ED; ": "
xor r15d, r15d
loc_65B1:
cmp rbp, r15
jz short loc_65FB
test r15, r15
jz short loc_65C9
lea rdi, off_901E
xor eax, eax
call _printf
loc_65C9:
mov rax, [rbx+10h]
mov rdi, [rax+r15]
mov r12, [rax+r15+8]
mov r13, [rax+r15+10h]
call rak_string_print
mov rdi, r14
xor eax, eax
call _printf
mov rdi, r12
mov rsi, r13
call rak_value_print
add r15, 18h
jmp short loc_65B1
loc_65FB:
push 7Dh ; '}'
pop rdi
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _putchar
|
long long rak_record_print(long long a1)
{
long long v1; // rax
long long v2; // rbp
long long i; // r15
long long v4; // rax
long long v5; // r12
long long v6; // r13
putchar(123LL);
v1 = *(unsigned int *)(a1 + 12);
if ( (int)v1 <= 0 )
v1 = 0LL;
v2 = 24 * v1;
for ( i = 0LL; v2 != i; i += 24LL )
{
if ( i )
printf((const char *)&off_901E);
v4 = *(_QWORD *)(a1 + 16);
v5 = *(_QWORD *)(v4 + i + 8);
v6 = *(_QWORD *)(v4 + i + 16);
rak_string_print(*(_QWORD *)(v4 + i));
printf(": ");
rak_value_print(v5, v6);
}
return putchar(125LL);
}
|
rak_record_print:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
PUSH 0x7b
POP RDI
CALL 0x00102040
MOV EAX,dword ptr [RBX + 0xc]
XOR ECX,ECX
TEST EAX,EAX
CMOVLE EAX,ECX
IMUL RBP,RAX,0x18
LEA R14,[0x1098ed]
XOR R15D,R15D
LAB_001065b1:
CMP RBP,R15
JZ 0x001065fb
TEST R15,R15
JZ 0x001065c9
LEA RDI,[0x10901e]
XOR EAX,EAX
CALL 0x00102090
LAB_001065c9:
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RAX + R15*0x1]
MOV R12,qword ptr [RAX + R15*0x1 + 0x8]
MOV R13,qword ptr [RAX + R15*0x1 + 0x10]
CALL 0x00106a2d
MOV RDI,R14
XOR EAX,EAX
CALL 0x00102090
MOV RDI,R12
MOV RSI,R13
CALL 0x00106ca0
ADD R15,0x18
JMP 0x001065b1
LAB_001065fb:
PUSH 0x7d
POP RDI
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00102040
|
void rak_record_print(long param_1)
{
long lVar1;
int8 uVar2;
int8 uVar3;
ulong uVar4;
long lVar5;
putchar(0x7b);
uVar4 = (ulong)*(uint *)(param_1 + 0xc);
if ((int)*(uint *)(param_1 + 0xc) < 1) {
uVar4 = 0;
}
for (lVar5 = 0; uVar4 * 0x18 - lVar5 != 0; lVar5 = lVar5 + 0x18) {
if (lVar5 != 0) {
printf(", ");
}
lVar1 = *(long *)(param_1 + 0x10);
uVar2 = *(int8 *)(lVar1 + 8 + lVar5);
uVar3 = *(int8 *)(lVar1 + 0x10 + lVar5);
rak_string_print(*(int8 *)(lVar1 + lVar5));
printf(": ");
rak_value_print(uVar2,uVar3);
}
putchar(0x7d);
return;
}
|
|
57,770
|
mi_ft_update
|
eloqsql/storage/myisam/ft_update.c
|
int _mi_ft_update(MI_INFO *info, uint keynr, uchar *keybuf,
const uchar *oldrec, const uchar *newrec, my_off_t pos)
{
int error= -1;
FT_WORD *oldlist,*newlist, *old_word, *new_word;
CHARSET_INFO *cs=info->s->keyinfo[keynr].seg->charset;
uint key_length;
int cmp, cmp2;
DBUG_ENTER("_mi_ft_update");
if (!(old_word=oldlist=_mi_ft_parserecord(info, keynr, oldrec,
&info->ft_memroot)) ||
!(new_word=newlist=_mi_ft_parserecord(info, keynr, newrec,
&info->ft_memroot)))
goto err;
error=0;
while(old_word->pos && new_word->pos)
{
cmp= ha_compare_text(cs, (uchar*) old_word->pos,old_word->len,
(uchar*) new_word->pos,new_word->len,0);
cmp2= cmp ? 0 : (fabs(old_word->weight - new_word->weight) > 1.e-5);
if (cmp < 0 || cmp2)
{
key_length=_ft_make_key(info,keynr,keybuf,old_word,pos);
if ((error=_mi_ck_delete(info,keynr,(uchar*) keybuf,key_length)))
goto err;
}
if (cmp > 0 || cmp2)
{
key_length=_ft_make_key(info,keynr,keybuf,new_word,pos);
if ((error=_mi_ck_write(info,keynr,(uchar*) keybuf,key_length)))
goto err;
}
if (cmp<=0) old_word++;
if (cmp>=0) new_word++;
}
if (old_word->pos)
error=_mi_ft_erase(info,keynr,keybuf,old_word,pos);
else if (new_word->pos)
error=_mi_ft_store(info,keynr,keybuf,new_word,pos);
err:
free_root(&info->ft_memroot, MYF(MY_MARK_BLOCKS_FREE));
DBUG_RETURN(error);
}
|
O3
|
c
|
mi_ft_update:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, -0x50(%rbp)
movq %r8, -0x58(%rbp)
movq %rdx, -0x48(%rbp)
movl %esi, %r13d
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x218(%rax), %rax
movl %esi, %edx
imulq $0x70, %rdx, %rdx
movq 0x28(%rax,%rdx), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
leaq 0x90(%rdi), %r15
movq %rcx, %rdx
movq %r15, %rcx
callq 0x754f7
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x7582a
movq %rax, %r14
movq %rbx, -0x40(%rbp)
movq %rbx, %rdi
movl %r13d, %esi
movq -0x58(%rbp), %rdx
movq %r15, %rcx
callq 0x754f7
testq %rax, %rax
je 0x7582a
movq %rax, %rbx
movq (%r14), %rsi
testq %rsi, %rsi
movq %r15, -0x38(%rbp)
je 0x757e8
movl %r13d, -0x2c(%rbp)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x7580c
movq 0x10(%r14), %rdx
movq 0x10(%rbx), %r8
xorl %r13d, %r13d
movq -0x60(%rbp), %rdi
xorl %r9d, %r9d
callq 0x9fc34
movl %eax, %r15d
testl %eax, %eax
jne 0x7573a
movsd 0x8(%r14), %xmm0
subsd 0x8(%rbx), %xmm0
andpd 0x649e2(%rip), %xmm0 # 0xda110
ucomisd 0x6cf4a(%rip), %xmm0 # 0xe2680
seta %r13b
testl %r15d, %r15d
js 0x75744
testb %r13b, %r13b
je 0x75783
movq -0x40(%rbp), %rdi
movl %r13d, -0x58(%rbp)
movl -0x2c(%rbp), %r13d
movl %r13d, %esi
movq -0x48(%rbp), %r12
movq %r12, %rdx
movq %r14, %rcx
movq -0x50(%rbp), %r8
callq 0x75849
movq -0x40(%rbp), %rdi
movl %r13d, %esi
movl -0x58(%rbp), %r13d
movq %r12, %rdx
movl %eax, %ecx
callq 0x75fa1
testl %eax, %eax
jne 0x75823
testl %r15d, %r15d
setg %al
orb %r13b, %al
testb $0x1, %al
movl -0x2c(%rbp), %r13d
je 0x757c9
movq -0x40(%rbp), %r13
movq %r13, %rdi
movl -0x2c(%rbp), %esi
movq -0x48(%rbp), %r12
movq %r12, %rdx
movq %rbx, %rcx
movq -0x50(%rbp), %r8
callq 0x75849
movq %r13, %rdi
movl -0x2c(%rbp), %r13d
movl %r13d, %esi
movq %r12, %rdx
movl %eax, %ecx
callq 0x894af
testl %eax, %eax
jne 0x75823
leaq 0x18(%r14), %rax
leaq 0x18(%rbx), %rcx
testl %r15d, %r15d
cmovleq %rax, %r14
cmovnsq %rcx, %rbx
movq (%r14), %rsi
testq %rsi, %rsi
jne 0x756f1
cmpq $0x0, (%rbx)
movq -0x40(%rbp), %rdi
je 0x75807
movl %r13d, %esi
movq -0x48(%rbp), %rdx
movq %rbx, %rcx
movq -0x50(%rbp), %r8
callq 0x7596b
jmp 0x75823
xorl %r12d, %r12d
jmp 0x75826
movq -0x40(%rbp), %rdi
movl %r13d, %esi
movq -0x48(%rbp), %rdx
movq %r14, %rcx
movq -0x50(%rbp), %r8
callq 0x758e4
movl %eax, %r12d
movq -0x38(%rbp), %r15
movl $0x2, %esi
movq %r15, %rdi
callq 0x9e1a3
movl %r12d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_mi_ft_update:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rbp+var_50], r9
mov [rbp+var_58], r8
mov [rbp+var_48], rdx
mov r13d, esi
mov rbx, rdi
mov rax, [rdi]
mov rax, [rax+218h]
mov edx, esi
imul rdx, 70h ; 'p'
mov rax, [rax+rdx+28h]
mov rax, [rax]
mov [rbp+var_60], rax
lea r15, [rdi+90h]
mov rdx, rcx
mov rcx, r15
call _mi_ft_parserecord
mov r12d, 0FFFFFFFFh
test rax, rax
jz loc_7582A
mov r14, rax
mov [rbp+var_40], rbx
mov rdi, rbx
mov esi, r13d
mov rdx, [rbp+var_58]
mov rcx, r15
call _mi_ft_parserecord
test rax, rax
jz loc_7582A
mov rbx, rax
mov rsi, [r14]
test rsi, rsi
mov [rbp+var_38], r15
jz loc_757E8
mov [rbp+var_2C], r13d
loc_756F1:
mov rcx, [rbx]
test rcx, rcx
jz loc_7580C
mov rdx, [r14+10h]
mov r8, [rbx+10h]
xor r13d, r13d
mov rdi, [rbp+var_60]
xor r9d, r9d
call ha_compare_text
mov r15d, eax
test eax, eax
jnz short loc_7573A
movsd xmm0, qword ptr [r14+8]
subsd xmm0, qword ptr [rbx+8]
andpd xmm0, cs:xmmword_DA110
ucomisd xmm0, cs:qword_E2680
setnbe r13b
loc_7573A:
test r15d, r15d
js short loc_75744
test r13b, r13b
jz short loc_75783
loc_75744:
mov rdi, [rbp+var_40]
mov dword ptr [rbp+var_58], r13d
mov r13d, [rbp+var_2C]
mov esi, r13d
mov r12, [rbp+var_48]
mov rdx, r12
mov rcx, r14
mov r8, [rbp+var_50]
call _ft_make_key
mov rdi, [rbp+var_40]
mov esi, r13d
mov r13d, dword ptr [rbp+var_58]
mov rdx, r12
mov ecx, eax
call _mi_ck_delete
test eax, eax
jnz loc_75823
loc_75783:
test r15d, r15d
setnle al
or al, r13b
test al, 1
mov r13d, [rbp+var_2C]
jz short loc_757C9
mov r13, [rbp+var_40]
mov rdi, r13
mov esi, [rbp+var_2C]
mov r12, [rbp+var_48]
mov rdx, r12
mov rcx, rbx
mov r8, [rbp+var_50]
call _ft_make_key
mov rdi, r13
mov r13d, [rbp+var_2C]
mov esi, r13d
mov rdx, r12
mov ecx, eax
call _mi_ck_write
test eax, eax
jnz short loc_75823
loc_757C9:
lea rax, [r14+18h]
lea rcx, [rbx+18h]
test r15d, r15d
cmovle r14, rax
cmovns rbx, rcx
mov rsi, [r14]
test rsi, rsi
jnz loc_756F1
loc_757E8:
cmp qword ptr [rbx], 0
mov rdi, [rbp+var_40]
jz short loc_75807
mov esi, r13d
mov rdx, [rbp+var_48]
mov rcx, rbx
mov r8, [rbp+var_50]
call _mi_ft_store
jmp short loc_75823
loc_75807:
xor r12d, r12d
jmp short loc_75826
loc_7580C:
mov rdi, [rbp+var_40]
mov esi, r13d
mov rdx, [rbp+var_48]
mov rcx, r14
mov r8, [rbp+var_50]
call _mi_ft_erase
loc_75823:
mov r12d, eax
loc_75826:
mov r15, [rbp+var_38]
loc_7582A:
mov esi, 2
mov rdi, r15
call free_root
mov eax, r12d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long mi_ft_update(_QWORD *a1, unsigned int a2, long long a3, long long a4, long long a5, long long a6)
{
unsigned int v6; // r13d
_QWORD *v7; // r15
double *v8; // rax
unsigned int v9; // r12d
double *v10; // r14
double *v11; // rax
double *v12; // rbx
double v13; // rsi
bool v14; // r13
int v15; // r15d
unsigned int key; // eax
unsigned int v17; // eax
bool v18; // zf
unsigned int v19; // eax
long long v21; // [rsp+0h] [rbp-60h]
unsigned int v25; // [rsp+34h] [rbp-2Ch]
v6 = a2;
v21 = **(_QWORD **)(*(_QWORD *)(*a1 + 536LL) + 112LL * a2 + 40);
v7 = a1 + 18;
v8 = (double *)mi_ft_parserecord(a1, a2, a4, (long long)(a1 + 18));
v9 = -1;
if ( v8 )
{
v10 = v8;
v11 = (double *)mi_ft_parserecord(a1, a2, a5, (long long)(a1 + 18));
if ( v11 )
{
v12 = v11;
v13 = *v10;
if ( *(_QWORD *)v10 )
{
v25 = v6;
while ( *(_QWORD *)v12 )
{
v14 = 0;
v15 = ha_compare_text(v21, *(_QWORD *)&v13, *((_QWORD *)v10 + 2), *(_QWORD *)v12, *((_QWORD *)v12 + 2), 0LL);
if ( !v15 )
v14 = fabs(v10[1] - v12[1]) > 0.00001;
if ( v15 < 0 || v14 )
{
key = ft_make_key(a1, v25, a3, v10, a6);
v17 = mi_ck_delete(a1, v25, a3, key);
if ( v17 )
goto LABEL_22;
}
v18 = !v14 && v15 <= 0;
v6 = v25;
if ( !v18 )
{
v19 = ft_make_key(a1, v25, a3, v12, a6);
v6 = v25;
v17 = mi_ck_write(a1, v25, a3, v19);
if ( v17 )
goto LABEL_22;
}
if ( v15 <= 0 )
v10 += 3;
if ( v15 >= 0 )
v12 += 3;
v13 = *v10;
if ( !*(_QWORD *)v10 )
goto LABEL_18;
}
v17 = mi_ft_erase(a1, v6, a3, v10, a6);
}
else
{
LABEL_18:
if ( !*(_QWORD *)v12 )
{
v9 = 0;
LABEL_23:
v7 = a1 + 18;
goto LABEL_24;
}
v17 = mi_ft_store(a1, v6, a3, v12, a6);
}
LABEL_22:
v9 = v17;
goto LABEL_23;
}
}
LABEL_24:
free_root(v7, 2LL);
return v9;
}
|
_mi_ft_update:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x50],R9
MOV qword ptr [RBP + -0x58],R8
MOV qword ptr [RBP + -0x48],RDX
MOV R13D,ESI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x218]
MOV EDX,ESI
IMUL RDX,RDX,0x70
MOV RAX,qword ptr [RAX + RDX*0x1 + 0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x60],RAX
LEA R15,[RDI + 0x90]
MOV RDX,RCX
MOV RCX,R15
CALL 0x001754f7
MOV R12D,0xffffffff
TEST RAX,RAX
JZ 0x0017582a
MOV R14,RAX
MOV qword ptr [RBP + -0x40],RBX
MOV RDI,RBX
MOV ESI,R13D
MOV RDX,qword ptr [RBP + -0x58]
MOV RCX,R15
CALL 0x001754f7
TEST RAX,RAX
JZ 0x0017582a
MOV RBX,RAX
MOV RSI,qword ptr [R14]
TEST RSI,RSI
MOV qword ptr [RBP + -0x38],R15
JZ 0x001757e8
MOV dword ptr [RBP + -0x2c],R13D
LAB_001756f1:
MOV RCX,qword ptr [RBX]
TEST RCX,RCX
JZ 0x0017580c
MOV RDX,qword ptr [R14 + 0x10]
MOV R8,qword ptr [RBX + 0x10]
XOR R13D,R13D
MOV RDI,qword ptr [RBP + -0x60]
XOR R9D,R9D
CALL 0x0019fc34
MOV R15D,EAX
TEST EAX,EAX
JNZ 0x0017573a
MOVSD XMM0,qword ptr [R14 + 0x8]
SUBSD XMM0,qword ptr [RBX + 0x8]
ANDPD XMM0,xmmword ptr [0x001da110]
UCOMISD XMM0,qword ptr [0x001e2680]
SETA R13B
LAB_0017573a:
TEST R15D,R15D
JS 0x00175744
TEST R13B,R13B
JZ 0x00175783
LAB_00175744:
MOV RDI,qword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x58],R13D
MOV R13D,dword ptr [RBP + -0x2c]
MOV ESI,R13D
MOV R12,qword ptr [RBP + -0x48]
MOV RDX,R12
MOV RCX,R14
MOV R8,qword ptr [RBP + -0x50]
CALL 0x00175849
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,R13D
MOV R13D,dword ptr [RBP + -0x58]
MOV RDX,R12
MOV ECX,EAX
CALL 0x00175fa1
TEST EAX,EAX
JNZ 0x00175823
LAB_00175783:
TEST R15D,R15D
SETG AL
OR AL,R13B
TEST AL,0x1
MOV R13D,dword ptr [RBP + -0x2c]
JZ 0x001757c9
MOV R13,qword ptr [RBP + -0x40]
MOV RDI,R13
MOV ESI,dword ptr [RBP + -0x2c]
MOV R12,qword ptr [RBP + -0x48]
MOV RDX,R12
MOV RCX,RBX
MOV R8,qword ptr [RBP + -0x50]
CALL 0x00175849
MOV RDI,R13
MOV R13D,dword ptr [RBP + -0x2c]
MOV ESI,R13D
MOV RDX,R12
MOV ECX,EAX
CALL 0x001894af
TEST EAX,EAX
JNZ 0x00175823
LAB_001757c9:
LEA RAX,[R14 + 0x18]
LEA RCX,[RBX + 0x18]
TEST R15D,R15D
CMOVLE R14,RAX
CMOVNS RBX,RCX
MOV RSI,qword ptr [R14]
TEST RSI,RSI
JNZ 0x001756f1
LAB_001757e8:
CMP qword ptr [RBX],0x0
MOV RDI,qword ptr [RBP + -0x40]
JZ 0x00175807
MOV ESI,R13D
MOV RDX,qword ptr [RBP + -0x48]
MOV RCX,RBX
MOV R8,qword ptr [RBP + -0x50]
CALL 0x0017596b
JMP 0x00175823
LAB_00175807:
XOR R12D,R12D
JMP 0x00175826
LAB_0017580c:
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,R13D
MOV RDX,qword ptr [RBP + -0x48]
MOV RCX,R14
MOV R8,qword ptr [RBP + -0x50]
CALL 0x001758e4
LAB_00175823:
MOV R12D,EAX
LAB_00175826:
MOV R15,qword ptr [RBP + -0x38]
LAB_0017582a:
MOV ESI,0x2
MOV RDI,R15
CALL 0x0019e1a3
MOV EAX,R12D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int _mi_ft_update(long *param_1,ulong param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6)
{
long *plVar1;
int8 uVar2;
long lVar3;
bool bVar4;
int iVar5;
int4 uVar6;
int iVar7;
long *plVar8;
long *plVar9;
int4 uVar10;
uVar10 = (int4)param_2;
uVar2 = **(int8 **)(*(long *)(*param_1 + 0x218) + 0x28 + (param_2 & 0xffffffff) * 0x70);
plVar1 = param_1 + 0x12;
plVar8 = (long *)_mi_ft_parserecord(param_1,param_2,param_4,plVar1);
iVar7 = -1;
if ((plVar8 != (long *)0x0) &&
(plVar9 = (long *)_mi_ft_parserecord(param_1,param_2 & 0xffffffff,param_5,plVar1),
plVar9 != (long *)0x0)) {
lVar3 = *plVar8;
while (lVar3 != 0) {
if (*plVar9 == 0) {
iVar7 = _mi_ft_erase(param_1,param_2 & 0xffffffff,param_3,plVar8,param_6);
goto LAB_0017582a;
}
bVar4 = false;
iVar5 = ha_compare_text(uVar2,lVar3,plVar8[2],*plVar9,plVar9[2],0);
if (iVar5 == 0) {
bVar4 = _DAT_001e2680 <
(double)((ulong)((double)plVar8[1] - (double)plVar9[1]) & _DAT_001da110);
}
if ((iVar5 < 0) || (bVar4)) {
uVar6 = _ft_make_key(param_1,uVar10,param_3,plVar8,param_6);
iVar7 = _mi_ck_delete(param_1,uVar10,param_3,uVar6);
if (iVar7 != 0) goto LAB_0017582a;
}
if (0 < iVar5 || bVar4) {
uVar6 = _ft_make_key(param_1,uVar10,param_3,plVar9,param_6);
iVar7 = _mi_ck_write(param_1,param_2 & 0xffffffff,param_3,uVar6);
if (iVar7 != 0) goto LAB_0017582a;
}
if (iVar5 < 1) {
plVar8 = plVar8 + 3;
}
if (-1 < iVar5) {
plVar9 = plVar9 + 3;
}
lVar3 = *plVar8;
}
if (*plVar9 == 0) {
iVar7 = 0;
}
else {
iVar7 = _mi_ft_store(param_1,param_2 & 0xffffffff,param_3,plVar9,param_6);
}
}
LAB_0017582a:
free_root(plVar1,2);
return iVar7;
}
|
|
57,771
|
common_ngram_cache_merge(std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&, std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&)
|
monkey531[P]llama/common/ngram-cache.cpp
|
void common_ngram_cache_merge(common_ngram_cache & ngram_cache_target, common_ngram_cache & ngram_cache_add) {
for (std::pair<common_ngram, common_ngram_cache_part> ngram_part : ngram_cache_add) {
const common_ngram ngram = ngram_part.first;
common_ngram_cache_part part = ngram_part.second;
common_ngram_cache::iterator part_merged_it = ngram_cache_target.find(ngram);
if (part_merged_it == ngram_cache_target.end()) {
ngram_cache_target.emplace(ngram, part);
continue;
}
for (std::pair<llama_token, int32_t> token_count : part) {
const llama_token token = token_count.first;
const int32_t count = token_count.second;
GGML_ASSERT(count > 0);
common_ngram_cache_part::iterator token_count_merged_it = part_merged_it->second.find(token);
if (token_count_merged_it == part_merged_it->second.end()) {
part_merged_it->second.emplace(token, count);
continue;
}
token_count_merged_it->second += count;
}
}
}
|
O2
|
cpp
|
common_ngram_cache_merge(std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&, std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0x10, %r14
leaq 0xc(%rsp), %r12
leaq 0x8(%rsp), %rbp
movq (%r14), %r14
testq %r14, %r14
je 0x9868c
leaq 0x8(%r14), %rsi
leaq 0x60(%rsp), %rdi
callq 0x9873c
movups 0x60(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x98a4c
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x98b66
movq %rax, %rbx
testq %rax, %rax
je 0x98661
movq 0x38(%rsp), %r13
addq $0x18, %rbx
testq %r13, %r13
je 0x98673
movl 0x8(%r13), %eax
movl 0xc(%r13), %ecx
movl %eax, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
testl %ecx, %ecx
jle 0x9869e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9927c
testq %rax, %rax
je 0x9864d
movl 0x8(%rsp), %ecx
addl %ecx, 0xc(%rax)
jmp 0x9865b
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x995f8
movq (%r13), %r13
jmp 0x9861b
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x994e2
leaq 0x28(%rsp), %rdi
callq 0x2800e
leaq 0x70(%rsp), %rdi
callq 0x2800e
jmp 0x985ca
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2282f(%rip), %rdi # 0xbaed4
leaq 0x13a94(%rip), %rdx # 0xac140
leaq 0x228c4(%rip), %rcx # 0xbaf77
movl $0x112, %esi # imm = 0x112
xorl %eax, %eax
callq 0x24e90
movq %rax, %rbx
jmp 0x986d5
jmp 0x986c8
jmp 0x986c8
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2800e
leaq 0x70(%rsp), %rdi
callq 0x2800e
movq %rbx, %rdi
callq 0x24f60
nop
|
_Z24common_ngram_cache_mergeRSt13unordered_mapI12common_ngramS_IiiSt4hashIiESt8equal_toIiESaISt4pairIKiiEEE26common_ngram_hash_functionS3_IS0_ESaIS5_IKS0_S9_EEESG_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov r14, rsi
mov r15, rdi
add r14, 10h
lea r12, [rsp+0D8h+var_CC]
lea rbp, [rsp+0D8h+var_D0]
loc_985CA:
mov r14, [r14]
test r14, r14
jz loc_9868C
lea rsi, [r14+8]
lea rdi, [rsp+0D8h+var_78]
call _ZNSt4pairI12common_ngramSt13unordered_mapIiiSt4hashIiESt8equal_toIiESaIS_IKiiEEEEC2IKS0_S9_TnNSt9enable_ifIXaaclsr6_PCCFPIT_T0_EE18_ConstructiblePairISE_SF_EEclsr6_PCCFPISE_SF_EE26_ImplicitlyConvertiblePairISE_SF_EEEbE4typeELb1EEERKS_ISE_SF_E
movups xmm0, [rsp+0D8h+var_78]
movaps [rsp+0D8h+var_C8], xmm0
lea rdi, [rsp+0D8h+var_B0]
lea rsi, [rsp+0D8h+var_68]
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEEC2ERKSF_; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_Hashtable(std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&)
mov rdi, r15
lea rsi, [rsp+0D8h+var_C8]
call _ZNSt10_HashtableI12common_ngramSt4pairIKS0_St13unordered_mapIiiSt4hashIiESt8equal_toIiESaIS1_IKiiEEEESaISC_ENSt8__detail10_Select1stES6_IS0_E26common_ngram_hash_functionNSE_18_Mod_range_hashingENSE_20_Default_ranged_hashENSE_20_Prime_rehash_policyENSE_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS2_; std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(common_ngram const&)
mov rbx, rax
test rax, rax
jz short loc_98661
mov r13, [rsp+0D8h+var_A0]
add rbx, 18h
loc_9861B:
test r13, r13
jz short loc_98673
mov eax, [r13+8]
mov ecx, [r13+0Ch]
mov [rsp+0D8h+var_CC], eax
mov [rsp+0D8h+var_D0], ecx
test ecx, ecx
jle short loc_9869E
mov rdi, rbx
mov rsi, r12
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE4findERS1_; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::find(int const&)
test rax, rax
jz short loc_9864D
mov ecx, [rsp+0D8h+var_D0]
add [rax+0Ch], ecx
jmp short loc_9865B
loc_9864D:
mov rdi, rbx
mov rsi, r12
mov rdx, rbp
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE10_M_emplaceIJRS1_SH_EEES0_INS4_14_Node_iteratorIS2_Lb0ELb0EEEbESt17integral_constantIbLb1EEDpOT_; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_emplace<int const&,int const&>(std::integral_constant<bool,true>,int const&,int const&)
loc_9865B:
mov r13, [r13+0]
jmp short loc_9861B
loc_98661:
mov rdi, r15
lea rsi, [rsp+0D8h+var_C8]
lea rdx, [rsp+0D8h+var_B0]
call _ZNSt10_HashtableI12common_ngramSt4pairIKS0_St13unordered_mapIiiSt4hashIiESt8equal_toIiESaIS1_IKiiEEEESaISC_ENSt8__detail10_Select1stES6_IS0_E26common_ngram_hash_functionNSE_18_Mod_range_hashingENSE_20_Default_ranged_hashENSE_20_Prime_rehash_policyENSE_17_Hashtable_traitsILb1ELb0ELb1EEEE10_M_emplaceIJRS2_RSB_EEES1_INSE_14_Node_iteratorISC_Lb0ELb1EEEbESt17integral_constantIbLb1EEDpOT_; std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::_M_emplace<common_ngram const&,std::unordered_map<int,int>&>(std::integral_constant<bool,true>,common_ngram const&,std::unordered_map<int,int>&)
loc_98673:
lea rdi, [rsp+0D8h+var_B0]
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
lea rdi, [rsp+0D8h+var_68]
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
jmp loc_985CA
loc_9868C:
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9869E:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCount0; "count > 0"
mov esi, 112h
xor eax, eax
call _ggml_abort
mov rbx, rax
jmp short loc_986D5
jmp short loc_986C8
jmp short $+2
loc_986C8:
mov rbx, rax
lea rdi, [rsp+0D8h+var_B0]
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
loc_986D5:
lea rdi, [rsp+0D8h+var_68]
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
mov rdi, rbx
call __Unwind_Resume
|
void common_ngram_cache_merge(long long a1, long long a2)
{
_QWORD *v2; // r14
long long v3; // rax
int v4; // ecx
int v5; // r8d
int v6; // r9d
long long *v7; // r13
long long v8; // rbx
int v9; // ecx
long long v10; // rax
long long v11; // rbx
char v12; // [rsp+0h] [rbp-D8h]
int v13; // [rsp+8h] [rbp-D0h] BYREF
int v14; // [rsp+Ch] [rbp-CCh] BYREF
__int128 v15; // [rsp+10h] [rbp-C8h] BYREF
_BYTE v16[16]; // [rsp+28h] [rbp-B0h] BYREF
long long *v17; // [rsp+38h] [rbp-A0h]
__int128 v18; // [rsp+60h] [rbp-78h] BYREF
_BYTE v19[104]; // [rsp+70h] [rbp-68h] BYREF
v2 = (_QWORD *)(a2 + 16);
while ( 1 )
{
v2 = (_QWORD *)*v2;
if ( !v2 )
break;
ZNSt4pairI12common_ngramSt13unordered_mapIiiSt4hashIiESt8equal_toIiESaIS_IKiiEEEEC2IKS0_S9_TnNSt9enable_ifIXaaclsr6_PCCFPIT_T0_EE18_ConstructiblePairISE_SF_EEclsr6_PCCFPISE_SF_EE26_ImplicitlyConvertiblePairISE_SF_EEEbE4typeELb1EEERKS_ISE_SF_E(
&v18,
v2 + 1);
v15 = v18;
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_Hashtable(
v16,
v19);
v3 = std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
a1,
&v15);
if ( v3 )
{
v7 = v17;
v8 = v3 + 24;
while ( v7 )
{
v9 = *((_DWORD *)v7 + 3);
v14 = *((_DWORD *)v7 + 2);
v13 = v9;
if ( v9 <= 0 )
{
v11 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/ngram-cache.cpp",
274LL,
"GGML_ASSERT(%s) failed",
"count > 0");
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable((long long)v19);
_Unwind_Resume(v11);
}
v10 = std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::find(
v8,
&v14);
if ( v10 )
*(_DWORD *)(v10 + 12) += v13;
else
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_emplace<int const&,int const&>(
v8,
&v14,
&v13);
v7 = (long long *)*v7;
}
}
else
{
std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::_M_emplace<common_ngram const&,std::unordered_map<int,int>&>(
a1,
(unsigned int)&v15,
(unsigned int)v16,
v4,
v5,
v6,
v12);
}
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable((long long)v16);
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable((long long)v19);
}
}
|
common_ngram_cache_merge:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV R14,RSI
MOV R15,RDI
ADD R14,0x10
LEA R12,[RSP + 0xc]
LEA RBP,[RSP + 0x8]
LAB_001985ca:
MOV R14,qword ptr [R14]
TEST R14,R14
JZ 0x0019868c
LEA RSI,[R14 + 0x8]
LEA RDI,[RSP + 0x60]
CALL 0x0019873c
MOVUPS XMM0,xmmword ptr [RSP + 0x60]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
LAB_001985ee:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x70]
CALL 0x00198a4c
LAB_001985fd:
MOV RDI,R15
LEA RSI,[RSP + 0x10]
CALL 0x00198b66
MOV RBX,RAX
TEST RAX,RAX
JZ 0x00198661
MOV R13,qword ptr [RSP + 0x38]
ADD RBX,0x18
LAB_0019861b:
TEST R13,R13
JZ 0x00198673
MOV EAX,dword ptr [R13 + 0x8]
MOV ECX,dword ptr [R13 + 0xc]
MOV dword ptr [RSP + 0xc],EAX
MOV dword ptr [RSP + 0x8],ECX
TEST ECX,ECX
JLE 0x0019869e
LAB_00198634:
MOV RDI,RBX
MOV RSI,R12
CALL 0x0019927c
TEST RAX,RAX
JZ 0x0019864d
MOV ECX,dword ptr [RSP + 0x8]
ADD dword ptr [RAX + 0xc],ECX
JMP 0x0019865b
LAB_0019864d:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,RBP
CALL 0x001995f8
LAB_0019865b:
MOV R13,qword ptr [R13]
JMP 0x0019861b
LAB_00198661:
MOV RDI,R15
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0x28]
CALL 0x001994e2
LAB_00198673:
LEA RDI,[RSP + 0x28]
CALL 0x0012800e
LEA RDI,[RSP + 0x70]
CALL 0x0012800e
JMP 0x001985ca
LAB_0019868c:
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019869e:
LEA RDI,[0x1baed4]
LEA RDX,[0x1ac140]
LEA RCX,[0x1baf77]
MOV ESI,0x112
XOR EAX,EAX
CALL 0x00124e90
|
/* common_ngram_cache_merge(std::unordered_map<common_ngram, std::unordered_map<int, int,
std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int> > >,
common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram
const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>,
std::allocator<std::pair<int const, int> > > > > >&, std::unordered_map<common_ngram,
std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int
const, int> > >, common_ngram_hash_function, std::equal_to<common_ngram>,
std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>,
std::equal_to<int>, std::allocator<std::pair<int const, int> > > > > >&) */
void common_ngram_cache_merge(unordered_map *param_1,unordered_map *param_2)
{
long lVar1;
long lVar2;
int8 *puVar3;
unordered_map *puVar4;
int local_d0;
int local_cc;
int8 local_c8;
int8 uStack_c0;
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
local_b0 [16];
int8 *local_a0;
int8 local_78;
int8 uStack_70;
_Hashtable local_68 [56];
puVar4 = param_2 + 0x10;
do {
puVar4 = *(unordered_map **)puVar4;
if (puVar4 == (unordered_map *)0x0) {
return;
}
_ZNSt4pairI12common_ngramSt13unordered_mapIiiSt4hashIiESt8equal_toIiESaIS_IKiiEEEEC2IKS0_S9_TnNSt9enable_ifIXaaclsr6_PCCFPIT_T0_EE18_ConstructiblePairISE_SF_EEclsr6_PCCFPISE_SF_EE26_ImplicitlyConvertiblePairISE_SF_EEEbE4typeELb1EEERKS_ISE_SF_E
(&local_78,puVar4 + 8);
local_c8 = local_78;
uStack_c0 = uStack_70;
/* try { // try from 001985ee to 001985fc has its CatchHandler @ 001986bf */
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::_Hashtable(local_b0,local_68);
/* try { // try from 001985fd to 00198609 has its CatchHandler @ 001986c4 */
lVar1 = std::
_Hashtable<common_ngram,std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>,std::allocator<std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<common_ngram,std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>,std::allocator<std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)param_1,(common_ngram *)&local_c8);
if (lVar1 == 0) {
/* try { // try from 00198661 to 00198672 has its CatchHandler @ 001986c4 */
std::
_Hashtable<common_ngram,std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>,std::allocator<std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::
_M_emplace<common_ngram_const&,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>&>
(param_1,&local_c8,local_b0);
}
else {
for (puVar3 = local_a0; puVar3 != (int8 *)0x0; puVar3 = (int8 *)*puVar3) {
local_cc = *(int *)(puVar3 + 1);
local_d0 = *(int *)((long)puVar3 + 0xc);
if (local_d0 < 1) {
/* try { // try from 0019869e to 001986be has its CatchHandler @ 001986c6 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/ngram-cache.cpp"
,0x112,"GGML_ASSERT(%s) failed","count > 0");
}
/* try { // try from 00198634 to 0019865a has its CatchHandler @ 001986c8 */
lVar2 = std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::find((_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)(lVar1 + 0x18),&local_cc);
if (lVar2 == 0) {
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::_M_emplace<int_const&,int_const&>
((_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)(lVar1 + 0x18),&local_cc,&local_d0);
}
else {
*(int *)(lVar2 + 0xc) = *(int *)(lVar2 + 0xc) + local_d0;
}
}
}
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::~_Hashtable(local_b0);
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::~_Hashtable((_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)local_68);
} while( true );
}
|
|
57,772
|
common_ngram_cache_merge(std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&, std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&)
|
monkey531[P]llama/common/ngram-cache.cpp
|
void common_ngram_cache_merge(common_ngram_cache & ngram_cache_target, common_ngram_cache & ngram_cache_add) {
for (std::pair<common_ngram, common_ngram_cache_part> ngram_part : ngram_cache_add) {
const common_ngram ngram = ngram_part.first;
common_ngram_cache_part part = ngram_part.second;
common_ngram_cache::iterator part_merged_it = ngram_cache_target.find(ngram);
if (part_merged_it == ngram_cache_target.end()) {
ngram_cache_target.emplace(ngram, part);
continue;
}
for (std::pair<llama_token, int32_t> token_count : part) {
const llama_token token = token_count.first;
const int32_t count = token_count.second;
GGML_ASSERT(count > 0);
common_ngram_cache_part::iterator token_count_merged_it = part_merged_it->second.find(token);
if (token_count_merged_it == part_merged_it->second.end()) {
part_merged_it->second.emplace(token, count);
continue;
}
token_count_merged_it->second += count;
}
}
}
|
O3
|
cpp
|
common_ngram_cache_merge(std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&, std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsi), %r14
testq %r14, %r14
je 0xcdc2a
leaq 0x80(%rsp), %rbx
leaq 0x38(%rsp), %r13
leaq 0x18(%rsp), %r12
movups 0x8(%r14), %xmm0
movaps %xmm0, 0x70(%rsp)
leaq 0x18(%r14), %rsi
xorl %r15d, %r15d
movq %r15, 0x80(%rsp)
movq 0x20(%r14), %rax
movq %rax, 0x88(%rsp)
movq %r15, 0x90(%rsp)
movq 0x30(%r14), %rax
movq %rax, 0x98(%rsp)
movups 0x38(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movq %r15, 0xb0(%rsp)
movq %rbx, 0x38(%rsp)
movq %rbx, %rdi
movq %r13, %rdx
callq 0xcdf9a
movaps 0x70(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movq %r15, 0x38(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %r15, 0x48(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x20(%rbx), %xmm0
leaq 0x58(%rsp), %rax
movups %xmm0, (%rax)
movq %r15, 0x68(%rsp)
movq %r13, 0x18(%rsp)
movq %r13, %r15
movq %r13, %rdi
movq %rbx, %rbp
movq %rbx, %rsi
movq %r12, %rdx
callq 0xcdf9a
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xce0dc
movq %rax, %r13
testq %rax, %rax
je 0xcdbf6
movq 0x48(%rsp), %rbx
testq %rbx, %rbx
je 0xcdc08
addq $0x18, %r13
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %ecx
movl %eax, 0x18(%rsp)
movl %ecx, 0xc(%rsp)
testl %ecx, %ecx
jle 0xcdc3c
movq %r13, %rdi
movq %r12, %rsi
callq 0xce7cc
testq %rax, %rax
je 0xcdbdc
movl 0xc(%rsp), %ecx
addl %ecx, 0xc(%rax)
jmp 0xcdbec
movq %r13, %rdi
movq %r12, %rsi
leaq 0xc(%rsp), %rdx
callq 0xceba4
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0xcdbb1
jmp 0xcdc08
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, %rdx
callq 0xcea2c
movq %r15, %r13
movq %r15, %rdi
callq 0x21ec2
movq %rbp, %rbx
movq %rbp, %rdi
callq 0x21ec2
movq (%r14), %r14
testq %r14, %r14
jne 0xcdada
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x292bb(%rip), %rdi # 0xf6efe
leaq 0x1a4f6(%rip), %rdx # 0xe8140
leaq 0x29350(%rip), %rcx # 0xf6fa1
movl $0x112, %esi # imm = 0x112
xorl %eax, %eax
callq 0x1be80
movq %rax, %r14
jmp 0xcdc73
jmp 0xcdc66
jmp 0xcdc66
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x21ec2
movq %rbp, %rdi
callq 0x21ec2
movq %r14, %rdi
callq 0x1bf70
nop
|
_Z24common_ngram_cache_mergeRSt13unordered_mapI12common_ngramS_IiiSt4hashIiESt8equal_toIiESaISt4pairIKiiEEE26common_ngram_hash_functionS3_IS0_ESaIS5_IKS0_S9_EEESG_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov [rsp+0E8h+var_D8], rdi
mov r14, [rsi+10h]
test r14, r14
jz loc_CDC2A
lea rbx, [rsp+0E8h+var_68]
lea r13, [rsp+0E8h+var_B0]
lea r12, [rsp+0E8h+var_D0]
loc_CDADA:
movups xmm0, xmmword ptr [r14+8]
movaps [rsp+0E8h+var_78], xmm0
lea rsi, [r14+18h]
xor r15d, r15d
mov [rsp+0E8h+var_68], r15
mov rax, [r14+20h]
mov [rsp+0E8h+var_60], rax
mov [rsp+0E8h+var_58], r15
mov rax, [r14+30h]
mov [rsp+0E8h+var_50], rax
movups xmm0, xmmword ptr [r14+38h]
movups xmmword ptr [rbx+20h], xmm0
mov [rsp+0E8h+var_38], r15
mov [rsp+0E8h+var_B0], rbx
mov rdi, rbx
mov rdx, r13
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE9_M_assignIRKSF_NS4_10_AllocNodeISaINS4_10_Hash_nodeIS2_Lb0EEEEEEEEvOT_RKT0_; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_assign<std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>>>(std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>> const&)
movaps xmm0, [rsp+0E8h+var_78]
movaps [rsp+0E8h+var_C8], xmm0
mov [rsp+0E8h+var_B0], r15
mov rax, [rsp+0E8h+var_60]
mov [rsp+0E8h+var_A8], rax
mov [rsp+0E8h+var_A0], r15
mov rax, [rsp+0E8h+var_50]
mov [rsp+0E8h+var_98], rax
movups xmm0, xmmword ptr [rbx+20h]
lea rax, [rsp+0E8h+var_90]
movups xmmword ptr [rax], xmm0
mov [rsp+0E8h+var_80], r15
mov [rsp+0E8h+var_D0], r13
mov r15, r13
mov rdi, r13
mov rbp, rbx
mov rsi, rbx
mov rdx, r12
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE9_M_assignIRKSF_NS4_10_AllocNodeISaINS4_10_Hash_nodeIS2_Lb0EEEEEEEEvOT_RKT0_; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_assign<std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>>>(std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>> const&)
mov rdi, [rsp+0E8h+var_D8]
lea rsi, [rsp+0E8h+var_C8]
call _ZNSt10_HashtableI12common_ngramSt4pairIKS0_St13unordered_mapIiiSt4hashIiESt8equal_toIiESaIS1_IKiiEEEESaISC_ENSt8__detail10_Select1stES6_IS0_E26common_ngram_hash_functionNSE_18_Mod_range_hashingENSE_20_Default_ranged_hashENSE_20_Prime_rehash_policyENSE_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS2_; std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(common_ngram const&)
mov r13, rax
test rax, rax
jz short loc_CDBF6
mov rbx, [rsp+0E8h+var_A0]
test rbx, rbx
jz short loc_CDC08
add r13, 18h
loc_CDBB1:
mov eax, [rbx+8]
mov ecx, [rbx+0Ch]
mov dword ptr [rsp+0E8h+var_D0], eax
mov [rsp+0E8h+var_DC], ecx
test ecx, ecx
jle short loc_CDC3C
mov rdi, r13
mov rsi, r12
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE4findERS1_; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::find(int const&)
test rax, rax
jz short loc_CDBDC
mov ecx, [rsp+0E8h+var_DC]
add [rax+0Ch], ecx
jmp short loc_CDBEC
loc_CDBDC:
mov rdi, r13
mov rsi, r12
lea rdx, [rsp+0E8h+var_DC]
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE10_M_emplaceIJRS1_SH_EEES0_INS4_14_Node_iteratorIS2_Lb0ELb0EEEbESt17integral_constantIbLb1EEDpOT_; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_emplace<int const&,int const&>(std::integral_constant<bool,true>,int const&,int const&)
loc_CDBEC:
mov rbx, [rbx]
test rbx, rbx
jnz short loc_CDBB1
jmp short loc_CDC08
loc_CDBF6:
mov rdi, [rsp+0E8h+var_D8]
lea rsi, [rsp+0E8h+var_C8]
mov rdx, r15
call _ZNSt10_HashtableI12common_ngramSt4pairIKS0_St13unordered_mapIiiSt4hashIiESt8equal_toIiESaIS1_IKiiEEEESaISC_ENSt8__detail10_Select1stES6_IS0_E26common_ngram_hash_functionNSE_18_Mod_range_hashingENSE_20_Default_ranged_hashENSE_20_Prime_rehash_policyENSE_17_Hashtable_traitsILb1ELb0ELb1EEEE10_M_emplaceIJRS2_RSB_EEES1_INSE_14_Node_iteratorISC_Lb0ELb1EEEbESt17integral_constantIbLb1EEDpOT_; std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::_M_emplace<common_ngram const&,std::unordered_map<int,int>&>(std::integral_constant<bool,true>,common_ngram const&,std::unordered_map<int,int>&)
loc_CDC08:
mov r13, r15
mov rdi, r15
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
mov rbx, rbp
mov rdi, rbp
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
mov r14, [r14]
test r14, r14
jnz loc_CDADA
loc_CDC2A:
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_CDC3C:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCount0; "count > 0"
mov esi, 112h
xor eax, eax
call _ggml_abort
mov r14, rax
jmp short loc_CDC73
jmp short loc_CDC66
jmp short $+2
loc_CDC66:
mov r14, rax
lea rdi, [rsp+0E8h+var_B0]
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
loc_CDC73:
mov rdi, rbp
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
mov rdi, r14
call __Unwind_Resume
|
void common_ngram_cache_merge(long long a1, long long a2)
{
long long *v2; // r14
long long *v3; // rbx
_QWORD *v4; // r13
long long v5; // r15
long long v6; // rbp
long long v7; // rdx
long long v8; // rcx
long long v9; // rax
long long *v10; // rbx
long long v11; // r13
int v12; // ecx
long long v13; // rax
long long v14; // rax
long long v15; // r14
int v16; // [rsp+Ch] [rbp-DCh] BYREF
long long v17; // [rsp+10h] [rbp-D8h]
_QWORD *v18; // [rsp+18h] [rbp-D0h] BYREF
__int128 v19; // [rsp+20h] [rbp-C8h] BYREF
_QWORD v20[2]; // [rsp+38h] [rbp-B0h] BYREF
long long *v21; // [rsp+48h] [rbp-A0h]
long long v22; // [rsp+50h] [rbp-98h]
__int128 v23; // [rsp+58h] [rbp-90h]
long long v24; // [rsp+68h] [rbp-80h]
__int128 v25; // [rsp+70h] [rbp-78h]
long long v26; // [rsp+80h] [rbp-68h] BYREF
long long v27; // [rsp+88h] [rbp-60h]
long long v28; // [rsp+90h] [rbp-58h]
long long v29; // [rsp+98h] [rbp-50h]
long long v30; // [rsp+B0h] [rbp-38h]
v17 = a1;
v2 = *(long long **)(a2 + 16);
if ( v2 )
{
v3 = &v26;
v4 = v20;
do
{
v25 = *(_OWORD *)(v2 + 1);
v26 = 0LL;
v27 = v2[4];
v28 = 0LL;
v29 = v2[6];
*((_OWORD *)v3 + 2) = *(_OWORD *)(v2 + 7);
v30 = 0LL;
v20[0] = v3;
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_assign<std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>>>(
v3,
v2 + 3,
v4);
v19 = v25;
v20[0] = 0LL;
v20[1] = v27;
v21 = 0LL;
v22 = v29;
v23 = *((_OWORD *)v3 + 2);
v24 = 0LL;
v18 = v4;
v5 = (long long)v4;
v6 = (long long)v3;
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_assign<std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>>>(
v4,
v3,
&v18);
v9 = std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
v17,
&v19,
v7,
v8);
if ( v9 )
{
v10 = v21;
if ( v21 )
{
v11 = v9 + 24;
do
{
v12 = *((_DWORD *)v10 + 3);
LODWORD(v18) = *((_DWORD *)v10 + 2);
v16 = v12;
if ( v12 <= 0 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/ngram-cache.cpp",
274LL,
"GGML_ASSERT(%s) failed",
"count > 0");
v15 = v14;
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable(v6);
_Unwind_Resume(v15);
}
v13 = std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::find(
v11,
&v18);
if ( v13 )
*(_DWORD *)(v13 + 12) += v16;
else
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_emplace<int const&,int const&>(
v11,
&v18,
&v16);
v10 = (long long *)*v10;
}
while ( v10 );
}
}
else
{
std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::_M_emplace<common_ngram const&,std::unordered_map<int,int>&>(
v17,
&v19,
v4);
}
v4 = (_QWORD *)v5;
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable(v5);
v3 = (long long *)v6;
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable(v6);
v2 = (long long *)*v2;
}
while ( v2 );
}
}
|
common_ngram_cache_merge:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV qword ptr [RSP + 0x10],RDI
MOV R14,qword ptr [RSI + 0x10]
TEST R14,R14
JZ 0x001cdc2a
LEA RBX,[RSP + 0x80]
LEA R13,[RSP + 0x38]
LEA R12,[RSP + 0x18]
LAB_001cdada:
MOVUPS XMM0,xmmword ptr [R14 + 0x8]
MOVAPS xmmword ptr [RSP + 0x70],XMM0
LEA RSI,[R14 + 0x18]
XOR R15D,R15D
MOV qword ptr [RSP + 0x80],R15
MOV RAX,qword ptr [R14 + 0x20]
MOV qword ptr [RSP + 0x88],RAX
MOV qword ptr [RSP + 0x90],R15
MOV RAX,qword ptr [R14 + 0x30]
MOV qword ptr [RSP + 0x98],RAX
MOVUPS XMM0,xmmword ptr [R14 + 0x38]
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOV qword ptr [RSP + 0xb0],R15
MOV qword ptr [RSP + 0x38],RBX
MOV RDI,RBX
MOV RDX,R13
CALL 0x001cdf9a
MOVAPS XMM0,xmmword ptr [RSP + 0x70]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV qword ptr [RSP + 0x38],R15
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],R15
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x50],RAX
MOVUPS XMM0,xmmword ptr [RBX + 0x20]
LEA RAX,[RSP + 0x58]
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RSP + 0x68],R15
MOV qword ptr [RSP + 0x18],R13
LAB_001cdb78:
MOV R15,R13
MOV RDI,R13
MOV RBP,RBX
MOV RSI,RBX
MOV RDX,R12
CALL 0x001cdf9a
LAB_001cdb8c:
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x20]
CALL 0x001ce0dc
MOV R13,RAX
TEST RAX,RAX
JZ 0x001cdbf6
MOV RBX,qword ptr [RSP + 0x48]
TEST RBX,RBX
JZ 0x001cdc08
ADD R13,0x18
LAB_001cdbb1:
MOV EAX,dword ptr [RBX + 0x8]
MOV ECX,dword ptr [RBX + 0xc]
MOV dword ptr [RSP + 0x18],EAX
MOV dword ptr [RSP + 0xc],ECX
TEST ECX,ECX
JLE 0x001cdc3c
LAB_001cdbc3:
MOV RDI,R13
MOV RSI,R12
CALL 0x001ce7cc
TEST RAX,RAX
JZ 0x001cdbdc
MOV ECX,dword ptr [RSP + 0xc]
ADD dword ptr [RAX + 0xc],ECX
JMP 0x001cdbec
LAB_001cdbdc:
MOV RDI,R13
MOV RSI,R12
LEA RDX,[RSP + 0xc]
CALL 0x001ceba4
LAB_001cdbec:
MOV RBX,qword ptr [RBX]
TEST RBX,RBX
JNZ 0x001cdbb1
JMP 0x001cdc08
LAB_001cdbf6:
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x20]
MOV RDX,R15
CALL 0x001cea2c
LAB_001cdc08:
MOV R13,R15
MOV RDI,R15
CALL 0x00121ec2
MOV RBX,RBP
MOV RDI,RBP
CALL 0x00121ec2
MOV R14,qword ptr [R14]
TEST R14,R14
JNZ 0x001cdada
LAB_001cdc2a:
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001cdc3c:
LEA RDI,[0x1f6efe]
LEA RDX,[0x1e8140]
LEA RCX,[0x1f6fa1]
MOV ESI,0x112
XOR EAX,EAX
CALL 0x0011be80
|
/* common_ngram_cache_merge(std::unordered_map<common_ngram, std::unordered_map<int, int,
std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int> > >,
common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram
const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>,
std::allocator<std::pair<int const, int> > > > > >&, std::unordered_map<common_ngram,
std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int
const, int> > >, common_ngram_hash_function, std::equal_to<common_ngram>,
std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>,
std::equal_to<int>, std::allocator<std::pair<int const, int> > > > > >&) */
void common_ngram_cache_merge(unordered_map *param_1,unordered_map *param_2)
{
long lVar1;
long lVar2;
long *plVar3;
long *plVar4;
int local_dc;
unordered_map *local_d8;
_Hashtable *local_d0;
long local_c8;
long lStack_c0;
_Hashtable *local_b0;
long local_a8;
long *local_a0;
long local_98;
long local_90;
long lStack_88;
int8 local_80;
long local_78;
long lStack_70;
int8 local_68;
long local_60;
int8 local_58;
long local_50;
long local_48;
long lStack_40;
int8 local_38;
plVar4 = *(long **)(param_2 + 0x10);
if (plVar4 != (long *)0x0) {
local_d8 = param_1;
do {
local_78 = plVar4[1];
lStack_70 = plVar4[2];
local_68 = 0;
local_60 = plVar4[4];
local_58 = 0;
local_50 = plVar4[6];
local_48 = plVar4[7];
lStack_40 = plVar4[8];
local_38 = 0;
local_b0 = (_Hashtable *)&local_68;
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::
_M_assign<std::_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int_const,int>,false>>>>
((_Hashtable *)&local_68,(_AllocNode *)(plVar4 + 3));
local_c8 = local_78;
lStack_c0 = lStack_70;
local_b0 = (_Hashtable *)0x0;
local_a8 = local_60;
local_a0 = (long *)0x0;
local_98 = local_50;
local_90 = local_48;
lStack_88 = lStack_40;
local_80 = 0;
local_d0 = (_Hashtable *)&local_b0;
/* try { // try from 001cdb78 to 001cdb8b has its CatchHandler @ 001cdc5d */
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::
_M_assign<std::_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int_const,int>,false>>>>
((_Hashtable *)&local_b0,(_AllocNode *)&local_68);
/* try { // try from 001cdb8c to 001cdb9a has its CatchHandler @ 001cdc62 */
lVar1 = std::
_Hashtable<common_ngram,std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>,std::allocator<std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<common_ngram,std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>,std::allocator<std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)local_d8,(common_ngram *)&local_c8);
if (lVar1 == 0) {
/* try { // try from 001cdbf6 to 001cdc07 has its CatchHandler @ 001cdc62 */
std::
_Hashtable<common_ngram,std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>,std::allocator<std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::
_M_emplace<common_ngram_const&,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>&>
(local_d8,&local_c8,(_Hashtable *)&local_b0);
}
else if (local_a0 != (long *)0x0) {
plVar3 = local_a0;
do {
local_dc = *(int *)((long)plVar3 + 0xc);
local_d0 = (_Hashtable *)CONCAT44(local_d0._4_4_,(int)plVar3[1]);
if (local_dc < 1) {
/* try { // try from 001cdc3c to 001cdc5c has its CatchHandler @ 001cdc64 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/ngram-cache.cpp"
,0x112,"GGML_ASSERT(%s) failed","count > 0");
}
/* try { // try from 001cdbc3 to 001cdbeb has its CatchHandler @ 001cdc66 */
lVar2 = std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::find((_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)(lVar1 + 0x18),(int *)&local_d0);
if (lVar2 == 0) {
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::_M_emplace<int_const&,int_const&>
((_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)(lVar1 + 0x18),&local_d0,&local_dc);
}
else {
*(int *)(lVar2 + 0xc) = *(int *)(lVar2 + 0xc) + local_dc;
}
plVar3 = (long *)*plVar3;
} while (plVar3 != (long *)0x0);
}
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::~_Hashtable((_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)&local_b0);
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::~_Hashtable((_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)&local_68);
plVar4 = (long *)*plVar4;
} while (plVar4 != (long *)0x0);
}
return;
}
|
|
57,773
|
ma_send_connect_attr
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
char *ma_send_connect_attr(MYSQL *mysql, unsigned char *buffer)
{
if (mysql->server_capabilities & CLIENT_CONNECT_ATTRS)
{
buffer= (unsigned char *)mysql_net_store_length((unsigned char *)buffer, (mysql->options.extension) ?
mysql->options.extension->connect_attrs_len : 0);
if (mysql->options.extension &&
ma_hashtbl_inited(&mysql->options.extension->connect_attrs))
{
uint i;
for (i=0; i < mysql->options.extension->connect_attrs.records; i++)
{
size_t len;
uchar *p= ma_hashtbl_element(&mysql->options.extension->connect_attrs, i);
len= strlen((char *)p);
buffer= mysql_net_store_length(buffer, len);
memcpy(buffer, p, len);
buffer+= (len);
p+= (len + 1);
len= strlen((char *)p);
buffer= mysql_net_store_length(buffer, len);
memcpy(buffer, p, len);
buffer+= len;
}
}
}
return (char *)buffer;
}
|
O0
|
c
|
ma_send_connect_attr:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x370(%rax), %rax
andq $0x100000, %rax # imm = 0x100000
cmpq $0x0, %rax
je 0x1c178
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x1c066
movq -0x8(%rbp), %rax
movq 0x480(%rax), %rax
movq 0x78(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x1c06e
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x1c06e
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x27ab0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x1c176
movq -0x8(%rbp), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x48(%rax)
je 0x1c176
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x480(%rcx), %rcx
cmpl 0x38(%rcx), %eax
jae 0x1c174
movq -0x8(%rbp), %rax
movq 0x480(%rax), %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %esi
callq 0x46bc0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x131a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x27ab0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13360
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x131a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x27ab0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13360
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1c0ae
jmp 0x1c176
jmp 0x1c178
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_send_connect_attr:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax+370h]
and rax, 100000h
cmp rax, 0
jz loc_1C178
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
cmp qword ptr [rax+480h], 0
jz short loc_1C066
mov rax, [rbp+var_8]
mov rax, [rax+480h]
mov rax, [rax+78h]
mov [rbp+var_38], rax
jmp short loc_1C06E
loc_1C066:
xor eax, eax
mov [rbp+var_38], rax
jmp short $+2
loc_1C06E:
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_38]
call mysql_net_store_length
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
cmp qword ptr [rax+480h], 0
jz loc_1C176
mov rax, [rbp+var_8]
mov rax, [rax+480h]
cmp qword ptr [rax+48h], 0
jz loc_1C176
mov [rbp+var_14], 0
loc_1C0AE:
mov eax, [rbp+var_14]
mov rcx, [rbp+var_8]
mov rcx, [rcx+480h]
cmp eax, [rcx+38h]
jnb loc_1C174
mov rax, [rbp+var_8]
mov rdi, [rax+480h]
add rdi, 30h ; '0'
mov esi, [rbp+var_14]
call ma_hashtbl_element
mov [rbp+var_28], rax
mov rdi, [rbp+var_28]
call _strlen
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call mysql_net_store_length
mov [rbp+var_10], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_20]
call _memcpy
mov rax, [rbp+var_20]
add rax, [rbp+var_10]
mov [rbp+var_10], rax
mov rax, [rbp+var_20]
add rax, 1
add rax, [rbp+var_28]
mov [rbp+var_28], rax
mov rdi, [rbp+var_28]
call _strlen
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call mysql_net_store_length
mov [rbp+var_10], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_20]
call _memcpy
mov rax, [rbp+var_20]
add rax, [rbp+var_10]
mov [rbp+var_10], rax
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp loc_1C0AE
loc_1C174:
jmp short $+2
loc_1C176:
jmp short $+2
loc_1C178:
mov rax, [rbp+var_10]
add rsp, 40h
pop rbp
retn
|
long long ma_send_connect_attr(long long a1, long long a2)
{
long long v2; // rax
long long v4; // [rsp+18h] [rbp-28h]
long long v5; // [rsp+18h] [rbp-28h]
long long v6; // [rsp+20h] [rbp-20h]
long long v7; // [rsp+20h] [rbp-20h]
unsigned int i; // [rsp+2Ch] [rbp-14h]
long long v9; // [rsp+30h] [rbp-10h]
long long v10; // [rsp+30h] [rbp-10h]
long long v11; // [rsp+30h] [rbp-10h]
long long v12; // [rsp+30h] [rbp-10h]
v9 = a2;
if ( (*(_QWORD *)(a1 + 880) & 0x100000LL) != 0 )
{
if ( *(_QWORD *)(a1 + 1152) )
v2 = mysql_net_store_length(a2, *(_QWORD *)(*(_QWORD *)(a1 + 1152) + 120LL));
else
v2 = mysql_net_store_length(a2, 0LL);
v9 = v2;
if ( *(_QWORD *)(a1 + 1152) && *(_QWORD *)(*(_QWORD *)(a1 + 1152) + 72LL) )
{
for ( i = 0; i < *(_DWORD *)(*(_QWORD *)(a1 + 1152) + 56LL); ++i )
{
v4 = ma_hashtbl_element(*(_QWORD *)(a1 + 1152) + 48LL, i);
v6 = strlen(v4);
v10 = mysql_net_store_length(v9, v6);
memcpy(v10, v4, v6);
v11 = v10 + v6;
v5 = v4 + v6 + 1;
v7 = strlen(v5);
v12 = mysql_net_store_length(v11, v7);
memcpy(v12, v5, v7);
v9 = v12 + v7;
}
}
}
return v9;
}
|
ma_send_connect_attr:
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 + -0x8]
MOV RAX,qword ptr [RAX + 0x370]
AND RAX,0x100000
CMP RAX,0x0
JZ 0x0011c178
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x0011c066
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0011c06e
LAB_0011c066:
XOR EAX,EAX
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0011c06e
LAB_0011c06e:
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00127ab0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x0011c176
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x48],0x0
JZ 0x0011c176
MOV dword ptr [RBP + -0x14],0x0
LAB_0011c0ae:
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x480]
CMP EAX,dword ptr [RCX + 0x38]
JNC 0x0011c174
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x480]
ADD RDI,0x30
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x00146bc0
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001131a0
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00127ab0
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00113360
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001131a0
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00127ab0
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00113360
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0011c0ae
LAB_0011c174:
JMP 0x0011c176
LAB_0011c176:
JMP 0x0011c178
LAB_0011c178:
MOV RAX,qword ptr [RBP + -0x10]
ADD RSP,0x40
POP RBP
RET
|
long ma_send_connect_attr(long param_1,long param_2)
{
char *__s;
size_t __n;
void *pvVar1;
size_t __n_00;
int8 local_40;
uint local_1c;
long local_18;
local_18 = param_2;
if ((*(ulong *)(param_1 + 0x370) & 0x100000) != 0) {
if (*(long *)(param_1 + 0x480) == 0) {
local_40 = 0;
}
else {
local_40 = *(int8 *)(*(long *)(param_1 + 0x480) + 0x78);
}
local_18 = mysql_net_store_length(param_2,local_40);
if ((*(long *)(param_1 + 0x480) != 0) && (*(long *)(*(long *)(param_1 + 0x480) + 0x48) != 0)) {
for (local_1c = 0; local_1c < *(uint *)(*(long *)(param_1 + 0x480) + 0x38);
local_1c = local_1c + 1) {
__s = (char *)ma_hashtbl_element(*(long *)(param_1 + 0x480) + 0x30,local_1c);
__n = strlen(__s);
pvVar1 = (void *)mysql_net_store_length(local_18,__n);
memcpy(pvVar1,__s,__n);
__n_00 = strlen(__s + __n + 1);
pvVar1 = (void *)mysql_net_store_length(__n + (long)pvVar1,__n_00);
memcpy(pvVar1,__s + __n + 1,__n_00);
local_18 = __n_00 + (long)pvVar1;
}
}
}
return local_18;
}
|
|
57,774
|
ma_send_connect_attr
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
char *ma_send_connect_attr(MYSQL *mysql, unsigned char *buffer)
{
if (mysql->server_capabilities & CLIENT_CONNECT_ATTRS)
{
buffer= (unsigned char *)mysql_net_store_length((unsigned char *)buffer, (mysql->options.extension) ?
mysql->options.extension->connect_attrs_len : 0);
if (mysql->options.extension &&
ma_hashtbl_inited(&mysql->options.extension->connect_attrs))
{
uint i;
for (i=0; i < mysql->options.extension->connect_attrs.records; i++)
{
size_t len;
uchar *p= ma_hashtbl_element(&mysql->options.extension->connect_attrs, i);
len= strlen((char *)p);
buffer= mysql_net_store_length(buffer, len);
memcpy(buffer, p, len);
buffer+= (len);
p+= (len + 1);
len= strlen((char *)p);
buffer= mysql_net_store_length(buffer, len);
memcpy(buffer, p, len);
buffer+= len;
}
}
}
return (char *)buffer;
}
|
O3
|
c
|
ma_send_connect_attr:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testb $0x10, 0x372(%rdi)
je 0x19240
movq %rdi, %rbx
movq 0x480(%rdi), %rax
testq %rax, %rax
je 0x19196
movq 0x78(%rax), %rsi
jmp 0x19198
xorl %esi, %esi
movq %r14, %rdi
callq 0x1fa2f
movq %rax, %r14
movq 0x480(%rbx), %rdi
testq %rdi, %rdi
je 0x19240
cmpq $0x0, 0x48(%rdi)
je 0x19240
cmpl $0x0, 0x38(%rdi)
je 0x19240
xorl %r15d, %r15d
addq $0x30, %rdi
movl %r15d, %esi
callq 0x31d39
movq %rax, %r12
movq %rax, %rdi
callq 0x131c0
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fa2f
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x13390
addq %r13, %r14
addq %r13, %r12
incq %r12
movq %r12, %rdi
callq 0x131c0
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fa2f
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x13390
addq %r13, %r14
incl %r15d
movq 0x480(%rbx), %rdi
cmpl 0x38(%rdi), %r15d
jb 0x191c7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
ma_send_connect_attr:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
test byte ptr [rdi+372h], 10h
jz loc_19240
mov rbx, rdi
mov rax, [rdi+480h]
test rax, rax
jz short loc_19196
mov rsi, [rax+78h]
jmp short loc_19198
loc_19196:
xor esi, esi
loc_19198:
mov rdi, r14
call mysql_net_store_length
mov r14, rax
mov rdi, [rbx+480h]
test rdi, rdi
jz loc_19240
cmp qword ptr [rdi+48h], 0
jz loc_19240
cmp dword ptr [rdi+38h], 0
jz short loc_19240
xor r15d, r15d
loc_191C7:
add rdi, 30h ; '0'
mov esi, r15d
call ma_hashtbl_element
mov r12, rax
mov rdi, rax
call _strlen
mov r13, rax
mov rdi, r14
mov rsi, rax
call mysql_net_store_length
mov r14, rax
mov rdi, rax
mov rsi, r12
mov rdx, r13
call _memcpy
add r14, r13
add r12, r13
inc r12
mov rdi, r12
call _strlen
mov r13, rax
mov rdi, r14
mov rsi, rax
call mysql_net_store_length
mov r14, rax
mov rdi, rax
mov rsi, r12
mov rdx, r13
call _memcpy
add r14, r13
inc r15d
mov rdi, [rbx+480h]
cmp r15d, [rdi+38h]
jb short loc_191C7
loc_19240:
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ma_send_connect_attr(long long a1, long long a2)
{
long long v4; // rax
long long v5; // rsi
long long v6; // rdi
unsigned int v7; // r15d
long long v8; // r12
long long v9; // r13
long long v10; // r14
long long v11; // r14
long long v12; // r12
long long v13; // r13
long long v14; // r14
if ( (*(_BYTE *)(a1 + 882) & 0x10) != 0 )
{
v4 = *(_QWORD *)(a1 + 1152);
if ( v4 )
v5 = *(_QWORD *)(v4 + 120);
else
v5 = 0LL;
a2 = mysql_net_store_length(a2, v5);
v6 = *(_QWORD *)(a1 + 1152);
if ( v6 && *(_QWORD *)(v6 + 72) && *(_DWORD *)(v6 + 56) )
{
v7 = 0;
do
{
v8 = ma_hashtbl_element(v6 + 48, v7);
v9 = strlen(v8);
v10 = mysql_net_store_length(a2, v9);
memcpy(v10, v8, v9);
v11 = v9 + v10;
v12 = v9 + v8 + 1;
v13 = strlen(v12);
v14 = mysql_net_store_length(v11, v13);
memcpy(v14, v12, v13);
a2 = v13 + v14;
++v7;
v6 = *(_QWORD *)(a1 + 1152);
}
while ( v7 < *(_DWORD *)(v6 + 56) );
}
}
return a2;
}
|
ma_send_connect_attr:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
TEST byte ptr [RDI + 0x372],0x10
JZ 0x00119240
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x480]
TEST RAX,RAX
JZ 0x00119196
MOV RSI,qword ptr [RAX + 0x78]
JMP 0x00119198
LAB_00119196:
XOR ESI,ESI
LAB_00119198:
MOV RDI,R14
CALL 0x0011fa2f
MOV R14,RAX
MOV RDI,qword ptr [RBX + 0x480]
TEST RDI,RDI
JZ 0x00119240
CMP qword ptr [RDI + 0x48],0x0
JZ 0x00119240
CMP dword ptr [RDI + 0x38],0x0
JZ 0x00119240
XOR R15D,R15D
LAB_001191c7:
ADD RDI,0x30
MOV ESI,R15D
CALL 0x00131d39
MOV R12,RAX
MOV RDI,RAX
CALL 0x001131c0
MOV R13,RAX
MOV RDI,R14
MOV RSI,RAX
CALL 0x0011fa2f
MOV R14,RAX
MOV RDI,RAX
MOV RSI,R12
MOV RDX,R13
CALL 0x00113390
ADD R14,R13
ADD R12,R13
INC R12
MOV RDI,R12
CALL 0x001131c0
MOV R13,RAX
MOV RDI,R14
MOV RSI,RAX
CALL 0x0011fa2f
MOV R14,RAX
MOV RDI,RAX
MOV RSI,R12
MOV RDX,R13
CALL 0x00113390
ADD R14,R13
INC R15D
MOV RDI,qword ptr [RBX + 0x480]
CMP R15D,dword ptr [RDI + 0x38]
JC 0x001191c7
LAB_00119240:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long ma_send_connect_attr(long param_1,long param_2)
{
char *__s;
size_t __n;
void *pvVar1;
size_t __n_00;
int8 uVar2;
long lVar3;
uint uVar4;
if ((*(byte *)(param_1 + 0x372) & 0x10) != 0) {
if (*(long *)(param_1 + 0x480) == 0) {
uVar2 = 0;
}
else {
uVar2 = *(int8 *)(*(long *)(param_1 + 0x480) + 0x78);
}
param_2 = mysql_net_store_length(param_2,uVar2);
lVar3 = *(long *)(param_1 + 0x480);
if (((lVar3 != 0) && (*(long *)(lVar3 + 0x48) != 0)) && (*(int *)(lVar3 + 0x38) != 0)) {
uVar4 = 0;
do {
__s = (char *)ma_hashtbl_element(lVar3 + 0x30,uVar4);
__n = strlen(__s);
pvVar1 = (void *)mysql_net_store_length(param_2,__n);
memcpy(pvVar1,__s,__n);
__n_00 = strlen(__s + __n + 1);
pvVar1 = (void *)mysql_net_store_length((long)pvVar1 + __n,__n_00);
memcpy(pvVar1,__s + __n + 1,__n_00);
param_2 = (long)pvVar1 + __n_00;
uVar4 = uVar4 + 1;
lVar3 = *(long *)(param_1 + 0x480);
} while (uVar4 < *(uint *)(lVar3 + 0x38));
}
}
return param_2;
}
|
|
57,775
|
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 0x549e1
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 0x24d70
subq $0x1, %r14
jb 0x549f5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x25140
jmp 0x549ce
leaq 0x5cf47(%rip), %rsi # 0xb192f
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x27fde
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x54a04
movq %rax, %r14
movq %rbx, %rdi
callq 0x251d8
movq %r14, %rdi
callq 0x24f80
|
_Z13string_repeatRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
test rdx, rdx
jz short loc_549E1
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_549CE:
sub r14, 1
jb short loc_549F5
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_; std::string::append(std::string const&)
jmp short loc_549CE
loc_549E1:
lea rsi, aErrorWhileHand_0+34h; ""
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_549F5:
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
jmp short $+2
loc_54A04:
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 0x001549e1
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_001549c6:
MOV RDI,RBX
CALL 0x00124d70
LAB_001549ce:
SUB R14,0x1
JC 0x001549f5
LAB_001549d4:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00125140
LAB_001549df:
JMP 0x001549ce
LAB_001549e1:
LEA RSI,[0x1b192f]
LEA RDX,[RSP + 0xf]
MOV RDI,RBX
CALL 0x00127fde
LAB_001549f5:
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 001549c6 to 001549cd has its CatchHandler @ 00154a02 */
std::__cxx11::string::reserve((ulong)param_1);
while (bVar1 = in_RDX != 0, in_RDX = in_RDX + -1, bVar1) {
/* try { // try from 001549d4 to 001549de has its CatchHandler @ 00154a04 */
std::__cxx11::string::append(param_1);
}
}
return param_1;
}
|
|
57,776
|
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;
}
|
O3
|
c
|
pagecache_unlock_by_link:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r12
movl %ecx, -0x30(%rbp)
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %r14
movb 0x10(%rbp), %al
movb %al, -0x29(%rbp)
addq $0xc8, %rdi
cmpq $0x0, 0x108(%r14)
movq %rdi, -0x38(%rbp)
jne 0x3af99
callq 0x29200
movl -0x30(%rbp), %eax
xorl $0x1, %eax
movl %r13d, %ecx
xorl $0x5, %ecx
orl %eax, %ecx
jne 0x3ae3e
movq %r14, %rdi
movq %r15, %rsi
movl $0x5, %edx
movl $0x1, %ecx
callq 0x3a9ff
jmp 0x3af76
incq 0x68(%r14)
cmpb $0x0, -0x29(%rbp)
je 0x3ae8b
testq %r12, %r12
je 0x3ae67
movabsq $0xffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFF
cmpq %rax, 0x88(%r15)
jne 0x3ae67
movq %r12, 0x88(%r15)
testq %rbx, %rbx
je 0x3ae7a
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3a942
movl 0x74(%r15), %eax
andl $-0x4, %eax
orl $0x2, %eax
movw %ax, 0x74(%r15)
jmp 0x3ae90
movzwl 0x74(%r15), %eax
movl %r13d, %ecx
andl $-0x2, %ecx
cmpl $0x6, %ecx
jne 0x3af21
movzwl %ax, %ecx
movl %ecx, %edx
andl $0x40, %edx
je 0x3af21
cmpb $0x0, -0x29(%rbp)
je 0x3af17
andl $0x20, %ecx
jne 0x3af17
leaq 0x10(%r15), %rax
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
testq %rdx, %rdx
je 0x3aece
movq %rcx, 0x18(%rdx)
movq (%rax), %rdx
jmp 0x3aed0
xorl %edx, %edx
movq %rdx, (%rcx)
movq 0x128(%r14), %rcx
movq 0x20(%r15), %rdx
movl 0x28(%r14), %esi
decl %esi
andl 0x28(%rdx), %esi
leaq (%rcx,%rsi,8), %rcx
movq %rcx, 0x18(%r15)
movq (%rcx), %rdx
movq %rdx, 0x10(%r15)
testq %rdx, %rdx
je 0x3aeff
movq %rax, 0x18(%rdx)
movq %r15, (%rcx)
orb $0x20, 0x74(%r15)
incq 0x58(%r14)
incq 0x168(%r14)
movzwl 0x74(%r15), %eax
andl $0xffbf, %eax # imm = 0xFFBF
movw %ax, 0x74(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl %r13d, %edx
movl -0x30(%rbp), %ebx
movl %ebx, %ecx
callq 0x3a9ff
testl %ebx, %ebx
je 0x3af48
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x3ab6f
decq 0x68(%r14)
jne 0x3af76
movq 0x110(%r14), %rax
testq %rax, %rax
je 0x3af76
movq 0x88(%rax), %rbx
movq 0x38(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x3afc1
movq %rbx, %rdi
callq 0x295b0
movq 0x108(%r14), %rdi
testq %rdi, %rdi
jne 0x3afaf
movq -0x38(%rbp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x291c0
leaq 0x9f36a(%rip), %rsi # 0xda30a
movl $0xd47, %edx # imm = 0xD47
callq 0x2eb6f
jmp 0x3ae14
leaq 0x34b05a(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x3af82
leaq 0x34b048(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x170(%rax)
jmp 0x3af6e
|
pagecache_unlock_by_link:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, r9
mov r12, r8
mov [rbp+var_30], ecx
mov r13d, edx
mov r15, rsi
mov r14, rdi
mov al, [rbp+arg_0]
mov [rbp+var_29], al
add rdi, 0C8h
cmp qword ptr [r14+108h], 0
mov [rbp+var_38], rdi
jnz loc_3AF99
call _pthread_mutex_lock
loc_3AE14:
mov eax, [rbp+var_30]
xor eax, 1
mov ecx, r13d
xor ecx, 5
or ecx, eax
jnz short loc_3AE3E
mov rdi, r14
mov rsi, r15
mov edx, 5
mov ecx, 1
call make_lock_and_pin
jmp loc_3AF76
loc_3AE3E:
inc qword ptr [r14+68h]
cmp [rbp+var_29], 0
jz short loc_3AE8B
test r12, r12
jz short loc_3AE67
mov rax, 0FFFFFFFFFFFFFFh
cmp [r15+88h], rax
jnz short loc_3AE67
mov [r15+88h], r12
loc_3AE67:
test rbx, rbx
jz short loc_3AE7A
mov rdi, r14
mov rsi, rbx
mov rdx, r15
call check_and_set_lsn
loc_3AE7A:
mov eax, [r15+74h]
and eax, 0FFFFFFFCh
or eax, 2
mov [r15+74h], ax
jmp short loc_3AE90
loc_3AE8B:
movzx eax, word ptr [r15+74h]
loc_3AE90:
mov ecx, r13d
and ecx, 0FFFFFFFEh
cmp ecx, 6
jnz loc_3AF21
movzx ecx, ax
mov edx, ecx
and edx, 40h
jz short loc_3AF21
cmp [rbp+var_29], 0
jz short loc_3AF17
and ecx, 20h
jnz short loc_3AF17
lea rax, [r15+10h]
mov rdx, [r15+10h]
mov rcx, [r15+18h]
test rdx, rdx
jz short loc_3AECE
mov [rdx+18h], rcx
mov rdx, [rax]
jmp short loc_3AED0
loc_3AECE:
xor edx, edx
loc_3AED0:
mov [rcx], rdx
mov rcx, [r14+128h]
mov rdx, [r15+20h]
mov esi, [r14+28h]
dec esi
and esi, [rdx+28h]
lea rcx, [rcx+rsi*8]
mov [r15+18h], rcx
mov rdx, [rcx]
mov [r15+10h], rdx
test rdx, rdx
jz short loc_3AEFF
mov [rdx+18h], rax
loc_3AEFF:
mov [rcx], r15
or byte ptr [r15+74h], 20h
inc qword ptr [r14+58h]
inc qword ptr [r14+168h]
movzx eax, word ptr [r15+74h]
loc_3AF17:
and eax, 0FFBFh
mov [r15+74h], ax
loc_3AF21:
mov rdi, r14
mov rsi, r15
mov edx, r13d
mov ebx, [rbp+var_30]
mov ecx, ebx
call make_lock_and_pin
test ebx, ebx
jz short loc_3AF48
mov rdi, r14
mov rsi, r15
mov edx, 1
call unreg_request
loc_3AF48:
dec qword ptr [r14+68h]
jnz short loc_3AF76
mov rax, [r14+110h]
test rax, rax
jz short loc_3AF76
mov rbx, [rax+88h]
mov rdi, [rbx+38h]
add rbx, 8
test rdi, rdi
jnz short loc_3AFC1
loc_3AF6E:
mov rdi, rbx
call _pthread_cond_signal
loc_3AF76:
mov rdi, [r14+108h]
test rdi, rdi
jnz short loc_3AFAF
loc_3AF82:
mov rdi, [rbp+var_38]
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_3AF99:
lea rsi, aWorkspaceLlm4b_25; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0D47h
call psi_mutex_lock
jmp loc_3AE14
loc_3AFAF:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_3AF82
loc_3AFC1:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp short loc_3AF6E
|
long long pagecache_unlock_by_link(
long long a1,
long long a2,
int a3,
int a4,
long long a5,
signed long long a6,
char a7)
{
long long v11; // rdi
unsigned int v12; // eax
long long *v13; // rax
long long v14; // rdx
_QWORD *v15; // rcx
long long v16; // rdx
long long *v17; // rcx
long long v18; // rdx
long long v20; // rax
long long v21; // rbx
long long v22; // rdi
long long v23; // rbx
long long v25; // [rsp+8h] [rbp-38h]
v11 = a1 + 200;
v25 = v11;
if ( *(_QWORD *)(a1 + 264) )
psi_mutex_lock(v11, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c", 0xD47u);
else
pthread_mutex_lock(v11);
if ( a4 ^ 1 | a3 ^ 5 )
{
++*(_QWORD *)(a1 + 104);
if ( a7 )
{
if ( a5 && *(_QWORD *)(a2 + 136) == 0xFFFFFFFFFFFFFFLL )
*(_QWORD *)(a2 + 136) = a5;
if ( a6 )
check_and_set_lsn(a1, a6, a2);
v12 = *(_DWORD *)(a2 + 116) & 0xFFFFFFFC | 2;
*(_WORD *)(a2 + 116) = *(_WORD *)(a2 + 116) & 0xFFFC | 2;
}
else
{
LOWORD(v12) = *(_WORD *)(a2 + 116);
}
if ( (a3 & 0xFFFFFFFE) == 6 && (v12 & 0x40) != 0 )
{
if ( a7 && (v12 & 0x20) == 0 )
{
v13 = (long long *)(a2 + 16);
v14 = *(_QWORD *)(a2 + 16);
v15 = *(_QWORD **)(a2 + 24);
if ( v14 )
{
*(_QWORD *)(v14 + 24) = v15;
v16 = *v13;
}
else
{
v16 = 0LL;
}
*v15 = v16;
v17 = (long long *)(*(_QWORD *)(a1 + 296)
+ 8LL * (*(_DWORD *)(*(_QWORD *)(a2 + 32) + 40LL) & (unsigned int)(*(_DWORD *)(a1 + 40) - 1)));
*(_QWORD *)(a2 + 24) = v17;
v18 = *v17;
*(_QWORD *)(a2 + 16) = *v17;
if ( v18 )
*(_QWORD *)(v18 + 24) = v13;
*v17 = a2;
*(_BYTE *)(a2 + 116) |= 0x20u;
++*(_QWORD *)(a1 + 88);
++*(_QWORD *)(a1 + 360);
LOWORD(v12) = *(_WORD *)(a2 + 116);
}
*(_WORD *)(a2 + 116) = v12 & 0xFFBF;
}
make_lock_and_pin(a1, a2, a3, a4);
if ( a4 )
unreg_request((_QWORD *)a1, a2, 1);
if ( (*(_QWORD *)(a1 + 104))-- == 1LL )
{
v20 = *(_QWORD *)(a1 + 272);
if ( v20 )
{
v21 = *(_QWORD *)(v20 + 136);
v22 = *(_QWORD *)(v21 + 56);
v23 = v21 + 8;
if ( v22 )
PSI_server[46]();
pthread_cond_signal(v23);
}
}
}
else
{
make_lock_and_pin(a1, a2, 5, 1);
}
if ( *(_QWORD *)(a1 + 264) )
PSI_server[44]();
return pthread_mutex_unlock(v25);
}
|
pagecache_unlock_by_link:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,R9
MOV R12,R8
MOV dword ptr [RBP + -0x30],ECX
MOV R13D,EDX
MOV R15,RSI
MOV R14,RDI
MOV AL,byte ptr [RBP + 0x10]
MOV byte ptr [RBP + -0x29],AL
ADD RDI,0xc8
CMP qword ptr [R14 + 0x108],0x0
MOV qword ptr [RBP + -0x38],RDI
JNZ 0x0013af99
CALL 0x00129200
LAB_0013ae14:
MOV EAX,dword ptr [RBP + -0x30]
XOR EAX,0x1
MOV ECX,R13D
XOR ECX,0x5
OR ECX,EAX
JNZ 0x0013ae3e
MOV RDI,R14
MOV RSI,R15
MOV EDX,0x5
MOV ECX,0x1
CALL 0x0013a9ff
JMP 0x0013af76
LAB_0013ae3e:
INC qword ptr [R14 + 0x68]
CMP byte ptr [RBP + -0x29],0x0
JZ 0x0013ae8b
TEST R12,R12
JZ 0x0013ae67
MOV RAX,0xffffffffffffff
CMP qword ptr [R15 + 0x88],RAX
JNZ 0x0013ae67
MOV qword ptr [R15 + 0x88],R12
LAB_0013ae67:
TEST RBX,RBX
JZ 0x0013ae7a
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
CALL 0x0013a942
LAB_0013ae7a:
MOV EAX,dword ptr [R15 + 0x74]
AND EAX,0xfffffffc
OR EAX,0x2
MOV word ptr [R15 + 0x74],AX
JMP 0x0013ae90
LAB_0013ae8b:
MOVZX EAX,word ptr [R15 + 0x74]
LAB_0013ae90:
MOV ECX,R13D
AND ECX,0xfffffffe
CMP ECX,0x6
JNZ 0x0013af21
MOVZX ECX,AX
MOV EDX,ECX
AND EDX,0x40
JZ 0x0013af21
CMP byte ptr [RBP + -0x29],0x0
JZ 0x0013af17
AND ECX,0x20
JNZ 0x0013af17
LEA RAX,[R15 + 0x10]
MOV RDX,qword ptr [R15 + 0x10]
MOV RCX,qword ptr [R15 + 0x18]
TEST RDX,RDX
JZ 0x0013aece
MOV qword ptr [RDX + 0x18],RCX
MOV RDX,qword ptr [RAX]
JMP 0x0013aed0
LAB_0013aece:
XOR EDX,EDX
LAB_0013aed0:
MOV qword ptr [RCX],RDX
MOV RCX,qword ptr [R14 + 0x128]
MOV RDX,qword ptr [R15 + 0x20]
MOV ESI,dword ptr [R14 + 0x28]
DEC ESI
AND ESI,dword ptr [RDX + 0x28]
LEA RCX,[RCX + RSI*0x8]
MOV qword ptr [R15 + 0x18],RCX
MOV RDX,qword ptr [RCX]
MOV qword ptr [R15 + 0x10],RDX
TEST RDX,RDX
JZ 0x0013aeff
MOV qword ptr [RDX + 0x18],RAX
LAB_0013aeff:
MOV qword ptr [RCX],R15
OR byte ptr [R15 + 0x74],0x20
INC qword ptr [R14 + 0x58]
INC qword ptr [R14 + 0x168]
MOVZX EAX,word ptr [R15 + 0x74]
LAB_0013af17:
AND EAX,0xffbf
MOV word ptr [R15 + 0x74],AX
LAB_0013af21:
MOV RDI,R14
MOV RSI,R15
MOV EDX,R13D
MOV EBX,dword ptr [RBP + -0x30]
MOV ECX,EBX
CALL 0x0013a9ff
TEST EBX,EBX
JZ 0x0013af48
MOV RDI,R14
MOV RSI,R15
MOV EDX,0x1
CALL 0x0013ab6f
LAB_0013af48:
DEC qword ptr [R14 + 0x68]
JNZ 0x0013af76
MOV RAX,qword ptr [R14 + 0x110]
TEST RAX,RAX
JZ 0x0013af76
MOV RBX,qword ptr [RAX + 0x88]
MOV RDI,qword ptr [RBX + 0x38]
ADD RBX,0x8
TEST RDI,RDI
JNZ 0x0013afc1
LAB_0013af6e:
MOV RDI,RBX
CALL 0x001295b0
LAB_0013af76:
MOV RDI,qword ptr [R14 + 0x108]
TEST RDI,RDI
JNZ 0x0013afaf
LAB_0013af82:
MOV RDI,qword ptr [RBP + -0x38]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001291c0
LAB_0013af99:
LEA RSI,[0x1da30a]
MOV EDX,0xd47
CALL 0x0012eb6f
JMP 0x0013ae14
LAB_0013afaf:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0013af82
LAB_0013afc1:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x0013af6e
|
void pagecache_unlock_by_link
(long param_1,long param_2,uint param_3,int param_4,long param_5,long param_6,
char param_7)
{
long *plVar1;
int8 *puVar2;
long lVar3;
ushort uVar4;
uint uVar5;
int8 uVar6;
pthread_mutex_t *__mutex;
__mutex = (pthread_mutex_t *)(param_1 + 200);
if (*(long *)(param_1 + 0x108) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xd47);
}
if (param_3 == 5 && param_4 == 1) {
make_lock_and_pin(param_1,param_2,5,1);
}
else {
*(long *)(param_1 + 0x68) = *(long *)(param_1 + 0x68) + 1;
if (param_7 == '\0') {
uVar5 = (uint)*(ushort *)(param_2 + 0x74);
}
else {
if ((param_5 != 0) && (*(long *)(param_2 + 0x88) == 0xffffffffffffff)) {
*(long *)(param_2 + 0x88) = param_5;
}
if (param_6 != 0) {
check_and_set_lsn(param_1,param_6,param_2);
}
uVar5 = *(uint *)(param_2 + 0x74) & 0xfffffffc | 2;
*(short *)(param_2 + 0x74) = (short)uVar5;
}
uVar4 = (ushort)uVar5;
if (((param_3 & 0xfffffffe) == 6) && ((uVar5 & 0x40) != 0)) {
if ((param_7 != '\0') && ((uVar5 & 0x20) == 0)) {
puVar2 = *(int8 **)(param_2 + 0x18);
if (*(long *)(param_2 + 0x10) == 0) {
uVar6 = 0;
}
else {
*(int8 **)(*(long *)(param_2 + 0x10) + 0x18) = puVar2;
uVar6 = *(int8 *)(param_2 + 0x10);
}
*puVar2 = uVar6;
plVar1 = (long *)(*(long *)(param_1 + 0x128) +
(ulong)(*(int *)(param_1 + 0x28) - 1U &
*(uint *)(*(long *)(param_2 + 0x20) + 0x28)) * 8);
*(long **)(param_2 + 0x18) = plVar1;
lVar3 = *plVar1;
*(long *)(param_2 + 0x10) = lVar3;
if (lVar3 != 0) {
*(int8 **)(lVar3 + 0x18) = (int8 *)(param_2 + 0x10);
}
*plVar1 = param_2;
*(byte *)(param_2 + 0x74) = *(byte *)(param_2 + 0x74) | 0x20;
*(long *)(param_1 + 0x58) = *(long *)(param_1 + 0x58) + 1;
*(long *)(param_1 + 0x168) = *(long *)(param_1 + 0x168) + 1;
uVar4 = *(ushort *)(param_2 + 0x74);
}
*(ushort *)(param_2 + 0x74) = uVar4 & 0xffbf;
}
make_lock_and_pin(param_1,param_2,param_3,param_4);
if (param_4 != 0) {
unreg_request(param_1,param_2,1);
}
plVar1 = (long *)(param_1 + 0x68);
*plVar1 = *plVar1 + -1;
if ((*plVar1 == 0) && (*(long *)(param_1 + 0x110) != 0)) {
lVar3 = *(long *)(*(long *)(param_1 + 0x110) + 0x88);
if (*(long *)(lVar3 + 0x38) != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal((pthread_cond_t *)(lVar3 + 8));
}
}
if (*(long *)(param_1 + 0x108) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return;
}
|
|
57,777
|
run
|
fabiosvm[P]rak/src/main.c
|
static void run(RakVM *vm, RakChunk *chunk, RakError *err)
{
rak_vm_init(vm, RAK_VM_VSTK_DEFAULT_SIZE, err);
check_error(err);
rak_builtin_load_globals(vm, err);
check_error(err);
rak_vm_run(vm, chunk, err);
check_error(err);
}
|
O0
|
c
|
run:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x400, %esi # imm = 0x400
callq 0xb450
movq -0x18(%rbp), %rdi
callq 0x97e0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2f00
movq -0x18(%rbp), %rdi
callq 0x97e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb540
movq -0x18(%rbp), %rdi
callq 0x97e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
|
run:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_18]
mov esi, 400h
call rak_vm_init
mov rdi, [rbp+var_18]
call check_error
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call rak_builtin_load_globals
mov rdi, [rbp+var_18]
call check_error
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call rak_vm_run
mov rdi, [rbp+var_18]
call check_error
add rsp, 20h
pop rbp
retn
|
_BYTE * run(long long a1, long long a2, _BYTE *a3)
{
rak_vm_init(a1, 1024LL, a3);
check_error(a3);
rak_builtin_load_globals(a1, a3);
check_error(a3);
rak_vm_run(a1, a2, a3);
return check_error(a3);
}
|
run:
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 RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x18]
MOV ESI,0x400
CALL 0x0010b450
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001097e0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00102f00
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001097e0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x0010b540
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001097e0
ADD RSP,0x20
POP RBP
RET
|
void run(int8 param_1,int8 param_2,int8 param_3)
{
rak_vm_init(param_1,0x400,param_3);
check_error(param_3);
rak_builtin_load_globals(param_1,param_3);
check_error(param_3);
rak_vm_run(param_1,param_2,param_3);
check_error(param_3);
return;
}
|
|
57,778
|
ftxui::ContainerBase::MoveSelector(int)
|
Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/component/container.cpp
|
void MoveSelector(int dir) {
for (int i = *selector_ + dir; i >= 0 && i < int(children_.size());
i += dir) {
if (children_[i]->Focusable()) {
*selector_ = i;
return;
}
}
}
|
O3
|
cpp
|
ftxui::ContainerBase::MoveSelector(int):
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl (%rax), %r14d
addl %ebp, %r14d
js 0x282f5
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
cmpl %ecx, %r14d
jge 0x282f5
movl %r14d, %ecx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x282c0
movq 0x30(%rbx), %rax
movl %r14d, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
|
_ZN5ftxui13ContainerBase12MoveSelectorEi:
push rbp
push r14
push rbx
mov ebp, esi
mov rbx, rdi
mov rax, [rdi+30h]
mov r14d, [rax]
loc_282C0:
add r14d, ebp
js short loc_282F5
mov rax, [rbx+8]
mov rcx, [rbx+10h]
sub rcx, rax
shr rcx, 4
cmp r14d, ecx
jge short loc_282F5
mov ecx, r14d
shl rcx, 4
mov rdi, [rax+rcx]
mov rax, [rdi]
call qword ptr [rax+30h]
test al, al
jz short loc_282C0
mov rax, [rbx+30h]
mov [rax], r14d
loc_282F5:
pop rbx
pop r14
pop rbp
retn
|
int * ftxui::ContainerBase::MoveSelector(ftxui::ContainerBase *this, int a2)
{
int *result; // rax
int v3; // r14d
result = (int *)*((_QWORD *)this + 6);
v3 = *result;
while ( 1 )
{
v3 += a2;
if ( v3 < 0 )
break;
result = (int *)*((_QWORD *)this + 1);
if ( v3 >= (int)((*((_QWORD *)this + 2) - (_QWORD)result) >> 4) )
break;
result = (int *)(*(long long ( **)(_QWORD))(**(_QWORD **)&result[4 * v3] + 48LL))(*(_QWORD *)&result[4 * v3]);
if ( (_BYTE)result )
{
result = (int *)*((_QWORD *)this + 6);
*result = v3;
return result;
}
}
return result;
}
|
MoveSelector:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBP,ESI
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x30]
MOV R14D,dword ptr [RAX]
LAB_001282c0:
ADD R14D,EBP
JS 0x001282f5
MOV RAX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RBX + 0x10]
SUB RCX,RAX
SHR RCX,0x4
CMP R14D,ECX
JGE 0x001282f5
MOV ECX,R14D
SHL RCX,0x4
MOV RDI,qword ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x30]
TEST AL,AL
JZ 0x001282c0
MOV RAX,qword ptr [RBX + 0x30]
MOV dword ptr [RAX],R14D
LAB_001282f5:
POP RBX
POP R14
POP RBP
RET
|
/* ftxui::ContainerBase::MoveSelector(int) */
void __thiscall ftxui::ContainerBase::MoveSelector(ContainerBase *this,int param_1)
{
char cVar1;
uint uVar2;
uVar2 = **(uint **)(this + 0x30);
while( true ) {
uVar2 = uVar2 + param_1;
if ((int)uVar2 < 0) {
return;
}
if ((int)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 4) <= (int)uVar2) break;
cVar1 = (**(code **)(**(long **)(*(long *)(this + 8) + (ulong)uVar2 * 0x10) + 0x30))();
if (cVar1 != '\0') {
**(uint **)(this + 0x30) = uVar2;
return;
}
}
return;
}
|
|
57,779
|
my_hash_sort_utf32_nopad
|
eloqsql/strings/ctype-ucs2.c
|
static void
my_hash_sort_utf32_nopad(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
int res;
const uchar *e= s + slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((res= my_utf32_uni(cs, &wc, (uchar*) s, (uchar*) e)) > 0)
{
my_tosort_utf32(uni_plane, &wc);
MY_HASH_ADD(m1, m2, (uint) (wc >> 24));
MY_HASH_ADD(m1, m2, (uint) (wc >> 16) & 0xFF);
MY_HASH_ADD(m1, m2, (uint) (wc >> 8) & 0xFF);
MY_HASH_ADD(m1, m2, (uint) (wc & 0xFF));
s+= res;
}
*nr1= m1;
*nr2= m2;
}
|
O0
|
c
|
my_hash_sort_utf32_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x59c90
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0x5ed87
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5edb0
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x18, %rcx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x5ecb3
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x10, %rcx
andl $0xff, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x5ecf4
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x8, %rcx
andl $0xff, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x5ed35
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
andq $0xff, %rcx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x5ec4a
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_hash_sort_utf32_nopad:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_58], rax
loc_5EC4A:
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_utf32_uni
mov [rbp+var_34], eax
cmp eax, 0
jle loc_5ED87
mov rdi, [rbp+var_48]
lea rsi, [rbp+var_30]
call my_tosort_utf32
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
shr rcx, 18h
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_5ECB3:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
shr rcx, 10h
and ecx, 0FFh
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_5ECF4:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
shr rcx, 8
and ecx, 0FFh
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_5ED35:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
and rcx, 0FFh
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp loc_5EC4A
loc_5ED87:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_58]
mov rax, [rbp+var_28]
mov [rax], rcx
add rsp, 60h
pop rbp
retn
|
_QWORD * my_hash_sort_utf32_nopad(long long a1, long long a2, long long a3, long long *a4, _QWORD *a5, long long a6)
{
_QWORD *result; // rax
long long v7; // [rsp+8h] [rbp-58h]
long long v8; // [rsp+8h] [rbp-58h]
long long v9; // [rsp+10h] [rbp-50h]
long long v10; // [rsp+10h] [rbp-50h]
long long v11; // [rsp+10h] [rbp-50h]
long long v12; // [rsp+10h] [rbp-50h]
long long v13; // [rsp+18h] [rbp-48h]
long long v14; // [rsp+20h] [rbp-40h]
int v15; // [rsp+2Ch] [rbp-34h]
unsigned long long v16; // [rsp+30h] [rbp-30h] BYREF
_QWORD *v17; // [rsp+38h] [rbp-28h]
long long *v18; // [rsp+40h] [rbp-20h]
long long v19; // [rsp+48h] [rbp-18h]
long long v20; // [rsp+50h] [rbp-10h]
long long v21; // [rsp+58h] [rbp-8h]
v21 = a1;
v20 = a2;
v19 = a3;
v18 = a4;
v17 = a5;
v14 = a3 + a2;
v13 = *(_QWORD *)(a1 + 120);
v9 = *a4;
v7 = *a5;
while ( 1 )
{
v15 = my_utf32_uni(v21, (long long)&v16, v20, v14, (long long)a5, a6);
if ( v15 <= 0 )
break;
my_tosort_utf32(v13, &v16);
v10 = v9 ^ ((v9 << 8) + (unsigned int)(v16 >> 24) * (v7 + (v9 & 0x3F)));
v8 = v7 + 3;
v11 = v10 ^ ((v10 << 8) + BYTE2(v16) * (v8 + (v10 & 0x3F)));
v8 += 3LL;
v12 = v11 ^ ((v11 << 8) + BYTE1(v16) * (v8 + (v11 & 0x3F)));
v8 += 3LL;
v9 = v12 ^ ((v12 << 8) + (unsigned __int8)v16 * (v8 + (v12 & 0x3F)));
v7 = v8 + 3;
v20 += v15;
}
*v18 = v9;
result = v17;
*v17 = v7;
return result;
}
|
my_hash_sort_utf32_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
LAB_0015ec4a:
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x00159c90
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x0015ed87
MOV RDI,qword ptr [RBP + -0x48]
LEA RSI,[RBP + -0x30]
CALL 0x0015edb0
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x18
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0015ecb3
LAB_0015ecb3:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x10
AND ECX,0xff
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0015ecf4
LAB_0015ecf4:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x8
AND ECX,0xff
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0015ed35
LAB_0015ed35:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
AND RCX,0xff
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0015ec4a
LAB_0015ed87:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
ADD RSP,0x60
POP RBP
RET
|
void my_hash_sort_utf32_nopad(long param_1,long param_2,long param_3,ulong *param_4,long *param_5)
{
int8 uVar1;
int iVar2;
long local_60;
ulong local_58;
ulong local_38;
long *local_30;
ulong *local_28;
long local_20;
long local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_58 = *param_4;
local_60 = *param_5;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
iVar2 = my_utf32_uni(local_10,&local_38,local_18,param_2 + param_3);
if (iVar2 < 1) break;
my_tosort_utf32(uVar1,&local_38);
local_58 = ((local_58 & 0x3f) + local_60) * (local_38 >> 0x18 & 0xffffffff) + local_58 * 0x100 ^
local_58;
local_58 = ((local_58 & 0x3f) + local_60 + 3) * (ulong)((uint)(local_38 >> 0x10) & 0xff) +
local_58 * 0x100 ^ local_58;
local_58 = ((local_58 & 0x3f) + local_60 + 6) * (ulong)((uint)(local_38 >> 8) & 0xff) +
local_58 * 0x100 ^ local_58;
local_58 = ((local_58 & 0x3f) + local_60 + 9) * (ulong)((uint)local_38 & 0xff) +
local_58 * 0x100 ^ local_58;
local_60 = local_60 + 0xc;
local_18 = local_18 + iVar2;
}
*local_28 = local_58;
*local_30 = local_60;
return;
}
|
|
57,780
|
unsigned char const* evmone::instr::core::push<3ul>(evmone::StackTop, evmone::ExecutionState&, unsigned char const*)
|
corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/lib/evmone/instructions.hpp
|
inline code_iterator push(StackTop stack, ExecutionState& /*state*/, code_iterator pos) noexcept
{
constexpr auto num_full_words = Len / sizeof(uint64_t);
constexpr auto num_partial_bytes = Len % sizeof(uint64_t);
auto data = pos + 1;
stack.push(0);
auto& r = stack.top();
// Load top partial word.
if constexpr (num_partial_bytes != 0)
{
r[num_full_words] = load_partial_push_data<num_partial_bytes>(data);
data += num_partial_bytes;
}
// Load full words.
for (size_t i = 0; i < num_full_words; ++i)
{
r[num_full_words - 1 - i] = intx::be::unsafe::load<uint64_t>(data);
data += sizeof(uint64_t);
}
return pos + (Len + 1);
}
|
O0
|
cpp
|
unsigned char const* evmone::instr::core::push<3ul>(evmone::StackTop, evmone::ExecutionState&, unsigned char const*):
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x4, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x60670
leaq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x674a0
leaq -0x8(%rbp), %rdi
callq 0x5fb80
movq %rax, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
cmpq $0x4, -0x60(%rbp)
jae 0x6ba04
movq -0x30(%rbp), %rdi
callq 0x69d60
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
movl $0x3, %esi
subq -0x60(%rbp), %rsi
callq 0x5fe00
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x6b9bd
movq -0x18(%rbp), %rax
addq $0x21, %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN6evmone5instr4core4pushILm32EEEPKhNS_8StackTopERNS_14ExecutionStateES4_:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], 4
mov [rbp+var_28], 0
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_30], rax
lea rdi, [rbp+var_50]
xor esi, esi
call _ZN4intx4uintILj256EEC2IJiEvEEDpT_; intx::uint<256u>::uint<int,void>(int)
lea rdi, [rbp+var_8]
lea rsi, [rbp+var_50]
call _ZN6evmone8StackTop4pushERKN4intx4uintILj256EEE; evmone::StackTop::push(intx::uint<256u> const&)
lea rdi, [rbp+var_8]; this
call _ZN6evmone8StackTop3topEv; evmone::StackTop::top(void)
mov [rbp+var_58], rax
mov [rbp+var_60], 0
loc_6B9BD:
cmp [rbp+var_60], 4
jnb short loc_6BA04
mov rdi, [rbp+var_30]
call _ZN4intx2be6unsafe4loadImEET_PKh; intx::be::unsafe::load<ulong>(uchar const*)
mov [rbp+var_68], rax
mov rdi, [rbp+var_58]
mov esi, 3
sub rsi, [rbp+var_60]
call _ZN4intx4uintILj256EEixEm; intx::uint<256u>::operator[](ulong)
mov rcx, [rbp+var_68]
mov [rax], rcx
mov rax, [rbp+var_30]
add rax, 8
mov [rbp+var_30], rax
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_60], rax
jmp short loc_6B9BD
loc_6BA04:
mov rax, [rbp+var_18]
add rax, 21h ; '!'
add rsp, 70h
pop rbp
retn
|
long long evmone::instr::core::push<32ul>(long long a1, long long a2, long long a3)
{
unsigned long long v4; // [rsp+8h] [rbp-68h]
unsigned long long i; // [rsp+10h] [rbp-60h]
long long v6; // [rsp+18h] [rbp-58h]
_QWORD v7[4]; // [rsp+20h] [rbp-50h] BYREF
intx *v8; // [rsp+40h] [rbp-30h]
long long v9; // [rsp+48h] [rbp-28h]
long long v10; // [rsp+50h] [rbp-20h]
long long v11; // [rsp+58h] [rbp-18h]
long long v12; // [rsp+60h] [rbp-10h]
long long v13; // [rsp+68h] [rbp-8h] BYREF
v13 = a1;
v12 = a2;
v11 = a3;
v10 = 4LL;
v9 = 0LL;
v8 = (intx *)(a3 + 1);
intx::uint<256u>::uint<int,void>(v7, 0);
evmone::StackTop::push(&v13, v7);
v6 = evmone::StackTop::top((evmone::StackTop *)&v13);
for ( i = 0LL; i < 4; ++i )
{
v4 = intx::be::unsafe::load<unsigned long>(v8);
*(_QWORD *)intx::uint<256u>::operator[](v6, 3 - i) = v4;
v8 = (intx *)((char *)v8 + 8);
}
return v11 + 33;
}
|
push<32ul>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],0x4
MOV qword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[RBP + -0x50]
XOR ESI,ESI
CALL 0x00160670
LEA RDI,[RBP + -0x8]
LEA RSI,[RBP + -0x50]
CALL 0x001674a0
LEA RDI,[RBP + -0x8]
CALL 0x0015fb80
MOV qword ptr [RBP + -0x58],RAX
MOV qword ptr [RBP + -0x60],0x0
LAB_0016b9bd:
CMP qword ptr [RBP + -0x60],0x4
JNC 0x0016ba04
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00169d60
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x58]
MOV ESI,0x3
SUB RSI,qword ptr [RBP + -0x60]
CALL 0x0015fe00
MOV RCX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x8
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
JMP 0x0016b9bd
LAB_0016ba04:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x21
ADD RSP,0x70
POP RBP
RET
|
/* unsigned char const* evmone::instr::core::push<32ul>(evmone::StackTop, evmone::ExecutionState&,
unsigned char const*) */
uchar * evmone::instr::core::push<32ul>(int8 param_1,int8 param_2,long param_3)
{
uint<256u> *this;
ulong uVar1;
ulong *puVar2;
ulong local_68;
uint<256u> local_58 [32];
uchar *local_38;
int8 local_30;
int8 local_28;
long local_20;
int8 local_18;
int8 local_10;
local_28 = 4;
local_30 = 0;
local_38 = (uchar *)(param_3 + 1);
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
intx::uint<256u>::uint<int,void>(local_58,0);
StackTop::push((StackTop *)&local_10,(uint *)local_58);
this = (uint<256u> *)StackTop::top((StackTop *)&local_10);
for (local_68 = 0; local_68 < 4; local_68 = local_68 + 1) {
uVar1 = intx::be::unsafe::load<unsigned_long>(local_38);
puVar2 = (ulong *)intx::uint<256u>::operator[](this,3 - local_68);
*puVar2 = uVar1;
local_38 = local_38 + 8;
}
return (uchar *)(local_20 + 0x21);
}
|
|
57,781
|
my_strnncoll_latin1_de
|
eloqsql/strings/ctype-latin1.c
|
static int my_strnncoll_latin1_de(CHARSET_INFO *cs __attribute__((unused)),
const uchar *a, size_t a_length,
const uchar *b, size_t b_length,
my_bool b_is_prefix)
{
const uchar *a_end= a + a_length;
const uchar *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;
}
/*
A simple test of string lengths won't work -- we test to see
which string ran out first
*/
return ((a < a_end || a_extend) ? (b_is_prefix ? 0 : 1) :
(b < b_end || b_extend) ? -1 : 0);
}
|
O3
|
c
|
my_strnncoll_latin1_de:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
addq %rsi, %rdx
addq %rcx, %r8
xorl %r10d, %r10d
leaq 0x1717e4(%rip), %rax # 0x224570
leaq 0x1716dd(%rip), %rdi # 0x224470
xorl %r11d, %r11d
cmpq %r8, %rcx
setb %r14b
testb %r11b, %r11b
setne %bl
orb %r14b, %bl
cmpq %rdx, %rsi
jb 0xb2db0
testb %r10b, %r10b
je 0xb2dfa
testb %bl, %bl
je 0xb2e01
testb %r10b, %r10b
je 0xb2dc1
movl %r10d, %ebx
xorl %r10d, %r10d
jmp 0xb2dce
movzbl (%rsi), %ebx
movb (%rbx,%rax), %r10b
incq %rsi
movb (%rbx,%rdi), %bl
testb %r11b, %r11b
je 0xb2ddb
movl %r11d, %r14d
xorl %r11d, %r11d
jmp 0xb2dea
movzbl (%rcx), %r14d
movb (%r14,%rax), %r11b
incq %rcx
movb (%r14,%rdi), %r14b
cmpb %r14b, %bl
je 0xb2d96
movzbl %r14b, %ecx
movzbl %bl, %eax
subl %ecx, %eax
jmp 0xb2e09
movzbl %bl, %eax
negl %eax
jmp 0xb2e09
xorl %eax, %eax
testb %r9b, %r9b
sete %al
popq %rbx
popq %r14
popq %rbp
retq
|
my_strnncoll_latin1_de:
push rbp
mov rbp, rsp
push r14
push rbx
add rdx, rsi
add r8, rcx
xor r10d, r10d
lea rax, combo2map
lea rdi, combo1map
xor r11d, r11d
loc_B2D96:
cmp rcx, r8
setb r14b
test r11b, r11b
setnz bl
or bl, r14b
cmp rsi, rdx
jb short loc_B2DB0
test r10b, r10b
jz short loc_B2DFA
loc_B2DB0:
test bl, bl
jz short loc_B2E01
test r10b, r10b
jz short loc_B2DC1
mov ebx, r10d
xor r10d, r10d
jmp short loc_B2DCE
loc_B2DC1:
movzx ebx, byte ptr [rsi]
mov r10b, [rbx+rax]
inc rsi
mov bl, [rbx+rdi]
loc_B2DCE:
test r11b, r11b
jz short loc_B2DDB
mov r14d, r11d
xor r11d, r11d
jmp short loc_B2DEA
loc_B2DDB:
movzx r14d, byte ptr [rcx]
mov r11b, [r14+rax]
inc rcx
mov r14b, [r14+rdi]
loc_B2DEA:
cmp bl, r14b
jz short loc_B2D96
movzx ecx, r14b
movzx eax, bl
sub eax, ecx
jmp short loc_B2E09
loc_B2DFA:
movzx eax, bl
neg eax
jmp short loc_B2E09
loc_B2E01:
xor eax, eax
test r9b, r9b
setz al
loc_B2E09:
pop rbx
pop r14
pop rbp
retn
|
long long my_strnncoll_latin1_de(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned __int8 *a4,
long long a5,
char a6)
{
unsigned __int8 *v6; // rdx
unsigned __int8 *v7; // r8
unsigned __int8 v8; // r10
unsigned __int8 v9; // r11
bool v10; // bl
unsigned __int8 v11; // bl
long long v12; // rbx
unsigned __int8 v13; // r14
long long v14; // r14
v6 = &a2[a3];
v7 = &a4[a5];
v8 = 0;
v9 = 0;
while ( 1 )
{
v10 = a4 < v7 || v9 != 0;
if ( a2 >= v6 && !v8 )
return (unsigned int)-v10;
if ( !v10 )
break;
if ( v8 )
{
v11 = v8;
v8 = 0;
}
else
{
v12 = *a2;
v8 = combo2map[v12];
++a2;
v11 = combo1map[v12];
}
if ( v9 )
{
v13 = v9;
v9 = 0;
}
else
{
v14 = *a4;
v9 = combo2map[v14];
++a4;
v13 = combo1map[v14];
}
if ( v11 != v13 )
return v11 - (unsigned int)v13;
}
return a6 == 0;
}
|
my_strnncoll_latin1_de:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
ADD RDX,RSI
ADD R8,RCX
XOR R10D,R10D
LEA RAX,[0x324570]
LEA RDI,[0x324470]
XOR R11D,R11D
LAB_001b2d96:
CMP RCX,R8
SETC R14B
TEST R11B,R11B
SETNZ BL
OR BL,R14B
CMP RSI,RDX
JC 0x001b2db0
TEST R10B,R10B
JZ 0x001b2dfa
LAB_001b2db0:
TEST BL,BL
JZ 0x001b2e01
TEST R10B,R10B
JZ 0x001b2dc1
MOV EBX,R10D
XOR R10D,R10D
JMP 0x001b2dce
LAB_001b2dc1:
MOVZX EBX,byte ptr [RSI]
MOV R10B,byte ptr [RBX + RAX*0x1]
INC RSI
MOV BL,byte ptr [RBX + RDI*0x1]
LAB_001b2dce:
TEST R11B,R11B
JZ 0x001b2ddb
MOV R14D,R11D
XOR R11D,R11D
JMP 0x001b2dea
LAB_001b2ddb:
MOVZX R14D,byte ptr [RCX]
MOV R11B,byte ptr [R14 + RAX*0x1]
INC RCX
MOV R14B,byte ptr [R14 + RDI*0x1]
LAB_001b2dea:
CMP BL,R14B
JZ 0x001b2d96
MOVZX ECX,R14B
MOVZX EAX,BL
SUB EAX,ECX
JMP 0x001b2e09
LAB_001b2dfa:
MOVZX EAX,BL
NEG EAX
JMP 0x001b2e09
LAB_001b2e01:
XOR EAX,EAX
TEST R9B,R9B
SETZ AL
LAB_001b2e09:
POP RBX
POP R14
POP RBP
RET
|
uint my_strnncoll_latin1_de
(int8 param_1,byte *param_2,long param_3,byte *param_4,long param_5,
char param_6)
{
byte *pbVar1;
byte bVar2;
byte *pbVar3;
byte bVar4;
byte bVar5;
byte bVar6;
pbVar1 = param_2 + param_3;
pbVar3 = param_4 + param_5;
bVar4 = 0;
bVar5 = 0;
do {
if ((pbVar1 <= param_2) && (bVar4 == 0)) {
return -(uint)(bVar5 != 0 || param_4 < pbVar3);
}
if (bVar5 == 0 && param_4 >= pbVar3) {
return (uint)(param_6 == '\0');
}
if (bVar4 == 0) {
bVar2 = *param_2;
bVar4 = combo2map[bVar2];
param_2 = param_2 + 1;
bVar2 = combo1map[bVar2];
}
else {
bVar2 = bVar4;
bVar4 = 0;
}
if (bVar5 == 0) {
bVar6 = *param_4;
bVar5 = combo2map[bVar6];
param_4 = param_4 + 1;
bVar6 = combo1map[bVar6];
}
else {
bVar6 = bVar5;
bVar5 = 0;
}
} while (bVar2 == bVar6);
return (uint)bVar2 - (uint)bVar6;
}
|
|
57,782
|
ma_field_extension_deep_dup
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
MA_FIELD_EXTENSION *ma_field_extension_deep_dup(MA_MEM_ROOT *memroot,
const MA_FIELD_EXTENSION *from)
{
MA_FIELD_EXTENSION *ext= new_ma_field_extension(memroot);
uint i;
if (!ext)
return NULL;
for (i= 0; i < MARIADB_FIELD_ATTR_LAST; i++)
{
if (from->metadata[i].str)
ext->metadata[i]= ma_const_string_copy_root(memroot,
from->metadata[i].str,
from->metadata[i].length);
}
return ext;
}
|
O0
|
c
|
ma_field_extension_deep_dup:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b770
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4b7e1
movq $0x0, -0x8(%rbp)
jmp 0x4b87a
movl $0x0, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jae 0x4b872
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x4b862
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
callq 0x4b890
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x4b864
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4b7e8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_field_extension_deep_dup:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]
call new_ma_field_extension
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jnz short loc_4B7E1
mov [rbp+var_8], 0
jmp loc_4B87A
loc_4B7E1:
mov [rbp+var_24], 0
loc_4B7E8:
cmp [rbp+var_24], 1
jnb loc_4B872
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
shl rcx, 4
add rax, rcx
cmp qword ptr [rax], 0
jz short loc_4B862
mov rax, [rbp+var_20]
mov ecx, [rbp+var_24]
shl rcx, 4
add rax, rcx
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
shl rcx, 4
add rax, rcx
mov rsi, [rax]
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
shl rcx, 4
add rax, rcx
mov rdx, [rax+8]
call ma_const_string_copy_root
mov rcx, rax
mov rax, [rbp+var_40]
mov [rbp+var_38], rcx
mov [rbp+var_30], rdx
mov rcx, [rbp+var_38]
mov [rax], rcx
mov rcx, [rbp+var_30]
mov [rax+8], rcx
loc_4B862:
jmp short $+2
loc_4B864:
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp loc_4B7E8
loc_4B872:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_4B87A:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
_QWORD * ma_field_extension_deep_dup(long long a1, _QWORD *a2)
{
long long v2; // rdx
int i; // [rsp+1Ch] [rbp-24h]
_QWORD *v5; // [rsp+20h] [rbp-20h]
v5 = (_QWORD *)new_ma_field_extension(a1);
if ( !v5 )
return 0LL;
for ( i = 0; !i; i = 1 )
{
if ( *a2 )
{
*v5 = ma_const_string_copy_root(a1, *a2, a2[1]);
v5[1] = v2;
}
}
return v5;
}
|
ma_field_extension_deep_dup:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014b770
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0014b7e1
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014b87a
LAB_0014b7e1:
MOV dword ptr [RBP + -0x24],0x0
LAB_0014b7e8:
CMP dword ptr [RBP + -0x24],0x1
JNC 0x0014b872
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
SHL RCX,0x4
ADD RAX,RCX
CMP qword ptr [RAX],0x0
JZ 0x0014b862
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x0014b890
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RCX
MOV qword ptr [RBP + -0x30],RDX
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],RCX
LAB_0014b862:
JMP 0x0014b864
LAB_0014b864:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0014b7e8
LAB_0014b872:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_0014b87a:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int1 (*) [16] ma_field_extension_deep_dup(int8 param_1,long *param_2)
{
bool bVar1;
int1 auVar2 [16];
int1 (*local_10) [16];
local_10 = (int1 (*) [16])new_ma_field_extension(param_1);
if (local_10 == (int1 (*) [16])0x0) {
local_10 = (int1 (*) [16])0x0;
}
else {
bVar1 = false;
while (!bVar1) {
if (*param_2 != 0) {
auVar2 = ma_const_string_copy_root(param_1,*param_2,param_2[1]);
*local_10 = auVar2;
}
bVar1 = true;
}
}
return local_10;
}
|
|
57,783
|
my_setwd
|
eloqsql/mysys/my_getwd.c
|
int my_setwd(const char *dir, myf MyFlags)
{
int res;
size_t length;
char *start, *pos;
DBUG_ENTER("my_setwd");
DBUG_PRINT("my",("dir: '%s' MyFlags %lu", dir, MyFlags));
start=(char *) dir;
if (! dir[0] || (dir[0] == FN_LIBCHAR && dir[1] == 0))
dir=FN_ROOTDIR;
if ((res=chdir((char*) dir)) != 0)
{
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_SETWD,MYF(ME_BELL),start,errno);
}
else
{
if (test_if_hard_path(start))
{ /* Hard pathname */
pos= strmake(&curr_dir[0],start,(size_t) FN_REFLEN-1);
if (pos[-1] != FN_LIBCHAR)
{
length=(uint) (pos-(char*) curr_dir);
curr_dir[length]=FN_LIBCHAR; /* must end with '/' */
curr_dir[length+1]='\0';
}
}
else
curr_dir[0]='\0'; /* Don't save name */
}
DBUG_RETURN(res);
}
|
O0
|
c
|
my_setwd:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x34c92
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x34cbc
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x34cc7
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x34cc7
leaq 0x4c727(%rip), %rax # 0x813ea
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24430
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x34d20
callq 0x24050
movl (%rax), %eax
movl %eax, -0x34(%rbp)
callq 0x26810
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x34d1e
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x24050
movq -0x40(%rbp), %rdx
movl (%rax), %ecx
movl $0x11, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x34540
jmp 0x34d95
movq -0x28(%rbp), %rdi
callq 0x34db0
cmpl $0x0, %eax
je 0x34d89
movq -0x28(%rbp), %rsi
leaq 0x358be7(%rip), %rdi # 0x38d920
movl $0x1ff, %edx # imm = 0x1FF
callq 0x7de10
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x34d87
movq -0x30(%rbp), %rax
leaq 0x358bc1(%rip), %rcx # 0x38d920
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0x358bad(%rip), %rax # 0x38d920
movb $0x2f, (%rax,%rcx)
movq -0x20(%rbp), %rcx
leaq 0x358b9e(%rip), %rax # 0x38d920
movb $0x0, 0x1(%rax,%rcx)
jmp 0x34d93
leaq 0x358b90(%rip), %rax # 0x38d920
movb $0x0, (%rax)
jmp 0x34d95
jmp 0x34d97
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_setwd:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_34C92:
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov rax, [rbp+var_8]
cmp byte ptr [rax], 0
jz short loc_34CBC
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_34CC7
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax+1]
cmp eax, 0
jnz short loc_34CC7
loc_34CBC:
lea rax, unk_813EA
mov [rbp+var_8], rax
loc_34CC7:
mov rdi, [rbp+var_8]
call _chdir
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_34D20
call ___errno_location
mov eax, [rax]
mov [rbp+var_34], eax
call _my_thread_var
mov ecx, [rbp+var_34]
mov [rax], ecx
mov rax, [rbp+var_10]
and rax, 10h
cmp rax, 0
jz short loc_34D1E
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
call ___errno_location
mov rdx, [rbp+var_40]
mov ecx, [rax]
mov edi, 11h
mov esi, 4
mov al, 0
call my_error
loc_34D1E:
jmp short loc_34D95
loc_34D20:
mov rdi, [rbp+var_28]
call test_if_hard_path
cmp eax, 0
jz short loc_34D89
mov rsi, [rbp+var_28]
lea rdi, curr_dir
mov edx, 1FFh
call strmake
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jz short loc_34D87
mov rax, [rbp+var_30]
lea rcx, curr_dir
sub rax, rcx
mov eax, eax
mov [rbp+var_20], rax
mov rcx, [rbp+var_20]
lea rax, curr_dir
mov byte ptr [rax+rcx], 2Fh ; '/'
mov rcx, [rbp+var_20]
lea rax, curr_dir
mov byte ptr [rax+rcx+1], 0
loc_34D87:
jmp short loc_34D93
loc_34D89:
lea rax, curr_dir
mov byte ptr [rax], 0
loc_34D93:
jmp short $+2
loc_34D95:
jmp short $+2
loc_34D97:
mov eax, [rbp+var_14]
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
add rsp, 50h
pop rbp
retn
|
long long my_setwd(_BYTE *a1, char a2)
{
unsigned int *v2; // rax
int v4; // [rsp+1Ch] [rbp-34h]
long long v5; // [rsp+20h] [rbp-30h]
unsigned int v6; // [rsp+3Ch] [rbp-14h]
void *v7; // [rsp+48h] [rbp-8h]
v7 = a1;
if ( !*a1 || *a1 == 47 && !a1[1] )
v7 = &unk_813EA;
v6 = chdir(v7);
if ( v6 )
{
v4 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var() = v4;
if ( (a2 & 0x10) != 0 )
{
v2 = (unsigned int *)__errno_location();
my_error(0x11u, 4LL, a1, *v2);
}
}
else if ( (unsigned int)test_if_hard_path(a1) )
{
v5 = strmake(curr_dir, a1, 511LL);
if ( *(_BYTE *)(v5 - 1) != 47 )
{
curr_dir[(unsigned int)(v5 - (_QWORD)curr_dir)] = 47;
curr_dir[(unsigned int)(v5 - (_QWORD)curr_dir) + 1] = 0;
}
}
else
{
curr_dir[0] = 0;
}
return v6;
}
|
my_setwd:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x00134c92
LAB_00134c92:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX],0x0
JZ 0x00134cbc
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x00134cc7
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x0
JNZ 0x00134cc7
LAB_00134cbc:
LEA RAX,[0x1813ea]
MOV qword ptr [RBP + -0x8],RAX
LAB_00134cc7:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00124430
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x00134d20
CALL 0x00124050
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
CALL 0x00126810
MOV ECX,dword ptr [RBP + -0x34]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x10
CMP RAX,0x0
JZ 0x00134d1e
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
CALL 0x00124050
MOV RDX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RAX]
MOV EDI,0x11
MOV ESI,0x4
MOV AL,0x0
CALL 0x00134540
LAB_00134d1e:
JMP 0x00134d95
LAB_00134d20:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00134db0
CMP EAX,0x0
JZ 0x00134d89
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[0x48d920]
MOV EDX,0x1ff
CALL 0x0017de10
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JZ 0x00134d87
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x48d920]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0x20],RAX
MOV RCX,qword ptr [RBP + -0x20]
LEA RAX,[0x48d920]
MOV byte ptr [RAX + RCX*0x1],0x2f
MOV RCX,qword ptr [RBP + -0x20]
LEA RAX,[0x48d920]
MOV byte ptr [RAX + RCX*0x1 + 0x1],0x0
LAB_00134d87:
JMP 0x00134d93
LAB_00134d89:
LEA RAX,[0x48d920]
MOV byte ptr [RAX],0x0
LAB_00134d93:
JMP 0x00134d95
LAB_00134d95:
JMP 0x00134d97
LAB_00134d97:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
ADD RSP,0x50
POP RBP
RET
|
int my_setwd(char *param_1,ulong param_2)
{
int iVar1;
int iVar2;
uint uVar3;
int *piVar4;
long lVar5;
char *local_10;
if ((*param_1 == '\0') || ((local_10 = param_1, *param_1 == '/' && (param_1[1] == '\0')))) {
local_10 = "/";
}
iVar1 = chdir(local_10);
if (iVar1 == 0) {
iVar2 = test_if_hard_path(param_1);
if (iVar2 == 0) {
curr_dir = 0;
}
else {
lVar5 = strmake(&curr_dir,param_1,0x1ff);
if (*(char *)(lVar5 + -1) != '/') {
uVar3 = (int)lVar5 - 0x48d920;
(&curr_dir)[uVar3] = 0x2f;
(&DAT_0048d921)[uVar3] = 0;
}
}
}
else {
piVar4 = __errno_location();
iVar2 = *piVar4;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar2;
if ((param_2 & 0x10) != 0) {
piVar4 = __errno_location();
my_error(0x11,4,param_1,*piVar4);
}
}
return iVar1;
}
|
|
57,784
|
ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node> (bool)>)::Impl::Render()
|
Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/component/renderer.cpp
|
Element Render() override { return render_(Focused()) | reflect(box_); }
|
O2
|
cpp
|
ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node> (bool)>)::Impl::Render():
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsi), %r15
movq %rsi, %rdi
callq 0x21d92
movzbl %al, %edx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x26dde
addq $0x28, %r14
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2f9d4
movq %rsp, %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x20893
leaq 0x10(%rsp), %rdi
callq 0x13b10
leaq 0x8(%rsp), %rdi
callq 0x13452
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x13b10
jmp 0x26a31
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13452
movq %rbx, %rdi
callq 0xc7f0
nop
|
_ZZN5ftxui8RendererESt8functionIFSt10shared_ptrINS_4NodeEEbEEEN4Impl6RenderEv:
push r15
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
lea r15, [rsi+38h]
mov rdi, rsi; this
call _ZNK5ftxui13ComponentBase7FocusedEv; ftxui::ComponentBase::Focused(void)
movzx edx, al
mov rdi, rsp
mov rsi, r15
call _ZNKSt8functionIFSt10shared_ptrIN5ftxui4NodeEEbEEclEb; std::function<std::shared_ptr<ftxui::Node> ()(bool)>::operator()(bool)
add r14, 28h ; '('
lea rdi, [rsp+48h+var_38]
mov rsi, r14
call _ZN5ftxui7reflectERNS_3BoxE; ftxui::reflect(ftxui::Box &)
mov rsi, rsp
lea rdx, [rsp+48h+var_38]
mov rdi, rbx
call _ZN5ftxuiorESt10shared_ptrINS_4NodeEESt8functionIFS2_S2_EE; ftxui::operator|(std::shared_ptr<ftxui::Node>,std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)
lea rdi, [rsp+48h+var_38]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+48h+var_40]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 30h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
jmp short loc_26A31
mov rbx, rax
loc_26A31:
lea rdi, [rsp+arg_0]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, rbx
call __Unwind_Resume
|
long long ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node> ()(bool)>)::Impl::Render(
long long a1,
long long a2)
{
unsigned __int8 v2; // al
__int128 v4; // [rsp+0h] [rbp-48h] BYREF
_BYTE v5[56]; // [rsp+10h] [rbp-38h] BYREF
v2 = ftxui::ComponentBase::Focused((ftxui::ComponentBase *)a2);
std::function<std::shared_ptr<ftxui::Node> ()(bool)>::operator()(&v4, a2 + 56, v2);
ftxui::reflect((ftxui *)v5, (ftxui::Box *)(a2 + 40));
ftxui::operator|(a1, &v4, (long long)v5);
std::_Function_base::~_Function_base((std::_Function_base *)v5);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)&v4 + 1);
return a1;
}
|
Render:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSI + 0x38]
MOV RDI,RSI
CALL 0x00121d92
MOVZX EDX,AL
MOV RDI,RSP
MOV RSI,R15
CALL 0x00126dde
ADD R14,0x28
LAB_001269e1:
LEA RDI,[RSP + 0x10]
MOV RSI,R14
CALL 0x0012f9d4
LAB_001269ee:
MOV RSI,RSP
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00120893
LAB_001269fe:
LEA RDI,[RSP + 0x10]
CALL 0x00113b10
LEA RDI,[RSP + 0x8]
CALL 0x00113452
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
/* Render() */
void ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node>(bool)>)::Impl::Render(void)
{
ComponentBase *in_RSI;
function<std::shared_ptr<ftxui::Node>(bool)> afStack_48 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_40 [8];
ftxui local_38 [32];
ComponentBase::Focused(in_RSI);
std::function<std::shared_ptr<ftxui::Node>(bool)>::operator()
(afStack_48,(bool)((char)in_RSI + '8'));
/* try { // try from 001269e1 to 001269ed has its CatchHandler @ 00126a2e */
reflect(local_38,in_RSI + 0x28);
/* try { // try from 001269ee to 001269fd has its CatchHandler @ 00126a1f */
operator|();
std::_Function_base::~_Function_base((_Function_base *)local_38);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_40);
return;
}
|
|
57,785
|
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>> 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>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&)
|
monkey531[P]llama/common/json.hpp
|
iterator insert_iterator(const_iterator pos, Args&& ... args)
{
iterator result(this);
JSON_ASSERT(m_data.m_value.array != nullptr);
auto insert_pos = std::distance(m_data.m_value.array->begin(), pos.m_it.array_iterator);
m_data.m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
result.m_it.array_iterator = m_data.m_value.array->begin() + insert_pos;
// This could have been written as:
// result.m_it.array_iterator = m_data.m_value.array->insert(pos.m_it.array_iterator, cnt, val);
// but the return value of insert is missing in GCC 4.8, so it is written this way instead.
set_parents();
return result;
}
|
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>> 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>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
movq $0x0, 0x8(%rdi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x18(%rdi)
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xafce1
movq %rsi, %r14
movq 0x10(%rdx), %rsi
movq %rsi, %r15
subq (%rdi), %r15
movq %rcx, %rdx
callq 0xafd8a
movq 0x8(%r14), %rax
addq (%rax), %r15
movq %r15, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x40761(%rip), %rdi # 0xf0449
leaq 0x3a4cb(%rip), %rdx # 0xea1ba
leaq 0x40816(%rip), %rcx # 0xf050c
movl $0x582c, %esi # imm = 0x582C
xorl %eax, %eax
callq 0x1bf40
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE15insert_iteratorIJRKSD_EEENS0_6detail9iter_implISD_EENSI_ISF_EEDpOT_:
push r15
push r14
push rbx
mov rbx, rdi
mov [rdi], rsi
mov qword ptr [rdi+8], 0
mov rax, 8000000000000000h
mov [rdi+18h], rax
mov rdi, [rsi+8]
test rdi, rdi
jz short loc_AFCE1
mov r14, rsi
mov rsi, [rdx+10h]
mov r15, rsi
sub r15, [rdi]
mov rdx, rcx
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE6insertEN9__gnu_cxx17__normal_iteratorIPKSD_SF_EERSI_; 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>>::insert(__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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*,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>>>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, [r14+8]
add r15, [rax]
mov [rbx+10h], r15
mov rax, rbx
pop rbx
pop r14
pop r15
retn
loc_AFCE1:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMDataMTypeValu_0+23h; "m_data.m_value.array != nullptr"
mov esi, 582Ch
xor eax, eax
call _ggml_abort
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&>(
_QWORD *a1,
long long a2,
long long a3,
long long a4)
{
_QWORD *v5; // rdi
long long v6; // r15
*a1 = a2;
a1[1] = 0LL;
a1[3] = 0x8000000000000000LL;
v5 = *(_QWORD **)(a2 + 8);
if ( v5 )
{
v6 = *(_QWORD *)(a3 + 16) - *v5;
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>>::insert(
v5,
*(_QWORD *)(a3 + 16),
a4);
a1[2] = **(_QWORD **)(a2 + 8) + v6;
return (long long)a1;
}
else
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
22572LL,
"GGML_ASSERT(%s) failed",
"m_data.m_value.array != nullptr");
return nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
22572LL);
}
}
|
insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&>:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV qword ptr [RDI],RSI
MOV qword ptr [RDI + 0x8],0x0
MOV RAX,-0x8000000000000000
MOV qword ptr [RDI + 0x18],RAX
MOV RDI,qword ptr [RSI + 0x8]
TEST RDI,RDI
JZ 0x001afce1
MOV R14,RSI
MOV RSI,qword ptr [RDX + 0x10]
MOV R15,RSI
SUB R15,qword ptr [RDI]
MOV RDX,RCX
CALL 0x001afd8a
MOV RAX,qword ptr [R14 + 0x8]
ADD R15,qword ptr [RAX]
MOV qword ptr [RBX + 0x10],R15
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
LAB_001afce1:
LEA RDI,[0x1f0449]
LEA RDX,[0x1ea1ba]
LEA RCX,[0x1f050c]
MOV ESI,0x582c
XOR EAX,EAX
CALL 0x0011bf40
|
/* 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> > 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>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>
const&>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
long * 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>
::
insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&>
(long *param_1,long param_2,long param_3,int8 param_4)
{
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>>>
*pvVar1;
long lVar2;
long lVar3;
*param_1 = param_2;
param_1[1] = 0;
param_1[3] = -0x8000000000000000;
pvVar1 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(param_2 + 8);
if (pvVar1 != (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>>>
*)0x0) {
lVar2 = *(long *)(param_3 + 0x10);
lVar3 = *(long *)pvVar1;
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>>>
::insert(pvVar1,lVar2,param_4);
param_1[2] = (lVar2 - lVar3) + **(long **)(param_2 + 8);
return param_1;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x582c,
"GGML_ASSERT(%s) failed","m_data.m_value.array != nullptr");
}
|
|
57,786
|
append_player_join(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
untodesu[P]voxelius/game/client/chat.cc
|
static void append_player_join(const std::string &sender)
{
GuiChatMessage message;
message.spawn = globals::curtime;
message.text = fmt::format("{} {}", sender, language::resolve("chat.client_join"));
message.color = ImGui::GetStyleColorVec4(ImGuiCol_DragDropTarget);
history.push_back(message);
if(sfx_chat_message && session::is_ingame()) {
sound::play_ui(sfx_chat_message, false, 1.0f);
}
}
|
O0
|
cpp
|
append_player_join(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x20(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5f0f0
leaq 0x4b7dc1(%rip), %rax # 0x510aa0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x88(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x31a72b(%rip), %rax # 0x373423
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x317c0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq 0x3135c0(%rip), %rdi # 0x36c2e3
callq 0xd80b0
movq %rax, -0xb8(%rbp)
jmp 0x58d31
movq -0xc0(%rbp), %rcx
movq -0xb8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x78(%rbp), %rdi
leaq -0xa0(%rbp), %r8
callq 0x5f350
jmp 0x58d63
leaq -0x50(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movq %rsi, -0xd0(%rbp)
callq 0x2c9c0
movq -0xd0(%rbp), %rdi
callq 0x2d648
movl $0x33, %edi
callq 0x2251c0
movq %rax, -0xc8(%rbp)
jmp 0x58d96
movq -0xc8(%rbp), %rax
movups (%rax), %xmm0
movups %xmm0, -0x30(%rbp)
leaq 0x4b4c85(%rip), %rdi # 0x50da30
leaq -0x58(%rbp), %rsi
callq 0x59d10
jmp 0x58db6
leaq 0x4b4ce3(%rip), %rdi # 0x50daa0
callq 0x59d70
testb $0x1, %al
jne 0x58dcb
jmp 0x58e58
callq 0x11c270
movb %al, -0xd1(%rbp)
jmp 0x58dd8
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x58de4
jmp 0x58e58
leaq 0x4b4cb5(%rip), %rsi # 0x50daa0
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x59d90
movq -0xe0(%rbp), %rdi
xorl %esi, %esi
movss 0x311235(%rip), %xmm0 # 0x36a044
callq 0x133c50
jmp 0x58e16
leaq -0xb0(%rbp), %rdi
callq 0x597d0
jmp 0x58e58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x58e6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x597d0
jmp 0x58e6a
leaq -0x58(%rbp), %rdi
callq 0x59dc0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x59dc0
movq -0x90(%rbp), %rdi
callq 0x2cbe0
nop
|
_ZL18append_player_joinRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov [rbp+var_20], rdi
lea rdi, [rbp+var_58]; this
call _ZN14GuiChatMessageC2Ev; GuiChatMessage::GuiChatMessage(void)
lea rax, _ZN7globals7curtimeE; globals::curtime
mov rax, [rax]
mov [rbp+var_58], rax
lea rax, [rbp+var_88]
mov [rbp+var_10], rax
lea rax, aDefine+8; "{} {}"
mov [rbp+var_18], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]; char *
call _ZN3fmt3v1117basic_string_viewIcEC2EPKc; fmt::v11::basic_string_view<char>::basic_string_view(char const*)
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
mov rax, [rbp+var_20]
mov [rbp+var_C0], rax
lea rdi, aChatClientJoin; "chat.client_join"
call _ZN8language7resolveEPKc; language::resolve(char const*)
mov [rbp+var_B8], rax
jmp short $+2
loc_58D31:
mov rcx, [rbp+var_C0]
mov rax, [rbp+var_B8]
mov [rbp+var_A0], rax
mov rsi, [rbp+var_88]
mov rdx, [rbp+var_80]
lea rdi, [rbp+var_78]
lea r8, [rbp+var_A0]
call _ZN3fmt3v116formatIJRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKcEEES7_NS0_19basic_format_stringIcJDpNS0_13type_identityIT_E4typeEEEEDpOSE_; fmt::v11::format<std::string const&,char const*>(fmt::v11::basic_format_string<char,fmt::v11::type_identity<std::string const&,char const*>::type>,std::string const&,char const*&&)
jmp short $+2
loc_58D63:
lea rdi, [rbp+var_50]
lea rsi, [rbp+var_78]; int
mov [rbp+var_D0], rsi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [rbp+var_D0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov edi, (offset dword_30+3); this
call _ZN5ImGui17GetStyleColorVec4Ei; ImGui::GetStyleColorVec4(int)
mov [rbp+var_C8], rax
jmp short $+2
loc_58D96:
mov rax, [rbp+var_C8]
movups xmm0, xmmword ptr [rax]
movups [rbp+var_30], xmm0
lea rdi, _ZL7history; history
lea rsi, [rbp+var_58]
call _ZNSt5dequeI14GuiChatMessageSaIS0_EE9push_backERKS0_; std::deque<GuiChatMessage>::push_back(GuiChatMessage const&)
jmp short $+2
loc_58DB6:
lea rdi, _ZL16sfx_chat_message; this
call _ZNKSt12__shared_ptrIK11SoundEffectLN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<SoundEffect const,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_58DCB
jmp loc_58E58
loc_58DCB:
call _ZN7session9is_ingameEv; session::is_ingame(void)
mov [rbp+var_D1], al
jmp short $+2
loc_58DD8:
mov al, [rbp+var_D1]
test al, 1
jnz short loc_58DE4
jmp short loc_58E58
loc_58DE4:
lea rsi, _ZL16sfx_chat_message; sfx_chat_message
lea rdi, [rbp+var_B0]
mov [rbp+var_E0], rdi
call _ZNSt10shared_ptrIK11SoundEffectEC2ERKS2_; std::shared_ptr<SoundEffect const>::shared_ptr(std::shared_ptr<SoundEffect const> const&)
mov rdi, [rbp+var_E0]
xor esi, esi
movss xmm0, cs:flt_36A044
call _ZN5sound7play_uiESt10shared_ptrIK11SoundEffectEbf; sound::play_ui(std::shared_ptr<SoundEffect const>,bool,float)
jmp short $+2
loc_58E16:
lea rdi, [rbp+var_B0]; void *
call _ZNSt10shared_ptrIK11SoundEffectED2Ev; std::shared_ptr<SoundEffect const>::~shared_ptr()
jmp short loc_58E58
mov rcx, rax
mov eax, edx
mov [rbp+var_90], rcx
mov [rbp+var_94], eax
jmp short loc_58E6A
mov rcx, rax
mov eax, edx
mov [rbp+var_90], rcx
mov [rbp+var_94], eax
lea rdi, [rbp+var_B0]; void *
call _ZNSt10shared_ptrIK11SoundEffectED2Ev; std::shared_ptr<SoundEffect const>::~shared_ptr()
jmp short loc_58E6A
loc_58E58:
lea rdi, [rbp+var_58]; this
call _ZN14GuiChatMessageD2Ev; GuiChatMessage::~GuiChatMessage()
add rsp, 0E0h
pop rbp
retn
loc_58E6A:
lea rdi, [rbp+var_58]; this
call _ZN14GuiChatMessageD2Ev; GuiChatMessage::~GuiChatMessage()
mov rdi, [rbp+var_90]
call __Unwind_Resume
|
void append_player_join(long long a1)
{
long long v1; // [rsp+20h] [rbp-C0h]
_BYTE v2[16]; // [rsp+30h] [rbp-B0h] BYREF
long long v3; // [rsp+40h] [rbp-A0h] BYREF
_QWORD v4[2]; // [rsp+58h] [rbp-88h] BYREF
int v5[8]; // [rsp+68h] [rbp-78h] BYREF
long long v6; // [rsp+88h] [rbp-58h] BYREF
_BYTE v7[32]; // [rsp+90h] [rbp-50h] BYREF
__int128 v8; // [rsp+B0h] [rbp-30h]
long long v9; // [rsp+C0h] [rbp-20h]
char *v10; // [rsp+C8h] [rbp-18h]
_QWORD *v11; // [rsp+D0h] [rbp-10h]
char *v12; // [rsp+D8h] [rbp-8h]
v9 = a1;
GuiChatMessage::GuiChatMessage((GuiChatMessage *)&v6);
v6 = globals::curtime;
v11 = v4;
v10 = "{} {}";
fmt::v11::basic_string_view<char>::basic_string_view(v4, (long long)"{} {}");
v12 = v10;
v1 = v9;
v3 = language::resolve((language *)"chat.client_join", "{} {}");
fmt::v11::format<std::string const&,char const*>(v5, v4[0], v4[1], v1, &v3);
std::string::operator=(v7);
std::string::~string(v5);
v8 = *(_OWORD *)ImGui::GetStyleColorVec4((ImGui *)((char *)&dword_30 + 3), (int)v5);
std::deque<GuiChatMessage>::push_back(&history, &v6);
if ( (std::__shared_ptr<SoundEffect const,(__gnu_cxx::_Lock_policy)2>::operator bool(&sfx_chat_message) & 1) != 0
&& (session::is_ingame((session *)&sfx_chat_message) & 1) != 0 )
{
std::shared_ptr<SoundEffect const>::shared_ptr(v2, &sfx_chat_message);
sound::play_ui(v2, 0LL, 1.0);
std::shared_ptr<SoundEffect const>::~shared_ptr(v2);
}
GuiChatMessage::~GuiChatMessage((GuiChatMessage *)&v6);
}
|
append_player_join:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV qword ptr [RBP + -0x20],RDI
LEA RDI,[RBP + -0x58]
CALL 0x0015f0f0
LEA RAX,[0x610aa0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
LEA RAX,[RBP + -0x88]
MOV qword ptr [RBP + -0x10],RAX
LEA RAX,[0x473423]
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001317c0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0xc0],RAX
LAB_00158d1c:
LEA RDI,[0x46c2e3]
CALL 0x001d80b0
MOV qword ptr [RBP + -0xb8],RAX
JMP 0x00158d31
LAB_00158d31:
MOV RCX,qword ptr [RBP + -0xc0]
MOV RAX,qword ptr [RBP + -0xb8]
MOV qword ptr [RBP + -0xa0],RAX
MOV RSI,qword ptr [RBP + -0x88]
MOV RDX,qword ptr [RBP + -0x80]
LEA RDI,[RBP + -0x78]
LEA R8,[RBP + -0xa0]
CALL 0x0015f350
JMP 0x00158d63
LAB_00158d63:
LEA RDI,[RBP + -0x50]
LEA RSI,[RBP + -0x78]
MOV qword ptr [RBP + -0xd0],RSI
CALL 0x0012c9c0
MOV RDI,qword ptr [RBP + -0xd0]
CALL 0x0012d648
MOV EDI,0x33
CALL 0x003251c0
MOV qword ptr [RBP + -0xc8],RAX
JMP 0x00158d96
LAB_00158d96:
MOV RAX,qword ptr [RBP + -0xc8]
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RBP + -0x30],XMM0
LEA RDI,[0x60da30]
LEA RSI,[RBP + -0x58]
CALL 0x00159d10
JMP 0x00158db6
LAB_00158db6:
LEA RDI,[0x60daa0]
CALL 0x00159d70
TEST AL,0x1
JNZ 0x00158dcb
JMP 0x00158e58
LAB_00158dcb:
CALL 0x0021c270
MOV byte ptr [RBP + -0xd1],AL
JMP 0x00158dd8
LAB_00158dd8:
MOV AL,byte ptr [RBP + -0xd1]
TEST AL,0x1
JNZ 0x00158de4
JMP 0x00158e58
LAB_00158de4:
LEA RSI,[0x60daa0]
LEA RDI,[RBP + -0xb0]
MOV qword ptr [RBP + -0xe0],RDI
CALL 0x00159d90
MOV RDI,qword ptr [RBP + -0xe0]
LAB_00158e05:
XOR ESI,ESI
MOVSS XMM0,dword ptr [0x0046a044]
CALL 0x00233c50
LAB_00158e14:
JMP 0x00158e16
LAB_00158e16:
LEA RDI,[RBP + -0xb0]
CALL 0x001597d0
JMP 0x00158e58
LAB_00158e58:
LEA RDI,[RBP + -0x58]
CALL 0x00159dc0
ADD RSP,0xe0
POP RBP
RET
|
/* append_player_join(std::__cxx11::string const&) */
void append_player_join(string *param_1)
{
string *psVar1;
bool bVar2;
byte bVar3;
int8 *puVar4;
shared_ptr<SoundEffect_const> local_b8 [16];
int8 local_a8 [3];
int8 local_90;
int8 local_88;
string local_80 [32];
int8 local_60;
string local_58 [32];
int8 local_38;
int8 uStack_30;
string *local_28;
char *local_20;
basic_string_view<char> *local_18;
char *local_10;
local_28 = param_1;
GuiChatMessage::GuiChatMessage((GuiChatMessage *)&local_60);
local_60 = globals::curtime;
local_18 = (basic_string_view<char> *)&local_90;
local_20 = "{} {}";
fmt::v11::basic_string_view<char>::basic_string_view(local_18,"{} {}");
psVar1 = local_28;
local_10 = local_20;
/* try { // try from 00158d1c to 00158dcf has its CatchHandler @ 00158e24 */
local_a8[0] = language::resolve("chat.client_join");
fmt::v11::format<std::__cxx11::string_const&,char_const*>
(local_80,local_90,local_88,psVar1,local_a8);
std::__cxx11::string::operator=(local_58,local_80);
std::__cxx11::string::~string(local_80);
puVar4 = (int8 *)ImGui::GetStyleColorVec4(0x33);
local_38 = *puVar4;
uStack_30 = puVar4[1];
std::deque<GuiChatMessage,std::allocator<GuiChatMessage>>::push_back
((deque<GuiChatMessage,std::allocator<GuiChatMessage>> *)history,
(GuiChatMessage *)&local_60);
bVar2 = std::__shared_ptr::operator_cast_to_bool((__shared_ptr *)sfx_chat_message);
if ((bVar2) && (bVar3 = session::is_ingame(), (bVar3 & 1) != 0)) {
std::shared_ptr<SoundEffect_const>::shared_ptr(local_b8,(shared_ptr *)sfx_chat_message);
/* try { // try from 00158e05 to 00158e13 has its CatchHandler @ 00158e38 */
sound::play_ui(DAT_0046a044,local_b8,0);
std::shared_ptr<SoundEffect_const>::~shared_ptr(local_b8);
}
GuiChatMessage::~GuiChatMessage((GuiChatMessage *)&local_60);
return;
}
|
|
57,787
|
my_strnxfrm_unicode_full_bin_internal
|
eloqsql/strings/ctype-utf8.c
|
size_t
my_strnxfrm_unicode_full_bin_internal(CHARSET_INFO *cs,
uchar *dst, uchar *de, uint *nweights,
const uchar *src, const uchar *se)
{
my_wc_t UNINIT_VAR(wc);
uchar *dst0= dst;
DBUG_ASSERT(src || !se);
DBUG_ASSERT(cs->state & MY_CS_BINSORT);
for (; dst < de && *nweights; (*nweights)--)
{
int res;
if ((res= my_ci_mb_wc(cs, &wc, src, se)) <= 0)
break;
src+= res;
*dst++= (uchar) (wc >> 16);
if (dst < de)
{
*dst++= (uchar) ((wc >> 8) & 0xFF);
if (dst < de)
*dst++= (uchar) (wc & 0xFF);
}
}
return dst - dst0;
}
|
O3
|
c
|
my_strnxfrm_unicode_full_bin_internal:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x40(%rbp)
movq %rsi, %rax
movq %rsi, -0x38(%rbp)
cmpq %rdx, %rsi
jae 0x4fcb5
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbx
movl (%rcx), %ecx
movq -0x38(%rbp), %r14
testl %ecx, %ecx
je 0x4fcb2
movq 0xb8(%rbx), %rax
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
movq %r15, %rdx
movq -0x40(%rbp), %rcx
callq *0x28(%rax)
testl %eax, %eax
jle 0x4fcb2
movl %eax, %ecx
movb -0x2e(%rbp), %dl
leaq 0x1(%r14), %rax
movb %dl, (%r14)
cmpq %r13, %rax
jae 0x4fc99
movb -0x2f(%rbp), %dl
leaq 0x2(%r14), %rax
movb %dl, 0x1(%r14)
cmpq %r13, %rax
jae 0x4fc99
movb -0x30(%rbp), %al
movb %al, 0x2(%r14)
addq $0x3, %r14
movq %r14, %rax
movl %ecx, %ecx
addq %rcx, %r15
movl (%r12), %ecx
decl %ecx
movl %ecx, (%r12)
movq %rax, %r14
cmpq %r13, %rax
jb 0x4fc4a
jmp 0x4fcb5
movq %r14, %rax
subq -0x38(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strnxfrm_unicode_full_bin_internal:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_40], r9
mov rax, rsi
mov [rbp+var_38], rsi
cmp rsi, rdx
jnb short loc_4FCB5
mov r15, r8
mov r12, rcx
mov r13, rdx
mov rbx, rdi
mov ecx, [rcx]
mov r14, [rbp+var_38]
loc_4FC4A:
test ecx, ecx
jz short loc_4FCB2
mov rax, [rbx+0B8h]
mov rdi, rbx
lea rsi, [rbp+var_30]
mov rdx, r15
mov rcx, [rbp+var_40]
call qword ptr [rax+28h]
test eax, eax
jle short loc_4FCB2
mov ecx, eax
mov dl, [rbp+var_2E]
lea rax, [r14+1]
mov [r14], dl
cmp rax, r13
jnb short loc_4FC99
mov dl, [rbp+var_2F]
lea rax, [r14+2]
mov [r14+1], dl
cmp rax, r13
jnb short loc_4FC99
mov al, [rbp+var_30]
mov [r14+2], al
add r14, 3
mov rax, r14
loc_4FC99:
mov ecx, ecx
add r15, rcx
mov ecx, [r12]
dec ecx
mov [r12], ecx
mov r14, rax
cmp rax, r13
jb short loc_4FC4A
jmp short loc_4FCB5
loc_4FCB2:
mov rax, r14
loc_4FCB5:
sub rax, [rbp+var_38]
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_strnxfrm_unicode_full_bin_internal(
long long a1,
_BYTE *a2,
unsigned long long a3,
int *a4,
long long a5,
long long a6)
{
_BYTE *v6; // rax
int v10; // ecx
_BYTE *v11; // r14
int v12; // eax
unsigned int v13; // ecx
_BYTE v16[48]; // [rsp+10h] [rbp-30h] BYREF
v6 = a2;
if ( (unsigned long long)a2 < a3 )
{
v10 = *a4;
v11 = a2;
while ( v10 )
{
v12 = (*(long long ( **)(long long, _BYTE *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL))(
a1,
v16,
a5,
a6);
if ( v12 <= 0 )
break;
v13 = v12;
v6 = v11 + 1;
*v11 = v16[2];
if ( (unsigned long long)(v11 + 1) < a3 )
{
v6 = v11 + 2;
v11[1] = v16[1];
if ( (unsigned long long)(v11 + 2) < a3 )
{
v11[2] = v16[0];
v6 = v11 + 3;
}
}
a5 += v13;
v10 = *a4 - 1;
*a4 = v10;
v11 = v6;
if ( (unsigned long long)v6 >= a3 )
return v6 - a2;
}
v6 = v11;
}
return v6 - a2;
}
|
my_strnxfrm_unicode_full_bin_internal:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x40],R9
MOV RAX,RSI
MOV qword ptr [RBP + -0x38],RSI
CMP RSI,RDX
JNC 0x0014fcb5
MOV R15,R8
MOV R12,RCX
MOV R13,RDX
MOV RBX,RDI
MOV ECX,dword ptr [RCX]
MOV R14,qword ptr [RBP + -0x38]
LAB_0014fc4a:
TEST ECX,ECX
JZ 0x0014fcb2
MOV RAX,qword ptr [RBX + 0xb8]
MOV RDI,RBX
LEA RSI,[RBP + -0x30]
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x40]
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
JLE 0x0014fcb2
MOV ECX,EAX
MOV DL,byte ptr [RBP + -0x2e]
LEA RAX,[R14 + 0x1]
MOV byte ptr [R14],DL
CMP RAX,R13
JNC 0x0014fc99
MOV DL,byte ptr [RBP + -0x2f]
LEA RAX,[R14 + 0x2]
MOV byte ptr [R14 + 0x1],DL
CMP RAX,R13
JNC 0x0014fc99
MOV AL,byte ptr [RBP + -0x30]
MOV byte ptr [R14 + 0x2],AL
ADD R14,0x3
MOV RAX,R14
LAB_0014fc99:
MOV ECX,ECX
ADD R15,RCX
MOV ECX,dword ptr [R12]
DEC ECX
MOV dword ptr [R12],ECX
MOV R14,RAX
CMP RAX,R13
JC 0x0014fc4a
JMP 0x0014fcb5
LAB_0014fcb2:
MOV RAX,R14
LAB_0014fcb5:
SUB RAX,qword ptr [RBP + -0x38]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_strnxfrm_unicode_full_bin_internal
(long param_1,int1 *param_2,int1 *param_3,int *param_4,long param_5,
int8 param_6)
{
uint uVar1;
int iVar2;
int1 *puVar3;
int1 *puVar4;
int1 local_38;
int1 local_37;
int1 local_36;
puVar4 = param_2;
if (param_2 < param_3) {
iVar2 = *param_4;
puVar3 = param_2;
do {
puVar4 = puVar3;
if ((iVar2 == 0) ||
(uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x28))(param_1,&local_38,param_5,param_6)
, (int)uVar1 < 1)) break;
puVar4 = puVar3 + 1;
*puVar3 = local_36;
if (puVar4 < param_3) {
puVar4 = puVar3 + 2;
puVar3[1] = local_37;
if (puVar4 < param_3) {
puVar3[2] = local_38;
puVar4 = puVar3 + 3;
}
}
param_5 = param_5 + (ulong)uVar1;
iVar2 = *param_4 + -1;
*param_4 = iVar2;
puVar3 = puVar4;
} while (puVar4 < param_3);
}
return (long)puVar4 - (long)param_2;
}
|
|
57,788
|
check_longlong
|
eloqsql/strings/my_vsnprintf.c
|
static const char *check_longlong(const char *fmt, uint *have_longlong)
{
*have_longlong= 0;
if (*fmt == 'l')
{
fmt++;
if (*fmt != 'l')
*have_longlong= (sizeof(long) == sizeof(longlong));
else
{
fmt++;
*have_longlong= 1;
}
}
else if (*fmt == 'z')
{
fmt++;
*have_longlong= (sizeof(size_t) == sizeof(longlong));
}
else if (*fmt == 'p')
*have_longlong= (sizeof(void *) == sizeof(longlong));
return fmt;
}
|
O0
|
c
|
check_longlong:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
jne 0x7c18e
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
je 0x7c176
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x7c18c
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x7c1cc
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7a, %eax
jne 0x7c1b2
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x7c1ca
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x70, %eax
jne 0x7c1c8
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x7c1ca
jmp 0x7c1cc
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
check_longlong:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov dword ptr [rax], 0
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 6Ch ; 'l'
jnz short loc_7C18E
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 6Ch ; 'l'
jz short loc_7C176
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
jmp short loc_7C18C
loc_7C176:
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
loc_7C18C:
jmp short loc_7C1CC
loc_7C18E:
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 7Ah ; 'z'
jnz short loc_7C1B2
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
jmp short loc_7C1CA
loc_7C1B2:
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 70h ; 'p'
jnz short loc_7C1C8
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
loc_7C1C8:
jmp short $+2
loc_7C1CA:
jmp short $+2
loc_7C1CC:
mov rax, [rbp+var_8]
pop rbp
retn
|
_BYTE * check_longlong(_BYTE *a1, _DWORD *a2)
{
_BYTE *v3; // [rsp+8h] [rbp-8h]
v3 = a1;
*a2 = 0;
switch ( *a1 )
{
case 'l':
v3 = a1 + 1;
if ( a1[1] == 108 )
v3 = a1 + 2;
*a2 = 1;
break;
case 'z':
v3 = a1 + 1;
*a2 = 1;
break;
case 'p':
*a2 = 1;
break;
}
return v3;
}
|
check_longlong:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x6c
JNZ 0x0017c18e
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x6c
JZ 0x0017c176
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
JMP 0x0017c18c
LAB_0017c176:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
LAB_0017c18c:
JMP 0x0017c1cc
LAB_0017c18e:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x7a
JNZ 0x0017c1b2
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
JMP 0x0017c1ca
LAB_0017c1b2:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x70
JNZ 0x0017c1c8
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
LAB_0017c1c8:
JMP 0x0017c1ca
LAB_0017c1ca:
JMP 0x0017c1cc
LAB_0017c1cc:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
char * check_longlong(char *param_1,int4 *param_2)
{
char *local_10;
*param_2 = 0;
if (*param_1 == 'l') {
local_10 = param_1 + 1;
if (*local_10 == 'l') {
local_10 = param_1 + 2;
*param_2 = 1;
}
else {
*param_2 = 1;
}
}
else if (*param_1 == 'z') {
local_10 = param_1 + 1;
*param_2 = 1;
}
else {
local_10 = param_1;
if (*param_1 == 'p') {
*param_2 = 1;
}
}
return local_10;
}
|
|
57,789
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [9], 0>(char const (&) [9])
|
monkey531[P]llama/common/json.hpp
|
reference at(KeyType && key)
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return set_parent(it->second);
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [9], 0>(char const (&) [9]):
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xdf7e0
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x145708
jmp 0x1457e4
movb $0x1, 0x83(%rsp)
movl $0x20, %edi
callq 0x565c0
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0xdd300
movq %rax, 0x90(%rsp)
leaq 0xa4642(%rip), %rsi # 0x1e9d7a
leaq 0x98(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x14c960
jmp 0x14574f
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rdi
movl $0x130, %esi # imm = 0x130
leaq 0x98(%rsp), %rdx
callq 0xf62f0
jmp 0x14576d
movq 0x18(%rsp), %rdi
movb $0x0, 0x83(%rsp)
leaq 0x127987(%rip), %rsi # 0x26d108
leaq -0x683d8(%rip), %rdx # 0xdd3b0
callq 0x569b0
jmp 0x145975
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x1457c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x572d0
testb $0x1, 0x83(%rsp)
jne 0x1457d5
jmp 0x1457df
movq 0x18(%rsp), %rdi
callq 0x56dd0
jmp 0x145968
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0xb8(%rsp), %rsi
callq 0x14fe60
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x78(%rsp)
movq 0x8(%rax), %rdi
callq 0xdf620
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xf5f40
testb $0x1, %al
jne 0x14582d
jmp 0x14593e
movb $0x1, 0x2e(%rsp)
movl $0x20, %edi
callq 0x565c0
movq %rax, (%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x56f00
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x66600
jmp 0x145872
leaq 0xa4531(%rip), %rsi # 0x1e9daa
leaq 0xa4530(%rip), %rcx # 0x1e9db0
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x14db80
jmp 0x145891
movq 0x20(%rsp), %rcx
movq (%rsp), %rdi
movl $0x193, %esi # imm = 0x193
leaq 0x50(%rsp), %rdx
callq 0xf4140
jmp 0x1458ab
movq (%rsp), %rdi
movb $0x0, 0x2e(%rsp)
leaq 0x127935(%rip), %rsi # 0x26d1f0
leaq -0x520f2(%rip), %rdx # 0xf37d0
callq 0x569b0
jmp 0x145975
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x145920
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x145916
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x572d0
leaq 0x30(%rsp), %rdi
callq 0x572d0
leaq 0x2f(%rsp), %rdi
callq 0x572b0
testb $0x1, 0x2e(%rsp)
jne 0x145933
jmp 0x14593c
movq (%rsp), %rdi
callq 0x56dd0
jmp 0x145968
leaq 0x78(%rsp), %rdi
callq 0xf6140
movq 0x20(%rsp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
movq $-0x1, %rdx
callq 0x14c840
addq $0xc8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x56a10
nopw %cs:(%rax,%rax)
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA13_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
sub rsp, 0C8h
mov [rsp+0C8h+var_8], rdi
mov qword ptr [rsp+0C8h+var_10], rsi
mov rdi, [rsp+0C8h+var_8]
mov [rsp+0C8h+var_A8], rdi; int
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_objectEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_object(void)
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_145708
jmp loc_1457E4
loc_145708:
mov [rsp+0C8h+var_45], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, [rsp+0C8h+var_A8]
mov [rsp+0C8h+var_B0], rax; char
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
mov qword ptr [rsp+0C8h+var_38], rax; char
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+0C8h+var_30]; int
lea rdx, [rsp+0C8h+var_38]; int
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
jmp short $+2
loc_14574F:
mov rcx, [rsp+0C8h+var_A8]
mov rdi, [rsp+0C8h+var_B0]; int
mov esi, 130h
lea rdx, [rsp+0C8h+var_30]
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
jmp short $+2
loc_14576D:
mov rdi, [rsp+0C8h+var_B0]; void *
mov [rsp+0C8h+var_45], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail10type_errorD2Ev; void (*)(void *)
call ___cxa_throw
jmp loc_145975
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
jmp short loc_1457C9
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
lea rdi, [rsp+arg_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1457C9:
test [rsp+arg_7B], 1
jnz short loc_1457D5
jmp short loc_1457DF
loc_1457D5:
mov rdi, [rsp+arg_10]; void *
call ___cxa_free_exception
loc_1457DF:
jmp loc_145968
loc_1457E4:
mov rax, [rsp+0C8h+var_A8]
mov rdi, [rax+8]
mov rsi, qword ptr [rsp+0C8h+var_10]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA13_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
mov rcx, rax
mov rax, [rsp+0C8h+var_A8]
mov qword ptr [rsp+0C8h+var_50], rcx; int
mov rdi, [rax+8]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::end(void)
mov qword ptr [rsp+0C8h+var_58], rax; char
lea rdi, [rsp+0C8h+var_50]
lea rsi, [rsp+0C8h+var_58]
call _ZN9__gnu_cxxeqIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator==<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&,__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&)
test al, 1
jnz short loc_14582D
jmp loc_14593E
loc_14582D:
mov [rsp+0C8h+var_9A], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov [rsp+0C8h+var_C8], rax; int
mov rax, qword ptr [rsp+0C8h+var_10]
mov qword ptr [rsp+0C8h+var_C0], rax; int
lea rdi, [rsp+0C8h+var_99]
mov qword ptr [rsp+0C8h+var_B8], rdi; int
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, qword ptr [rsp+0C8h+var_C0]
mov rdx, qword ptr [rsp+0C8h+var_B8]
lea rdi, [rsp+0C8h+var_99+1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_145872:
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+0C8h+var_78]; int
lea rdx, [rsp+0C8h+var_99+1]; int
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
jmp short $+2
loc_145891:
mov rcx, [rsp+0C8h+var_A8]
mov rdi, [rsp+0C8h+var_C8]; int
mov esi, 193h
lea rdx, [rsp+0C8h+var_78]
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
jmp short $+2
loc_1458AB:
mov rdi, [rsp+0C8h+var_C8]; void *
mov [rsp+0C8h+var_9A], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail12out_of_rangeD2Ev; void (*)(void *)
call ___cxa_throw
jmp loc_145975
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
jmp short loc_145920
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
jmp short loc_145916
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_145916:
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_145920:
lea rdi, [rsp+arg_27]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
test [rsp+arg_26], 1
jnz short loc_145933
jmp short loc_14593C
loc_145933:
mov rdi, [rsp+0]; void *
call ___cxa_free_exception
loc_14593C:
jmp short loc_145968
loc_14593E:
lea rdi, [rsp+0C8h+var_50]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator->(void)
mov rdi, [rsp+0C8h+var_A8]
mov rsi, rax
add rsi, 20h ; ' '
mov rdx, 0FFFFFFFFFFFFFFFFh
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10set_parentERSD_m; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::set_parent(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&,ulong)
add rsp, 0C8h
retn
loc_145968:
mov rdi, [rsp+arg_80]
call __Unwind_Resume
loc_145975:
nop word ptr [rax+rax+00000000h]
nop
|
long long ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA13_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_(
long long a1,
long long a2)
{
int v2; // ecx
int v3; // r8d
int v4; // r9d
int v5; // r8d
int v6; // r9d
long long v7; // rax
int v9; // [rsp+0h] [rbp-C8h]
void *v10; // [rsp+0h] [rbp-C8h]
nlohmann::json_abi_v3_11_3::detail::out_of_range *v11; // [rsp+0h] [rbp-C8h]
void *v12; // [rsp+8h] [rbp-C0h]
long long v13; // [rsp+8h] [rbp-C0h]
int v14; // [rsp+10h] [rbp-B8h]
int v15; // [rsp+18h] [rbp-B0h]
void *exception; // [rsp+18h] [rbp-B0h]
nlohmann::json_abi_v3_11_3::detail::type_error *v17; // [rsp+18h] [rbp-B0h]
long long v18; // [rsp+20h] [rbp-A8h]
char v19; // [rsp+2Fh] [rbp-99h] BYREF
_BYTE v20[32]; // [rsp+30h] [rbp-98h] BYREF
int v21[8]; // [rsp+50h] [rbp-78h] BYREF
char v22[8]; // [rsp+70h] [rbp-58h] BYREF
int v23[2]; // [rsp+78h] [rbp-50h] BYREF
char v24; // [rsp+83h] [rbp-45h]
char v25[8]; // [rsp+90h] [rbp-38h] BYREF
int v26[8]; // [rsp+98h] [rbp-30h] BYREF
int v27[2]; // [rsp+B8h] [rbp-10h]
long long v28; // [rsp+C0h] [rbp-8h]
v28 = a1;
*(_QWORD *)v27 = a2;
if ( !nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_object((_BYTE *)a1) )
{
exception = __cxa_allocate_exception(0x20uLL);
*(_QWORD *)v25 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((_BYTE *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(
(int)v26,
(int)"cannot use at() with ",
(int)v25,
v2,
v3,
v4,
v9,
v12,
v14,
(long long)exception);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v17,
304,
(long long)v26,
a1);
v24 = 0;
__cxa_throw(
v17,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::type_error::~type_error);
}
*(_QWORD *)v23 = ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA13_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(
*(_QWORD *)(a1 + 8),
*(_QWORD *)v27);
*(_QWORD *)v22 = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::end(*(_QWORD *)(a1 + 8));
if ( __gnu_cxx::operator==<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>(
(long long)v23,
(long long)v22) )
{
v10 = __cxa_allocate_exception(0x20uLL);
v13 = *(_QWORD *)v27;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v20, v13, (long long)&v19);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
(int)v21,
(int)"key '",
(int)v20,
(int)"' not found",
v5,
v6,
v10,
v13,
(int)&v19,
v15,
a1);
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v11,
403,
(long long)v21,
v18);
__cxa_throw(
v11,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::out_of_range::~out_of_range);
}
v7 = __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator->((long long)v23);
return 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>::set_parent(
a1,
v7 + 32,
-1LL);
}
| |||
57,790
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [9], 0>(char const (&) [9])
|
monkey531[P]llama/common/json.hpp
|
reference at(KeyType && key)
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return set_parent(it->second);
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [9], 0>(char const (&) [9]):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0x7bba8
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0x7bb8d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a1b0
testl %eax, %eax
je 0x7bb8a
addq $0x30, %rbx
jmp 0x7bb6b
movq %rbx, %rax
movq 0x8(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0x7bc04
addq $0x20, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1a3b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x52ede
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x456a6(%rip), %rsi # 0xc1272
movq %rsp, %rdi
callq 0x81127
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x5ea10
xorl %ebp, %ebp
leaq 0x776d5(%rip), %rsi # 0xf32c8
leaq -0x1ab68(%rip), %rdx # 0x61092
movq %rbx, %rdi
callq 0x1ad60
jmp 0x7bc7d
movl $0x20, %edi
callq 0x1a3b0
movq %rax, %rbx
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x1a350
leaq (%rax,%r15), %rdx
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x26294
leaq 0x45667(%rip), %rsi # 0xc12a2
leaq 0x45666(%rip), %rcx # 0xc12a8
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x81730
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0x5dce8
xorl %ebp, %ebp
leaq 0x77742(%rip), %rsi # 0xf33b0
leaq -0x1abe3(%rip), %rdx # 0x61092
movq %rbx, %rdi
callq 0x1ad60
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7bca3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a7f0
jmp 0x7bca3
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7bcdc
movq 0x30(%rsp), %rsi
jmp 0x7bccc
jmp 0x7bcd6
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7bcdc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a7f0
jmp 0x7bcdc
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x7bce9
movq %rbx, %rdi
callq 0x1a5a0
movq %r14, %rdi
callq 0x1adc0
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA13_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
push rbp; char
push r15; int
push r14; int
push r12; int
push rbx; char
sub rsp, 40h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_7BBA8
mov r15, rsi
mov r12, [r14+8]
mov rbx, [r12]
loc_7BB6B:
mov rax, [r12+8]
cmp rbx, rax
jz short loc_7BB8D
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_7BB8A
add rbx, 30h ; '0'
jmp short loc_7BB6B
loc_7BB8A:
mov rax, rbx
loc_7BB8D:
mov rcx, [r14+8]
cmp rax, [rcx+8]
jz short loc_7BC04
add rax, 20h ; ' '
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_7BBA8:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+68h+var_48]
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 130h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_7BC7D
loc_7BC04:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r12, [rsp+68h+var_38]
mov [r12-10h], r12
mov rdi, r15
call _strlen
lea rdx, [rax+r15]
lea rdi, [rsp+68h+var_48]
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
mov rdi, rsp
lea rdx, [rsp+68h+var_48]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 193h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_7BC7D:
mov r14, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7BCA3
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7BCA3
mov r14, rax
mov bpl, 1
loc_7BCA3:
mov rdi, [rsp+68h+var_48]
cmp rdi, r12
jz short loc_7BCDC
mov rsi, [rsp+68h+var_38]
jmp short loc_7BCCC
jmp short loc_7BCD6
mov r14, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7BCDC
mov rsi, [rsp+68h+var_58]
loc_7BCCC:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7BCDC
loc_7BCD6:
mov r14, rax
mov bpl, 1
loc_7BCDC:
test bpl, bpl
jz short loc_7BCE9
mov rdi, rbx; void *
call ___cxa_free_exception
loc_7BCE9:
mov rdi, r14
call __Unwind_Resume
|
long long ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA13_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_(
long long a1,
_BYTE *a2)
{
long long *v2; // r12
long long i; // rbx
long long v4; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v7; // rbx
long long v8; // rax
_QWORD v9[2]; // [rsp+0h] [rbp-68h] BYREF
_QWORD v10[2]; // [rsp+20h] [rbp-48h] BYREF
long long v11; // [rsp+30h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v10[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>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(v9, "cannot use at() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
304,
v9);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v2 = *(long long **)(a1 + 8);
for ( i = *v2; ; i += 48LL )
{
v4 = v2[1];
if ( i == v4 )
break;
if ( !(unsigned int)std::string::compare(i, a2) )
{
v4 = i;
break;
}
}
if ( v4 == *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) )
{
v7 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v10[0] = &v11;
v8 = strlen(a2);
std::string::_M_construct<char const*>(v10, a2, (long long)&a2[v8]);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
v9,
"key '",
v10,
"' not found");
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v7,
403,
v9);
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return v4 + 32;
}
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA13_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x0017bba8
MOV R15,RSI
MOV R12,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [R12]
LAB_0017bb6b:
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JZ 0x0017bb8d
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011a1b0
TEST EAX,EAX
JZ 0x0017bb8a
ADD RBX,0x30
JMP 0x0017bb6b
LAB_0017bb8a:
MOV RAX,RBX
LAB_0017bb8d:
MOV RCX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
JZ 0x0017bc04
ADD RAX,0x20
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0017bba8:
MOV EDI,0x20
CALL 0x0011a3b0
MOV RBX,RAX
MOV RDI,R14
CALL 0x00152ede
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_0017bbc5:
LEA RSI,[0x1c1272]
MOV RDI,RSP
CALL 0x00181127
MOV BPL,0x1
LAB_0017bbd7:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x0015ea10
XOR EBP,EBP
LEA RSI,[0x1f32c8]
LEA RDX,[0x161092]
MOV RDI,RBX
CALL 0x0011ad60
LAB_0017bc04:
MOV EDI,0x20
CALL 0x0011a3b0
MOV RBX,RAX
LEA R12,[RSP + 0x30]
MOV qword ptr [R12 + -0x10],R12
MOV RDI,R15
CALL 0x0011a350
LEA RDX,[RAX + R15*0x1]
LAB_0017bc27:
LEA RDI,[RSP + 0x20]
MOV RSI,R15
CALL 0x00126294
LAB_0017bc34:
LEA RSI,[0x1c12a2]
LEA RCX,[0x1c12a8]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x00181730
MOV BPL,0x1
LAB_0017bc52:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x0015dce8
XOR EBP,EBP
LEA RSI,[0x1f33b0]
LEA RDX,[0x161092]
MOV RDI,RBX
CALL 0x0011ad60
|
char * _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA13_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,char *param_2)
{
int8 *puVar1;
int iVar2;
char *pcVar3;
int8 uVar4;
size_t sVar5;
char *pcVar6;
detail adStack_68 [32];
char *local_48 [2];
char local_38 [16];
if (*param_1 !=
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
uVar4 = __cxa_allocate_exception(0x20);
local_48[0] = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name(param_1);
/* try { // try from 0017bbc5 to 0017bbd3 has its CatchHandler @ 0017bcd6 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(adStack_68,"cannot use at() with ",local_48);
/* try { // try from 0017bbd7 to 0017bc01 has its CatchHandler @ 0017bcb6 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x130,adStack_68,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
puVar1 = *(int8 **)(param_1 + 8);
pcVar6 = (char *)*puVar1;
while ((pcVar3 = (char *)puVar1[1], pcVar6 != pcVar3 &&
(iVar2 = std::__cxx11::string::compare(pcVar6), pcVar3 = pcVar6, iVar2 != 0))) {
pcVar6 = pcVar6 + 0x30;
}
if (pcVar3 == *(char **)(*(long *)(param_1 + 8) + 8)) {
uVar4 = __cxa_allocate_exception(0x20);
local_48[0] = local_38;
sVar5 = strlen(param_2);
/* try { // try from 0017bc27 to 0017bc33 has its CatchHandler @ 0017bcb4 */
std::__cxx11::string::_M_construct<char_const*>(local_48,param_2,param_2 + sVar5);
/* try { // try from 0017bc34 to 0017bc4e has its CatchHandler @ 0017bc9d */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(adStack_68,"key \'",(string *)local_48,"\' not found");
/* try { // try from 0017bc52 to 0017bc7c has its CatchHandler @ 0017bc7d */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x193,adStack_68,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return pcVar3 + 0x20;
}
|
|
57,791
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [9], 0>(char const (&) [9])
|
monkey531[P]llama/common/json.hpp
|
reference at(KeyType && key)
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return set_parent(it->second);
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [9], 0>(char const (&) [9]):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0x6d279
movq %rsi, %r15
movq 0x8(%r14), %rdi
callq 0x71058
movq 0x8(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0x6d2d7
addq $0x20, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x223e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x4df64
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x32fa6(%rip), %rsi # 0xa0241
leaq 0x8(%rsp), %rdi
callq 0x7067d
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x56eb0
xorl %ebp, %ebp
leaq 0x74002(%rip), %rsi # 0xe12c8
leaq -0x14449(%rip), %rdx # 0x58e84
movq %rbx, %rdi
callq 0x22d40
jmp 0x6d341
pushq $0x20
popq %rdi
callq 0x223e0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0x29014
leaq 0x32f76(%rip), %rsi # 0xa0271
leaq 0x32f75(%rip), %rcx # 0xa0277
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x70c87
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0x564d6
xorl %ebp, %ebp
leaq 0x7407e(%rip), %rsi # 0xe13b0
leaq -0x144b5(%rip), %rdx # 0x58e84
movq %rbx, %rdi
callq 0x22d40
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x22f98
jmp 0x6d356
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
jmp 0x6d367
jmp 0x6d373
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x22f98
testb %bpl, %bpl
jne 0x6d376
jmp 0x6d37e
movq %rax, %r14
movq %rbx, %rdi
callq 0x225c0
movq %r14, %rdi
callq 0x22da0
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
push rbp; char
push r15; int
push r14; int
push rbx; int
sub rsp, 48h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_6D279
mov r15, rsi
mov rdi, [r14+8]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA9_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
mov rcx, [r14+8]
cmp rax, [rcx+8]
jz short loc_6D2D7
add rax, 20h ; ' '
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_6D279:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+68h+var_40]
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+68h+var_60]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
lea rdx, [rsp+68h+var_60]
mov rdi, rbx; this
mov esi, 130h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_6D341
loc_6D2D7:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_61]
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+68h+var_60]
lea rdx, [rsp+68h+var_40]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
mov bpl, 1
lea rdx, [rsp+68h+var_60]
mov rdi, rbx; this
mov esi, 193h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_6D341:
mov r14, rax
lea rdi, [rsp+68h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6D356
mov r14, rax
mov bpl, 1
loc_6D356:
lea rdi, [rsp+68h+var_40]
jmp short loc_6D367
jmp short loc_6D373
mov r14, rax
lea rdi, [rsp+68h+var_60]; void *
loc_6D367:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_6D376
jmp short loc_6D37E
loc_6D373:
mov r14, rax
loc_6D376:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_6D37E:
mov rdi, r14
call __Unwind_Resume
|
long long ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_(
long long a1,
long long a2)
{
long long v2; // rax
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::out_of_range *v5; // rbx
_BYTE v6[32]; // [rsp+8h] [rbp-60h] BYREF
_QWORD v7[8]; // [rsp+28h] [rbp-40h] BYREF
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v7[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>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(v6, "cannot use at() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
304,
(long long)v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v2 = ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA9_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(*(_QWORD *)(a1 + 8));
if ( v2 == *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) )
{
v5 = (nlohmann::json_abi_v3_11_3::detail::out_of_range *)__cxa_allocate_exception(0x20uLL);
std::string::basic_string<std::allocator<char>>(v7, a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
v6,
"key '",
v7,
"' not found");
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v5,
403,
(long long)v6);
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return v2 + 32;
}
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x0016d279
MOV R15,RSI
MOV RDI,qword ptr [R14 + 0x8]
CALL 0x00171058
MOV RCX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
JZ 0x0016d2d7
ADD RAX,0x20
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0016d279:
PUSH 0x20
POP RDI
CALL 0x001223e0
MOV RBX,RAX
MOV RDI,R14
CALL 0x0014df64
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],RAX
LAB_0016d294:
LEA RSI,[0x1a0241]
LEA RDI,[RSP + 0x8]
CALL 0x0017067d
MOV BPL,0x1
LAB_0016d2a8:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x00156eb0
XOR EBP,EBP
LEA RSI,[0x1e12c8]
LEA RDX,[0x158e84]
MOV RDI,RBX
CALL 0x00122d40
LAB_0016d2d7:
PUSH 0x20
POP RDI
CALL 0x001223e0
MOV RBX,RAX
LAB_0016d2e2:
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x7]
MOV RSI,R15
CALL 0x00129014
LAB_0016d2f4:
LEA RSI,[0x1a0271]
LEA RCX,[0x1a0277]
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x28]
CALL 0x00170c87
MOV BPL,0x1
LAB_0016d314:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x001564d6
XOR EBP,EBP
LEA RSI,[0x1e13b0]
LEA RDX,[0x158e84]
MOV RDI,RBX
CALL 0x00122d40
|
long _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,char *param_2)
{
long lVar1;
int8 uVar2;
allocator local_61;
detail local_60 [32];
char *local_40 [4];
if (*param_1 !=
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
uVar2 = __cxa_allocate_exception(0x20);
local_40[0] = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name(param_1);
/* try { // try from 0016d294 to 0016d2a4 has its CatchHandler @ 0016d373 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(local_60,"cannot use at() with ",local_40);
/* try { // try from 0016d2a8 to 0016d2d4 has its CatchHandler @ 0016d35f */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x130,local_60,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
lVar1 = _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA9_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
(*(int8 *)(param_1 + 8));
if (lVar1 != *(long *)(*(long *)(param_1 + 8) + 8)) {
return lVar1 + 0x20;
}
uVar2 = __cxa_allocate_exception(0x20);
/* try { // try from 0016d2e2 to 0016d2f3 has its CatchHandler @ 0016d35d */
std::__cxx11::string::string<std::allocator<char>>((string *)local_40,param_2,&local_61);
/* try { // try from 0016d2f4 to 0016d310 has its CatchHandler @ 0016d350 */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(local_60,"key \'",(string *)local_40,"\' not found");
/* try { // try from 0016d314 to 0016d340 has its CatchHandler @ 0016d341 */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x193,local_60,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
|
|
57,792
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [9], 0>(char const (&) [9])
|
monkey531[P]llama/common/json.hpp
|
reference at(KeyType && key)
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return set_parent(it->second);
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [9], 0>(char const (&) [9]):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0x789af
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0x78999
movq %rbx, %rdi
movq %r15, %rsi
callq 0x191b0
testl %eax, %eax
je 0x7898e
addq $0x30, %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
jne 0x7896f
jmp 0x78991
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
cmpq %rbx, %rax
je 0x78a0d
addq $0x20, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x193b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x5108e
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x44891(%rip), %rsi # 0xbd262
leaq 0x20(%rsp), %rdi
callq 0x7ec31
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x5c804
xorl %ebp, %ebp
leaq 0x768cc(%rip), %rsi # 0xef2c8
leaq -0x19b63(%rip), %rdx # 0x5eea0
movq %rbx, %rdi
callq 0x19d60
jmp 0x78a86
movl $0x20, %edi
callq 0x193b0
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x19350
leaq (%rax,%r15), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x25304
leaq 0x44850(%rip), %rsi # 0xbd292
leaq 0x4484f(%rip), %rcx # 0xbd298
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x7f20e
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0x5bb64
xorl %ebp, %ebp
leaq 0x76939(%rip), %rsi # 0xef3b0
leaq -0x19bde(%rip), %rdx # 0x5eea0
movq %rbx, %rdi
callq 0x19d60
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x78aa4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x197f0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x78aef
movq 0x10(%rsp), %rsi
jmp 0x78ae7
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x78af9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x197f0
jmp 0x78af9
jmp 0x78af6
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x78aef
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x197f0
testb %bpl, %bpl
jne 0x78af9
jmp 0x78b01
movq %rax, %r14
movq %rbx, %rdi
callq 0x195a0
movq %r14, %rdi
callq 0x19dc0
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
push rbp; char
push r15; int
push r14; int
push r12; int
push rbx; char
sub rsp, 40h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_789AF
mov r15, rsi
mov r12, [r14+8]
mov rbx, [r12]
mov rax, [r12+8]
cmp rbx, rax
jz short loc_78999
loc_7896F:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_7898E
add rbx, 30h ; '0'
mov rax, [r12+8]
cmp rbx, rax
jnz short loc_7896F
jmp short loc_78991
loc_7898E:
mov rax, rbx
loc_78991:
mov rcx, [r14+8]
mov rbx, [rcx+8]
loc_78999:
cmp rax, rbx
jz short loc_78A0D
add rax, 20h ; ' '
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_789AF:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
mov rdx, rsp
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+68h+var_48]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 130h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_78A86
loc_78A0D:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r12, [rsp+68h+var_58]
mov [r12-10h], r12
mov rdi, r15
call _strlen
lea rdx, [rax+r15]
mov rdi, rsp
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+68h+var_48]
mov rdx, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 193h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_78A86:
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_78AA4
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_78AA4:
mov rdi, [rsp+68h+var_68]
cmp rdi, r12
jz short loc_78AEF
mov rsi, [rsp+68h+var_58]
jmp short loc_78AE7
mov r14, rax
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r12
jz short loc_78AF9
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_78AF9
jmp short loc_78AF6
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_78AEF
mov rsi, [rsp+68h+var_38]
loc_78AE7:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_78AEF:
test bpl, bpl
jnz short loc_78AF9
jmp short loc_78B01
loc_78AF6:
mov r14, rax
loc_78AF9:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_78B01:
mov rdi, r14
call __Unwind_Resume
|
long long ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_(
long long a1,
_BYTE *a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v7; // rbx
long long v8; // rax
void *v9[2]; // [rsp+0h] [rbp-68h] BYREF
long long v10; // [rsp+10h] [rbp-58h] BYREF
_QWORD v11[2]; // [rsp+20h] [rbp-48h] BYREF
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v9[0] = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(v11, "cannot use at() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
304,
v11);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v2 = *(long long **)(a1 + 8);
v3 = *v2;
v4 = v2[1];
if ( *v2 != v4 )
{
while ( (unsigned int)std::string::compare(v3, a2) )
{
v3 += 48LL;
v4 = v2[1];
if ( v3 == v4 )
goto LABEL_7;
}
v4 = v3;
LABEL_7:
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
if ( v4 == v3 )
{
v7 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v9[0] = &v10;
v8 = strlen(a2);
std::string::_M_construct<char const*>((long long)v9, a2, (long long)&a2[v8]);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
v11,
"key '",
v9,
"' not found");
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v7,
403,
v11);
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return v4 + 32;
}
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x001789af
MOV R15,RSI
MOV R12,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JZ 0x00178999
LAB_0017896f:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001191b0
TEST EAX,EAX
JZ 0x0017898e
ADD RBX,0x30
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JNZ 0x0017896f
JMP 0x00178991
LAB_0017898e:
MOV RAX,RBX
LAB_00178991:
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
LAB_00178999:
CMP RAX,RBX
JZ 0x00178a0d
ADD RAX,0x20
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001789af:
MOV EDI,0x20
CALL 0x001193b0
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015108e
MOV RDX,RSP
MOV qword ptr [RDX],RAX
LAB_001789ca:
LEA RSI,[0x1bd262]
LEA RDI,[RSP + 0x20]
CALL 0x0017ec31
MOV BPL,0x1
LAB_001789de:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x0015c804
XOR EBP,EBP
LEA RSI,[0x1ef2c8]
LEA RDX,[0x15eea0]
MOV RDI,RBX
CALL 0x00119d60
LAB_00178a0d:
MOV EDI,0x20
CALL 0x001193b0
MOV RBX,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
MOV RDI,R15
CALL 0x00119350
LEA RDX,[RAX + R15*0x1]
LAB_00178a30:
MOV RDI,RSP
MOV RSI,R15
CALL 0x00125304
LAB_00178a3b:
LEA RSI,[0x1bd292]
LEA RCX,[0x1bd298]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x0017f20e
MOV BPL,0x1
LAB_00178a59:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x0015bb64
XOR EBP,EBP
LEA RSI,[0x1ef3b0]
LEA RDX,[0x15eea0]
MOV RDI,RBX
CALL 0x00119d60
|
char * _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,char *param_2)
{
long *plVar1;
int iVar2;
char *pcVar3;
int8 uVar4;
size_t sVar5;
char *pcVar6;
char *local_68 [2];
char local_58 [16];
detail local_48 [32];
if (*param_1 !=
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name(param_1);
/* try { // try from 001789ca to 001789da has its CatchHandler @ 00178af6 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(local_48,"cannot use at() with ",local_68);
/* try { // try from 001789de to 00178a0a has its CatchHandler @ 00178ad1 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x130,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
plVar1 = *(long **)(param_1 + 8);
pcVar6 = (char *)*plVar1;
pcVar3 = (char *)plVar1[1];
if (pcVar6 != pcVar3) {
do {
pcVar3 = pcVar6;
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar6 = pcVar3 + 0x30;
pcVar3 = (char *)plVar1[1];
} while (pcVar6 != pcVar3);
pcVar6 = *(char **)(*(long *)(param_1 + 8) + 8);
}
if (pcVar3 == pcVar6) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = local_58;
sVar5 = strlen(param_2);
/* try { // try from 00178a30 to 00178a3a has its CatchHandler @ 00178acf */
std::__cxx11::string::_M_construct<char_const*>(local_68,param_2,param_2 + sVar5);
/* try { // try from 00178a3b to 00178a55 has its CatchHandler @ 00178ab4 */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(local_48,"key \'",(string *)local_68,"\' not found");
/* try { // try from 00178a59 to 00178a85 has its CatchHandler @ 00178a86 */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x193,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return pcVar3 + 0x20;
}
|
|
57,793
|
nglog::(anonymous namespace)::DumpSignalInfo(int, siginfo_t*)
|
ng-log[P]ng-log/src/signalhandler.cc
|
void DumpSignalInfo(int signal_number, siginfo_t* siginfo) {
// Get the signal name.
const char* signal_name = nullptr;
for (auto kFailureSignal : kFailureSignals) {
if (signal_number == kFailureSignal.number) {
signal_name = kFailureSignal.name;
}
}
char buf[256]; // Big enough for signal info.
MinimalFormatter formatter(buf, sizeof(buf));
formatter.AppendString("*** ");
if (signal_name) {
formatter.AppendString(signal_name);
} else {
// Use the signal number if the name is unknown. The signal name
// should be known, but just in case.
formatter.AppendString("Signal ");
formatter.AppendUint64(static_cast<uint64>(signal_number), 10);
}
formatter.AppendString(" (@0x");
formatter.AppendUint64(reinterpret_cast<uintptr_t>(siginfo->si_addr), 16);
formatter.AppendString(")");
formatter.AppendString(" received by PID ");
formatter.AppendUint64(static_cast<uint64>(getpid()), 10);
formatter.AppendString(" (TID ");
std::ostringstream oss;
oss << std::showbase << std::hex << std::this_thread::get_id();
formatter.AppendString(oss.str().c_str());
# if defined(GLOG_OS_LINUX) && defined(HAVE_SYS_SYSCALL_H) && \
defined(HAVE_SYS_TYPES_H)
pid_t tid = syscall(SYS_gettid);
formatter.AppendString(" LWP ");
formatter.AppendUint64(static_cast<uint64>(tid), 10);
# endif
formatter.AppendString(") ");
// Only linux has the PID of the signal sender in si_pid.
# ifdef NGLOG_OS_LINUX
formatter.AppendString("from PID ");
formatter.AppendUint64(static_cast<uint64>(siginfo->si_pid), 10);
formatter.AppendString("; ");
# endif
formatter.AppendString("stack trace: ***\n");
g_failure_writer(buf, formatter.num_bytes_written());
}
|
O0
|
cpp
|
nglog::(anonymous namespace)::DumpSignalInfo(int, siginfo_t*):
pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp # imm = 0x350
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x29c0f(%rip), %rax # 0x76cb0
movq %rax, -0x20(%rbp)
leaq 0x29c04(%rip), %rax # 0x76cb0
movq %rax, -0x28(%rbp)
leaq 0x29bf9(%rip), %rax # 0x76cb0
addq $0x60, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x4d0fc
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x40(%rbp), %eax
jne 0x4d0ec
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x4d0ee
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
jmp 0x4d0bf
leaq -0x140(%rbp), %rsi
leaq -0x158(%rbp), %rdi
movl $0x100, %edx # imm = 0x100
callq 0x4d3f0
leaq -0x158(%rbp), %rdi
leaq 0x5f8f(%rip), %rsi # 0x530b1
callq 0x4d430
cmpq $0x0, -0x18(%rbp)
je 0x4d140
movq -0x18(%rbp), %rsi
leaq -0x158(%rbp), %rdi
callq 0x4d430
jmp 0x4d168
leaq -0x158(%rbp), %rdi
leaq 0x5f68(%rip), %rsi # 0x530b6
callq 0x4d430
movslq -0x4(%rbp), %rsi
leaq -0x158(%rbp), %rdi
movl $0xa, %edx
callq 0x4d4c0
leaq 0x5f4f(%rip), %rsi # 0x530be
leaq -0x158(%rbp), %rdi
movq %rdi, -0x320(%rbp)
callq 0x4d430
movq -0x320(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x10, %edx
callq 0x4d4c0
movq -0x320(%rbp), %rdi
leaq 0x4ccd(%rip), %rsi # 0x51e76
callq 0x4d430
movq -0x320(%rbp), %rdi
leaq 0x5f08(%rip), %rsi # 0x530c4
callq 0x4d430
callq 0x9b30
movq -0x320(%rbp), %rdi
movslq %eax, %rsi
movl $0xa, %edx
callq 0x4d4c0
movq -0x320(%rbp), %rdi
leaq 0x5eee(%rip), %rsi # 0x530d6
callq 0x4d430
leaq -0x2d0(%rbp), %rdi
movq %rdi, -0x318(%rbp)
callq 0x9a10
movq -0x318(%rbp), %rdi
leaq 0x7e2(%rip), %rsi # 0x4d9f0
callq 0x9210
movq %rax, -0x310(%rbp)
jmp 0x4d21c
movq -0x310(%rbp), %rdi
leaq -0x1541a(%rip), %rsi # 0x37e10
callq 0x9210
movq %rax, -0x328(%rbp)
jmp 0x4d238
callq 0x1d6f0
movq -0x328(%rbp), %rdi
movq %rax, -0x2e8(%rbp)
movq -0x2e8(%rbp), %rsi
callq 0x1d760
jmp 0x4d259
leaq -0x308(%rbp), %rdi
leaq -0x2d0(%rbp), %rsi
callq 0x9730
jmp 0x4d26e
leaq -0x308(%rbp), %rdi
movq %rdi, -0x338(%rbp)
callq 0x92b0
movq %rax, %rsi
leaq -0x158(%rbp), %rdi
movq %rdi, -0x330(%rbp)
callq 0x4d430
movq -0x338(%rbp), %rdi
callq 0x9ee8
movq -0x330(%rbp), %rdi
leaq 0x6016(%rip), %rsi # 0x532c7
callq 0x4d430
movq -0x330(%rbp), %rdi
leaq 0x5e19(%rip), %rsi # 0x530dd
callq 0x4d430
movq -0x330(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rsi
movl $0xa, %edx
callq 0x4d4c0
jmp 0x4d2e4
leaq 0x5dfc(%rip), %rsi # 0x530e7
leaq -0x158(%rbp), %rdi
movq %rdi, -0x348(%rbp)
callq 0x4d430
movq -0x348(%rbp), %rdi
leaq 0x467c(%rip), %rsi # 0x51988
callq 0x4d430
movq -0x348(%rbp), %rdi
movq 0x2a881(%rip), %rax # 0x77ba0
movq %rax, -0x340(%rbp)
callq 0x4d5a0
movq %rax, %rsi
movq -0x340(%rbp), %rax
leaq -0x140(%rbp), %rdi
callq *%rax
jmp 0x4d340
leaq -0x2d0(%rbp), %rdi
callq 0x9150
addq $0x350, %rsp # imm = 0x350
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2d8(%rbp)
movl %eax, -0x2dc(%rbp)
leaq -0x2d0(%rbp), %rdi
callq 0x9150
movq -0x2d8(%rbp), %rdi
callq 0x9d40
nop
|
_ZN5nglog12_GLOBAL__N_114DumpSignalInfoEiP9siginfo_t:
push rbp
mov rbp, rsp
sub rsp, 350h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], 0
lea rax, _ZN5nglog12_GLOBAL__N_115kFailureSignalsE; nglog::`anonymous namespace'::kFailureSignals
mov [rbp+var_20], rax
lea rax, _ZN5nglog12_GLOBAL__N_115kFailureSignalsE; nglog::`anonymous namespace'::kFailureSignals
mov [rbp+var_28], rax
lea rax, _ZN5nglog12_GLOBAL__N_115kFailureSignalsE; nglog::`anonymous namespace'::kFailureSignals
add rax, 60h ; '`'
mov [rbp+var_30], rax
loc_4D0BF:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jz short loc_4D0FC
mov rax, [rbp+var_28]
mov rcx, [rax]
mov [rbp+var_40], rcx
mov rax, [rax+8]
mov [rbp+var_38], rax
mov eax, [rbp+var_4]
cmp eax, dword ptr [rbp+var_40]
jnz short loc_4D0EC
mov rax, [rbp+var_38]
mov [rbp+var_18], rax
loc_4D0EC:
jmp short $+2
loc_4D0EE:
mov rax, [rbp+var_28]
add rax, 10h
mov [rbp+var_28], rax
jmp short loc_4D0BF
loc_4D0FC:
lea rsi, [rbp+var_140]; char *
lea rdi, [rbp+var_158]; this
mov edx, 100h; unsigned __int64
call _ZN5nglog12_GLOBAL__N_116MinimalFormatterC2EPcm; nglog::`anonymous namespace'::MinimalFormatter::MinimalFormatter(char *,ulong)
lea rdi, [rbp+var_158]; this
lea rsi, asc_530B1; "*** "
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendStringEPKc; nglog::`anonymous namespace'::MinimalFormatter::AppendString(char const*)
cmp [rbp+var_18], 0
jz short loc_4D140
mov rsi, [rbp+var_18]; char *
lea rdi, [rbp+var_158]; this
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendStringEPKc; nglog::`anonymous namespace'::MinimalFormatter::AppendString(char const*)
jmp short loc_4D168
loc_4D140:
lea rdi, [rbp+var_158]; this
lea rsi, aSignal; "Signal "
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendStringEPKc; nglog::`anonymous namespace'::MinimalFormatter::AppendString(char const*)
movsxd rsi, [rbp+var_4]; unsigned __int64
lea rdi, [rbp+var_158]; this
mov edx, 0Ah; unsigned int
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendUint64Emj; nglog::`anonymous namespace'::MinimalFormatter::AppendUint64(ulong,uint)
loc_4D168:
lea rsi, a0x; " (@0x"
lea rdi, [rbp+var_158]; this
mov [rbp+var_320], rdi
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendStringEPKc; nglog::`anonymous namespace'::MinimalFormatter::AppendString(char const*)
mov rdi, [rbp+var_320]; this
mov rax, [rbp+var_10]
mov rsi, [rax+10h]; unsigned __int64
mov edx, 10h; unsigned int
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendUint64Emj; nglog::`anonymous namespace'::MinimalFormatter::AppendUint64(ulong,uint)
mov rdi, [rbp+var_320]; this
lea rsi, aVoidNglogAnony+86h; char *
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendStringEPKc; nglog::`anonymous namespace'::MinimalFormatter::AppendString(char const*)
mov rdi, [rbp+var_320]; this
lea rsi, aReceivedByPid; " received by PID "
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendStringEPKc; nglog::`anonymous namespace'::MinimalFormatter::AppendString(char const*)
call _getpid
mov rdi, [rbp+var_320]; this
movsxd rsi, eax; unsigned __int64
mov edx, 0Ah; unsigned int
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendUint64Emj; nglog::`anonymous namespace'::MinimalFormatter::AppendUint64(ulong,uint)
mov rdi, [rbp+var_320]; this
lea rsi, aTid; " (TID "
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendStringEPKc; nglog::`anonymous namespace'::MinimalFormatter::AppendString(char const*)
lea rdi, [rbp+var_2D0]
mov [rbp+var_318], rdi
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rdi, [rbp+var_318]
lea rsi, _ZSt8showbaseRSt8ios_base; std::showbase(std::ios_base &)
call __ZNSolsEPFRSt8ios_baseS0_E; std::ostream::operator<<(std::ios_base & (*)(std::ios_base &))
mov [rbp+var_310], rax
jmp short $+2
loc_4D21C:
mov rdi, [rbp+var_310]; this
lea rsi, _ZSt3hexRSt8ios_base; std::hex(std::ios_base &)
call __ZNSolsEPFRSt8ios_baseS0_E; std::ostream::operator<<(std::ios_base & (*)(std::ios_base &))
mov [rbp+var_328], rax
jmp short $+2
loc_4D238:
call _ZNSt11this_thread6get_idEv; std::this_thread::get_id(void)
mov rdi, [rbp+var_328]
mov [rbp+var_2E8], rax
mov rsi, [rbp+var_2E8]
call _ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_NSt6thread2idE; std::operator<<<char,std::char_traits<char>>(std::ostream &,std::thread::id)
jmp short $+2
loc_4D259:
lea rdi, [rbp+var_308]
lea rsi, [rbp+var_2D0]
call __ZNKSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEE3strEv; std::ostringstream::str(void)
jmp short $+2
loc_4D26E:
lea rdi, [rbp+var_308]
mov [rbp+var_338], rdi
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rsi, rax; char *
lea rdi, [rbp+var_158]; this
mov [rbp+var_330], rdi
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendStringEPKc; nglog::`anonymous namespace'::MinimalFormatter::AppendString(char const*)
mov rdi, [rbp+var_338]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rdi, [rbp+var_330]; this
lea rsi, aCheckFailedIsl_0+23h; char *
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendStringEPKc; nglog::`anonymous namespace'::MinimalFormatter::AppendString(char const*)
mov rdi, [rbp+var_330]; this
lea rsi, aFromPid; "from PID "
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendStringEPKc; nglog::`anonymous namespace'::MinimalFormatter::AppendString(char const*)
mov rdi, [rbp+var_330]; this
mov rax, [rbp+var_10]
movsxd rsi, dword ptr [rax+10h]; unsigned __int64
mov edx, 0Ah; unsigned int
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendUint64Emj; nglog::`anonymous namespace'::MinimalFormatter::AppendUint64(ulong,uint)
jmp short $+2
loc_4D2E4:
lea rsi, asc_530E7; "; "
lea rdi, [rbp+var_158]; this
mov [rbp+var_348], rdi
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendStringEPKc; nglog::`anonymous namespace'::MinimalFormatter::AppendString(char const*)
mov rdi, [rbp+var_348]; this
lea rsi, aCheckFailureSt+12h; char *
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendStringEPKc; nglog::`anonymous namespace'::MinimalFormatter::AppendString(char const*)
mov rdi, [rbp+var_348]; this
mov rax, cs:_ZN5nglog12_GLOBAL__N_116g_failure_writerE; nglog::`anonymous namespace'::g_failure_writer
mov [rbp+var_340], rax
call _ZNK5nglog12_GLOBAL__N_116MinimalFormatter17num_bytes_writtenEv; nglog::`anonymous namespace'::MinimalFormatter::num_bytes_written(void)
mov rsi, rax
mov rax, [rbp+var_340]
lea rdi, [rbp+var_140]
call rax
jmp short $+2
loc_4D340:
lea rdi, [rbp+var_2D0]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
add rsp, 350h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_2D8], rcx
mov [rbp+var_2DC], eax
lea rdi, [rbp+var_2D0]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rdi, [rbp+var_2D8]
call __Unwind_Resume
|
long long nglog::`anonymous namespace'::DumpSignalInfo(int a1, long long a2)
{
int v2; // eax
std::this_thread *v3; // rdi
const char *v4; // rax
long long v5; // rax
long long ( *v7)(nglog::_anonymous_namespace_ *__hidden, const char *, unsigned long long); // [rsp+10h] [rbp-340h]
long long v8; // [rsp+28h] [rbp-328h]
_BYTE v9[32]; // [rsp+48h] [rbp-308h] BYREF
long long id; // [rsp+68h] [rbp-2E8h]
_BYTE v11[376]; // [rsp+80h] [rbp-2D0h] BYREF
char v12[24]; // [rsp+1F8h] [rbp-158h] BYREF
char v13[256]; // [rsp+210h] [rbp-140h] BYREF
long long v14; // [rsp+310h] [rbp-40h]
char *v15; // [rsp+318h] [rbp-38h]
char *v16; // [rsp+320h] [rbp-30h]
long long *v17; // [rsp+328h] [rbp-28h]
void *v18; // [rsp+330h] [rbp-20h]
char *v19; // [rsp+338h] [rbp-18h]
long long v20; // [rsp+340h] [rbp-10h]
int v21; // [rsp+34Ch] [rbp-4h]
v21 = a1;
v20 = a2;
v19 = 0LL;
v18 = &nglog::`anonymous namespace'::kFailureSignals;
v17 = (long long *)&nglog::`anonymous namespace'::kFailureSignals;
v16 = (char *)&nglog::`anonymous namespace'::kFailureSignals + 96;
while ( v17 != (long long *)v16 )
{
v14 = *v17;
v15 = (char *)v17[1];
if ( v21 == (_DWORD)v14 )
v19 = v15;
v17 += 2;
}
nglog::`anonymous namespace'::MinimalFormatter::MinimalFormatter(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
v13,
0x100uLL);
nglog::`anonymous namespace'::MinimalFormatter::AppendString(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
"*** ");
if ( v19 )
{
nglog::`anonymous namespace'::MinimalFormatter::AppendString(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
v19);
}
else
{
nglog::`anonymous namespace'::MinimalFormatter::AppendString(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
"Signal ");
nglog::`anonymous namespace'::MinimalFormatter::AppendUint64(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
v21,
0xAu);
}
nglog::`anonymous namespace'::MinimalFormatter::AppendString(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
" (@0x");
nglog::`anonymous namespace'::MinimalFormatter::AppendUint64(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
*(_QWORD *)(v20 + 16),
0x10u);
nglog::`anonymous namespace'::MinimalFormatter::AppendString(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
")");
nglog::`anonymous namespace'::MinimalFormatter::AppendString(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
" received by PID ");
v2 = getpid();
nglog::`anonymous namespace'::MinimalFormatter::AppendUint64(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
v2,
0xAu);
nglog::`anonymous namespace'::MinimalFormatter::AppendString(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
" (TID ");
std::ostringstream::basic_ostringstream(v11);
v3 = (std::this_thread *)std::ostream::operator<<(v11, std::showbase);
v8 = std::ostream::operator<<(v3, std::hex);
id = std::this_thread::get_id(v3);
std::operator<<<char,std::char_traits<char>>(v8, id);
std::ostringstream::str(v9, v11);
v4 = (const char *)std::string::c_str(v9);
nglog::`anonymous namespace'::MinimalFormatter::AppendString(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
v4);
std::string::~string(v9);
nglog::`anonymous namespace'::MinimalFormatter::AppendString(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
") ");
nglog::`anonymous namespace'::MinimalFormatter::AppendString(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
"from PID ");
nglog::`anonymous namespace'::MinimalFormatter::AppendUint64(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
*(int *)(v20 + 16),
0xAu);
nglog::`anonymous namespace'::MinimalFormatter::AppendString(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
"; ");
nglog::`anonymous namespace'::MinimalFormatter::AppendString(
(nglog::_anonymous_namespace_::MinimalFormatter *)v12,
"stack trace: ***\n");
v7 = nglog::`anonymous namespace'::g_failure_writer;
v5 = nglog::`anonymous namespace'::MinimalFormatter::num_bytes_written((nglog::_anonymous_namespace_::MinimalFormatter *)v12);
((void ( *)(char *, long long))v7)(v13, v5);
return std::ostringstream::~ostringstream(v11);
}
|
DumpSignalInfo:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x350
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],0x0
LEA RAX,[0x176cb0]
MOV qword ptr [RBP + -0x20],RAX
LEA RAX,[0x176cb0]
MOV qword ptr [RBP + -0x28],RAX
LEA RAX,[0x176cb0]
ADD RAX,0x60
MOV qword ptr [RBP + -0x30],RAX
LAB_0014d0bf:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x0014d0fc
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x40]
JNZ 0x0014d0ec
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x18],RAX
LAB_0014d0ec:
JMP 0x0014d0ee
LAB_0014d0ee:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x10
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0014d0bf
LAB_0014d0fc:
LEA RSI,[RBP + -0x140]
LEA RDI,[RBP + -0x158]
MOV EDX,0x100
CALL 0x0014d3f0
LEA RDI,[RBP + -0x158]
LEA RSI,[0x1530b1]
CALL 0x0014d430
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0014d140
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x158]
CALL 0x0014d430
JMP 0x0014d168
LAB_0014d140:
LEA RDI,[RBP + -0x158]
LEA RSI,[0x1530b6]
CALL 0x0014d430
MOVSXD RSI,dword ptr [RBP + -0x4]
LEA RDI,[RBP + -0x158]
MOV EDX,0xa
CALL 0x0014d4c0
LAB_0014d168:
LEA RSI,[0x1530be]
LEA RDI,[RBP + -0x158]
MOV qword ptr [RBP + -0x320],RDI
CALL 0x0014d430
MOV RDI,qword ptr [RBP + -0x320]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV EDX,0x10
CALL 0x0014d4c0
MOV RDI,qword ptr [RBP + -0x320]
LEA RSI,[0x151e76]
CALL 0x0014d430
MOV RDI,qword ptr [RBP + -0x320]
LEA RSI,[0x1530c4]
CALL 0x0014d430
CALL 0x00109b30
MOV RDI,qword ptr [RBP + -0x320]
MOVSXD RSI,EAX
MOV EDX,0xa
CALL 0x0014d4c0
MOV RDI,qword ptr [RBP + -0x320]
LEA RSI,[0x1530d6]
CALL 0x0014d430
LEA RDI,[RBP + -0x2d0]
MOV qword ptr [RBP + -0x318],RDI
CALL 0x00109a10
MOV RDI,qword ptr [RBP + -0x318]
LAB_0014d207:
LEA RSI,[0x14d9f0]
CALL 0x00109210
MOV qword ptr [RBP + -0x310],RAX
JMP 0x0014d21c
LAB_0014d21c:
MOV RDI,qword ptr [RBP + -0x310]
LEA RSI,[0x137e10]
CALL 0x00109210
MOV qword ptr [RBP + -0x328],RAX
JMP 0x0014d238
LAB_0014d238:
CALL 0x0011d6f0
MOV RDI,qword ptr [RBP + -0x328]
MOV qword ptr [RBP + -0x2e8],RAX
MOV RSI,qword ptr [RBP + -0x2e8]
CALL 0x0011d760
JMP 0x0014d259
LAB_0014d259:
LEA RDI,[RBP + -0x308]
LEA RSI,[RBP + -0x2d0]
CALL 0x00109730
JMP 0x0014d26e
LAB_0014d26e:
LEA RDI,[RBP + -0x308]
MOV qword ptr [RBP + -0x338],RDI
CALL 0x001092b0
MOV RSI,RAX
LEA RDI,[RBP + -0x158]
MOV qword ptr [RBP + -0x330],RDI
CALL 0x0014d430
MOV RDI,qword ptr [RBP + -0x338]
CALL 0x00109ee8
MOV RDI,qword ptr [RBP + -0x330]
LEA RSI,[0x1532c7]
CALL 0x0014d430
MOV RDI,qword ptr [RBP + -0x330]
LEA RSI,[0x1530dd]
CALL 0x0014d430
MOV RDI,qword ptr [RBP + -0x330]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RSI,dword ptr [RAX + 0x10]
MOV EDX,0xa
CALL 0x0014d4c0
JMP 0x0014d2e4
LAB_0014d2e4:
LEA RSI,[0x1530e7]
LEA RDI,[RBP + -0x158]
MOV qword ptr [RBP + -0x348],RDI
CALL 0x0014d430
MOV RDI,qword ptr [RBP + -0x348]
LEA RSI,[0x151988]
CALL 0x0014d430
MOV RDI,qword ptr [RBP + -0x348]
MOV RAX,qword ptr [0x00177ba0]
MOV qword ptr [RBP + -0x340],RAX
CALL 0x0014d5a0
MOV RSI,RAX
MOV RAX,qword ptr [RBP + -0x340]
LEA RDI,[RBP + -0x140]
CALL RAX
LAB_0014d33e:
JMP 0x0014d340
LAB_0014d340:
LEA RDI,[RBP + -0x2d0]
CALL 0x00109150
ADD RSP,0x350
POP RBP
RET
|
/* nglog::(anonymous namespace)::DumpSignalInfo(int, siginfo_t*) */
void nglog::(anonymous_namespace)::DumpSignalInfo(int param_1,siginfo_t *param_2)
{
int *puVar1;
__pid_t _Var2;
ostream *this;
int8 uVar3;
char *pcVar4;
string local_310 [32];
int8 local_2f0;
ostringstream local_2d8 [376];
MinimalFormatter local_160 [24];
char local_148 [256];
Elf64_DynTag local_48;
char *local_40;
Elf64_Dyn *local_38;
Elf64_Dyn *local_30;
int8 *local_28;
char *local_20;
siginfo_t *local_18;
int local_c;
local_20 = (char *)0x0;
local_28 = &kFailureSignals;
local_38 = _DYNAMIC;
for (local_30 = (Elf64_Dyn *)&kFailureSignals; local_30 != _DYNAMIC; local_30 = local_30 + 1) {
local_48 = local_30->d_tag;
local_40 = (char *)local_30->d_val;
if (param_1 == (int4)local_48) {
local_20 = local_40;
}
}
local_18 = param_2;
local_c = param_1;
MinimalFormatter::MinimalFormatter(local_160,local_148,0x100);
MinimalFormatter::AppendString(local_160,"*** ");
if (local_20 == (char *)0x0) {
MinimalFormatter::AppendString(local_160,"Signal ");
MinimalFormatter::AppendUint64(local_160,(long)local_c,10);
}
else {
MinimalFormatter::AppendString(local_160,local_20);
}
MinimalFormatter::AppendString(local_160," (@0x");
MinimalFormatter::AppendUint64(local_160,(local_18->_sifields)._sigpoll.si_band,0x10);
MinimalFormatter::AppendString(local_160,")");
MinimalFormatter::AppendString(local_160," received by PID ");
_Var2 = getpid();
MinimalFormatter::AppendUint64(local_160,(long)_Var2,10);
MinimalFormatter::AppendString(local_160," (TID ");
std::__cxx11::ostringstream::ostringstream(local_2d8);
/* try { // try from 0014d207 to 0014d33d has its CatchHandler @ 0014d355 */
this = (ostream *)std::ostream::operator<<((ostream *)local_2d8,std::showbase);
uVar3 = std::ostream::operator<<(this,std::hex);
local_2f0 = std::this_thread::get_id();
std::operator<<(uVar3,local_2f0);
std::__cxx11::ostringstream::str();
pcVar4 = (char *)std::__cxx11::string::c_str();
MinimalFormatter::AppendString(local_160,pcVar4);
std::__cxx11::string::~string(local_310);
MinimalFormatter::AppendString(local_160,") ");
MinimalFormatter::AppendString(local_160,"from PID ");
MinimalFormatter::AppendUint64(local_160,(long)(local_18->_sifields)._pad[0],10);
MinimalFormatter::AppendString(local_160,"; ");
MinimalFormatter::AppendString(local_160,"stack trace: ***\n");
puVar1 = g_failure_writer;
uVar3 = MinimalFormatter::num_bytes_written(local_160);
(*(code *)puVar1)(local_148,uVar3);
std::__cxx11::ostringstream::~ostringstream(local_2d8);
return;
}
|
|
57,794
|
Relay_log_info::reset_inuse_relaylog()
|
eloqsql/sql/rpl_rli.cc
|
void
Relay_log_info::reset_inuse_relaylog()
{
inuse_relaylog *cur= inuse_relaylog_list;
while (cur)
{
DBUG_ASSERT(cur->queued_count == cur->dequeued_count);
inuse_relaylog *next= cur->next;
free_inuse_relaylog(cur);
cur= next;
}
inuse_relaylog_list= last_inuse_relaylog= NULL;
}
|
O3
|
cpp
|
Relay_log_info::reset_inuse_relaylog():
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1c60(%rdi), %r14
addq $0x1c60, %rbx # imm = 0x1C60
testq %r14, %r14
je 0x5cacab
movq (%r14), %r15
movq 0x10(%r14), %rdi
callq 0x8a2682
movl $0x238, %esi # imm = 0x238
movq %r14, %rdi
callq 0x400200
movq %r15, %r14
testq %r15, %r15
jne 0x5cac8a
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
_ZN14Relay_log_info20reset_inuse_relaylogEv:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov r14, [rdi+1C60h]
add rbx, 1C60h
test r14, r14
jz short loc_5CACAB
loc_5CAC8A:
mov r15, [r14]
mov rdi, [r14+10h]
call my_free
mov esi, 238h; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
mov r14, r15
test r15, r15
jnz short loc_5CAC8A
loc_5CACAB:
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
void Relay_log_info::reset_inuse_relaylog(Relay_log_info *this)
{
_QWORD *v1; // r14
_QWORD *v2; // r15
v1 = (_QWORD *)*((_QWORD *)this + 908);
if ( v1 )
{
do
{
v2 = (_QWORD *)*v1;
my_free(v1[2]);
operator delete(v1, 0x238uLL);
v1 = v2;
}
while ( v2 );
}
*((_OWORD *)this + 454) = 0LL;
}
|
awake_no_mutex:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14D,ESI
MOV RBX,RDI
LEA RDX,[0xaa4497]
MOV ESI,0x3
CALL 0x005710c2
MOV EAX,dword ptr [RBX + 0x3ebc]
CMP EAX,0xc
JL 0x005cac9a
MOV R14D,dword ptr [RBX + 0x3ebc]
LAB_005cac9a:
MOV EAX,dword ptr [RBX + 0x3ebc]
CMP EAX,R14D
JG 0x005cacac
MOV dword ptr [RBX + 0x3ebc],R14D
LAB_005cacac:
CMP R14D,0xc
SETL AL
TEST R14D,R14D
SETNZ CL
TEST AL,CL
JNZ 0x005cad20
CALL 0x00567888
CMP RAX,RBX
JZ 0x005cacf1
LEA RAX,[0x11e4b60]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RBX + 0x3e48],RAX
JZ 0x005cacf1
MOV RDI,qword ptr [RBX + 0x3a38]
TEST RDI,RDI
JZ 0x005cacf1
MOV ESI,0x2
CALL qword ptr [RDI + 0x1c0]
LAB_005cacf1:
MOV RDI,qword ptr [RBX + 0x3e48]
CALL 0x009a6416
CMP byte ptr [RBX + 0x3fb3],0x0
JNZ 0x005cad20
MOV RAX,qword ptr [RBX + 0x588]
TEST RAX,RAX
JZ 0x005cad20
MOV RAX,qword ptr [RAX + 0x38]
TEST RAX,RAX
JZ 0x005cad20
MOV RDI,RBX
CALL RAX
LAB_005cad20:
TEST R14D,R14D
JZ 0x005cad4a
CMP qword ptr [RBX + 0x65a8],-0x1
JZ 0x005cad38
CMP dword ptr [RBX + 0x65d8],0x0
JNZ 0x005cad4a
LAB_005cad38:
MOV RDI,RBX
CALL 0x005cad58
MOV RDI,RBX
MOV ESI,EAX
CALL 0x007b5d27
LAB_005cad4a:
MOV RDI,RBX
XOR ESI,ESI
POP RBX
POP R14
POP RBP
JMP 0x005cadb4
|
/* THD::awake_no_mutex(killed_state) */
void __thiscall THD::awake_no_mutex(THD *this,int param_2)
{
code *pcVar1;
THD *pTVar2;
print_aborted_warning(this,3,"KILLED");
if (0xb < *(int *)(this + 0x3ebc)) {
param_2 = *(int *)(this + 0x3ebc);
}
if (*(int *)(this + 0x3ebc) <= param_2) {
*(int *)(this + 0x3ebc) = param_2;
}
if (0xb < param_2 || param_2 == 0) {
pTVar2 = (THD *)_current_thd();
if (((pTVar2 != this) && (*(long *)(this + 0x3e48) != shutdown_thread_id)) &&
(*(long *)(this + 0x3a38) != 0)) {
(**(code **)(*(long *)(this + 0x3a38) + 0x1c0))();
}
thr_alarm_kill(*(int8 *)(this + 0x3e48));
if (((this[0x3fb3] == (THD)0x0) && (*(long *)(this + 0x588) != 0)) &&
(pcVar1 = *(code **)(*(long *)(this + 0x588) + 0x38), pcVar1 != (code *)0x0)) {
(*pcVar1)(this);
}
}
if ((param_2 != 0) && ((*(long *)(this + 0x65a8) == -1 || (*(int *)(this + 0x65d8) == 0)))) {
thd_kill_level(this);
ha_kill_query(this);
}
abort_current_cond_wait(this,false);
return;
}
|
|
57,795
|
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int)
|
AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc
|
void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("%s from %s ran.",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
if (GTEST_FLAG_GET(print_time)) {
printf(" (%s ms total)",
internal::StreamableToString(unit_test.elapsed_time()).c_str());
}
printf("\n");
ColoredPrintf(GTestColor::kGreen, "[ PASSED ] ");
printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
const int skipped_test_count = unit_test.skipped_test_count();
if (skipped_test_count > 0) {
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
printf("%s, listed below:\n", FormatTestCount(skipped_test_count).c_str());
PrintSkippedTests(unit_test);
}
if (!unit_test.Passed()) {
PrintFailedTests(unit_test);
PrintFailedTestSuites(unit_test);
}
int num_disabled = unit_test.reportable_disabled_test_count();
if (num_disabled && !GTEST_FLAG_GET(also_run_disabled_tests)) {
if (unit_test.Passed()) {
printf("\n"); // Add a spacer if no FAILURE banner is displayed.
}
ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n",
num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
}
// Ensure that Google Test output is printed before, e.g., heapchecker output.
fflush(stdout);
}
|
O0
|
cpp
|
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int):
subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movl %edx, 0x104(%rsp)
leaq 0x49e47(%rip), %rsi # 0x11399c
xorl %eax, %eax
movl $0x2, %edi
callq 0xc83b0
movq 0x108(%rsp), %rdi
callq 0xc8de0
movl %eax, %esi
leaq 0xe0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xc8da0
movq 0x28(%rsp), %rdi
callq 0x1acc0
movq %rax, 0x30(%rsp)
movq 0x108(%rsp), %rdi
callq 0xc8e40
movl %eax, 0x38(%rsp)
jmp 0xc9ba4
movl 0x38(%rsp), %esi
leaq 0xc0(%rsp), %rdi
callq 0xc8e00
jmp 0xc9bb7
leaq 0xc0(%rsp), %rdi
callq 0x1acc0
movq 0x30(%rsp), %rsi
movq %rax, %rdx
leaq 0x49f44(%rip), %rdi # 0x113b17
xorl %eax, %eax
callq 0x14060
jmp 0xc9bdc
leaq 0xc0(%rsp), %rdi
callq 0x1aac0
leaq 0xe0(%rsp), %rdi
callq 0x1aac0
leaq 0xaefc4(%rip), %rax # 0x178bc1
testb $0x1, (%rax)
je 0xc9cd0
movq 0x108(%rsp), %rdi
callq 0xc9ed0
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x88(%rsp), %rsi
callq 0xe9000
movq 0x20(%rsp), %rdi
callq 0x1acc0
movq %rax, %rsi
leaq 0x49ede(%rip), %rdi # 0x113b27
xorl %eax, %eax
callq 0x14060
jmp 0xc9c52
leaq 0x90(%rsp), %rdi
callq 0x1aac0
jmp 0xc9cd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0xc9c98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x1aac0
leaq 0xe0(%rsp), %rdi
callq 0x1aac0
jmp 0xc9eb7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x1aac0
jmp 0xc9eb7
leaq 0x49d9c(%rip), %rdi # 0x113a73
xorl %eax, %eax
movb %al, 0x1f(%rsp)
callq 0x14060
movb 0x1f(%rsp), %al
leaq 0x49e49(%rip), %rsi # 0x113b36
movl $0x2, %edi
callq 0xc83b0
movq 0x108(%rsp), %rdi
callq 0xc9ef0
movl %eax, %esi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xc8da0
movq 0x10(%rsp), %rdi
callq 0x1acc0
movq %rax, %rsi
movb 0x1f(%rsp), %al
leaq 0x49c35(%rip), %rdi # 0x113962
callq 0x14060
jmp 0xc9d34
leaq 0x68(%rsp), %rdi
callq 0x1aac0
movq 0x108(%rsp), %rdi
callq 0xc9b10
movl %eax, 0x64(%rsp)
cmpl $0x0, 0x64(%rsp)
jle 0xc9e00
leaq 0x49cd3(%rip), %rsi # 0x113a34
xorl %eax, %eax
movb %al, 0xf(%rsp)
movl $0x2, %edi
callq 0xc83b0
movl 0x64(%rsp), %esi
leaq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xc8da0
movq (%rsp), %rdi
callq 0x1acc0
movq %rax, %rsi
movb 0xf(%rsp), %al
leaq 0x49cfe(%rip), %rdi # 0x113a98
callq 0x14060
jmp 0xc9da1
leaq 0x40(%rsp), %rdi
callq 0x1aac0
movq 0x108(%rsp), %rdi
callq 0xc99b0
jmp 0xc9e00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1aac0
jmp 0xc9eb7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1aac0
jmp 0xc9eb7
movq 0x108(%rsp), %rdi
callq 0xc9f10
testb $0x1, %al
jne 0xc9e2b
movq 0x108(%rsp), %rdi
callq 0xc9640
movq 0x108(%rsp), %rdi
callq 0xc98b0
movq 0x108(%rsp), %rdi
callq 0xc9f30
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0xc9ea0
leaq 0xaed09(%rip), %rax # 0x178b53
testb $0x1, (%rax)
jne 0xc9ea0
movq 0x108(%rsp), %rdi
callq 0xc9f10
testb $0x1, %al
jne 0xc9e62
jmp 0xc9e70
leaq 0x49c0a(%rip), %rdi # 0x113a73
movb $0x0, %al
callq 0x14060
movl 0x3c(%rsp), %edx
movl 0x3c(%rsp), %esi
leaq 0x49c47(%rip), %rcx # 0x113ac6
leaq 0x49c3b(%rip), %rax # 0x113ac1
cmpl $0x1, %esi
cmoveq %rax, %rcx
movl $0x3, %edi
leaq 0x49cab(%rip), %rsi # 0x113b44
movb $0x0, %al
callq 0xc83b0
movq 0xae069(%rip), %rax # 0x177f10
movq (%rax), %rdi
callq 0x14810
addq $0x118, %rsp # imm = 0x118
retq
movq 0xb8(%rsp), %rdi
callq 0x14c80
nopw %cs:(%rax,%rax)
|
_ZN7testing8internal27PrettyUnitTestResultPrinter18OnTestIterationEndERKNS_8UnitTestEi:
sub rsp, 118h
mov [rsp+118h+var_8], rdi
mov [rsp+118h+var_10], rsi
mov [rsp+118h+var_14], edx
lea rsi, asc_11399C; "[==========] "
xor eax, eax
mov edi, 2
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest17test_to_run_countEv; testing::UnitTest::test_to_run_count(void)
mov esi, eax
lea rdi, [rsp+118h+var_38]
mov [rsp+118h+var_F0], rdi
call _ZN7testingL15FormatTestCountB5cxx11Ei; testing::FormatTestCount(int)
mov rdi, [rsp+118h+var_F0]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov [rsp+118h+var_E8], rax
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest23test_suite_to_run_countEv; testing::UnitTest::test_suite_to_run_count(void)
mov [rsp+118h+var_E0], eax
jmp short $+2
loc_C9BA4:
mov esi, [rsp+118h+var_E0]
lea rdi, [rsp+118h+var_58]
call _ZN7testingL20FormatTestSuiteCountB5cxx11Ei; testing::FormatTestSuiteCount(int)
jmp short $+2
loc_C9BB7:
lea rdi, [rsp+118h+var_58]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rsi, [rsp+118h+var_E8]
mov rdx, rax
lea rdi, aSFromSRan; "%s from %s ran."
xor eax, eax
call _printf
jmp short $+2
loc_C9BDC:
lea rdi, [rsp+118h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rax, _ZN7testing22FLAGS_gtest_print_timeE; testing::FLAGS_gtest_print_time
test byte ptr [rax], 1
jz loc_C9CD0
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest12elapsed_timeEv; testing::UnitTest::elapsed_time(void)
mov [rsp+118h+var_90], rax
lea rdi, [rsp+118h+var_88]
mov [rsp+118h+var_F8], rdi
lea rsi, [rsp+118h+var_90]
call _ZN7testing8internal18StreamableToStringIlEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::internal::StreamableToString<long>(long const&)
mov rdi, [rsp+118h+var_F8]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rsi, rax
lea rdi, aSMsTotal; " (%s ms total)"
xor eax, eax
call _printf
jmp short $+2
loc_C9C52:
lea rdi, [rsp+118h+var_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_C9CD0
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
jmp short loc_C9C98
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
lea rdi, [rsp+arg_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_C9C98:
lea rdi, [rsp+arg_D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_C9EB7
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
lea rdi, [rsp+arg_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_C9EB7
loc_C9CD0:
lea rdi, aSFromSSMsTotal+19h; "\n"
xor eax, eax
mov [rsp+118h+var_F9], al
call _printf
mov al, [rsp+118h+var_F9]
lea rsi, aPassed; "[ PASSED ] "
mov edi, 2
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest21successful_test_countEv; testing::UnitTest::successful_test_count(void)
mov esi, eax
lea rdi, [rsp+118h+var_B0]
mov [rsp+118h+var_108], rdi
call _ZN7testingL15FormatTestCountB5cxx11Ei; testing::FormatTestCount(int)
mov rdi, [rsp+118h+var_108]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rsi, rax; testing::UnitTest *
mov al, [rsp+118h+var_F9]
lea rdi, aNoteThisIsTest+1Fh; "%s.\n"
call _printf
jmp short $+2
loc_C9D34:
lea rdi, [rsp+118h+var_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest18skipped_test_countEv; testing::UnitTest::skipped_test_count(void)
mov [rsp+118h+var_B4], eax
cmp [rsp+118h+var_B4], 0
jle loc_C9E00
lea rsi, aSkipped_0; "[ SKIPPED ] "
xor eax, eax
mov [rsp+118h+var_109], al
mov edi, 2
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
mov esi, [rsp+118h+var_B4]
lea rdi, [rsp+118h+var_D8]
mov [rsp+118h+var_118], rdi
call _ZN7testingL15FormatTestCountB5cxx11Ei; testing::FormatTestCount(int)
mov rdi, [rsp+118h+var_118]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rsi, rax; testing::UnitTest *
mov al, [rsp+118h+var_109]
lea rdi, aSListedBelow; "%s, listed below:\n"
call _printf
jmp short $+2
loc_C9DA1:
lea rdi, [rsp+118h+var_D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+118h+var_10]; this
call _ZN7testing8internal27PrettyUnitTestResultPrinter17PrintSkippedTestsERKNS_8UnitTestE; testing::internal::PrettyUnitTestResultPrinter::PrintSkippedTests(testing::UnitTest const&)
jmp short loc_C9E00
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
lea rdi, [rsp+arg_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_C9EB7
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
lea rdi, [rsp+arg_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_C9EB7
loc_C9E00:
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest6PassedEv; testing::UnitTest::Passed(void)
test al, 1
jnz short loc_C9E2B
mov rdi, [rsp+118h+var_10]; this
call _ZN7testing8internal27PrettyUnitTestResultPrinter16PrintFailedTestsERKNS_8UnitTestE; testing::internal::PrettyUnitTestResultPrinter::PrintFailedTests(testing::UnitTest const&)
mov rdi, [rsp+118h+var_10]; this
call _ZN7testing8internal27PrettyUnitTestResultPrinter21PrintFailedTestSuitesERKNS_8UnitTestE; testing::internal::PrettyUnitTestResultPrinter::PrintFailedTestSuites(testing::UnitTest const&)
loc_C9E2B:
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest30reportable_disabled_test_countEv; testing::UnitTest::reportable_disabled_test_count(void)
mov [rsp+118h+var_DC], eax
cmp [rsp+118h+var_DC], 0
jz short loc_C9EA0
lea rax, _ZN7testing35FLAGS_gtest_also_run_disabled_testsE; testing::FLAGS_gtest_also_run_disabled_tests
test byte ptr [rax], 1
jnz short loc_C9EA0
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest6PassedEv; testing::UnitTest::Passed(void)
test al, 1
jnz short loc_C9E62
jmp short loc_C9E70
loc_C9E62:
lea rdi, aSFromSSMsTotal+19h; "\n"
mov al, 0
call _printf
loc_C9E70:
mov edx, [rsp+118h+var_DC]
mov esi, [rsp+118h+var_DC]
lea rcx, aTests; "TESTS"
lea rax, aTest_0; "TEST"
cmp esi, 1
cmovz rcx, rax
mov edi, 3
lea rsi, aYouHaveDDisabl; " YOU HAVE %d DISABLED %s\n\n"
mov al, 0
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
loc_C9EA0:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
add rsp, 118h
retn
loc_C9EB7:
mov rdi, [rsp+arg_B0]
call __Unwind_Resume
|
long long testing::internal::PrettyUnitTestResultPrinter::OnTestIterationEnd(
testing::internal::PrettyUnitTestResultPrinter *this,
const testing::UnitTest *a2,
int a3)
{
unsigned int v3; // eax
const char *v4; // rax
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
const char *v9; // rax
unsigned int v10; // eax
const char *v11; // rsi
const char *v12; // rcx
int v14; // [rsp+0h] [rbp-118h]
int v15; // [rsp+8h] [rbp-110h]
const char *v16; // [rsp+30h] [rbp-E8h]
unsigned int v17; // [rsp+38h] [rbp-E0h]
int v18; // [rsp+3Ch] [rbp-DCh]
_BYTE v19[36]; // [rsp+40h] [rbp-D8h] BYREF
int v20; // [rsp+64h] [rbp-B4h]
_BYTE v21[32]; // [rsp+68h] [rbp-B0h] BYREF
long long v22; // [rsp+88h] [rbp-90h] BYREF
_BYTE v23[48]; // [rsp+90h] [rbp-88h] BYREF
_BYTE v24[32]; // [rsp+C0h] [rbp-58h] BYREF
_BYTE v25[36]; // [rsp+E0h] [rbp-38h] BYREF
int v26; // [rsp+104h] [rbp-14h]
testing::UnitTest *v27; // [rsp+108h] [rbp-10h]
testing::internal::PrettyUnitTestResultPrinter *v28; // [rsp+110h] [rbp-8h]
v28 = this;
v27 = a2;
v26 = a3;
testing::internal::ColoredPrintf(2u, (long long)"[==========] ");
v3 = testing::UnitTest::test_to_run_count(a2);
testing::FormatTestCount[abi:cxx11](v25, v3);
v16 = (const char *)std::string::c_str((long long)v25);
v17 = testing::UnitTest::test_suite_to_run_count(v27);
testing::FormatTestSuiteCount[abi:cxx11](v24, v17);
v4 = (const char *)std::string::c_str((long long)v24);
printf("%s from %s ran.", v16, v4);
std::string::~string(v24);
std::string::~string(v25);
if ( (testing::FLAGS_gtest_print_time & 1) != 0 )
{
v22 = testing::UnitTest::elapsed_time(v27);
testing::internal::StreamableToString<long>((unsigned int)v23, (unsigned int)&v22, v5, v6, v7, v8, v14, v15);
v9 = (const char *)std::string::c_str((long long)v23);
printf(" (%s ms total)", v9);
std::string::~string(v23);
}
printf("\n");
testing::internal::ColoredPrintf(2u, (long long)"[ PASSED ] ");
v10 = testing::UnitTest::successful_test_count(v27);
testing::FormatTestCount[abi:cxx11](v21, v10);
v11 = (const char *)std::string::c_str((long long)v21);
printf("%s.\n", v11);
std::string::~string(v21);
v20 = testing::UnitTest::skipped_test_count(v27);
if ( v20 > 0 )
{
testing::internal::ColoredPrintf(2u, (long long)"[ SKIPPED ] ");
testing::FormatTestCount[abi:cxx11](v19, (unsigned int)v20);
v11 = (const char *)std::string::c_str((long long)v19);
printf("%s, listed below:\n", v11);
std::string::~string(v19);
testing::internal::PrettyUnitTestResultPrinter::PrintSkippedTests(v27, (const testing::UnitTest *)v11);
}
if ( (testing::UnitTest::Passed(v27) & 1) == 0 )
{
testing::internal::PrettyUnitTestResultPrinter::PrintFailedTests(v27, (const testing::UnitTest *)v11);
testing::internal::PrettyUnitTestResultPrinter::PrintFailedTestSuites(v27, (const testing::UnitTest *)v11);
}
v18 = testing::UnitTest::reportable_disabled_test_count(v27);
if ( v18 && (testing::FLAGS_gtest_also_run_disabled_tests & 1) == 0 )
{
if ( (testing::UnitTest::Passed(v27) & 1) != 0 )
printf("\n");
v12 = "TESTS";
if ( v18 == 1 )
v12 = "TEST";
testing::internal::ColoredPrintf(3u, (long long)" YOU HAVE %d DISABLED %s\n\n", v18, v12);
}
return fflush(stdout);
}
|
OnTestIterationEnd:
SUB RSP,0x118
MOV qword ptr [RSP + 0x110],RDI
MOV qword ptr [RSP + 0x108],RSI
MOV dword ptr [RSP + 0x104],EDX
LEA RSI,[0x21399c]
XOR EAX,EAX
MOV EDI,0x2
CALL 0x001c83b0
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001c8de0
MOV ESI,EAX
LEA RDI,[RSP + 0xe0]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x001c8da0
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0011acc0
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x108]
LAB_001c9b99:
CALL 0x001c8e40
MOV dword ptr [RSP + 0x38],EAX
JMP 0x001c9ba4
LAB_001c9ba4:
MOV ESI,dword ptr [RSP + 0x38]
LEA RDI,[RSP + 0xc0]
CALL 0x001c8e00
JMP 0x001c9bb7
LAB_001c9bb7:
LEA RDI,[RSP + 0xc0]
CALL 0x0011acc0
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,RAX
LAB_001c9bcc:
LEA RDI,[0x213b17]
XOR EAX,EAX
CALL 0x00114060
LAB_001c9bda:
JMP 0x001c9bdc
LAB_001c9bdc:
LEA RDI,[RSP + 0xc0]
CALL 0x0011aac0
LEA RDI,[RSP + 0xe0]
CALL 0x0011aac0
LEA RAX,[0x278bc1]
TEST byte ptr [RAX],0x1
JZ 0x001c9cd0
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001c9ed0
MOV qword ptr [RSP + 0x88],RAX
LEA RDI,[RSP + 0x90]
MOV qword ptr [RSP + 0x20],RDI
LEA RSI,[RSP + 0x88]
CALL 0x001e9000
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x0011acc0
MOV RSI,RAX
LAB_001c9c42:
LEA RDI,[0x213b27]
XOR EAX,EAX
CALL 0x00114060
LAB_001c9c50:
JMP 0x001c9c52
LAB_001c9c52:
LEA RDI,[RSP + 0x90]
CALL 0x0011aac0
JMP 0x001c9cd0
LAB_001c9cd0:
LEA RDI,[0x213a73]
XOR EAX,EAX
MOV byte ptr [RSP + 0x1f],AL
CALL 0x00114060
MOV AL,byte ptr [RSP + 0x1f]
LEA RSI,[0x213b36]
MOV EDI,0x2
CALL 0x001c83b0
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001c9ef0
MOV ESI,EAX
LEA RDI,[RSP + 0x68]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x001c8da0
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0011acc0
MOV RSI,RAX
MOV AL,byte ptr [RSP + 0x1f]
LAB_001c9d26:
LEA RDI,[0x213962]
CALL 0x00114060
LAB_001c9d32:
JMP 0x001c9d34
LAB_001c9d34:
LEA RDI,[RSP + 0x68]
CALL 0x0011aac0
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001c9b10
MOV dword ptr [RSP + 0x64],EAX
CMP dword ptr [RSP + 0x64],0x0
JLE 0x001c9e00
LEA RSI,[0x213a34]
XOR EAX,EAX
MOV byte ptr [RSP + 0xf],AL
MOV EDI,0x2
CALL 0x001c83b0
MOV ESI,dword ptr [RSP + 0x64]
LEA RDI,[RSP + 0x40]
MOV qword ptr [RSP],RDI
CALL 0x001c8da0
MOV RDI,qword ptr [RSP]
CALL 0x0011acc0
MOV RSI,RAX
MOV AL,byte ptr [RSP + 0xf]
LAB_001c9d93:
LEA RDI,[0x213a98]
CALL 0x00114060
LAB_001c9d9f:
JMP 0x001c9da1
LAB_001c9da1:
LEA RDI,[RSP + 0x40]
CALL 0x0011aac0
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001c99b0
JMP 0x001c9e00
LAB_001c9e00:
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001c9f10
TEST AL,0x1
JNZ 0x001c9e2b
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001c9640
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001c98b0
LAB_001c9e2b:
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001c9f30
MOV dword ptr [RSP + 0x3c],EAX
CMP dword ptr [RSP + 0x3c],0x0
JZ 0x001c9ea0
LEA RAX,[0x278b53]
TEST byte ptr [RAX],0x1
JNZ 0x001c9ea0
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001c9f10
TEST AL,0x1
JNZ 0x001c9e62
JMP 0x001c9e70
LAB_001c9e62:
LEA RDI,[0x213a73]
MOV AL,0x0
CALL 0x00114060
LAB_001c9e70:
MOV EDX,dword ptr [RSP + 0x3c]
MOV ESI,dword ptr [RSP + 0x3c]
LEA RCX,[0x213ac6]
LEA RAX,[0x213ac1]
CMP ESI,0x1
CMOVZ RCX,RAX
MOV EDI,0x3
LEA RSI,[0x213b44]
MOV AL,0x0
CALL 0x001c83b0
LAB_001c9ea0:
MOV RAX,qword ptr [0x00277f10]
MOV RDI,qword ptr [RAX]
CALL 0x00114810
ADD RSP,0x118
RET
|
/* testing::internal::PrettyUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int)
*/
void __thiscall
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationEnd
(PrettyUnitTestResultPrinter *this,UnitTest *param_1,int param_2)
{
int iVar1;
int8 uVar2;
int8 uVar3;
ulong uVar4;
char *pcVar5;
testing local_d8 [36];
int local_b4;
testing local_b0 [32];
long local_90;
internal local_88 [48];
testing local_58 [32];
testing local_38 [36];
int local_14;
UnitTest *local_10;
PrettyUnitTestResultPrinter *local_8;
local_14 = param_2;
local_10 = param_1;
local_8 = this;
ColoredPrintf(2,"[==========] ");
iVar1 = UnitTest::test_to_run_count(local_10);
FormatTestCount_abi_cxx11_(local_38,iVar1);
uVar2 = std::__cxx11::string::c_str((string *)local_38);
/* try { // try from 001c9b99 to 001c9bb4 has its CatchHandler @ 001c9c61 */
iVar1 = UnitTest::test_suite_to_run_count(local_10);
FormatTestSuiteCount_abi_cxx11_(local_58,iVar1);
uVar3 = std::__cxx11::string::c_str((string *)local_58);
/* try { // try from 001c9bcc to 001c9bd9 has its CatchHandler @ 001c9c77 */
printf("%s from %s ran.",uVar2,uVar3);
std::__cxx11::string::~string((string *)local_58);
std::__cxx11::string::~string((string *)local_38);
if ((FLAGS_gtest_print_time & 1) != 0) {
local_90 = UnitTest::elapsed_time(local_10);
StreamableToString<long>(local_88,&local_90);
uVar2 = std::__cxx11::string::c_str((string *)local_88);
/* try { // try from 001c9c42 to 001c9c4f has its CatchHandler @ 001c9caa */
printf(" (%s ms total)",uVar2);
std::__cxx11::string::~string((string *)local_88);
}
printf("\n");
ColoredPrintf(2,"[ PASSED ] ");
iVar1 = UnitTest::successful_test_count(local_10);
FormatTestCount_abi_cxx11_(local_b0,iVar1);
uVar2 = std::__cxx11::string::c_str((string *)local_b0);
/* try { // try from 001c9d26 to 001c9d31 has its CatchHandler @ 001c9dba */
printf("%s.\n",uVar2);
std::__cxx11::string::~string((string *)local_b0);
local_b4 = UnitTest::skipped_test_count(local_10);
if (0 < local_b4) {
ColoredPrintf(2,"[ SKIPPED ] ");
FormatTestCount_abi_cxx11_(local_d8,local_b4);
uVar2 = std::__cxx11::string::c_str((string *)local_d8);
/* try { // try from 001c9d93 to 001c9d9e has its CatchHandler @ 001c9ddd */
printf("%s, listed below:\n",uVar2);
std::__cxx11::string::~string((string *)local_d8);
PrintSkippedTests(local_10);
}
uVar4 = UnitTest::Passed(local_10);
if ((uVar4 & 1) == 0) {
PrintFailedTests(local_10);
PrintFailedTestSuites(local_10);
}
iVar1 = UnitTest::reportable_disabled_test_count(local_10);
if ((iVar1 != 0) && ((FLAGS_gtest_also_run_disabled_tests & 1) == 0)) {
uVar4 = UnitTest::Passed(local_10);
if ((uVar4 & 1) != 0) {
printf("\n");
}
pcVar5 = "TESTS";
if (iVar1 == 1) {
pcVar5 = "TEST";
}
ColoredPrintf(3," YOU HAVE %d DISABLED %s\n\n",iVar1,pcVar5);
}
fflush(*(FILE **)PTR_stdout_00277f10);
return;
}
|
|
57,796
|
stbi__tga_read_rgb16(stbi__context*, unsigned char*)
|
monkey531[P]llama/examples/llava/../../common/stb_image.h
|
static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
{
stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
stbi__uint16 fiveBitMask = 31;
// we have 3 channels with 5bits each
int r = (px >> 10) & fiveBitMask;
int g = (px >> 5) & fiveBitMask;
int b = px & fiveBitMask;
// Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
out[0] = (stbi_uc)((r * 255)/31);
out[1] = (stbi_uc)((g * 255)/31);
out[2] = (stbi_uc)((b * 255)/31);
// some people claim that the most significant bit might be used for alpha
// (possibly if an alpha-bit is set in the "image descriptor byte")
// but that only made 16bit test images completely translucent..
// so let's treat all 15 and 16bit TGAs as RGB with no alpha.
}
|
O0
|
c
|
stbi__tga_read_rgb16(stbi__context*, unsigned char*):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x945c0
movw %ax, 0x16(%rsp)
movw $0x1f, 0x14(%rsp)
movzwl 0x16(%rsp), %eax
sarl $0xa, %eax
movzwl 0x14(%rsp), %ecx
andl %ecx, %eax
movl %eax, 0x10(%rsp)
movzwl 0x16(%rsp), %eax
sarl $0x5, %eax
movzwl 0x14(%rsp), %ecx
andl %ecx, %eax
movl %eax, 0xc(%rsp)
movzwl 0x16(%rsp), %eax
movzwl 0x14(%rsp), %ecx
andl %ecx, %eax
movl %eax, 0x8(%rsp)
imull $0xff, 0x10(%rsp), %eax
movl $0x1f, %ecx
cltd
idivl %ecx
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
imull $0xff, 0xc(%rsp), %eax
movl $0x1f, %ecx
cltd
idivl %ecx
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, 0x1(%rax)
imull $0xff, 0x8(%rsp), %eax
movl $0x1f, %ecx
cltd
idivl %ecx
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, 0x2(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
|
_ZL20stbi__tga_read_rgb16P13stbi__contextPh:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov rdi, [rsp+28h+var_8]
call _ZL13stbi__get16leP13stbi__context; stbi__get16le(stbi__context *)
mov [rsp+28h+var_12], ax
mov [rsp+28h+var_14], 1Fh
movzx eax, [rsp+28h+var_12]
sar eax, 0Ah
movzx ecx, [rsp+28h+var_14]
and eax, ecx
mov [rsp+28h+var_18], eax
movzx eax, [rsp+28h+var_12]
sar eax, 5
movzx ecx, [rsp+28h+var_14]
and eax, ecx
mov [rsp+28h+var_1C], eax
movzx eax, [rsp+28h+var_12]
movzx ecx, [rsp+28h+var_14]
and eax, ecx
mov [rsp+28h+var_20], eax
imul eax, [rsp+28h+var_18], 0FFh
mov ecx, 1Fh
cdq
idiv ecx
mov cl, al
mov rax, [rsp+28h+var_10]
mov [rax], cl
imul eax, [rsp+28h+var_1C], 0FFh
mov ecx, 1Fh
cdq
idiv ecx
mov cl, al
mov rax, [rsp+28h+var_10]
mov [rax+1], cl
imul eax, [rsp+28h+var_20], 0FFh
mov ecx, 1Fh
cdq
idiv ecx
mov cl, al
mov rax, [rsp+28h+var_10]
mov [rax+2], cl
add rsp, 28h
retn
|
_BYTE * stbi__tga_read_rgb16(long long a1, _BYTE *a2)
{
unsigned __int16 v2; // ax
char v3; // cl
_BYTE *result; // rax
v2 = stbi__get16le(a1);
*a2 = 255 * (((int)v2 >> 10) & 0x1F) / 31;
a2[1] = 255 * (((int)v2 >> 5) & 0x1F) / 31;
v3 = 255 * (v2 & 0x1F) / 31;
result = a2;
a2[2] = v3;
return result;
}
|
stbi__tga_read_rgb16:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x001945c0
MOV word ptr [RSP + 0x16],AX
MOV word ptr [RSP + 0x14],0x1f
MOVZX EAX,word ptr [RSP + 0x16]
SAR EAX,0xa
MOVZX ECX,word ptr [RSP + 0x14]
AND EAX,ECX
MOV dword ptr [RSP + 0x10],EAX
MOVZX EAX,word ptr [RSP + 0x16]
SAR EAX,0x5
MOVZX ECX,word ptr [RSP + 0x14]
AND EAX,ECX
MOV dword ptr [RSP + 0xc],EAX
MOVZX EAX,word ptr [RSP + 0x16]
MOVZX ECX,word ptr [RSP + 0x14]
AND EAX,ECX
MOV dword ptr [RSP + 0x8],EAX
IMUL EAX,dword ptr [RSP + 0x10],0xff
MOV ECX,0x1f
CDQ
IDIV ECX
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x18]
MOV byte ptr [RAX],CL
IMUL EAX,dword ptr [RSP + 0xc],0xff
MOV ECX,0x1f
CDQ
IDIV ECX
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x18]
MOV byte ptr [RAX + 0x1],CL
IMUL EAX,dword ptr [RSP + 0x8],0xff
MOV ECX,0x1f
CDQ
IDIV ECX
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x18]
MOV byte ptr [RAX + 0x2],CL
ADD RSP,0x28
RET
|
/* stbi__tga_read_rgb16(stbi__context*, unsigned char*) */
void stbi__tga_read_rgb16(stbi__context *param_1,uchar *param_2)
{
ushort uVar1;
uVar1 = stbi__get16le(param_1);
*param_2 = (uchar)((ulong)(long)(int)(((int)(uint)uVar1 >> 10 & 0x1fU) * 0xff) / 0x1f);
param_2[1] = (uchar)((ulong)(long)(int)(((int)(uint)uVar1 >> 5 & 0x1fU) * 0xff) / 0x1f);
param_2[2] = (uchar)((ulong)(long)(int)((uint)(uVar1 & 0x1f) * 0xff) / 0x1f);
return;
}
|
|
57,797
|
my_hash_sort_utf8mb4_nopad
|
eloqsql/strings/ctype-utf8.c
|
static void
my_hash_sort_utf8mb4_nopad(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
int res;
const uchar *e= s + slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((res= my_mb_wc_utf8mb4(cs, &wc, (uchar*) s, (uchar*) e)) > 0)
{
my_tosort_unicode(uni_plane, &wc, cs->state);
MY_HASH_ADD_16(m1, m2, (uint) (wc & 0xFFFF));
if (wc > 0xFFFF)
{
/*
Put the highest byte only if it is non-zero,
to make hash functions for utf8mb3 and utf8mb4
compatible for BMP characters.
This is useful to keep order of records in
test results, e.g. for "SHOW GRANTS".
*/
MY_HASH_ADD(m1, m2, (uint) ((wc >> 16) & 0xFF));
}
s+= res;
}
*nr1= m1;
*nr2= m2;
}
|
O0
|
c
|
my_hash_sort_utf8mb4_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x6b400
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0x7047a
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
leaq -0x30(%rbp), %rsi
callq 0x6bb20
jmp 0x70391
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
andq $0xffff, %rcx # imm = 0xFFFF
andl $0xff, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x703d5
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
andq $0xffff, %rcx # imm = 0xFFFF
shrl $0x8, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x70416
cmpq $0xffff, -0x30(%rbp) # imm = 0xFFFF
jbe 0x70464
jmp 0x70422
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x10, %rcx
andq $0xff, %rcx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x70464
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x7035a
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_hash_sort_utf8mb4_nopad:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_58], rax
loc_7035A:
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_mb_wc_utf8mb4
mov [rbp+var_34], eax
cmp eax, 0
jle loc_7047A
mov rdi, [rbp+var_48]
mov rax, [rbp+var_8]
mov edx, [rax+0Ch]
lea rsi, [rbp+var_30]
call my_tosort_unicode
jmp short $+2
loc_70391:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
and rcx, 0FFFFh
and ecx, 0FFh
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_703D5:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
and rcx, 0FFFFh
shr ecx, 8
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_70416:
cmp [rbp+var_30], 0FFFFh
jbe short loc_70464
jmp short $+2
loc_70422:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
shr rcx, 10h
and rcx, 0FFh
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_70464:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp loc_7035A
loc_7047A:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_58]
mov rax, [rbp+var_28]
mov [rax], rcx
add rsp, 60h
pop rbp
retn
|
_QWORD * my_hash_sort_utf8mb4_nopad(long long a1, long long a2, long long a3, long long *a4, _QWORD *a5, long long a6)
{
_QWORD *result; // rax
long long v7; // [rsp+8h] [rbp-58h]
long long v8; // [rsp+8h] [rbp-58h]
long long v9; // [rsp+10h] [rbp-50h]
long long v10; // [rsp+10h] [rbp-50h]
_QWORD *v11; // [rsp+18h] [rbp-48h]
long long v12; // [rsp+20h] [rbp-40h]
int v13; // [rsp+2Ch] [rbp-34h]
unsigned long long v14; // [rsp+30h] [rbp-30h] BYREF
_QWORD *v15; // [rsp+38h] [rbp-28h]
long long *v16; // [rsp+40h] [rbp-20h]
long long v17; // [rsp+48h] [rbp-18h]
long long v18; // [rsp+50h] [rbp-10h]
long long v19; // [rsp+58h] [rbp-8h]
v19 = a1;
v18 = a2;
v17 = a3;
v16 = a4;
v15 = a5;
v12 = a3 + a2;
v11 = *(_QWORD **)(a1 + 120);
v9 = *a4;
v7 = *a5;
while ( 1 )
{
v13 = my_mb_wc_utf8mb4(v19, (long long)&v14, v18, v12, (long long)a5, a6);
if ( v13 <= 0 )
break;
my_tosort_unicode(v11, &v14, *(_DWORD *)(v19 + 12));
v10 = v9 ^ ((v9 << 8) + (unsigned __int8)v14 * (v7 + (v9 & 0x3F)));
v8 = v7 + 3;
v9 = v10 ^ ((v10 << 8) + BYTE1(v14) * (v8 + (v10 & 0x3F)));
v7 = v8 + 3;
if ( v14 > 0xFFFF )
{
v9 ^= (v9 << 8) + BYTE2(v14) * (v7 + (v9 & 0x3F));
v7 += 3LL;
}
v18 += v13;
}
*v16 = v9;
result = v15;
*v15 = v7;
return result;
}
|
my_hash_sort_utf8mb4_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
LAB_0017035a:
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x0016b400
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x0017047a
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RAX + 0xc]
LEA RSI,[RBP + -0x30]
CALL 0x0016bb20
JMP 0x00170391
LAB_00170391:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
AND RCX,0xffff
AND ECX,0xff
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001703d5
LAB_001703d5:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
AND RCX,0xffff
SHR ECX,0x8
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00170416
LAB_00170416:
CMP qword ptr [RBP + -0x30],0xffff
JBE 0x00170464
JMP 0x00170422
LAB_00170422:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x10
AND RCX,0xff
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00170464
LAB_00170464:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0017035a
LAB_0017047a:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
ADD RSP,0x60
POP RBP
RET
|
void my_hash_sort_utf8mb4_nopad(long param_1,long param_2,long param_3,ulong *param_4,long *param_5)
{
int8 uVar1;
long lVar2;
int iVar3;
long local_60;
ulong local_58;
ulong local_38;
long *local_30;
ulong *local_28;
long local_20;
long local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_58 = *param_4;
local_60 = *param_5;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
iVar3 = my_mb_wc_utf8mb4(local_10,&local_38,local_18,param_2 + param_3);
if (iVar3 < 1) break;
my_tosort_unicode(uVar1,&local_38,*(int4 *)(local_10 + 0xc));
local_58 = ((local_58 & 0x3f) + local_60) * (ulong)((uint)local_38 & 0xff) + local_58 * 0x100 ^
local_58;
local_58 = ((local_58 & 0x3f) + local_60 + 3) * (ulong)(((uint)local_38 & 0xffff) >> 8) +
local_58 * 0x100 ^ local_58;
lVar2 = local_60 + 6;
if (0xffff < local_38) {
local_58 = ((local_58 & 0x3f) + local_60 + 6) * (ulong)((uint)(local_38 >> 0x10) & 0xff) +
local_58 * 0x100 ^ local_58;
lVar2 = local_60 + 9;
}
local_60 = lVar2;
local_18 = local_18 + iVar3;
}
*local_28 = local_58;
*local_30 = local_60;
return;
}
|
|
57,798
|
list_add
|
eloqsql/mysys/list.c
|
LIST *list_add(LIST *root, LIST *element)
{
DBUG_ENTER("list_add");
DBUG_PRINT("enter",("root: %p element: %p", root, element));
if (root)
{
if (root->prev) /* If add in mid of list */
root->prev->next= element;
element->prev=root->prev;
root->prev=element;
}
else
element->prev=0;
element->next=root;
DBUG_RETURN(element); /* New root */
}
|
O0
|
c
|
list_add:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xe43ae
cmpq $0x0, -0x8(%rbp)
je 0xe43e9
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe43ce
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xe43f4
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nop
|
list_add:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_E43AE:
cmp [rbp+var_8], 0
jz short loc_E43E9
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz short loc_E43CE
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rax+8], rcx
loc_E43CE:
mov rax, [rbp+var_8]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax], rcx
jmp short loc_E43F4
loc_E43E9:
mov rax, [rbp+var_10]
mov qword ptr [rax], 0
loc_E43F4:
mov rcx, [rbp+var_8]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
pop rbp
retn
|
_QWORD * list_add(long long a1, _QWORD *a2)
{
if ( a1 )
{
if ( *(_QWORD *)a1 )
*(_QWORD *)(*(_QWORD *)a1 + 8LL) = a2;
*a2 = *(_QWORD *)a1;
*(_QWORD *)a1 = a2;
}
else
{
*a2 = 0LL;
}
a2[1] = a1;
return a2;
}
|
list_add:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x001e43ae
LAB_001e43ae:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x001e43e9
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX],0x0
JZ 0x001e43ce
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
LAB_001e43ce:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
JMP 0x001e43f4
LAB_001e43e9:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],0x0
LAB_001e43f4:
MOV RCX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET
|
long * list_add(long *param_1,long *param_2)
{
if (param_1 == (long *)0x0) {
*param_2 = 0;
}
else {
if (*param_1 != 0) {
*(long **)(*param_1 + 8) = param_2;
}
*param_2 = *param_1;
*param_1 = (long)param_2;
}
param_2[1] = (long)param_1;
return param_2;
}
|
|
57,799
|
minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!expr) throw std::runtime_error("UnaryOpExpr.expr is null");
auto e = expr->evaluate(context);
switch (op) {
case Op::Plus: return e;
case Op::Minus: return -e;
case Op::LogicalNot: return !e.to_bool();
case Op::Expansion:
case Op::ExpansionDict:
throw std::runtime_error("Expansion operator is only supported in function calls and collections");
}
throw std::runtime_error("Unknown unary operator");
}
|
O2
|
cpp
|
minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x6288a
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6298e
movl 0x30(%r14), %eax
cmpq $0x4, %rax
ja 0x628d6
leaq 0x4f0f9(%rip), %rcx # 0xb192c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x62ab8
jmp 0x62875
leaq 0x8(%rsp), %rdi
callq 0x62b64
xorb $0x1, %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x62c00
jmp 0x62875
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x62b10
leaq 0x8(%rsp), %rdi
callq 0x62c1e
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %r14
leaq 0x50364(%rip), %rsi # 0xb2c00
movq %rax, %rdi
callq 0x23310
movq 0x99745(%rip), %rsi # 0xfbff0
movq 0x996a6(%rip), %rdx # 0xfbf58
movq %r14, %rdi
callq 0x23ef0
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %r14
leaq 0x5034d(%rip), %rsi # 0xb2c19
movq %rax, %rdi
callq 0x23310
jmp 0x628f0
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %r14
leaq 0x50378(%rip), %rsi # 0xb2c60
movq %rax, %rdi
callq 0x23310
movq 0x996f9(%rip), %rsi # 0xfbff0
movq 0x9965a(%rip), %rdx # 0xfbf58
movq %r14, %rdi
callq 0x23ef0
jmp 0x6290a
jmp 0x62924
movq %rax, %rbx
movq %r14, %rdi
callq 0x23680
jmp 0x62927
movq %rax, %rbx
movq %r14, %rdi
callq 0x23680
jmp 0x62931
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62c1e
movq %rbx, %rdi
callq 0x23f80
nop
|
_ZNK5minja11UnaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push r14
push rbx
sub rsp, 58h
mov r14, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz short loc_6288A
mov rbx, rdi
lea rdi, [rsp+68h+var_60]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov eax, [r14+30h]
cmp rax, 4; switch 5 cases
ja def_6283A; jumptable 000000000006283A default case
lea rcx, jpt_6283A
movsxd rax, ds:(jpt_6283A - 0B192Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_6283C:
lea rsi, [rsp+68h+var_60]; jumptable 000000000006283A case 0
mov rdi, rbx
call _ZN5minja5ValueC2EOS0_; minja::Value::Value(minja::Value&&)
jmp short loc_62875
loc_6284B:
lea rdi, [rsp+68h+var_60]; jumptable 000000000006283A case 2
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
xor al, 1
lea rsi, [rsp+68h+var_61]; bool *
mov [rsi], al
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKb; minja::Value::Value(bool const&)
jmp short loc_62875
loc_62868:
lea rsi, [rsp+68h+var_60]; jumptable 000000000006283A case 1
mov rdi, rbx
call _ZNK5minja5ValuengEv; minja::Value::operator-(void)
loc_62875:
lea rdi, [rsp+68h+var_60]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rax, rbx
add rsp, 58h
pop rbx
pop r14
retn
loc_6288A:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnaryopexprExp; "UnaryOpExpr.expr is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_628BA:
push 10h; jumptable 000000000006283A cases 3,4
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpansionOpera; "Expansion operator is only supported in"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_628F0
def_6283A:
push 10h; jumptable 000000000006283A default case
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnknownUnaryOp; "Unknown unary operator"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_628F0:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_6290A
jmp short loc_62924
loc_6290A:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_62927
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_62931
loc_62924:
mov rbx, rax
loc_62927:
lea rdi, [rsp+68h+var_60]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_62931:
mov rdi, rbx
call __Unwind_Resume
|
minja::Value * minja::UnaryOpExpr::do_evaluate(
minja::Value *this,
long long a2,
int a3,
int a4,
int a5,
int a6)
{
long long v7; // rsi
std::runtime_error *exception; // r14
std::runtime_error *v10; // r14
bool v11; // [rsp+7h] [rbp-61h] BYREF
_BYTE v12[96]; // [rsp+8h] [rbp-60h] BYREF
v7 = *(_QWORD *)(a2 + 32);
if ( !v7 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "UnaryOpExpr.expr is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((unsigned int)v12, v7, a3, a4, a5, a6);
switch ( *(_DWORD *)(a2 + 48) )
{
case 0:
minja::Value::Value(this, v12);
goto LABEL_6;
case 1:
minja::Value::operator-(this);
goto LABEL_6;
case 2:
v11 = minja::Value::to_bool((minja::Value *)v12) ^ 1;
minja::Value::Value(this, &v11);
LABEL_6:
minja::Value::~Value((minja::Value *)v12);
return this;
case 3:
case 4:
v10 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v10, "Expansion operator is only supported in function calls and collections");
break;
default:
v10 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v10, "Unknown unary operator");
break;
}
__cxa_throw(
v10,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
|
do_evaluate:
PUSH R14
PUSH RBX
SUB RSP,0x58
MOV R14,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x0016288a
MOV RBX,RDI
LEA RDI,[RSP + 0x8]
CALL 0x0016298e
MOV EAX,dword ptr [R14 + 0x30]
CMP RAX,0x4
JA 0x001628d6
LEA RCX,[0x1b192c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00162ab8
JMP 0x00162875
caseD_2:
LEA RDI,[RSP + 0x8]
CALL 0x00162b64
XOR AL,0x1
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],AL
MOV RDI,RBX
CALL 0x00162c00
JMP 0x00162875
caseD_1:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00162b10
LAB_00162875:
LEA RDI,[RSP + 0x8]
CALL 0x00162c1e
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R14
RET
LAB_0016288a:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV R14,RAX
LAB_00162895:
LEA RSI,[0x1b2c00]
MOV RDI,RAX
CALL 0x00123310
LAB_001628a4:
MOV RSI,qword ptr [0x001fbff0]
MOV RDX,qword ptr [0x001fbf58]
MOV RDI,R14
CALL 0x00123ef0
caseD_3:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV R14,RAX
LAB_001628c5:
LEA RSI,[0x1b2c19]
MOV RDI,RAX
CALL 0x00123310
LAB_001628d4:
JMP 0x001628f0
default:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV R14,RAX
LAB_001628e1:
LEA RSI,[0x1b2c60]
MOV RDI,RAX
CALL 0x00123310
LAB_001628f0:
MOV RSI,qword ptr [0x001fbff0]
MOV RDX,qword ptr [0x001fbf58]
MOV RDI,R14
CALL 0x00123ef0
|
/* minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
UnaryOpExpr * __thiscall minja::UnaryOpExpr::do_evaluate(UnaryOpExpr *this,shared_ptr *param_1)
{
runtime_error *prVar1;
bool local_61;
Expression local_60 [80];
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00162895 to 001628a3 has its CatchHandler @ 00162917 */
std::runtime_error::runtime_error(prVar1,"UnaryOpExpr.expr is null");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_001fbff0,PTR__runtime_error_001fbf58);
}
Expression::evaluate(local_60,*(shared_ptr **)(param_1 + 0x20));
switch(*(int4 *)(param_1 + 0x30)) {
case 0:
Value::Value((Value *)this,(Value *)local_60);
break;
case 1:
/* try { // try from 00162868 to 00162874 has its CatchHandler @ 00162924 */
Value::operator-((Value *)this);
break;
case 2:
/* try { // try from 0016284b to 00162854 has its CatchHandler @ 00162908 */
local_61 = (bool)Value::to_bool((Value *)local_60);
local_61 = (bool)(local_61 ^ 1);
Value::Value((Value *)this,&local_61);
break;
case 3:
case 4:
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001628c5 to 001628d3 has its CatchHandler @ 0016290a */
std::runtime_error::runtime_error
(prVar1,"Expansion operator is only supported in function calls and collections");
goto LAB_001628f0;
default:
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001628e1 to 001628ef has its CatchHandler @ 00162906 */
std::runtime_error::runtime_error(prVar1,"Unknown unary operator");
LAB_001628f0:
/* try { // try from 001628f0 to 00162905 has its CatchHandler @ 00162924 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_001fbff0,PTR__runtime_error_001fbf58);
}
Value::~Value((Value *)local_60);
return this;
}
|
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.