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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
39,500 | mj_gravcomp | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_passive.c | static int mj_gravcomp(const mjModel* m, mjData* d) {
if (!m->ngravcomp || mjDISABLED(mjDSBL_GRAVITY) || mju_norm3(m->opt.gravity) == 0) {
return 0;
}
int nbody = m->nbody, has_gravcomp = 0;
mjtNum force[3], torque[3]={0};
// apply per-body gravity compensation
for (int i=1; i < nbody; i++) {
if (m->body_gravcomp[i]) {
has_gravcomp = 1;
mju_scl3(force, m->opt.gravity, -(m->body_mass[i]*m->body_gravcomp[i]));
mj_applyFT(m, d, force, torque, d->xipos+3*i, i, d->qfrc_gravcomp);
}
}
return has_gravcomp;
} | O0 | c | mj_gravcomp:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
cmpl $0x0, 0x114(%rax)
je 0xe4510
movq 0x58(%rsp), %rax
movl 0x258(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0xe4510
movq 0x58(%rsp), %rdi
addq $0x140, %rdi # imm = 0x140
addq $0x38, %rdi
callq 0x496e0
vxorps %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jne 0xe451d
jp 0xe451d
movl $0x0, 0x64(%rsp)
jmp 0xe4646
movq 0x58(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x4c(%rsp)
movl $0x0, 0x48(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x49430
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0xe463e
movq 0x58(%rsp), %rax
movq 0x5d8(%rax), %rax
movslq 0xc(%rsp), %rcx
vmovsd (%rax,%rcx,8), %xmm0
vxorps %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jne 0xe457f
jp 0xe457f
jmp 0xe462c
movl $0x1, 0x48(%rsp)
leaq 0x30(%rsp), %rdi
movq 0x58(%rsp), %rsi
addq $0x140, %rsi # imm = 0x140
addq $0x38, %rsi
movq 0x58(%rsp), %rax
movq 0x5b8(%rax), %rax
movslq 0xc(%rsp), %rcx
vmovsd (%rax,%rcx,8), %xmm0
movq 0x58(%rsp), %rax
movq 0x5d8(%rax), %rax
movslq 0xc(%rsp), %rcx
vmulsd (%rax,%rcx,8), %xmm0, %xmm0
vmovq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
vmovq %rax, %xmm0
callq 0x49340
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq 0x50(%rsp), %rax
movq 0x27818(%rax), %r8
imull $0x3, 0xc(%rsp), %eax
cltq
shlq $0x3, %rax
addq %rax, %r8
movl 0xc(%rsp), %r9d
movq 0x50(%rsp), %rax
movq 0x27998(%rax), %rax
movq %rax, (%rsp)
callq 0x4a030
jmp 0xe462e
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xe454a
movl 0x48(%rsp), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nop
| mj_gravcomp:
sub rsp, 68h
mov [rsp+68h+var_10], rdi
mov [rsp+68h+var_18], rsi
mov rax, [rsp+68h+var_10]
cmp dword ptr [rax+114h], 0
jz short loc_E4510
mov rax, [rsp+68h+var_10]
mov eax, [rax+258h]
and eax, 40h
cmp eax, 0
jnz short loc_E4510
mov rdi, [rsp+68h+var_10]
add rdi, 140h
add rdi, 38h ; '8'
call _mju_norm3
vxorps xmm1, xmm1, xmm1
vucomisd xmm0, xmm1
jnz short loc_E451D
jp short loc_E451D
loc_E4510:
mov [rsp+68h+var_4], 0
jmp loc_E4646
loc_E451D:
mov rax, [rsp+68h+var_10]
mov eax, [rax+10h]
mov [rsp+68h+var_1C], eax
mov [rsp+68h+var_20], 0
lea rdi, [rsp+68h+var_58]
xor esi, esi
mov edx, 18h
call _memset
mov [rsp+68h+var_5C], 1
loc_E454A:
mov eax, [rsp+68h+var_5C]
cmp eax, [rsp+68h+var_1C]
jge loc_E463E
mov rax, [rsp+68h+var_10]
mov rax, [rax+5D8h]
movsxd rcx, [rsp+68h+var_5C]
vmovsd xmm0, qword ptr [rax+rcx*8]
vxorps xmm1, xmm1, xmm1
vucomisd xmm0, xmm1
jnz short loc_E457F
jp short loc_E457F
jmp loc_E462C
loc_E457F:
mov [rsp+68h+var_20], 1
lea rdi, [rsp+68h+var_38]
mov rsi, [rsp+68h+var_10]
add rsi, 140h
add rsi, 38h ; '8'
mov rax, [rsp+68h+var_10]
mov rax, [rax+5B8h]
movsxd rcx, [rsp+68h+var_5C]
vmovsd xmm0, qword ptr [rax+rcx*8]
mov rax, [rsp+68h+var_10]
mov rax, [rax+5D8h]
movsxd rcx, [rsp+68h+var_5C]
vmulsd xmm0, xmm0, qword ptr [rax+rcx*8]
vmovq rax, xmm0
mov rcx, 8000000000000000h
xor rax, rcx
vmovq xmm0, rax
call _mju_scl3
mov rdi, [rsp+68h+var_10]
mov rsi, [rsp+68h+var_18]
lea rdx, [rsp+68h+var_38]
lea rcx, [rsp+68h+var_58]
mov rax, [rsp+68h+var_18]
mov r8, [rax+27818h]
imul eax, [rsp+68h+var_5C], 3
cdqe
shl rax, 3
add r8, rax
mov r9d, [rsp+68h+var_5C]
mov rax, [rsp+68h+var_18]
mov rax, [rax+27998h]
mov [rsp+68h+var_68], rax
call _mj_applyFT
loc_E462C:
jmp short $+2
loc_E462E:
mov eax, [rsp+68h+var_5C]
add eax, 1
mov [rsp+68h+var_5C], eax
jmp loc_E454A
loc_E463E:
mov eax, [rsp+68h+var_20]
mov [rsp+68h+var_4], eax
loc_E4646:
mov eax, [rsp+68h+var_4]
add rsp, 68h
retn
| long long mj_gravcomp(long long a1, long long a2, __m128 _XMM0, __m128 _XMM1)
{
char v4; // pf
char v6; // zf
int i; // [rsp+Ch] [rbp-5Ch]
_BYTE v18[32]; // [rsp+10h] [rbp-58h] BYREF
_BYTE v19[24]; // [rsp+30h] [rbp-38h] BYREF
unsigned int v20; // [rsp+48h] [rbp-20h]
int v21; // [rsp+4Ch] [rbp-1Ch]
long long v22; // [rsp+50h] [rbp-18h]
long long v23; // [rsp+58h] [rbp-10h]
v23 = a1;
v22 = a2;
if ( !*(_DWORD *)(a1 + 276) )
return 0;
if ( (*(_DWORD *)(v23 + 600) & 0x40) != 0 )
return 0;
*(double *)_XMM0.m128_u64 = mju_norm3(v23 + 376);
__asm
{
vxorps xmm1, xmm1, xmm1
vucomisd xmm0, xmm1
}
if ( !v6 || v4 )
{
v21 = *(_DWORD *)(v23 + 16);
v20 = 0;
memset(v18, 0LL, 24LL);
for ( i = 1; i < v21; ++i )
{
_RAX = *(_QWORD *)(v23 + 1496);
_RCX = i;
__asm
{
vmovsd xmm0, qword ptr [rax+rcx*8]
vxorps xmm1, xmm1, xmm1
vucomisd xmm0, xmm1
}
if ( i != v21 || __SETP__(i, v21) )
{
v20 = 1;
_RAX = *(_QWORD *)(v23 + 1464);
_RCX = i;
__asm
{
vmovsd xmm0, qword ptr [rax+rcx*8]
vmulsd xmm0, xmm0, qword ptr [rax+rcx*8]
vmovq rax, xmm0
}
_RAX ^= 0x8000000000000000LL;
__asm { vmovq xmm0, rax }
mju_scl3(v19, v23 + 376, *(double *)&_XMM0);
mj_applyFT(
v23,
v22,
(unsigned int)v19,
(unsigned int)v18,
24 * i + *(_QWORD *)(v22 + 161816),
i,
*(_QWORD *)(v22 + 162200));
}
}
return v20;
}
else
{
return 0;
}
}
| mj_gravcomp:
SUB RSP,0x68
MOV qword ptr [RSP + 0x58],RDI
MOV qword ptr [RSP + 0x50],RSI
MOV RAX,qword ptr [RSP + 0x58]
CMP dword ptr [RAX + 0x114],0x0
JZ 0x001e4510
MOV RAX,qword ptr [RSP + 0x58]
MOV EAX,dword ptr [RAX + 0x258]
AND EAX,0x40
CMP EAX,0x0
JNZ 0x001e4510
MOV RDI,qword ptr [RSP + 0x58]
ADD RDI,0x140
ADD RDI,0x38
CALL 0x001496e0
VXORPS XMM1,XMM1,XMM1
VUCOMISD XMM0,XMM1
JNZ 0x001e451d
JP 0x001e451d
LAB_001e4510:
MOV dword ptr [RSP + 0x64],0x0
JMP 0x001e4646
LAB_001e451d:
MOV RAX,qword ptr [RSP + 0x58]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RSP + 0x4c],EAX
MOV dword ptr [RSP + 0x48],0x0
LEA RDI,[RSP + 0x10]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x00149430
MOV dword ptr [RSP + 0xc],0x1
LAB_001e454a:
MOV EAX,dword ptr [RSP + 0xc]
CMP EAX,dword ptr [RSP + 0x4c]
JGE 0x001e463e
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0x5d8]
MOVSXD RCX,dword ptr [RSP + 0xc]
VMOVSD XMM0,qword ptr [RAX + RCX*0x8]
VXORPS XMM1,XMM1,XMM1
VUCOMISD XMM0,XMM1
JNZ 0x001e457f
JP 0x001e457f
JMP 0x001e462c
LAB_001e457f:
MOV dword ptr [RSP + 0x48],0x1
LEA RDI,[RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x58]
ADD RSI,0x140
ADD RSI,0x38
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0x5b8]
MOVSXD RCX,dword ptr [RSP + 0xc]
VMOVSD XMM0,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0x5d8]
MOVSXD RCX,dword ptr [RSP + 0xc]
VMULSD XMM0,XMM0,qword ptr [RAX + RCX*0x8]
VMOVQ RAX,XMM0
MOV RCX,-0x8000000000000000
XOR RAX,RCX
VMOVQ XMM0,RAX
CALL 0x00149340
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x50]
LEA RDX,[RSP + 0x30]
LEA RCX,[RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x50]
MOV R8,qword ptr [RAX + 0x27818]
IMUL EAX,dword ptr [RSP + 0xc],0x3
CDQE
SHL RAX,0x3
ADD R8,RAX
MOV R9D,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RAX + 0x27998]
MOV qword ptr [RSP],RAX
CALL 0x0014a030
LAB_001e462c:
JMP 0x001e462e
LAB_001e462e:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x001e454a
LAB_001e463e:
MOV EAX,dword ptr [RSP + 0x48]
MOV dword ptr [RSP + 0x64],EAX
LAB_001e4646:
MOV EAX,dword ptr [RSP + 0x64]
ADD RSP,0x68
RET
|
int4 mj_gravcomp(long param_1,long param_2)
{
double dVar1;
int local_5c;
int1 local_58 [32];
int1 local_38 [24];
int4 local_20;
int local_1c;
long local_18;
long local_10;
if ((*(int *)(param_1 + 0x114) != 0) && ((*(uint *)(param_1 + 600) & 0x40) == 0)) {
local_18 = param_2;
local_10 = param_1;
dVar1 = (double)mju_norm3(param_1 + 0x178);
if ((dVar1 != 0.0) || (NAN(dVar1))) {
local_1c = *(int *)(local_10 + 0x10);
local_20 = 0;
memset(local_58,0,0x18);
for (local_5c = 1; local_5c < local_1c; local_5c = local_5c + 1) {
dVar1 = *(double *)(*(long *)(local_10 + 0x5d8) + (long)local_5c * 8);
if ((dVar1 != 0.0) || (NAN(dVar1))) {
local_20 = 1;
mju_scl3(-(*(double *)(*(long *)(local_10 + 0x5b8) + (long)local_5c * 8) *
*(double *)(*(long *)(local_10 + 0x5d8) + (long)local_5c * 8)),local_38,
local_10 + 0x178);
mj_applyFT(local_10,local_18,local_38,local_58,
*(long *)(local_18 + 0x27818) + (long)(local_5c * 3) * 8,local_5c,
*(int8 *)(local_18 + 0x27998));
}
}
return local_20;
}
}
return 0;
}
| |
39,501 | vsort_is_nearly_sorted_int | davidesantangelo[P]vsort/vsort.c | static bool vsort_is_nearly_sorted_int(const int *arr, int size)
{
if (size < 20)
return false; // Too small to reliably tell
int inversions = 0;
// Sample about 5% of the array, max 100 samples
int sample_size = VSORT_MIN(100, VSORT_MAX(10, size / 20));
int step = VSORT_MAX(1, size / sample_size);
// Limit loop iterations to avoid excessive sampling on huge arrays if step becomes large
int max_iterations = sample_size;
int current_iterations = 0;
for (int i = 0; (i + step) < size && current_iterations < max_iterations; i += step, ++current_iterations)
{
if (arr[i] > arr[i + step])
{
inversions++;
}
}
if (current_iterations == 0)
return false; // Avoid division by zero if loop didn't run
// Consider nearly sorted if inversions are less than 10% of samples checked
return (inversions * 10 < current_iterations);
} | O0 | c | vsort_is_nearly_sorted_int:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpl $0x14, -0x14(%rsp)
jge 0x29ba
movb $0x0, -0x1(%rsp)
jmp 0x2b2f
movl $0x0, -0x18(%rsp)
movl -0x14(%rsp), %eax
movl $0x14, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl $0xa, %eax
cmpl %ecx, %eax
jle 0x29e4
movl $0xa, %eax
movl %eax, -0x30(%rsp)
jmp 0x29f4
movl -0x14(%rsp), %eax
movl $0x14, %ecx
cltd
idivl %ecx
movl %eax, -0x30(%rsp)
movl -0x30(%rsp), %ecx
movl $0x64, %eax
cmpl %ecx, %eax
jge 0x2a0c
movl $0x64, %eax
movl %eax, -0x34(%rsp)
jmp 0x2a46
movl -0x14(%rsp), %eax
movl $0x14, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl $0xa, %eax
cmpl %ecx, %eax
jle 0x2a2e
movl $0xa, %eax
movl %eax, -0x38(%rsp)
jmp 0x2a3e
movl -0x14(%rsp), %eax
movl $0x14, %ecx
cltd
idivl %ecx
movl %eax, -0x38(%rsp)
movl -0x38(%rsp), %eax
movl %eax, -0x34(%rsp)
movl -0x34(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x14(%rsp), %eax
cltd
idivl -0x1c(%rsp)
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jle 0x2a6d
movl $0x1, %eax
movl %eax, -0x3c(%rsp)
jmp 0x2a7a
movl -0x14(%rsp), %eax
cltd
idivl -0x1c(%rsp)
movl %eax, -0x3c(%rsp)
movl -0x3c(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, -0x24(%rsp)
movl $0x0, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
movl -0x2c(%rsp), %ecx
addl -0x20(%rsp), %ecx
xorl %eax, %eax
cmpl -0x14(%rsp), %ecx
movb %al, -0x3d(%rsp)
jge 0x2abd
movl -0x28(%rsp), %eax
cmpl -0x24(%rsp), %eax
setl %al
movb %al, -0x3d(%rsp)
movb -0x3d(%rsp), %al
testb $0x1, %al
jne 0x2ac7
jmp 0x2b0f
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rsp), %rcx
movl -0x2c(%rsp), %edx
addl -0x20(%rsp), %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x2af4
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x2af6
movl -0x20(%rsp), %eax
addl -0x2c(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x2a9a
cmpl $0x0, -0x28(%rsp)
jne 0x2b1d
movb $0x0, -0x1(%rsp)
jmp 0x2b2f
imull $0xa, -0x18(%rsp), %eax
cmpl -0x28(%rsp), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
| vsort_is_nearly_sorted_int:
mov [rsp+var_10], rdi
mov [rsp+var_14], esi
cmp [rsp+var_14], 14h
jge short loc_29BA
mov [rsp+var_1], 0
jmp loc_2B2F
loc_29BA:
mov [rsp+var_18], 0
mov eax, [rsp+var_14]
mov ecx, 14h
cdq
idiv ecx
mov ecx, eax
mov eax, 0Ah
cmp eax, ecx
jle short loc_29E4
mov eax, 0Ah
mov [rsp+var_30], eax
jmp short loc_29F4
loc_29E4:
mov eax, [rsp+var_14]
mov ecx, 14h
cdq
idiv ecx
mov [rsp+var_30], eax
loc_29F4:
mov ecx, [rsp+var_30]
mov eax, 64h ; 'd'
cmp eax, ecx
jge short loc_2A0C
mov eax, 64h ; 'd'
mov [rsp+var_34], eax
jmp short loc_2A46
loc_2A0C:
mov eax, [rsp+var_14]
mov ecx, 14h
cdq
idiv ecx
mov ecx, eax
mov eax, 0Ah
cmp eax, ecx
jle short loc_2A2E
mov eax, 0Ah
mov [rsp+var_38], eax
jmp short loc_2A3E
loc_2A2E:
mov eax, [rsp+var_14]
mov ecx, 14h
cdq
idiv ecx
mov [rsp+var_38], eax
loc_2A3E:
mov eax, [rsp+var_38]
mov [rsp+var_34], eax
loc_2A46:
mov eax, [rsp+var_34]
mov [rsp+var_1C], eax
mov eax, [rsp+var_14]
cdq
idiv [rsp+var_1C]
mov ecx, eax
mov eax, 1
cmp eax, ecx
jle short loc_2A6D
mov eax, 1
mov [rsp+var_3C], eax
jmp short loc_2A7A
loc_2A6D:
mov eax, [rsp+var_14]
cdq
idiv [rsp+var_1C]
mov [rsp+var_3C], eax
loc_2A7A:
mov eax, [rsp+var_3C]
mov [rsp+var_20], eax
mov eax, [rsp+var_1C]
mov [rsp+var_24], eax
mov [rsp+var_28], 0
mov [rsp+var_2C], 0
loc_2A9A:
mov ecx, [rsp+var_2C]
add ecx, [rsp+var_20]
xor eax, eax
cmp ecx, [rsp+var_14]
mov [rsp+var_3D], al
jge short loc_2ABD
mov eax, [rsp+var_28]
cmp eax, [rsp+var_24]
setl al
mov [rsp+var_3D], al
loc_2ABD:
mov al, [rsp+var_3D]
test al, 1
jnz short loc_2AC7
jmp short loc_2B0F
loc_2AC7:
mov rax, [rsp+var_10]
movsxd rcx, [rsp+var_2C]
mov eax, [rax+rcx*4]
mov rcx, [rsp+var_10]
mov edx, [rsp+var_2C]
add edx, [rsp+var_20]
movsxd rdx, edx
cmp eax, [rcx+rdx*4]
jle short loc_2AF4
mov eax, [rsp+var_18]
add eax, 1
mov [rsp+var_18], eax
loc_2AF4:
jmp short $+2
loc_2AF6:
mov eax, [rsp+var_20]
add eax, [rsp+var_2C]
mov [rsp+var_2C], eax
mov eax, [rsp+var_28]
add eax, 1
mov [rsp+var_28], eax
jmp short loc_2A9A
loc_2B0F:
cmp [rsp+var_28], 0
jnz short loc_2B1D
mov [rsp+var_1], 0
jmp short loc_2B2F
loc_2B1D:
imul eax, [rsp+var_18], 0Ah
cmp eax, [rsp+var_28]
setl al
and al, 1
mov [rsp+var_1], al
loc_2B2F:
mov al, [rsp+var_1]
and al, 1
retn
| bool vsort_is_nearly_sorted_int(long long a1, int a2)
{
bool v3; // [rsp+1h] [rbp-3Dh]
int v4; // [rsp+2h] [rbp-3Ch]
int v5; // [rsp+6h] [rbp-38h]
int v6; // [rsp+Ah] [rbp-34h]
int v7; // [rsp+Eh] [rbp-30h]
int v8; // [rsp+12h] [rbp-2Ch]
int v9; // [rsp+16h] [rbp-28h]
int v10; // [rsp+26h] [rbp-18h]
if ( a2 >= 20 )
{
v10 = 0;
if ( a2 / 20 >= 10 )
v7 = a2 / 20;
else
v7 = 10;
if ( v7 <= 100 )
{
if ( a2 / 20 >= 10 )
v5 = a2 / 20;
else
v5 = 10;
v6 = v5;
}
else
{
v6 = 100;
}
if ( a2 / v6 >= 1 )
v4 = a2 / v6;
else
v4 = 1;
v9 = 0;
v8 = 0;
while ( 1 )
{
v3 = 0;
if ( v4 + v8 < a2 )
v3 = v9 < v6;
if ( !v3 )
break;
if ( *(_DWORD *)(a1 + 4LL * v8) > *(_DWORD *)(a1 + 4LL * (v4 + v8)) )
++v10;
v8 += v4;
++v9;
}
return v9 && 10 * v10 < v9;
}
else
{
return 0;
}
}
| vsort_is_nearly_sorted_int:
MOV qword ptr [RSP + -0x10],RDI
MOV dword ptr [RSP + -0x14],ESI
CMP dword ptr [RSP + -0x14],0x14
JGE 0x001029ba
MOV byte ptr [RSP + -0x1],0x0
JMP 0x00102b2f
LAB_001029ba:
MOV dword ptr [RSP + -0x18],0x0
MOV EAX,dword ptr [RSP + -0x14]
MOV ECX,0x14
CDQ
IDIV ECX
MOV ECX,EAX
MOV EAX,0xa
CMP EAX,ECX
JLE 0x001029e4
MOV EAX,0xa
MOV dword ptr [RSP + -0x30],EAX
JMP 0x001029f4
LAB_001029e4:
MOV EAX,dword ptr [RSP + -0x14]
MOV ECX,0x14
CDQ
IDIV ECX
MOV dword ptr [RSP + -0x30],EAX
LAB_001029f4:
MOV ECX,dword ptr [RSP + -0x30]
MOV EAX,0x64
CMP EAX,ECX
JGE 0x00102a0c
MOV EAX,0x64
MOV dword ptr [RSP + -0x34],EAX
JMP 0x00102a46
LAB_00102a0c:
MOV EAX,dword ptr [RSP + -0x14]
MOV ECX,0x14
CDQ
IDIV ECX
MOV ECX,EAX
MOV EAX,0xa
CMP EAX,ECX
JLE 0x00102a2e
MOV EAX,0xa
MOV dword ptr [RSP + -0x38],EAX
JMP 0x00102a3e
LAB_00102a2e:
MOV EAX,dword ptr [RSP + -0x14]
MOV ECX,0x14
CDQ
IDIV ECX
MOV dword ptr [RSP + -0x38],EAX
LAB_00102a3e:
MOV EAX,dword ptr [RSP + -0x38]
MOV dword ptr [RSP + -0x34],EAX
LAB_00102a46:
MOV EAX,dword ptr [RSP + -0x34]
MOV dword ptr [RSP + -0x1c],EAX
MOV EAX,dword ptr [RSP + -0x14]
CDQ
IDIV dword ptr [RSP + -0x1c]
MOV ECX,EAX
MOV EAX,0x1
CMP EAX,ECX
JLE 0x00102a6d
MOV EAX,0x1
MOV dword ptr [RSP + -0x3c],EAX
JMP 0x00102a7a
LAB_00102a6d:
MOV EAX,dword ptr [RSP + -0x14]
CDQ
IDIV dword ptr [RSP + -0x1c]
MOV dword ptr [RSP + -0x3c],EAX
LAB_00102a7a:
MOV EAX,dword ptr [RSP + -0x3c]
MOV dword ptr [RSP + -0x20],EAX
MOV EAX,dword ptr [RSP + -0x1c]
MOV dword ptr [RSP + -0x24],EAX
MOV dword ptr [RSP + -0x28],0x0
MOV dword ptr [RSP + -0x2c],0x0
LAB_00102a9a:
MOV ECX,dword ptr [RSP + -0x2c]
ADD ECX,dword ptr [RSP + -0x20]
XOR EAX,EAX
CMP ECX,dword ptr [RSP + -0x14]
MOV byte ptr [RSP + -0x3d],AL
JGE 0x00102abd
MOV EAX,dword ptr [RSP + -0x28]
CMP EAX,dword ptr [RSP + -0x24]
SETL AL
MOV byte ptr [RSP + -0x3d],AL
LAB_00102abd:
MOV AL,byte ptr [RSP + -0x3d]
TEST AL,0x1
JNZ 0x00102ac7
JMP 0x00102b0f
LAB_00102ac7:
MOV RAX,qword ptr [RSP + -0x10]
MOVSXD RCX,dword ptr [RSP + -0x2c]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RSP + -0x10]
MOV EDX,dword ptr [RSP + -0x2c]
ADD EDX,dword ptr [RSP + -0x20]
MOVSXD RDX,EDX
CMP EAX,dword ptr [RCX + RDX*0x4]
JLE 0x00102af4
MOV EAX,dword ptr [RSP + -0x18]
ADD EAX,0x1
MOV dword ptr [RSP + -0x18],EAX
LAB_00102af4:
JMP 0x00102af6
LAB_00102af6:
MOV EAX,dword ptr [RSP + -0x20]
ADD EAX,dword ptr [RSP + -0x2c]
MOV dword ptr [RSP + -0x2c],EAX
MOV EAX,dword ptr [RSP + -0x28]
ADD EAX,0x1
MOV dword ptr [RSP + -0x28],EAX
JMP 0x00102a9a
LAB_00102b0f:
CMP dword ptr [RSP + -0x28],0x0
JNZ 0x00102b1d
MOV byte ptr [RSP + -0x1],0x0
JMP 0x00102b2f
LAB_00102b1d:
IMUL EAX,dword ptr [RSP + -0x18],0xa
CMP EAX,dword ptr [RSP + -0x28]
SETL AL
AND AL,0x1
MOV byte ptr [RSP + -0x1],AL
LAB_00102b2f:
MOV AL,byte ptr [RSP + -0x1]
AND AL,0x1
RET
|
int1 [16] vsort_is_nearly_sorted_int(long param_1,int param_2,ulong param_3)
{
bool bVar1;
uint3 uVar2;
ulong in_RAX;
int1 auVar3 [16];
int4 local_3c;
int4 local_38;
int4 local_34;
int4 local_30;
int4 local_2c;
int4 local_28;
int4 local_18;
int1 local_1;
if (param_2 < 0x14) {
local_1 = false;
}
else {
local_18 = 0;
if (param_2 / 0x14 < 10) {
local_30 = 10;
}
else {
local_30 = param_2 / 0x14;
}
if (local_30 < 0x65) {
if (param_2 / 0x14 < 10) {
local_38 = 10;
}
else {
local_38 = param_2 / 0x14;
}
local_34 = local_38;
}
else {
local_34 = 100;
}
param_3 = (long)param_2 % (long)local_34;
if (param_2 / local_34 < 1) {
local_3c = 1;
}
else {
local_3c = param_2 / local_34;
param_3 = (long)param_2 % (long)local_34;
}
param_3 = param_3 & 0xffffffff;
local_28 = 0;
local_2c = 0;
while( true ) {
uVar2 = 0;
bVar1 = local_2c + local_3c < param_2;
if (bVar1) {
uVar2 = (uint3)((uint)local_28 >> 8);
}
in_RAX = (ulong)uVar2 << 8;
if (!bVar1 || local_34 <= local_28) break;
param_3 = (ulong)(local_2c + local_3c);
if (*(int *)(param_1 + param_3 * 4) < *(int *)(param_1 + (long)local_2c * 4)) {
local_18 = local_18 + 1;
}
local_2c = local_3c + local_2c;
local_28 = local_28 + 1;
}
if (local_28 == 0) {
local_1 = false;
}
else {
local_1 = local_18 * 10 < local_28;
in_RAX = (ulong)CONCAT31((int3)((uint)(local_18 * 10) >> 8),local_1);
}
}
auVar3._1_7_ = (int7)(in_RAX >> 8);
auVar3[0] = local_1;
auVar3._8_8_ = param_3;
return auVar3;
}
| |
39,502 | js_new_message_pipe | bluesky950520[P]quickjs/quickjs-libc.c | static JSWorkerMessagePipe *js_new_message_pipe(void)
{
JSWorkerMessagePipe *ps;
int pipe_fds[2];
if (pipe(pipe_fds) < 0)
return NULL;
ps = malloc(sizeof(*ps));
if (!ps) {
close(pipe_fds[0]);
close(pipe_fds[1]);
return NULL;
}
ps->ref_count = 1;
init_list_head(&ps->msg_queue);
pthread_mutex_init(&ps->mutex, NULL);
ps->read_fd = pipe_fds[0];
ps->write_fd = pipe_fds[1];
return ps;
} | O0 | c | js_new_message_pipe:
subq $0x18, %rsp
movq %rsp, %rdi
callq 0xe3c0
cmpl $0x0, %eax
jge 0x1784c
movq $0x0, 0x10(%rsp)
jmp 0x178cb
movl $0x48, %edi
callq 0xe660
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1787f
movl (%rsp), %edi
callq 0xe3a0
movl 0x4(%rsp), %edi
callq 0xe3a0
movq $0x0, 0x10(%rsp)
jmp 0x178cb
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x112f0
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe940
movl (%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x40(%rax)
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x44(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| js_new_message_pipe:
sub rsp, 18h
mov rdi, rsp
call _pipe
cmp eax, 0
jge short loc_1784C
mov [rsp+18h+var_8], 0
jmp short loc_178CB
loc_1784C:
mov edi, 48h ; 'H'
call _malloc
mov [rsp+18h+var_10], rax
cmp [rsp+18h+var_10], 0
jnz short loc_1787F
mov edi, [rsp+18h+var_18]
call _close
mov edi, [rsp+18h+var_14]
call _close
mov [rsp+18h+var_8], 0
jmp short loc_178CB
loc_1787F:
mov rax, [rsp+18h+var_10]
mov dword ptr [rax], 1
mov rdi, [rsp+18h+var_10]
add rdi, 30h ; '0'
call init_list_head
mov rdi, [rsp+18h+var_10]
add rdi, 8
xor eax, eax
mov esi, eax
call _pthread_mutex_init
mov ecx, [rsp+18h+var_18]
mov rax, [rsp+18h+var_10]
mov [rax+40h], ecx
mov ecx, [rsp+18h+var_14]
mov rax, [rsp+18h+var_10]
mov [rax+44h], ecx
mov rax, [rsp+18h+var_10]
mov [rsp+18h+var_8], rax
loc_178CB:
mov rax, [rsp+18h+var_8]
add rsp, 18h
retn
| long long js_new_message_pipe()
{
unsigned int v1; // [rsp+0h] [rbp-18h] BYREF
unsigned int v2; // [rsp+4h] [rbp-14h]
long long v3; // [rsp+8h] [rbp-10h]
if ( (int)pipe(&v1) < 0 )
return 0LL;
v3 = malloc(72LL);
if ( v3 )
{
*(_DWORD *)v3 = 1;
init_list_head((_QWORD *)(v3 + 48));
pthread_mutex_init(v3 + 8, 0LL);
*(_DWORD *)(v3 + 64) = v1;
*(_DWORD *)(v3 + 68) = v2;
return v3;
}
else
{
close(v1);
close(v2);
return 0LL;
}
}
| js_new_message_pipe:
SUB RSP,0x18
MOV RDI,RSP
CALL 0x0010e3c0
CMP EAX,0x0
JGE 0x0011784c
MOV qword ptr [RSP + 0x10],0x0
JMP 0x001178cb
LAB_0011784c:
MOV EDI,0x48
CALL 0x0010e660
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x0011787f
MOV EDI,dword ptr [RSP]
CALL 0x0010e3a0
MOV EDI,dword ptr [RSP + 0x4]
CALL 0x0010e3a0
MOV qword ptr [RSP + 0x10],0x0
JMP 0x001178cb
LAB_0011787f:
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],0x1
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x30
CALL 0x001112f0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x8
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0010e940
MOV ECX,dword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX + 0x40],ECX
MOV ECX,dword ptr [RSP + 0x4]
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX + 0x44],ECX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RAX
LAB_001178cb:
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x18
RET
|
int4 * js_new_message_pipe(void)
{
int iVar1;
int local_18;
int local_14;
int4 *local_10;
int4 *local_8;
iVar1 = pipe(&local_18);
if (iVar1 < 0) {
local_8 = (int4 *)0x0;
}
else {
local_10 = (int4 *)malloc(0x48);
if (local_10 == (int4 *)0x0) {
close(local_18);
close(local_14);
local_8 = (int4 *)0x0;
}
else {
*local_10 = 1;
init_list_head(local_10 + 0xc);
pthread_mutex_init((pthread_mutex_t *)(local_10 + 2),(pthread_mutexattr_t *)0x0);
local_10[0x10] = local_18;
local_10[0x11] = local_14;
local_8 = local_10;
}
}
return local_8;
}
| |
39,503 | copy_decode_table | eloqsql/storage/maria/ma_packrec.c | static uint copy_decode_table(uint16 *to_pos, uint offset,
uint16 *decode_table)
{
uint prev_offset= offset;
DBUG_ENTER("copy_decode_table");
/* Descent on the left side. */
if (!(*decode_table & IS_CHAR))
{
/* Set a pointer to the next target node. */
to_pos[offset]=2;
/* Copy the left hand subtree there. */
offset=copy_decode_table(to_pos,offset+2,decode_table+ *decode_table);
}
else
{
/* Copy the uchar value. */
to_pos[offset]= *decode_table;
/* Step behind this node. */
offset+=2;
}
/* Descent on the right side. */
decode_table++;
if (!(*decode_table & IS_CHAR))
{
/* Set a pointer to the next free target node. */
to_pos[prev_offset+1]=(uint16) (offset-prev_offset-1);
/* Copy the right hand subtree to the entry of that node. */
offset=copy_decode_table(to_pos,offset,decode_table+ *decode_table);
}
else
{
/* Copy the uchar value. */
to_pos[prev_offset+1]= *decode_table;
}
DBUG_RETURN(offset);
} | O0 | c | copy_decode_table:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
jne 0x3ab1e
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movw $0x2, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
cltq
shlq %rax
addq %rax, %rdx
callq 0x3aac0
movl %eax, -0xc(%rbp)
jmp 0x3ab39
movq -0x18(%rbp), %rax
movw (%rax), %dx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
jne 0x3ab96
movl -0xc(%rbp), %eax
subl -0x1c(%rbp), %eax
subl $0x1, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
cltq
shlq %rax
addq %rax, %rdx
callq 0x3aac0
movl %eax, -0xc(%rbp)
jmp 0x3abad
movq -0x18(%rbp), %rax
movw (%rax), %dx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
jmp 0x3abaf
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| copy_decode_table:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov eax, [rbp+var_C]
mov [rbp+var_1C], eax
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
and eax, 8000h
cmp eax, 0
jnz short loc_3AB1E
mov rax, [rbp+var_8]
mov ecx, [rbp+var_C]
mov word ptr [rax+rcx*2], 2
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
add esi, 2
mov rdx, [rbp+var_18]
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
cdqe
shl rax, 1
add rdx, rax
call copy_decode_table
mov [rbp+var_C], eax
jmp short loc_3AB39
loc_3AB1E:
mov rax, [rbp+var_18]
mov dx, [rax]
mov rax, [rbp+var_8]
mov ecx, [rbp+var_C]
mov [rax+rcx*2], dx
mov eax, [rbp+var_C]
add eax, 2
mov [rbp+var_C], eax
loc_3AB39:
mov rax, [rbp+var_18]
add rax, 2
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
and eax, 8000h
cmp eax, 0
jnz short loc_3AB96
mov eax, [rbp+var_C]
sub eax, [rbp+var_1C]
sub eax, 1
mov dx, ax
mov rax, [rbp+var_8]
mov ecx, [rbp+var_1C]
add ecx, 1
mov ecx, ecx
mov [rax+rcx*2], dx
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
cdqe
shl rax, 1
add rdx, rax
call copy_decode_table
mov [rbp+var_C], eax
jmp short loc_3ABAD
loc_3AB96:
mov rax, [rbp+var_18]
mov dx, [rax]
mov rax, [rbp+var_8]
mov ecx, [rbp+var_1C]
add ecx, 1
mov ecx, ecx
mov [rax+rcx*2], dx
loc_3ABAD:
jmp short $+2
loc_3ABAF:
mov eax, [rbp+var_C]
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
| long long copy_decode_table(long long a1, unsigned int a2, _WORD *a3)
{
_WORD *v5; // [rsp+8h] [rbp-18h]
unsigned int v6; // [rsp+14h] [rbp-Ch]
if ( (*a3 & 0x8000) != 0 )
{
*(_WORD *)(a1 + 2LL * a2) = *a3;
v6 = a2 + 2;
}
else
{
*(_WORD *)(a1 + 2LL * a2) = 2;
v6 = copy_decode_table(a1, a2 + 2, &a3[(unsigned __int16)*a3]);
}
v5 = a3 + 1;
if ( (*v5 & 0x8000) != 0 )
{
*(_WORD *)(a1 + 2LL * (a2 + 1)) = *v5;
}
else
{
*(_WORD *)(a1 + 2LL * (a2 + 1)) = v6 - a2 - 1;
return (unsigned int)copy_decode_table(a1, v6, &v5[(unsigned __int16)*v5]);
}
return v6;
}
| copy_decode_table:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
AND EAX,0x8000
CMP EAX,0x0
JNZ 0x0013ab1e
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
MOV word ptr [RAX + RCX*0x2],0x2
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
ADD ESI,0x2
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
CDQE
SHL RAX,0x1
ADD RDX,RAX
CALL 0x0013aac0
MOV dword ptr [RBP + -0xc],EAX
JMP 0x0013ab39
LAB_0013ab1e:
MOV RAX,qword ptr [RBP + -0x18]
MOV DX,word ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
MOV word ptr [RAX + RCX*0x2],DX
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x2
MOV dword ptr [RBP + -0xc],EAX
LAB_0013ab39:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
AND EAX,0x8000
CMP EAX,0x0
JNZ 0x0013ab96
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV DX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,0x1
MOV ECX,ECX
MOV word ptr [RAX + RCX*0x2],DX
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
CDQE
SHL RAX,0x1
ADD RDX,RAX
CALL 0x0013aac0
MOV dword ptr [RBP + -0xc],EAX
JMP 0x0013abad
LAB_0013ab96:
MOV RAX,qword ptr [RBP + -0x18]
MOV DX,word ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,0x1
MOV ECX,ECX
MOV word ptr [RAX + RCX*0x2],DX
LAB_0013abad:
JMP 0x0013abaf
LAB_0013abaf:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
int copy_decode_table(long param_1,uint param_2,ushort *param_3)
{
int local_14;
if ((*param_3 & 0x8000) == 0) {
*(int2 *)(param_1 + (ulong)param_2 * 2) = 2;
local_14 = copy_decode_table(param_1,param_2 + 2,param_3 + (int)(uint)*param_3);
}
else {
*(ushort *)(param_1 + (ulong)param_2 * 2) = *param_3;
local_14 = param_2 + 2;
}
param_3 = param_3 + 1;
if ((*param_3 & 0x8000) == 0) {
*(short *)(param_1 + (ulong)(param_2 + 1) * 2) = ((short)local_14 - (short)param_2) + -1;
local_14 = copy_decode_table(param_1,local_14,param_3 + (int)(uint)*param_3);
}
else {
*(ushort *)(param_1 + (ulong)(param_2 + 1) * 2) = *param_3;
}
return local_14;
}
| |
39,504 | copy_decode_table | eloqsql/storage/maria/ma_packrec.c | static uint copy_decode_table(uint16 *to_pos, uint offset,
uint16 *decode_table)
{
uint prev_offset= offset;
DBUG_ENTER("copy_decode_table");
/* Descent on the left side. */
if (!(*decode_table & IS_CHAR))
{
/* Set a pointer to the next target node. */
to_pos[offset]=2;
/* Copy the left hand subtree there. */
offset=copy_decode_table(to_pos,offset+2,decode_table+ *decode_table);
}
else
{
/* Copy the uchar value. */
to_pos[offset]= *decode_table;
/* Step behind this node. */
offset+=2;
}
/* Descent on the right side. */
decode_table++;
if (!(*decode_table & IS_CHAR))
{
/* Set a pointer to the next free target node. */
to_pos[prev_offset+1]=(uint16) (offset-prev_offset-1);
/* Copy the right hand subtree to the entry of that node. */
offset=copy_decode_table(to_pos,offset,decode_table+ *decode_table);
}
else
{
/* Copy the uchar value. */
to_pos[prev_offset+1]= *decode_table;
}
DBUG_RETURN(offset);
} | O3 | c | copy_decode_table:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %eax
movq %rdi, %rbx
movzwl (%r14), %ecx
movl %eax, %r15d
addl $0x2, %eax
testw %cx, %cx
js 0x3bac6
movw $0x2, (%rbx,%r15,2)
movzwl (%r14), %ecx
leaq (%r14,%rcx,2), %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0x3ba8a
jmp 0x3bacb
movw %cx, (%rbx,%r15,2)
movzwl 0x2(%r14), %ecx
testw %cx, %cx
js 0x3baf2
addq $0x2, %r14
movl %r15d, %ecx
notl %ecx
addl %eax, %ecx
incl %r15d
movw %cx, (%rbx,%r15,2)
movzwl (%r14), %ecx
leaq (%r14,%rcx,2), %r14
jmp 0x3ba9c
incl %r15d
movw %cx, (%rbx,%r15,2)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| copy_decode_table:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rdx
mov eax, esi
mov rbx, rdi
loc_3BA9C:
movzx ecx, word ptr [r14]
mov r15d, eax
add eax, 2
test cx, cx
js short loc_3BAC6
mov word ptr [rbx+r15*2], 2
movzx ecx, word ptr [r14]
lea rdx, [r14+rcx*2]
mov rdi, rbx
mov esi, eax
call copy_decode_table
jmp short loc_3BACB
loc_3BAC6:
mov [rbx+r15*2], cx
loc_3BACB:
movzx ecx, word ptr [r14+2]
test cx, cx
js short loc_3BAF2
add r14, 2
mov ecx, r15d
not ecx
add ecx, eax
inc r15d
mov [rbx+r15*2], cx
movzx ecx, word ptr [r14]
lea r14, [r14+rcx*2]
jmp short loc_3BA9C
loc_3BAF2:
inc r15d
mov [rbx+r15*2], cx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long copy_decode_table(long long a1, int a2, unsigned __int16 *a3)
{
long long result; // rax
long long v5; // r15
__int16 v6; // cx
LODWORD(result) = a2;
while ( 1 )
{
v5 = (unsigned int)result;
result = (unsigned int)(result + 2);
if ( (*a3 & 0x8000u) != 0 )
{
*(_WORD *)(a1 + 2 * v5) = *a3;
}
else
{
*(_WORD *)(a1 + 2 * v5) = 2;
result = copy_decode_table(a1, (unsigned int)result, &a3[*a3]);
}
v6 = a3[1];
if ( v6 < 0 )
break;
*(_WORD *)(a1 + 2LL * (unsigned int)(v5 + 1)) = result + ~(_WORD)v5;
a3 += a3[1] + 1;
}
*(_WORD *)(a1 + 2LL * (unsigned int)(v5 + 1)) = v6;
return result;
}
| copy_decode_table:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV EAX,ESI
MOV RBX,RDI
LAB_0013ba9c:
MOVZX ECX,word ptr [R14]
MOV R15D,EAX
ADD EAX,0x2
TEST CX,CX
JS 0x0013bac6
MOV word ptr [RBX + R15*0x2],0x2
MOVZX ECX,word ptr [R14]
LEA RDX,[R14 + RCX*0x2]
MOV RDI,RBX
MOV ESI,EAX
CALL 0x0013ba8a
JMP 0x0013bacb
LAB_0013bac6:
MOV word ptr [RBX + R15*0x2],CX
LAB_0013bacb:
MOVZX ECX,word ptr [R14 + 0x2]
TEST CX,CX
JS 0x0013baf2
ADD R14,0x2
MOV ECX,R15D
NOT ECX
ADD ECX,EAX
INC R15D
MOV word ptr [RBX + R15*0x2],CX
MOVZX ECX,word ptr [R14]
LEA R14,[R14 + RCX*0x2]
JMP 0x0013ba9c
LAB_0013baf2:
INC R15D
MOV word ptr [RBX + R15*0x2],CX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void copy_decode_table(long param_1,uint param_2,ushort *param_3)
{
uint uVar1;
while( true ) {
uVar1 = param_2 + 2;
if ((short)*param_3 < 0) {
*(ushort *)(param_1 + (ulong)param_2 * 2) = *param_3;
}
else {
*(int2 *)(param_1 + (ulong)param_2 * 2) = 2;
uVar1 = copy_decode_table(param_1,uVar1,param_3 + *param_3);
}
if ((short)param_3[1] < 0) break;
*(ushort *)(param_1 + (ulong)(param_2 + 1) * 2) = ~(ushort)param_2 + (short)uVar1;
param_3 = param_3 + 1 + param_3[1];
param_2 = uVar1;
}
*(ushort *)(param_1 + (ulong)(param_2 + 1) * 2) = param_3[1];
return;
}
| |
39,505 | mysql_ha_find_match(THD*, TABLE_LIST*) | eloqsql/sql/sql_handler.cc | static SQL_HANDLER *mysql_ha_find_match(THD *thd, TABLE_LIST *tables)
{
SQL_HANDLER *hash_tables, *head= NULL;
TABLE_LIST *first= tables;
DBUG_ENTER("mysql_ha_find_match");
/* search for all handlers with matching table names */
for (uint i= 0; i < thd->handler_tables_hash.records; i++)
{
hash_tables= (SQL_HANDLER*) my_hash_element(&thd->handler_tables_hash, i);
for (tables= first; tables; tables= tables->next_local)
{
if (tables->is_anonymous_derived_table())
continue;
if ((! tables->db.str[0] ||
! my_strcasecmp(&my_charset_latin1, hash_tables->db.str,
tables->get_db_name())) &&
! my_strcasecmp(&my_charset_latin1, hash_tables->table_name.str,
tables->get_table_name()))
{
/* Link into hash_tables list */
hash_tables->next= head;
head= hash_tables;
break;
}
}
}
DBUG_RETURN(head);
} | O0 | cpp | mysql_ha_find_match(THD*, TABLE_LIST*):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x25d0(%rcx), %rax
jae 0x8aeabb
movq -0x8(%rbp), %rdi
addq $0x25b8, %rdi # imm = 0x25B8
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x12ab070
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8aeaab
movq -0x10(%rbp), %rdi
callq 0x856d50
testb $0x1, %al
jne 0x8ae9e6
jmp 0x8ae9eb
jmp 0x8aea9b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpb $0x0, (%rax)
je 0x8aea3c
leaq 0x13058c1(%rip), %rax # 0x1bb42c0
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x856b10
movq -0x40(%rbp), %rsi
movq %rax, %rdx
movq -0x38(%rbp), %rax
leaq 0x130588b(%rip), %rdi # 0x1bb42c0
callq *%rax
cmpl $0x0, %eax
jne 0x8aea99
leaq 0x130587d(%rip), %rax # 0x1bb42c0
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x856b50
movq -0x50(%rbp), %rsi
movq %rax, %rdx
movq -0x48(%rbp), %rax
leaq 0x1305847(%rip), %rdi # 0x1bb42c0
callq *%rax
cmpl $0x0, %eax
jne 0x8aea99
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x278(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8aeaab
jmp 0x8aea9b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x8ae9cc
jmp 0x8aeaad
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x8ae997
jmp 0x8aeabd
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZL19mysql_ha_find_matchP3THDP10TABLE_LIST:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_20], 0
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov [rbp+var_2C], 0
loc_8AE997:
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_8]
cmp rax, [rcx+25D0h]
jnb loc_8AEABB
mov rdi, [rbp+var_8]
add rdi, 25B8h
mov eax, [rbp+var_2C]
mov esi, eax
call my_hash_element
mov [rbp+var_18], rax
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
loc_8AE9CC:
cmp [rbp+var_10], 0
jz loc_8AEAAB
mov rdi, [rbp+var_10]; this
call _ZNK10TABLE_LIST26is_anonymous_derived_tableEv; TABLE_LIST::is_anonymous_derived_table(void)
test al, 1
jnz short loc_8AE9E6
jmp short loc_8AE9EB
loc_8AE9E6:
jmp loc_8AEA9B
loc_8AE9EB:
mov rax, [rbp+var_10]
mov rax, [rax+18h]
cmp byte ptr [rax], 0
jz short loc_8AEA3C
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]; this
call _ZNK10TABLE_LIST11get_db_nameEv; TABLE_LIST::get_db_name(void)
mov rsi, [rbp+var_40]
mov rdx, rax
mov rax, [rbp+var_38]
lea rdi, my_charset_latin1
call rax
cmp eax, 0
jnz short loc_8AEA99
loc_8AEA3C:
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
mov rax, [rax+48h]
mov [rbp+var_50], rax
mov rdi, [rbp+var_10]; this
call _ZNK10TABLE_LIST14get_table_nameEv; TABLE_LIST::get_table_name(void)
mov rsi, [rbp+var_50]
mov rdx, rax
mov rax, [rbp+var_48]
lea rdi, my_charset_latin1
call rax
cmp eax, 0
jnz short loc_8AEA99
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
mov [rax+278h], rcx
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
jmp short loc_8AEAAB
loc_8AEA99:
jmp short $+2
loc_8AEA9B:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_10], rax
jmp loc_8AE9CC
loc_8AEAAB:
jmp short $+2
loc_8AEAAD:
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp loc_8AE997
loc_8AEABB:
jmp short $+2
loc_8AEABD:
mov rax, [rbp+var_20]
add rsp, 50h
pop rbp
retn
| _QWORD * mysql_ha_find_match(THD *a1, TABLE_LIST *a2)
{
long long db_name; // rax
long long table_name; // rax
long long v5; // [rsp+0h] [rbp-50h]
unsigned int ( *v6)(void *, long long, long long); // [rsp+8h] [rbp-48h]
long long v7; // [rsp+10h] [rbp-40h]
unsigned int ( *v8)(void *, long long, long long); // [rsp+18h] [rbp-38h]
unsigned int i; // [rsp+24h] [rbp-2Ch]
_QWORD *v10; // [rsp+30h] [rbp-20h]
_QWORD *v11; // [rsp+38h] [rbp-18h]
TABLE_LIST *j; // [rsp+40h] [rbp-10h]
v10 = 0LL;
for ( i = 0; (unsigned long long)i < *((_QWORD *)a1 + 1210); ++i )
{
v11 = (_QWORD *)my_hash_element((char *)a1 + 9656, i);
for ( j = a2; j; j = *(TABLE_LIST **)j )
{
if ( (TABLE_LIST::is_anonymous_derived_table(j) & 1) == 0 )
{
if ( !**((_BYTE **)j + 3)
|| (v8 = *(unsigned int ( **)(void *, long long, long long))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL),
v7 = v11[7],
db_name = TABLE_LIST::get_db_name(j),
!v8(&my_charset_latin1, v7, db_name)) )
{
v6 = *(unsigned int ( **)(void *, long long, long long))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL);
v5 = v11[9];
table_name = TABLE_LIST::get_table_name(j);
if ( !v6(&my_charset_latin1, v5, table_name) )
{
v11[79] = v10;
v10 = v11;
break;
}
}
}
}
}
return v10;
}
| __cxx_global_var_init.4:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x264dc0c]
MOV ESI,0x10
CALL 0x008db900
POP RBP
RET
|
void __cxx_global_var_init_4(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_INTERVAL_DAY,0x10);
return;
}
| |
39,506 | mysql_ha_find_match(THD*, TABLE_LIST*) | eloqsql/sql/sql_handler.cc | static SQL_HANDLER *mysql_ha_find_match(THD *thd, TABLE_LIST *tables)
{
SQL_HANDLER *hash_tables, *head= NULL;
TABLE_LIST *first= tables;
DBUG_ENTER("mysql_ha_find_match");
/* search for all handlers with matching table names */
for (uint i= 0; i < thd->handler_tables_hash.records; i++)
{
hash_tables= (SQL_HANDLER*) my_hash_element(&thd->handler_tables_hash, i);
for (tables= first; tables; tables= tables->next_local)
{
if (tables->is_anonymous_derived_table())
continue;
if ((! tables->db.str[0] ||
! my_strcasecmp(&my_charset_latin1, hash_tables->db.str,
tables->get_db_name())) &&
! my_strcasecmp(&my_charset_latin1, hash_tables->table_name.str,
tables->get_table_name()))
{
/* Link into hash_tables list */
hash_tables->next= head;
head= hash_tables;
break;
}
}
}
DBUG_RETURN(head);
} | O3 | cpp | mysql_ha_find_match(THD*, TABLE_LIST*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r15d, %r15d
cmpq $0x0, 0x25d0(%rdi)
je 0x7363a8
movq %rsi, %rbx
leaq 0x25b8(%rdi), %rax
movq %rax, -0x38(%rbp)
leaq 0xdcd078(%rip), %r13 # 0x1503340
xorl %r14d, %r14d
movq %rsi, -0x30(%rbp)
movq %rdi, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0xcb3ad2
testq %rbx, %rbx
je 0x73637e
movq %rax, %r12
cmpq $0x0, 0x128(%rbx)
setne %cl
movq 0x198(%rbx), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x73636d
movq 0x18(%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x736342
leaq 0x258(%rbx), %rcx
leaq 0x18(%rbx), %rdx
testq %rax, %rax
movq 0xc0(%r13), %rax
movq 0x38(%r12), %rsi
cmoveq %rdx, %rcx
movq (%rcx), %rdx
movq %r13, %rdi
callq *0x40(%rax)
testl %eax, %eax
jne 0x73636d
movq 0x198(%rbx), %rax
movq 0xc0(%r13), %rcx
movq 0x48(%r12), %rsi
leaq 0x268(%rbx), %rdx
leaq 0x28(%rbx), %rdi
testq %rax, %rax
cmoveq %rdi, %rdx
movq (%rdx), %rdx
movq %r13, %rdi
callq *0x40(%rcx)
testl %eax, %eax
je 0x736383
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x7362eb
movq %r14, %r12
jmp 0x73638b
movq %r14, %r12
jmp 0x73638f
movq %r14, 0x278(%r12)
movq -0x30(%rbp), %rbx
incl %r15d
movq %r12, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, 0x25d0(%rdi)
ja 0x7362d3
jmp 0x7363ab
xorl %r12d, %r12d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZL19mysql_ha_find_matchP3THDP10TABLE_LIST:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
xor r15d, r15d
cmp qword ptr [rdi+25D0h], 0
jz loc_7363A8
mov rbx, rsi
lea rax, [rdi+25B8h]
mov [rbp+var_38], rax
lea r13, my_charset_latin1
xor r14d, r14d
mov [rbp+var_30], rsi
mov [rbp+var_40], rdi
loc_7362D3:
mov rdi, [rbp+var_38]
mov rsi, r15
call my_hash_element
test rbx, rbx
jz loc_73637E
mov r12, rax
loc_7362EB:
cmp qword ptr [rbx+128h], 0
setnz cl
mov rax, [rbx+198h]
test rax, rax
setz dl
test cl, dl
jnz short loc_73636D
mov rcx, [rbx+18h]
cmp byte ptr [rcx], 0
jz short loc_736342
lea rcx, [rbx+258h]
lea rdx, [rbx+18h]
test rax, rax
mov rax, [r13+0C0h]
mov rsi, [r12+38h]
cmovz rcx, rdx
mov rdx, [rcx]
mov rdi, r13
call qword ptr [rax+40h]
test eax, eax
jnz short loc_73636D
mov rax, [rbx+198h]
loc_736342:
mov rcx, [r13+0C0h]
mov rsi, [r12+48h]
lea rdx, [rbx+268h]
lea rdi, [rbx+28h]
test rax, rax
cmovz rdx, rdi
mov rdx, [rdx]
mov rdi, r13
call qword ptr [rcx+40h]
test eax, eax
jz short loc_736383
loc_73636D:
mov rbx, [rbx]
test rbx, rbx
jnz loc_7362EB
mov r12, r14
jmp short loc_73638B
loc_73637E:
mov r12, r14
jmp short loc_73638F
loc_736383:
mov [r12+278h], r14
loc_73638B:
mov rbx, [rbp+var_30]
loc_73638F:
inc r15d
mov r14, r12
mov rdi, [rbp+var_40]
cmp [rdi+25D0h], r15
ja loc_7362D3
jmp short loc_7363AB
loc_7363A8:
xor r12d, r12d
loc_7363AB:
mov rax, r12
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _QWORD * mysql_ha_find_match(THD *a1, TABLE_LIST *a2)
{
unsigned long long v2; // r15
TABLE_LIST *v3; // rbx
_QWORD *v4; // r14
long long v5; // rax
_QWORD *v6; // r12
long long v7; // rax
_QWORD *v8; // rcx
_QWORD *v9; // rdx
v2 = 0LL;
if ( !*((_QWORD *)a1 + 1210) )
return 0LL;
v3 = a2;
v4 = 0LL;
do
{
v5 = my_hash_element((char *)a1 + 9656, v2);
if ( !v3 )
{
v6 = v4;
goto LABEL_19;
}
v6 = (_QWORD *)v5;
while ( 1 )
{
v7 = *((_QWORD *)v3 + 51);
if ( v7 != 0 || *((_QWORD *)v3 + 37) == 0LL )
{
if ( **((_BYTE **)v3 + 3) )
{
v8 = (_QWORD *)((char *)v3 + 600);
if ( !v7 )
v8 = (_QWORD *)((char *)v3 + 24);
if ( (*(unsigned int ( **)(void *, _QWORD, _QWORD))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
v6[7],
*v8) )
{
goto LABEL_14;
}
v7 = *((_QWORD *)v3 + 51);
}
v9 = (_QWORD *)((char *)v3 + 616);
if ( !v7 )
v9 = (_QWORD *)((char *)v3 + 40);
if ( !(*(unsigned int ( **)(void *, _QWORD, _QWORD))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
v6[9],
*v9) )
break;
}
LABEL_14:
v3 = *(TABLE_LIST **)v3;
if ( !v3 )
{
v6 = v4;
goto LABEL_18;
}
}
v6[79] = v4;
LABEL_18:
v3 = a2;
LABEL_19:
v2 = (unsigned int)(v2 + 1);
v4 = v6;
}
while ( *((_QWORD *)a1 + 1210) > v2 );
return v6;
}
| |||
39,507 | 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>::empty() const | monkey531[P]llama/common/json.hpp | bool empty() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
{
// null values are empty
return true;
}
case value_t::array:
{
// delegate call to array_t::empty()
return m_data.m_value.array->empty();
}
case value_t::object:
{
// delegate call to object_t::empty()
return m_data.m_value.object->empty();
}
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
// all other types are nonempty
return false;
}
}
} | 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>::empty() const:
movzbl (%rdi), %eax
testl %eax, %eax
je 0xa2db0
cmpl $0x1, %eax
je 0xa2da1
cmpl $0x2, %eax
jne 0xa2db3
movq 0x8(%rdi), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
sete %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5emptyEv:
movzx eax, byte ptr [rdi]
test eax, eax
jz short loc_A2DB0
cmp eax, 1
jz short loc_A2DA1
cmp eax, 2
jnz short loc_A2DB3
loc_A2DA1:
mov rax, [rdi+8]
mov rcx, [rax]
cmp rcx, [rax+8]
setz al
retn
loc_A2DB0:
mov al, 1
retn
loc_A2DB3:
xor eax, eax
retn
| bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::empty(
unsigned __int8 *a1)
{
int v1; // eax
v1 = *a1;
if ( !*a1 )
return 1;
if ( v1 == 1 || v1 == 2 )
return **((_QWORD **)a1 + 1) == *(_QWORD *)(*((_QWORD *)a1 + 1) + 8LL);
return 0;
}
| empty:
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JZ 0x001a2db0
CMP EAX,0x1
JZ 0x001a2da1
CMP EAX,0x2
JNZ 0x001a2db3
LAB_001a2da1:
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX]
CMP RCX,qword ptr [RAX + 0x8]
SETZ AL
RET
LAB_001a2db0:
MOV AL,0x1
RET
LAB_001a2db3:
XOR EAX,EAX
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::empty() const */
int8 __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>
::empty(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>
bVar1;
long *plVar2;
bVar1 = *this;
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
return 1;
}
if ((bVar1 != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) &&
(bVar1 != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2)) {
return 0;
}
plVar2 = *(long **)(this + 8);
return CONCAT71((int7)((ulong)plVar2 >> 8),*plVar2 == plVar2[1]);
}
| |
39,508 | pfs_start_file_close_wait_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_start_file_close_wait_v1(PSI_file_locker *locker,
const char *src_file,
uint src_line)
{
PFS_thread *thread;
const char *name;
uint len;
PFS_file *pfs_file;
PSI_file_locker_state *state= reinterpret_cast<PSI_file_locker_state*> (locker);
assert(state != NULL);
switch (state->m_operation)
{
case PSI_FILE_DELETE:
thread= reinterpret_cast<PFS_thread*> (state->m_thread);
name= state->m_name;
len= (uint)strlen(name);
pfs_file= find_or_create_file(thread, NULL, name, len, false);
state->m_file= reinterpret_cast<PSI_file*> (pfs_file);
break;
case PSI_FILE_STREAM_CLOSE:
case PSI_FILE_CLOSE:
break;
default:
assert(false);
break;
}
pfs_start_file_wait_v1(locker, 0, src_file, src_line);
return;
} | O0 | cpp | pfs_start_file_close_wait_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x44(%rbp)
addl $-0x4, %eax
subl $0x2, %eax
jb 0xef74e6
jmp 0xef748f
movl -0x44(%rbp), %eax
subl $0xe, %eax
jne 0xef74e8
jmp 0xef7499
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7585f0
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %esi
xorl %r8d, %r8d
callq 0xf0cb70
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xef74ea
jmp 0xef74ea
jmp 0xef74ea
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
xorl %eax, %eax
movl %eax, %esi
callq 0xef6ec0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| pfs_start_file_close_wait_v1:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov eax, [rax+4]
mov [rbp+var_44], eax
add eax, 0FFFFFFFCh
sub eax, 2
jb short loc_EF74E6
jmp short $+2
loc_EF748F:
mov eax, [rbp+var_44]
sub eax, 0Eh
jnz short loc_EF74E8
jmp short $+2
loc_EF7499:
mov rax, [rbp+var_40]
mov rax, [rax+20h]
mov [rbp+var_20], rax
mov rax, [rbp+var_40]
mov rax, [rax+10h]
mov [rbp+var_28], rax
mov rdi, [rbp+var_28]
call _strlen
mov [rbp+var_2C], eax
mov rdi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov ecx, [rbp+var_2C]
xor eax, eax
mov esi, eax
xor r8d, r8d
call _Z19find_or_create_fileP10PFS_threadP14PFS_file_classPKcjb; find_or_create_file(PFS_thread *,PFS_file_class *,char const*,uint,bool)
mov [rbp+var_38], rax
mov rcx, [rbp+var_38]
mov rax, [rbp+var_40]
mov [rax+8], rcx
jmp short loc_EF74EA
loc_EF74E6:
jmp short loc_EF74EA
loc_EF74E8:
jmp short $+2
loc_EF74EA:
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
xor eax, eax
mov esi, eax
call pfs_start_file_wait_v1
add rsp, 50h
pop rbp
retn
| long long pfs_start_file_close_wait_v1(long long a1, long long a2, int a3)
{
int v4; // [rsp+Ch] [rbp-44h]
unsigned int v5; // [rsp+24h] [rbp-2Ch]
long long v6; // [rsp+28h] [rbp-28h]
long long v7; // [rsp+30h] [rbp-20h]
v4 = *(_DWORD *)(a1 + 4);
if ( (unsigned int)(v4 - 4) >= 2 && v4 == 14 )
{
v7 = *(_QWORD *)(a1 + 32);
v6 = *(_QWORD *)(a1 + 16);
v5 = strlen(v6);
*(_QWORD *)(a1 + 8) = find_or_create_file(v7, 0LL, v6, v5, 0LL);
}
return pfs_start_file_wait_v1((int *)a1, 0LL, a2, a3);
}
| vio_get_normalized_ip:
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 RAX,qword ptr [RBP + -0x8]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x5c],EAX
SUB EAX,0x2
JZ 0x00ef7492
JMP 0x00ef7485
LAB_00ef7485:
MOV EAX,dword ptr [RBP + -0x5c]
SUB EAX,0xa
JZ 0x00ef74a8
JMP 0x00ef75c9
LAB_00ef7492:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
CALL 0x00859350
JMP 0x00ef75c9
LAB_00ef74a8:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x8
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x38],RAX
MOV RCX,qword ptr [RBP + -0x38]
XOR EAX,EAX
CMP dword ptr [RCX],0x0
MOV byte ptr [RBP + -0x5d],AL
JNZ 0x00ef750a
MOV RCX,qword ptr [RBP + -0x38]
XOR EAX,EAX
CMP dword ptr [RCX + 0x4],0x0
MOV byte ptr [RBP + -0x5d],AL
JNZ 0x00ef750a
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x64],EAX
MOV EDI,0xffff
CALL 0x00859d60
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x64]
CMP EAX,ECX
SETZ AL
MOV byte ptr [RBP + -0x5d],AL
LAB_00ef750a:
MOV AL,byte ptr [RBP + -0x5d]
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x00ef7575
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RCX,qword ptr [RBP + -0x48]
XOR EAX,EAX
CMP dword ptr [RCX],0x0
MOV byte ptr [RBP + -0x65],AL
JNZ 0x00ef7564
MOV RCX,qword ptr [RBP + -0x48]
XOR EAX,EAX
CMP dword ptr [RCX + 0x4],0x0
MOV byte ptr [RBP + -0x65],AL
JNZ 0x00ef7564
MOV RCX,qword ptr [RBP + -0x48]
XOR EAX,EAX
CMP dword ptr [RCX + 0x8],0x0
MOV byte ptr [RBP + -0x65],AL
JNZ 0x00ef7564
MOV RAX,qword ptr [RBP + -0x48]
MOV EDI,dword ptr [RAX + 0xc]
CALL 0x0085a520
CMP EAX,0x1
SETA AL
MOV byte ptr [RBP + -0x65],AL
LAB_00ef7564:
MOV AL,byte ptr [RBP + -0x65]
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x4c],EAX
CMP dword ptr [RBP + -0x4c],0x0
JZ 0x00ef75b6
LAB_00ef7575:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x58]
XOR ESI,ESI
MOV EDX,0x10
CALL 0x008584b0
MOV RAX,qword ptr [RBP + -0x58]
MOV word ptr [RAX],0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV CX,word ptr [RAX + 0x2]
MOV RAX,qword ptr [RBP + -0x58]
MOV word ptr [RAX + 0x2],CX
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RAX + 0x4],ECX
JMP 0x00ef75c7
LAB_00ef75b6:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
CALL 0x00859350
LAB_00ef75c7:
JMP 0x00ef75c9
LAB_00ef75c9:
ADD RSP,0x70
POP RBP
RET
|
void vio_get_normalized_ip(short *param_1,size_t param_2,int2 *param_3)
{
uint32_t uVar1;
uint32_t uVar2;
bool bVar3;
if (*param_1 == 2) {
memcpy(param_3,param_1,param_2);
}
else if (*param_1 == 10) {
bVar3 = false;
if ((*(int *)(param_1 + 4) == 0) && (bVar3 = false, *(int *)(param_1 + 6) == 0)) {
uVar2 = *(uint32_t *)(param_1 + 8);
uVar1 = htonl(0xffff);
bVar3 = uVar2 == uVar1;
}
if (!bVar3) {
bVar3 = false;
if (((*(int *)(param_1 + 4) == 0) && (bVar3 = false, *(int *)(param_1 + 6) == 0)) &&
(bVar3 = false, *(int *)(param_1 + 8) == 0)) {
uVar2 = ntohl(*(uint32_t *)(param_1 + 10));
bVar3 = 1 < uVar2;
}
if (!bVar3) {
memcpy(param_3,param_1,param_2);
return;
}
}
memset(param_3,0,0x10);
*param_3 = 2;
param_3[1] = param_1[1];
*(int4 *)(param_3 + 2) = *(int4 *)(param_1 + 10);
}
return;
}
| |
39,509 | maria_page_crc_check_data | eloqsql/storage/maria/ma_pagecrc.c | my_bool maria_page_crc_check_data(int res, PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
if (res)
{
return 1;
}
return (maria_page_crc_check(page, (uint32) page_no, share,
MARIA_NO_CRC_NORMAL_PAGE,
share->block_size - CRC_SIZE));
} | O0 | c | maria_page_crc_check_data:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x5d0be
movb $0x1, -0x1(%rbp)
jmp 0x5d0ea
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %eax
movl %eax, %esi
movq -0x28(%rbp), %rdx
movq -0x28(%rbp), %rax
movl 0x7bc(%rax), %r8d
subl $0x4, %r8d
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0x5ce10
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| maria_page_crc_check_data:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_28], rax
cmp [rbp+var_8], 0
jz short loc_5D0BE
mov [rbp+var_1], 1
jmp short loc_5D0EA
loc_5D0BE:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_20]
mov eax, eax
mov esi, eax
mov rdx, [rbp+var_28]
mov rax, [rbp+var_28]
mov r8d, [rax+7BCh]
sub r8d, 4
mov ecx, 0FFFFFFFFh
call maria_page_crc_check
mov [rbp+var_1], al
loc_5D0EA:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| bool maria_page_crc_check_data(int a1, long long a2)
{
return a1
|| maria_page_crc_check(
*(_BYTE **)a2,
(const char *)(unsigned int)*(_QWORD *)(a2 + 8),
*(_QWORD *)(a2 + 16),
-1,
*(_DWORD *)(*(_QWORD *)(a2 + 16) + 1980LL) - 4);
}
| maria_page_crc_check_data:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x28],RAX
CMP dword ptr [RBP + -0x8],0x0
JZ 0x0015d0be
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0015d0ea
LAB_0015d0be:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,EAX
MOV ESI,EAX
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x28]
MOV R8D,dword ptr [RAX + 0x7bc]
SUB R8D,0x4
MOV ECX,0xffffffff
CALL 0x0015ce10
MOV byte ptr [RBP + -0x1],AL
LAB_0015d0ea:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 maria_page_crc_check_data(int param_1,int8 *param_2)
{
int1 local_9;
if (param_1 == 0) {
local_9 = maria_page_crc_check
(*param_2,param_2[1] & 0xffffffff,param_2[2],0xffffffff,
*(int *)(param_2[2] + 0x7bc) + -4);
}
else {
local_9 = 1;
}
return local_9;
}
| |
39,510 | wait_on_queue | eloqsql/mysys/mf_keycache.c | static void wait_on_queue(KEYCACHE_WQUEUE *wqueue,
mysql_mutex_t *mutex)
{
struct st_my_thread_var *last;
struct st_my_thread_var *thread= my_thread_var;
DBUG_ASSERT(!thread->next);
DBUG_ASSERT(!thread->prev); /* Not required, but must be true anyway. */
mysql_mutex_assert_owner(mutex);
/* Add to queue. */
if (! (last= wqueue->last_thread))
thread->next= thread;
else
{
thread->next= last->next;
last->next= thread;
}
wqueue->last_thread= thread;
/*
Wait until thread is removed from queue by the signaling thread.
The loop protects against stray signals.
*/
do
{
KEYCACHE_DBUG_PRINT("wait", ("suspend thread %ld", (ulong) thread->id));
keycache_pthread_cond_wait(&thread->suspend, mutex);
}
while (thread->next);
} | O3 | c | wait_on_queue:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0xa63fe
movq %rax, %r14
movq %rax, %r12
movq (%r15), %rax
testq %rax, %rax
je 0x99657
movq 0x88(%rax), %rcx
addq $0x88, %rax
movq %rcx, 0x88(%r12)
jmp 0x9965e
leaq 0x88(%r14), %rax
movq %r12, (%rax)
movq %r12, (%r15)
addq $0x8, %r14
leaq 0x46f7f(%rip), %r15 # 0xe05ee
cmpq $0x0, 0x38(%r12)
jne 0x9968f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a410
cmpq $0x0, 0x88(%r12)
jne 0x9966f
jmp 0x996a4
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x477, %ecx # imm = 0x477
callq 0x309d6
jmp 0x99682
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| wait_on_queue:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rsi
mov r15, rdi
call _my_thread_var
mov r14, rax
mov r12, rax
mov rax, [r15]
test rax, rax
jz short loc_99657
mov rcx, [rax+88h]
add rax, 88h
mov [r12+88h], rcx
jmp short loc_9965E
loc_99657:
lea rax, [r14+88h]
loc_9965E:
mov [rax], r12
mov [r15], r12
add r14, 8
lea r15, aWorkspaceLlm4b_40; "/workspace/llm4binary/github2025/eloqsq"...
loc_9966F:
cmp qword ptr [r12+38h], 0
jnz short loc_9968F
mov rdi, r14
mov rsi, rbx
call _pthread_cond_wait
loc_99682:
cmp qword ptr [r12+88h], 0
jnz short loc_9966F
jmp short loc_996A4
loc_9968F:
mov rdi, r14
mov rsi, rbx
mov rdx, r15
mov ecx, 477h
call psi_cond_wait
jmp short loc_99682
loc_996A4:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long wait_on_queue(long long *a1, const char *a2)
{
long long v2; // r14
long long v3; // r12
long long v4; // rax
long long v5; // rcx
long long *v6; // rax
long long v7; // r14
long long result; // rax
v2 = my_thread_var(a1, a2);
v3 = v2;
v4 = *a1;
if ( *a1 )
{
v5 = *(_QWORD *)(v4 + 136);
v6 = (long long *)(v4 + 136);
*(_QWORD *)(v2 + 136) = v5;
}
else
{
v6 = (long long *)(v2 + 136);
}
*v6 = v2;
*a1 = v2;
v7 = v2 + 8;
do
{
if ( *(_QWORD *)(v3 + 56) )
result = psi_cond_wait(
v7,
(long long)a2,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0x477u);
else
result = pthread_cond_wait(v7, a2);
}
while ( *(_QWORD *)(v3 + 136) );
return result;
}
| wait_on_queue:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RSI
MOV R15,RDI
CALL 0x001a63fe
MOV R14,RAX
MOV R12,RAX
MOV RAX,qword ptr [R15]
TEST RAX,RAX
JZ 0x00199657
MOV RCX,qword ptr [RAX + 0x88]
ADD RAX,0x88
MOV qword ptr [R12 + 0x88],RCX
JMP 0x0019965e
LAB_00199657:
LEA RAX,[R14 + 0x88]
LAB_0019965e:
MOV qword ptr [RAX],R12
MOV qword ptr [R15],R12
ADD R14,0x8
LEA R15,[0x1e05ee]
LAB_0019966f:
CMP qword ptr [R12 + 0x38],0x0
JNZ 0x0019968f
MOV RDI,R14
MOV RSI,RBX
CALL 0x0012a410
LAB_00199682:
CMP qword ptr [R12 + 0x88],0x0
JNZ 0x0019966f
JMP 0x001996a4
LAB_0019968f:
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
MOV ECX,0x477
CALL 0x001309d6
JMP 0x00199682
LAB_001996a4:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void wait_on_queue(long *param_1,pthread_mutex_t *param_2)
{
long lVar1;
long lVar2;
long lVar3;
lVar3 = _my_thread_var();
lVar1 = *param_1;
lVar2 = lVar3;
if (lVar1 != 0) {
*(int8 *)(lVar3 + 0x88) = *(int8 *)(lVar1 + 0x88);
lVar2 = lVar1;
}
*(long *)(lVar2 + 0x88) = lVar3;
*param_1 = lVar3;
do {
if (*(long *)(lVar3 + 0x38) == 0) {
pthread_cond_wait((pthread_cond_t *)(lVar3 + 8),param_2);
}
else {
psi_cond_wait((pthread_cond_t *)(lVar3 + 8),param_2,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0x477);
}
} while (*(long *)(lVar3 + 0x88) != 0);
return;
}
| |
39,511 | ftxui::(anonymous namespace)::BgColor::Render(ftxui::Screen&) | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/dom/color.cpp | void Render(Screen& screen) override {
for (int y = box_.y_min; y <= box_.y_max; ++y) {
for (int x = box_.x_min; x <= box_.x_max; ++x) {
screen.PixelAt(x, y).background_color = color_;
}
}
NodeDecorator::Render(screen);
} | O3 | cpp | ftxui::(anonymous namespace)::BgColor::Render(ftxui::Screen&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x54(%rdi), %r15d
movl 0x58(%rdi), %ecx
cmpl %ecx, %r15d
jg 0x22eb9
movl 0x50(%r14), %eax
movl 0x4c(%r14), %r12d
cmpl %eax, %r12d
jg 0x22ead
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x3985c
movl 0x5c(%r14), %ecx
movl %ecx, 0x28(%rax)
leal 0x1(%r12), %ecx
movl 0x50(%r14), %eax
cmpl %eax, %r12d
movl %ecx, %r12d
jl 0x22e83
movl 0x58(%r14), %ecx
leal 0x1(%r15), %edx
cmpl %ecx, %r15d
movl %edx, %r15d
jl 0x22e7a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x23eae
nop
| _ZN5ftxui12_GLOBAL__N_17BgColor6RenderERNS_6ScreenE:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov r15d, [rdi+54h]
mov ecx, [rdi+58h]
cmp r15d, ecx
jg short loc_22EB9
mov eax, [r14+50h]
loc_22E7A:
mov r12d, [r14+4Ch]
cmp r12d, eax
jg short loc_22EAD
loc_22E83:
mov rdi, rbx; this
mov esi, r12d; int
mov edx, r15d; int
call _ZN5ftxui6Screen7PixelAtEii; ftxui::Screen::PixelAt(int,int)
mov ecx, [r14+5Ch]
mov [rax+28h], ecx
lea ecx, [r12+1]
mov eax, [r14+50h]
cmp r12d, eax
mov r12d, ecx
jl short loc_22E83
mov ecx, [r14+58h]
loc_22EAD:
lea edx, [r15+1]
cmp r15d, ecx
mov r15d, edx
jl short loc_22E7A
loc_22EB9:
mov rdi, r14
mov rsi, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp _ZN5ftxui4Node6RenderERNS_6ScreenE; ftxui::Node::Render(ftxui::Screen &)
| long long ftxui::`anonymous namespace'::BgColor::Render(
ftxui::_anonymous_namespace_::BgColor *this,
ftxui::Screen *a2)
{
int v2; // r15d
int v3; // ecx
int v4; // eax
int v5; // r12d
bool v6; // cc
v2 = *((_DWORD *)this + 21);
v3 = *((_DWORD *)this + 22);
if ( v2 <= v3 )
{
v4 = *((_DWORD *)this + 20);
do
{
v5 = *((_DWORD *)this + 19);
if ( v5 <= v4 )
{
do
{
*(_DWORD *)(ftxui::Screen::PixelAt(a2, v5, v2) + 40) = *((_DWORD *)this + 23);
v4 = *((_DWORD *)this + 20);
v6 = v5++ < v4;
}
while ( v6 );
v3 = *((_DWORD *)this + 22);
}
v6 = v2++ < v3;
}
while ( v6 );
}
return ftxui::Node::Render(this, a2);
}
| Render:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV R15D,dword ptr [RDI + 0x54]
MOV ECX,dword ptr [RDI + 0x58]
CMP R15D,ECX
JG 0x00122eb9
MOV EAX,dword ptr [R14 + 0x50]
LAB_00122e7a:
MOV R12D,dword ptr [R14 + 0x4c]
CMP R12D,EAX
JG 0x00122ead
LAB_00122e83:
MOV RDI,RBX
MOV ESI,R12D
MOV EDX,R15D
CALL 0x0013985c
MOV ECX,dword ptr [R14 + 0x5c]
MOV dword ptr [RAX + 0x28],ECX
LEA ECX,[R12 + 0x1]
MOV EAX,dword ptr [R14 + 0x50]
CMP R12D,EAX
MOV R12D,ECX
JL 0x00122e83
MOV ECX,dword ptr [R14 + 0x58]
LAB_00122ead:
LEA EDX,[R15 + 0x1]
CMP R15D,ECX
MOV R15D,EDX
JL 0x00122e7a
LAB_00122eb9:
MOV RDI,R14
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x00123eae
|
/* ftxui::(anonymous namespace)::BgColor::Render(ftxui::Screen&) */
void __thiscall ftxui::(anonymous_namespace)::BgColor::Render(BgColor *this,Screen *param_1)
{
bool bVar1;
int iVar2;
long lVar3;
int iVar4;
int iVar5;
int iVar6;
iVar4 = *(int *)(this + 0x58);
if (*(int *)(this + 0x54) <= iVar4) {
iVar2 = *(int *)(this + 0x50);
iVar6 = *(int *)(this + 0x54);
do {
iVar5 = *(int *)(this + 0x4c);
if (*(int *)(this + 0x4c) <= iVar2) {
do {
lVar3 = Screen::PixelAt(param_1,iVar5,iVar6);
*(int4 *)(lVar3 + 0x28) = *(int4 *)(this + 0x5c);
iVar2 = *(int *)(this + 0x50);
bVar1 = iVar5 < iVar2;
iVar5 = iVar5 + 1;
} while (bVar1);
iVar4 = *(int *)(this + 0x58);
}
bVar1 = iVar6 < iVar4;
iVar6 = iVar6 + 1;
} while (bVar1);
}
Node::Render((Node *)this,param_1);
return;
}
| |
39,512 | ma_crypt_index_pre_write_hook | eloqsql/storage/maria/ma_crypt.c | static my_bool ma_crypt_index_pre_write_hook(PAGECACHE_IO_HOOK_ARGS *args)
{
MARIA_SHARE *share= (MARIA_SHARE*) args->data;
const uint block_size= share->block_size;
const uint page_used= _ma_get_page_used(share, args->page);
uint key_version;
uchar *crypt_buf= my_malloc(PSI_INSTRUMENT_ME, block_size, MYF(0));
if (crypt_buf == NULL)
{
args->crypt_buf= NULL; /* for post-hook */
return 1;
}
if (!share->base.born_transactional)
{
/* store a random number instead of LSN (for counter block) */
store_rand_lsn(args->page);
}
maria_page_crc_set_index(args);
{
const uchar *src= args->page;
uchar* dst= crypt_buf;
uint pageno= (uint)args->pageno;
LSN lsn= lsn_korr(src);
const uint head= share->keypage_header;
const uint tail= CRC_SIZE;
/* page_used includes header (but not trailer) */
const uint size= page_used - head;
/* 1 - copy head */
memcpy(dst, src, head);
/* 2 - encrypt page */
if (ma_encrypt(share, share->crypt_data,
src + head, dst + head, size, pageno, lsn, &key_version))
{
my_free(crypt_buf);
return 1;
}
/* 3 - copy tail */
memcpy(dst + block_size - tail, src + block_size - tail, tail);
/* 4 - store key version */
_ma_store_key_version(share, dst, key_version);
#ifdef HAVE_valgrind
/* 5 - keep valgrind happy by zeroing not used bytes */
bzero(dst+head+size, block_size - size - tail - head);
#endif
}
/* swap pointers to instead write out the encrypted block */
args->crypt_buf= args->page;
args->page= crypt_buf;
return 0;
} | O0 | c | ma_crypt_index_pre_write_hook:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x744(%rcx), %ecx
movzbl -0x1(%rax,%rcx), %eax
movzwl %ax, %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x18(%rbp), %rdx
movl 0x744(%rdx), %edx
movzbl -0x2(%rcx,%rdx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %esi
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0xf3800
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x89a35
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x89b84
movq -0x18(%rbp), %rax
cmpb $0x0, 0x44c(%rax)
jne 0x89a4e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x89d50
movq -0x10(%rbp), %rdi
callq 0x41220
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
movq -0x38(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x38(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
shlq $0x20, %rax
movq -0x38(%rbp), %rcx
movl 0x3(%rcx), %ecx
orq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movl 0x744(%rax), %eax
movl %eax, -0x54(%rbp)
movl $0x4, -0x58(%rbp)
movl -0x20(%rbp), %eax
subl -0x54(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x54(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0xc20(%rax), %rsi
movq -0x38(%rbp), %rdx
movl -0x54(%rbp), %eax
addq %rax, %rdx
movq -0x40(%rbp), %rcx
movl -0x54(%rbp), %eax
addq %rax, %rcx
movl -0x5c(%rbp), %r8d
movl -0x44(%rbp), %r9d
movq -0x50(%rbp), %r10
leaq -0x24(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x89e00
cmpl $0x0, %eax
je 0x89b2e
movq -0x30(%rbp), %rdi
callq 0xf3b80
movb $0x1, -0x1(%rbp)
jmp 0x89b84
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %rdx
movl -0x1c(%rbp), %esi
movl -0x4(%rdx,%rsi), %edx
movl %edx, -0x4(%rax,%rcx)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x744(%rcx), %ecx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x68(%rbp)
movl -0x24(%rbp), %ecx
movq -0x68(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x80, %rsp
popq %rbp
retq
| ma_crypt_index_pre_write_hook:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov eax, [rax+7BCh]
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_18]
mov ecx, [rcx+744h]
movzx eax, byte ptr [rax+rcx-1]
movzx eax, ax
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov rdx, [rbp+var_18]
mov edx, [rdx+744h]
movzx ecx, byte ptr [rcx+rdx-2]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_20], eax
mov eax, [rbp+var_1C]
mov esi, eax
xor edi, edi
xor eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jnz short loc_89A35
mov rax, [rbp+var_10]
mov qword ptr [rax+18h], 0
mov [rbp+var_1], 1
jmp loc_89B84
loc_89A35:
mov rax, [rbp+var_18]
cmp byte ptr [rax+44Ch], 0
jnz short loc_89A4E
mov rax, [rbp+var_10]
mov rdi, [rax]
call store_rand_lsn
loc_89A4E:
mov rdi, [rbp+var_10]
call maria_page_crc_set_index
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_44], eax
mov rax, [rbp+var_38]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
shl rax, 20h
mov rcx, [rbp+var_38]
mov ecx, [rcx+3]
or rax, rcx
mov [rbp+var_50], rax
mov rax, [rbp+var_18]
mov eax, [rax+744h]
mov [rbp+var_54], eax
mov [rbp+var_58], 4
mov eax, [rbp+var_20]
sub eax, [rbp+var_54]
mov [rbp+var_5C], eax
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_38]
mov eax, [rbp+var_54]
mov edx, eax
call _memcpy
mov rdi, [rbp+var_18]
mov rax, [rbp+var_18]
mov rsi, [rax+0C20h]
mov rdx, [rbp+var_38]
mov eax, [rbp+var_54]
add rdx, rax
mov rcx, [rbp+var_40]
mov eax, [rbp+var_54]
add rcx, rax
mov r8d, [rbp+var_5C]
mov r9d, [rbp+var_44]
mov r10, [rbp+var_50]
lea rax, [rbp+var_24]
mov [rsp+80h+var_80], r10
mov [rsp+80h+var_78], rax
call ma_encrypt
cmp eax, 0
jz short loc_89B2E
mov rdi, [rbp+var_30]
call my_free
mov [rbp+var_1], 1
jmp short loc_89B84
loc_89B2E:
mov rax, [rbp+var_40]
mov ecx, [rbp+var_1C]
mov rdx, [rbp+var_38]
mov esi, [rbp+var_1C]
mov edx, [rdx+rsi-4]
mov [rax+rcx-4], edx
mov rax, [rbp+var_40]
mov rcx, [rbp+var_18]
mov ecx, [rcx+744h]
add rax, rcx
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_68], rax
mov ecx, [rbp+var_24]
mov rax, [rbp+var_68]
mov [rax], ecx
mov rax, [rbp+var_10]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_1], 0
loc_89B84:
mov al, [rbp+var_1]
add rsp, 80h
pop rbp
retn
| char ma_crypt_index_pre_write_hook(long long *a1)
{
unsigned int v2; // [rsp+2Ch] [rbp-54h]
unsigned long long v3; // [rsp+30h] [rbp-50h]
int v4; // [rsp+3Ch] [rbp-44h]
unsigned __int16 *v5; // [rsp+48h] [rbp-38h]
long long v6; // [rsp+50h] [rbp-30h]
int v7; // [rsp+5Ch] [rbp-24h] BYREF
int v8; // [rsp+60h] [rbp-20h]
unsigned int v9; // [rsp+64h] [rbp-1Ch]
long long v10; // [rsp+68h] [rbp-18h]
long long *v11; // [rsp+70h] [rbp-10h]
v11 = a1;
v10 = a1[2];
v9 = *(_DWORD *)(v10 + 1980);
v8 = _byteswap_ushort(*(_WORD *)(*a1 + *(unsigned int *)(v10 + 1860) - 2));
v6 = my_malloc(0LL, v9, 0LL);
if ( v6 )
{
if ( !*(_BYTE *)(v10 + 1100) )
store_rand_lsn(*v11);
maria_page_crc_set_index(v11);
v5 = (unsigned __int16 *)*v11;
v4 = v11[1];
v3 = *(unsigned int *)(*v11 + 3) | ((unsigned long long)((*((unsigned __int8 *)v5 + 2) << 16) | (unsigned int)*v5) << 32);
v2 = *(_DWORD *)(v10 + 1860);
memcpy(v6, *v11, v2);
if ( (unsigned int)ma_encrypt(
v10,
*(_QWORD *)(v10 + 3104),
v2 + (unsigned int)v5,
v2 + (unsigned int)v6,
v8 - v2,
v4,
v3,
(long long)&v7) )
{
my_free(v6);
return 1;
}
else
{
*(_DWORD *)(v6 + v9 - 4) = *(_DWORD *)((char *)v5 + v9 - 4);
*(_DWORD *)(*(unsigned int *)(v10 + 1860) + v6 - 8) = v7;
v11[3] = *v11;
*v11 = v6;
return 0;
}
}
else
{
v11[3] = 0LL;
return 1;
}
}
| ma_crypt_index_pre_write_hook:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x744]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + -0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV RDX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RDX + 0x744]
MOVZX ECX,byte ptr [RCX + RDX*0x1 + -0x2]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV ESI,EAX
XOR EDI,EDI
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f3800
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00189a35
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],0x0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00189b84
LAB_00189a35:
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x44c],0x0
JNZ 0x00189a4e
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00189d50
LAB_00189a4e:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00141220
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
SHL RAX,0x20
MOV RCX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RCX + 0x3]
OR RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x744]
MOV dword ptr [RBP + -0x54],EAX
MOV dword ptr [RBP + -0x58],0x4
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x5c],EAX
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x54]
MOV EDX,EAX
CALL 0x0012a090
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0xc20]
MOV RDX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x54]
ADD RDX,RAX
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x54]
ADD RCX,RAX
MOV R8D,dword ptr [RBP + -0x5c]
MOV R9D,dword ptr [RBP + -0x44]
MOV R10,qword ptr [RBP + -0x50]
LEA RAX,[RBP + -0x24]
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00189e00
CMP EAX,0x0
JZ 0x00189b2e
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001f3b80
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00189b84
LAB_00189b2e:
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x1c]
MOV RDX,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x1c]
MOV EDX,dword ptr [RDX + RSI*0x1 + -0x4]
MOV dword ptr [RAX + RCX*0x1 + -0x4],EDX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x744]
ADD RAX,RCX
ADD RAX,-0x8
MOV qword ptr [RBP + -0x68],RAX
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x68]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV byte ptr [RBP + -0x1],0x0
LAB_00189b84:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x80
POP RBP
RET
|
int1 ma_crypt_index_pre_write_hook(long *param_1)
{
int4 uVar1;
uint uVar2;
int3 *__src;
ulong uVar3;
int3 uVar4;
int iVar5;
void *__dest;
int4 local_2c;
uint local_28;
uint local_24;
long local_20;
long *local_18;
int1 local_9;
local_20 = param_1[2];
local_24 = *(uint *)(local_20 + 0x7bc);
local_28 = (uint)CONCAT11(*(int1 *)(*param_1 + -2 + (ulong)*(uint *)(local_20 + 0x744)),
*(int1 *)(*param_1 + -1 + (ulong)*(uint *)(local_20 + 0x744)));
local_18 = param_1;
__dest = (void *)my_malloc(0,local_24,0);
if (__dest == (void *)0x0) {
local_18[3] = 0;
local_9 = 1;
}
else {
if (*(char *)(local_20 + 0x44c) == '\0') {
store_rand_lsn(*local_18);
}
maria_page_crc_set_index(local_18);
__src = (int3 *)*local_18;
uVar3 = local_18[1];
uVar4 = *__src;
uVar1 = *(int4 *)((long)__src + 3);
uVar2 = *(uint *)(local_20 + 0x744);
iVar5 = local_28 - uVar2;
memcpy(__dest,__src,(ulong)uVar2);
iVar5 = ma_encrypt(local_20,*(int8 *)(local_20 + 0xc20),(long)__src + (ulong)uVar2,
(long)__dest + (ulong)uVar2,iVar5,uVar3 & 0xffffffff,
(ulong)CONCAT34(uVar4,uVar1),&local_2c);
if (iVar5 == 0) {
*(int4 *)((long)__dest + ((ulong)local_24 - 4)) =
*(int4 *)((long)__src + ((ulong)local_24 - 4));
*(int4 *)((long)__dest + ((ulong)*(uint *)(local_20 + 0x744) - 8)) = local_2c;
local_18[3] = *local_18;
*local_18 = (long)__dest;
local_9 = 0;
}
else {
my_free(__dest);
local_9 = 1;
}
}
return local_9;
}
| |
39,513 | minja::Value::at(minja::Value const&) | monkey531[P]llama/common/minja.hpp | Value& at(const Value & index) {
if (!index.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
if (is_array()) return array_->at(index.get<int>());
if (is_object()) return object_->at(index.primitive_);
throw std::runtime_error("Value is not an array or object: " + dump());
} | O3 | cpp | minja::Value::at(minja::Value const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x0, 0x10(%rsi)
jne 0x930f9
cmpq $0x0, 0x20(%rsi)
jne 0x930f9
cmpq $0x0, 0x30(%rsi)
jne 0x930f9
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0x930df
movq %rsi, %rdi
callq 0x906b8
movslq %eax, %rsi
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x93156
leaq (%rsi,%rsi,4), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x93164
addq $0x40, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x94618
movl $0x10, %edi
callq 0x1b440
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x86334
leaq 0x5efef(%rip), %rsi # 0xf210e
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x78ac9
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1be00
xorl %ebp, %ebp
movq 0x9aea3(%rip), %rsi # 0x12dfe8
movq 0x9ae04(%rip), %rdx # 0x12df50
movq %rbx, %rdi
callq 0x1bef0
jmp 0x931bf
leaq 0x5f11f(%rip), %rdi # 0xf227c
xorl %eax, %eax
callq 0x1bcf0
movl $0x10, %edi
callq 0x1b440
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x86334
leaq 0x5f0d0(%rip), %rsi # 0xf225a
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x78ac9
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1be00
xorl %ebp, %ebp
movq 0x9ae38(%rip), %rsi # 0x12dfe8
movq 0x9ad99(%rip), %rdx # 0x12df50
movq %rbx, %rdi
callq 0x1bef0
jmp 0x931c5
jmp 0x93205
jmp 0x93225
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x931e3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b8b0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x931fe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8b0
testb %bpl, %bpl
jne 0x93228
jmp 0x93230
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x93228
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8b0
jmp 0x93228
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b650
movq %r14, %rdi
callq 0x1bf70
| _ZN5minja5Value2atERKS0_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
cmp qword ptr [rsi+10h], 0
jnz short loc_930F9
cmp qword ptr [rsi+20h], 0
jnz short loc_930F9
cmp qword ptr [rsi+30h], 0
jnz short loc_930F9
mov rbx, [r14+10h]
test rbx, rbx
jz short loc_930DF
mov rdi, rsi
call _ZNK5minja5Value3getIiEET_v; minja::Value::get<int>(void)
movsxd rsi, eax
mov rax, [rbx]
mov rcx, [rbx+8]
sub rcx, rax
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
cmp rdx, rsi
jbe loc_93156
lea rcx, [rsi+rsi*4]
shl rcx, 4
add rax, rcx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_930DF:
mov rdi, [r14+20h]
test rdi, rdi
jz short loc_93164
add rsi, 40h ; '@'
add rsp, 40h
pop rbx
pop r14
pop rbp
jmp _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atERSJ_; 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>>>::at(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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&)
loc_930F9:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_931BF
loc_93156:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
loc_93164:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr_0; "Value is not an array or object: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_931BF:
jmp short loc_931C5
jmp short loc_93205
jmp short loc_93225
loc_931C5:
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_931E3
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_931E3:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_931FE
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_931FE:
test bpl, bpl
jnz short loc_93228
jmp short loc_93230
loc_93205:
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_93228
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_93228
loc_93225:
mov r14, rax
loc_93228:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_93230:
mov rdi, r14
call __Unwind_Resume
| unsigned long long minja::Value::at(minja::Value *this, const minja::Value *a2)
{
_QWORD *v3; // rbx
unsigned long long v4; // rsi
unsigned long long v5; // rdx
long long v7; // rdi
void *exception; // rbx
void *v9; // rbx
_BYTE v10[16]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v11[16]; // [rsp+20h] [rbp-38h] BYREF
if ( *((_QWORD *)a2 + 2) || *((_QWORD *)a2 + 4) || *((_QWORD *)a2 + 6) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Unashable type: ", (long long)v10);
std::runtime_error::runtime_error(exception, v11);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = (_QWORD *)*((_QWORD *)this + 2);
if ( v3 )
{
v4 = (int)minja::Value::get<int>(a2);
v5 = 0xCCCCCCCCCCCCCCCDLL * ((long long)(v3[1] - *v3) >> 4);
if ( v5 <= v4 )
std::__throw_out_of_range_fmt("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)", v4, v5);
return 80 * v4 + *v3;
}
else
{
v7 = *((_QWORD *)this + 4);
if ( !v7 )
{
v9 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Value is not an array or object: ", (long long)v10);
std::runtime_error::runtime_error(v9, v11);
__cxa_throw(
v9,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return 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>>>::at(
v7,
(char *)a2 + 64);
}
}
| at:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP qword ptr [RSI + 0x10],0x0
JNZ 0x001930f9
CMP qword ptr [RSI + 0x20],0x0
JNZ 0x001930f9
CMP qword ptr [RSI + 0x30],0x0
JNZ 0x001930f9
MOV RBX,qword ptr [R14 + 0x10]
TEST RBX,RBX
JZ 0x001930df
MOV RDI,RSI
CALL 0x001906b8
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
SUB RCX,RAX
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
CMP RDX,RSI
JBE 0x00193156
LEA RCX,[RSI + RSI*0x4]
SHL RCX,0x4
ADD RAX,RCX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001930df:
MOV RDI,qword ptr [R14 + 0x20]
TEST RDI,RDI
JZ 0x00193164
ADD RSI,0x40
ADD RSP,0x40
POP RBX
POP R14
POP RBP
JMP 0x00194618
LAB_001930f9:
MOV EDI,0x10
CALL 0x0011b440
MOV RBX,RAX
LAB_00193106:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x00186334
LAB_00193118:
LEA RSI,[0x1f210e]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00178ac9
MOV BPL,0x1
LAB_0019312f:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x0011be00
XOR EBP,EBP
MOV RSI,qword ptr [0x0022dfe8]
MOV RDX,qword ptr [0x0022df50]
MOV RDI,RBX
CALL 0x0011bef0
LAB_00193156:
LEA RDI,[0x1f227c]
XOR EAX,EAX
CALL 0x0011bcf0
LAB_00193164:
MOV EDI,0x10
CALL 0x0011b440
MOV RBX,RAX
LAB_00193171:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x00186334
LAB_00193183:
LEA RSI,[0x1f225a]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00178ac9
MOV BPL,0x1
LAB_0019319a:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x0011be00
XOR EBP,EBP
MOV RSI,qword ptr [0x0022dfe8]
MOV RDX,qword ptr [0x0022df50]
MOV RDI,RBX
CALL 0x0011bef0
|
/* minja::Value::at(minja::Value const&) */
long __thiscall minja::Value::at(Value *this,Value *param_1)
{
long *plVar1;
int iVar2;
long lVar3;
runtime_error *prVar4;
ulong uVar5;
ulong uVar6;
int1 auStack_58 [32];
string local_38 [32];
if (((*(long *)(param_1 + 0x10) == 0) && (*(long *)(param_1 + 0x20) == 0)) &&
(*(long *)(param_1 + 0x30) == 0)) {
plVar1 = *(long **)(this + 0x10);
if (plVar1 == (long *)0x0) {
if (*(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
**)(this + 0x20) !=
(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)0x0) {
lVar3 = nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::at(*(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
**)(this + 0x20),(basic_json *)(param_1 + 0x40));
return lVar3;
}
}
else {
iVar2 = get<int>(param_1);
uVar6 = (ulong)iVar2;
uVar5 = (plVar1[1] - *plVar1 >> 4) * -0x3333333333333333;
if (uVar6 <= uVar5 && uVar5 - uVar6 != 0) {
return *plVar1 + uVar6 * 0x50;
}
std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)");
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00193171 to 00193182 has its CatchHandler @ 001931c3 */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 00193183 to 00193196 has its CatchHandler @ 001931c1 */
std::operator+((char *)local_38,(string *)"Value is not an array or object: ");
/* try { // try from 0019319a to 001931be has its CatchHandler @ 001931bf */
std::runtime_error::runtime_error(prVar4,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_0022dfe8,PTR__runtime_error_0022df50);
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00193106 to 00193117 has its CatchHandler @ 00193225 */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 00193118 to 0019312b has its CatchHandler @ 00193205 */
std::operator+((char *)local_38,(string *)"Unashable type: ");
/* try { // try from 0019312f to 00193153 has its CatchHandler @ 001931c5 */
std::runtime_error::runtime_error(prVar4,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_0022dfe8,PTR__runtime_error_0022df50);
}
| |
39,514 | ftxui::(anonymous namespace)::Frame::Render(ftxui::Screen&) | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/dom/frame.cpp | void Render(Screen& screen) override {
const AutoReset<Box> stencil(&screen.stencil,
Box::Intersection(box_, screen.stencil));
children_[0]->Render(screen);
} | O2 | cpp | ftxui::(anonymous namespace)::Frame::Render(ftxui::Screen&):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x4c(%rdi), %rdi
movq 0x54(%r14), %rsi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
callq 0x2fcbc
movups (%rbx), %xmm0
movaps %xmm0, (%rsp)
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movq 0x8(%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x20(%rax)
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq %rax, %rdi
callq 0xc7f0
nop
| _ZN5ftxui12_GLOBAL__N_15Frame6RenderERNS_6ScreenE:
push r14
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14, rdi
mov rdi, [rdi+4Ch]
mov rsi, [r14+54h]
mov rdx, [rbx]
mov rcx, [rbx+8]
call _ZN5ftxui3Box12IntersectionES0_S0_; ftxui::Box::Intersection(ftxui::Box,ftxui::Box)
movups xmm0, xmmword ptr [rbx]
movaps [rsp+28h+var_28], xmm0
mov [rbx], rax
mov [rbx+8], rdx
mov rax, [r14+8]
mov rdi, [rax]
mov rax, [rdi]
mov rsi, rbx
call qword ptr [rax+20h]
movaps xmm0, [rsp+28h+var_28]
movups xmmword ptr [rbx], xmm0
add rsp, 18h
pop rbx
pop r14
retn
movaps xmm0, xmmword ptr [rsp+0]
movups xmmword ptr [rbx], xmm0
mov rdi, rax
call __Unwind_Resume
| long long ftxui::`anonymous namespace'::Frame::Render(
ftxui::_anonymous_namespace_::Frame *this,
ftxui::Screen *a2)
{
long long v2; // rax
long long v3; // rdx
long long result; // rax
__int128 v5; // [rsp+0h] [rbp-28h]
v2 = ftxui::Box::Intersection(
*(_QWORD *)((char *)this + 76),
*(_QWORD *)((char *)this + 84),
*(_QWORD *)a2,
*((_QWORD *)a2 + 1));
v5 = *(_OWORD *)a2;
*(_QWORD *)a2 = v2;
*((_QWORD *)a2 + 1) = v3;
result = (*(long long ( **)(_QWORD, ftxui::Screen *))(***((_QWORD ***)this + 1) + 32LL))(
**((_QWORD **)this + 1),
a2);
*(_OWORD *)a2 = v5;
return result;
}
| Render:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x4c]
MOV RSI,qword ptr [R14 + 0x54]
MOV RDX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
CALL 0x0012fcbc
MOVUPS XMM0,xmmword ptr [RBX]
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],RDX
MOV RAX,qword ptr [R14 + 0x8]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RDI]
LAB_0012f72f:
MOV RSI,RBX
CALL qword ptr [RAX + 0x20]
LAB_0012f735:
MOVAPS XMM0,xmmword ptr [RSP]
MOVUPS xmmword ptr [RBX],XMM0
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* ftxui::(anonymous namespace)::Frame::Render(ftxui::Screen&) */
void __thiscall ftxui::(anonymous_namespace)::Frame::Render(Frame *this,Screen *param_1)
{
int8 uVar1;
int8 uVar2;
int1 auVar3 [16];
auVar3 = Box::Intersection(*(int8 *)(this + 0x4c),*(int8 *)(this + 0x54),
*(int8 *)param_1,*(int8 *)(param_1 + 8));
uVar1 = *(int8 *)param_1;
uVar2 = *(int8 *)(param_1 + 8);
*(int1 (*) [16])param_1 = auVar3;
/* try { // try from 0012f72f to 0012f734 has its CatchHandler @ 0012f744 */
(**(code **)(*(long *)**(int8 **)(this + 8) + 0x20))
((long *)**(int8 **)(this + 8),param_1);
*(int8 *)param_1 = uVar1;
*(int8 *)(param_1 + 8) = uVar2;
return;
}
| |
39,515 | bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [3], 0>(char const (&) [3]) const | monkey531[P]llama/common/json.hpp | constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
} | O3 | cpp | bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [3], 0>(char const (&) [3]) const:
cmpb $0x1, (%rdi)
jne 0xa6cd7
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%r12), %rbx
cmpq 0x8(%r12), %rbx
je 0xa6cda
movq %rsi, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a230
testl %eax, %eax
je 0xa6cca
addq $0x30, %rbx
cmpq 0x8(%r12), %rbx
jne 0xa6cb0
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
jmp 0xa6cdd
xorl %eax, %eax
retq
movq %rbx, %rax
cmpq %rbx, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_A6CD7
push r15
push r14
push r12
push rbx
push rax
mov r14, rdi
mov r12, [rdi+8]
mov rbx, [r12]
cmp rbx, [r12+8]
jz short loc_A6CDA
mov r15, rsi
loc_A6CB0:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_A6CCA
add rbx, 30h ; '0'
cmp rbx, [r12+8]
jnz short loc_A6CB0
loc_A6CCA:
mov rax, rbx
mov rcx, [r14+8]
mov rbx, [rcx+8]
jmp short loc_A6CDD
loc_A6CD7:
xor eax, eax
retn
loc_A6CDA:
mov rax, rbx
loc_A6CDD:
cmp rax, rbx
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
if ( *v2 == v2[1] )
{
v4 = *v2;
}
else
{
do
{
if ( !(unsigned int)std::string::compare(v3, a2) )
break;
v3 += 48LL;
}
while ( v3 != v2[1] );
v4 = v3;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
return v4 != v3;
}
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x001a6cd7
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [R12]
CMP RBX,qword ptr [R12 + 0x8]
JZ 0x001a6cda
MOV R15,RSI
LAB_001a6cb0:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011a230
TEST EAX,EAX
JZ 0x001a6cca
ADD RBX,0x30
CMP RBX,qword ptr [R12 + 0x8]
JNZ 0x001a6cb0
LAB_001a6cca:
MOV RAX,RBX
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
JMP 0x001a6cdd
LAB_001a6cd7:
XOR EAX,EAX
RET
LAB_001a6cda:
MOV RAX,RBX
LAB_001a6cdd:
CMP RAX,RBX
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)*plVar1;
pcVar4 = pcVar3;
if (pcVar3 != (char *)plVar1[1]) {
do {
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar3 = pcVar3 + 0x30;
} while (pcVar3 != (char *)plVar1[1]);
pcVar4 = *(char **)(*(long *)(param_1 + 8) + 8);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != pcVar4);
}
| |
39,516 | 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>::erase<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>>, 0>(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>>) | llama.cpp/common/json.hpp | IteratorType erase(IteratorType pos)
{
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
IteratorType result = end();
switch (m_data.m_type)
{
case value_t::boolean:
case value_t::number_float:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::string:
case value_t::binary:
{
if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
{
JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
}
if (is_string())
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
m_data.m_value.string = nullptr;
}
else if (is_binary())
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
m_data.m_value.binary = nullptr;
}
m_data.m_type = value_t::null;
assert_invariant();
break;
}
case value_t::object:
{
result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
break;
}
case value_t::array:
{
result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
break;
}
case value_t::null:
case value_t::discarded:
default:
JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
}
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>::erase<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>>, 0>(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>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
cmpq %rsi, (%rdx)
jne 0x8975b
movq %rdx, %r15
movq %rdi, %rbx
movq %r14, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x18(%rdi)
callq 0x8a672
movzbl (%r14), %eax
leal -0x3(%rax), %ecx
cmpl $0x6, %ecx
jae 0x896c8
cmpq $0x0, 0x18(%r15)
jne 0x897be
cmpl $0x8, %eax
je 0x896e9
cmpl $0x3, %eax
jne 0x8971c
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x896c1
movq (%rcx), %rsi
incq %rsi
movq %rax, %rdi
callq 0x21170
movq (%r15), %rdi
movl $0x20, %esi
jmp 0x89710
cmpl $0x1, %eax
je 0x8973d
cmpl $0x2, %eax
jne 0x8981e
movq 0x8(%r14), %rdi
movq 0x10(%r15), %rsi
callq 0x8ad32
movq %rax, 0x10(%rbx)
jmp 0x8972d
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x8970b
movq 0x10(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x21170
movq (%r15), %rdi
movl $0x28, %esi
callq 0x21170
movq $0x0, (%r15)
movb $0x0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x851fe
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r12
addq $0x8, %r12
movq 0x8(%r14), %rdi
movq 0x8(%r15), %rsi
leaq 0x30(%rsi), %rdx
callq 0x8a8ce
movq %rax, (%r12)
jmp 0x8972d
movl $0x20, %edi
callq 0x21630
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x92ee5(%rip), %rsi # 0x11c65d
leaq 0x92f01(%rip), %rdx # 0x11c680
leaq 0x8(%rsp), %rdi
callq 0x289fc
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xca, %esi
movq %r14, %rcx
callq 0x8a49a
xorl %ebp, %ebp
leaq 0xd9846(%rip), %rsi # 0x162ff0
leaq -0x13031(%rip), %rdx # 0x76780
movq %rbx, %rdi
callq 0x21a50
jmp 0x8987c
movl $0x20, %edi
callq 0x21630
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x92ea6(%rip), %rsi # 0x11c681
leaq 0x92eb4(%rip), %rdx # 0x11c696
leaq 0x8(%rsp), %rdi
callq 0x289fc
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcd, %esi
movq %r14, %rcx
callq 0x8a49a
xorl %ebp, %ebp
leaq 0xd97e3(%rip), %rsi # 0x162ff0
leaq -0x13094(%rip), %rdx # 0x76780
movq %rbx, %rdi
callq 0x21a50
jmp 0x8987c
movl $0x20, %edi
callq 0x21630
movq %rax, %rbx
movq %r14, %rdi
callq 0x8a8b0
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x92e55(%rip), %rsi # 0x11c697
leaq 0x8(%rsp), %rdi
callq 0x7a580
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x133, %esi # imm = 0x133
movq %r14, %rcx
callq 0x8a6d8
xorl %ebp, %ebp
leaq 0xd97c3(%rip), %rsi # 0x163030
leaq -0x130f4(%rip), %rdx # 0x76780
movq %rbx, %rdi
callq 0x21a50
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x898a2
jmp 0x898af
jmp 0x898b6
jmp 0x89895
jmp 0x898b6
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x898af
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21170
testb %bpl, %bpl
jne 0x898b9
jmp 0x898c1
movq %rax, %r14
movq %rbx, %rdi
callq 0x21f00
movq %r14, %rdi
callq 0x21af0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
push rbp; __int64
push r15; int
push r14; void *
push r12; int
push rbx; __int64
sub rsp, 30h
mov r14, rsi
cmp [rdx], rsi
jnz loc_8975B
mov r15, rdx
mov rbx, rdi
mov [rdi], r14
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
mov rax, 8000000000000000h
mov [rdi+18h], rax
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE7set_endEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::set_end(void)
movzx eax, byte ptr [r14]
lea ecx, [rax-3]
cmp ecx, 6
jnb short loc_896C8
cmp qword ptr [r15+18h], 0
jnz loc_897BE
cmp eax, 8
jz short loc_896E9
cmp eax, 3
jnz loc_8971C
lea r15, [r14+8]
mov rdi, [r14+8]
mov rax, [rdi]
lea rcx, [rdi+10h]
cmp rax, rcx
jz short loc_896C1
mov rsi, [rcx]
inc rsi; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [r15]
loc_896C1:
mov esi, 20h ; ' '
jmp short loc_89710
loc_896C8:
cmp eax, 1
jz short loc_8973D
cmp eax, 2
jnz loc_8981E
mov rdi, [r14+8]
mov rsi, [r15+10h]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE8_M_eraseEN9__gnu_cxx17__normal_iteratorIPSD_SF_EE; 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>>::_M_erase(__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>*,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>>>)
mov [rbx+10h], rax
jmp short loc_8972D
loc_896E9:
lea r15, [r14+8]
mov rdi, [r14+8]
mov rax, [rdi]
test rax, rax
jz short loc_8970B
mov rsi, [rdi+10h]
sub rsi, rax; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [r15]; void *
loc_8970B:
mov esi, 28h ; '('; unsigned __int64
loc_89710:
call __ZdlPvm; operator delete(void *,ulong)
mov qword ptr [r15], 0
loc_8971C:
mov byte ptr [r14], 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)
loc_8972D:
mov rax, rbx
add rsp, 30h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_8973D:
mov r12, rbx
add r12, 8
mov rdi, [r14+8]
mov rsi, [r15+8]
lea rdx, [rsi+30h]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEESP_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::erase(__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>>>>,__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>>>>)
mov [r12], rax
jmp short loc_8972D
loc_8975B:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+58h+var_40]
mov [r15-10h], r15
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdx, aIteratorDoesNo+23h; ""
lea rdi, [rsp+58h+var_50]
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
lea rdx, [rsp+58h+var_50]
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
jmp loc_8987C
loc_897BE:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+58h+var_40]
mov [r15-10h], r15
lea rsi, aIteratorOutOfR; "iterator out of range"
lea rdx, aIteratorOutOfR+15h; ""
lea rdi, [rsp+58h+var_50]
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
lea rdx, [rsp+58h+var_50]
mov rdi, rbx; this
mov esi, 0CDh; 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
jmp short loc_8987C
loc_8981E:
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+58h+var_30]
mov [rdx], rax
lea rsi, aCannotUseErase; "cannot use erase() with "
lea rdi, [rsp+58h+var_50]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA25_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[25],char const*>(char const(&)[25],char const* &&)
mov bpl, 1
lea rdx, [rsp+58h+var_50]
mov rdi, rbx; this
mov esi, 133h; 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
loc_8987C:
mov r14, rax
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]
cmp rdi, rax
jnz short loc_898A2
jmp short loc_898AF
jmp short loc_898B6
jmp short loc_89895
jmp short loc_898B6
loc_89895:
mov r14, rax
mov rdi, [rsp+58h+var_50]; void *
cmp rdi, r15
jz short loc_898AF
loc_898A2:
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_898AF:
test bpl, bpl
jnz short loc_898B9
jmp short loc_898C1
loc_898B6:
mov r14, rax
loc_898B9:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_898C1:
mov rdi, r14
call __Unwind_Resume
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
CMP qword ptr [RDX],RSI
JNZ 0x0018975b
MOV R15,RDX
MOV RBX,RDI
MOV qword ptr [RDI],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOV RAX,-0x8000000000000000
MOV qword ptr [RDI + 0x18],RAX
CALL 0x0018a672
MOVZX EAX,byte ptr [R14]
LEA ECX,[RAX + -0x3]
CMP ECX,0x6
JNC 0x001896c8
CMP qword ptr [R15 + 0x18],0x0
JNZ 0x001897be
CMP EAX,0x8
JZ 0x001896e9
CMP EAX,0x3
JNZ 0x0018971c
LEA R15,[R14 + 0x8]
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RDI]
LEA RCX,[RDI + 0x10]
CMP RAX,RCX
JZ 0x001896c1
MOV RSI,qword ptr [RCX]
INC RSI
MOV RDI,RAX
CALL 0x00121170
MOV RDI,qword ptr [R15]
LAB_001896c1:
MOV ESI,0x20
JMP 0x00189710
LAB_001896c8:
CMP EAX,0x1
JZ 0x0018973d
CMP EAX,0x2
JNZ 0x0018981e
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R15 + 0x10]
CALL 0x0018ad32
MOV qword ptr [RBX + 0x10],RAX
JMP 0x0018972d
LAB_001896e9:
LEA R15,[R14 + 0x8]
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0018970b
MOV RSI,qword ptr [RDI + 0x10]
SUB RSI,RAX
MOV RDI,RAX
CALL 0x00121170
MOV RDI,qword ptr [R15]
LAB_0018970b:
MOV ESI,0x28
LAB_00189710:
CALL 0x00121170
MOV qword ptr [R15],0x0
LAB_0018971c:
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x001851fe
LAB_0018972d:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0018973d:
MOV R12,RBX
ADD R12,0x8
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R15 + 0x8]
LEA RDX,[RSI + 0x30]
CALL 0x0018a8ce
MOV qword ptr [R12],RAX
JMP 0x0018972d
LAB_0018975b:
MOV EDI,0x20
CALL 0x00121630
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_00189771:
LEA RSI,[0x21c65d]
LEA RDX,[0x21c680]
LEA RDI,[RSP + 0x8]
CALL 0x001289fc
MOV BPL,0x1
LAB_0018978c:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xca
MOV RCX,R14
CALL 0x0018a49a
XOR EBP,EBP
LEA RSI,[0x262ff0]
LEA RDX,[0x176780]
MOV RDI,RBX
CALL 0x00121a50
LAB_001897be:
MOV EDI,0x20
CALL 0x00121630
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_001897d4:
LEA RSI,[0x21c681]
LEA RDX,[0x21c696]
LEA RDI,[RSP + 0x8]
CALL 0x001289fc
MOV BPL,0x1
LAB_001897ef:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xcd
MOV RCX,R14
CALL 0x0018a49a
XOR EBP,EBP
LEA RSI,[0x262ff0]
LEA RDX,[0x176780]
MOV RDI,RBX
CALL 0x00121a50
LAB_0018981e:
MOV EDI,0x20
CALL 0x00121630
MOV RBX,RAX
MOV RDI,R14
CALL 0x0018a8b0
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],RAX
LAB_0018983b:
LEA RSI,[0x21c697]
LEA RDI,[RSP + 0x8]
CALL 0x0017a580
MOV BPL,0x1
LAB_0018984f:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x133
MOV RCX,R14
CALL 0x0018a6d8
XOR EBP,EBP
LEA RSI,[0x263030]
LEA RDX,[0x176780]
MOV RDI,RBX
CALL 0x00121a50
|
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>>
* _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
(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>>
*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>
*param_2,long *param_3)
{
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
void *pvVar2;
int8 uVar3;
ulong uVar4;
int8 *puVar5;
int1 *local_50 [2];
int1 local_40 [16];
char *local_30;
if ((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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 != param_2) {
uVar3 = __cxa_allocate_exception(0x20);
local_50[0] = local_40;
/* try { // try from 00189771 to 00189788 has its CatchHandler @ 001898b6 */
std::__cxx11::string::_M_construct<char_const*>
(local_50,"iterator does not fit current value","");
/* try { // try from 0018978c to 001897b8 has its CatchHandler @ 00189895 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0xca,local_50,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&nlohmann::json_abi_v3_11_3::detail::invalid_iterator::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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 = param_2;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0x8000000000000000;
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::set_end(param_1);
bVar1 = *param_2;
if (5 < (byte)bVar1 - 3) {
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
uVar3 = nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::erase(*(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(param_2 + 8),param_3[1],param_3[1] + 0x30);
*(int8 *)(param_1 + 8) = uVar3;
return param_1;
}
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar3 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::_M_erase(*(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),param_3[2]);
*(int8 *)(param_1 + 0x10) = uVar3;
return param_1;
}
uVar3 = __cxa_allocate_exception(0x20);
local_30 = (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_2);
/* try { // try from 0018983b to 0018984b has its CatchHandler @ 0018988f */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[25],char_const*>
((detail *)local_50,"cannot use erase() with ",&local_30);
/* try { // try from 0018984f to 0018987b has its CatchHandler @ 0018987c */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0x133,local_50,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if (param_3[3] != 0) {
uVar3 = __cxa_allocate_exception(0x20);
local_50[0] = local_40;
/* try { // try from 001897d4 to 001897eb has its CatchHandler @ 00189893 */
std::__cxx11::string::_M_construct<char_const*>(local_50,"iterator out of range","");
/* try { // try from 001897ef to 0018981b has its CatchHandler @ 00189891 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0xcd,local_50,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&nlohmann::json_abi_v3_11_3::detail::invalid_iterator::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x8) {
puVar5 = *(int8 **)(param_2 + 8);
pvVar2 = (void *)*puVar5;
if (pvVar2 != (void *)0x0) {
operator_delete(pvVar2,puVar5[2] - (long)pvVar2);
puVar5 = *(int8 **)(param_2 + 8);
}
uVar4 = 0x28;
}
else {
if (bVar1 != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x3) goto LAB_0018971c;
puVar5 = *(int8 **)(param_2 + 8);
if ((long *)*puVar5 != puVar5 + 2) {
operator_delete((long *)*puVar5,puVar5[2] + 1);
puVar5 = *(int8 **)(param_2 + 8);
}
uVar4 = 0x20;
}
operator_delete(puVar5,uVar4);
*(int8 *)(param_2 + 8) = 0;
LAB_0018971c:
*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>
)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(SUB81(param_2,0));
return param_1;
}
| ||
39,517 | js_typed_array_set | bluesky950520[P]quickjs/quickjs.c | static JSValue js_typed_array_set(JSContext *ctx,
JSValue this_val,
int argc, JSValue *argv)
{
JSValue offset = JS_UNDEFINED;
if (argc > 1) {
offset = argv[1];
}
return js_typed_array_set_internal(ctx, this_val, argv[0], offset);
} | O1 | c | js_typed_array_set:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
cmpl $0x2, %ecx
jl 0x80a0e
movq 0x10(%r8), %r12
movq 0x18(%r8), %r15
jmp 0x80a17
movl $0x3, %r15d
xorl %r12d, %r12d
movq (%r8), %rbp
movq 0x8(%r8), %r14
movq $0x0, 0x20(%rsp)
movq %rsi, 0x70(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x78(%rsp)
cmpl $-0x1, %edx
jne 0x80a4e
movq 0x40(%rsp), %r13
movzwl 0x6(%r13), %eax
addl $-0x15, %eax
cmpw $0xc, %ax
jb 0x80a62
leaq 0x219bc(%rip), %rsi # 0xa2411
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22567
movl $0x3, %ecx
testq %r13, %r13
je 0x80b19
movq %r12, 0x40(%rsp)
cmpl $-0x9, %r15d
jb 0x80a82
movq 0x40(%rsp), %rax
incl (%rax)
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x277bc
testl %eax, %eax
movl $0x3, %ecx
jne 0x80b19
movq 0x80(%rsp), %r12
testq %r12, %r12
js 0x80ad8
movq %r13, %rdi
callq 0x396c4
movl $0x3, %ecx
testl %eax, %eax
je 0x80afa
leaq 0x2195c(%rip), %rsi # 0xa2422
movq %rbx, %rdi
xorl %eax, %eax
movq %rcx, %r14
callq 0x22567
movq %r14, %rcx
jmp 0x80b19
movl $0x3, %eax
movq %rax, 0x18(%rsp)
leaq 0x1e6b5(%rip), %rsi # 0x9f19e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20add
movq 0x18(%rsp), %rcx
jmp 0x80b19
movl 0x40(%r13), %r15d
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x26ddd
movq %rdx, %rcx
movq %rax, 0x20(%rsp)
cmpl $0x6, %ecx
jne 0x80b43
movq 0x20(%rsp), %rsi
movq 0x18(%rbx), %rdi
movq %rcx, %rdx
callq 0x1d8c6
movl $0x6, %edx
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, 0x28(%rsp)
movq 0x20(%rsp), %r15
movzwl 0x6(%r15), %r14d
leal -0x15(%r14), %eax
cmpw $0xb, %ax
movq %rcx, 0x18(%rsp)
ja 0x80c3d
movq 0x30(%r13), %rax
movq %rax, 0x50(%rsp)
movq 0x18(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x30(%r15), %rax
movq %rax, 0x68(%rsp)
movq 0x18(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x30(%rsp)
movzwl 0x6(%r13), %ebp
leaq 0x1cd42(%rip), %rax # 0x9d8df
movzbl -0x15(%rbp,%rax), %eax
movq %rax, 0x60(%rsp)
movq %r15, %rdi
callq 0x396c4
movl $0x4, %ecx
testl %eax, %eax
jne 0x80c18
movl 0x40(%r15), %edx
movq %rdx, 0x38(%rsp)
movq 0x28(%rsp), %rax
subq %rdx, %rax
movl $0x3, %ecx
cmpq %rax, %r12
jg 0x80c18
xorl %ecx, %ecx
cmpw %bp, %r14w
jne 0x80c18
movq 0x50(%rsp), %rax
movl 0x20(%rax), %eax
movq 0x58(%rsp), %rcx
addq 0x10(%rcx), %rax
movq %r12, %rdi
movq 0x60(%rsp), %rcx
shlq %cl, %rdi
addq %rax, %rdi
movq 0x68(%rsp), %rax
movl 0x20(%rax), %esi
movq 0x30(%rsp), %rax
addq 0x10(%rax), %rsi
shlq %cl, %rdx
callq 0xe720
movl $0x5, %ecx
cmpl $0x5, %ecx
ja 0x80b2f
movl %ecx, %eax
leaq 0x1cb4a(%rip), %rcx # 0x9d774
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rcx
jmp 0x80abf
movq 0x20(%rsp), %rdx
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x22adc
testl %eax, %eax
jne 0x80af3
movq 0x28(%rsp), %rax
subq 0x38(%rsp), %rax
cmpq %rax, %r12
jg 0x80ae2
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
jle 0x80d38
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x1, %ebp
xorl %ecx, %ecx
movq %rbx, %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x241b4
movq %rdx, %r14
cmpl $0x6, %r14d
je 0x80af3
movq %rax, %r15
movq %r13, %rdi
callq 0x396c4
testl %eax, %eax
je 0x80ccd
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1d8c6
jmp 0x80d26
movq %r15, 0x40(%rsp)
movl %r12d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
testl %r12d, %r12d
movq %xmm0, %rcx
cmovnsq %rax, %rcx
movq %r14, 0x48(%rsp)
movl $0x7, %r8d
movl $0x0, %eax
cmovnsq %rax, %r8
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
movl $0x4000, %r9d # imm = 0x4000
callq 0x24d59
testl %eax, %eax
js 0x80af3
movl %ebp, %ecx
incl %r12d
incl %ebp
cmpq %rcx, 0x28(%rsp)
jg 0x80c8e
movq 0x20(%rsp), %rsi
movq 0x18(%rbx), %rdi
movq 0x18(%rsp), %rdx
callq 0x1d8c6
movl $0x3, %edx
jmp 0x80b2f
| js_typed_array_set:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov rbx, rdi
cmp ecx, 2
jl short loc_80A0E
mov r12, [r8+10h]
mov r15, [r8+18h]
jmp short loc_80A17
loc_80A0E:
mov r15d, 3
xor r12d, r12d
loc_80A17:
mov rbp, [r8]
mov r14, [r8+8]
mov [rsp+0B8h+var_98], 0
mov [rsp+0B8h+var_48], rsi
mov qword ptr [rsp+0B8h+var_78], rsi
mov [rsp+0B8h+var_40], rdx
cmp edx, 0FFFFFFFFh
jnz short loc_80A4E
mov r13, qword ptr [rsp+0B8h+var_78]
movzx eax, word ptr [r13+6]
add eax, 0FFFFFFEBh
cmp ax, 0Ch
jb short loc_80A62
loc_80A4E:
lea rsi, aNotATypedarray; "not a TypedArray"
xor r13d, r13d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
loc_80A62:
mov ecx, 3
test r13, r13
jz loc_80B19
mov qword ptr [rsp+0B8h+var_78], r12
cmp r15d, 0FFFFFFF7h
jb short loc_80A82
mov rax, qword ptr [rsp+0B8h+var_78]
inc dword ptr [rax]
loc_80A82:
lea rsi, [rsp+0B8h+var_38]
mov rdi, rbx
mov rdx, r12
mov rcx, r15
call JS_ToInt64SatFree
test eax, eax
mov ecx, 3
jnz short loc_80B19
mov r12, [rsp+0B8h+var_38]
test r12, r12
js short loc_80AD8
mov rdi, r13
call typed_array_is_oob
mov ecx, 3
test eax, eax
jz short loc_80AFA
loc_80ABF:
lea rsi, aArraybufferIsD_0; "ArrayBuffer is detached or resized"
mov rdi, rbx
xor eax, eax
mov r14, rcx
call JS_ThrowTypeError
mov rcx, r14
jmp short loc_80B19
loc_80AD8:
mov eax, 3
mov [rsp+0B8h+var_A0], rax
loc_80AE2:
lea rsi, aInvalidArrayLe; jumptable 0000000000080C31 case 3
mov rdi, rbx
xor eax, eax
call JS_ThrowRangeError
loc_80AF3:
mov rcx, [rsp+0B8h+var_A0]
jmp short loc_80B19
loc_80AFA:
mov r15d, [r13+40h]
mov rdi, rbx
mov rsi, rbp
mov rdx, r14
call JS_ToObject
mov rcx, rdx
mov [rsp+0B8h+var_98], rax
cmp ecx, 6
jnz short loc_80B43
loc_80B19:
mov rsi, [rsp+0B8h+var_98]
mov rdi, [rbx+18h]
mov rdx, rcx
call JS_FreeValueRT
mov edx, 6
def_80C31:
xor eax, eax; jumptable 0000000000080C31 default case, cases 1,2
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_80B43:
mov [rsp+0B8h+var_90], r15
mov r15, [rsp+0B8h+var_98]
movzx r14d, word ptr [r15+6]
lea eax, [r14-15h]
cmp ax, 0Bh
mov [rsp+0B8h+var_A0], rcx
ja loc_80C3D
mov rax, [r13+30h]
mov [rsp+0B8h+var_68], rax
mov rax, [rax+18h]
mov rax, [rax+30h]
mov [rsp+0B8h+var_60], rax
mov rax, [r15+30h]
mov [rsp+0B8h+var_50], rax
mov rax, [rax+18h]
mov rax, [rax+30h]
mov [rsp+0B8h+var_88], rax
movzx ebp, word ptr [r13+6]
lea rax, typed_array_size_log2
movzx eax, byte ptr [rbp+rax-15h]
mov [rsp+0B8h+var_58], rax
mov rdi, r15
call typed_array_is_oob
mov ecx, 4
test eax, eax
jnz short loc_80C18
mov edx, [r15+40h]
mov [rsp+0B8h+var_80], rdx
mov rax, [rsp+0B8h+var_90]
sub rax, rdx
mov ecx, 3
cmp r12, rax
jg short loc_80C18
xor ecx, ecx
cmp r14w, bp
jnz short loc_80C18
mov rax, [rsp+0B8h+var_68]
mov eax, [rax+20h]
mov rcx, [rsp+0B8h+var_60]
add rax, [rcx+10h]
mov rdi, r12
mov rcx, [rsp+0B8h+var_58]
shl rdi, cl
add rdi, rax
mov rax, [rsp+0B8h+var_50]
mov esi, [rax+20h]
mov rax, [rsp+0B8h+var_88]
add rsi, [rax+10h]
shl rdx, cl
call _memmove
mov ecx, 5
loc_80C18:
cmp ecx, 5; switch 6 cases
ja def_80C31; jumptable 0000000000080C31 default case, cases 1,2
mov eax, ecx
lea rcx, jpt_80C31
movsxd rax, ds:(jpt_80C31 - 9D774h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_80C33:
mov rcx, [rsp+0B8h+var_A0]; jumptable 0000000000080C31 case 4
jmp loc_80ABF
loc_80C3D:
mov rdx, [rsp+0B8h+var_98]
lea rsi, [rsp+0B8h+var_80]
mov rdi, rbx
call js_get_length64
test eax, eax
jnz loc_80AF3
mov rax, [rsp+0B8h+var_90]
sub rax, [rsp+0B8h+var_80]
cmp r12, rax
jg loc_80AE2; jumptable 0000000000080C31 case 3
loc_80C6A:
mov rax, [rsp+0B8h+var_80]; jumptable 0000000000080C31 case 0
mov [rsp+0B8h+var_90], rax
test rax, rax
jle loc_80D38; jumptable 0000000000080C31 case 5
mov rax, [rsp+0B8h+var_98]
mov [rsp+0B8h+var_88], rax
mov ebp, 1
xor ecx, ecx
loc_80C8E:
mov rdi, rbx
mov rsi, [rsp+0B8h+var_88]
mov rdx, [rsp+0B8h+var_A0]
call JS_GetPropertyInt64
mov r14, rdx
cmp r14d, 6
jz loc_80AF3
mov r15, rax
mov rdi, r13
call typed_array_is_oob
test eax, eax
jz short loc_80CCD
mov rdi, [rbx+18h]
mov rsi, r15
mov rdx, r14
call JS_FreeValueRT
jmp short loc_80D26
loc_80CCD:
mov qword ptr [rsp+0B8h+var_78], r15
mov eax, r12d
xorps xmm0, xmm0
cvtsi2sd xmm0, rax
test r12d, r12d
movq rcx, xmm0
cmovns rcx, rax
mov qword ptr [rsp+0B8h+var_78+8], r14
mov r8d, 7
mov eax, 0
cmovns r8, rax
movups xmm0, [rsp+0B8h+var_78]
movups [rsp+0B8h+var_B8], xmm0
mov rdi, rbx
mov rsi, [rsp+0B8h+var_48]
mov rdx, [rsp+0B8h+var_40]
mov r9d, 4000h
call JS_SetPropertyValue
test eax, eax
js loc_80AF3
loc_80D26:
mov ecx, ebp
inc r12d
inc ebp
cmp [rsp+0B8h+var_90], rcx
jg loc_80C8E
loc_80D38:
mov rsi, [rsp+0B8h+var_98]; jumptable 0000000000080C31 case 5
mov rdi, [rbx+18h]
mov rdx, [rsp+0B8h+var_A0]
call JS_FreeValueRT
mov edx, 3
jmp def_80C31; jumptable 0000000000080C31 default case, cases 1,2
| long long js_typed_array_set(
long long a1,
unsigned long long a2,
long long a3,
long long a4,
long long *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // r12
long long v15; // r15
long long v16; // rbp
long long v17; // r14
long long v18; // r13
long long v19; // rcx
int v20; // eax
long long v21; // rdx
long long v22; // r8
long long v23; // r9
__m128 v24; // xmm4
__m128 v25; // xmm5
long long v26; // r12
BOOL is_oob; // eax
long long v28; // rcx
long long v29; // r14
long long v30; // r15
_DWORD *v31; // rax
long long v32; // rdx
__int16 v34; // r14
long long v35; // rbp
BOOL v36; // eax
unsigned int v37; // ebp
signed long long v38; // rcx
unsigned long long PropertyInt64; // rax
long long v40; // rdx
long long v41; // r14
_DWORD *v42; // r15
double v43; // xmm4_8
double v44; // xmm5_8
double v45; // rcx
long long v46; // r8
char v47; // [rsp+0h] [rbp-B8h]
long long v48; // [rsp+18h] [rbp-A0h]
_DWORD *v49; // [rsp+20h] [rbp-98h]
signed long long v50; // [rsp+28h] [rbp-90h]
long long v51; // [rsp+30h] [rbp-88h]
long long v52; // [rsp+38h] [rbp-80h] BYREF
__int128 v53; // [rsp+40h] [rbp-78h]
long long v54; // [rsp+50h] [rbp-68h]
long long v55; // [rsp+58h] [rbp-60h]
long long v56; // [rsp+60h] [rbp-58h]
long long v57; // [rsp+68h] [rbp-50h]
unsigned long long v58; // [rsp+70h] [rbp-48h]
unsigned long long v59; // [rsp+78h] [rbp-40h]
unsigned long long v60[7]; // [rsp+80h] [rbp-38h] BYREF
if ( (int)a4 < 2 )
{
v15 = 3LL;
v14 = 0LL;
}
else
{
v14 = a5[2];
v15 = a5[3];
}
v16 = *a5;
v17 = a5[1];
v49 = 0LL;
v58 = a2;
*(_QWORD *)&v53 = a2;
v59 = a3;
if ( (_DWORD)a3 != -1 || (v18 = v53, (unsigned __int16)(*(_WORD *)(v53 + 6) - 21) >= 0xCu) )
{
v18 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"not a TypedArray",
a3,
a4,
(long long)a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v47);
}
v19 = 3LL;
if ( !v18 )
goto LABEL_18;
*(_QWORD *)&v53 = v14;
if ( (unsigned int)v15 >= 0xFFFFFFF7 )
++*(_DWORD *)v53;
v20 = JS_ToInt64SatFree(a1, v60, v14, v15);
v19 = 3LL;
if ( v20 )
goto LABEL_18;
v26 = v60[0];
if ( (v60[0] & 0x8000000000000000LL) != 0LL )
{
v48 = 3LL;
goto LABEL_15;
}
is_oob = typed_array_is_oob(v18);
v28 = 3LL;
if ( is_oob )
{
LABEL_13:
v29 = v28;
JS_ThrowTypeError(
a1,
(long long)"ArrayBuffer is detached or resized",
v21,
v28,
v22,
v23,
a7,
a8,
a9,
a10,
v24,
v25,
a13,
a14,
v47);
v19 = v29;
LABEL_18:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v49, v19);
return 0LL;
}
v30 = *(unsigned int *)(v18 + 64);
v31 = JS_ToObject(a1, v16, v17, 3LL, v22, v23, a7, a8, a9, a10, v24, v25, a13, a14);
v19 = v32;
v49 = v31;
if ( (_DWORD)v32 == 6 )
goto LABEL_18;
v34 = *((_WORD *)v31 + 3);
v48 = v32;
if ( (unsigned __int16)(v34 - 21) > 0xBu )
{
if ( (unsigned int)js_get_length64(a1, &v52, (int)v31, v32) )
goto LABEL_16;
if ( v26 <= v30 - v52 )
{
LABEL_29:
v50 = v52;
if ( v52 <= 0 )
{
LABEL_40:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v49, v48);
return 0LL;
}
v37 = 1;
v38 = 0LL;
while ( 1 )
{
PropertyInt64 = JS_GetPropertyInt64(a1, (long long)v49, v48, v38);
v41 = v40;
if ( (_DWORD)v40 == 6 )
goto LABEL_16;
v42 = (_DWORD *)PropertyInt64;
if ( typed_array_is_oob(v18) )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v42, v41);
}
else
{
*(_QWORD *)&v53 = v42;
v45 = (double)(int)v26;
if ( (int)v26 >= 0 )
*(_QWORD *)&v45 = (unsigned int)v26;
*((_QWORD *)&v53 + 1) = v41;
v46 = 7LL;
if ( (int)v26 >= 0 )
v46 = 0LL;
if ( (int)JS_SetPropertyValue(
a1,
v58,
v59,
*(_DWORD **)&v45,
v46,
0x4000u,
*(double *)&v53,
a8,
a9,
a10,
v43,
v44,
a13,
a14,
v53) < 0 )
goto LABEL_16;
}
v38 = v37;
LODWORD(v26) = v26 + 1;
++v37;
if ( v50 <= v38 )
goto LABEL_40;
}
}
LABEL_15:
JS_ThrowRangeError(
a1,
(long long)"invalid array length",
v21,
v19,
v22,
v23,
a7,
a8,
a9,
a10,
v24,
v25,
a13,
a14,
v47);
LABEL_16:
v19 = v48;
goto LABEL_18;
}
v54 = *(_QWORD *)(v18 + 48);
v55 = *(_QWORD *)(*(_QWORD *)(v54 + 24) + 48LL);
v57 = *((_QWORD *)v31 + 6);
v51 = *(_QWORD *)(*(_QWORD *)(v57 + 24) + 48LL);
v35 = *(unsigned __int16 *)(v18 + 6);
v56 = (unsigned __int8)typed_array_size_log2[v35 - 21];
v36 = typed_array_is_oob((long long)v31);
v19 = 4LL;
if ( !v36 )
{
v21 = (unsigned int)v49[16];
v52 = v21;
v19 = 3LL;
if ( v26 <= v30 - v21 )
{
v19 = 0LL;
if ( v34 == (_WORD)v35 )
{
memmove(
*(_QWORD *)(v55 + 16) + *(unsigned int *)(v54 + 32) + (v26 << v56),
*(_QWORD *)(v51 + 16) + *(unsigned int *)(v57 + 32),
v21 << v56);
v19 = 5LL;
}
}
}
switch ( (int)v19 )
{
case 0:
goto LABEL_29;
case 3:
goto LABEL_15;
case 4:
v28 = v48;
goto LABEL_13;
case 5:
goto LABEL_40;
default:
return 0LL;
}
return 0LL;
}
| js_typed_array_set:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV RBX,RDI
CMP ECX,0x2
JL 0x00180a0e
MOV R12,qword ptr [R8 + 0x10]
MOV R15,qword ptr [R8 + 0x18]
JMP 0x00180a17
LAB_00180a0e:
MOV R15D,0x3
XOR R12D,R12D
LAB_00180a17:
MOV RBP,qword ptr [R8]
MOV R14,qword ptr [R8 + 0x8]
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x70],RSI
MOV qword ptr [RSP + 0x40],RSI
MOV qword ptr [RSP + 0x78],RDX
CMP EDX,-0x1
JNZ 0x00180a4e
MOV R13,qword ptr [RSP + 0x40]
MOVZX EAX,word ptr [R13 + 0x6]
ADD EAX,-0x15
CMP AX,0xc
JC 0x00180a62
LAB_00180a4e:
LEA RSI,[0x1a2411]
XOR R13D,R13D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00122567
LAB_00180a62:
MOV ECX,0x3
TEST R13,R13
JZ 0x00180b19
MOV qword ptr [RSP + 0x40],R12
CMP R15D,-0x9
JC 0x00180a82
MOV RAX,qword ptr [RSP + 0x40]
INC dword ptr [RAX]
LAB_00180a82:
LEA RSI,[RSP + 0x80]
MOV RDI,RBX
MOV RDX,R12
MOV RCX,R15
CALL 0x001277bc
TEST EAX,EAX
MOV ECX,0x3
JNZ 0x00180b19
MOV R12,qword ptr [RSP + 0x80]
TEST R12,R12
JS 0x00180ad8
MOV RDI,R13
CALL 0x001396c4
MOV ECX,0x3
TEST EAX,EAX
JZ 0x00180afa
LAB_00180abf:
LEA RSI,[0x1a2422]
MOV RDI,RBX
XOR EAX,EAX
MOV R14,RCX
CALL 0x00122567
MOV RCX,R14
JMP 0x00180b19
LAB_00180ad8:
MOV EAX,0x3
MOV qword ptr [RSP + 0x18],RAX
caseD_3:
LEA RSI,[0x19f19e]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00120add
LAB_00180af3:
MOV RCX,qword ptr [RSP + 0x18]
JMP 0x00180b19
LAB_00180afa:
MOV R15D,dword ptr [R13 + 0x40]
MOV RDI,RBX
MOV RSI,RBP
MOV RDX,R14
CALL 0x00126ddd
MOV RCX,RDX
MOV qword ptr [RSP + 0x20],RAX
CMP ECX,0x6
JNZ 0x00180b43
LAB_00180b19:
MOV RSI,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RBX + 0x18]
MOV RDX,RCX
CALL 0x0011d8c6
MOV EDX,0x6
caseD_1:
XOR EAX,EAX
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00180b43:
MOV qword ptr [RSP + 0x28],R15
MOV R15,qword ptr [RSP + 0x20]
MOVZX R14D,word ptr [R15 + 0x6]
LEA EAX,[R14 + -0x15]
CMP AX,0xb
MOV qword ptr [RSP + 0x18],RCX
JA 0x00180c3d
MOV RAX,qword ptr [R13 + 0x30]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [R15 + 0x30]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x30],RAX
MOVZX EBP,word ptr [R13 + 0x6]
LEA RAX,[0x19d8df]
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x15]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,R15
CALL 0x001396c4
MOV ECX,0x4
TEST EAX,EAX
JNZ 0x00180c18
MOV EDX,dword ptr [R15 + 0x40]
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,RDX
MOV ECX,0x3
CMP R12,RAX
JG 0x00180c18
XOR ECX,ECX
CMP R14W,BP
JNZ 0x00180c18
MOV RAX,qword ptr [RSP + 0x50]
MOV EAX,dword ptr [RAX + 0x20]
MOV RCX,qword ptr [RSP + 0x58]
ADD RAX,qword ptr [RCX + 0x10]
MOV RDI,R12
MOV RCX,qword ptr [RSP + 0x60]
SHL RDI,CL
ADD RDI,RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RAX + 0x20]
MOV RAX,qword ptr [RSP + 0x30]
ADD RSI,qword ptr [RAX + 0x10]
SHL RDX,CL
CALL 0x0010e720
MOV ECX,0x5
LAB_00180c18:
CMP ECX,0x5
JA 0x00180b2f
MOV EAX,ECX
LEA RCX,[0x19d774]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_4:
MOV RCX,qword ptr [RSP + 0x18]
JMP 0x00180abf
LAB_00180c3d:
MOV RDX,qword ptr [RSP + 0x20]
LEA RSI,[RSP + 0x38]
MOV RDI,RBX
CALL 0x00122adc
TEST EAX,EAX
JNZ 0x00180af3
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr [RSP + 0x38]
CMP R12,RAX
JG 0x00180ae2
caseD_0:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x28],RAX
TEST RAX,RAX
JLE 0x00180d38
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x30],RAX
MOV EBP,0x1
XOR ECX,ECX
LAB_00180c8e:
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x001241b4
MOV R14,RDX
CMP R14D,0x6
JZ 0x00180af3
MOV R15,RAX
MOV RDI,R13
CALL 0x001396c4
TEST EAX,EAX
JZ 0x00180ccd
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R15
MOV RDX,R14
CALL 0x0011d8c6
JMP 0x00180d26
LAB_00180ccd:
MOV qword ptr [RSP + 0x40],R15
MOV EAX,R12D
XORPS XMM0,XMM0
CVTSI2SD XMM0,RAX
TEST R12D,R12D
MOVQ RCX,XMM0
CMOVNS RCX,RAX
MOV qword ptr [RSP + 0x48],R14
MOV R8D,0x7
MOV EAX,0x0
CMOVNS R8,RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
MOV R9D,0x4000
CALL 0x00124d59
TEST EAX,EAX
JS 0x00180af3
LAB_00180d26:
MOV ECX,EBP
INC R12D
INC EBP
CMP qword ptr [RSP + 0x28],RCX
JG 0x00180c8e
caseD_5:
MOV RSI,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RBX + 0x18]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x0011d8c6
MOV EDX,0x3
JMP 0x00180b2f
|
int8
js_typed_array_set(long param_1,long param_2,int8 param_3,int param_4,int8 *param_5)
{
ushort uVar1;
ushort uVar2;
uint uVar3;
int8 uVar4;
int8 uVar5;
long lVar6;
bool bVar7;
ulong uVar8;
int iVar9;
long lVar10;
int4 uVar11;
ulong uVar12;
double dVar13;
ulong uVar14;
int8 uVar15;
int iVar16;
int *piVar17;
ulong uVar18;
int1 auVar19 [16];
int1 auVar20 [16];
int8 local_98;
ulong local_80;
int1 local_78 [16];
long local_68;
long local_60;
ulong local_58;
long local_50;
long local_48;
int8 local_40;
ulong local_38;
if (param_4 < 2) {
uVar15 = 3;
piVar17 = (int *)0x0;
}
else {
piVar17 = (int *)param_5[2];
uVar15 = param_5[3];
}
uVar4 = *param_5;
uVar5 = param_5[1];
local_78._0_8_ = param_2;
local_48 = param_2;
local_40 = param_3;
if (((int)param_3 != -1) || (0xb < (ushort)(*(short *)(param_2 + 6) - 0x15U))) {
param_2 = 0;
JS_ThrowTypeError(param_1,"not a TypedArray");
}
auVar19 = ZEXT816(3) << 0x40;
if (param_2 == 0) goto LAB_00180b19;
if (0xfffffff6 < (uint)uVar15) {
*piVar17 = *piVar17 + 1;
}
local_78._0_8_ = piVar17;
iVar9 = JS_ToInt64SatFree(param_1,&local_38,piVar17,uVar15);
auVar19 = ZEXT816(3) << 0x40;
if (iVar9 != 0) goto LAB_00180b19;
if ((long)local_38 < 0) {
auVar19 = ZEXT816(3) << 0x40;
}
else {
iVar9 = typed_array_is_oob(param_2);
auVar19 = ZEXT816(3) << 0x40;
if (iVar9 != 0) {
LAB_00180abf:
JS_ThrowTypeError(param_1,"ArrayBuffer is detached or resized");
goto LAB_00180b19;
}
uVar3 = *(uint *)(param_2 + 0x40);
auVar19 = JS_ToObject(param_1,uVar4,uVar5);
lVar10 = auVar19._0_8_;
if (auVar19._8_4_ == 6) goto LAB_00180b19;
uVar1 = *(ushort *)(lVar10 + 6);
if ((ushort)(uVar1 - 0x15) < 0xc) {
local_68 = *(long *)(param_2 + 0x30);
local_60 = *(long *)(*(long *)(local_68 + 0x18) + 0x30);
local_50 = *(long *)(lVar10 + 0x30);
lVar6 = *(long *)(*(long *)(local_50 + 0x18) + 0x30);
uVar2 = *(ushort *)(param_2 + 6);
local_58 = (ulong)(byte)"toSorted"[(ulong)uVar2 + 6];
iVar9 = typed_array_is_oob(lVar10);
uVar11 = 4;
if (iVar9 == 0) {
local_80 = (ulong)*(uint *)(lVar10 + 0x40);
uVar11 = 3;
if (((long)local_38 <= (long)(uVar3 - local_80)) && (uVar11 = 0, uVar1 == uVar2)) {
memmove((void *)((local_38 << ((byte)local_58 & 0x3f)) +
(ulong)*(uint *)(local_68 + 0x20) + *(long *)(local_60 + 0x10)),
(void *)((ulong)*(uint *)(local_50 + 0x20) + *(long *)(lVar6 + 0x10)),
local_80 << ((byte)local_58 & 0x3f));
uVar11 = 5;
}
}
switch(uVar11) {
case 0:
switchD_00180c31_caseD_0:
uVar8 = local_80;
if (0 < (long)local_80) {
uVar12 = 0;
uVar14 = 1;
uVar18 = local_38;
do {
auVar20 = JS_GetPropertyInt64(param_1,lVar10,auVar19._8_8_,uVar12);
if (auVar20._8_4_ == 6) goto LAB_00180b19;
iVar9 = typed_array_is_oob(param_2);
iVar16 = (int)uVar18;
if (iVar9 == 0) {
dVar13 = (double)(uVar18 & 0xffffffff);
if (-1 < iVar16) {
dVar13 = (double)(uVar18 & 0xffffffff);
}
uVar15 = 7;
if (-1 < iVar16) {
uVar15 = 0;
}
local_78._0_4_ = auVar20._0_4_;
iVar9 = JS_SetPropertyValue(param_1,local_48,local_40,dVar13,uVar15,0x4000,
local_78._0_4_,auVar20._8_4_);
local_78 = auVar20;
if (iVar9 < 0) goto LAB_00180b19;
}
else {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar20._0_8_,auVar20._8_8_);
}
uVar18 = (ulong)(iVar16 + 1);
bVar7 = (long)uVar14 < (long)uVar8;
uVar12 = uVar14;
uVar14 = (ulong)((int)uVar14 + 1);
} while (bVar7);
}
case 5:
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),lVar10,auVar19._8_8_);
return 0;
default:
return 0;
case 3:
goto switchD_00180c31_caseD_3;
case 4:
goto LAB_00180abf;
}
}
iVar9 = js_get_length64(param_1,&local_80,lVar10);
if (iVar9 != 0) goto LAB_00180b19;
if ((long)local_38 <= (long)(uVar3 - local_80)) goto switchD_00180c31_caseD_0;
}
switchD_00180c31_caseD_3:
JS_ThrowRangeError(param_1,"invalid array length");
LAB_00180b19:
local_98 = auVar19._0_8_;
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_98,auVar19._8_8_);
return 0;
}
| |
39,518 | js_typed_array_set | bluesky950520[P]quickjs/quickjs.c | static JSValue js_typed_array_set(JSContext *ctx,
JSValue this_val,
int argc, JSValue *argv)
{
JSValue offset = JS_UNDEFINED;
if (argc > 1) {
offset = argv[1];
}
return js_typed_array_set_internal(ctx, this_val, argv[0], offset);
} | O2 | c | js_typed_array_set:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
pushq $0x3
popq %r14
cmpl $0x2, %ecx
jl 0x6c250
movq %r14, %rbp
movq 0x10(%r8), %r13
movq 0x18(%r8), %r14
jmp 0x6c256
xorl %r13d, %r13d
movq %r14, %rbp
movq (%r8), %r15
movq 0x8(%r8), %r12
movq %rbx, %rdi
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
callq 0x3280b
testq %rax, %rax
je 0x6c290
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rdx
movq %r14, %rcx
callq 0x21416
testl %eax, %eax
je 0x6c2b8
xorl %r15d, %r15d
movq %rbp, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1801e
pushq $0x6
popq %rdx
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x48(%rsp), %rbp
testq %rbp, %rbp
js 0x6c2e4
movq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x32836
testl %eax, %eax
je 0x6c2fe
pushq $0x3
popq %r14
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x3289b
jmp 0x6c296
pushq $0x3
popq %r14
xorl %r15d, %r15d
leaq 0x19dfc(%rip), %rsi # 0x860ee
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1acb3
jmp 0x6c296
movl 0x40(%r14), %r13d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x20b92
movq %rax, %r15
movq %rdx, %r14
cmpl $0x6, %edx
je 0x6c296
movzwl 0x6(%r15), %r12d
leal -0x15(%r12), %eax
cmpw $0xb, %ax
ja 0x6c3f6
movq %rbp, (%rsp)
movq 0x10(%rsp), %rcx
movq 0x30(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%r15), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
movzwl 0x6(%rcx), %ebp
leaq 0x1850c(%rip), %rax # 0x8487f
movzbl -0x15(%rbp,%rax), %eax
movq %rax, 0x18(%rsp)
movq %r15, %rdi
callq 0x32836
testl %eax, %eax
jne 0x6c2da
movq 0x8(%rsp), %r9
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %r8
movl 0x40(%r15), %eax
subq %rax, %r13
cmpq %r13, (%rsp)
jg 0x6c2eb
movq %rax, %rdx
cmpw %bp, %r12w
jne 0x6c427
movl 0x20(%r9), %eax
addq 0x10(%rdi), %rax
movq (%rsp), %rdi
shlq %cl, %rdi
addq %rax, %rdi
movl 0x20(%rsi), %esi
addq 0x10(%r8), %rsi
shlq %cl, %rdx
callq 0xe740
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1801e
pushq $0x3
jmp 0x6c2a6
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1cc43
testl %eax, %eax
jne 0x6c296
movq 0x50(%rsp), %rax
movq %rax, %rdx
subq %rax, %r13
cmpq %r13, %rbp
jg 0x6c2eb
jmp 0x6c42b
movq (%rsp), %rbp
movq %rdx, 0x8(%rsp)
xorl %ecx, %ecx
movl %ecx, %ecx
cmpq %rcx, 0x8(%rsp)
jle 0x6c3e1
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rcx, %r13
callq 0x1e178
movq %rdx, %r12
cmpl $0x6, %r12d
je 0x6c296
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x32836
testl %eax, %eax
je 0x6c47c
movq %rbx, %rdi
movq (%rsp), %rsi
movq %r12, %rdx
callq 0x1801e
jmp 0x6c4a2
leal (%rbp,%r13), %ecx
movq %rbx, %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq (%rsp), %r8
movq %r12, %r9
callq 0x1ece3
testl %eax, %eax
js 0x6c296
incl %r13d
movq %r13, %rcx
jmp 0x6c432
| js_typed_array_set:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
push 3
pop r14
cmp ecx, 2
jl short loc_6C250
mov rbp, r14
mov r13, [r8+10h]
mov r14, [r8+18h]
jmp short loc_6C256
loc_6C250:
xor r13d, r13d
mov rbp, r14
loc_6C256:
mov r15, [r8]
mov r12, [r8+8]
mov rdi, rbx
mov [rsp+88h+var_50], rsi
mov [rsp+88h+var_48], rdx
call get_typed_array
test rax, rax
jz short loc_6C290
mov [rsp+88h+var_78], rax
lea rsi, [rsp+88h+var_40]
mov rdi, rbx
mov rdx, r13
mov rcx, r14
call JS_ToInt64Sat
test eax, eax
jz short loc_6C2B8
loc_6C290:
xor r15d, r15d
mov r14, rbp
loc_6C296:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_FreeValue
push 6
loc_6C2A6:
pop rdx
xor eax, eax
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6C2B8:
mov rbp, [rsp+88h+var_40]
test rbp, rbp
js short loc_6C2E4
mov r14, [rsp+88h+var_78]
mov rdi, r14
call typed_array_is_oob
test eax, eax
jz short loc_6C2FE
push 3
pop r14
xor r15d, r15d
loc_6C2DA:
mov rdi, rbx
call JS_ThrowTypeErrorArrayBufferOOB
jmp short loc_6C296
loc_6C2E4:
push 3
pop r14
xor r15d, r15d
loc_6C2EB:
lea rsi, aInvalidArrayLe; "invalid array length"
mov rdi, rbx
xor eax, eax
call JS_ThrowRangeError
jmp short loc_6C296
loc_6C2FE:
mov r13d, [r14+40h]
mov rdi, rbx
mov rsi, r15
mov rdx, r12
call JS_ToObject
mov r15, rax
mov r14, rdx
cmp edx, 6
jz loc_6C296
movzx r12d, word ptr [r15+6]
lea eax, [r12-15h]
cmp ax, 0Bh
ja loc_6C3F6
mov [rsp+88h+var_88], rbp
mov rcx, [rsp+88h+var_78]
mov rax, [rcx+30h]
mov [rsp+88h+var_80], rax
mov rax, [rax+18h]
mov rax, [rax+30h]
mov [rsp+88h+var_60], rax
mov rax, [r15+30h]
mov [rsp+88h+var_58], rax
mov rax, [rax+18h]
mov rax, [rax+30h]
mov [rsp+88h+var_68], rax
movzx ebp, word ptr [rcx+6]
lea rax, typed_array_size_log2
movzx eax, byte ptr [rbp+rax-15h]
mov [rsp+88h+var_70], rax
mov rdi, r15
call typed_array_is_oob
test eax, eax
jnz loc_6C2DA
mov r9, [rsp+88h+var_80]
mov rdi, [rsp+88h+var_60]
mov rcx, [rsp+88h+var_70]
mov rsi, [rsp+88h+var_58]
mov r8, [rsp+88h+var_68]
mov eax, [r15+40h]
sub r13, rax
cmp [rsp+88h+var_88], r13
jg loc_6C2EB
mov rdx, rax
cmp r12w, bp
jnz short loc_6C427
mov eax, [r9+20h]
add rax, [rdi+10h]
mov rdi, [rsp+88h+var_88]
shl rdi, cl
add rdi, rax
mov esi, [rsi+20h]
add rsi, [r8+10h]
shl rdx, cl
call _memmove
loc_6C3E1:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_FreeValue
push 3
jmp loc_6C2A6
loc_6C3F6:
lea rsi, [rsp+88h+var_38]
mov rdi, rbx
mov rdx, r15
mov rcx, r14
call js_get_length64
test eax, eax
jnz loc_6C296
mov rax, [rsp+88h+var_38]
mov rdx, rax
sub r13, rax
cmp rbp, r13
jg loc_6C2EB
jmp short loc_6C42B
loc_6C427:
mov rbp, [rsp+88h+var_88]
loc_6C42B:
mov [rsp+88h+var_80], rdx
xor ecx, ecx
loc_6C432:
mov ecx, ecx
cmp [rsp+88h+var_80], rcx
jle short loc_6C3E1
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov r13, rcx
call JS_GetPropertyInt64
mov r12, rdx
cmp r12d, 6
jz loc_6C296
mov [rsp+88h+var_88], rax
mov rdi, [rsp+88h+var_78]
call typed_array_is_oob
test eax, eax
jz short loc_6C47C
mov rdi, rbx
mov rsi, [rsp+88h+var_88]
mov rdx, r12
call JS_FreeValue
jmp short loc_6C4A2
loc_6C47C:
lea ecx, [rbp+r13+0]
mov rdi, rbx
mov rsi, [rsp+88h+var_50]
mov rdx, [rsp+88h+var_48]
mov r8, [rsp+88h+var_88]
mov r9, r12
call JS_SetPropertyUint32
test eax, eax
js loc_6C296
loc_6C4A2:
inc r13d
mov rcx, r13
jmp short loc_6C432
| long long js_typed_array_set(
long long a1,
long long a2,
long long a3,
long long a4,
long long *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // r14
_DWORD *v15; // r13
long long v16; // r15
long long v17; // r12
long long typed_array; // rax
long long *v19; // rsi
long long v20; // rdx
long long v21; // rcx
long long v22; // r8
long long v23; // r9
__m128 v24; // xmm4
__m128 v25; // xmm5
long long v26; // r15
long long v27; // r14
signed long long v29; // rbp
long long v30; // rcx
long long v31; // r8
long long v32; // r9
long long v33; // r13
long long v34; // rax
long long v35; // rdx
__int16 v36; // r12
long long v37; // rbp
unsigned int i; // ecx
unsigned int v39; // r13d
unsigned long long PropertyInt64; // rax
long long v41; // rdx
long long v42; // r12
signed long long v43; // [rsp+0h] [rbp-88h]
long long v44; // [rsp+0h] [rbp-88h]
long long v45; // [rsp+8h] [rbp-80h]
long long v46; // [rsp+8h] [rbp-80h]
long long v47; // [rsp+10h] [rbp-78h]
long long v48; // [rsp+18h] [rbp-70h]
long long v49; // [rsp+20h] [rbp-68h]
long long v50; // [rsp+28h] [rbp-60h]
long long v51; // [rsp+30h] [rbp-58h]
int v52; // [rsp+38h] [rbp-50h]
int v53; // [rsp+40h] [rbp-48h]
long long v54; // [rsp+48h] [rbp-40h] BYREF
long long v55[7]; // [rsp+50h] [rbp-38h] BYREF
LODWORD(v14) = 3;
if ( (int)a4 < 2 )
{
v15 = 0LL;
}
else
{
v15 = (_DWORD *)a5[2];
v14 = a5[3];
}
v16 = *a5;
v17 = a5[1];
v52 = a2;
v53 = a3;
typed_array = get_typed_array(a1, a2, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( !typed_array || (v47 = typed_array, v19 = &v54, (unsigned int)JS_ToInt64Sat(a1, (long long)&v54, v15, v14)) )
{
v26 = 0LL;
v27 = 3LL;
goto LABEL_7;
}
v29 = v54;
if ( v54 < 0 )
{
v27 = 3LL;
v26 = 0LL;
goto LABEL_13;
}
if ( typed_array_is_oob(v47) )
{
v27 = 3LL;
v26 = 0LL;
LABEL_11:
JS_ThrowTypeErrorArrayBufferOOB(a1, a7, a8, a9, a10, v24, v25, a13, a14, (long long)v19, v20, v30, v31, v32, v43);
goto LABEL_7;
}
v33 = *(unsigned int *)(v47 + 64);
v19 = (long long *)v16;
v34 = JS_ToObject(a1, v16, v17, v30, v31, v32, a7, a8, a9, a10, v24, v25, a13, a14);
v26 = v34;
v27 = v35;
if ( (_DWORD)v35 == 6 )
goto LABEL_7;
v36 = *(_WORD *)(v34 + 6);
if ( (unsigned __int16)(v36 - 21) > 0xBu )
{
if ( (unsigned int)js_get_length64(a1, v55, v34, v35) )
goto LABEL_7;
v20 = v55[0];
if ( v29 <= v33 - v55[0] )
goto LABEL_25;
LABEL_13:
JS_ThrowRangeError(
a1,
(long long)"invalid array length",
v20,
v21,
v22,
v23,
a7,
a8,
a9,
a10,
v24,
v25,
a13,
a14,
v43);
goto LABEL_7;
}
v43 = v29;
v45 = *(_QWORD *)(v47 + 48);
v50 = *(_QWORD *)(*(_QWORD *)(v45 + 24) + 48LL);
v51 = *(_QWORD *)(v34 + 48);
v49 = *(_QWORD *)(*(_QWORD *)(v51 + 24) + 48LL);
v37 = *(unsigned __int16 *)(v47 + 6);
v48 = (unsigned __int8)typed_array_size_log2[v37 - 21];
if ( typed_array_is_oob(v34) )
goto LABEL_11;
v23 = v45;
v21 = v48;
v22 = v49;
if ( v43 > v33 - *(unsigned int *)(v26 + 64) )
goto LABEL_13;
v20 = *(unsigned int *)(v26 + 64);
if ( v36 == (_WORD)v37 )
{
memmove(
*(_QWORD *)(v50 + 16) + *(unsigned int *)(v45 + 32) + (v43 << v48),
*(_QWORD *)(v49 + 16) + *(unsigned int *)(v51 + 32),
v20 << v48);
goto LABEL_7;
}
LODWORD(v29) = v43;
LABEL_25:
v46 = v20;
for ( i = 0; v46 > i; i = v39 + 1 )
{
v39 = i;
PropertyInt64 = JS_GetPropertyInt64(a1, v26, v27, i);
v42 = v41;
if ( (_DWORD)v41 == 6 )
break;
v44 = PropertyInt64;
if ( typed_array_is_oob(v47) )
{
JS_FreeValue(a1, v44, v42);
}
else if ( (int)JS_SetPropertyUint32(a1, v52, v53, (unsigned int)v29 + v39, v44, v42) < 0 )
{
break;
}
}
LABEL_7:
JS_FreeValue(a1, v26, v27);
return 0LL;
}
| js_typed_array_set:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
PUSH 0x3
POP R14
CMP ECX,0x2
JL 0x0016c250
MOV RBP,R14
MOV R13,qword ptr [R8 + 0x10]
MOV R14,qword ptr [R8 + 0x18]
JMP 0x0016c256
LAB_0016c250:
XOR R13D,R13D
MOV RBP,R14
LAB_0016c256:
MOV R15,qword ptr [R8]
MOV R12,qword ptr [R8 + 0x8]
MOV RDI,RBX
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x40],RDX
CALL 0x0013280b
TEST RAX,RAX
JZ 0x0016c290
MOV qword ptr [RSP + 0x10],RAX
LEA RSI,[RSP + 0x48]
MOV RDI,RBX
MOV RDX,R13
MOV RCX,R14
CALL 0x00121416
TEST EAX,EAX
JZ 0x0016c2b8
LAB_0016c290:
XOR R15D,R15D
MOV R14,RBP
LAB_0016c296:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011801e
PUSH 0x6
LAB_0016c2a6:
POP RDX
XOR EAX,EAX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016c2b8:
MOV RBP,qword ptr [RSP + 0x48]
TEST RBP,RBP
JS 0x0016c2e4
MOV R14,qword ptr [RSP + 0x10]
MOV RDI,R14
CALL 0x00132836
TEST EAX,EAX
JZ 0x0016c2fe
PUSH 0x3
POP R14
XOR R15D,R15D
LAB_0016c2da:
MOV RDI,RBX
CALL 0x0013289b
JMP 0x0016c296
LAB_0016c2e4:
PUSH 0x3
POP R14
XOR R15D,R15D
LAB_0016c2eb:
LEA RSI,[0x1860ee]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0011acb3
JMP 0x0016c296
LAB_0016c2fe:
MOV R13D,dword ptr [R14 + 0x40]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
CALL 0x00120b92
MOV R15,RAX
MOV R14,RDX
CMP EDX,0x6
JZ 0x0016c296
MOVZX R12D,word ptr [R15 + 0x6]
LEA EAX,[R12 + -0x15]
CMP AX,0xb
JA 0x0016c3f6
MOV qword ptr [RSP],RBP
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RCX + 0x30]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [R15 + 0x30]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x20],RAX
MOVZX EBP,word ptr [RCX + 0x6]
LEA RAX,[0x18487f]
MOVZX EAX,byte ptr [RBP + RAX*0x1 + -0x15]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,R15
CALL 0x00132836
TEST EAX,EAX
JNZ 0x0016c2da
MOV R9,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x30]
MOV R8,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [R15 + 0x40]
SUB R13,RAX
CMP qword ptr [RSP],R13
JG 0x0016c2eb
MOV RDX,RAX
CMP R12W,BP
JNZ 0x0016c427
MOV EAX,dword ptr [R9 + 0x20]
ADD RAX,qword ptr [RDI + 0x10]
MOV RDI,qword ptr [RSP]
SHL RDI,CL
ADD RDI,RAX
MOV ESI,dword ptr [RSI + 0x20]
ADD RSI,qword ptr [R8 + 0x10]
SHL RDX,CL
CALL 0x0010e740
LAB_0016c3e1:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011801e
PUSH 0x3
JMP 0x0016c2a6
LAB_0016c3f6:
LEA RSI,[RSP + 0x50]
MOV RDI,RBX
MOV RDX,R15
MOV RCX,R14
CALL 0x0011cc43
TEST EAX,EAX
JNZ 0x0016c296
MOV RAX,qword ptr [RSP + 0x50]
MOV RDX,RAX
SUB R13,RAX
CMP RBP,R13
JG 0x0016c2eb
JMP 0x0016c42b
LAB_0016c427:
MOV RBP,qword ptr [RSP]
LAB_0016c42b:
MOV qword ptr [RSP + 0x8],RDX
XOR ECX,ECX
LAB_0016c432:
MOV ECX,ECX
CMP qword ptr [RSP + 0x8],RCX
JLE 0x0016c3e1
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV R13,RCX
CALL 0x0011e178
MOV R12,RDX
CMP R12D,0x6
JZ 0x0016c296
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00132836
TEST EAX,EAX
JZ 0x0016c47c
MOV RDI,RBX
MOV RSI,qword ptr [RSP]
MOV RDX,R12
CALL 0x0011801e
JMP 0x0016c4a2
LAB_0016c47c:
LEA ECX,[RBP + R13*0x1]
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
MOV R8,qword ptr [RSP]
MOV R9,R12
CALL 0x0011ece3
TEST EAX,EAX
JS 0x0016c296
LAB_0016c4a2:
INC R13D
MOV RCX,R13
JMP 0x0016c432
|
int1 [16]
js_typed_array_set(int8 param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5)
{
byte bVar1;
ushort uVar2;
ushort uVar3;
int8 uVar4;
int8 uVar5;
long lVar6;
long lVar7;
long lVar8;
long lVar9;
int iVar10;
long lVar11;
ulong uVar13;
uint uVar14;
int8 uVar15;
int8 uVar16;
int1 auVar17 [16];
int1 auVar18 [16];
ulong uStack_90;
long local_40;
ulong local_38;
long lVar12;
uVar16 = 3;
if (param_4 < 2) {
uVar15 = 0;
}
else {
uVar15 = param_5[2];
uVar16 = param_5[3];
}
uVar4 = *param_5;
uVar5 = param_5[1];
lVar11 = get_typed_array(param_1);
if ((lVar11 == 0) || (iVar10 = JS_ToInt64Sat(param_1,&local_40,uVar15,uVar16), iVar10 != 0)) {
auVar17 = ZEXT816(3) << 0x40;
}
else {
if (local_40 < 0) {
auVar17 = ZEXT816(3) << 0x40;
goto LAB_0016c2eb;
}
iVar10 = typed_array_is_oob(lVar11);
if (iVar10 == 0) {
uVar14 = *(uint *)(lVar11 + 0x40);
auVar17 = JS_ToObject(param_1,uVar4,uVar5);
lVar12 = auVar17._0_8_;
if (auVar17._8_4_ != 6) {
uVar2 = *(ushort *)(lVar12 + 6);
if ((ushort)(uVar2 - 0x15) < 0xc) {
lVar6 = *(long *)(lVar11 + 0x30);
lVar7 = *(long *)(*(long *)(lVar6 + 0x18) + 0x30);
lVar8 = *(long *)(lVar12 + 0x30);
lVar9 = *(long *)(*(long *)(lVar8 + 0x18) + 0x30);
uVar3 = *(ushort *)(lVar11 + 6);
bVar1 = "toSorted"[(ulong)uVar3 + 6];
iVar10 = typed_array_is_oob(lVar12);
if (iVar10 != 0) goto LAB_0016c2da;
uVar13 = (ulong)*(uint *)(lVar12 + 0x40);
if (local_40 <= (long)(uVar14 - uVar13)) {
if (uVar2 != uVar3) goto LAB_0016c42b;
memmove((void *)((local_40 << (bVar1 & 0x3f)) +
(ulong)*(uint *)(lVar6 + 0x20) + *(long *)(lVar7 + 0x10)),
(void *)((ulong)*(uint *)(lVar8 + 0x20) + *(long *)(lVar9 + 0x10)),
uVar13 << (bVar1 & 0x3f));
LAB_0016c3e1:
JS_FreeValue(param_1,lVar12,auVar17._8_8_);
uStack_90 = 3;
goto LAB_0016c2a6;
}
}
else {
iVar10 = js_get_length64(param_1,&local_38,lVar12);
if (iVar10 != 0) goto LAB_0016c296;
uVar13 = local_38;
if (local_40 <= (long)(uVar14 - local_38)) {
LAB_0016c42b:
for (uVar14 = 0; (long)(ulong)uVar14 < (long)uVar13; uVar14 = uVar14 + 1) {
auVar18 = JS_GetPropertyInt64(param_1,lVar12,auVar17._8_8_);
if (auVar18._8_4_ == 6) goto LAB_0016c296;
iVar10 = typed_array_is_oob(lVar11);
if (iVar10 == 0) {
iVar10 = JS_SetPropertyUint32
(param_1,param_2,param_3,(int)local_40 + uVar14,auVar18._0_8_,
auVar18._8_8_);
if (iVar10 < 0) goto LAB_0016c296;
}
else {
JS_FreeValue(param_1,auVar18._0_8_,auVar18._8_8_);
}
}
goto LAB_0016c3e1;
}
}
LAB_0016c2eb:
JS_ThrowRangeError(param_1,"invalid array length");
}
}
else {
auVar17 = ZEXT816(3) << 0x40;
LAB_0016c2da:
JS_ThrowTypeErrorArrayBufferOOB(param_1);
}
}
LAB_0016c296:
JS_FreeValue(param_1,auVar17._0_8_,auVar17._8_8_);
uStack_90 = 6;
LAB_0016c2a6:
auVar17._8_8_ = 0;
auVar17._0_8_ = uStack_90;
return auVar17 << 0x40;
}
| |
39,519 | ma_free_root | eloqsql/libmariadb/libmariadb/ma_alloc.c | void ma_free_root(MA_MEM_ROOT *root, myf MyFlags)
{
reg1 MA_USED_MEM *next,*old;
if (!root)
return; /* purecov: inspected */
if (!(MyFlags & MY_KEEP_PREALLOC))
root->pre_alloc=0;
for ( next=root->used; next ;)
{
old=next; next= next->next ;
if (old != root->pre_alloc)
free(old);
}
for (next= root->free ; next ; )
{
old=next; next= next->next ;
if (old != root->pre_alloc)
free(old);
}
root->used=root->free=0;
if (root->pre_alloc)
{
root->free=root->pre_alloc;
root->free->left=root->pre_alloc->size-ALIGN_SIZE(sizeof(MA_USED_MEM));
root->free->next=0;
}
} | O3 | c | ma_free_root:
testq %rdi, %rdi
je 0x20f0d
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testb $0x1, %sil
jne 0x20ea4
movq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x20ec3
movq (%rdi), %r14
cmpq 0x10(%rbx), %rdi
je 0x20ebb
callq 0x13570
movq %r14, %rdi
testq %r14, %r14
jne 0x20ead
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x20ee1
movq (%rdi), %r14
cmpq 0x10(%rbx), %rdi
je 0x20ed9
callq 0x13570
movq %r14, %rdi
testq %r14, %r14
jne 0x20ecb
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x20f09
movq %rax, (%rbx)
movq 0x10(%rax), %rcx
addq $-0x18, %rcx
movq %rcx, 0x8(%rax)
movq (%rbx), %rax
movq $0x0, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
| ma_free_root:
test rdi, rdi
jz locret_20F0D
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
test sil, 1
jnz short loc_20EA4
mov qword ptr [rbx+10h], 0
loc_20EA4:
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_20EC3
loc_20EAD:
mov r14, [rdi]
cmp rdi, [rbx+10h]
jz short loc_20EBB
call _free
loc_20EBB:
mov rdi, r14
test r14, r14
jnz short loc_20EAD
loc_20EC3:
mov rdi, [rbx]
test rdi, rdi
jz short loc_20EE1
loc_20ECB:
mov r14, [rdi]
cmp rdi, [rbx+10h]
jz short loc_20ED9
call _free
loc_20ED9:
mov rdi, r14
test r14, r14
jnz short loc_20ECB
loc_20EE1:
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
mov rax, [rbx+10h]
test rax, rax
jz short loc_20F09
mov [rbx], rax
mov rcx, [rax+10h]
add rcx, 0FFFFFFFFFFFFFFE8h
mov [rax+8], rcx
mov rax, [rbx]
mov qword ptr [rax], 0
loc_20F09:
pop rbx
pop r14
pop rbp
locret_20F0D:
retn
| void ma_free_root(long long a1, char a2)
{
_QWORD *v3; // rdi
_QWORD *v4; // r14
_QWORD *v5; // rdi
_QWORD *v6; // r14
long long v7; // rax
if ( a1 )
{
if ( (a2 & 1) == 0 )
*(_QWORD *)(a1 + 16) = 0LL;
v3 = *(_QWORD **)(a1 + 8);
if ( v3 )
{
do
{
v4 = (_QWORD *)*v3;
if ( v3 != *(_QWORD **)(a1 + 16) )
free(v3);
v3 = v4;
}
while ( v4 );
}
v5 = *(_QWORD **)a1;
if ( *(_QWORD *)a1 )
{
do
{
v6 = (_QWORD *)*v5;
if ( v5 != *(_QWORD **)(a1 + 16) )
free(v5);
v5 = v6;
}
while ( v6 );
}
*(_OWORD *)a1 = 0LL;
v7 = *(_QWORD *)(a1 + 16);
if ( v7 )
{
*(_QWORD *)a1 = v7;
*(_QWORD *)(v7 + 8) = *(_QWORD *)(v7 + 16) - 24LL;
**(_QWORD **)a1 = 0LL;
}
}
}
| ma_free_root:
TEST RDI,RDI
JZ 0x00120f0d
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
TEST SIL,0x1
JNZ 0x00120ea4
MOV qword ptr [RBX + 0x10],0x0
LAB_00120ea4:
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x00120ec3
LAB_00120ead:
MOV R14,qword ptr [RDI]
CMP RDI,qword ptr [RBX + 0x10]
JZ 0x00120ebb
CALL 0x00113570
LAB_00120ebb:
MOV RDI,R14
TEST R14,R14
JNZ 0x00120ead
LAB_00120ec3:
MOV RDI,qword ptr [RBX]
TEST RDI,RDI
JZ 0x00120ee1
LAB_00120ecb:
MOV R14,qword ptr [RDI]
CMP RDI,qword ptr [RBX + 0x10]
JZ 0x00120ed9
CALL 0x00113570
LAB_00120ed9:
MOV RDI,R14
TEST R14,R14
JNZ 0x00120ecb
LAB_00120ee1:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOV RAX,qword ptr [RBX + 0x10]
TEST RAX,RAX
JZ 0x00120f09
MOV qword ptr [RBX],RAX
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,-0x18
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBX]
MOV qword ptr [RAX],0x0
LAB_00120f09:
POP RBX
POP R14
POP RBP
LAB_00120f0d:
RET
|
void ma_free_root(long *param_1,byte param_2)
{
int8 *puVar1;
long lVar2;
int8 *puVar3;
if (param_1 != (long *)0x0) {
if ((param_2 & 1) == 0) {
param_1[2] = 0;
}
puVar1 = (int8 *)param_1[1];
while (puVar3 = puVar1, puVar3 != (int8 *)0x0) {
puVar1 = (int8 *)*puVar3;
if (puVar3 != (int8 *)param_1[2]) {
free(puVar3);
}
}
puVar1 = (int8 *)*param_1;
while (puVar3 = puVar1, puVar3 != (int8 *)0x0) {
puVar1 = (int8 *)*puVar3;
if (puVar3 != (int8 *)param_1[2]) {
free(puVar3);
}
}
*param_1 = 0;
param_1[1] = 0;
lVar2 = param_1[2];
if (lVar2 != 0) {
*param_1 = lVar2;
*(long *)(lVar2 + 8) = *(long *)(lVar2 + 0x10) + -0x18;
*(int8 *)*param_1 = 0;
}
}
return;
}
| |
39,520 | ma_unique_hash | eloqsql/storage/maria/ma_unique.c | ha_checksum _ma_unique_hash(MARIA_UNIQUEDEF *def, const uchar *record)
{
const uchar *pos, *end;
ha_checksum crc= 0;
ulong seed1=0, seed2= 4;
HA_KEYSEG *keyseg;
for (keyseg=def->seg ; keyseg < def->end ; keyseg++)
{
enum ha_base_keytype type=(enum ha_base_keytype) keyseg->type;
uint length=keyseg->length;
if (keyseg->null_bit)
{
if (record[keyseg->null_pos] & keyseg->null_bit)
{
/*
Change crc in a way different from an empty string or 0.
(This is an optimisation; The code will work even if this isn't
done)
*/
crc=((crc << 8) + 511+
(crc >> (8*sizeof(ha_checksum)-8)));
continue;
}
}
pos= record+keyseg->start;
if (keyseg->flag & HA_VAR_LENGTH_PART)
{
uint pack_length= keyseg->bit_start;
uint tmp_length= (pack_length == 1 ? (uint) *pos :
uint2korr(pos));
pos+= pack_length; /* Skip VARCHAR length */
set_if_smaller(length,tmp_length);
}
else if (keyseg->flag & HA_BLOB_PART)
{
uint tmp_length= _ma_calc_blob_length(keyseg->bit_start,pos);
memcpy((void*) &pos,pos+keyseg->bit_start,sizeof(char*));
if (!length || length > tmp_length)
length=tmp_length; /* The whole blob */
}
end= pos+length;
if (type == HA_KEYTYPE_TEXT || type == HA_KEYTYPE_VARTEXT1 ||
type == HA_KEYTYPE_VARTEXT2)
{
my_ci_hash_sort(keyseg->charset,
(const uchar*) pos, length,
&seed1, &seed2);
crc+= seed1;
}
else
{
my_hash_sort_bin((CHARSET_INFO*) 0, pos, (size_t) (end-pos),
&seed1, &seed2);
crc+= seed1;
}
}
return crc;
} | O3 | c | ma_unique_hash:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x4, -0x40(%rbp)
movq 0x8(%rdi), %r13
movq %rdi, -0x48(%rbp)
movq 0x10(%rdi), %rax
xorl %r15d, %r15d
cmpq %rax, %r13
jae 0x58a2b
xorl %r15d, %r15d
movzbl 0x18(%r13), %r14d
movzwl 0x14(%r13), %ebx
movb 0x19(%r13), %cl
testb %cl, %cl
je 0x58978
movl 0xc(%r13), %edx
movq -0x38(%rbp), %rsi
testb %cl, (%rsi,%rdx)
je 0x58978
roll $0x8, %r15d
addl $0x1ff, %r15d # imm = 0x1FF
jmp 0x58a1e
movl 0x8(%r13), %r12d
addq -0x38(%rbp), %r12
movzwl 0x12(%r13), %eax
testb $0x8, %al
jne 0x589b3
testb $0x20, %al
je 0x589d2
movzbl 0x1a(%r13), %edi
movq %r12, %rsi
callq 0x48c57
movzbl 0x1a(%r13), %ecx
movq (%r12,%rcx), %r12
cmpl %eax, %ebx
movl %eax, %ecx
cmovbl %ebx, %ecx
testl %ebx, %ebx
cmovel %eax, %ecx
movl %ecx, %ebx
jmp 0x589d2
movzbl 0x1a(%r13), %eax
cmpq $0x1, %rax
jne 0x589c5
movzbl (%r12), %ecx
jmp 0x589ca
movzwl (%r12), %ecx
addq %rax, %r12
cmpl %ebx, %ecx
cmovbl %ecx, %ebx
movl %ebx, %edx
cmpl $0x11, %r14d
ja 0x58a00
movl $0x28002, %eax # imm = 0x28002
btl %r14d, %eax
jae 0x58a00
movq (%r13), %rdi
movq 0xc0(%rdi), %rax
movq %r12, %rsi
leaq -0x30(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq *0x50(%rax)
jmp 0x58a12
xorl %edi, %edi
movq %r12, %rsi
leaq -0x30(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0xac3a9
addl -0x30(%rbp), %r15d
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x20, %r13
cmpq %rax, %r13
jb 0x58949
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_unique_hash:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_38], rsi
mov [rbp+var_30], 0
mov [rbp+var_40], 4
mov r13, [rdi+8]
mov [rbp+var_48], rdi
mov rax, [rdi+10h]
xor r15d, r15d
cmp r13, rax
jnb loc_58A2B
xor r15d, r15d
loc_58949:
movzx r14d, byte ptr [r13+18h]
movzx ebx, word ptr [r13+14h]
mov cl, [r13+19h]
test cl, cl
jz short loc_58978
mov edx, [r13+0Ch]
mov rsi, [rbp+var_38]
test [rsi+rdx], cl
jz short loc_58978
rol r15d, 8
add r15d, 1FFh
jmp loc_58A1E
loc_58978:
mov r12d, [r13+8]
add r12, [rbp+var_38]
movzx eax, word ptr [r13+12h]
test al, 8
jnz short loc_589B3
test al, 20h
jz short loc_589D2
movzx edi, byte ptr [r13+1Ah]
mov rsi, r12
call _ma_calc_blob_length
movzx ecx, byte ptr [r13+1Ah]
mov r12, [r12+rcx]
cmp ebx, eax
mov ecx, eax
cmovb ecx, ebx
test ebx, ebx
cmovz ecx, eax
mov ebx, ecx
jmp short loc_589D2
loc_589B3:
movzx eax, byte ptr [r13+1Ah]
cmp rax, 1
jnz short loc_589C5
movzx ecx, byte ptr [r12]
jmp short loc_589CA
loc_589C5:
movzx ecx, word ptr [r12]
loc_589CA:
add r12, rax
cmp ecx, ebx
cmovb ebx, ecx
loc_589D2:
mov edx, ebx
cmp r14d, 11h
ja short loc_58A00
mov eax, 28002h
bt eax, r14d
jnb short loc_58A00
mov rdi, [r13+0]
mov rax, [rdi+0C0h]
mov rsi, r12
lea rcx, [rbp+var_30]
lea r8, [rbp+var_40]
call qword ptr [rax+50h]
jmp short loc_58A12
loc_58A00:
xor edi, edi
mov rsi, r12
lea rcx, [rbp+var_30]
lea r8, [rbp+var_40]
call my_hash_sort_bin
loc_58A12:
add r15d, dword ptr [rbp+var_30]
mov rax, [rbp+var_48]
mov rax, [rax+10h]
loc_58A1E:
add r13, 20h ; ' '
cmp r13, rax
jb loc_58949
loc_58A2B:
mov eax, r15d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_unique_hash(long long a1, long long a2)
{
_QWORD *v2; // r13
unsigned long long v3; // rax
unsigned int v4; // r15d
unsigned int v5; // r14d
unsigned int v6; // ebx
unsigned __int8 v7; // cl
unsigned __int8 *v8; // r12
__int16 v9; // ax
unsigned int v10; // eax
unsigned int v11; // ecx
long long v12; // rax
unsigned int v13; // ecx
int v14; // eax
long long v16; // [rsp+10h] [rbp-40h] BYREF
long long v17; // [rsp+18h] [rbp-38h]
_QWORD v18[6]; // [rsp+20h] [rbp-30h] BYREF
v17 = a2;
v18[0] = 0LL;
v16 = 4LL;
v2 = *(_QWORD **)(a1 + 8);
v3 = *(_QWORD *)(a1 + 16);
v4 = 0;
if ( (unsigned long long)v2 < v3 )
{
v4 = 0;
do
{
v5 = *((unsigned __int8 *)v2 + 24);
v6 = *((unsigned __int16 *)v2 + 10);
v7 = *((_BYTE *)v2 + 25);
if ( v7 && (v7 & *(_BYTE *)(v17 + *((unsigned int *)v2 + 3))) != 0 )
{
v4 = __ROL4__(v4, 8) + 511;
}
else
{
v8 = (unsigned __int8 *)(v17 + *((unsigned int *)v2 + 2));
v9 = *((_WORD *)v2 + 9);
if ( (v9 & 8) != 0 )
{
v12 = *((unsigned __int8 *)v2 + 26);
if ( v12 == 1 )
v13 = *v8;
else
v13 = *(unsigned __int16 *)v8;
v8 += v12;
if ( v13 < v6 )
v6 = v13;
}
else if ( (v9 & 0x20) != 0 )
{
v10 = ma_calc_blob_length(*((unsigned __int8 *)v2 + 26), (unsigned __int8 *)(v17 + *((unsigned int *)v2 + 2)));
v8 = *(unsigned __int8 **)&v8[*((unsigned __int8 *)v2 + 26)];
v11 = v10;
if ( v6 < v10 )
v11 = v6;
if ( !v6 )
v11 = v10;
v6 = v11;
}
if ( v5 <= 0x11 && (v14 = 163842, _bittest(&v14, v5)) )
(*(void ( **)(_QWORD, unsigned __int8 *, _QWORD, _QWORD *, long long *))(*(_QWORD *)(*v2 + 192LL)
+ 80LL))(
*v2,
v8,
v6,
v18,
&v16);
else
my_hash_sort_bin(0LL, v8, v6, v18, &v16);
v4 += LODWORD(v18[0]);
v3 = *(_QWORD *)(a1 + 16);
}
v2 += 4;
}
while ( (unsigned long long)v2 < v3 );
}
return v4;
}
| _ma_unique_hash:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x38],RSI
MOV qword ptr [RBP + -0x30],0x0
MOV qword ptr [RBP + -0x40],0x4
MOV R13,qword ptr [RDI + 0x8]
MOV qword ptr [RBP + -0x48],RDI
MOV RAX,qword ptr [RDI + 0x10]
XOR R15D,R15D
CMP R13,RAX
JNC 0x00158a2b
XOR R15D,R15D
LAB_00158949:
MOVZX R14D,byte ptr [R13 + 0x18]
MOVZX EBX,word ptr [R13 + 0x14]
MOV CL,byte ptr [R13 + 0x19]
TEST CL,CL
JZ 0x00158978
MOV EDX,dword ptr [R13 + 0xc]
MOV RSI,qword ptr [RBP + -0x38]
TEST byte ptr [RSI + RDX*0x1],CL
JZ 0x00158978
ROL R15D,0x8
ADD R15D,0x1ff
JMP 0x00158a1e
LAB_00158978:
MOV R12D,dword ptr [R13 + 0x8]
ADD R12,qword ptr [RBP + -0x38]
MOVZX EAX,word ptr [R13 + 0x12]
TEST AL,0x8
JNZ 0x001589b3
TEST AL,0x20
JZ 0x001589d2
MOVZX EDI,byte ptr [R13 + 0x1a]
MOV RSI,R12
CALL 0x00148c57
MOVZX ECX,byte ptr [R13 + 0x1a]
MOV R12,qword ptr [R12 + RCX*0x1]
CMP EBX,EAX
MOV ECX,EAX
CMOVC ECX,EBX
TEST EBX,EBX
CMOVZ ECX,EAX
MOV EBX,ECX
JMP 0x001589d2
LAB_001589b3:
MOVZX EAX,byte ptr [R13 + 0x1a]
CMP RAX,0x1
JNZ 0x001589c5
MOVZX ECX,byte ptr [R12]
JMP 0x001589ca
LAB_001589c5:
MOVZX ECX,word ptr [R12]
LAB_001589ca:
ADD R12,RAX
CMP ECX,EBX
CMOVC EBX,ECX
LAB_001589d2:
MOV EDX,EBX
CMP R14D,0x11
JA 0x00158a00
MOV EAX,0x28002
BT EAX,R14D
JNC 0x00158a00
MOV RDI,qword ptr [R13]
MOV RAX,qword ptr [RDI + 0xc0]
MOV RSI,R12
LEA RCX,[RBP + -0x30]
LEA R8,[RBP + -0x40]
CALL qword ptr [RAX + 0x50]
JMP 0x00158a12
LAB_00158a00:
XOR EDI,EDI
MOV RSI,R12
LEA RCX,[RBP + -0x30]
LEA R8,[RBP + -0x40]
CALL 0x001ac3a9
LAB_00158a12:
ADD R15D,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x10]
LAB_00158a1e:
ADD R13,0x20
CMP R13,RAX
JC 0x00158949
LAB_00158a2b:
MOV EAX,R15D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint _ma_unique_hash(long param_1,long param_2)
{
byte bVar1;
ushort uVar2;
uint uVar3;
long *plVar4;
uint uVar5;
ushort *puVar6;
long *plVar7;
uint uVar8;
int8 local_48;
long local_40;
int8 local_38;
local_38 = 0;
local_48 = 4;
plVar7 = *(long **)(param_1 + 8);
plVar4 = *(long **)(param_1 + 0x10);
uVar8 = 0;
if (plVar7 < plVar4) {
uVar8 = 0;
local_40 = param_2;
do {
bVar1 = *(byte *)(plVar7 + 3);
uVar2 = *(ushort *)((long)plVar7 + 0x14);
if ((*(byte *)((long)plVar7 + 0x19) == 0) ||
((*(byte *)(local_40 + (ulong)*(uint *)((long)plVar7 + 0xc)) &
*(byte *)((long)plVar7 + 0x19)) == 0)) {
puVar6 = (ushort *)((ulong)*(uint *)(plVar7 + 1) + local_40);
uVar5 = (uint)uVar2;
if ((*(ushort *)((long)plVar7 + 0x12) & 8) == 0) {
if ((*(ushort *)((long)plVar7 + 0x12) & 0x20) != 0) {
uVar3 = _ma_calc_blob_length(*(int1 *)((long)plVar7 + 0x1a),puVar6);
puVar6 = *(ushort **)((long)puVar6 + (ulong)*(byte *)((long)plVar7 + 0x1a));
uVar5 = uVar3;
if (uVar2 < uVar3) {
uVar5 = (uint)uVar2;
}
if (uVar2 == 0) {
uVar5 = uVar3;
}
}
}
else {
if ((ulong)*(byte *)((long)plVar7 + 0x1a) == 1) {
uVar3 = (uint)(byte)*puVar6;
}
else {
uVar3 = (uint)*puVar6;
}
puVar6 = (ushort *)((long)puVar6 + (ulong)*(byte *)((long)plVar7 + 0x1a));
if (uVar3 < uVar2) {
uVar5 = uVar3;
}
}
if ((bVar1 < 0x12) && ((0x28002U >> (bVar1 & 0x1f) & 1) != 0)) {
(**(code **)(*(long *)(*plVar7 + 0xc0) + 0x50))(*plVar7,puVar6,uVar5,&local_38,&local_48);
}
else {
my_hash_sort_bin(0,puVar6,uVar5,&local_38,&local_48);
}
uVar8 = uVar8 + (int)local_38;
plVar4 = *(long **)(param_1 + 0x10);
}
else {
uVar8 = (uVar8 << 8 | uVar8 >> 0x18) + 0x1ff;
}
plVar7 = plVar7 + 4;
} while (plVar7 < plVar4);
}
return uVar8;
}
| |
39,521 | inline_mysql_file_delete | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_delete(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *name, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_DELETE, name, &locker);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_delete(name, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_delete(name, flags);
return result;
} | O0 | c | inline_mysql_file_delete:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq 0x24ff24(%rip), %rax # 0x2c1018
movq (%rax), %rax
movq 0x148(%rax), %rax
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x80(%rbp), %rdi
movl $0xe, %edx
leaq -0x38(%rbp), %r8
callq *%rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%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 0x71188
leaq 0x24fed9(%rip), %rax # 0x2c1018
movq (%rax), %rax
movq 0x220(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xf10b0
movl %eax, -0x2c(%rbp)
leaq 0x24feab(%rip), %rax # 0x2c1018
movq (%rax), %rax
movq 0x228(%rax), %rax
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq *%rax
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7119e
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xf10b0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| inline_mysql_file_delete:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+148h]
mov esi, [rbp+var_8]
mov rcx, [rbp+var_20]
lea rdi, [rbp+var_80]
mov edx, 0Eh
lea r8, [rbp+var_38]
call rax
mov [rbp+var_38], rax
cmp [rbp+var_38], 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_71188
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+220h]
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
call my_delete
mov [rbp+var_2C], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+228h]
mov rdi, [rbp+var_38]
mov esi, [rbp+var_2C]
call rax
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
jmp short loc_7119E
loc_71188:
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
call my_delete
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
loc_7119E:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
| long long inline_mysql_file_delete(unsigned int a1, long long a2, unsigned int a3, long long a4, long long a5)
{
_BYTE v6[72]; // [rsp+0h] [rbp-80h] BYREF
long long v7; // [rsp+48h] [rbp-38h] BYREF
unsigned int v8; // [rsp+54h] [rbp-2Ch]
long long v9; // [rsp+58h] [rbp-28h]
long long v10; // [rsp+60h] [rbp-20h]
unsigned int v11; // [rsp+6Ch] [rbp-14h]
long long v12; // [rsp+70h] [rbp-10h]
unsigned int v13; // [rsp+78h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a5;
v7 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(v6, a1, 14LL, a4, &v7);
if ( v7 )
{
((void ( *)(long long, long long, _QWORD))PSI_server[68])(v7, v12, v11);
v8 = my_delete(v10, v9);
((void ( *)(long long, _QWORD))PSI_server[69])(v7, v8);
}
else
{
return (unsigned int)my_delete(v10, v9);
}
return v8;
}
| inline_mysql_file_delete:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
LEA RAX,[0x3c1018]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV ESI,dword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x80]
MOV EDX,0xe
LEA R8,[RBP + -0x38]
CALL RAX
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],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 0x00171188
LEA RAX,[0x3c1018]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x220]
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001f10b0
MOV dword ptr [RBP + -0x2c],EAX
LEA RAX,[0x3c1018]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x228]
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x2c]
CALL RAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017119e
LAB_00171188:
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001f10b0
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
LAB_0017119e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_delete
(int4 param_1,int8 param_2,int4 param_3,int8 param_4,
int8 param_5)
{
int1 local_88 [72];
long local_40;
int4 local_34;
int8 local_30;
int8 local_28;
int4 local_1c;
int8 local_18;
int4 local_10;
int4 local_c;
local_30 = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_40 = (**(code **)(PSI_server + 0x148))(local_88,param_1,0xe,param_4,&local_40);
if (local_40 == 0) {
local_c = my_delete(local_28,local_30);
}
else {
(**(code **)(PSI_server + 0x220))(local_40,local_18,local_1c);
local_34 = my_delete(local_28,local_30);
(**(code **)(PSI_server + 0x228))(local_40,local_34);
local_c = local_34;
}
return local_c;
}
| |
39,522 | 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>>::operator->() const | llama.cpp/common/./json.hpp | pointer operator->() const
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
return &(m_it.object_iterator->second);
}
case value_t::array:
{
JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
return &*m_it.array_iterator;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
{
return m_object;
}
JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
}
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator->() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x867b3
movq %rdi, %r14
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0x86716
cmpl $0x1, %ecx
jne 0x86743
movq 0x8(%rax), %rcx
movq 0x8(%r14), %rax
cmpq 0x8(%rcx), %rax
je 0x867cf
addq $0x20, %rax
jmp 0x8674a
movq 0x8(%rax), %rcx
movq 0x10(%r14), %rax
cmpq 0x8(%rcx), %rax
jne 0x8674a
leaq 0xec6aa(%rip), %rdi # 0x172dd5
leaq 0xec6e0(%rip), %rdx # 0x172e12
leaq 0xeecc1(%rip), %rcx # 0x1753fa
movl $0x3397, %esi # imm = 0x3397
jmp 0x867e9
cmpq $0x0, 0x18(%r14)
jne 0x86755
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x25790
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xeecc5(%rip), %rsi # 0x175437
leaq 0xeecce(%rip), %rdx # 0x175447
leaq 0x8(%rsp), %rdi
callq 0x52736
movq (%r14), %rcx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xd6, %esi
callq 0x80a70
xorl %ebp, %ebp
leaq 0x1542a4(%rip), %rsi # 0x1daa48
leaq -0x2549(%rip), %rdx # 0x84262
movq %rbx, %rdi
callq 0x25c00
leaq 0xec61b(%rip), %rdi # 0x172dd5
leaq 0xec651(%rip), %rdx # 0x172e12
leaq 0xeebb5(%rip), %rcx # 0x17537d
movl $0x338b, %esi # imm = 0x338B
jmp 0x867e9
leaq 0xec5ff(%rip), %rdi # 0x172dd5
leaq 0xec635(%rip), %rdx # 0x172e12
leaq 0xeebd7(%rip), %rcx # 0x1753bb
movl $0x3391, %esi # imm = 0x3391
xorl %eax, %eax
callq 0x26090
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8680a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x251b0
testb %bpl, %bpl
jne 0x86814
jmp 0x8681c
movq %rax, %r14
movq %rbx, %rdi
callq 0x26150
movq %r14, %rdi
callq 0x25ca0
| _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEptEv:
push rbp; void *
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov rax, [rdi]
test rax, rax
jz loc_867B3
mov r14, rdi
movzx ecx, byte ptr [rax]
cmp ecx, 2
jz short loc_86716
cmp ecx, 1
jnz short loc_86743
mov rcx, [rax+8]
mov rax, [r14+8]
cmp rax, [rcx+8]
jz loc_867CF
add rax, 20h ; ' '
jmp short loc_8674A
loc_86716:
mov rcx, [rax+8]
mov rax, [r14+10h]
cmp rax, [rcx+8]
jnz short loc_8674A
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMItArrayIterat; "m_it.array_iterator != m_object->m_data"...
mov esi, 3397h
jmp loc_867E9
loc_86743:
cmp qword ptr [r14+18h], 0
jnz short loc_86755
loc_8674A:
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_86755:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aCannotGetValue; "cannot get value"
lea rdx, aCannotGetValue+10h; ""
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rcx, [r14]
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 0D6h; int
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_867B3:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 338Bh
jmp short loc_867E9
loc_867CF:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMItObjectItera; "m_it.object_iterator != m_object->m_dat"...
mov esi, 3391h
loc_867E9:
xor eax, eax
call _ggml_abort
mov r14, rax
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_8680A
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8680A:
test bpl, bpl
jnz short loc_86814
jmp short loc_8681C
mov r14, rax
loc_86814:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_8681C:
mov rdi, r14
call __Unwind_Resume
| unsigned __int8 * nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator->(
unsigned __int8 **a1)
{
void *v1; // rbx
char v2; // bp
void *v3; // r15
unsigned __int8 *result; // rax
int v5; // ecx
long long v6; // rcx
unsigned __int8 *v7; // rax
long long v8; // rcx
long long v9; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
long long v11; // r14
void *v12[2]; // [rsp+8h] [rbp-40h] BYREF
long long v13; // [rsp+18h] [rbp-30h] BYREF
result = *a1;
if ( !*a1 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/./json.hpp",
13195LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
goto LABEL_13;
}
v5 = *result;
if ( v5 == 2 )
{
v8 = *((_QWORD *)result + 1);
result = a1[2];
if ( result == *(unsigned __int8 **)(v8 + 8) )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/./json.hpp",
13207LL,
"GGML_ASSERT(%s) failed",
"m_it.array_iterator != m_object->m_data.m_value.array->end()");
goto LABEL_13;
}
}
else
{
if ( v5 == 1 )
{
v6 = *((_QWORD *)result + 1);
v7 = a1[1];
if ( v7 != *(unsigned __int8 **)(v6 + 8) )
return v7 + 32;
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/./json.hpp",
13201LL,
"GGML_ASSERT(%s) failed",
"m_it.object_iterator != m_object->m_data.m_value.object->end()");
LABEL_13:
v11 = v9;
if ( v12[0] != v3 )
operator delete(v12[0], v13 + 1);
if ( v2 )
__cxa_free_exception(v1);
_Unwind_Resume(v11);
}
if ( a1[3] )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v12[0] = &v13;
std::string::_M_construct<char const*>((long long)v12, "cannot get 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_(
exception,
214,
v12);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
}
return result;
}
| operator->:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001867b3
MOV R14,RDI
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x2
JZ 0x00186716
CMP ECX,0x1
JNZ 0x00186743
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
JZ 0x001867cf
ADD RAX,0x20
JMP 0x0018674a
LAB_00186716:
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R14 + 0x10]
CMP RAX,qword ptr [RCX + 0x8]
JNZ 0x0018674a
LEA RDI,[0x272dd5]
LEA RDX,[0x272e12]
LEA RCX,[0x2753fa]
MOV ESI,0x3397
JMP 0x001867e9
LAB_00186743:
CMP qword ptr [R14 + 0x18],0x0
JNZ 0x00186755
LAB_0018674a:
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00186755:
MOV EDI,0x20
CALL 0x00125790
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_0018676b:
LEA RSI,[0x275437]
LEA RDX,[0x275447]
LEA RDI,[RSP + 0x8]
CALL 0x00152736
MOV RCX,qword ptr [R14]
MOV BPL,0x1
LAB_00186789:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xd6
CALL 0x00180a70
XOR EBP,EBP
LEA RSI,[0x2daa48]
LEA RDX,[0x184262]
MOV RDI,RBX
CALL 0x00125c00
LAB_001867b3:
LEA RDI,[0x272dd5]
LEA RDX,[0x272e12]
LEA RCX,[0x27537d]
MOV ESI,0x338b
JMP 0x001867e9
LAB_001867cf:
LEA RDI,[0x272dd5]
LEA RDX,[0x272e12]
LEA RCX,[0x2753bb]
MOV ESI,0x3391
LAB_001867e9:
XOR EAX,EAX
CALL 0x00126090
|
/* 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> >::TEMPNAMEPLACEHOLDERVALUE() const */
char * __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator->(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
long *plVar1;
char *pcVar2;
int8 uVar3;
int1 *local_40 [2];
int1 local_30 [16];
pcVar2 = *(char **)this;
if (pcVar2 == (char *)0x0) {
pcVar2 = "m_object != nullptr";
uVar3 = 0x338b;
LAB_001867e9:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/./json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
if (*pcVar2 == '\x02') {
plVar1 = (long *)(pcVar2 + 8);
pcVar2 = *(char **)(this + 0x10);
if (pcVar2 == *(char **)(*plVar1 + 8)) {
pcVar2 = "m_it.array_iterator != m_object->m_data.m_value.array->end()";
uVar3 = 0x3397;
goto LAB_001867e9;
}
}
else if (*pcVar2 == '\x01') {
if (*(long *)(this + 8) == *(long *)(*(long *)(pcVar2 + 8) + 8)) {
pcVar2 = "m_it.object_iterator != m_object->m_data.m_value.object->end()";
uVar3 = 0x3391;
goto LAB_001867e9;
}
pcVar2 = (char *)(*(long *)(this + 8) + 0x20);
}
else if (*(long *)(this + 0x18) != 0) {
uVar3 = __cxa_allocate_exception(0x20);
local_40[0] = local_30;
/* try { // try from 0018676b to 00186782 has its CatchHandler @ 00186811 */
std::__cxx11::string::_M_construct<char_const*>(local_40,"cannot get value","");
/* try { // try from 00186789 to 001867b2 has its CatchHandler @ 001867f0 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0xd6,local_40,*(int8 *)this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&invalid_iterator::typeinfo,exception::~exception);
}
return pcVar2;
}
| |
39,523 | my_hash_sort_bin | eloqsql/strings/ctype-bin.c | void my_hash_sort_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,ulong *nr1, ulong *nr2)
{
const uchar *end = key + len;
ulong tmp1= *nr1;
ulong tmp2= *nr2;
for (; key < end ; key++)
{
MY_HASH_ADD(tmp1, tmp2, (uint) *key);
}
*nr1= tmp1;
*nr2= tmp2;
} | O3 | c | my_hash_sort_bin:
movq (%rcx), %rax
movq (%r8), %rdi
testq %rdx, %rdx
jle 0x4229f
pushq %rbp
movq %rsp, %rbp
addq %rsi, %rdx
movl %eax, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rax, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rax
addq $0x3, %rdi
incq %rsi
cmpq %rdx, %rsi
jb 0x42273
popq %rbp
movq %rax, (%rcx)
movq %rdi, (%r8)
retq
| my_hash_sort_bin:
mov rax, [rcx]
mov rdi, [r8]
test rdx, rdx
jle short loc_4229F
push rbp
mov rbp, rsp
add rdx, rsi
loc_42273:
mov r9d, eax
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rax
shl r9, 8
add r9, r10
xor rax, r9
add rdi, 3
inc rsi
cmp rsi, rdx
jb short loc_42273
pop rbp
loc_4229F:
mov [rcx], rax
mov [r8], rdi
retn
| long long my_hash_sort_bin(long long a1, unsigned __int8 *a2, long long a3, long long *a4, long long *a5)
{
long long result; // rax
long long v6; // rdi
unsigned __int8 *v7; // rdx
result = *a4;
v6 = *a5;
if ( a3 > 0 )
{
v7 = &a2[a3];
do
{
result ^= (v6 + (result & 0x3F)) * *a2 + (result << 8);
v6 += 3LL;
++a2;
}
while ( a2 < v7 );
}
*a4 = result;
*a5 = v6;
return result;
}
| my_hash_sort_bin:
MOV RAX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
TEST RDX,RDX
JLE 0x0014229f
PUSH RBP
MOV RBP,RSP
ADD RDX,RSI
LAB_00142273:
MOV R9D,EAX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RAX
SHL R9,0x8
ADD R9,R10
XOR RAX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RDX
JC 0x00142273
POP RBP
LAB_0014229f:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],RDI
RET
|
void my_hash_sort_bin(int8 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)*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;
}
| |
39,524 | to_printable_8bit | eloqsql/strings/ctype.c | static uint to_printable_8bit(uchar *dst, my_wc_t wc, uint bs)
{
/*
This function is used only in context of error messages for now.
All non-BMP characters are currently replaced to question marks
when a message is put into diagnostics area.
*/
DBUG_ASSERT(wc < 0x10000);
*dst++= (char) bs;
*dst++= _dig_vec_upper[(wc >> 12) & 0x0F];
*dst++= _dig_vec_upper[(wc >> 8) & 0x0F];
*dst++= _dig_vec_upper[(wc >> 4) & 0x0F];
*dst++= _dig_vec_upper[wc & 0x0F];
return MY_CS_PRINTABLE_CHAR_LENGTH;
} | O0 | c | to_printable_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
jmp 0xec481
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
shrq $0xc, %rcx
andq $0xf, %rcx
leaq 0x152076(%rip), %rax # 0x23e520
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
shrq $0x8, %rcx
andq $0xf, %rcx
leaq 0x15204f(%rip), %rax # 0x23e520
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
shrq $0x4, %rcx
andq $0xf, %rcx
leaq 0x152028(%rip), %rax # 0x23e520
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
andq $0xf, %rcx
leaq 0x152005(%rip), %rax # 0x23e520
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl $0x5, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| to_printable_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
jmp short $+2
loc_EC481:
mov eax, [rbp+var_14]
mov cl, al
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov rcx, [rbp+var_10]
shr rcx, 0Ch
and rcx, 0Fh
lea rax, _dig_vec_upper; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
mov cl, [rax+rcx]
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov rcx, [rbp+var_10]
shr rcx, 8
and rcx, 0Fh
lea rax, _dig_vec_upper; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
mov cl, [rax+rcx]
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov rcx, [rbp+var_10]
shr rcx, 4
and rcx, 0Fh
lea rax, _dig_vec_upper; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
mov cl, [rax+rcx]
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov rcx, [rbp+var_10]
and rcx, 0Fh
lea rax, _dig_vec_upper; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
mov cl, [rax+rcx]
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov eax, 5
pop rbp
retn
| long long to_printable_8bit(_BYTE *a1, unsigned long long a2, char a3)
{
*a1 = a3;
a1[1] = dig_vec_upper[(unsigned __int16)a2 >> 12];
a1[2] = dig_vec_upper[(a2 >> 8) & 0xF];
a1[3] = dig_vec_upper[(unsigned __int8)a2 >> 4];
a1[4] = dig_vec_upper[a2 & 0xF];
return 5LL;
}
| to_printable_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
JMP 0x001ec481
LAB_001ec481:
MOV EAX,dword ptr [RBP + -0x14]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x10]
SHR RCX,0xc
AND RCX,0xf
LEA RAX,[0x33e520]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x10]
SHR RCX,0x8
AND RCX,0xf
LEA RAX,[0x33e520]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x10]
SHR RCX,0x4
AND RCX,0xf
LEA RAX,[0x33e520]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x10]
AND RCX,0xf
LEA RAX,[0x33e520]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV EAX,0x5
POP RBP
RET
|
int8 to_printable_8bit(int1 *param_1,ulong param_2,int1 param_3)
{
*param_1 = param_3;
param_1[1] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[param_2 >> 0xc & 0xf];
param_1[2] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[param_2 >> 8 & 0xf];
param_1[3] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[param_2 >> 4 & 0xf];
param_1[4] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[param_2 & 0xf];
return 5;
}
| |
39,525 | ma_remove_not_visible_states_with_lock | eloqsql/storage/maria/ma_state.c | void _ma_remove_not_visible_states_with_lock(MARIA_SHARE *share,
my_bool all)
{
my_bool is_lock_trman;
if ((is_lock_trman= trman_is_inited()))
trnman_lock();
mysql_mutex_lock(&share->intern_lock);
share->state_history= _ma_remove_not_visible_states(share->state_history,
all, 1);
mysql_mutex_unlock(&share->intern_lock);
if (is_lock_trman)
trnman_unlock();
} | O3 | c | ma_remove_not_visible_states_with_lock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
xorl %eax, %eax
callq 0x615eb
testb %al, %al
je 0x41343
xorl %eax, %eax
callq 0x6159b
leaq 0x8f0(%rbx), %r15
cmpq $0x0, 0x930(%rbx)
jne 0x41396
movq %r15, %rdi
callq 0x291d0
movq 0x450(%rbx), %rdi
movsbl %r14b, %esi
movl $0x1, %edx
callq 0x4120e
movq %rax, 0x450(%rbx)
movq 0x930(%rbx), %rdi
testq %rdi, %rdi
jne 0x413af
movq %r15, %rdi
callq 0x291a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x615bc
leaq 0x8f0(%rbx), %r15
cmpq $0x0, 0x930(%rbx)
jne 0x413c4
movq %r15, %rdi
callq 0x291d0
movq 0x450(%rbx), %rdi
movsbl %r14b, %esi
movl $0x1, %edx
callq 0x4120e
movq %rax, 0x450(%rbx)
movq 0x930(%rbx), %rdi
testq %rdi, %rdi
jne 0x413da
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x291a0
leaq 0x9e0e2(%rip), %rsi # 0xdf47f
movq %r15, %rdi
movl $0xe1, %edx
callq 0x2eee9
jmp 0x412fe
leaq 0x34bcba(%rip), %rax # 0x38d070
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4132a
leaq 0x9e0b4(%rip), %rsi # 0xdf47f
movq %r15, %rdi
movl $0xe1, %edx
callq 0x2eee9
jmp 0x4135c
leaq 0x34bc8f(%rip), %rax # 0x38d070
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x41384
| _ma_remove_not_visible_states_with_lock:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14d, esi
mov rbx, rdi
xor eax, eax
call trman_is_inited
test al, al
jz short loc_41343
xor eax, eax
call trnman_lock
lea r15, [rbx+8F0h]
cmp qword ptr [rbx+930h], 0
jnz loc_41396
mov rdi, r15
call _pthread_mutex_lock
loc_412FE:
mov rdi, [rbx+450h]
movsx esi, r14b
mov edx, 1
call _ma_remove_not_visible_states
mov [rbx+450h], rax
mov rdi, [rbx+930h]
test rdi, rdi
jnz loc_413AF
loc_4132A:
mov rdi, r15
call _pthread_mutex_unlock
xor eax, eax
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp trnman_unlock
loc_41343:
lea r15, [rbx+8F0h]
cmp qword ptr [rbx+930h], 0
jnz short loc_413C4
mov rdi, r15
call _pthread_mutex_lock
loc_4135C:
mov rdi, [rbx+450h]
movsx esi, r14b
mov edx, 1
call _ma_remove_not_visible_states
mov [rbx+450h], rax
mov rdi, [rbx+930h]
test rdi, rdi
jnz short loc_413DA
loc_41384:
mov rdi, r15
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_41396:
lea rsi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov edx, 0E1h
call psi_mutex_lock
jmp loc_412FE
loc_413AF:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_4132A
loc_413C4:
lea rsi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov edx, 0E1h
call psi_mutex_lock
jmp short loc_4135C
loc_413DA:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_41384
| long long ma_remove_not_visible_states_with_lock(long long a1, char a2)
{
if ( (unsigned __int8)trman_is_inited(a1) )
{
trnman_lock();
if ( *(_QWORD *)(a1 + 2352) )
psi_mutex_lock(a1 + 2288, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c", 0xE1u);
else
pthread_mutex_lock(a1 + 2288);
*(_QWORD *)(a1 + 1104) = ma_remove_not_visible_states(*(_QWORD **)(a1 + 1104), a2, 1);
if ( *(_QWORD *)(a1 + 2352) )
PSI_server[44]();
pthread_mutex_unlock(a1 + 2288);
return trnman_unlock();
}
else
{
if ( *(_QWORD *)(a1 + 2352) )
psi_mutex_lock(a1 + 2288, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c", 0xE1u);
else
pthread_mutex_lock(a1 + 2288);
*(_QWORD *)(a1 + 1104) = ma_remove_not_visible_states(*(_QWORD **)(a1 + 1104), a2, 1);
if ( *(_QWORD *)(a1 + 2352) )
PSI_server[44]();
return pthread_mutex_unlock(a1 + 2288);
}
}
| _ma_remove_not_visible_states_with_lock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14D,ESI
MOV RBX,RDI
XOR EAX,EAX
CALL 0x001615eb
TEST AL,AL
JZ 0x00141343
XOR EAX,EAX
CALL 0x0016159b
LEA R15,[RBX + 0x8f0]
CMP qword ptr [RBX + 0x930],0x0
JNZ 0x00141396
MOV RDI,R15
CALL 0x001291d0
LAB_001412fe:
MOV RDI,qword ptr [RBX + 0x450]
MOVSX ESI,R14B
MOV EDX,0x1
CALL 0x0014120e
MOV qword ptr [RBX + 0x450],RAX
MOV RDI,qword ptr [RBX + 0x930]
TEST RDI,RDI
JNZ 0x001413af
LAB_0014132a:
MOV RDI,R15
CALL 0x001291a0
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001615bc
LAB_00141343:
LEA R15,[RBX + 0x8f0]
CMP qword ptr [RBX + 0x930],0x0
JNZ 0x001413c4
MOV RDI,R15
CALL 0x001291d0
LAB_0014135c:
MOV RDI,qword ptr [RBX + 0x450]
MOVSX ESI,R14B
MOV EDX,0x1
CALL 0x0014120e
MOV qword ptr [RBX + 0x450],RAX
MOV RDI,qword ptr [RBX + 0x930]
TEST RDI,RDI
JNZ 0x001413da
LAB_00141384:
MOV RDI,R15
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001291a0
LAB_00141396:
LEA RSI,[0x1df47f]
MOV RDI,R15
MOV EDX,0xe1
CALL 0x0012eee9
JMP 0x001412fe
LAB_001413af:
LEA RAX,[0x48d070]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014132a
LAB_001413c4:
LEA RSI,[0x1df47f]
MOV RDI,R15
MOV EDX,0xe1
CALL 0x0012eee9
JMP 0x0014135c
LAB_001413da:
LEA RAX,[0x48d070]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00141384
|
void _ma_remove_not_visible_states_with_lock(long param_1,char param_2)
{
pthread_mutex_t *ppVar1;
char cVar2;
int8 uVar3;
cVar2 = trman_is_inited();
if (cVar2 != '\0') {
trnman_lock();
ppVar1 = (pthread_mutex_t *)(param_1 + 0x8f0);
if (*(long *)(param_1 + 0x930) == 0) {
pthread_mutex_lock(ppVar1);
}
else {
psi_mutex_lock(ppVar1,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c",0xe1
);
}
uVar3 = _ma_remove_not_visible_states(*(int8 *)(param_1 + 0x450),(int)param_2,1);
*(int8 *)(param_1 + 0x450) = uVar3;
if (*(long *)(param_1 + 0x930) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(ppVar1);
trnman_unlock();
return;
}
ppVar1 = (pthread_mutex_t *)(param_1 + 0x8f0);
if (*(long *)(param_1 + 0x930) == 0) {
pthread_mutex_lock(ppVar1);
}
else {
psi_mutex_lock(ppVar1,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c",0xe1);
}
uVar3 = _ma_remove_not_visible_states(*(int8 *)(param_1 + 0x450),(int)param_2,1);
*(int8 *)(param_1 + 0x450) = uVar3;
if (*(long *)(param_1 + 0x930) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(ppVar1);
return;
}
| |
39,526 | JS_GetFunctionBytecode | bluesky950520[P]quickjs/quickjs.c | static JSFunctionBytecode *JS_GetFunctionBytecode(JSValue val)
{
JSObject *p;
if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
return NULL;
p = JS_VALUE_GET_OBJ(val);
if (!js_class_has_bytecode(p->class_id))
return NULL;
return p->u.func.function_bytecode;
} | O0 | c | JS_GetFunctionBytecode:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $-0x1, %eax
je 0x65fd3
movq $0x0, 0x20(%rsp)
jmp 0x66009
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %edi
callq 0x50530
cmpl $0x0, %eax
jne 0x65ffb
movq $0x0, 0x20(%rsp)
jmp 0x66009
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_GetFunctionBytecode:
sub rsp, 28h
mov [rsp+28h+var_18], rdi
mov [rsp+28h+var_10], rsi
mov rax, [rsp+28h+var_10]
cmp eax, 0FFFFFFFFh
jz short loc_65FD3
mov [rsp+28h+var_8], 0
jmp short loc_66009
loc_65FD3:
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_20], rax
mov rax, [rsp+28h+var_20]
movzx edi, word ptr [rax+6]
call js_class_has_bytecode
cmp eax, 0
jnz short loc_65FFB
mov [rsp+28h+var_8], 0
jmp short loc_66009
loc_65FFB:
mov rax, [rsp+28h+var_20]
mov rax, [rax+30h]
mov [rsp+28h+var_8], rax
loc_66009:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
| long long JS_GetFunctionBytecode(long long a1, int a2)
{
if ( a2 != -1 )
return 0LL;
if ( js_class_has_bytecode(*(unsigned __int16 *)(a1 + 6)) )
return *(_QWORD *)(a1 + 48);
return 0LL;
}
| JS_GetFunctionBytecode:
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr [RSP + 0x18]
CMP EAX,-0x1
JZ 0x00165fd3
MOV qword ptr [RSP + 0x20],0x0
JMP 0x00166009
LAB_00165fd3:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOVZX EDI,word ptr [RAX + 0x6]
CALL 0x00150530
CMP EAX,0x0
JNZ 0x00165ffb
MOV qword ptr [RSP + 0x20],0x0
JMP 0x00166009
LAB_00165ffb:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LAB_00166009:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
int8 JS_GetFunctionBytecode(long param_1,int param_2)
{
int iVar1;
int8 local_8;
if (param_2 == -1) {
iVar1 = js_class_has_bytecode(*(int2 *)(param_1 + 6));
if (iVar1 == 0) {
local_8 = 0;
}
else {
local_8 = *(int8 *)(param_1 + 0x30);
}
}
else {
local_8 = 0;
}
return local_8;
}
| |
39,527 | JS_GetFunctionBytecode | bluesky950520[P]quickjs/quickjs.c | static JSFunctionBytecode *JS_GetFunctionBytecode(JSValue val)
{
JSObject *p;
if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
return NULL;
p = JS_VALUE_GET_OBJ(val);
if (!js_class_has_bytecode(p->class_id))
return NULL;
return p->u.func.function_bytecode;
} | O2 | c | JS_GetFunctionBytecode:
cmpl $-0x1, %edx
jne 0x34ed0
movzwl 0x6(%rsi), %eax
cmpq $0x38, %rax
ja 0x34ed0
movabsq $0x110000000012000, %rcx # imm = 0x110000000012000
btq %rax, %rcx
jae 0x34ed0
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x34ed0
movzwl 0x18(%rax), %eax
andl $0x3, %eax
cmpw $0x2, %ax
jne 0x34ed0
pushq $0x3
popq %rdx
jmp 0x34ee6
pushq %rax
leaq 0x56b69(%rip), %rsi # 0x8ba41
xorl %eax, %eax
callq 0x201fd
pushq $0x6
popq %rdx
addq $0x8, %rsp
xorl %eax, %eax
retq
| js_function_proto_caller:
cmp edx, 0FFFFFFFFh
jnz short loc_34ED0
movzx eax, word ptr [rsi+6]
cmp rax, 38h ; '8'
ja short loc_34ED0
mov rcx, 110000000012000h
bt rcx, rax
jnb short loc_34ED0
mov rax, [rsi+30h]
test rax, rax
jz short loc_34ED0
movzx eax, word ptr [rax+18h]
and eax, 3
cmp ax, 2
jnz short loc_34ED0
push 3
pop rdx
jmp short loc_34EE6
loc_34ED0:
push rax
lea rsi, aInvalidPropert; "invalid property access"
xor eax, eax
call JS_ThrowTypeError
push 6
pop rdx
add rsp, 8
loc_34EE6:
xor eax, eax
retn
| long long js_function_proto_caller(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
unsigned long long v14; // rax
if ( (_DWORD)a3 != -1
|| (v14 = *(unsigned __int16 *)(a2 + 6), v14 > 0x38)
|| (a4 = 0x110000000012000LL, !_bittest64(&a4, v14))
|| (v14 = *(_QWORD *)(a2 + 48)) == 0
|| (LOWORD(v14) = *(_WORD *)(v14 + 24) & 3, (_WORD)v14 != 2) )
{
JS_ThrowTypeError(a1, (long long)"invalid property access", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v14);
}
return 0LL;
}
| js_function_proto_caller:
CMP EDX,-0x1
JNZ 0x00134ed0
MOVZX EAX,word ptr [RSI + 0x6]
CMP RAX,0x38
JA 0x00134ed0
MOV RCX,0x110000000012000
BT RCX,RAX
JNC 0x00134ed0
MOV RAX,qword ptr [RSI + 0x30]
TEST RAX,RAX
JZ 0x00134ed0
MOVZX EAX,word ptr [RAX + 0x18]
AND EAX,0x3
CMP AX,0x2
JNZ 0x00134ed0
PUSH 0x3
POP RDX
JMP 0x00134ee6
LAB_00134ed0:
PUSH RAX
LEA RSI,[0x18ba41]
XOR EAX,EAX
CALL 0x001201fd
PUSH 0x6
POP RDX
ADD RSP,0x8
LAB_00134ee6:
XOR EAX,EAX
RET
|
int1 [16] js_function_proto_caller(int8 param_1,long param_2,int param_3)
{
int1 auVar1 [16];
ulong uVar2;
if ((((param_3 == -1) && ((ulong)*(ushort *)(param_2 + 6) < 0x39)) &&
((0x110000000012000U >> ((ulong)*(ushort *)(param_2 + 6) & 0x3f) & 1) != 0)) &&
((*(long *)(param_2 + 0x30) != 0 && ((*(ushort *)(*(long *)(param_2 + 0x30) + 0x18) & 3) == 2))
)) {
uVar2 = 3;
}
else {
JS_ThrowTypeError(param_1,"invalid property access");
uVar2 = 6;
}
auVar1._8_8_ = 0;
auVar1._0_8_ = uVar2;
return auVar1 << 0x40;
}
| |
39,528 | ma_net_init | eloqsql/libmariadb/libmariadb/ma_net.c | int ma_net_init(NET *net, MARIADB_PVIO* pvio)
{
if (!(net->buff=(uchar*) malloc(net_buffer_length)))
return 1;
if (!net->extension)
return 1;
memset(net->buff, 0, net_buffer_length);
net->max_packet_size= MAX(net_buffer_length, max_allowed_packet);
net->buff_end=net->buff+(net->max_packet=net_buffer_length);
net->pvio = pvio;
net->error=0; net->return_status=0;
net->read_timeout=(uint) net_read_timeout; /* Timeout for read */
net->compress_pkt_nr= net->pkt_nr= 0;
net->write_pos=net->read_pos = net->buff;
net->last_error[0]= net->sqlstate[0] =0;
net->compress=0; net->reading_or_writing=0;
net->where_b = net->remain_in_buf=0;
net->last_errno=0;
if (pvio != 0) /* If real connection */
{
ma_pvio_get_handle(pvio, &net->fd);
ma_pvio_blocking(pvio, 1, 0);
ma_pvio_fast_send(pvio);
}
return 0;
} | O3 | c | ma_net_init:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x179bd(%rip), %rax # 0x48a30
movq (%rax), %r13
movq %r13, %rdi
callq 0x13600
movq %rax, 0x8(%r14)
movl $0x1, %r15d
testq %rax, %rax
je 0x31159
cmpq $0x0, 0x2a0(%r14)
je 0x31159
movq %rax, %r12
xorl %r15d, %r15d
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x13260
leaq 0x1795f(%rip), %rax # 0x48a18
movq (%rax), %rax
cmpq %rax, %r13
cmovaq %r13, %rax
movq %rax, 0x58(%r14)
movq %r13, 0x50(%r14)
movq %r12, %rax
addq %r13, %rax
movq %rax, 0x10(%r14)
movq %rbx, (%r14)
movb %r15b, 0x94(%r14)
movq %r15, 0x78(%r14)
leaq 0x17936(%rip), %rax # 0x48a20
movl (%rax), %eax
movl %eax, 0x6c(%r14)
movq %r15, 0x60(%r14)
movq %r12, 0x20(%r14)
movq %r12, 0x18(%r14)
movb %r15b, 0x297(%r14)
movb %r15b, 0x97(%r14)
movb %r15b, 0x84(%r14)
movb %r15b, 0x80(%r14)
movq %r15, 0x30(%r14)
movq %r15, 0x48(%r14)
movl $0x0, 0x90(%r14)
testq %rbx, %rbx
je 0x31159
addq $0x28, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d697
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x1d3c4
movq %rbx, %rdi
callq 0x1d170
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_net_init:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
lea rax, net_buffer_length
mov r13, [rax]
mov rdi, r13
call _malloc
mov [r14+8], rax
mov r15d, 1
test rax, rax
jz loc_31159
cmp qword ptr [r14+2A0h], 0
jz loc_31159
mov r12, rax
xor r15d, r15d
mov rdi, rax
xor esi, esi
mov rdx, r13
call _memset
lea rax, max_allowed_packet
mov rax, [rax]
cmp r13, rax
cmova rax, r13
mov [r14+58h], rax
mov [r14+50h], r13
mov rax, r12
add rax, r13
mov [r14+10h], rax
mov [r14], rbx
mov [r14+94h], r15b
mov [r14+78h], r15
lea rax, net_read_timeout
mov eax, [rax]
mov [r14+6Ch], eax
mov [r14+60h], r15
mov [r14+20h], r12
mov [r14+18h], r12
mov [r14+297h], r15b
mov [r14+97h], r15b
mov [r14+84h], r15b
mov [r14+80h], r15b
mov [r14+30h], r15
mov [r14+48h], r15
mov dword ptr [r14+90h], 0
test rbx, rbx
jz short loc_31159
add r14, 28h ; '('
mov rdi, rbx
mov rsi, r14
call ma_pvio_get_handle
xor r15d, r15d
mov rdi, rbx
mov esi, 1
xor edx, edx
call ma_pvio_blocking
mov rdi, rbx
call ma_pvio_fast_send
loc_31159:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_net_init(long long a1, long long a2)
{
unsigned long long v2; // r13
long long v3; // rax
unsigned int v4; // r15d
long long v5; // r12
unsigned long long v6; // rax
v2 = net_buffer_length;
v3 = malloc(net_buffer_length);
*(_QWORD *)(a1 + 8) = v3;
v4 = 1;
if ( v3 && *(_QWORD *)(a1 + 672) )
{
v5 = v3;
v4 = 0;
memset(v3, 0LL, v2);
v6 = max_allowed_packet;
if ( v2 > max_allowed_packet )
v6 = v2;
*(_QWORD *)(a1 + 88) = v6;
*(_QWORD *)(a1 + 80) = v2;
*(_QWORD *)(a1 + 16) = v2 + v5;
*(_QWORD *)a1 = a2;
*(_BYTE *)(a1 + 148) = 0;
*(_QWORD *)(a1 + 120) = 0LL;
*(_DWORD *)(a1 + 108) = net_read_timeout;
*(_QWORD *)(a1 + 96) = 0LL;
*(_QWORD *)(a1 + 32) = v5;
*(_QWORD *)(a1 + 24) = v5;
*(_BYTE *)(a1 + 663) = 0;
*(_BYTE *)(a1 + 151) = 0;
*(_BYTE *)(a1 + 132) = 0;
*(_BYTE *)(a1 + 128) = 0;
*(_QWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 72) = 0LL;
*(_DWORD *)(a1 + 144) = 0;
if ( a2 )
{
ma_pvio_get_handle(a2);
v4 = 0;
ma_pvio_blocking(a2, 1);
ma_pvio_fast_send(a2);
}
}
return v4;
}
| ma_net_init:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
LEA RAX,[0x148a30]
MOV R13,qword ptr [RAX]
MOV RDI,R13
CALL 0x00113600
MOV qword ptr [R14 + 0x8],RAX
MOV R15D,0x1
TEST RAX,RAX
JZ 0x00131159
CMP qword ptr [R14 + 0x2a0],0x0
JZ 0x00131159
MOV R12,RAX
XOR R15D,R15D
MOV RDI,RAX
XOR ESI,ESI
MOV RDX,R13
CALL 0x00113260
LEA RAX,[0x148a18]
MOV RAX,qword ptr [RAX]
CMP R13,RAX
CMOVA RAX,R13
MOV qword ptr [R14 + 0x58],RAX
MOV qword ptr [R14 + 0x50],R13
MOV RAX,R12
ADD RAX,R13
MOV qword ptr [R14 + 0x10],RAX
MOV qword ptr [R14],RBX
MOV byte ptr [R14 + 0x94],R15B
MOV qword ptr [R14 + 0x78],R15
LEA RAX,[0x148a20]
MOV EAX,dword ptr [RAX]
MOV dword ptr [R14 + 0x6c],EAX
MOV qword ptr [R14 + 0x60],R15
MOV qword ptr [R14 + 0x20],R12
MOV qword ptr [R14 + 0x18],R12
MOV byte ptr [R14 + 0x297],R15B
MOV byte ptr [R14 + 0x97],R15B
MOV byte ptr [R14 + 0x84],R15B
MOV byte ptr [R14 + 0x80],R15B
MOV qword ptr [R14 + 0x30],R15
MOV qword ptr [R14 + 0x48],R15
MOV dword ptr [R14 + 0x90],0x0
TEST RBX,RBX
JZ 0x00131159
ADD R14,0x28
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011d697
XOR R15D,R15D
MOV RDI,RBX
MOV ESI,0x1
XOR EDX,EDX
CALL 0x0011d3c4
MOV RDI,RBX
CALL 0x0011d170
LAB_00131159:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 ma_net_init(long *param_1,long param_2)
{
size_t __n;
void *__s;
ulong uVar1;
int8 uVar2;
__n = net_buffer_length;
__s = malloc(net_buffer_length);
param_1[1] = (long)__s;
uVar2 = 1;
if ((__s != (void *)0x0) && (param_1[0x54] != 0)) {
uVar2 = 0;
memset(__s,0,__n);
uVar1 = max_allowed_packet;
if (max_allowed_packet < __n) {
uVar1 = __n;
}
param_1[0xb] = uVar1;
param_1[10] = __n;
param_1[2] = (long)__s + __n;
*param_1 = param_2;
*(int1 *)((long)param_1 + 0x94) = 0;
param_1[0xf] = 0;
*(int4 *)((long)param_1 + 0x6c) = net_read_timeout;
param_1[0xc] = 0;
param_1[4] = (long)__s;
param_1[3] = (long)__s;
*(int1 *)((long)param_1 + 0x297) = 0;
*(int1 *)((long)param_1 + 0x97) = 0;
*(int1 *)((long)param_1 + 0x84) = 0;
*(int1 *)(param_1 + 0x10) = 0;
param_1[6] = 0;
param_1[9] = 0;
*(int4 *)(param_1 + 0x12) = 0;
if (param_2 != 0) {
ma_pvio_get_handle(param_2,param_1 + 5);
uVar2 = 0;
ma_pvio_blocking(param_2,1,0);
ma_pvio_fast_send(param_2);
}
}
return uVar2;
}
| |
39,529 | minja::Value& nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::operator[]<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/json.hpp | T & operator[](KeyType && key)
{
return emplace(std::forward<KeyType>(key), T{}).first->second;
} | O1 | cpp | minja::Value& nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::operator[]<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x40(%rsp), %r14
movq $0x0, 0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%r14)
movaps %xmm0, -0x30(%r14)
movaps %xmm0, -0x20(%r14)
movaps %xmm0, -0x10(%r14)
movb $0x0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x3f802
movq %r14, %rdi
movl $0x1, %esi
callq 0x3f802
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x507e6
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3f802
movq %r14, %rdi
callq 0x4c76e
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x4fe1d
callq 0x319fe
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4fe2c
callq 0x319fe
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4fe3b
callq 0x319fe
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4fe71
movq 0x9114c(%rip), %rax # 0xe0f98
cmpb $0x0, (%rax)
je 0x4fe5c
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x4fe66
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x4fe71
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3f776
movq %rbx, %rdi
callq 0x18bc0
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_:
push r15
push r14
push rbx
sub rsp, 50h
mov rbx, rsi
mov r15, rdi
lea r14, [rsp+68h+var_28]
mov qword ptr [r14+8], 0
xorps xmm0, xmm0
movaps xmmword ptr [r14-40h], xmm0
movaps xmmword ptr [r14-30h], xmm0
movaps xmmword ptr [r14-20h], xmm0
movaps xmmword ptr [r14-10h], xmm0
mov byte ptr [r14], 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)
mov rdx, rsp
mov rdi, r15
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_
mov rbx, rax
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+68h+var_30]
test rdi, rdi
jz short loc_4FE1D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4FE1D:
mov rdi, [rsp+68h+var_40]
test rdi, rdi
jz short loc_4FE2C
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4FE2C:
mov rdi, [rsp+68h+var_50]
test rdi, rdi
jz short loc_4FE3B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4FE3B:
mov rdi, [rsp+68h+var_60]
test rdi, rdi
jz short loc_4FE71
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_4FE5C
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_4FE66
loc_4FE5C:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_4FE66:
cmp eax, 1
jnz short loc_4FE71
mov rax, [rdi]
call qword ptr [rax+18h]
loc_4FE71:
add rbx, 10h
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_(
long long a1,
long long a2)
{
long long v2; // rbx
long long v3; // rdi
signed __int32 v4; // eax
__int128 v6; // [rsp+0h] [rbp-68h] BYREF
__int128 v7; // [rsp+10h] [rbp-58h]
__int128 v8; // [rsp+20h] [rbp-48h]
__int128 v9; // [rsp+30h] [rbp-38h]
void *v10[5]; // [rsp+40h] [rbp-28h] BYREF
v10[1] = 0LL;
v6 = 0LL;
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
LOBYTE(v10[0]) = 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 *)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 *)v10);
v2 = ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_(
a1,
a2,
&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>::assert_invariant((char *)v10);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v10);
if ( *((_QWORD *)&v9 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v9 + 1));
if ( *((_QWORD *)&v8 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v8 + 1));
if ( *((_QWORD *)&v7 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v7 + 1));
v3 = *((_QWORD *)&v6 + 1);
if ( *((_QWORD *)&v6 + 1) )
{
if ( _libc_single_threaded )
{
v4 = *(_DWORD *)(*((_QWORD *)&v6 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v6 + 1) + 12LL) = v4 - 1;
}
else
{
v4 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v6 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v4 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v3 + 24LL))(v3, 0LL);
}
return v2 + 16;
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RSI
MOV R15,RDI
LEA R14,[RSP + 0x40]
MOV qword ptr [R14 + 0x8],0x0
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R14 + -0x40],XMM0
MOVAPS xmmword ptr [R14 + -0x30],XMM0
MOVAPS xmmword ptr [R14 + -0x20],XMM0
MOVAPS xmmword ptr [R14 + -0x10],XMM0
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013f802
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013f802
LAB_0014fdeb:
MOV RDX,RSP
MOV RDI,R15
MOV RSI,RBX
CALL 0x001507e6
LAB_0014fdf9:
MOV RBX,RAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013f802
MOV RDI,R14
CALL 0x0014c76e
MOV RDI,qword ptr [RSP + 0x38]
TEST RDI,RDI
JZ 0x0014fe1d
CALL 0x001319fe
LAB_0014fe1d:
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x0014fe2c
CALL 0x001319fe
LAB_0014fe2c:
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x0014fe3b
CALL 0x001319fe
LAB_0014fe3b:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0014fe71
MOV RAX,qword ptr [0x001e0f98]
CMP byte ptr [RAX],0x0
JZ 0x0014fe5c
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0014fe66
LAB_0014fe5c:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0014fe66:
CMP EAX,0x1
JNZ 0x0014fe71
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0014fe71:
ADD RBX,0x10
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
long _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_
(int8 param_1,int8 param_2)
{
int *piVar1;
int iVar2;
long lVar3;
bool bVar4;
int8 local_68;
long *plStack_60;
int8 local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_50;
int8 local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_40;
int8 local_38;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_30;
data local_28 [8];
int8 local_20;
local_20 = 0;
local_68 = 0;
plStack_60 = (long *)0x0;
local_58 = 0;
p_Stack_50 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
local_48 = 0;
p_Stack_40 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
local_38 = 0;
p_Stack_30 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
local_28[0] = (data)0x0;
bVar4 = SUB81(local_28,0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar4);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar4);
/* try { // try from 0014fdeb to 0014fdf8 has its CatchHandler @ 0014fe82 */
lVar3 = _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_
(param_1,param_2,&local_68);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar4);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_28);
if (p_Stack_30 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_30);
}
if (p_Stack_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_40);
}
if (p_Stack_50 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_50);
}
if (plStack_60 != (long *)0x0) {
if (*PTR___libc_single_threaded_001e0f98 == '\0') {
LOCK();
piVar1 = (int *)((long)plStack_60 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)plStack_60 + 0xc);
*(int *)((long)plStack_60 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*plStack_60 + 0x18))();
}
}
return lVar3 + 0x10;
}
| |
39,530 | Uart::SetControl(unsigned short) | sp1187[P]veesem/src/core/spg200/uart.cc | void Uart::SetControl(word_t value) {
bool old_tx_enable = control_.tx_enable;
control_.raw = value;
if (!control_.rx_enable) {
rx_buf_ = 0;
}
bool rx_irq_active = control_.rx_irq_enable && status_.rx_ready;
bool tx_irq_active = control_.tx_irq_enable && status_.tx_ready;
irq_.SetUartIrq(rx_irq_active || tx_irq_active);
if (control_.tx_enable != old_tx_enable) {
status_.tx_ready = control_.tx_enable;
if (!control_.tx_enable) {
status_.tx_busy = false;
tx_counter_ = 0;
}
}
} | O3 | cpp | Uart::SetControl(unsigned short):
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0x10(%rdi), %eax
movw %si, 0x10(%rdi)
testb $0x40, %sil
jne 0xd250
movb $0x0, 0x18(%rbx)
testb %al, %al
sets %bpl
movzwl 0x12(%rbx), %eax
andl %esi, %eax
movzwl %ax, %esi
shrl %esi
movq (%rbx), %rdi
orl %eax, %esi
andl $0x1, %esi
callq 0xf120
movzwl 0x10(%rbx), %eax
andl $0x80, %eax
movl %eax, %ecx
shrl $0x7, %ecx
cmpb %cl, %bpl
je 0xd2ad
movzwl %ax, %ecx
movzwl 0x12(%rbx), %eax
movl %eax, %edx
andl $-0x3, %edx
movl %ecx, %esi
shrl $0x6, %esi
orl %edx, %esi
movw %si, 0x12(%rbx)
testw %cx, %cx
jne 0xd2ad
andl $0xffbd, %eax # imm = 0xFFBD
movw %ax, 0x12(%rbx)
movl $0x0, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| _ZN4Uart10SetControlEt:
push rbp
push rbx
push rax
mov rbx, rdi
movzx eax, word ptr [rdi+10h]
mov [rdi+10h], si
test sil, 40h
jnz short loc_D250
mov byte ptr [rbx+18h], 0
loc_D250:
test al, al
sets bpl
movzx eax, word ptr [rbx+12h]
and eax, esi
movzx esi, ax
shr esi, 1
mov rdi, [rbx]; this
or esi, eax
and esi, 1; bool
call _ZN3Irq10SetUartIrqEb; Irq::SetUartIrq(bool)
movzx eax, word ptr [rbx+10h]
and eax, 80h
mov ecx, eax
shr ecx, 7
cmp bpl, cl
jz short loc_D2AD
movzx ecx, ax
movzx eax, word ptr [rbx+12h]
mov edx, eax
and edx, 0FFFFFFFDh
mov esi, ecx
shr esi, 6
or esi, edx
mov [rbx+12h], si
test cx, cx
jnz short loc_D2AD
and eax, 0FFBDh
mov [rbx+12h], ax
mov dword ptr [rbx+1Ch], 0
loc_D2AD:
add rsp, 8
pop rbx
pop rbp
retn
| long long Uart::SetControl(Uart *this, unsigned __int16 a2)
{
__int16 v2; // ax
char v3; // bp
long long result; // rax
unsigned __int16 v5; // cx
v2 = *((_WORD *)this + 8);
*((_WORD *)this + 8) = a2;
if ( (a2 & 0x40) == 0 )
*((_BYTE *)this + 24) = 0;
v3 = (v2 & 0x80u) != 0;
Irq::SetUartIrq(*(Irq **)this, a2 & *((_WORD *)this + 9) & 1 | ((a2 & *((_WORD *)this + 9) & 2) != 0));
result = *((_WORD *)this + 8) & 0x80;
if ( v3 != (*((_WORD *)this + 8) & 0x80u) >> 7 )
{
v5 = *((_WORD *)this + 8) & 0x80;
result = *((unsigned __int16 *)this + 9);
*((_WORD *)this + 9) = *((_WORD *)this + 9) & 0xFFFD | (v5 >> 6);
if ( !v5 )
{
result = (unsigned __int16)result & 0xFFBD;
*((_WORD *)this + 9) = result;
*((_DWORD *)this + 7) = 0;
}
}
return result;
}
| SetControl:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOVZX EAX,word ptr [RDI + 0x10]
MOV word ptr [RDI + 0x10],SI
TEST SIL,0x40
JNZ 0x0010d250
MOV byte ptr [RBX + 0x18],0x0
LAB_0010d250:
TEST AL,AL
SETS BPL
MOVZX EAX,word ptr [RBX + 0x12]
AND EAX,ESI
MOVZX ESI,AX
SHR ESI,0x1
MOV RDI,qword ptr [RBX]
OR ESI,EAX
AND ESI,0x1
CALL 0x0010f120
MOVZX EAX,word ptr [RBX + 0x10]
AND EAX,0x80
MOV ECX,EAX
SHR ECX,0x7
CMP BPL,CL
JZ 0x0010d2ad
MOVZX ECX,AX
MOVZX EAX,word ptr [RBX + 0x12]
MOV EDX,EAX
AND EDX,0xfffffffd
MOV ESI,ECX
SHR ESI,0x6
OR ESI,EDX
MOV word ptr [RBX + 0x12],SI
TEST CX,CX
JNZ 0x0010d2ad
AND EAX,0xffbd
MOV word ptr [RBX + 0x12],AX
MOV dword ptr [RBX + 0x1c],0x0
LAB_0010d2ad:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* Uart::SetControl(unsigned short) */
void __thiscall Uart::SetControl(Uart *this,ushort param_1)
{
int2 uVar1;
ushort uVar2;
uint uVar3;
uVar1 = *(int2 *)(this + 0x10);
*(ushort *)(this + 0x10) = param_1;
if ((param_1 & 0x40) == 0) {
this[0x18] = (Uart)0x0;
}
Irq::SetUartIrq(*(Irq **)this,
(bool)(((byte)((*(ushort *)(this + 0x12) & param_1) >> 1) |
(byte)(*(ushort *)(this + 0x12) & param_1)) & 1));
uVar3 = *(ushort *)(this + 0x10) & 0x80;
if ((char)uVar1 < '\0' != SUB41(uVar3 >> 7,0)) {
uVar2 = *(ushort *)(this + 0x12);
*(ushort *)(this + 0x12) = (ushort)(uVar3 >> 6) | uVar2 & 0xfffd;
if ((short)uVar3 == 0) {
*(ushort *)(this + 0x12) = uVar2 & 0xffbd;
*(int4 *)(this + 0x1c) = 0;
}
}
return;
}
| |
39,531 | starter_stop | navaro[P]qoraal-tictactoe/build_O3/_deps/qoraal_engine-src/src/starter.c | int32_t
starter_stop (void)
{
int i ;
const STATEMACHINE_T* statemachine ;
STRINGTABLE_T* stringtable ;
engine_stop () ;
for (i=0; i < ENGINE_MAX_INSTANCES; i++) {
statemachine = engine_remove_statemachine (i) ;
if (statemachine) {
machine_destroy (statemachine) ;
}
}
stringtable = (STRINGTABLE_T*)engine_remove_stringtable () ;
if (stringtable) {
machine_stringtable_destroy (stringtable) ;
}
engine_log_mem_usage () ;
return ENGINE_OK ;
} | O3 | c | starter_stop:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0xf995
xorl %ebx, %ebx
movl %ebx, %edi
callq 0xe428
testq %rax, %rax
je 0x10bf3
movq %rax, %rdi
callq 0x9758
incl %ebx
cmpl $0x14, %ebx
jne 0x10bdf
callq 0xe4b9
testq %rax, %rax
je 0x10c0c
movq %rax, %rdi
callq 0x990f
callq 0xd9c2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| starter_stop:
push rbp
mov rbp, rsp
push rbx
push rax
call engine_stop
xor ebx, ebx
loc_10BDF:
mov edi, ebx
call engine_remove_statemachine
test rax, rax
jz short loc_10BF3
mov rdi, rax
call machine_destroy
loc_10BF3:
inc ebx
cmp ebx, 14h
jnz short loc_10BDF
call engine_remove_stringtable
test rax, rax
jz short loc_10C0C
mov rdi, rax
call machine_stringtable_destroy
loc_10C0C:
call engine_log_mem_usage
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
| long long starter_stop(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // rdx
long long v11; // rcx
long long v12; // r8
long long v13; // r9
__m128 v14; // xmm4
__m128 v15; // xmm5
unsigned int i; // ebx
long long v17; // rdi
long long v18; // rax
long long v19; // rax
long long v20; // rdx
long long v21; // rcx
long long v22; // r8
int v23; // r9d
engine_stop(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
for ( i = 0; i != 20; ++i )
{
v17 = i;
v18 = engine_remove_statemachine(i, a3, a4, a5, a6, v14, v15, a9, a10, a2, v10, v11, v12, v13);
if ( v18 )
{
v17 = v18;
machine_destroy(v18);
}
}
v19 = engine_remove_stringtable(v17);
if ( v19 )
{
v17 = v19;
machine_stringtable_destroy(v19);
}
engine_log_mem_usage(v17, a2, v20, v21, v22, v23);
return 0LL;
}
| starter_stop:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
CALL 0x0010f995
XOR EBX,EBX
LAB_00110bdf:
MOV EDI,EBX
CALL 0x0010e428
TEST RAX,RAX
JZ 0x00110bf3
MOV RDI,RAX
CALL 0x00109758
LAB_00110bf3:
INC EBX
CMP EBX,0x14
JNZ 0x00110bdf
CALL 0x0010e4b9
TEST RAX,RAX
JZ 0x00110c0c
MOV RDI,RAX
CALL 0x0010990f
LAB_00110c0c:
CALL 0x0010d9c2
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 starter_stop(void)
{
long lVar1;
int iVar2;
engine_stop();
iVar2 = 0;
do {
lVar1 = engine_remove_statemachine(iVar2);
if (lVar1 != 0) {
machine_destroy(lVar1);
}
iVar2 = iVar2 + 1;
} while (iVar2 != 0x14);
lVar1 = engine_remove_stringtable();
if (lVar1 != 0) {
machine_stringtable_destroy(lVar1);
}
engine_log_mem_usage();
return 0;
}
| |
39,532 | safe_hash_change | eloqsql/mysys/my_safehash.c | void safe_hash_change(SAFE_HASH *hash, uchar *old_data, uchar *new_data)
{
SAFE_HASH_ENTRY *entry, *next;
DBUG_ENTER("safe_hash_change");
mysql_rwlock_wrlock(&hash->mutex);
for (entry= hash->root ; entry ; entry= next)
{
next= entry->next;
if (entry->data == old_data)
{
if (new_data == hash->default_value)
{
if ((*entry->prev= entry->next))
entry->next->prev= entry->prev;
my_hash_delete(&hash->hash, (uchar*) entry);
}
else
entry->data= new_data;
}
}
mysql_rwlock_unlock(&hash->mutex);
DBUG_VOID_RETURN;
} | O3 | c | safe_hash_change:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x90(%rdi)
jne 0xa70d9
movq %rbx, %rdi
callq 0xa5321
movq 0x110(%rbx), %r13
testq %r13, %r13
je 0xa70b7
leaq 0x98(%rbx), %r12
movq %r13, %rsi
movq 0x18(%r13), %r13
cmpq %r15, 0x10(%rsi)
jne 0xa70b2
cmpq %r14, 0x108(%rbx)
je 0xa7092
movq %r14, 0x10(%rsi)
jmp 0xa70b2
movq 0x20(%rsi), %rax
movq %r13, (%rax)
testq %r13, %r13
je 0xa70aa
movq 0x18(%rsi), %rax
movq 0x20(%rsi), %rcx
movq %rcx, 0x20(%rax)
movq %r12, %rdi
callq 0x950ea
testq %r13, %r13
jne 0xa7076
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
jne 0xa70f2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa53c2
leaq 0x36b02(%rip), %rsi # 0xddbe2
movq %rbx, %rdi
movl $0x11b, %edx # imm = 0x11B
callq 0x2ed7b
jmp 0xa7063
leaq 0x2e0fc7(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x168(%rax)
jmp 0xa70c3
| safe_hash_change:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
cmp qword ptr [rdi+90h], 0
jnz short loc_A70D9
mov rdi, rbx
call my_rw_wrlock
loc_A7063:
mov r13, [rbx+110h]
test r13, r13
jz short loc_A70B7
lea r12, [rbx+98h]
loc_A7076:
mov rsi, r13
mov r13, [r13+18h]
cmp [rsi+10h], r15
jnz short loc_A70B2
cmp [rbx+108h], r14
jz short loc_A7092
mov [rsi+10h], r14
jmp short loc_A70B2
loc_A7092:
mov rax, [rsi+20h]
mov [rax], r13
test r13, r13
jz short loc_A70AA
mov rax, [rsi+18h]
mov rcx, [rsi+20h]
mov [rax+20h], rcx
loc_A70AA:
mov rdi, r12
call my_hash_delete
loc_A70B2:
test r13, r13
jnz short loc_A7076
loc_A70B7:
mov rdi, [rbx+90h]
test rdi, rdi
jnz short loc_A70F2
loc_A70C3:
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp my_rw_unlock
loc_A70D9:
lea rsi, aWorkspaceLlm4b_41; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 11Bh
call psi_rwlock_wrlock
jmp loc_A7063
loc_A70F2:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+168h]
jmp short loc_A70C3
| long long safe_hash_change(_QWORD *a1, long long a2, long long a3)
{
long long v6; // r13
long long v7; // rsi
long long v8; // rdi
if ( a1[18] )
psi_rwlock_wrlock((long long)a1, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/my_safehash.c", 0x11Bu);
else
my_rw_wrlock((long long)a1);
v6 = a1[34];
while ( v6 )
{
v7 = v6;
v6 = *(_QWORD *)(v6 + 24);
if ( *(_QWORD *)(v7 + 16) == a2 )
{
if ( a1[33] == a3 )
{
**(_QWORD **)(v7 + 32) = v6;
if ( v6 )
*(_QWORD *)(*(_QWORD *)(v7 + 24) + 32LL) = *(_QWORD *)(v7 + 32);
my_hash_delete((long long)(a1 + 19), v7);
}
else
{
*(_QWORD *)(v7 + 16) = a3;
}
}
}
v8 = a1[18];
if ( v8 )
((void ( *)(long long))PSI_server[45])(v8);
return my_rw_unlock((long long)a1);
}
| safe_hash_change:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
CMP qword ptr [RDI + 0x90],0x0
JNZ 0x001a70d9
MOV RDI,RBX
CALL 0x001a5321
LAB_001a7063:
MOV R13,qword ptr [RBX + 0x110]
TEST R13,R13
JZ 0x001a70b7
LEA R12,[RBX + 0x98]
LAB_001a7076:
MOV RSI,R13
MOV R13,qword ptr [R13 + 0x18]
CMP qword ptr [RSI + 0x10],R15
JNZ 0x001a70b2
CMP qword ptr [RBX + 0x108],R14
JZ 0x001a7092
MOV qword ptr [RSI + 0x10],R14
JMP 0x001a70b2
LAB_001a7092:
MOV RAX,qword ptr [RSI + 0x20]
MOV qword ptr [RAX],R13
TEST R13,R13
JZ 0x001a70aa
MOV RAX,qword ptr [RSI + 0x18]
MOV RCX,qword ptr [RSI + 0x20]
MOV qword ptr [RAX + 0x20],RCX
LAB_001a70aa:
MOV RDI,R12
CALL 0x001950ea
LAB_001a70b2:
TEST R13,R13
JNZ 0x001a7076
LAB_001a70b7:
MOV RDI,qword ptr [RBX + 0x90]
TEST RDI,RDI
JNZ 0x001a70f2
LAB_001a70c3:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001a53c2
LAB_001a70d9:
LEA RSI,[0x1ddbe2]
MOV RDI,RBX
MOV EDX,0x11b
CALL 0x0012ed7b
JMP 0x001a7063
LAB_001a70f2:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x001a70c3
|
void safe_hash_change(long param_1,long param_2,long param_3)
{
long lVar1;
long lVar2;
if (*(long *)(param_1 + 0x90) == 0) {
my_rw_wrlock(param_1);
}
else {
psi_rwlock_wrlock(param_1,"/workspace/llm4binary/github2025/eloqsql/mysys/my_safehash.c",0x11b);
}
if (*(long *)(param_1 + 0x110) != 0) {
lVar2 = *(long *)(param_1 + 0x110);
do {
lVar1 = *(long *)(lVar2 + 0x18);
if (*(long *)(lVar2 + 0x10) == param_2) {
if (*(long *)(param_1 + 0x108) == param_3) {
**(long **)(lVar2 + 0x20) = lVar1;
if (lVar1 != 0) {
*(int8 *)(*(long *)(lVar2 + 0x18) + 0x20) = *(int8 *)(lVar2 + 0x20);
}
my_hash_delete(param_1 + 0x98);
}
else {
*(long *)(lVar2 + 0x10) = param_3;
}
}
lVar2 = lVar1;
} while (lVar1 != 0);
}
if (*(long *)(param_1 + 0x90) != 0) {
(**(code **)(PSI_server + 0x168))();
}
my_rw_unlock(param_1);
return;
}
| |
39,533 | minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling) | llama.cpp/common/minja/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 "";
} | O3 | 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 0xdf678
movq 0x18(%r15), %rax
movq 0x20(%r15), %rsi
subq %rsi, %rax
movq 0x8(%r14), %rdx
cmpq %rdx, %rax
jl 0xdedda
addq %rsi, %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x723f6
movq 0x8(%r12), %rdx
cmpq 0x8(%r14), %rdx
jne 0xded90
movq 0x8(%rsp), %r12
testq %rdx, %rdx
je 0xded99
movq (%r14), %rsi
movq %r12, %rdi
callq 0x20bf0
testl %eax, %eax
sete %bpl
jmp 0xded9c
movq 0x8(%rsp), %r12
xorl %ebp, %ebp
jmp 0xded9c
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
cmpq %rax, %r12
je 0xdedb6
movq 0x18(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x20180
testb %bpl, %bpl
je 0xdedda
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 0x28562
jmp 0xdedf7
movq %r13, 0x20(%r15)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x40a45(%rip), %rdx # 0x11f831
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x28790
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 loc_DEDDA
add rdx, rsi
lea rax, [rsp+58h+var_40]
mov [rax-10h], rax
mov qword ptr [rax-8], 0
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_DED90
mov r12, [rsp+58h+var_50]
test rdx, rdx
jz short loc_DED99
mov rsi, [r14]
mov rdi, r12
call _bcmp
test eax, eax
setz bpl
jmp short loc_DED9C
loc_DED90:
mov r12, [rsp+58h+var_50]
xor ebp, ebp
jmp short loc_DED9C
loc_DED99:
mov bpl, 1
loc_DED9C:
lea rax, [rsp+58h+var_40]
cmp r12, rax
jz short loc_DEDB6
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_DEDB6:
test bpl, bpl
jz short loc_DEDDA
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_DEDF7
loc_DEDDA:
mov [r15+20h], r13
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aExampleToolCal+1Dh; ""
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_DEDF7:
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, _BYTE **a3, unsigned int a4)
{
long long v6; // r13
_BYTE *v7; // rsi
_BYTE *v8; // rdx
_QWORD *v9; // r12
bool v10; // bp
_BYTE *v11; // rdx
void *v13; // [rsp+8h] [rbp-50h] BYREF
_BYTE *v14; // [rsp+10h] [rbp-48h]
_QWORD v15[8]; // [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 < (long long)v8 )
goto LABEL_11;
v13 = v15;
v14 = 0LL;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(
(long long)&v13,
v7,
(long long)&v8[(_QWORD)v7]);
if ( v14 == a3[1] )
{
v9 = v13;
v10 = !v14 || (unsigned int)bcmp(v13, *a3) == 0;
}
else
{
v9 = v13;
v10 = 0;
}
if ( v9 != v15 )
operator delete(v9, v15[0] + 1LL);
if ( v10 )
{
v11 = a3[1];
*(_QWORD *)(a2 + 32) += v11;
*a1 = a1 + 2;
std::string::_M_construct<char *>((long long)a1, *a3, (long long)&v11[(_QWORD)*a3]);
}
else
{
LABEL_11:
*(_QWORD *)(a2 + 32) = v6;
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)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 0x001df678
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 0x001dedda
ADD RDX,RSI
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
MOV qword ptr [RAX + -0x8],0x0
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x001723f6
MOV RDX,qword ptr [R12 + 0x8]
CMP RDX,qword ptr [R14 + 0x8]
JNZ 0x001ded90
MOV R12,qword ptr [RSP + 0x8]
TEST RDX,RDX
JZ 0x001ded99
MOV RSI,qword ptr [R14]
MOV RDI,R12
CALL 0x00120bf0
TEST EAX,EAX
SETZ BPL
JMP 0x001ded9c
LAB_001ded90:
MOV R12,qword ptr [RSP + 0x8]
XOR EBP,EBP
JMP 0x001ded9c
LAB_001ded99:
MOV BPL,0x1
LAB_001ded9c:
LEA RAX,[RSP + 0x18]
CMP R12,RAX
JZ 0x001dedb6
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
MOV RDI,R12
CALL 0x00120180
LAB_001dedb6:
TEST BPL,BPL
JZ 0x001dedda
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 0x00128562
JMP 0x001dedf7
LAB_001dedda:
MOV qword ptr [R15 + 0x20],R13
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RDX,[0x21f831]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x00128790
LAB_001dedf7:
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) */
long * minja::Parser::consumeToken(long *param_1,Parser *param_2,long *param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
long *plVar3;
int iVar4;
bool bVar5;
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 + 0x20);
if (param_3[1] <= *(long *)(param_2 + 0x18) - lVar2) {
local_50 = local_40;
local_48 = 0;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(&local_50,lVar2,param_3[1] + lVar2);
plVar3 = local_50;
if (local_48 == param_3[1]) {
if (local_48 == 0) {
bVar5 = true;
}
else {
iVar4 = bcmp(local_50,(void *)*param_3,local_48);
bVar5 = iVar4 == 0;
}
}
else {
bVar5 = false;
}
if (plVar3 != local_40) {
operator_delete(plVar3,local_40[0] + 1);
}
if (bVar5) {
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);
return param_1;
}
}
*(int8 *)(param_2 + 0x20) = uVar1;
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char_const*>(param_1,"");
return param_1;
}
| |
39,534 | mj_applyFT | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_support.c | void mj_applyFT(const mjModel* m, mjData* d,
const mjtNum force[3], const mjtNum torque[3],
const mjtNum point[3], int body, mjtNum* qfrc_target) {
int nv = m->nv;
// allocate local variables
mj_markStack(d);
mjtNum* jacp = force ? mj_stackAllocNum(d, 3*nv) : NULL;
mjtNum* jacr = torque ? mj_stackAllocNum(d, 3*nv) : NULL;
mjtNum* qforce = mj_stackAllocNum(d, nv);
// make sure body is in range
if (body < 0 || body >= m->nbody) {
mjERROR("invalid body %d", body);
}
// sparse case
if (mj_isSparse(m)) {
// construct chain and sparse Jacobians
int* chain = mj_stackAllocInt(d, nv);
int NV = mj_bodyChain(m, body, chain);
mj_jacSparse(m, d, jacp, jacr, point, body, NV, chain);
// compute J'*f and accumulate
if (force) {
mju_mulMatTVec(qforce, jacp, force, 3, NV);
for (int i=0; i < NV; i++) {
qfrc_target[chain[i]] += qforce[i];
}
}
if (torque) {
mju_mulMatTVec(qforce, jacr, torque, 3, NV);
for (int i=0; i < NV; i++) {
qfrc_target[chain[i]] += qforce[i];
}
}
}
// dense case
else {
// compute Jacobians
mj_jac(m, d, jacp, jacr, point, body);
// compute J'*f and accumulate
if (force) {
mju_mulMatTVec(qforce, jacp, force, 3, nv);
mju_addTo(qfrc_target, qforce, nv);
}
if (torque) {
mju_mulMatTVec(qforce, jacr, torque, 3, nv);
mju_addTo(qfrc_target, qforce, nv);
}
}
mj_freeStack(d);
} | O3 | c | mj_applyFT:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movl %r9d, %r14d
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r13
movslq 0x4(%rdi), %r12
movq %rsi, %rdi
callq 0x2d310
movq %rbp, 0x18(%rsp)
testq %rbp, %rbp
je 0x9a1c7
leaq (%r12,%r12,2), %rsi
movq %rbx, %rdi
callq 0x2d370
movq %rax, (%rsp)
jmp 0x9a1cf
movq $0x0, (%rsp)
testq %r15, %r15
movq %r15, 0x20(%rsp)
je 0x9a1ef
leal (%r12,%r12,2), %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x2d370
movq %rax, 0x8(%rsp)
jmp 0x9a1f8
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2d370
movq %rax, %r15
testl %r14d, %r14d
movq %rbx, 0x28(%rsp)
js 0x9a216
cmpl %r14d, 0x10(%r13)
jg 0x9a257
leaq 0x1341e4(%rip), %rsi # 0x1ce401
leaq 0x30(%rsp), %rbx
movl $0x400, %edx # imm = 0x400
movq %rbx, %rdi
callq 0x2d240
leaq 0x3a(%rsp), %rdi
leaq 0x1341d1(%rip), %rdx # 0x1ce40c
movl $0x3f6, %esi # imm = 0x3F6
movl %r14d, %ecx
xorl %eax, %eax
callq 0x2d250
movq %rbx, %rdi
movq 0x28(%rsp), %rbx
callq 0x2d260
movq 0x470(%rsp), %rbp
movq %r13, %rdi
callq 0x2d7a0
testl %eax, %eax
je 0x9a346
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2d320
movq %rax, %r12
movq %r13, %rdi
movl %r14d, %esi
movq %rax, %rdx
callq 0x97c71
movq %rbx, %rsi
movl %eax, %ebx
movq %r13, %rdi
movl %r14d, %r9d
movq (%rsp), %r14
movq %r14, %rdx
movq 0x8(%rsp), %r13
movq %r13, %rcx
movq 0x10(%rsp), %r8
pushq %r12
pushq %rbx
callq 0x981af
addq $0x10, %rsp
movq 0x18(%rsp), %rdx
testq %rdx, %rdx
je 0x9a2f9
movq %r15, %rdi
movq %r14, %rsi
movl $0x3, %ecx
movl %ebx, %r8d
callq 0x2d2d0
testl %ebx, %ebx
jle 0x9a2f9
movl %ebx, %eax
xorl %ecx, %ecx
vmovsd (%r15,%rcx,8), %xmm0
movslq (%r12,%rcx,4), %rdx
vaddsd (%rbp,%rdx,8), %xmm0, %xmm0
vmovsd %xmm0, (%rbp,%rdx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x9a2db
movq 0x20(%rsp), %rdx
testq %rdx, %rdx
je 0x9a3be
movq %r15, %rdi
movq %r13, %rsi
movl $0x3, %ecx
movl %ebx, %r8d
callq 0x2d2d0
testl %ebx, %ebx
jle 0x9a3be
movl %ebx, %eax
xorl %ecx, %ecx
vmovsd (%r15,%rcx,8), %xmm0
movslq (%r12,%rcx,4), %rdx
vaddsd (%rbp,%rdx,8), %xmm0, %xmm0
vmovsd %xmm0, (%rbp,%rdx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x9a326
jmp 0x9a3be
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %r9d
movq (%rsp), %r14
movq %r14, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
movq 0x10(%rsp), %r8
callq 0x2d7b0
movq 0x18(%rsp), %rdx
testq %rdx, %rdx
je 0x9a393
movq %r15, %rdi
movq %r14, %rsi
movl $0x3, %ecx
movl %r12d, %r8d
callq 0x2d2d0
movq %rbp, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x2d830
movq 0x20(%rsp), %rdx
testq %rdx, %rdx
je 0x9a3be
movq %r15, %rdi
movq %rbx, %rsi
movl $0x3, %ecx
movl %r12d, %r8d
callq 0x2d2d0
movq %rbp, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x2d830
movq 0x28(%rsp), %rdi
callq 0x2d340
addq $0x438, %rsp # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| mj_applyFT:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 438h
mov r14d, r9d
mov [rsp+468h+var_458], r8
mov r15, rcx
mov rbp, rdx
mov rbx, rsi
mov r13, rdi
movsxd r12, dword ptr [rdi+4]
mov rdi, rsi
call _mj_markStack
mov [rsp+468h+var_450], rbp
test rbp, rbp
jz short loc_9A1C7
lea rsi, [r12+r12*2]
mov rdi, rbx
call _mj_stackAllocNum
mov [rsp+468h+var_468], rax
jmp short loc_9A1CF
loc_9A1C7:
mov [rsp+468h+var_468], 0
loc_9A1CF:
test r15, r15
mov [rsp+468h+var_448], r15
jz short loc_9A1EF
lea eax, [r12+r12*2]
movsxd rsi, eax
mov rdi, rbx
call _mj_stackAllocNum
mov [rsp+468h+var_460], rax
jmp short loc_9A1F8
loc_9A1EF:
mov [rsp+468h+var_460], 0
loc_9A1F8:
mov rdi, rbx
mov rsi, r12
call _mj_stackAllocNum
mov r15, rax
test r14d, r14d
mov [rsp+468h+var_440], rbx
js short loc_9A216
cmp [r13+10h], r14d
jg short loc_9A257
loc_9A216:
lea rsi, aMjApplyft_0; "mj_applyFT"
lea rbx, [rsp+468h+var_438]
mov edx, 400h
mov rdi, rbx
call _strncpy
lea rdi, [rsp+468h+var_42E]
lea rdx, aInvalidBodyD; ": invalid body %d"
mov esi, 3F6h
mov ecx, r14d
xor eax, eax
call _snprintf
mov rdi, rbx
mov rbx, [rsp+468h+var_440]
call _mju_error_raw
loc_9A257:
mov rbp, [rsp+468h+arg_0]
mov rdi, r13
call _mj_isSparse
test eax, eax
jz loc_9A346
mov rdi, rbx
mov rsi, r12
call _mj_stackAllocInt
mov r12, rax
mov rdi, r13
mov esi, r14d
mov rdx, rax
call mj_bodyChain
mov rsi, rbx
mov ebx, eax
mov rdi, r13
mov r9d, r14d
mov r14, [rsp+468h+var_468]
mov rdx, r14
mov r13, [rsp+468h+var_460]
mov rcx, r13
mov r8, [rsp+468h+var_458]
push r12
push rbx
call mj_jacSparse
add rsp, 10h
mov rdx, [rsp+468h+var_450]
test rdx, rdx
jz short loc_9A2F9
mov rdi, r15
mov rsi, r14
mov ecx, 3
mov r8d, ebx
call _mju_mulMatTVec
test ebx, ebx
jle short loc_9A2F9
mov eax, ebx
xor ecx, ecx
loc_9A2DB:
vmovsd xmm0, qword ptr [r15+rcx*8]
movsxd rdx, dword ptr [r12+rcx*4]
vaddsd xmm0, xmm0, qword ptr [rbp+rdx*8+0]
vmovsd qword ptr [rbp+rdx*8+0], xmm0
inc rcx
cmp rax, rcx
jnz short loc_9A2DB
loc_9A2F9:
mov rdx, [rsp+468h+var_448]
test rdx, rdx
jz loc_9A3BE
mov rdi, r15
mov rsi, r13
mov ecx, 3
mov r8d, ebx
call _mju_mulMatTVec
test ebx, ebx
jle loc_9A3BE
mov eax, ebx
xor ecx, ecx
loc_9A326:
vmovsd xmm0, qword ptr [r15+rcx*8]
movsxd rdx, dword ptr [r12+rcx*4]
vaddsd xmm0, xmm0, qword ptr [rbp+rdx*8+0]
vmovsd qword ptr [rbp+rdx*8+0], xmm0
inc rcx
cmp rax, rcx
jnz short loc_9A326
jmp short loc_9A3BE
loc_9A346:
mov rdi, r13
mov rsi, rbx
mov r9d, r14d
mov r14, [rsp+468h+var_468]
mov rdx, r14
mov rbx, [rsp+468h+var_460]
mov rcx, rbx
mov r8, [rsp+468h+var_458]
call _mj_jac
mov rdx, [rsp+468h+var_450]
test rdx, rdx
jz short loc_9A393
mov rdi, r15
mov rsi, r14
mov ecx, 3
mov r8d, r12d
call _mju_mulMatTVec
mov rdi, rbp
mov rsi, r15
mov edx, r12d
call _mju_addTo
loc_9A393:
mov rdx, [rsp+468h+var_448]
test rdx, rdx
jz short loc_9A3BE
mov rdi, r15
mov rsi, rbx
mov ecx, 3
mov r8d, r12d
call _mju_mulMatTVec
mov rdi, rbp
mov rsi, r15
mov edx, r12d
call _mju_addTo
loc_9A3BE:
mov rdi, [rsp+468h+var_440]
call _mj_freeStack
add rsp, 438h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mj_applyFT(
long long a1,
_QWORD *a2,
long long a3,
long long a4,
long long a5,
int a6,
double a7,
double a8,
double a9,
double a10,
double a11,
double a12,
double a13,
long long a14)
{
unsigned long long v17; // r12
double v18; // xmm0_8
int *v21; // r12
int v22; // ebx
double v23; // xmm4_8
double v24; // xmm5_8
long long v34; // [rsp+0h] [rbp-468h]
long long v35; // [rsp+8h] [rbp-460h]
long long v37; // [rsp+18h] [rbp-450h]
long long v38; // [rsp+20h] [rbp-448h]
_BYTE v39[10]; // [rsp+30h] [rbp-438h] BYREF
_BYTE v40[1070]; // [rsp+3Ah] [rbp-42Eh] BYREF
v17 = *(int *)(a1 + 4);
v18 = mj_markStack(a2, a7);
v37 = a3;
if ( a3 )
v34 = mj_stackAllocNum((long long)a2, 3 * v17);
else
v34 = 0LL;
v38 = a4;
if ( a4 )
v35 = mj_stackAllocNum((long long)a2, 3 * (int)v17);
else
v35 = 0LL;
_R15 = mj_stackAllocNum((long long)a2, v17);
if ( a6 < 0 || *(_DWORD *)(a1 + 16) <= a6 )
{
strncpy(v39, "mj_applyFT", 1024LL);
snprintf(v40, 1014LL, ": invalid body %d", a6);
v18 = mju_error_raw(v39);
}
_RBP = a14;
if ( (unsigned int)mj_isSparse(a1) )
{
v21 = (int *)mj_stackAllocInt((long long)a2, v17);
v22 = mj_bodyChain((_QWORD *)a1, a6, v21);
mj_jacSparse((_QWORD *)a1, (long long)a2, v34, v35, a5, a6, v18, a8, a9, a10, v23, v24, a13, v22, (long long)v21);
if ( v37 )
{
mju_mulMatTVec(_R15, v34, v37, 3LL, (unsigned int)v22);
if ( v22 > 0 )
{
for ( _RCX = 0LL; _RCX != v22; ++_RCX )
{
__asm { vmovsd xmm0, qword ptr [r15+rcx*8] }
_RDX = v21[_RCX];
__asm
{
vaddsd xmm0, xmm0, qword ptr [rbp+rdx*8+0]
vmovsd qword ptr [rbp+rdx*8+0], xmm0
}
}
}
}
if ( v38 )
{
mju_mulMatTVec(_R15, v35, v38, 3LL, (unsigned int)v22);
if ( v22 > 0 )
{
for ( _RCX = 0LL; _RCX != v22; ++_RCX )
{
__asm { vmovsd xmm0, qword ptr [r15+rcx*8] }
_RDX = v21[_RCX];
__asm
{
vaddsd xmm0, xmm0, qword ptr [rbp+rdx*8+0]
vmovsd qword ptr [rbp+rdx*8+0], xmm0
}
}
}
}
}
else
{
mj_jac(a1, a2, v34, v35, a5, (unsigned int)a6);
if ( v37 )
{
mju_mulMatTVec(_R15, v34, v37, 3LL, (unsigned int)v17);
mju_addTo(a14, _R15, (unsigned int)v17);
}
if ( v38 )
{
mju_mulMatTVec(_R15, v35, v38, 3LL, (unsigned int)v17);
mju_addTo(a14, _R15, (unsigned int)v17);
}
}
return mj_freeStack(a2);
}
| mj_applyFT:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x438
MOV R14D,R9D
MOV qword ptr [RSP + 0x10],R8
MOV R15,RCX
MOV RBP,RDX
MOV RBX,RSI
MOV R13,RDI
MOVSXD R12,dword ptr [RDI + 0x4]
MOV RDI,RSI
CALL 0x0012d310
MOV qword ptr [RSP + 0x18],RBP
TEST RBP,RBP
JZ 0x0019a1c7
LEA RSI,[R12 + R12*0x2]
MOV RDI,RBX
CALL 0x0012d370
MOV qword ptr [RSP],RAX
JMP 0x0019a1cf
LAB_0019a1c7:
MOV qword ptr [RSP],0x0
LAB_0019a1cf:
TEST R15,R15
MOV qword ptr [RSP + 0x20],R15
JZ 0x0019a1ef
LEA EAX,[R12 + R12*0x2]
MOVSXD RSI,EAX
MOV RDI,RBX
CALL 0x0012d370
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0019a1f8
LAB_0019a1ef:
MOV qword ptr [RSP + 0x8],0x0
LAB_0019a1f8:
MOV RDI,RBX
MOV RSI,R12
CALL 0x0012d370
MOV R15,RAX
TEST R14D,R14D
MOV qword ptr [RSP + 0x28],RBX
JS 0x0019a216
CMP dword ptr [R13 + 0x10],R14D
JG 0x0019a257
LAB_0019a216:
LEA RSI,[0x2ce401]
LEA RBX,[RSP + 0x30]
MOV EDX,0x400
MOV RDI,RBX
CALL 0x0012d240
LEA RDI,[RSP + 0x3a]
LEA RDX,[0x2ce40c]
MOV ESI,0x3f6
MOV ECX,R14D
XOR EAX,EAX
CALL 0x0012d250
MOV RDI,RBX
MOV RBX,qword ptr [RSP + 0x28]
CALL 0x0012d260
LAB_0019a257:
MOV RBP,qword ptr [RSP + 0x470]
MOV RDI,R13
CALL 0x0012d7a0
TEST EAX,EAX
JZ 0x0019a346
MOV RDI,RBX
MOV RSI,R12
CALL 0x0012d320
MOV R12,RAX
MOV RDI,R13
MOV ESI,R14D
MOV RDX,RAX
CALL 0x00197c71
MOV RSI,RBX
MOV EBX,EAX
MOV RDI,R13
MOV R9D,R14D
MOV R14,qword ptr [RSP]
MOV RDX,R14
MOV R13,qword ptr [RSP + 0x8]
MOV RCX,R13
MOV R8,qword ptr [RSP + 0x10]
PUSH R12
PUSH RBX
CALL 0x001981af
ADD RSP,0x10
MOV RDX,qword ptr [RSP + 0x18]
TEST RDX,RDX
JZ 0x0019a2f9
MOV RDI,R15
MOV RSI,R14
MOV ECX,0x3
MOV R8D,EBX
CALL 0x0012d2d0
TEST EBX,EBX
JLE 0x0019a2f9
MOV EAX,EBX
XOR ECX,ECX
LAB_0019a2db:
VMOVSD XMM0,qword ptr [R15 + RCX*0x8]
MOVSXD RDX,dword ptr [R12 + RCX*0x4]
VADDSD XMM0,XMM0,qword ptr [RBP + RDX*0x8]
VMOVSD qword ptr [RBP + RDX*0x8],XMM0
INC RCX
CMP RAX,RCX
JNZ 0x0019a2db
LAB_0019a2f9:
MOV RDX,qword ptr [RSP + 0x20]
TEST RDX,RDX
JZ 0x0019a3be
MOV RDI,R15
MOV RSI,R13
MOV ECX,0x3
MOV R8D,EBX
CALL 0x0012d2d0
TEST EBX,EBX
JLE 0x0019a3be
MOV EAX,EBX
XOR ECX,ECX
LAB_0019a326:
VMOVSD XMM0,qword ptr [R15 + RCX*0x8]
MOVSXD RDX,dword ptr [R12 + RCX*0x4]
VADDSD XMM0,XMM0,qword ptr [RBP + RDX*0x8]
VMOVSD qword ptr [RBP + RDX*0x8],XMM0
INC RCX
CMP RAX,RCX
JNZ 0x0019a326
JMP 0x0019a3be
LAB_0019a346:
MOV RDI,R13
MOV RSI,RBX
MOV R9D,R14D
MOV R14,qword ptr [RSP]
MOV RDX,R14
MOV RBX,qword ptr [RSP + 0x8]
MOV RCX,RBX
MOV R8,qword ptr [RSP + 0x10]
CALL 0x0012d7b0
MOV RDX,qword ptr [RSP + 0x18]
TEST RDX,RDX
JZ 0x0019a393
MOV RDI,R15
MOV RSI,R14
MOV ECX,0x3
MOV R8D,R12D
CALL 0x0012d2d0
MOV RDI,RBP
MOV RSI,R15
MOV EDX,R12D
CALL 0x0012d830
LAB_0019a393:
MOV RDX,qword ptr [RSP + 0x20]
TEST RDX,RDX
JZ 0x0019a3be
MOV RDI,R15
MOV RSI,RBX
MOV ECX,0x3
MOV R8D,R12D
CALL 0x0012d2d0
MOV RDI,RBP
MOV RSI,R15
MOV EDX,R12D
CALL 0x0012d830
LAB_0019a3be:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0012d340
ADD RSP,0x438
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void mj_applyFT(long param_1,int8 param_2,long param_3,long param_4,int8 param_5,
uint param_6,long param_7)
{
int iVar1;
int iVar2;
uint uVar3;
long lVar4;
ulong uVar5;
long lVar6;
ulong uVar7;
long lVar8;
int8 local_468;
int8 local_460;
char local_438 [10];
char local_42e [1022];
iVar1 = *(int *)(param_1 + 4);
lVar8 = (long)iVar1;
mj_markStack(param_2);
if (param_3 == 0) {
local_468 = 0;
}
else {
local_468 = mj_stackAllocNum(param_2,lVar8 * 3);
}
if (param_4 == 0) {
local_460 = 0;
}
else {
local_460 = mj_stackAllocNum(param_2,(long)(iVar1 * 3));
}
lVar4 = mj_stackAllocNum(param_2,lVar8);
if (((int)param_6 < 0) || (*(int *)(param_1 + 0x10) <= (int)param_6)) {
strncpy(local_438,"mj_applyFT",0x400);
snprintf(local_42e,0x3f6,": invalid body %d",(ulong)param_6);
mju_error_raw(local_438);
}
iVar2 = mj_isSparse(param_1);
if (iVar2 == 0) {
mj_jac(param_1,param_2,local_468,local_460,param_5,param_6);
if (param_3 != 0) {
mju_mulMatTVec(lVar4,local_468,param_3,3,iVar1);
mju_addTo(param_7,lVar4,iVar1);
}
if (param_4 != 0) {
mju_mulMatTVec(lVar4,local_460,param_4,3,iVar1);
mju_addTo(param_7,lVar4,iVar1);
}
}
else {
lVar8 = mj_stackAllocInt(param_2,lVar8);
uVar3 = mj_bodyChain(param_1,param_6,lVar8);
uVar7 = (ulong)uVar3;
mj_jacSparse(param_1,param_2,local_468,local_460,param_5,param_6,uVar7,lVar8);
if ((param_3 != 0) && (mju_mulMatTVec(lVar4,local_468,param_3,3,uVar3), 0 < (int)uVar3)) {
uVar5 = 0;
do {
lVar6 = (long)*(int *)(lVar8 + uVar5 * 4);
*(double *)(param_7 + lVar6 * 8) =
*(double *)(lVar4 + uVar5 * 8) + *(double *)(param_7 + lVar6 * 8);
uVar5 = uVar5 + 1;
} while (uVar7 != uVar5);
}
if ((param_4 != 0) && (mju_mulMatTVec(lVar4,local_460,param_4,3,uVar7), 0 < (int)uVar3)) {
uVar5 = 0;
do {
lVar6 = (long)*(int *)(lVar8 + uVar5 * 4);
*(double *)(param_7 + lVar6 * 8) =
*(double *)(lVar4 + uVar5 * 8) + *(double *)(param_7 + lVar6 * 8);
uVar5 = uVar5 + 1;
} while (uVar7 != uVar5);
}
}
mj_freeStack(param_2);
return;
}
| |
39,535 | inline_mysql_file_seek | eloqsql/include/mysql/psi/mysql_file.h | static inline my_off_t
inline_mysql_file_seek(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, my_off_t pos, int whence, myf flags)
{
my_off_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_SEEK);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_seek(file, pos, whence, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
#endif
result= my_seek(file, pos, whence, flags);
return result;
} | O0 | c | inline_mysql_file_seek:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x1e00b0(%rip), %rax # 0x2c0248
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0x8, %edx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xe0233
leaq 0x1e006a(%rip), %rax # 0x2c0248
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
xorl %esi, %esi
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0xf4e30
movq %rax, -0x38(%rbp)
leaq 0x1e0033(%rip), %rax # 0x2c0248
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x40(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe0252
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0xf4e30
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop
| inline_mysql_file_seek_6:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_88]
mov edx, 8
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_E0233
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_40]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
xor esi, esi
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rcx, [rbp+var_30]
call my_seek
mov [rbp+var_38], rax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_40]
xor ecx, ecx
mov esi, ecx
call rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
jmp short loc_E0252
loc_E0233:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rcx, [rbp+var_30]
call my_seek
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_E0252:
mov rax, [rbp+var_8]
add rsp, 90h
pop rbp
retn
| long long inline_mysql_file_seek_6(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
unsigned int a5,
long long a6)
{
_BYTE v7[72]; // [rsp+8h] [rbp-88h] BYREF
long long v8; // [rsp+50h] [rbp-40h]
long long v9; // [rsp+58h] [rbp-38h]
long long v10; // [rsp+60h] [rbp-30h]
unsigned int v11; // [rsp+6Ch] [rbp-24h]
long long v12; // [rsp+70h] [rbp-20h]
unsigned int v13; // [rsp+78h] [rbp-18h]
unsigned int v14; // [rsp+7Ch] [rbp-14h]
long long v15; // [rsp+80h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v10 = a6;
v8 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v7, a3, 8LL);
if ( !v8 )
return my_seek(v13, v12, v11, v10);
((void ( *)(long long, _QWORD, long long, _QWORD))PSI_server[66])(v8, 0LL, v15, v14);
v9 = my_seek(v13, v12, v11, v10);
((void ( *)(long long, _QWORD))PSI_server[67])(v8, 0LL);
return v9;
}
| inline_mysql_file_seek:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x3c0248]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x8
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001e0233
LEA RAX,[0x3c0248]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
XOR ESI,ESI
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001f4e30
MOV qword ptr [RBP + -0x38],RAX
LEA RAX,[0x3c0248]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
XOR ECX,ECX
MOV ESI,ECX
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001e0252
LAB_001e0233:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001f4e30
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001e0252:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x90
POP RBP
RET
|
int8
inline_mysql_file_seek
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
int4 param_5,int8 param_6)
{
int1 local_90 [72];
long local_48;
int8 local_40;
int8 local_38;
int4 local_2c;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
int8 local_10;
local_38 = param_6;
local_2c = param_5;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_48 = (**(code **)(PSI_server + 0x158))(local_90,param_3,8);
if (local_48 == 0) {
local_10 = my_seek(local_20,local_28,local_2c,local_38);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,0,local_18,local_1c);
local_40 = my_seek(local_20,local_28,local_2c,local_38);
(**(code **)(PSI_server + 0x218))(local_48,0);
local_10 = local_40;
}
return local_10;
}
| |
39,536 | js_dynamic_import | bluesky950520[P]quickjs/quickjs.c | static JSValue js_dynamic_import(JSContext *ctx, JSValue specifier)
{
JSAtom basename;
JSValue promise, resolving_funcs[2], basename_val;
JSValue args[4];
basename = JS_GetScriptOrModuleName(ctx, 0);
if (basename == JS_ATOM_NULL)
basename_val = JS_NULL;
else
basename_val = JS_AtomToValue(ctx, basename);
JS_FreeAtom(ctx, basename);
if (JS_IsException(basename_val))
return basename_val;
promise = JS_NewPromiseCapability(ctx, resolving_funcs);
if (JS_IsException(promise)) {
JS_FreeValue(ctx, basename_val);
return promise;
}
args[0] = resolving_funcs[0];
args[1] = resolving_funcs[1];
args[2] = basename_val;
args[3] = specifier;
/* cannot run JS_LoadModuleInternal synchronously because it would
cause an unexpected recursion in js_evaluate_module() */
JS_EnqueueJob(ctx, js_dynamic_import_job, 4, args);
JS_FreeValue(ctx, basename_val);
JS_FreeValue(ctx, resolving_funcs[0]);
JS_FreeValue(ctx, resolving_funcs[1]);
return promise;
} | O0 | c | js_dynamic_import:
subq $0xe8, %rsp
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rdi, 0xc0(%rsp)
movq 0xc0(%rsp), %rdi
xorl %esi, %esi
callq 0x4a160
movl %eax, 0xbc(%rsp)
cmpl $0x0, 0xbc(%rsp)
jne 0x660a6
movl $0x0, 0x20(%rsp)
movq $0x2, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0x660d8
movq 0xc0(%rsp), %rdi
movl 0xbc(%rsp), %esi
callq 0x28e30
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0xc0(%rsp), %rdi
movl 0xbc(%rsp), %esi
callq 0x29040
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x6611f
movq 0x70(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0x6629d
movq 0xc0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x4a490
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x661ac
movq 0xc0(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x23c90
movq 0xa8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0x6629d
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0xc0(%rsp), %rdi
leaq 0x30(%rsp), %rcx
leaq 0x7a2e(%rip), %rsi # 0x6dc50
movl $0x4, %edx
callq 0x23930
movq 0xc0(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x23c90
movq 0xc0(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x23c90
movq 0xc0(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x23c90
movq 0xa8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xd8(%rsp), %rax
movq 0xe0(%rsp), %rdx
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
| js_dynamic_import:
sub rsp, 0E8h
mov [rsp+0E8h+var_20], rsi
mov [rsp+0E8h+var_18], rdx
mov [rsp+0E8h+var_28], rdi
mov rdi, [rsp+0E8h+var_28]
xor esi, esi
call JS_GetScriptOrModuleName
mov [rsp+0E8h+var_2C], eax
cmp [rsp+0E8h+var_2C], 0
jnz short loc_660A6
mov dword ptr [rsp+0E8h+var_C8], 0
mov [rsp+0E8h+var_C0], 2
mov rax, [rsp+0E8h+var_C8]
mov [rsp+0E8h+var_78], rax
mov rax, [rsp+0E8h+var_C0]
mov [rsp+0E8h+var_70], rax
jmp short loc_660D8
loc_660A6:
mov rdi, [rsp+0E8h+var_28]
mov esi, [rsp+0E8h+var_2C]
call JS_AtomToValue
mov [rsp+0E8h+var_D8], rax
mov [rsp+0E8h+var_D0], rdx
mov rax, [rsp+0E8h+var_D8]
mov [rsp+0E8h+var_78], rax
mov rax, [rsp+0E8h+var_D0]
mov [rsp+0E8h+var_70], rax
loc_660D8:
mov rdi, [rsp+0E8h+var_28]
mov esi, [rsp+0E8h+var_2C]
call JS_FreeAtom
mov rdi, [rsp+0E8h+var_78]
mov rsi, [rsp+0E8h+var_70]
call JS_IsException_1
cmp eax, 0
jz short loc_6611F
mov rax, [rsp+0E8h+var_78]
mov [rsp+0E8h+var_10], rax
mov rax, [rsp+0E8h+var_70]
mov [rsp+0E8h+var_8], rax
jmp loc_6629D
loc_6611F:
mov rdi, [rsp+0E8h+var_28]
lea rsi, [rsp+0E8h+var_68]
call JS_NewPromiseCapability
mov [rsp+0E8h+var_E8], rax
mov [rsp+0E8h+var_E0], rdx
mov rax, [rsp+0E8h+var_E8]
mov [rsp+0E8h+var_40], rax
mov rax, [rsp+0E8h+var_E0]
mov [rsp+0E8h+var_38], rax
mov rdi, [rsp+0E8h+var_40]
mov rsi, [rsp+0E8h+var_38]
call JS_IsException_1
cmp eax, 0
jz short loc_661AC
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_78]
mov rdx, [rsp+0E8h+var_70]
call JS_FreeValue
mov rax, [rsp+0E8h+var_40]
mov [rsp+0E8h+var_10], rax
mov rax, [rsp+0E8h+var_38]
mov [rsp+0E8h+var_8], rax
jmp loc_6629D
loc_661AC:
mov rax, [rsp+0E8h+var_68]
mov [rsp+0E8h+var_B8], rax
mov rax, [rsp+0E8h+var_60]
mov [rsp+0E8h+var_B0], rax
mov rax, [rsp+0E8h+var_58]
mov [rsp+0E8h+var_A8], rax
mov rax, [rsp+0E8h+var_50]
mov [rsp+0E8h+var_A0], rax
mov rax, [rsp+0E8h+var_78]
mov [rsp+0E8h+var_98], rax
mov rax, [rsp+0E8h+var_70]
mov [rsp+0E8h+var_90], rax
mov rax, [rsp+0E8h+var_20]
mov [rsp+0E8h+var_88], rax
mov rax, [rsp+0E8h+var_18]
mov [rsp+0E8h+var_80], rax
mov rdi, [rsp+0E8h+var_28]
lea rcx, [rsp+0E8h+var_B8]
lea rsi, js_dynamic_import_job
mov edx, 4
call JS_EnqueueJob
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_78]
mov rdx, [rsp+0E8h+var_70]
call JS_FreeValue
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_68]
mov rdx, [rsp+0E8h+var_60]
call JS_FreeValue
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_58]
mov rdx, [rsp+0E8h+var_50]
call JS_FreeValue
mov rax, [rsp+0E8h+var_40]
mov [rsp+0E8h+var_10], rax
mov rax, [rsp+0E8h+var_38]
mov [rsp+0E8h+var_8], rax
loc_6629D:
mov rax, [rsp+0E8h+var_10]
mov rdx, [rsp+0E8h+var_8]
add rsp, 0E8h
retn
| long long js_dynamic_import(long long a1, long long a2, long long a3)
{
long long v3; // rdx
long long v4; // rdx
long long v6; // [rsp+20h] [rbp-C8h]
_QWORD v7[8]; // [rsp+30h] [rbp-B8h] BYREF
long long v8; // [rsp+70h] [rbp-78h]
long long v9; // [rsp+78h] [rbp-70h]
long long v10; // [rsp+80h] [rbp-68h] BYREF
long long v11; // [rsp+88h] [rbp-60h]
long long v12; // [rsp+90h] [rbp-58h]
long long v13; // [rsp+98h] [rbp-50h]
long long v14; // [rsp+A8h] [rbp-40h]
long long v15; // [rsp+B0h] [rbp-38h]
unsigned int ScriptOrModuleName; // [rsp+BCh] [rbp-2Ch]
long long v17; // [rsp+C0h] [rbp-28h]
long long v18; // [rsp+C8h] [rbp-20h]
long long v19; // [rsp+D0h] [rbp-18h]
long long v20; // [rsp+D8h] [rbp-10h]
long long v21; // [rsp+E0h] [rbp-8h]
v18 = a2;
v19 = a3;
v17 = a1;
ScriptOrModuleName = JS_GetScriptOrModuleName(a1, 0);
if ( ScriptOrModuleName )
{
v8 = JS_AtomToValue(v17, ScriptOrModuleName);
v9 = v3;
}
else
{
LODWORD(v6) = 0;
v8 = v6;
v9 = 2LL;
}
JS_FreeAtom(v17, ScriptOrModuleName);
if ( JS_IsException_1(v8, v9) )
{
v20 = v8;
v21 = v9;
}
else
{
v14 = JS_NewPromiseCapability(v17, (long long)&v10);
v15 = v4;
if ( JS_IsException_1(v14, v4) )
{
JS_FreeValue(v17, v8, v9);
}
else
{
v7[0] = v10;
v7[1] = v11;
v7[2] = v12;
v7[3] = v13;
v7[4] = v8;
v7[5] = v9;
v7[6] = v18;
v7[7] = v19;
JS_EnqueueJob(v17, (long long)js_dynamic_import_job, 4, (long long)v7);
JS_FreeValue(v17, v8, v9);
JS_FreeValue(v17, v10, v11);
JS_FreeValue(v17, v12, v13);
}
v20 = v14;
v21 = v15;
}
return v20;
}
| js_dynamic_import:
SUB RSP,0xe8
MOV qword ptr [RSP + 0xc8],RSI
MOV qword ptr [RSP + 0xd0],RDX
MOV qword ptr [RSP + 0xc0],RDI
MOV RDI,qword ptr [RSP + 0xc0]
XOR ESI,ESI
CALL 0x0014a160
MOV dword ptr [RSP + 0xbc],EAX
CMP dword ptr [RSP + 0xbc],0x0
JNZ 0x001660a6
MOV dword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x2
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x78],RAX
JMP 0x001660d8
LAB_001660a6:
MOV RDI,qword ptr [RSP + 0xc0]
MOV ESI,dword ptr [RSP + 0xbc]
CALL 0x00128e30
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x78],RAX
LAB_001660d8:
MOV RDI,qword ptr [RSP + 0xc0]
MOV ESI,dword ptr [RSP + 0xbc]
CALL 0x00129040
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x78]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x0016611f
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0xe0],RAX
JMP 0x0016629d
LAB_0016611f:
MOV RDI,qword ptr [RSP + 0xc0]
LEA RSI,[RSP + 0x80]
CALL 0x0014a490
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0xb0],RAX
MOV RDI,qword ptr [RSP + 0xa8]
MOV RSI,qword ptr [RSP + 0xb0]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001661ac
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x00123c90
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0xe0],RAX
JMP 0x0016629d
LAB_001661ac:
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0xc0]
LEA RCX,[RSP + 0x30]
LEA RSI,[0x16dc50]
MOV EDX,0x4
CALL 0x00123930
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x00123c90
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0xe0],RAX
LAB_0016629d:
MOV RAX,qword ptr [RSP + 0xd8]
MOV RDX,qword ptr [RSP + 0xe0]
ADD RSP,0xe8
RET
|
int1 [16] js_dynamic_import(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
uint uStack_c4;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_a0;
int1 local_98 [16];
int8 local_88;
int8 local_80;
int1 local_78 [16];
int8 local_68;
int8 local_60;
int8 local_58;
int8 local_50;
int1 local_40 [16];
int local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_2c = JS_GetScriptOrModuleName(param_1,0);
if (local_2c == 0) {
local_78._8_8_ = 2;
local_78._0_8_ = (ulong)uStack_c4 << 0x20;
}
else {
local_78 = JS_AtomToValue(local_28,local_2c);
}
JS_FreeAtom(local_28,local_2c);
iVar1 = JS_IsException(local_78._0_8_,local_78._8_8_);
local_40 = local_78;
if (iVar1 == 0) {
local_40 = JS_NewPromiseCapability(local_28,&local_68);
iVar1 = JS_IsException(local_40._0_8_,local_40._8_8_);
if (iVar1 == 0) {
local_b8 = local_68;
local_b0 = local_60;
local_a8 = local_58;
local_a0 = local_50;
local_88 = local_20;
local_80 = local_18;
local_98 = local_78;
JS_EnqueueJob(local_28,js_dynamic_import_job,4,&local_b8);
JS_FreeValue(local_28,local_78._0_8_,local_78._8_8_);
JS_FreeValue(local_28,local_68,local_60);
JS_FreeValue(local_28,local_58,local_50);
}
else {
JS_FreeValue(local_28,local_78._0_8_,local_78._8_8_);
}
}
return local_40;
}
| |
39,537 | ps_fetch_datetime | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | static
void ps_fetch_datetime(MYSQL_BIND *r_param, const MYSQL_FIELD * field,
unsigned char **row)
{
MYSQL_TIME *t= (MYSQL_TIME *)r_param->buffer;
unsigned int len= net_field_length(row);
switch (r_param->buffer_type) {
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
convert_to_datetime(t, row, len, field->type);
break;
case MYSQL_TYPE_DATE:
convert_to_datetime(t, row, len, field->type);
break;
case MYSQL_TYPE_TIME:
convert_to_datetime(t, row, len, field->type);
t->year= t->day= t->month= 0;
break;
case MYSQL_TYPE_YEAR:
{
MYSQL_TIME tm;
convert_to_datetime(&tm, row, len, field->type);
shortstore(r_param->buffer, tm.year);
break;
}
default:
{
char dtbuffer[60];
MYSQL_TIME tm;
size_t length;
convert_to_datetime(&tm, row, len, field->type);
switch(field->type) {
case MYSQL_TYPE_DATE:
length= sprintf(dtbuffer, "%04u-%02u-%02u", tm.year, tm.month, tm.day);
break;
case MYSQL_TYPE_TIME:
length= sprintf(dtbuffer, "%s%02u:%02u:%02u", (tm.neg ? "-" : ""), tm.hour, tm.minute, tm.second);
if (field->decimals && field->decimals <= 6)
{
char ms[8];
sprintf(ms, ".%06lu", tm.second_part);
if (field->decimals < 6)
ms[field->decimals + 1]= 0;
length+= strlen(ms);
strcat(dtbuffer, ms);
}
break;
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
length= sprintf(dtbuffer, "%04u-%02u-%02u %02u:%02u:%02u", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second);
if (field->decimals && field->decimals <= 6)
{
char ms[8];
sprintf(ms, ".%06lu", tm.second_part);
if (field->decimals < 6)
ms[field->decimals + 1]= 0;
length+= strlen(ms);
strcat(dtbuffer, ms);
}
break;
default:
dtbuffer[0]= 0;
length= 0;
break;
}
convert_froma_string(r_param, dtbuffer, length);
break;
}
}
(*row) += len;
} | O0 | c | ps_fetch_datetime:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x68(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdx, -0x78(%rbp)
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x3d1a0
movl %eax, -0x84(%rbp)
movq -0x68(%rbp), %rax
movl 0x60(%rax), %eax
addl $-0x7, %eax
movl %eax, %ecx
movq %rcx, -0xf0(%rbp)
subl $0x6, %eax
ja 0x56195
movq -0xf0(%rbp), %rax
leaq 0x7fcf7(%rip), %rcx # 0xd5db0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movl -0x84(%rbp), %edx
movq -0x70(%rbp), %rax
movl 0x70(%rax), %ecx
callq 0x58610
jmp 0x563af
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movl -0x84(%rbp), %edx
movq -0x70(%rbp), %rax
movl 0x70(%rax), %ecx
callq 0x58610
jmp 0x563af
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movl -0x84(%rbp), %edx
movq -0x70(%rbp), %rax
movl 0x70(%rax), %ecx
callq 0x58610
movq -0x80(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x80(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x80(%rbp), %rax
movl $0x0, (%rax)
jmp 0x563af
movq -0x78(%rbp), %rsi
movl -0x84(%rbp), %edx
movq -0x70(%rbp), %rax
movl 0x70(%rax), %ecx
leaq -0xb0(%rbp), %rdi
callq 0x58610
movl -0xb0(%rbp), %eax
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
movb %al, %cl
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rax
movb %cl, (%rax)
movl -0xb4(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rax
movb %cl, 0x1(%rax)
jmp 0x563af
movq -0x78(%rbp), %rsi
movl -0x84(%rbp), %edx
movq -0x70(%rbp), %rax
movl 0x70(%rax), %ecx
leaq -0xe0(%rbp), %rdi
callq 0x58610
movq -0x70(%rbp), %rax
movl 0x70(%rax), %eax
addl $-0x7, %eax
movl %eax, %ecx
movq %rcx, -0xf8(%rbp)
subl $0x5, %eax
ja 0x5638c
movq -0xf8(%rbp), %rax
leaq 0x7fbf0(%rip), %rcx # 0xd5dcc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x50(%rbp), %rdi
movl -0xe0(%rbp), %edx
movl -0xdc(%rbp), %ecx
movl -0xd8(%rbp), %r8d
leaq 0x78e97(%rip), %rsi # 0xcf09a
movb $0x0, %al
callq 0x37a20
cltq
movq %rax, -0xe8(%rbp)
jmp 0x5639b
leaq -0x50(%rbp), %rdi
movsbl -0xc0(%rbp), %ecx
leaq 0x7ea7c(%rip), %rdx # 0xd4ca6
leaq 0x7f88d(%rip), %rax # 0xd5abe
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movl -0xd4(%rbp), %ecx
movl -0xd0(%rbp), %r8d
movl -0xcc(%rbp), %r9d
leaq 0x78e56(%rip), %rsi # 0xcf0a9
movb $0x0, %al
callq 0x37a20
cltq
movq %rax, -0xe8(%rbp)
movq -0x70(%rbp), %rax
cmpl $0x0, 0x68(%rax)
je 0x562cf
movq -0x70(%rbp), %rax
cmpl $0x6, 0x68(%rax)
ja 0x562cf
leaq -0x58(%rbp), %rdi
movq -0xc8(%rbp), %rdx
leaq 0x78e31(%rip), %rsi # 0xcf0ba
movb $0x0, %al
callq 0x37a20
movq -0x70(%rbp), %rax
cmpl $0x6, 0x68(%rax)
jae 0x562ab
movq -0x70(%rbp), %rax
movl 0x68(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movb $0x0, -0x58(%rbp,%rax)
leaq -0x58(%rbp), %rdi
callq 0x37400
addq -0xe8(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x376a0
jmp 0x5639b
leaq -0x50(%rbp), %rdi
movl -0xe0(%rbp), %edx
movl -0xdc(%rbp), %ecx
movl -0xd8(%rbp), %r8d
movl -0xd4(%rbp), %r9d
movl -0xd0(%rbp), %r10d
movl -0xcc(%rbp), %eax
leaq 0x78dbb(%rip), %rsi # 0xcf0c1
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x37a20
cltq
movq %rax, -0xe8(%rbp)
movq -0x70(%rbp), %rax
cmpl $0x0, 0x68(%rax)
je 0x5638a
movq -0x70(%rbp), %rax
cmpl $0x6, 0x68(%rax)
ja 0x5638a
leaq -0x60(%rbp), %rdi
movq -0xc8(%rbp), %rdx
leaq 0x78d76(%rip), %rsi # 0xcf0ba
movb $0x0, %al
callq 0x37a20
movq -0x70(%rbp), %rax
cmpl $0x6, 0x68(%rax)
jae 0x56366
movq -0x70(%rbp), %rax
movl 0x68(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movb $0x0, -0x60(%rbp,%rax)
leaq -0x60(%rbp), %rdi
callq 0x37400
addq -0xe8(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x376a0
jmp 0x5639b
movb $0x0, -0x50(%rbp)
movq $0x0, -0xe8(%rbp)
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq -0xe8(%rbp), %rdx
callq 0x56da0
movl -0x84(%rbp), %eax
movl %eax, %edx
movq -0x78(%rbp), %rax
movq (%rax), %rcx
addq %rdx, %rcx
movq %rcx, (%rax)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x563df
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
callq 0x372c0
nopw %cs:(%rax,%rax)
| ps_fetch_datetime:
push rbp
mov rbp, rsp
sub rsp, 110h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov [rbp+var_78], rdx
mov rax, [rbp+var_68]
mov rax, [rax+10h]
mov [rbp+var_80], rax
mov rdi, [rbp+var_78]
call net_field_length
mov [rbp+var_84], eax
mov rax, [rbp+var_68]
mov eax, [rax+60h]
add eax, 0FFFFFFF9h; switch 7 cases
mov ecx, eax
mov [rbp+var_F0], rcx
sub eax, 6
ja def_560C0; jumptable 00000000000560C0 default case, cases 8,9
mov rax, [rbp+var_F0]
lea rcx, jpt_560C0
movsxd rax, ds:(jpt_560C0 - 0D5DB0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_560C2:
mov rdi, [rbp+var_80]; jumptable 00000000000560C0 cases 7,12
mov rsi, [rbp+var_78]
mov edx, [rbp+var_84]
mov rax, [rbp+var_70]
mov ecx, [rax+70h]
call convert_to_datetime
jmp loc_563AF
loc_560E1:
mov rdi, [rbp+var_80]; jumptable 00000000000560C0 case 10
mov rsi, [rbp+var_78]
mov edx, [rbp+var_84]
mov rax, [rbp+var_70]
mov ecx, [rax+70h]
call convert_to_datetime
jmp loc_563AF
loc_56100:
mov rdi, [rbp+var_80]; jumptable 00000000000560C0 case 11
mov rsi, [rbp+var_78]
mov edx, [rbp+var_84]
mov rax, [rbp+var_70]
mov ecx, [rax+70h]
call convert_to_datetime
mov rax, [rbp+var_80]
mov dword ptr [rax+4], 0
mov rax, [rbp+var_80]
mov dword ptr [rax+8], 0
mov rax, [rbp+var_80]
mov dword ptr [rax], 0
jmp loc_563AF
loc_5613F:
mov rsi, [rbp+var_78]; jumptable 00000000000560C0 case 13
mov edx, [rbp+var_84]
mov rax, [rbp+var_70]
mov ecx, [rax+70h]
lea rdi, [rbp+var_B0]
call convert_to_datetime
mov eax, [rbp+var_B0]
mov [rbp+var_B4], eax
mov eax, [rbp+var_B4]
mov cl, al
mov rax, [rbp+var_68]
mov rax, [rax+10h]
mov [rax], cl
mov eax, [rbp+var_B4]
shr eax, 8
mov cl, al
mov rax, [rbp+var_68]
mov rax, [rax+10h]
mov [rax+1], cl
jmp loc_563AF
def_560C0:
mov rsi, [rbp+var_78]; jumptable 00000000000560C0 default case, cases 8,9
mov edx, [rbp+var_84]
mov rax, [rbp+var_70]
mov ecx, [rax+70h]
lea rdi, [rbp+var_E0]
call convert_to_datetime
mov rax, [rbp+var_70]
mov eax, [rax+70h]
add eax, 0FFFFFFF9h; switch 6 cases
mov ecx, eax
mov [rbp+var_F8], rcx
sub eax, 5
ja def_561E3; jumptable 00000000000561E3 default case, cases 8,9
mov rax, [rbp+var_F8]
lea rcx, jpt_561E3
movsxd rax, ds:(jpt_561E3 - 0D5DCCh)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_561E5:
lea rdi, [rbp+var_50]; jumptable 00000000000561E3 case 10
mov edx, [rbp+var_E0]
mov ecx, [rbp+var_DC]
mov r8d, [rbp+var_D8]
lea rsi, a04u02u02u; "%04u-%02u-%02u"
mov al, 0
call _sprintf
cdqe
mov [rbp+var_E8], rax
jmp loc_5639B
loc_56218:
lea rdi, [rbp+var_50]; jumptable 00000000000561E3 case 11
movsx ecx, [rbp+var_C0]
lea rdx, asc_D4CA2+4; ""
lea rax, asc_D5ABB+3; "-"
cmp ecx, 0
cmovnz rdx, rax
mov ecx, [rbp+var_D4]
mov r8d, [rbp+var_D0]
mov r9d, [rbp+var_CC]
lea rsi, aS02u02u02u; "%s%02u:%02u:%02u"
mov al, 0
call _sprintf
cdqe
mov [rbp+var_E8], rax
mov rax, [rbp+var_70]
cmp dword ptr [rax+68h], 0
jz short loc_562CF
mov rax, [rbp+var_70]
cmp dword ptr [rax+68h], 6
ja short loc_562CF
lea rdi, [rbp+var_58]
mov rdx, [rbp+var_C8]
lea rsi, a06lu; ".%06lu"
mov al, 0
call _sprintf
mov rax, [rbp+var_70]
cmp dword ptr [rax+68h], 6
jnb short loc_562AB
mov rax, [rbp+var_70]
mov eax, [rax+68h]
add eax, 1
mov eax, eax
mov [rbp+rax+var_58], 0
loc_562AB:
lea rdi, [rbp+var_58]
call _strlen
add rax, [rbp+var_E8]
mov [rbp+var_E8], rax
lea rdi, [rbp+var_50]
lea rsi, [rbp+var_58]
call _strcat
loc_562CF:
jmp loc_5639B
loc_562D4:
lea rdi, [rbp+var_50]; jumptable 00000000000561E3 cases 7,12
mov edx, [rbp+var_E0]
mov ecx, [rbp+var_DC]
mov r8d, [rbp+var_D8]
mov r9d, [rbp+var_D4]
mov r10d, [rbp+var_D0]
mov eax, [rbp+var_CC]
lea rsi, a04u02u02u02u02; "%04u-%02u-%02u %02u:%02u:%02u"
mov [rsp+110h+var_110], r10d
mov [rsp+110h+var_108], eax
mov al, 0
call _sprintf
cdqe
mov [rbp+var_E8], rax
mov rax, [rbp+var_70]
cmp dword ptr [rax+68h], 0
jz short loc_5638A
mov rax, [rbp+var_70]
cmp dword ptr [rax+68h], 6
ja short loc_5638A
lea rdi, [rbp+var_60]
mov rdx, [rbp+var_C8]
lea rsi, a06lu; ".%06lu"
mov al, 0
call _sprintf
mov rax, [rbp+var_70]
cmp dword ptr [rax+68h], 6
jnb short loc_56366
mov rax, [rbp+var_70]
mov eax, [rax+68h]
add eax, 1
mov eax, eax
mov [rbp+rax+var_60], 0
loc_56366:
lea rdi, [rbp+var_60]
call _strlen
add rax, [rbp+var_E8]
mov [rbp+var_E8], rax
lea rdi, [rbp+var_50]
lea rsi, [rbp+var_60]
call _strcat
loc_5638A:
jmp short loc_5639B
def_561E3:
mov [rbp+var_50], 0; jumptable 00000000000561E3 default case, cases 8,9
mov [rbp+var_E8], 0
loc_5639B:
mov rdi, [rbp+var_68]
lea rsi, [rbp+var_50]
mov rdx, [rbp+var_E8]
call convert_froma_string
loc_563AF:
mov eax, [rbp+var_84]
mov edx, eax
mov rax, [rbp+var_78]
mov rcx, [rax]
add rcx, rdx
mov [rax], rcx
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_563DF
add rsp, 110h
pop rbp
retn
loc_563DF:
call ___stack_chk_fail
| unsigned long long ps_fetch_datetime(long long a1, long long a2, unsigned __int8 **a3)
{
char *v3; // rdx
long long v5; // [rsp+28h] [rbp-E8h]
long long v6; // [rsp+28h] [rbp-E8h]
_DWORD v7[6]; // [rsp+30h] [rbp-E0h] BYREF
long long v8; // [rsp+48h] [rbp-C8h]
char v9; // [rsp+50h] [rbp-C0h]
int v10; // [rsp+5Ch] [rbp-B4h]
_DWORD v11[11]; // [rsp+60h] [rbp-B0h] BYREF
unsigned int v12; // [rsp+8Ch] [rbp-84h]
_DWORD *v13; // [rsp+90h] [rbp-80h]
unsigned __int8 **v14; // [rsp+98h] [rbp-78h]
long long v15; // [rsp+A0h] [rbp-70h]
long long v16; // [rsp+A8h] [rbp-68h]
_BYTE v17[8]; // [rsp+B0h] [rbp-60h] BYREF
_BYTE v18[8]; // [rsp+B8h] [rbp-58h] BYREF
_BYTE v19[72]; // [rsp+C0h] [rbp-50h] BYREF
unsigned long long v20; // [rsp+108h] [rbp-8h]
v20 = __readfsqword(0x28u);
v16 = a1;
v15 = a2;
v14 = a3;
v13 = *(_DWORD **)(a1 + 16);
v12 = net_field_length(a3);
switch ( *(_DWORD *)(a1 + 96) )
{
case 7:
case 0xA:
case 0xC:
convert_to_datetime(v13, v14, v12, *(unsigned int *)(v15 + 112));
break;
case 0xB:
convert_to_datetime(v13, v14, v12, *(unsigned int *)(v15 + 112));
v13[1] = 0;
v13[2] = 0;
*v13 = 0;
break;
case 0xD:
convert_to_datetime(v11, v14, v12, *(unsigned int *)(v15 + 112));
v10 = v11[0];
**(_BYTE **)(v16 + 16) = v11[0];
*(_BYTE *)(*(_QWORD *)(v16 + 16) + 1LL) = BYTE1(v10);
break;
default:
convert_to_datetime(v7, v14, v12, *(unsigned int *)(v15 + 112));
switch ( *(_DWORD *)(v15 + 112) )
{
case 7:
case 0xC:
v6 = (int)sprintf(v19, "%04u-%02u-%02u %02u:%02u:%02u", v7[0], v7[1], v7[2], v7[3], v7[4], v7[5]);
if ( *(_DWORD *)(v15 + 104) && *(_DWORD *)(v15 + 104) <= 6u )
{
sprintf(v17, ".%06lu", v8);
if ( *(_DWORD *)(v15 + 104) < 6u )
v17[*(_DWORD *)(v15 + 104) + 1] = 0;
v6 += strlen(v17);
strcat(v19, v17);
}
goto LABEL_22;
case 0xA:
v5 = (int)sprintf(v19, "%04u-%02u-%02u", v7[0]);
convert_froma_string(v16, v19, v5);
goto LABEL_23;
case 0xB:
v3 = "";
if ( v9 )
v3 = "-";
v6 = (int)sprintf(v19, "%s%02u:%02u:%02u", v3);
if ( *(_DWORD *)(v15 + 104) && *(_DWORD *)(v15 + 104) <= 6u )
{
sprintf(v18, ".%06lu", v8);
if ( *(_DWORD *)(v15 + 104) < 6u )
v18[*(_DWORD *)(v15 + 104) + 1] = 0;
v6 += strlen(v18);
strcat(v19, v18);
}
goto LABEL_22;
default:
v19[0] = 0;
v6 = 0LL;
LABEL_22:
convert_froma_string(v16, v19, v6);
break;
}
break;
}
LABEL_23:
*v14 += v12;
return __readfsqword(0x28u);
}
| ps_fetch_datetime:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x110
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV qword ptr [RBP + -0x78],RDX
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x80],RAX
MOV RDI,qword ptr [RBP + -0x78]
CALL 0x0013d1a0
MOV dword ptr [RBP + -0x84],EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV EAX,dword ptr [RAX + 0x60]
ADD EAX,-0x7
MOV ECX,EAX
MOV qword ptr [RBP + -0xf0],RCX
SUB EAX,0x6
JA 0x00156195
MOV RAX,qword ptr [RBP + -0xf0]
LEA RCX,[0x1d5db0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_7:
MOV RDI,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x78]
MOV EDX,dword ptr [RBP + -0x84]
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,dword ptr [RAX + 0x70]
CALL 0x00158610
JMP 0x001563af
caseD_a:
MOV RDI,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x78]
MOV EDX,dword ptr [RBP + -0x84]
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,dword ptr [RAX + 0x70]
CALL 0x00158610
JMP 0x001563af
caseD_b:
MOV RDI,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x78]
MOV EDX,dword ptr [RBP + -0x84]
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,dword ptr [RAX + 0x70]
CALL 0x00158610
MOV RAX,qword ptr [RBP + -0x80]
MOV dword ptr [RAX + 0x4],0x0
MOV RAX,qword ptr [RBP + -0x80]
MOV dword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x80]
MOV dword ptr [RAX],0x0
JMP 0x001563af
caseD_d:
MOV RSI,qword ptr [RBP + -0x78]
MOV EDX,dword ptr [RBP + -0x84]
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,dword ptr [RAX + 0x70]
LEA RDI,[RBP + -0xb0]
CALL 0x00158610
MOV EAX,dword ptr [RBP + -0xb0]
MOV dword ptr [RBP + -0xb4],EAX
MOV EAX,dword ptr [RBP + -0xb4]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x10]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0xb4]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x10]
MOV byte ptr [RAX + 0x1],CL
JMP 0x001563af
caseD_8:
MOV RSI,qword ptr [RBP + -0x78]
MOV EDX,dword ptr [RBP + -0x84]
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,dword ptr [RAX + 0x70]
LEA RDI,[RBP + -0xe0]
CALL 0x00158610
MOV RAX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RAX + 0x70]
ADD EAX,-0x7
MOV ECX,EAX
MOV qword ptr [RBP + -0xf8],RCX
SUB EAX,0x5
JA 0x0015638c
MOV RAX,qword ptr [RBP + -0xf8]
LEA RCX,[0x1d5dcc]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_a:
LEA RDI,[RBP + -0x50]
MOV EDX,dword ptr [RBP + -0xe0]
MOV ECX,dword ptr [RBP + -0xdc]
MOV R8D,dword ptr [RBP + -0xd8]
LEA RSI,[0x1cf09a]
MOV AL,0x0
CALL 0x00137a20
CDQE
MOV qword ptr [RBP + -0xe8],RAX
JMP 0x0015639b
caseD_b:
LEA RDI,[RBP + -0x50]
MOVSX ECX,byte ptr [RBP + -0xc0]
LEA RDX,[0x1d4ca6]
LEA RAX,[0x1d5abe]
CMP ECX,0x0
CMOVNZ RDX,RAX
MOV ECX,dword ptr [RBP + -0xd4]
MOV R8D,dword ptr [RBP + -0xd0]
MOV R9D,dword ptr [RBP + -0xcc]
LEA RSI,[0x1cf0a9]
MOV AL,0x0
CALL 0x00137a20
CDQE
MOV qword ptr [RBP + -0xe8],RAX
MOV RAX,qword ptr [RBP + -0x70]
CMP dword ptr [RAX + 0x68],0x0
JZ 0x001562cf
MOV RAX,qword ptr [RBP + -0x70]
CMP dword ptr [RAX + 0x68],0x6
JA 0x001562cf
LEA RDI,[RBP + -0x58]
MOV RDX,qword ptr [RBP + -0xc8]
LEA RSI,[0x1cf0ba]
MOV AL,0x0
CALL 0x00137a20
MOV RAX,qword ptr [RBP + -0x70]
CMP dword ptr [RAX + 0x68],0x6
JNC 0x001562ab
MOV RAX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RAX + 0x68]
ADD EAX,0x1
MOV EAX,EAX
MOV byte ptr [RBP + RAX*0x1 + -0x58],0x0
LAB_001562ab:
LEA RDI,[RBP + -0x58]
CALL 0x00137400
ADD RAX,qword ptr [RBP + -0xe8]
MOV qword ptr [RBP + -0xe8],RAX
LEA RDI,[RBP + -0x50]
LEA RSI,[RBP + -0x58]
CALL 0x001376a0
LAB_001562cf:
JMP 0x0015639b
caseD_7:
LEA RDI,[RBP + -0x50]
MOV EDX,dword ptr [RBP + -0xe0]
MOV ECX,dword ptr [RBP + -0xdc]
MOV R8D,dword ptr [RBP + -0xd8]
MOV R9D,dword ptr [RBP + -0xd4]
MOV R10D,dword ptr [RBP + -0xd0]
MOV EAX,dword ptr [RBP + -0xcc]
LEA RSI,[0x1cf0c1]
MOV dword ptr [RSP],R10D
MOV dword ptr [RSP + 0x8],EAX
MOV AL,0x0
CALL 0x00137a20
CDQE
MOV qword ptr [RBP + -0xe8],RAX
MOV RAX,qword ptr [RBP + -0x70]
CMP dword ptr [RAX + 0x68],0x0
JZ 0x0015638a
MOV RAX,qword ptr [RBP + -0x70]
CMP dword ptr [RAX + 0x68],0x6
JA 0x0015638a
LEA RDI,[RBP + -0x60]
MOV RDX,qword ptr [RBP + -0xc8]
LEA RSI,[0x1cf0ba]
MOV AL,0x0
CALL 0x00137a20
MOV RAX,qword ptr [RBP + -0x70]
CMP dword ptr [RAX + 0x68],0x6
JNC 0x00156366
MOV RAX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RAX + 0x68]
ADD EAX,0x1
MOV EAX,EAX
MOV byte ptr [RBP + RAX*0x1 + -0x60],0x0
LAB_00156366:
LEA RDI,[RBP + -0x60]
CALL 0x00137400
ADD RAX,qword ptr [RBP + -0xe8]
MOV qword ptr [RBP + -0xe8],RAX
LEA RDI,[RBP + -0x50]
LEA RSI,[RBP + -0x60]
CALL 0x001376a0
LAB_0015638a:
JMP 0x0015639b
caseD_8:
MOV byte ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0xe8],0x0
LAB_0015639b:
MOV RDI,qword ptr [RBP + -0x68]
LEA RSI,[RBP + -0x50]
MOV RDX,qword ptr [RBP + -0xe8]
CALL 0x00156da0
LAB_001563af:
MOV EAX,dword ptr [RBP + -0x84]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RAX]
ADD RCX,RDX
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001563df
ADD RSP,0x110
POP RBP
RET
LAB_001563df:
CALL 0x001372c0
|
void ps_fetch_datetime(long param_1,long param_2,long *param_3)
{
int iVar1;
size_t sVar2;
int1 *puVar3;
long in_FS_OFFSET;
long local_f0;
uint local_e8;
uint local_e4;
uint local_e0;
uint local_dc;
uint local_d8;
uint local_d4;
int8 local_d0;
char local_c8;
int4 local_bc;
int4 local_b8 [11];
uint local_8c;
int4 *local_88;
long *local_80;
long local_78;
long local_70;
char local_68 [8];
char local_60 [8];
char local_58 [72];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_88 = *(int4 **)(param_1 + 0x10);
local_80 = param_3;
local_78 = param_2;
local_70 = param_1;
local_8c = net_field_length(param_3);
switch(*(int4 *)(local_70 + 0x60)) {
case 7:
case 0xc:
convert_to_datetime(local_88,local_80,local_8c,*(int4 *)(local_78 + 0x70));
break;
default:
convert_to_datetime(&local_e8,local_80,local_8c,*(int4 *)(local_78 + 0x70));
switch(*(int4 *)(local_78 + 0x70)) {
case 7:
case 0xc:
iVar1 = sprintf(local_58,"%04u-%02u-%02u %02u:%02u:%02u",(ulong)local_e8,(ulong)local_e4,
(ulong)local_e0,(ulong)local_dc,local_d8,local_d4);
local_f0 = (long)iVar1;
if ((*(int *)(local_78 + 0x68) != 0) && (*(uint *)(local_78 + 0x68) < 7)) {
sprintf(local_68,".%06lu",local_d0);
if (*(uint *)(local_78 + 0x68) < 6) {
local_68[*(int *)(local_78 + 0x68) + 1] = '\0';
}
sVar2 = strlen(local_68);
local_f0 = sVar2 + local_f0;
strcat(local_58,local_68);
}
break;
default:
local_58[0] = '\0';
local_f0 = 0;
break;
case 10:
iVar1 = sprintf(local_58,"%04u-%02u-%02u",(ulong)local_e8,(ulong)local_e4,(ulong)local_e0);
local_f0 = (long)iVar1;
break;
case 0xb:
puVar3 = &DAT_001d4ca6;
if (local_c8 != '\0') {
puVar3 = &DAT_001d5abe;
}
iVar1 = sprintf(local_58,"%s%02u:%02u:%02u",puVar3,(ulong)local_dc,(ulong)local_d8,
(ulong)local_d4);
local_f0 = (long)iVar1;
if ((*(int *)(local_78 + 0x68) != 0) && (*(uint *)(local_78 + 0x68) < 7)) {
sprintf(local_60,".%06lu",local_d0);
if (*(uint *)(local_78 + 0x68) < 6) {
local_60[*(int *)(local_78 + 0x68) + 1] = '\0';
}
sVar2 = strlen(local_60);
local_f0 = sVar2 + local_f0;
strcat(local_58,local_60);
}
}
convert_froma_string(local_70,local_58,local_f0);
break;
case 10:
convert_to_datetime(local_88,local_80,local_8c,*(int4 *)(local_78 + 0x70));
break;
case 0xb:
convert_to_datetime(local_88,local_80,local_8c,*(int4 *)(local_78 + 0x70));
local_88[1] = 0;
local_88[2] = 0;
*local_88 = 0;
break;
case 0xd:
convert_to_datetime(local_b8,local_80,local_8c,*(int4 *)(local_78 + 0x70));
local_bc = local_b8[0];
**(int1 **)(local_70 + 0x10) = (char)local_b8[0];
*(char *)(*(long *)(local_70 + 0x10) + 1) = (char)((uint)local_b8[0] >> 8);
}
*local_80 = *local_80 + (ulong)local_8c;
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
39,538 | set_default_charset_by_name | eloqsql/libmariadb/libmariadb/mariadb_charset.c | my_bool set_default_charset_by_name(const char *cs_name, myf flags __attribute__((unused)))
{
MARIADB_CHARSET_INFO *new_charset;
new_charset = mysql_get_charset_by_name(cs_name);
if (!new_charset)
{
return(TRUE); /* error */
}
ma_default_charset_info = new_charset;
return(FALSE);
} | O3 | c | set_default_charset_by_name:
pushq %rbp
movq %rsp, %rbp
callq 0x319c8
testq %rax, %rax
je 0x31a1e
leaq 0x18e61(%rip), %rcx # 0x4a878
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0x31a20
movb $0x1, %al
popq %rbp
retq
nop
| set_default_charset_by_name:
push rbp
mov rbp, rsp
call mysql_get_charset_by_name
test rax, rax
jz short loc_31A1E
lea rcx, ma_default_charset_info
mov [rcx], rax
xor eax, eax
jmp short loc_31A20
loc_31A1E:
mov al, 1
loc_31A20:
pop rbp
retn
| long long set_default_charset_by_name(long long a1)
{
_DWORD *charset_by_name; // rax
charset_by_name = mysql_get_charset_by_name(a1);
if ( !charset_by_name )
return 1LL;
ma_default_charset_info = charset_by_name;
return 0LL;
}
| set_default_charset_by_name:
PUSH RBP
MOV RBP,RSP
CALL 0x001319c8
TEST RAX,RAX
JZ 0x00131a1e
LEA RCX,[0x14a878]
MOV qword ptr [RCX],RAX
XOR EAX,EAX
JMP 0x00131a20
LAB_00131a1e:
MOV AL,0x1
LAB_00131a20:
POP RBP
RET
|
bool set_default_charset_by_name(void)
{
long lVar1;
lVar1 = mysql_get_charset_by_name();
if (lVar1 != 0) {
ma_default_charset_info = lVar1;
}
return lVar1 == 0;
}
| |
39,539 | lshift | eloqsql/strings/dtoa.c | static Bigint *lshift(Bigint *b, int k, Stack_alloc *alloc)
{
int i, k1, n, n1;
Bigint *b1;
ULong *x, *x1, *xe, z;
n= k >> 5;
k1= b->k;
n1= n + b->wds + 1;
for (i= b->maxwds; n1 > i; i<<= 1)
k1++;
b1= Balloc(k1, alloc);
x1= b1->p.x;
for (i= 0; i < n; i++)
*x1++= 0;
x= b->p.x;
xe= x + b->wds;
if (k&= 0x1f)
{
k1= 32 - k;
z= 0;
do
{
*x1++= *x << k | z;
z= *x++ >> k1;
}
while (x < xe);
if ((*x1= z))
++n1;
}
else
do
*x1++= *x++;
while (x < xe);
b1->wds= n1 - 1;
Bfree(b, alloc);
return b1;
} | O3 | c | lshift:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %r14
movl %esi, %r12d
shrl $0x5, %r12d
movl 0x8(%rdi), %edi
movl 0xc(%r14), %eax
movl 0x14(%r14), %ebx
addl %r12d, %ebx
cmpl %eax, %ebx
jl 0x2c5f9
incl %edi
addl %eax, %eax
jmp 0x2c5ef
movq %rdx, -0x38(%rbp)
movq %rdx, %rsi
callq 0x2c19c
movq (%rax), %r13
cmpl $0x20, %r15d
jb 0x2c630
decl %r12d
leaq 0x4(,%r12,4), %rdx
movq %r13, %rdi
xorl %esi, %esi
movq %rax, -0x30(%rbp)
callq 0x24180
movq -0x30(%rbp), %rax
leaq 0x4(%r13,%r12,4), %r13
movq (%r14), %rdx
movslq 0x14(%r14), %rcx
leaq (%rdx,%rcx,4), %rsi
andl $0x1f, %r15d
je 0x2c67c
movl $0x20, %r9d
subl %r15d, %r9d
xorl %edi, %edi
movl (%rdx), %r8d
movl %r15d, %ecx
shll %cl, %r8d
orl %edi, %r8d
movl %r8d, (%r13)
addq $0x4, %r13
movl (%rdx), %edi
addq $0x4, %rdx
movl %r9d, %ecx
shrl %cl, %edi
cmpq %rsi, %rdx
jb 0x2c64c
movl %edi, (%r13)
cmpl $0x1, %edi
sbbl $-0x1, %ebx
jmp 0x2c68f
movl (%rdx), %ecx
addq $0x4, %rdx
movl %ecx, (%r13)
addq $0x4, %r13
cmpq %rsi, %rdx
jb 0x2c67c
movl %ebx, 0x14(%rax)
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rbx
callq 0x2c595
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| lshift:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15d, esi
mov r14, rdi
mov r12d, esi
shr r12d, 5
mov edi, [rdi+8]
mov eax, [r14+0Ch]
mov ebx, [r14+14h]
add ebx, r12d
loc_2C5EF:
cmp ebx, eax
jl short loc_2C5F9
inc edi
add eax, eax
jmp short loc_2C5EF
loc_2C5F9:
mov [rbp+var_38], rdx
mov rsi, rdx
call Balloc
mov r13, [rax]
cmp r15d, 20h ; ' '
jb short loc_2C630
dec r12d
lea rdx, ds:4[r12*4]
mov rdi, r13
xor esi, esi
mov [rbp+var_30], rax
call _memset
mov rax, [rbp+var_30]
lea r13, [r13+r12*4+4]
loc_2C630:
mov rdx, [r14]
movsxd rcx, dword ptr [r14+14h]
lea rsi, [rdx+rcx*4]
and r15d, 1Fh
jz short loc_2C67C
mov r9d, 20h ; ' '
sub r9d, r15d
xor edi, edi
loc_2C64C:
mov r8d, [rdx]
mov ecx, r15d
shl r8d, cl
or r8d, edi
mov [r13+0], r8d
add r13, 4
mov edi, [rdx]
add rdx, 4
mov ecx, r9d
shr edi, cl
cmp rdx, rsi
jb short loc_2C64C
mov [r13+0], edi
cmp edi, 1
sbb ebx, 0FFFFFFFFh
jmp short loc_2C68F
loc_2C67C:
mov ecx, [rdx]
add rdx, 4
mov [r13+0], ecx
add r13, 4
cmp rdx, rsi
jb short loc_2C67C
loc_2C68F:
mov [rax+14h], ebx
mov rdi, r14
mov rsi, [rbp+var_38]
mov rbx, rax
call Bfree
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long lshift(unsigned long long a1, unsigned int a2, unsigned long long *a3)
{
char v3; // r15
int v5; // edi
int v6; // eax
int v7; // ebx
long long v8; // rax
int *v9; // r13
long long v10; // r12
int *v11; // rdx
unsigned long long v12; // rsi
int v13; // r15d
int v14; // edi
unsigned int v15; // edi
int v16; // ecx
long long v17; // rbx
long long v20; // [rsp+10h] [rbp-30h]
v3 = a2;
v5 = *(_DWORD *)(a1 + 8);
v6 = *(_DWORD *)(a1 + 12);
v7 = (a2 >> 5) + *(_DWORD *)(a1 + 20);
while ( v7 >= v6 )
{
++v5;
v6 *= 2;
}
v8 = Balloc(v5, (long long)a3);
v9 = *(int **)v8;
if ( a2 >= 0x20 )
{
v10 = (a2 >> 5) - 1;
v20 = v8;
memset(*(_QWORD *)v8, 0LL, 4 * v10 + 4);
v8 = v20;
v9 += v10 + 1;
}
v11 = *(int **)a1;
v12 = *(_QWORD *)a1 + 4LL * *(int *)(a1 + 20);
v13 = v3 & 0x1F;
if ( v13 )
{
v14 = 0;
do
{
*v9++ = v14 | (*v11 << v13);
v15 = *v11++;
v14 = v15 >> (32 - v13);
}
while ( (unsigned long long)v11 < v12 );
*v9 = v14;
v7 -= (v14 == 0) - 1;
}
else
{
do
{
v16 = *v11++;
*v9++ = v16;
}
while ( (unsigned long long)v11 < v12 );
}
*(_DWORD *)(v8 + 20) = v7;
v17 = v8;
Bfree(a1, a3);
return v17;
}
| lshift:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15D,ESI
MOV R14,RDI
MOV R12D,ESI
SHR R12D,0x5
MOV EDI,dword ptr [RDI + 0x8]
MOV EAX,dword ptr [R14 + 0xc]
MOV EBX,dword ptr [R14 + 0x14]
ADD EBX,R12D
LAB_0012c5ef:
CMP EBX,EAX
JL 0x0012c5f9
INC EDI
ADD EAX,EAX
JMP 0x0012c5ef
LAB_0012c5f9:
MOV qword ptr [RBP + -0x38],RDX
MOV RSI,RDX
CALL 0x0012c19c
MOV R13,qword ptr [RAX]
CMP R15D,0x20
JC 0x0012c630
DEC R12D
LEA RDX,[0x4 + R12*0x4]
MOV RDI,R13
XOR ESI,ESI
MOV qword ptr [RBP + -0x30],RAX
CALL 0x00124180
MOV RAX,qword ptr [RBP + -0x30]
LEA R13,[R13 + R12*0x4 + 0x4]
LAB_0012c630:
MOV RDX,qword ptr [R14]
MOVSXD RCX,dword ptr [R14 + 0x14]
LEA RSI,[RDX + RCX*0x4]
AND R15D,0x1f
JZ 0x0012c67c
MOV R9D,0x20
SUB R9D,R15D
XOR EDI,EDI
LAB_0012c64c:
MOV R8D,dword ptr [RDX]
MOV ECX,R15D
SHL R8D,CL
OR R8D,EDI
MOV dword ptr [R13],R8D
ADD R13,0x4
MOV EDI,dword ptr [RDX]
ADD RDX,0x4
MOV ECX,R9D
SHR EDI,CL
CMP RDX,RSI
JC 0x0012c64c
MOV dword ptr [R13],EDI
CMP EDI,0x1
SBB EBX,-0x1
JMP 0x0012c68f
LAB_0012c67c:
MOV ECX,dword ptr [RDX]
ADD RDX,0x4
MOV dword ptr [R13],ECX
ADD R13,0x4
CMP RDX,RSI
JC 0x0012c67c
LAB_0012c68f:
MOV dword ptr [RAX + 0x14],EBX
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x38]
MOV RBX,RAX
CALL 0x0012c595
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 * lshift(int8 *param_1,uint param_2,int8 param_3)
{
uint *puVar1;
sbyte sVar2;
int iVar3;
int8 *puVar4;
uint *puVar5;
int iVar6;
uint uVar7;
ulong uVar8;
uint *__s;
iVar6 = *(int *)((long)param_1 + 0x14) + (param_2 >> 5);
for (iVar3 = *(int *)((long)param_1 + 0xc); iVar3 <= iVar6; iVar3 = iVar3 * 2) {
}
puVar4 = (int8 *)Balloc();
__s = (uint *)*puVar4;
if (0x1f < param_2) {
uVar8 = (ulong)((param_2 >> 5) - 1);
memset(__s,0,uVar8 * 4 + 4);
__s = __s + uVar8 + 1;
}
puVar5 = (uint *)*param_1;
puVar1 = puVar5 + *(int *)((long)param_1 + 0x14);
if ((param_2 & 0x1f) == 0) {
do {
uVar7 = *puVar5;
puVar5 = puVar5 + 1;
*__s = uVar7;
__s = __s + 1;
} while (puVar5 < puVar1);
}
else {
sVar2 = (sbyte)(param_2 & 0x1f);
uVar7 = 0;
do {
*__s = *puVar5 << sVar2 | uVar7;
__s = __s + 1;
uVar7 = *puVar5;
puVar5 = puVar5 + 1;
uVar7 = uVar7 >> (0x20U - sVar2 & 0x1f);
} while (puVar5 < puVar1);
*__s = uVar7;
iVar6 = (iVar6 + 1) - (uint)(uVar7 == 0);
}
*(int *)((long)puVar4 + 0x14) = iVar6;
Bfree(param_1,param_3);
return puVar4;
}
| |
39,540 | Field_enum::eq_def(Field const*) const | eloqsql/sql/field.cc | bool Field_enum::eq_def(const Field *field) const
{
const TYPELIB *values;
if (!Field::eq_def(field))
return FALSE;
values= ((Field_enum*) field)->typelib;
/* Definition must be strictly equal. */
if (typelib->count != values->count)
return FALSE;
return compare_type_names(field_charset(), typelib, values);
} | O0 | cpp | Field_enum::eq_def(Field const*) const:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
callq 0xcf09b0
testb $0x1, %al
jne 0xcf0a7b
movb $0x0, -0x1(%rbp)
jmp 0xcf0aca
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0xe0(%rcx), %rcx
movq %rcx, -0x20(%rbp)
movq 0xe0(%rax), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0xcf0aa5
movb $0x0, -0x1(%rbp)
jmp 0xcf0aca
movq -0x28(%rbp), %rdi
callq 0xb40950
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0xe0(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xcf0ae0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZNK10Field_enum6eq_defEPK5Field:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]; this
mov [rbp+var_28], rdi
mov rsi, [rbp+var_18]; Field *
call _ZNK5Field6eq_defEPKS_; Field::eq_def(Field const*)
test al, 1
jnz short loc_CF0A7B
mov [rbp+var_1], 0
jmp short loc_CF0ACA
loc_CF0A7B:
mov rax, [rbp+var_28]
mov rcx, [rbp+var_18]
mov rcx, [rcx+0E0h]
mov [rbp+var_20], rcx
mov rax, [rax+0E0h]
mov eax, [rax]
mov rcx, [rbp+var_20]
cmp eax, [rcx]
jz short loc_CF0AA5
mov [rbp+var_1], 0
jmp short loc_CF0ACA
loc_CF0AA5:
mov rdi, [rbp+var_28]; this
call _ZNK9Field_str13field_charsetEv; Field_str::field_charset(void)
mov rdi, rax
mov rax, [rbp+var_28]
mov rsi, [rax+0E0h]
mov rdx, [rbp+var_20]
call _ZL18compare_type_namesPK15charset_info_stPK10st_typelibS4_; compare_type_names(charset_info_st const*,st_typelib const*,st_typelib const*)
and al, 1
mov [rbp+var_1], al
loc_CF0ACA:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
| char Field_enum::eq_def(Field_enum *this, const Field *a2)
{
long long v2; // rax
_DWORD *v4; // [rsp+10h] [rbp-20h]
if ( !Field::eq_def(this, a2) )
return 0;
v4 = (_DWORD *)*((_QWORD *)a2 + 28);
if ( **((_DWORD **)this + 28) != *v4 )
return 0;
v2 = Field_str::field_charset(this);
return compare_type_names(v2, *((_QWORD *)this + 28), v4) & 1;
}
| Item_func_min_max_val_str:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RSI,qword ptr [RBP + -0x10]
LEA RDI,[RBP + -0x40]
CALL 0x00ad3d40
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EDX,word ptr [RAX + 0xc]
LEA RDI,[RBP + -0x40]
CALL 0x00ad3fa0
ADD RSP,0x40
POP RBP
RET
|
/* Type_handler_datetime_common::Item_func_min_max_val_str(Item_func_min_max*, String*) const */
void __thiscall
Type_handler_datetime_common::Item_func_min_max_val_str
(Type_handler_datetime_common *this,Item_func_min_max *param_1,String *param_2)
{
Datetime local_48 [40];
String *local_20;
Item_func_min_max *local_18;
Type_handler_datetime_common *local_10;
local_20 = param_2;
local_18 = param_1;
local_10 = this;
::Datetime::Datetime(local_48,(Item *)param_1);
::Datetime::to_string(local_48,local_20,(uint)*(ushort *)(local_18 + 0xc));
return;
}
| |
39,541 | google::protobuf::HasSuffixString(google::protobuf::stringpiece_internal::StringPiece, google::protobuf::stringpiece_internal::StringPiece) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/strutil.h | inline bool HasSuffixString(StringPiece str, StringPiece suffix) {
return str.size() >= suffix.size() &&
memcmp(str.data() + str.size() - suffix.size(), suffix.data(),
suffix.size()) == 0;
} | O0 | c | google::protobuf::HasSuffixString(google::protobuf::stringpiece_internal::StringPiece, google::protobuf::stringpiece_internal::StringPiece):
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x29010
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x29010
movq 0x28(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x37(%rsp)
jb 0x28d61
leaq 0x48(%rsp), %rdi
callq 0x29020
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x29010
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x29010
movq %rax, %rdx
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x29020
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x29010
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0x21b80
cmpl $0x0, %eax
sete %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax)
| _ZN6google8protobuf15HasSuffixStringENS0_20stringpiece_internal11StringPieceES2_:
sub rsp, 58h
mov [rsp+58h+var_10], rdi
mov [rsp+58h+var_8], rsi
mov [rsp+58h+var_20], rdx
mov [rsp+58h+var_18], rcx
lea rdi, [rsp+58h+var_10]; this
call _ZNK6google8protobuf20stringpiece_internal11StringPiece4sizeEv; google::protobuf::stringpiece_internal::StringPiece::size(void)
mov [rsp+58h+var_30], rax
lea rdi, [rsp+58h+var_20]; this
call _ZNK6google8protobuf20stringpiece_internal11StringPiece4sizeEv; google::protobuf::stringpiece_internal::StringPiece::size(void)
mov rcx, [rsp+58h+var_30]
mov rdx, rax
xor eax, eax
cmp rcx, rdx
mov [rsp+58h+var_21], al
jb short loc_28D61
lea rdi, [rsp+58h+var_10]; this
call _ZNK6google8protobuf20stringpiece_internal11StringPiece4dataEv; google::protobuf::stringpiece_internal::StringPiece::data(void)
mov [rsp+58h+var_50], rax
lea rdi, [rsp+58h+var_10]; this
call _ZNK6google8protobuf20stringpiece_internal11StringPiece4sizeEv; google::protobuf::stringpiece_internal::StringPiece::size(void)
mov rcx, rax
mov rax, [rsp+58h+var_50]
add rax, rcx
mov [rsp+58h+var_48], rax
lea rdi, [rsp+58h+var_20]; this
call _ZNK6google8protobuf20stringpiece_internal11StringPiece4sizeEv; google::protobuf::stringpiece_internal::StringPiece::size(void)
mov rdx, rax
mov rax, [rsp+58h+var_48]
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rsp+58h+var_40], rax
lea rdi, [rsp+58h+var_20]; this
call _ZNK6google8protobuf20stringpiece_internal11StringPiece4dataEv; google::protobuf::stringpiece_internal::StringPiece::data(void)
mov [rsp+58h+var_38], rax
lea rdi, [rsp+58h+var_20]; this
call _ZNK6google8protobuf20stringpiece_internal11StringPiece4sizeEv; google::protobuf::stringpiece_internal::StringPiece::size(void)
mov rdi, [rsp+58h+var_40]
mov rsi, [rsp+58h+var_38]
mov rdx, rax
call _memcmp
cmp eax, 0
setz al
mov [rsp+58h+var_21], al
loc_28D61:
mov al, [rsp+58h+var_21]
and al, 1
add rsp, 58h
retn
| bool google::protobuf::HasSuffixString(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
long long v6; // [rsp+8h] [rbp-50h]
long long v7; // [rsp+10h] [rbp-48h]
long long v8; // [rsp+18h] [rbp-40h]
long long v9; // [rsp+20h] [rbp-38h]
unsigned long long v10; // [rsp+28h] [rbp-30h]
bool v11; // [rsp+37h] [rbp-21h]
_QWORD v12[2]; // [rsp+38h] [rbp-20h] BYREF
_QWORD v13[2]; // [rsp+48h] [rbp-10h] BYREF
v13[0] = a1;
v13[1] = a2;
v12[0] = a3;
v12[1] = a4;
v10 = google::protobuf::stringpiece_internal::StringPiece::size((google::protobuf::stringpiece_internal::StringPiece *)v13);
v11 = 0;
if ( v10 >= google::protobuf::stringpiece_internal::StringPiece::size((google::protobuf::stringpiece_internal::StringPiece *)v12) )
{
v6 = google::protobuf::stringpiece_internal::StringPiece::data((google::protobuf::stringpiece_internal::StringPiece *)v13);
v7 = google::protobuf::stringpiece_internal::StringPiece::size((google::protobuf::stringpiece_internal::StringPiece *)v13)
+ v6;
v8 = v7
- google::protobuf::stringpiece_internal::StringPiece::size((google::protobuf::stringpiece_internal::StringPiece *)v12);
v9 = google::protobuf::stringpiece_internal::StringPiece::data((google::protobuf::stringpiece_internal::StringPiece *)v12);
v4 = google::protobuf::stringpiece_internal::StringPiece::size((google::protobuf::stringpiece_internal::StringPiece *)v12);
return (unsigned int)memcmp(v8, v9, v4) == 0;
}
return v11;
}
| HasSuffixString:
SUB RSP,0x58
MOV qword ptr [RSP + 0x48],RDI
MOV qword ptr [RSP + 0x50],RSI
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x40],RCX
LEA RDI,[RSP + 0x48]
CALL 0x00129010
MOV qword ptr [RSP + 0x28],RAX
LEA RDI,[RSP + 0x38]
CALL 0x00129010
MOV RCX,qword ptr [RSP + 0x28]
MOV RDX,RAX
XOR EAX,EAX
CMP RCX,RDX
MOV byte ptr [RSP + 0x37],AL
JC 0x00128d61
LEA RDI,[RSP + 0x48]
CALL 0x00129020
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x48]
CALL 0x00129010
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,RCX
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0x38]
CALL 0x00129010
MOV RDX,RAX
MOV RAX,qword ptr [RSP + 0x10]
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RSP + 0x18],RAX
LEA RDI,[RSP + 0x38]
CALL 0x00129020
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[RSP + 0x38]
CALL 0x00129010
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,RAX
CALL 0x00121b80
CMP EAX,0x0
SETZ AL
MOV byte ptr [RSP + 0x37],AL
LAB_00128d61:
MOV AL,byte ptr [RSP + 0x37]
AND AL,0x1
ADD RSP,0x58
RET
|
/* google::protobuf::HasSuffixString(google::protobuf::stringpiece_internal::StringPiece,
google::protobuf::stringpiece_internal::StringPiece) */
int8
google::protobuf::HasSuffixString
(int8 param_1,int8 param_2,int8 param_3,int8 param_4)
{
int iVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
long lVar5;
long lVar6;
void *__s2;
size_t __n;
int4 extraout_var;
int7 uVar7;
bool local_21;
int8 local_20;
int8 local_18;
int8 local_10;
int8 local_8;
local_20 = param_3;
local_18 = param_4;
local_10 = param_1;
local_8 = param_2;
uVar2 = stringpiece_internal::StringPiece::size((StringPiece *)&local_10);
uVar3 = stringpiece_internal::StringPiece::size((StringPiece *)&local_20);
uVar7 = 0;
local_21 = false;
if (uVar3 <= uVar2) {
lVar4 = stringpiece_internal::StringPiece::data((StringPiece *)&local_10);
lVar5 = stringpiece_internal::StringPiece::size((StringPiece *)&local_10);
lVar6 = stringpiece_internal::StringPiece::size((StringPiece *)&local_20);
__s2 = (void *)stringpiece_internal::StringPiece::data((StringPiece *)&local_20);
__n = stringpiece_internal::StringPiece::size((StringPiece *)&local_20);
iVar1 = memcmp((void *)((lVar4 + lVar5) - lVar6),__s2,__n);
local_21 = iVar1 == 0;
uVar7 = (int7)(CONCAT44(extraout_var,iVar1) >> 8);
}
return CONCAT71(uVar7,local_21);
}
| |
39,542 | my_thread_global_reinit | eloqsql/mysys/my_thr_init.c | void my_thread_global_reinit(void)
{
struct st_my_thread_var *tmp;
DBUG_ASSERT(my_thread_global_init_done);
#ifdef HAVE_PSI_INTERFACE
my_init_mysys_psi_keys();
#endif
my_thread_destroy_common_mutex();
my_thread_init_common_mutex();
my_thread_destroy_internal_mutex();
my_thread_init_internal_mutex();
tmp= my_thread_var;
DBUG_ASSERT(tmp);
my_thread_destory_thr_mutex(tmp);
my_thread_init_thr_mutex(tmp);
} | O0 | c | my_thread_global_reinit:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xfc03a
callq 0xf8ea0
callq 0xfbee0
callq 0xfc080
callq 0xfbf90
callq 0xfc150
callq 0xfc1b0
movq %rax, -0x8(%rbp)
jmp 0xfc05e
movq -0x8(%rbp), %rdi
callq 0xfc1d0
movq -0x8(%rbp), %rdi
callq 0xfc200
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_thread_global_reinit:
push rbp
mov rbp, rsp
sub rsp, 10h
jmp short $+2
loc_FC03A:
call my_init_mysys_psi_keys
call my_thread_destroy_common_mutex
call my_thread_init_common_mutex
call my_thread_destroy_internal_mutex
call my_thread_init_internal_mutex
call _my_thread_var
mov [rbp+var_8], rax
jmp short $+2
loc_FC05E:
mov rdi, [rbp+var_8]
call my_thread_destory_thr_mutex
mov rdi, [rbp+var_8]
call my_thread_init_thr_mutex
add rsp, 10h
pop rbp
retn
| long long my_thread_global_reinit(long long a1, const char *a2)
{
long long v3; // [rsp+8h] [rbp-8h]
my_init_mysys_psi_keys();
my_thread_destroy_common_mutex();
my_thread_init_common_mutex();
my_thread_destroy_internal_mutex();
my_thread_init_internal_mutex();
v3 = my_thread_var(a1, a2);
my_thread_destory_thr_mutex(v3);
return my_thread_init_thr_mutex(v3);
}
| my_thread_global_reinit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
JMP 0x001fc03a
LAB_001fc03a:
CALL 0x001f8ea0
CALL 0x001fbee0
CALL 0x001fc080
CALL 0x001fbf90
CALL 0x001fc150
CALL 0x001fc1b0
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001fc05e
LAB_001fc05e:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001fc1d0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001fc200
ADD RSP,0x10
POP RBP
RET
|
void my_thread_global_reinit(void)
{
int8 uVar1;
my_init_mysys_psi_keys();
my_thread_destroy_common_mutex();
my_thread_init_common_mutex();
my_thread_destroy_internal_mutex();
my_thread_init_internal_mutex();
uVar1 = _my_thread_var();
my_thread_destory_thr_mutex(uVar1);
my_thread_init_thr_mutex(uVar1);
return;
}
| |
39,543 | testing::TestPartResult::~TestPartResult() | AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/gtest-test-part.h | class GTEST_API_ TestPartResult {
public:
// The possible outcomes of a test part (i.e. an assertion or an
// explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
enum Type {
kSuccess, // Succeeded.
kNonFatalFailure, // Failed but the test can continue.
kFatalFailure, // Failed and the test should be terminated.
kSkip // Skipped.
};
// C'tor. TestPartResult does NOT have a default constructor.
// Always use this constructor (with parameters) to create a
// TestPartResult object.
TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
const char* a_message)
: type_(a_type),
file_name_(a_file_name == nullptr ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
message_(a_message) {}
// Gets the outcome of the test part.
Type type() const { return type_; }
// Gets the name of the source file where the test part took place, or
// NULL if it's unknown.
const char* file_name() const {
return file_name_.empty() ? nullptr : file_name_.c_str();
}
// Gets the line in the source file where the test part took place,
// or -1 if it's unknown.
int line_number() const { return line_number_; }
// Gets the summary of the failure message.
const char* summary() const { return summary_.c_str(); }
// Gets the message associated with the test part.
const char* message() const { return message_.c_str(); }
// Returns true if and only if the test part was skipped.
bool skipped() const { return type_ == kSkip; }
// Returns true if and only if the test part passed.
bool passed() const { return type_ == kSuccess; }
// Returns true if and only if the test part non-fatally failed.
bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
// Returns true if and only if the test part fatally failed.
bool fatally_failed() const { return type_ == kFatalFailure; }
// Returns true if and only if the test part failed.
bool failed() const { return fatally_failed() || nonfatally_failed(); }
private:
Type type_;
// Gets the summary of the failure message by omitting the stack
// trace in it.
static std::string ExtractSummary(const char* message);
// The name of the source file where the test part took place, or
// "" if the source file is unknown.
std::string file_name_;
// The line in the source file where the test part took place, or -1
// if the line number is unknown.
int line_number_;
std::string summary_; // The test failure summary.
std::string message_; // The test failure message.
} | O0 | c | testing::TestPartResult::~TestPartResult():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x50, %rdi
callq 0xec60
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0xec60
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xec60
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN7testing14TestPartResultD2Ev:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rdi, [rsp+18h+var_8]
mov [rsp+18h+var_10], rdi
add rdi, 50h ; 'P'; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+18h+var_10]
add rdi, 30h ; '0'; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+18h+var_10]
add rdi, 8; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add rsp, 18h
retn
| void testing::TestPartResult::~TestPartResult(testing::TestPartResult *this)
{
std::string::~string((char *)this + 80);
std::string::~string((char *)this + 48);
std::string::~string((char *)this + 8);
}
| ~TestPartResult:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
ADD RDI,0x50
CALL 0x0010ec60
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x30
CALL 0x0010ec60
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x8
CALL 0x0010ec60
ADD RSP,0x18
RET
|
/* testing::TestPartResult::~TestPartResult() */
void __thiscall testing::TestPartResult::~TestPartResult(TestPartResult *this)
{
std::__cxx11::string::~string((string *)(this + 0x50));
std::__cxx11::string::~string((string *)(this + 0x30));
std::__cxx11::string::~string((string *)(this + 8));
return;
}
| |
39,544 | minja::MacroTemplateToken::MacroTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::VariableExpr>&&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>>>&&) | monkey531[P]llama/common/minja.hpp | TemplateToken(Type type, const Location & location, SpaceHandling pre, SpaceHandling post) : type(type), location(location), pre_space(pre), post_space(post) {} | O3 | cpp | minja::MacroTemplateToken::MacroTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::VariableExpr>&&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>>>&&):
leaq 0x90ad9(%rip), %rax # 0x12c2e8
addq $0x10, %rax
movq %rax, (%rdi)
movl $0xf, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rdi)
testq %rax, %rax
je 0x9b847
movq 0x92748(%rip), %r9 # 0x12df80
cmpb $0x0, (%r9)
je 0x9b843
incl 0x8(%rax)
jmp 0x9b847
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rdi)
movl %edx, 0x28(%rdi)
movl %ecx, 0x2c(%rdi)
leaq 0x915ec(%rip), %rax # 0x12ce48
addq $0x10, %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x38(%rdi)
movups (%r8), %xmm0
movq %rax, 0x8(%r8)
movups %xmm0, 0x30(%rdi)
movq %rax, (%r8)
retq
nop
| _ZN5minja19FilterTemplateTokenC2ERKNS_8LocationENS_13SpaceHandlingES4_OSt10shared_ptrINS_10ExpressionEE:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rdi], rax
mov dword ptr [rdi+8], 0Fh
mov rax, [rsi]
mov [rdi+10h], rax
mov rax, [rsi+8]
mov [rdi+18h], rax
test rax, rax
jz short loc_9B847
mov r9, cs:__libc_single_threaded_ptr
cmp byte ptr [r9], 0
jz short loc_9B843
inc dword ptr [rax+8]
jmp short loc_9B847
loc_9B843:
lock inc dword ptr [rax+8]
loc_9B847:
mov rax, [rsi+10h]
mov [rdi+20h], rax
mov [rdi+28h], edx
mov [rdi+2Ch], ecx
lea rax, _ZTVN5minja19FilterTemplateTokenE; `vtable for'minja::FilterTemplateToken
add rax, 10h
mov [rdi], rax
xor eax, eax
mov [rdi+38h], rax
movups xmm0, xmmword ptr [r8]
mov [r8+8], rax
movups xmmword ptr [rdi+30h], xmm0
mov [r8], rax
retn
| long long minja::FilterTemplateToken::FilterTemplateToken(
long long a1,
_QWORD *a2,
int a3,
int a4,
__int128 *a5)
{
long long v5; // rax
long long result; // rax
__int128 v7; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::TemplateToken + 2;
*(_DWORD *)(a1 + 8) = 15;
*(_QWORD *)(a1 + 16) = *a2;
v5 = a2[1];
*(_QWORD *)(a1 + 24) = v5;
if ( v5 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v5 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v5 + 8));
}
*(_QWORD *)(a1 + 32) = a2[2];
*(_DWORD *)(a1 + 40) = a3;
*(_DWORD *)(a1 + 44) = a4;
*(_QWORD *)a1 = &`vtable for'minja::FilterTemplateToken + 2;
result = 0LL;
*(_QWORD *)(a1 + 56) = 0LL;
v7 = *a5;
*((_QWORD *)a5 + 1) = 0LL;
*(_OWORD *)(a1 + 48) = v7;
*(_QWORD *)a5 = 0LL;
return result;
}
| FilterTemplateToken:
LEA RAX,[0x22c2e8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV dword ptr [RDI + 0x8],0xf
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x18],RAX
TEST RAX,RAX
JZ 0x0019b847
MOV R9,qword ptr [0x0022df80]
CMP byte ptr [R9],0x0
JZ 0x0019b843
INC dword ptr [RAX + 0x8]
JMP 0x0019b847
LAB_0019b843:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0019b847:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x20],RAX
MOV dword ptr [RDI + 0x28],EDX
MOV dword ptr [RDI + 0x2c],ECX
LEA RAX,[0x22ce48]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x38],RAX
MOVUPS XMM0,xmmword ptr [R8]
MOV qword ptr [R8 + 0x8],RAX
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOV qword ptr [R8],RAX
RET
|
/* minja::FilterTemplateToken::FilterTemplateToken(minja::Location const&, minja::SpaceHandling,
minja::SpaceHandling, std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::FilterTemplateToken::FilterTemplateToken
(FilterTemplateToken *this,int8 *param_1,int4 param_3,int4 param_4,
int8 *param_5)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR__TemplateToken_0022c2f8;
*(int4 *)(this + 8) = 0xf;
*(int8 *)(this + 0x10) = *param_1;
lVar1 = param_1[1];
*(long *)(this + 0x18) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_0022df80 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x20) = param_1[2];
*(int4 *)(this + 0x28) = param_3;
*(int4 *)(this + 0x2c) = param_4;
*(int ***)this = &PTR__FilterTemplateToken_0022ce58;
*(int8 *)(this + 0x38) = 0;
uVar2 = param_5[1];
param_5[1] = 0;
*(int8 *)(this + 0x30) = *param_5;
*(int8 *)(this + 0x38) = uVar2;
*param_5 = 0;
return;
}
| |
39,545 | common_kv_cache_dump_view(llama_kv_cache_view const&, int) | monkey531[P]llama/common/common.cpp | void common_kv_cache_dump_view(const llama_kv_cache_view & view, int row_size) {
static const char slot_chars[] = ".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+";
printf("=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, largest empty slot=%d @ %d",
view.n_cells, view.n_seq_max, view.used_cells, view.token_count, view.max_contiguous, view.max_contiguous_idx);
llama_kv_cache_view_cell * c_curr = view.cells;
llama_seq_id * cs_curr = view.cells_sequences;
for (int i = 0; i < view.n_cells; i++, c_curr++, cs_curr += view.n_seq_max) {
if (i % row_size == 0) {
printf("\n%5d: ", i);
}
int seq_count = 0;
for (int j = 0; j < view.n_seq_max; j++) {
if (cs_curr[j] >= 0) { seq_count++; }
}
putchar(slot_chars[std::min(sizeof(slot_chars) - 2, size_t(seq_count))]);
}
printf("\n=== Done dumping\n");
} | O1 | cpp | common_kv_cache_dump_view(llama_kv_cache_view const&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %esi
movl 0x4(%rdi), %edx
movl 0xc(%rdi), %ecx
movl 0x8(%rdi), %r8d
movl 0x10(%rdi), %r9d
movl 0x14(%rdi), %eax
movl %eax, (%rsp)
leaq 0x7c5fc(%rip), %rdi # 0xf334b
xorl %eax, %eax
callq 0x1b070
cmpl $0x0, (%r14)
jle 0x76dcc
movq 0x20(%r14), %r12
movl $0x3e, %r13d
leaq 0x7eb33(%rip), %r15 # 0xf58a0
xorl %ebp, %ebp
movl %ebp, %eax
cltd
idivl %ebx
testl %edx, %edx
jne 0x76d88
leaq 0x7c656(%rip), %rdi # 0xf33d5
movl %ebp, %esi
xorl %eax, %eax
callq 0x1b070
movslq 0x4(%r14), %rcx
testq %rcx, %rcx
jle 0x76daa
xorl %edx, %edx
xorl %eax, %eax
movl (%r12,%rdx,4), %esi
notl %esi
shrl $0x1f, %esi
addl %esi, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x76d95
jmp 0x76dac
xorl %eax, %eax
cmpl $0x3e, %eax
cmovael %r13d, %eax
movsbl (%rax,%r15), %edi
callq 0x1bc00
incl %ebp
movslq 0x4(%r14), %rax
leaq (%r12,%rax,4), %r12
cmpl (%r14), %ebp
jl 0x76d6f
leaq 0x7eab9(%rip), %rdi # 0xf588c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1bd40
| _Z25common_kv_cache_dump_viewRK19llama_kv_cache_viewi:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, esi
mov r14, rdi
mov esi, [rdi]
mov edx, [rdi+4]
mov ecx, [rdi+0Ch]
mov r8d, [rdi+8]
mov r9d, [rdi+10h]
mov eax, [rdi+14h]
mov [rsp+38h+var_38], eax
lea rdi, aDumpingKvCache; "=== Dumping KV cache. total cells %d, m"...
xor eax, eax
call _printf
cmp dword ptr [r14], 0
jle short loc_76DCC
mov r12, [r14+20h]
mov r13d, 3Eh ; '>'
lea r15, _ZZ25common_kv_cache_dump_viewRK19llama_kv_cache_viewiE10slot_chars; ".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabc"...
xor ebp, ebp
loc_76D6F:
mov eax, ebp
cdq
idiv ebx
test edx, edx
jnz short loc_76D88
lea rdi, a5d; "\n%5d: "
mov esi, ebp
xor eax, eax
call _printf
loc_76D88:
movsxd rcx, dword ptr [r14+4]
test rcx, rcx
jle short loc_76DAA
xor edx, edx
xor eax, eax
loc_76D95:
mov esi, [r12+rdx*4]
not esi
shr esi, 1Fh
add eax, esi
inc rdx
cmp rcx, rdx
jnz short loc_76D95
jmp short loc_76DAC
loc_76DAA:
xor eax, eax
loc_76DAC:
cmp eax, 3Eh ; '>'
cmovnb eax, r13d
movsx edi, byte ptr [rax+r15]
call _putchar
inc ebp
movsxd rax, dword ptr [r14+4]
lea r12, [r12+rax*4]
cmp ebp, [r14]
jl short loc_76D6F
loc_76DCC:
lea rdi, aDoneDumping; "\n=== Done dumping"
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _puts
| long long common_kv_cache_dump_view(long long a1, int a2)
{
long long v2; // r12
int v3; // ebp
long long v4; // rcx
long long v5; // rdx
long long v6; // rax
printf(
"=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, large"
"st empty slot=%d @ %d",
*(_DWORD *)a1,
*(_DWORD *)(a1 + 4),
*(_DWORD *)(a1 + 12),
*(_DWORD *)(a1 + 8),
*(_DWORD *)(a1 + 16),
*(_DWORD *)(a1 + 20));
if ( *(int *)a1 > 0 )
{
v2 = *(_QWORD *)(a1 + 32);
v3 = 0;
do
{
if ( !(v3 % a2) )
printf("\n%5d: ", v3);
v4 = *(int *)(a1 + 4);
if ( v4 <= 0 )
{
v6 = 0LL;
}
else
{
v5 = 0LL;
LODWORD(v6) = 0;
do
v6 = (*(_DWORD *)(v2 + 4 * v5++) >= 0) + (unsigned int)v6;
while ( v4 != v5 );
}
if ( (unsigned int)v6 >= 0x3E )
v6 = 62LL;
putchar((unsigned int)common_kv_cache_dump_view(llama_kv_cache_view const&,int)::slot_chars[v6]);
++v3;
v2 += 4LL * *(int *)(a1 + 4);
}
while ( v3 < *(_DWORD *)a1 );
}
return puts("\n=== Done dumping");
}
| |||
39,546 | common_kv_cache_dump_view(llama_kv_cache_view const&, int) | monkey531[P]llama/common/common.cpp | void common_kv_cache_dump_view(const llama_kv_cache_view & view, int row_size) {
static const char slot_chars[] = ".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+";
printf("=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, largest empty slot=%d @ %d",
view.n_cells, view.n_seq_max, view.used_cells, view.token_count, view.max_contiguous, view.max_contiguous_idx);
llama_kv_cache_view_cell * c_curr = view.cells;
llama_seq_id * cs_curr = view.cells_sequences;
for (int i = 0; i < view.n_cells; i++, c_curr++, cs_curr += view.n_seq_max) {
if (i % row_size == 0) {
printf("\n%5d: ", i);
}
int seq_count = 0;
for (int j = 0; j < view.n_seq_max; j++) {
if (cs_curr[j] >= 0) { seq_count++; }
}
putchar(slot_chars[std::min(sizeof(slot_chars) - 2, size_t(seq_count))]);
}
printf("\n=== Done dumping\n");
} | O2 | cpp | common_kv_cache_dump_view(llama_kv_cache_view const&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %esi
movl 0x4(%rdi), %edx
movl 0xc(%rdi), %ecx
movl 0x8(%rdi), %r8d
movl 0x10(%rdi), %r9d
movl 0x14(%rdi), %eax
movl %eax, (%rsp)
leaq 0x5d8eb(%rip), %rdi # 0xb532b
xorl %eax, %eax
callq 0x24060
movq 0x20(%r14), %r12
pushq $0x3e
popq %r13
leaq 0x5fe2a(%rip), %r15 # 0xb7880
xorl %ebp, %ebp
cmpl (%r14), %ebp
jge 0x57ab5
movl %ebp, %eax
cltd
idivl %ebx
testl %edx, %edx
jne 0x57a76
leaq 0x5d948(%rip), %rdi # 0xb53b5
movl %ebp, %esi
xorl %eax, %eax
callq 0x24060
movl 0x4(%r14), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
cmpq %rcx, %rax
je 0x57a98
movl (%r12,%rcx,4), %esi
notl %esi
shrl $0x1f, %esi
addl %esi, %edx
incq %rcx
jmp 0x57a83
cmpl $0x3e, %edx
cmovael %r13d, %edx
movsbl (%rdx,%r15), %edi
callq 0x24c20
incl %ebp
movslq 0x4(%r14), %rax
leaq (%r12,%rax,4), %r12
jmp 0x57a58
leaq 0x5fda8(%rip), %rdi # 0xb7864
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24d50
| _Z25common_kv_cache_dump_viewRK19llama_kv_cache_viewi:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, esi
mov r14, rdi
mov esi, [rdi]
mov edx, [rdi+4]
mov ecx, [rdi+0Ch]
mov r8d, [rdi+8]
mov r9d, [rdi+10h]
mov eax, [rdi+14h]
mov [rsp+38h+var_38], eax
lea rdi, aDumpingKvCache; "=== Dumping KV cache. total cells %d, m"...
xor eax, eax
call _printf
mov r12, [r14+20h]
push 3Eh ; '>'
pop r13
lea r15, _ZZ25common_kv_cache_dump_viewRK19llama_kv_cache_viewiE10slot_chars; ".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabc"...
xor ebp, ebp
loc_57A58:
cmp ebp, [r14]
jge short loc_57AB5
mov eax, ebp
cdq
idiv ebx
test edx, edx
jnz short loc_57A76
lea rdi, a5d; "\n%5d: "
mov esi, ebp
xor eax, eax
call _printf
loc_57A76:
mov eax, [r14+4]
xor ecx, ecx
test eax, eax
cmovle eax, ecx
xor edx, edx
loc_57A83:
cmp rax, rcx
jz short loc_57A98
mov esi, [r12+rcx*4]
not esi
shr esi, 1Fh
add edx, esi
inc rcx
jmp short loc_57A83
loc_57A98:
cmp edx, 3Eh ; '>'
cmovnb edx, r13d
movsx edi, byte ptr [rdx+r15]
call _putchar
inc ebp
movsxd rax, dword ptr [r14+4]
lea r12, [r12+rax*4]
jmp short loc_57A58
loc_57AB5:
lea rdi, aDoneDumping; "\n=== Done dumping"
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _puts
| long long common_kv_cache_dump_view(long long a1, int a2)
{
long long v2; // r12
int i; // ebp
long long v4; // rax
long long v5; // rcx
long long v6; // rdx
printf(
"=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, large"
"st empty slot=%d @ %d",
*(_DWORD *)a1,
*(_DWORD *)(a1 + 4),
*(_DWORD *)(a1 + 12),
*(_DWORD *)(a1 + 8),
*(_DWORD *)(a1 + 16),
*(_DWORD *)(a1 + 20));
v2 = *(_QWORD *)(a1 + 32);
for ( i = 0; i < *(_DWORD *)a1; ++i )
{
if ( !(i % a2) )
printf("\n%5d: ", i);
v4 = *(unsigned int *)(a1 + 4);
v5 = 0LL;
if ( (int)v4 <= 0 )
v4 = 0LL;
v6 = 0LL;
while ( v4 != v5 )
v6 = (*(_DWORD *)(v2 + 4 * v5++) >= 0) + (unsigned int)v6;
if ( (unsigned int)v6 >= 0x3E )
v6 = 62LL;
putchar((unsigned int)common_kv_cache_dump_view(llama_kv_cache_view const&,int)::slot_chars[v6]);
v2 += 4LL * *(int *)(a1 + 4);
}
return puts("\n=== Done dumping");
}
| common_kv_cache_dump_view:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
MOV ESI,dword ptr [RDI]
MOV EDX,dword ptr [RDI + 0x4]
MOV ECX,dword ptr [RDI + 0xc]
MOV R8D,dword ptr [RDI + 0x8]
MOV R9D,dword ptr [RDI + 0x10]
MOV EAX,dword ptr [RDI + 0x14]
MOV dword ptr [RSP],EAX
LEA RDI,[0x1b532b]
XOR EAX,EAX
CALL 0x00124060
MOV R12,qword ptr [R14 + 0x20]
PUSH 0x3e
POP R13
LEA R15,[0x1b7880]
XOR EBP,EBP
LAB_00157a58:
CMP EBP,dword ptr [R14]
JGE 0x00157ab5
MOV EAX,EBP
CDQ
IDIV EBX
TEST EDX,EDX
JNZ 0x00157a76
LEA RDI,[0x1b53b5]
MOV ESI,EBP
XOR EAX,EAX
CALL 0x00124060
LAB_00157a76:
MOV EAX,dword ptr [R14 + 0x4]
XOR ECX,ECX
TEST EAX,EAX
CMOVLE EAX,ECX
XOR EDX,EDX
LAB_00157a83:
CMP RAX,RCX
JZ 0x00157a98
MOV ESI,dword ptr [R12 + RCX*0x4]
NOT ESI
SHR ESI,0x1f
ADD EDX,ESI
INC RCX
JMP 0x00157a83
LAB_00157a98:
CMP EDX,0x3e
CMOVNC EDX,R13D
MOVSX EDI,byte ptr [RDX + R15*0x1]
CALL 0x00124c20
INC EBP
MOVSXD RAX,dword ptr [R14 + 0x4]
LEA R12,[R12 + RAX*0x4]
JMP 0x00157a58
LAB_00157ab5:
LEA RDI,[0x1b7864]
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00124d50
|
/* common_kv_cache_dump_view(llama_kv_cache_view const&, int) */
void common_kv_cache_dump_view(llama_kv_cache_view *param_1,int param_2)
{
int8 in_RAX;
ulong uVar1;
uint uVar2;
ulong uVar3;
uint uVar4;
long lVar5;
printf("=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, largest empty slot=%d @ %d"
,(ulong)*(uint *)param_1,(ulong)*(uint *)(param_1 + 4),(ulong)*(uint *)(param_1 + 0xc),
(ulong)*(uint *)(param_1 + 8),(ulong)*(uint *)(param_1 + 0x10),
CONCAT44((int)((ulong)in_RAX >> 0x20),*(int4 *)(param_1 + 0x14)));
lVar5 = *(long *)(param_1 + 0x20);
for (uVar4 = 0; (int)uVar4 < *(int *)param_1; uVar4 = uVar4 + 1) {
if ((int)uVar4 % param_2 == 0) {
printf("\n%5d: ",(ulong)uVar4);
}
uVar1 = 0;
uVar3 = (ulong)*(uint *)(param_1 + 4);
if ((int)*(uint *)(param_1 + 4) < 1) {
uVar3 = uVar1;
}
uVar2 = 0;
for (; uVar3 != uVar1; uVar1 = uVar1 + 1) {
uVar2 = uVar2 - ((int)~*(uint *)(lVar5 + uVar1 * 4) >> 0x1f);
}
uVar3 = (ulong)uVar2;
if (0x3d < uVar2) {
uVar3 = 0x3e;
}
putchar((int)".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+"[uVar3]);
lVar5 = lVar5 + (long)*(int *)(param_1 + 4) * 4;
}
puts("\n=== Done dumping");
return;
}
| |
39,547 | nglog::NullStream::~NullStream() | ng-log[P]ng-log/src/ng-log/logging.h | class NGLOG_EXPORT NullStream : public LogMessage::LogStream {
public:
// Initialize the LogStream so the messages can be written somewhere
// (they'll never be actually displayed). This will be needed if a
// NullStream& is implicitly converted to LogStream&, in which case
// the overloaded NullStream::operator<< will not be invoked.
NullStream();
NullStream(const char* /*file*/, int /*line*/,
const internal::CheckOpString& /*result*/);
NullStream& stream();
private:
// A very short buffer for messages (which we discard anyway). This
// will be needed if NullStream& converted to LogStream& (e.g. as a
// result of a conditional expression).
char message_buffer_[3];
} | O0 | c | nglog::NullStream::~NullStream():
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
popq %rbp
jmp 0x20570
nopl (%rax)
| _ZTv0_n24_N5nglog10NullStreamD0Ev:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
mov rax, [rdi]
mov rax, [rax-18h]
add rdi, rax; this
pop rbp
jmp _ZN5nglog10NullStreamD0Ev; nglog::NullStream::~NullStream()
| void `virtual thunk to'nglog::NullStream::~NullStream(nglog::NullStream *this)
{
nglog::NullStream::~NullStream((nglog::NullStream *)((char *)this + *(_QWORD *)(*(_QWORD *)this - 24LL)));
}
| ~NullStream:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
ADD RDI,RAX
POP RBP
JMP 0x00120570
|
/* virtual thunk to nglog::NullStream::~NullStream() */
void __thiscall nglog::NullStream::~NullStream(NullStream *this)
{
~NullStream(this + *(long *)(*(long *)this + -0x18));
return;
}
| |
39,548 | nglog::NullStream::~NullStream() | ng-log[P]ng-log/src/ng-log/logging.h | class NGLOG_EXPORT NullStream : public LogMessage::LogStream {
public:
// Initialize the LogStream so the messages can be written somewhere
// (they'll never be actually displayed). This will be needed if a
// NullStream& is implicitly converted to LogStream&, in which case
// the overloaded NullStream::operator<< will not be invoked.
NullStream();
NullStream(const char* /*file*/, int /*line*/,
const internal::CheckOpString& /*result*/);
NullStream& stream();
private:
// A very short buffer for messages (which we discard anyway). This
// will be needed if NullStream& converted to LogStream& (e.g. as a
// result of a conditional expression).
char message_buffer_[3];
} | O1 | c | nglog::NullStream::~NullStream():
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq -0x18(%rax), %rax
leaq (%rdi,%rax), %rbx
leaq 0x1e5e2(%rip), %rcx # 0x31888
leaq 0x18(%rcx), %rdx
leaq (%rdi,%rax), %r14
addq $0x60, %r14
movq %rdx, -0x60(%r14)
addq $0x40, %rcx
movq %rcx, (%r14)
movq 0x1ec64(%rip), %rcx # 0x31f28
addq $0x10, %rcx
movq %rcx, -0x58(%r14)
addq %rax, %rdi
addq $0x40, %rdi
callq 0x7760
movq %r14, %rdi
callq 0x7160
movl $0x168, %esi # imm = 0x168
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x900c
| _ZTv0_n24_N5nglog10NullStreamD0Ev:
push r14
push rbx
push rax
mov rax, [rdi]
mov rax, [rax-18h]
lea rbx, [rdi+rax]
lea rcx, _ZTCN5nglog10NullStreamE0_NS_10LogMessage9LogStreamE; `construction vtable for'nglog::LogMessage::LogStream-in-nglog::NullStream
lea rdx, [rcx+18h]
lea r14, [rdi+rax]
add r14, 60h ; '`'
mov [r14-60h], rdx
add rcx, 40h ; '@'
mov [r14], rcx
mov rcx, cs:_ZTVSt15basic_streambufIcSt11char_traitsIcEE_ptr
add rcx, 10h
mov [r14-58h], rcx
add rdi, rax
add rdi, 40h ; '@'; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rdi, r14; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov esi, 168h; unsigned __int64
mov rdi, rbx; void *
add rsp, 8
pop rbx
pop r14
jmp _ZdlPvm; operator delete(void *,ulong)
| void `virtual thunk to'nglog::NullStream::~NullStream(nglog::NullStream *this)
{
_QWORD *v1; // rbx
v1 = (_QWORD *)((char *)this + *(_QWORD *)(*(_QWORD *)this - 24LL));
*v1 = (char *)&`construction vtable for'nglog::LogMessage::LogStream-in-nglog::NullStream + 24;
v1[12] = (char *)&`construction vtable for'nglog::LogMessage::LogStream-in-nglog::NullStream + 64;
v1[1] = (char *)&`vtable for'std::streambuf + 16;
std::locale::~locale((std::locale *)(v1 + 8));
std::ios_base::~ios_base((std::ios_base *)(v1 + 12));
operator delete(v1);
}
| ~NullStream:
PUSH R14
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
LEA RBX,[RDI + RAX*0x1]
LEA RCX,[0x131888]
LEA RDX,[RCX + 0x18]
LEA R14,[RDI + RAX*0x1]
ADD R14,0x60
MOV qword ptr [R14 + -0x60],RDX
ADD RCX,0x40
MOV qword ptr [R14],RCX
MOV RCX,qword ptr [0x00131f28]
ADD RCX,0x10
MOV qword ptr [R14 + -0x58],RCX
ADD RDI,RAX
ADD RDI,0x40
CALL 0x00107760
MOV RDI,R14
CALL 0x00107160
MOV ESI,0x168
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0010900c
|
/* virtual thunk to nglog::NullStream::~NullStream() */
void __thiscall nglog::NullStream::~NullStream(NullStream *this)
{
NullStream *pNVar1;
long lVar2;
lVar2 = *(long *)(*(long *)this + -0x18);
pNVar1 = this + lVar2;
*(int8 *)pNVar1 = 0x1318a0;
*(int8 *)(pNVar1 + 0x60) = 0x1318c8;
*(int **)(pNVar1 + 8) = PTR_vtable_00131f28 + 0x10;
std::locale::~locale((locale *)(this + lVar2 + 0x40));
std::ios_base::~ios_base((ios_base *)(pNVar1 + 0x60));
operator_delete(this + lVar2,0x168);
return;
}
| |
39,549 | nglog::NullStream::~NullStream() | ng-log[P]ng-log/src/ng-log/logging.h | class NGLOG_EXPORT NullStream : public LogMessage::LogStream {
public:
// Initialize the LogStream so the messages can be written somewhere
// (they'll never be actually displayed). This will be needed if a
// NullStream& is implicitly converted to LogStream&, in which case
// the overloaded NullStream::operator<< will not be invoked.
NullStream();
NullStream(const char* /*file*/, int /*line*/,
const internal::CheckOpString& /*result*/);
NullStream& stream();
private:
// A very short buffer for messages (which we discard anyway). This
// will be needed if NullStream& converted to LogStream& (e.g. as a
// result of a conditional expression).
char message_buffer_[3];
} | O2 | c | nglog::NullStream::~NullStream():
pushq %rbx
movq %rdi, %rbx
leaq 0x1f565(%rip), %rsi # 0x2f890
addq $0x8, %rsi
callq 0xaa80
addq $0x60, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x7180
nop
| _ZN5nglog10NullStreamD1Ev:
push rbx
mov rbx, rdi
lea rsi, _ZTTN5nglog10NullStreamE; `VTT for'nglog::NullStream
add rsi, 8
call _ZN5nglog10LogMessage9LogStreamD2Ev; nglog::LogMessage::LogStream::~LogStream()
add rbx, 60h ; '`'
mov rdi, rbx; this
pop rbx
jmp __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
| void nglog::NullStream::~NullStream(nglog::NullStream *this)
{
nglog::LogMessage::LogStream::~LogStream(this, (long long *)&`VTT for'nglog::NullStream[1]);
std::ios_base::~ios_base((nglog::NullStream *)((char *)this + 96));
}
| ~NullStream:
PUSH RBX
MOV RBX,RDI
LEA RSI,[0x12f890]
ADD RSI,0x8
CALL 0x0010aa80
ADD RBX,0x60
MOV RDI,RBX
POP RBX
JMP 0x00107180
|
/* nglog::NullStream::~NullStream() */
void __thiscall nglog::NullStream::~NullStream(NullStream *this)
{
LogMessage::LogStream::~LogStream((LogStream *)this);
std::ios_base::~ios_base((ios_base *)(this + 0x60));
return;
}
| |
39,550 | nglog::NullStream::~NullStream() | ng-log[P]ng-log/src/ng-log/logging.h | class NGLOG_EXPORT NullStream : public LogMessage::LogStream {
public:
// Initialize the LogStream so the messages can be written somewhere
// (they'll never be actually displayed). This will be needed if a
// NullStream& is implicitly converted to LogStream&, in which case
// the overloaded NullStream::operator<< will not be invoked.
NullStream();
NullStream(const char* /*file*/, int /*line*/,
const internal::CheckOpString& /*result*/);
NullStream& stream();
private:
// A very short buffer for messages (which we discard anyway). This
// will be needed if NullStream& converted to LogStream& (e.g. as a
// result of a conditional expression).
char message_buffer_[3];
} | O3 | c | nglog::NullStream::~NullStream():
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq -0x18(%rax), %rax
leaq (%rdi,%rax), %rbx
leaq 0x1ea14(%rip), %rcx # 0x318c8
leaq 0x18(%rcx), %rdx
leaq (%rdi,%rax), %r14
addq $0x60, %r14
movq %rdx, -0x60(%r14)
addq $0x40, %rcx
movq %rcx, (%r14)
movq 0x1f056(%rip), %rcx # 0x31f28
addq $0x10, %rcx
movq %rcx, -0x58(%r14)
addq %rax, %rdi
addq $0x40, %rdi
callq 0x7760
movq %r14, %rdi
callq 0x7160
movl $0x168, %esi # imm = 0x168
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8edc
| _ZTv0_n24_N5nglog10NullStreamD0Ev:
push r14
push rbx
push rax
mov rax, [rdi]
mov rax, [rax-18h]
lea rbx, [rdi+rax]
lea rcx, _ZTCN5nglog10NullStreamE0_NS_10LogMessage9LogStreamE; `construction vtable for'nglog::LogMessage::LogStream-in-nglog::NullStream
lea rdx, [rcx+18h]
lea r14, [rdi+rax]
add r14, 60h ; '`'
mov [r14-60h], rdx
add rcx, 40h ; '@'
mov [r14], rcx
mov rcx, cs:_ZTVSt15basic_streambufIcSt11char_traitsIcEE_ptr
add rcx, 10h
mov [r14-58h], rcx
add rdi, rax
add rdi, 40h ; '@'; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rdi, r14; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov esi, 168h; unsigned __int64
mov rdi, rbx; void *
add rsp, 8
pop rbx
pop r14
jmp _ZdlPvm; operator delete(void *,ulong)
| void `virtual thunk to'nglog::NullStream::~NullStream(nglog::NullStream *this)
{
_QWORD *v1; // rbx
v1 = (_QWORD *)((char *)this + *(_QWORD *)(*(_QWORD *)this - 24LL));
*v1 = (char *)&`construction vtable for'nglog::LogMessage::LogStream-in-nglog::NullStream + 24;
v1[12] = (char *)&`construction vtable for'nglog::LogMessage::LogStream-in-nglog::NullStream + 64;
v1[1] = (char *)&`vtable for'std::streambuf + 16;
std::locale::~locale((std::locale *)(v1 + 8));
std::ios_base::~ios_base((std::ios_base *)(v1 + 12));
operator delete(v1);
}
| ~NullStream:
PUSH R14
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
LEA RBX,[RDI + RAX*0x1]
LEA RCX,[0x1318c8]
LEA RDX,[RCX + 0x18]
LEA R14,[RDI + RAX*0x1]
ADD R14,0x60
MOV qword ptr [R14 + -0x60],RDX
ADD RCX,0x40
MOV qword ptr [R14],RCX
MOV RCX,qword ptr [0x00131f28]
ADD RCX,0x10
MOV qword ptr [R14 + -0x58],RCX
ADD RDI,RAX
ADD RDI,0x40
CALL 0x00107760
MOV RDI,R14
CALL 0x00107160
MOV ESI,0x168
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00108edc
|
/* virtual thunk to nglog::NullStream::~NullStream() */
void __thiscall nglog::NullStream::~NullStream(NullStream *this)
{
NullStream *pNVar1;
long lVar2;
lVar2 = *(long *)(*(long *)this + -0x18);
pNVar1 = this + lVar2;
*(int8 *)pNVar1 = 0x1318e0;
*(int8 *)(pNVar1 + 0x60) = 0x131908;
*(int **)(pNVar1 + 8) = PTR_vtable_00131f28 + 0x10;
std::locale::~locale((locale *)(this + lVar2 + 0x40));
std::ios_base::~ios_base((ios_base *)(pNVar1 + 0x60));
operator_delete(this + lVar2,0x168);
return;
}
| |
39,551 | nglog::LogMessage::~LogMessage() | ng-log[P]ng-log/src/logging.cc | LogMessage::~LogMessage() noexcept(false) {
Flush();
bool fail = data_->severity_ == NGLOG_FATAL && exit_on_dfatal;
#ifdef NGLOG_THREAD_LOCAL_STORAGE
if (data_ == static_cast<void*>(&thread_msg_data)) {
data_->~LogMessageData();
thread_data_available = true;
} else {
delete allocated_;
}
#else // !defined(NGLOG_THREAD_LOCAL_STORAGE)
delete allocated_;
#endif // defined(NGLOG_THREAD_LOCAL_STORAGE)
//
if (fail) {
const char* message = "*** Check failure stack trace: ***\n";
if (write(fileno(stderr), message, strlen(message)) < 0) {
// Ignore errors.
}
AlsoErrorWrite(NGLOG_FATAL, tools::ProgramInvocationShortName(), message);
#if defined(__cpp_lib_uncaught_exceptions) && \
(__cpp_lib_uncaught_exceptions >= 201411L)
if (std::uncaught_exceptions() == 0)
#else
if (!std::uncaught_exception())
#endif
{
Fail();
}
}
} | O0 | cpp | nglog::LogMessage::~LogMessage():
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xef00
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
xorl %eax, %eax
cmpl $0x3, 0x7698(%rcx)
movb %al, -0x19(%rbp)
jne 0xee48
movb 0x61927(%rip), %al # 0x7076c
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, -0x9(%rbp)
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xee79
movq -0x30(%rbp), %rdi
callq 0x17370
movq -0x30(%rbp), %rdi
movl $0x76f0, %esi # imm = 0x76F0
callq 0x9720
testb $0x1, -0x9(%rbp)
je 0xeeeb
leaq 0x3e830(%rip), %rax # 0x4d6b6
movq %rax, -0x18(%rbp)
movq 0x6111f(%rip), %rax # 0x6ffb0
movq (%rax), %rdi
callq 0x9790
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x92f0
movl -0x3c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x9230
cmpq $0x0, %rax
jge 0xeec4
jmp 0xeec4
callq 0x4ac20
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movl $0x3, %edi
callq 0x4abb0
callq 0x98e0
cmpl $0x0, %eax
jne 0xeee9
callq 0xf130
jmp 0xeeeb
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN5nglog10LogMessageD2Ev:
push rbp; Alternative name is 'nglog::LogMessage::~LogMessage()'
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
mov [rbp+var_28], rdi
call _ZN5nglog10LogMessage5FlushEv; nglog::LogMessage::Flush(void)
mov rax, [rbp+var_28]
mov rcx, [rax+8]
xor eax, eax
cmp dword ptr [rcx+7698h], 3
mov [rbp+var_19], al
jnz short loc_EE48
mov al, cs:_ZN5nglogL14exit_on_dfatalE; nglog::exit_on_dfatal
mov [rbp+var_19], al
loc_EE48:
mov rax, [rbp+var_28]
mov cl, [rbp+var_19]
and cl, 1
mov [rbp+var_9], cl
mov rax, [rax]
mov [rbp+var_30], rax
cmp rax, 0
jz short loc_EE79
mov rdi, [rbp+var_30]; void *
call _ZN5nglog8internal14LogMessageDataD2Ev; nglog::internal::LogMessageData::~LogMessageData()
mov rdi, [rbp+var_30]; void *
mov esi, 76F0h; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EE79:
test [rbp+var_9], 1
jz short loc_EEEB
lea rax, aCheckFailureSt; "*** Check failure stack trace: ***\n"
mov [rbp+var_18], rax
mov rax, cs:stderr_ptr
mov rdi, [rax]
call _fileno
mov dword ptr [rbp+var_3C], eax
mov rax, [rbp+var_18]
mov [rbp+var_3C+4], rax
mov rdi, [rbp+var_18]
call _strlen
mov edi, dword ptr [rbp+var_3C]; this
mov rsi, [rbp+var_3C+4]
mov rdx, rax
call _write
cmp rax, 0
jge short loc_EEC4
jmp short $+2
loc_EEC4:
call _ZN5nglog5tools26ProgramInvocationShortNameEv; nglog::tools::ProgramInvocationShortName(void)
mov rsi, rax
mov rdx, [rbp+var_18]
mov edi, (offset dword_0+3); this
call _ZN5nglog5tools14AlsoErrorWriteENS_11LogSeverityEPKcS3_; nglog::tools::AlsoErrorWrite(nglog::LogSeverity,char const*,char const*)
call __ZSt19uncaught_exceptionsv; std::uncaught_exceptions(void)
cmp eax, 0
jnz short loc_EEE9
call _ZN5nglog10LogMessage4FailEv; nglog::LogMessage::Fail(void)
loc_EEE9:
jmp short $+2
loc_EEEB:
add rsp, 40h
pop rbp
retn
| void nglog::LogMessage::~LogMessage(nglog::LogMessage *this)
{
long long v1; // rax
long long v2; // rax
unsigned int v3; // [rsp+4h] [rbp-3Ch]
void *v4; // [rsp+10h] [rbp-30h]
char v5; // [rsp+27h] [rbp-19h]
nglog::LogMessage::Flush(this);
v5 = 0;
if ( *(_DWORD *)(*((_QWORD *)this + 1) + 30360LL) == 3 )
v5 = nglog::exit_on_dfatal;
v4 = *(void **)this;
if ( *(_QWORD *)this )
{
nglog::internal::LogMessageData::~LogMessageData(v4);
operator delete(v4, 0x76F0uLL);
}
if ( (v5 & 1) != 0 )
{
v3 = fileno(stderr);
v1 = strlen("*** Check failure stack trace: ***\n");
write(v3, "*** Check failure stack trace: ***\n", v1);
v2 = nglog::tools::ProgramInvocationShortName((nglog::tools *)v3);
nglog::tools::AlsoErrorWrite((char *)&dword_0 + 3, v2, "*** Check failure stack trace: ***\n");
if ( !(unsigned int)std::uncaught_exceptions() )
nglog::LogMessage::Fail((nglog::LogMessage *)((char *)&dword_0 + 3));
}
}
| ~LogMessage:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RDI
CALL 0x0010ef00
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x8]
XOR EAX,EAX
CMP dword ptr [RCX + 0x7698],0x3
MOV byte ptr [RBP + -0x19],AL
JNZ 0x0010ee48
MOV AL,byte ptr [0x0017076c]
MOV byte ptr [RBP + -0x19],AL
LAB_0010ee48:
MOV RAX,qword ptr [RBP + -0x28]
MOV CL,byte ptr [RBP + -0x19]
AND CL,0x1
MOV byte ptr [RBP + -0x9],CL
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,0x0
JZ 0x0010ee79
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00117370
MOV RDI,qword ptr [RBP + -0x30]
MOV ESI,0x76f0
CALL 0x00109720
LAB_0010ee79:
TEST byte ptr [RBP + -0x9],0x1
JZ 0x0010eeeb
LEA RAX,[0x14d6b6]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [0x0016ffb0]
MOV RDI,qword ptr [RAX]
CALL 0x00109790
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001092f0
MOV EDI,dword ptr [RBP + -0x3c]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,RAX
CALL 0x00109230
CMP RAX,0x0
JGE 0x0010eec4
JMP 0x0010eec4
LAB_0010eec4:
CALL 0x0014ac20
MOV RSI,RAX
MOV RDX,qword ptr [RBP + -0x18]
MOV EDI,0x3
CALL 0x0014abb0
CALL 0x001098e0
CMP EAX,0x0
JNZ 0x0010eee9
CALL 0x0010f130
LAB_0010eee9:
JMP 0x0010eeeb
LAB_0010eeeb:
ADD RSP,0x40
POP RBP
RET
|
/* nglog::LogMessage::~LogMessage() */
void __thiscall nglog::LogMessage::~LogMessage(LogMessage *this)
{
LogMessageData *this_00;
int iVar1;
size_t __n;
int8 uVar2;
byte local_21;
Flush(this);
local_21 = 0;
if (*(int *)(*(long *)(this + 8) + 0x7698) == 3) {
local_21 = exit_on_dfatal;
}
this_00 = *(LogMessageData **)this;
if (this_00 != (LogMessageData *)0x0) {
internal::LogMessageData::~LogMessageData(this_00);
operator_delete(this_00,0x76f0);
}
if ((local_21 & 1) != 0) {
iVar1 = fileno(*(FILE **)PTR_stderr_0016ffb0);
__n = strlen("*** Check failure stack trace: ***\n");
write(iVar1,"*** Check failure stack trace: ***\n",__n);
uVar2 = tools::ProgramInvocationShortName();
tools::AlsoErrorWrite(3,uVar2,"*** Check failure stack trace: ***\n");
iVar1 = std::uncaught_exceptions();
if (iVar1 == 0) {
Fail();
}
}
return;
}
| |
39,552 | my_caseup_str_mb | eloqsql/strings/ctype-mb.c | size_t my_caseup_str_mb(CHARSET_INFO * cs, char *str)
{
register uint32 l;
register const uchar *map= cs->to_upper;
char *str_orig= str;
while (*str)
{
/* Pointing after the '\0' is safe here. */
if ((l= my_ismbchar(cs, str, str + cs->mbmaxlen)))
str+= l;
else
{
*str= (char) map[(uchar)*str];
str++;
}
}
return (size_t) (str - str_orig);
} | O0 | c | my_caseup_str_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4b4e7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x9c(%rax), %eax
addq %rax, %rdx
callq 0x4b500
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x4b4c5
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x4b4e5
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4b484
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_caseup_str_mb:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax+50h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
loc_4B484:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jz short loc_4B4E7
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
mov rax, [rbp+var_8]
mov eax, [rax+9Ch]
add rdx, rax
call my_ismbchar_0
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_4B4C5
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov ecx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp short loc_4B4E5
loc_4B4C5:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov cl, [rax+rcx]
mov rax, [rbp+var_10]
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
loc_4B4E5:
jmp short loc_4B484
loc_4B4E7:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_28]
sub rax, rcx
add rsp, 30h
pop rbp
retn
| _BYTE * my_caseup_str_mb(long long a1, _BYTE *a2)
{
long long v3; // [rsp+10h] [rbp-20h]
unsigned int v4; // [rsp+1Ch] [rbp-14h]
_BYTE *v5; // [rsp+20h] [rbp-10h]
v5 = a2;
v3 = *(_QWORD *)(a1 + 80);
while ( *v5 )
{
v4 = my_ismbchar_0(a1, v5, &v5[*(unsigned int *)(a1 + 156)]);
if ( v4 )
{
v5 += v4;
}
else
{
*v5 = *(_BYTE *)(v3 + (unsigned __int8)*v5);
++v5;
}
}
return (_BYTE *)(v5 - a2);
}
| my_caseup_str_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x50]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
LAB_0014b484:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JZ 0x0014b4e7
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x9c]
ADD RDX,RAX
CALL 0x0014b500
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x0014b4c5
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0014b4e5
LAB_0014b4c5:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_0014b4e5:
JMP 0x0014b484
LAB_0014b4e7:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
ADD RSP,0x30
POP RBP
RET
|
long my_caseup_str_mb(long param_1,byte *param_2)
{
long lVar1;
uint uVar2;
byte *local_18;
lVar1 = *(long *)(param_1 + 0x50);
local_18 = param_2;
while (*local_18 != 0) {
uVar2 = my_ismbchar(param_1,local_18,local_18 + *(uint *)(param_1 + 0x9c));
if (uVar2 == 0) {
*local_18 = *(byte *)(lVar1 + (ulong)*local_18);
local_18 = local_18 + 1;
}
else {
local_18 = local_18 + uVar2;
}
}
return (long)local_18 - (long)param_2;
}
| |
39,553 | my_strnncollsp_nchars_binary | eloqsql/strings/ctype-bin.c | static int my_strnncollsp_nchars_binary(CHARSET_INFO * cs __attribute__((unused)),
const uchar *s, size_t slen,
const uchar *t, size_t tlen,
size_t nchars)
{
set_if_smaller(slen, nchars);
set_if_smaller(tlen, nchars);
return my_strnncoll_binary(cs, s, slen, t, tlen, 0);
} | O3 | c | my_strnncollsp_nchars_binary:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %r9, %rbx
movq %rdx, %r14
cmpq %r9, %rdx
cmovaeq %r9, %r14
movq %rsi, %rdi
cmpq %r9, %r8
cmovbq %r8, %rbx
cmpq %rbx, %r14
movq %rbx, %rdx
cmovbq %r14, %rdx
movq %rcx, %rsi
callq 0x24130
subl %ebx, %r14d
testl %eax, %eax
cmovel %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
| my_strnncollsp_nchars_binary:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, r9
mov r14, rdx
cmp rdx, r9
cmovnb r14, r9
mov rdi, rsi
cmp r8, r9
cmovb rbx, r8
cmp r14, rbx
mov rdx, rbx
cmovb rdx, r14
mov rsi, rcx
call _memcmp
sub r14d, ebx
test eax, eax
cmovz eax, r14d
pop rbx
pop r14
pop rbp
retn
| long long my_strnncollsp_nchars_binary(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
unsigned long long a6)
{
unsigned long long v6; // rbx
unsigned long long v7; // r14
unsigned long long v8; // rdx
long long result; // rax
unsigned int v10; // r14d
v6 = a6;
v7 = a3;
if ( a3 >= a6 )
v7 = a6;
if ( a5 < a6 )
v6 = a5;
v8 = v6;
if ( v7 < v6 )
v8 = v7;
result = memcmp(a2, a4, v8);
v10 = v7 - v6;
if ( !(_DWORD)result )
return v10;
return result;
}
| my_strnncollsp_nchars_binary:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,R9
MOV R14,RDX
CMP RDX,R9
CMOVNC R14,R9
MOV RDI,RSI
CMP R8,R9
CMOVC RBX,R8
CMP R14,RBX
MOV RDX,RBX
CMOVC RDX,R14
MOV RSI,RCX
CALL 0x00124130
SUB R14D,EBX
TEST EAX,EAX
CMOVZ EAX,R14D
POP RBX
POP R14
POP RBP
RET
|
int my_strnncollsp_nchars_binary
(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
ulong param_6)
{
int iVar1;
ulong __n;
if (param_6 <= param_3) {
param_3 = param_6;
}
if (param_5 < param_6) {
param_6 = param_5;
}
__n = param_6;
if (param_3 < param_6) {
__n = param_3;
}
iVar1 = memcmp(param_2,param_4,__n);
if (iVar1 == 0) {
iVar1 = (int)param_3 - (int)param_6;
}
return iVar1;
}
| |
39,554 | vec_zero | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/vect.h | static inline void vec_zero(void *ret, size_t num)
{
volatile limb_t *rp = (volatile limb_t *)ret;
size_t i;
num /= sizeof(limb_t);
for (i = 0; i < num; i++)
rp[i] = 0;
#if defined(__GNUC__) || defined(__clang__)
__asm__ __volatile__("" : : "r"(ret) : "memory");
#endif
} | O0 | c | vec_zero:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x23360
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x23338
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| vec_zero:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
shr rax, 3
mov [rbp+var_10], rax
mov [rbp+var_20], 0
loc_23338:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_10]
jnb short loc_23360
mov rax, [rbp+var_18]
mov rcx, [rbp+var_20]
mov qword ptr [rax+rcx*8], 0
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_23338
loc_23360:
mov rax, [rbp+var_8]
pop rbp
retn
| long long vec_zero(long long a1, unsigned long long a2)
{
unsigned long long i; // [rsp+0h] [rbp-20h]
for ( i = 0LL; i < a2 >> 3; ++i )
*(_QWORD *)(a1 + 8 * i) = 0LL;
return a1;
}
| vec_zero:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
SHR RAX,0x3
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x20],0x0
LAB_00123338:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x00123360
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + RCX*0x8],0x0
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00123338
LAB_00123360:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
long vec_zero(long param_1,ulong param_2)
{
int8 local_28;
for (local_28 = 0; local_28 < param_2 >> 3; local_28 = local_28 + 1) {
*(int8 *)(param_1 + local_28 * 8) = 0;
}
return param_1;
}
| |
39,555 | ma_crypt_index_pre_write_hook | eloqsql/storage/maria/ma_crypt.c | static my_bool ma_crypt_index_pre_write_hook(PAGECACHE_IO_HOOK_ARGS *args)
{
MARIA_SHARE *share= (MARIA_SHARE*) args->data;
const uint block_size= share->block_size;
const uint page_used= _ma_get_page_used(share, args->page);
uint key_version;
uchar *crypt_buf= my_malloc(PSI_INSTRUMENT_ME, block_size, MYF(0));
if (crypt_buf == NULL)
{
args->crypt_buf= NULL; /* for post-hook */
return 1;
}
if (!share->base.born_transactional)
{
/* store a random number instead of LSN (for counter block) */
store_rand_lsn(args->page);
}
maria_page_crc_set_index(args);
{
const uchar *src= args->page;
uchar* dst= crypt_buf;
uint pageno= (uint)args->pageno;
LSN lsn= lsn_korr(src);
const uint head= share->keypage_header;
const uint tail= CRC_SIZE;
/* page_used includes header (but not trailer) */
const uint size= page_used - head;
/* 1 - copy head */
memcpy(dst, src, head);
/* 2 - encrypt page */
if (ma_encrypt(share, share->crypt_data,
src + head, dst + head, size, pageno, lsn, &key_version))
{
my_free(crypt_buf);
return 1;
}
/* 3 - copy tail */
memcpy(dst + block_size - tail, src + block_size - tail, tail);
/* 4 - store key version */
_ma_store_key_version(share, dst, key_version);
#ifdef HAVE_valgrind
/* 5 - keep valgrind happy by zeroing not used bytes */
bzero(dst+head+size, block_size - size - tail - head);
#endif
}
/* swap pointers to instead write out the encrypted block */
args->crypt_buf= args->page;
args->page= crypt_buf;
return 0;
} | O0 | c | ma_crypt_index_pre_write_hook:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x744(%rcx), %ecx
movzbl -0x1(%rax,%rcx), %eax
movzwl %ax, %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x18(%rbp), %rdx
movl 0x744(%rdx), %edx
movzbl -0x2(%rcx,%rdx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %esi
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0xf99f0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x89615
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x89764
movq -0x18(%rbp), %rax
cmpb $0x0, 0x44c(%rax)
jne 0x8962e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x89930
movq -0x10(%rbp), %rdi
callq 0x3f6b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
movq -0x38(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x38(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
shlq $0x20, %rax
movq -0x38(%rbp), %rcx
movl 0x3(%rcx), %ecx
orq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movl 0x744(%rax), %eax
movl %eax, -0x54(%rbp)
movl $0x4, -0x58(%rbp)
movl -0x20(%rbp), %eax
subl -0x54(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x54(%rbp), %eax
movl %eax, %edx
callq 0x2a0b0
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0xc20(%rax), %rsi
movq -0x38(%rbp), %rdx
movl -0x54(%rbp), %eax
addq %rax, %rdx
movq -0x40(%rbp), %rcx
movl -0x54(%rbp), %eax
addq %rax, %rcx
movl -0x5c(%rbp), %r8d
movl -0x44(%rbp), %r9d
movq -0x50(%rbp), %r10
leaq -0x24(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x899e0
cmpl $0x0, %eax
je 0x8970e
movq -0x30(%rbp), %rdi
callq 0xf9d70
movb $0x1, -0x1(%rbp)
jmp 0x89764
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %rdx
movl -0x1c(%rbp), %esi
movl -0x4(%rdx,%rsi), %edx
movl %edx, -0x4(%rax,%rcx)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x744(%rcx), %ecx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x68(%rbp)
movl -0x24(%rbp), %ecx
movq -0x68(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x80, %rsp
popq %rbp
retq
| ma_crypt_index_pre_write_hook:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov eax, [rax+7BCh]
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_18]
mov ecx, [rcx+744h]
movzx eax, byte ptr [rax+rcx-1]
movzx eax, ax
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov rdx, [rbp+var_18]
mov edx, [rdx+744h]
movzx ecx, byte ptr [rcx+rdx-2]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_20], eax
mov eax, [rbp+var_1C]
mov esi, eax
xor edi, edi
xor eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jnz short loc_89615
mov rax, [rbp+var_10]
mov qword ptr [rax+18h], 0
mov [rbp+var_1], 1
jmp loc_89764
loc_89615:
mov rax, [rbp+var_18]
cmp byte ptr [rax+44Ch], 0
jnz short loc_8962E
mov rax, [rbp+var_10]
mov rdi, [rax]
call store_rand_lsn
loc_8962E:
mov rdi, [rbp+var_10]
call maria_page_crc_set_index
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_44], eax
mov rax, [rbp+var_38]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
shl rax, 20h
mov rcx, [rbp+var_38]
mov ecx, [rcx+3]
or rax, rcx
mov [rbp+var_50], rax
mov rax, [rbp+var_18]
mov eax, [rax+744h]
mov [rbp+var_54], eax
mov [rbp+var_58], 4
mov eax, [rbp+var_20]
sub eax, [rbp+var_54]
mov [rbp+var_5C], eax
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_38]
mov eax, [rbp+var_54]
mov edx, eax
call _memcpy
mov rdi, [rbp+var_18]
mov rax, [rbp+var_18]
mov rsi, [rax+0C20h]
mov rdx, [rbp+var_38]
mov eax, [rbp+var_54]
add rdx, rax
mov rcx, [rbp+var_40]
mov eax, [rbp+var_54]
add rcx, rax
mov r8d, [rbp+var_5C]
mov r9d, [rbp+var_44]
mov r10, [rbp+var_50]
lea rax, [rbp+var_24]
mov [rsp+80h+var_80], r10
mov [rsp+80h+var_78], rax
call ma_encrypt
cmp eax, 0
jz short loc_8970E
mov rdi, [rbp+var_30]
call my_free
mov [rbp+var_1], 1
jmp short loc_89764
loc_8970E:
mov rax, [rbp+var_40]
mov ecx, [rbp+var_1C]
mov rdx, [rbp+var_38]
mov esi, [rbp+var_1C]
mov edx, [rdx+rsi-4]
mov [rax+rcx-4], edx
mov rax, [rbp+var_40]
mov rcx, [rbp+var_18]
mov ecx, [rcx+744h]
add rax, rcx
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_68], rax
mov ecx, [rbp+var_24]
mov rax, [rbp+var_68]
mov [rax], ecx
mov rax, [rbp+var_10]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_1], 0
loc_89764:
mov al, [rbp+var_1]
add rsp, 80h
pop rbp
retn
| char ma_crypt_index_pre_write_hook(long long *a1)
{
unsigned int v2; // [rsp+2Ch] [rbp-54h]
unsigned long long v3; // [rsp+30h] [rbp-50h]
int v4; // [rsp+3Ch] [rbp-44h]
unsigned __int16 *v5; // [rsp+48h] [rbp-38h]
long long v6; // [rsp+50h] [rbp-30h]
int v7; // [rsp+5Ch] [rbp-24h] BYREF
int v8; // [rsp+60h] [rbp-20h]
unsigned int v9; // [rsp+64h] [rbp-1Ch]
long long v10; // [rsp+68h] [rbp-18h]
long long *v11; // [rsp+70h] [rbp-10h]
v11 = a1;
v10 = a1[2];
v9 = *(_DWORD *)(v10 + 1980);
v8 = _byteswap_ushort(*(_WORD *)(*a1 + *(unsigned int *)(v10 + 1860) - 2));
v6 = my_malloc(0LL, v9, 0LL);
if ( v6 )
{
if ( !*(_BYTE *)(v10 + 1100) )
store_rand_lsn(*v11);
maria_page_crc_set_index(v11);
v5 = (unsigned __int16 *)*v11;
v4 = v11[1];
v3 = *(unsigned int *)(*v11 + 3) | ((unsigned long long)((*((unsigned __int8 *)v5 + 2) << 16) | (unsigned int)*v5) << 32);
v2 = *(_DWORD *)(v10 + 1860);
memcpy(v6, *v11, v2);
if ( (unsigned int)ma_encrypt(
v10,
*(_QWORD *)(v10 + 3104),
v2 + (unsigned int)v5,
v2 + (unsigned int)v6,
v8 - v2,
v4,
v3,
(long long)&v7) )
{
my_free(v6);
return 1;
}
else
{
*(_DWORD *)(v6 + v9 - 4) = *(_DWORD *)((char *)v5 + v9 - 4);
*(_DWORD *)(*(unsigned int *)(v10 + 1860) + v6 - 8) = v7;
v11[3] = *v11;
*v11 = v6;
return 0;
}
}
else
{
v11[3] = 0LL;
return 1;
}
}
| ma_crypt_index_pre_write_hook:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x744]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + -0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV RDX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RDX + 0x744]
MOVZX ECX,byte ptr [RCX + RDX*0x1 + -0x2]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV ESI,EAX
XOR EDI,EDI
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f99f0
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00189615
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],0x0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00189764
LAB_00189615:
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x44c],0x0
JNZ 0x0018962e
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00189930
LAB_0018962e:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013f6b0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
SHL RAX,0x20
MOV RCX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RCX + 0x3]
OR RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x744]
MOV dword ptr [RBP + -0x54],EAX
MOV dword ptr [RBP + -0x58],0x4
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x5c],EAX
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x54]
MOV EDX,EAX
CALL 0x0012a0b0
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0xc20]
MOV RDX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x54]
ADD RDX,RAX
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x54]
ADD RCX,RAX
MOV R8D,dword ptr [RBP + -0x5c]
MOV R9D,dword ptr [RBP + -0x44]
MOV R10,qword ptr [RBP + -0x50]
LEA RAX,[RBP + -0x24]
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001899e0
CMP EAX,0x0
JZ 0x0018970e
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001f9d70
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00189764
LAB_0018970e:
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x1c]
MOV RDX,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x1c]
MOV EDX,dword ptr [RDX + RSI*0x1 + -0x4]
MOV dword ptr [RAX + RCX*0x1 + -0x4],EDX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x744]
ADD RAX,RCX
ADD RAX,-0x8
MOV qword ptr [RBP + -0x68],RAX
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x68]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV byte ptr [RBP + -0x1],0x0
LAB_00189764:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x80
POP RBP
RET
|
int1 ma_crypt_index_pre_write_hook(long *param_1)
{
int4 uVar1;
uint uVar2;
int3 *__src;
ulong uVar3;
int3 uVar4;
int iVar5;
void *__dest;
int4 local_2c;
uint local_28;
uint local_24;
long local_20;
long *local_18;
int1 local_9;
local_20 = param_1[2];
local_24 = *(uint *)(local_20 + 0x7bc);
local_28 = (uint)CONCAT11(*(int1 *)(*param_1 + -2 + (ulong)*(uint *)(local_20 + 0x744)),
*(int1 *)(*param_1 + -1 + (ulong)*(uint *)(local_20 + 0x744)));
local_18 = param_1;
__dest = (void *)my_malloc(0,local_24,0);
if (__dest == (void *)0x0) {
local_18[3] = 0;
local_9 = 1;
}
else {
if (*(char *)(local_20 + 0x44c) == '\0') {
store_rand_lsn(*local_18);
}
maria_page_crc_set_index(local_18);
__src = (int3 *)*local_18;
uVar3 = local_18[1];
uVar4 = *__src;
uVar1 = *(int4 *)((long)__src + 3);
uVar2 = *(uint *)(local_20 + 0x744);
iVar5 = local_28 - uVar2;
memcpy(__dest,__src,(ulong)uVar2);
iVar5 = ma_encrypt(local_20,*(int8 *)(local_20 + 0xc20),(long)__src + (ulong)uVar2,
(long)__dest + (ulong)uVar2,iVar5,uVar3 & 0xffffffff,
(ulong)CONCAT34(uVar4,uVar1),&local_2c);
if (iVar5 == 0) {
*(int4 *)((long)__dest + ((ulong)local_24 - 4)) =
*(int4 *)((long)__src + ((ulong)local_24 - 4));
*(int4 *)((long)__dest + ((ulong)*(uint *)(local_20 + 0x744) - 8)) = local_2c;
local_18[3] = *local_18;
*local_18 = (long)__dest;
local_9 = 0;
}
else {
my_free(__dest);
local_9 = 1;
}
}
return local_9;
}
| |
39,556 | pagecache_unpin_by_link | eloqsql/storage/maria/ma_pagecache.c | void pagecache_unpin_by_link(PAGECACHE *pagecache,
PAGECACHE_BLOCK_LINK *block,
LSN lsn)
{
DBUG_ENTER("pagecache_unpin_by_link");
DBUG_PRINT("enter", ("block: %p fd: %u page: %lu",
block, (uint) block->hash_link->file.file,
(ulong) block->hash_link->pageno));
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
/*
As soon as we keep lock cache can be used, and we have lock because want
unlock.
*/
DBUG_ASSERT(pagecache->can_be_used);
/* we can't unpin such page without unlock */
DBUG_ASSERT((block->status & PCBLOCK_DIRECT_W) == 0);
inc_counter_for_resize_op(pagecache);
if (lsn != LSN_IMPOSSIBLE)
check_and_set_lsn(pagecache, lsn, block);
/*
We can just unpin only with keeping read lock because:
a) we can't pin without any lock
b) we can't unpin keeping write lock
*/
if (make_lock_and_pin(pagecache, block,
PAGECACHE_LOCK_LEFT_READLOCKED,
PAGECACHE_UNPIN, FALSE))
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.
*/
unreg_request(pagecache, block, 1);
dec_counter_for_resize_op(pagecache);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_VOID_RETURN;
} | O0 | c | pagecache_unpin_by_link:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x2ec56
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
leaq 0x123aa4(%rip), %rsi # 0x15270c
movl $0xdad, %edx # imm = 0xDAD
callq 0x2d850
jmp 0x2ec74
jmp 0x2ec76
jmp 0x2ec78
movq -0x8(%rbp), %rdi
callq 0x2dc00
cmpq $0x0, -0x18(%rbp)
je 0x2ec99
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2e470
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
callq 0x2e610
cmpb $0x0, %al
je 0x2ecbd
jmp 0x2ecb9
jmp 0x2ecbb
jmp 0x2ecbd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x2e7b0
movq -0x8(%rbp), %rdi
callq 0x2e930
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x2d8c0
jmp 0x2ecea
addq $0x20, %rsp
popq %rbp
retq
| pagecache_unpin_by_link:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
jmp short $+2
loc_2EC56:
mov rdi, [rbp+var_8]
add rdi, 0C8h
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0DADh
call inline_mysql_mutex_lock
jmp short $+2
loc_2EC74:
jmp short $+2
loc_2EC76:
jmp short $+2
loc_2EC78:
mov rdi, [rbp+var_8]
call inc_counter_for_resize_op
cmp [rbp+var_18], 0
jz short loc_2EC99
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_10]
call check_and_set_lsn
loc_2EC99:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, 1
mov ecx, 3
xor r8d, r8d
call make_lock_and_pin
cmp al, 0
jz short loc_2ECBD
jmp short $+2
loc_2ECB9:
jmp short $+2
loc_2ECBB:
jmp short $+2
loc_2ECBD:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, 1
call unreg_request
mov rdi, [rbp+var_8]
call dec_counter_for_resize_op
mov rdi, [rbp+var_8]
add rdi, 0C8h
call inline_mysql_mutex_unlock
jmp short $+2
loc_2ECEA:
add rsp, 20h
pop rbp
retn
| long long pagecache_unpin_by_link(_QWORD *a1, long long a2, long long a3)
{
inline_mysql_mutex_lock(
(long long)(a1 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xDADu);
inc_counter_for_resize_op((long long)a1);
if ( a3 )
check_and_set_lsn((long long)a1, a3, a2);
make_lock_and_pin((long long)a1, a2, 1, 3, 0);
unreg_request(a1, a2, 1);
dec_counter_for_resize_op((long long)a1);
return inline_mysql_mutex_unlock((long long)(a1 + 25));
}
| pagecache_unpin_by_link:
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
JMP 0x0012ec56
LAB_0012ec56:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
LEA RSI,[0x25270c]
MOV EDX,0xdad
CALL 0x0012d850
JMP 0x0012ec74
LAB_0012ec74:
JMP 0x0012ec76
LAB_0012ec76:
JMP 0x0012ec78
LAB_0012ec78:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012dc00
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0012ec99
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x10]
CALL 0x0012e470
LAB_0012ec99:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x1
MOV ECX,0x3
XOR R8D,R8D
CALL 0x0012e610
CMP AL,0x0
JZ 0x0012ecbd
JMP 0x0012ecb9
LAB_0012ecb9:
JMP 0x0012ecbb
LAB_0012ecbb:
JMP 0x0012ecbd
LAB_0012ecbd:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x1
CALL 0x0012e7b0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012e930
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
CALL 0x0012d8c0
JMP 0x0012ecea
LAB_0012ecea:
ADD RSP,0x20
POP RBP
RET
|
void pagecache_unpin_by_link(long param_1,int8 param_2,long param_3)
{
inline_mysql_mutex_lock
(param_1 + 200,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xdad);
inc_counter_for_resize_op(param_1);
if (param_3 != 0) {
check_and_set_lsn(param_1,param_3,param_2);
}
make_lock_and_pin(param_1,param_2,1,3,0);
unreg_request(param_1,param_2,1);
dec_counter_for_resize_op(param_1);
inline_mysql_mutex_unlock(param_1 + 200);
return;
}
| |
39,557 | pagecache_unpin_by_link | eloqsql/storage/maria/ma_pagecache.c | void pagecache_unpin_by_link(PAGECACHE *pagecache,
PAGECACHE_BLOCK_LINK *block,
LSN lsn)
{
DBUG_ENTER("pagecache_unpin_by_link");
DBUG_PRINT("enter", ("block: %p fd: %u page: %lu",
block, (uint) block->hash_link->file.file,
(ulong) block->hash_link->pageno));
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
/*
As soon as we keep lock cache can be used, and we have lock because want
unlock.
*/
DBUG_ASSERT(pagecache->can_be_used);
/* we can't unpin such page without unlock */
DBUG_ASSERT((block->status & PCBLOCK_DIRECT_W) == 0);
inc_counter_for_resize_op(pagecache);
if (lsn != LSN_IMPOSSIBLE)
check_and_set_lsn(pagecache, lsn, block);
/*
We can just unpin only with keeping read lock because:
a) we can't pin without any lock
b) we can't unpin keeping write lock
*/
if (make_lock_and_pin(pagecache, block,
PAGECACHE_LOCK_LEFT_READLOCKED,
PAGECACHE_UNPIN, FALSE))
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.
*/
unreg_request(pagecache, block, 1);
dec_counter_for_resize_op(pagecache);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_VOID_RETURN;
} | O3 | c | pagecache_unpin_by_link:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
leaq 0xc8(%rdi), %rbx
cmpq $0x0, 0x108(%rdi)
jne 0x33529
movq %rbx, %rdi
callq 0x29220
incq 0x68(%r14)
testq %r12, %r12
je 0x334cb
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x32df6
decl 0x64(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x33023
decq 0x68(%r14)
jne 0x3350d
movq 0x110(%r14), %rax
testq %rax, %rax
je 0x3350d
movq 0x88(%rax), %r15
movq 0x38(%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x33554
movq %r15, %rdi
callq 0x295c0
movq 0x108(%r14), %rdi
testq %rdi, %rdi
jne 0x33542
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x291e0
leaq 0xa7364(%rip), %rsi # 0xda894
movq %rbx, %rdi
movl $0xdad, %edx # imm = 0xDAD
callq 0x2eb8f
jmp 0x334b4
leaq 0x354b77(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x33519
leaq 0x354b65(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x170(%rax)
jmp 0x33505
| pagecache_unpin_by_link:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r12, rdx
mov r15, rsi
mov r14, rdi
lea rbx, [rdi+0C8h]
cmp qword ptr [rdi+108h], 0
jnz short loc_33529
mov rdi, rbx
call _pthread_mutex_lock
loc_334B4:
inc qword ptr [r14+68h]
test r12, r12
jz short loc_334CB
mov rdi, r14
mov rsi, r12
mov rdx, r15
call check_and_set_lsn
loc_334CB:
dec dword ptr [r15+64h]
mov rdi, r14
mov rsi, r15
mov edx, 1
call unreg_request
dec qword ptr [r14+68h]
jnz short loc_3350D
mov rax, [r14+110h]
test rax, rax
jz short loc_3350D
mov r15, [rax+88h]
mov rdi, [r15+38h]
add r15, 8
test rdi, rdi
jnz short loc_33554
loc_33505:
mov rdi, r15
call _pthread_cond_signal
loc_3350D:
mov rdi, [r14+108h]
test rdi, rdi
jnz short loc_33542
loc_33519:
mov rdi, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_33529:
lea rsi, aWorkspaceLlm4b_25; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 0DADh
call psi_mutex_lock
jmp loc_334B4
loc_33542:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_33519
loc_33554:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp short loc_33505
| long long pagecache_unpin_by_link(_QWORD *a1, long long a2, signed long long a3)
{
_QWORD *v5; // rbx
long long v7; // rax
long long v8; // r15
long long v9; // rdi
long long v10; // r15
v5 = a1 + 25;
if ( a1[33] )
psi_mutex_lock(
(long long)(a1 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xDADu);
else
pthread_mutex_lock(a1 + 25);
++a1[13];
if ( a3 )
check_and_set_lsn((long long)a1, a3, a2);
--*(_DWORD *)(a2 + 100);
unreg_request(a1, a2, 1);
if ( a1[13]-- == 1LL )
{
v7 = a1[34];
if ( v7 )
{
v8 = *(_QWORD *)(v7 + 136);
v9 = *(_QWORD *)(v8 + 56);
v10 = v8 + 8;
if ( v9 )
PSI_server[46]();
pthread_cond_signal(v10);
}
}
if ( a1[33] )
PSI_server[44]();
return pthread_mutex_unlock(v5);
}
| pagecache_unpin_by_link:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R12,RDX
MOV R15,RSI
MOV R14,RDI
LEA RBX,[RDI + 0xc8]
CMP qword ptr [RDI + 0x108],0x0
JNZ 0x00133529
MOV RDI,RBX
CALL 0x00129220
LAB_001334b4:
INC qword ptr [R14 + 0x68]
TEST R12,R12
JZ 0x001334cb
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x00132df6
LAB_001334cb:
DEC dword ptr [R15 + 0x64]
MOV RDI,R14
MOV RSI,R15
MOV EDX,0x1
CALL 0x00133023
DEC qword ptr [R14 + 0x68]
JNZ 0x0013350d
MOV RAX,qword ptr [R14 + 0x110]
TEST RAX,RAX
JZ 0x0013350d
MOV R15,qword ptr [RAX + 0x88]
MOV RDI,qword ptr [R15 + 0x38]
ADD R15,0x8
TEST RDI,RDI
JNZ 0x00133554
LAB_00133505:
MOV RDI,R15
CALL 0x001295c0
LAB_0013350d:
MOV RDI,qword ptr [R14 + 0x108]
TEST RDI,RDI
JNZ 0x00133542
LAB_00133519:
MOV RDI,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x001291e0
LAB_00133529:
LEA RSI,[0x1da894]
MOV RDI,RBX
MOV EDX,0xdad
CALL 0x0012eb8f
JMP 0x001334b4
LAB_00133542:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00133519
LAB_00133554:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x00133505
|
void pagecache_unpin_by_link(long param_1,long param_2,long param_3)
{
long *plVar1;
pthread_mutex_t *__mutex;
long lVar2;
__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",
0xdad);
}
*(long *)(param_1 + 0x68) = *(long *)(param_1 + 0x68) + 1;
if (param_3 != 0) {
check_and_set_lsn(param_1,param_3,param_2);
}
*(int *)(param_2 + 100) = *(int *)(param_2 + 100) + -1;
unreg_request(param_1,param_2,1);
plVar1 = (long *)(param_1 + 0x68);
*plVar1 = *plVar1 + -1;
if ((*plVar1 == 0) && (*(long *)(param_1 + 0x110) != 0)) {
lVar2 = *(long *)(*(long *)(param_1 + 0x110) + 0x88);
if (*(long *)(lVar2 + 0x38) != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal((pthread_cond_t *)(lVar2 + 8));
}
if (*(long *)(param_1 + 0x108) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return;
}
| |
39,558 | ft_init_boolean_search | eloqsql/storage/myisam/ft_boolean_search.c | FT_INFO * ft_init_boolean_search(MI_INFO *info, uint keynr, uchar *query,
uint query_len, CHARSET_INFO *cs)
{
FTB *ftb;
FTB_EXPR *ftbe;
FTB_WORD *ftbw;
if (!(ftb=(FTB *)my_malloc(mi_key_memory_FTB, sizeof(FTB), MYF(MY_WME))))
return 0;
ftb->please= (struct _ft_vft *) & _ft_vft_boolean;
ftb->state=UNINITIALIZED;
ftb->info=info;
ftb->keynr=keynr;
ftb->charset=cs;
DBUG_ASSERT(keynr==NO_SUCH_KEY || cs == info->s->keyinfo[keynr].seg->charset);
ftb->with_scan=0;
ftb->lastpos=HA_OFFSET_ERROR;
bzero(& ftb->no_dupes, sizeof(TREE));
ftb->last_word= 0;
init_alloc_root(mi_key_memory_FTB, &ftb->mem_root, 1024, 1024, MYF(0));
ftb->queue.max_elements= 0;
if (!(ftbe=(FTB_EXPR *)alloc_root(&ftb->mem_root, sizeof(FTB_EXPR))))
goto err;
ftbe->weight=1;
ftbe->flags=FTB_FLAG_YES;
ftbe->nos=1;
ftbe->up=0;
ftbe->max_docid= ftbe->ythresh= ftbe->yweaks= 0;
ftbe->docid[0]=ftbe->docid[1]=HA_OFFSET_ERROR;
ftbe->phrase= NULL;
ftbe->document= 0;
ftb->root=ftbe;
if (unlikely(_ftb_parse_query(ftb, query, query_len,
keynr == NO_SUCH_KEY ? &ft_default_parser :
info->s->keyinfo[keynr].parser)))
goto err;
/*
Hack: instead of init_queue, we'll use reinit queue to be able
to alloc queue with alloc_root()
*/
if (! (ftb->queue.root= (uchar **)alloc_root(&ftb->mem_root,
(ftb->queue.max_elements + 1) *
sizeof(void *))))
goto err;
reinit_queue(&ftb->queue, ftb->queue.max_elements, 0, 0,
(int (*)(void*, uchar*, uchar*))FTB_WORD_cmp, 0, 0, 0);
for (ftbw= ftb->last_word; ftbw; ftbw= ftbw->prev)
queue_insert(&ftb->queue, (uchar *)ftbw);
ftb->list=(FTB_WORD **)alloc_root(&ftb->mem_root,
sizeof(FTB_WORD *)*ftb->queue.elements);
memcpy(ftb->list, &queue_top(&ftb->queue), sizeof(FTB_WORD *)*ftb->queue.elements);
my_qsort2(ftb->list, ftb->queue.elements, sizeof(FTB_WORD *),
(qsort2_cmp)FTB_WORD_cmp_list, (void*)ftb->charset);
if (ftb->queue.elements<2) ftb->with_scan &= ~FTB_FLAG_TRUNC;
ftb->state=READY;
return ftb;
err:
free_root(& ftb->mem_root, MYF(0));
my_free(ftb);
return 0;
} | O0 | c | ft_init_boolean_search:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
leaq 0xbdb5f8(%rip), %rax # 0xc78f0c
movl (%rax), %edi
movl $0x350, %esi # imm = 0x350
movl $0x10, %edx
callq 0xf2e30
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x9d93c
movq $0x0, -0x8(%rbp)
jmp 0x9dc89
movq -0x38(%rbp), %rax
leaq 0x215c91(%rip), %rcx # 0x2b35d8
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x348(%rax)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x340(%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x9d97f
movq -0x38(%rbp), %rax
movb $0x0, 0x344(%rax)
movq -0x38(%rbp), %rax
movq $-0x1, 0x338(%rax)
movq -0x38(%rbp), %rdi
addq $0xa0, %rdi
xorl %esi, %esi
movl $0x298, %edx # imm = 0x298
callq 0x2a2b0
movq -0x38(%rbp), %rax
movq $0x0, 0x28(%rax)
leaq 0xbdb549(%rip), %rax # 0xc78f0c
movl (%rax), %edi
movq -0x38(%rbp), %rsi
addq $0x30, %rsi
movl $0x400, %ecx # imm = 0x400
xorl %eax, %eax
movl %eax, %r8d
movq %rcx, %rdx
callq 0xec770
movq -0x38(%rbp), %rax
movl $0x0, 0x84(%rax)
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movl $0x50, %esi
callq 0xeca30
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x9da0e
jmp 0x9dc67
movq -0x40(%rbp), %rax
movss 0xb25ee(%rip), %xmm0 # 0x150008
movss %xmm0, 0x28(%rax)
movq -0x40(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x40(%rbp), %rax
movl $0x1, 0x44(%rax)
movq -0x40(%rbp), %rax
movq $0x0, (%rax)
movq -0x40(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x40(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x40(%rbp), %rax
movq $-0x1, 0x18(%rax)
movq -0x40(%rbp), %rax
movq $-0x1, 0x10(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x9dac7
leaq 0x22069f(%rip), %rax # 0x2be160
movq %rax, -0x68(%rbp)
jmp 0x9dae7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rax
movq %rax, -0x68(%rbp)
movl -0x4c(%rbp), %edx
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rcx
callq 0x9dca0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x9db13
jmp 0x9dc67
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movq -0x38(%rbp), %rax
movl 0x84(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0xeca30
movq -0x38(%rbp), %rcx
movq %rax, 0x70(%rcx)
cmpq $0x0, %rax
jne 0x9db48
jmp 0x9dc67
movq -0x38(%rbp), %rdi
addq $0x70, %rdi
movq -0x38(%rbp), %rax
movl 0x84(%rax), %esi
xorl %ecx, %ecx
leaq 0x24d(%rip), %r8 # 0x9ddb0
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xf65a0
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x9dbb0
movq -0x38(%rbp), %rdi
addq $0x70, %rdi
movq -0x48(%rbp), %rsi
callq 0xf6720
movq -0x48(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x9db8a
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movq -0x38(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0xeca30
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x38(%rbp), %rax
movq 0x70(%rax), %rsi
addq $0x8, %rsi
movq -0x38(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, %edx
shlq $0x3, %rdx
callq 0x2a0a0
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x38(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, %esi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %r8
movl $0x8, %edx
leaq 0x257(%rip), %rcx # 0x9de80
callq 0xea750
movq -0x38(%rbp), %rax
cmpl $0x2, 0x80(%rax)
jae 0x9dc4f
movq -0x38(%rbp), %rax
movzbl 0x344(%rax), %ecx
andl $-0x2, %ecx
movb %cl, 0x344(%rax)
movq -0x38(%rbp), %rax
movl $0x1, 0x348(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9dc89
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xecfe0
movq -0x38(%rbp), %rdi
callq 0xf31b0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ft_init_boolean_search:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
lea rax, mi_key_memory_FTB
mov edi, [rax]
mov esi, 350h
mov edx, 10h
call my_malloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_9D93C
mov [rbp+var_8], 0
jmp loc_9DC89
loc_9D93C:
mov rax, [rbp+var_38]
lea rcx, _ft_vft_boolean
mov [rax], rcx
mov rax, [rbp+var_38]
mov dword ptr [rax+348h], 0
mov rcx, [rbp+var_10]
mov rax, [rbp+var_38]
mov [rax+8], rcx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_38]
mov [rax+340h], ecx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_38]
mov [rax+10h], rcx
jmp short $+2
loc_9D97F:
mov rax, [rbp+var_38]
mov byte ptr [rax+344h], 0
mov rax, [rbp+var_38]
mov qword ptr [rax+338h], 0FFFFFFFFFFFFFFFFh
mov rdi, [rbp+var_38]
add rdi, 0A0h
xor esi, esi
mov edx, 298h
call _memset
mov rax, [rbp+var_38]
mov qword ptr [rax+28h], 0
lea rax, mi_key_memory_FTB
mov edi, [rax]
mov rsi, [rbp+var_38]
add rsi, 30h ; '0'
mov ecx, 400h
xor eax, eax
mov r8d, eax
mov rdx, rcx
call init_alloc_root
mov rax, [rbp+var_38]
mov dword ptr [rax+84h], 0
mov rdi, [rbp+var_38]
add rdi, 30h ; '0'
mov esi, 50h ; 'P'
call alloc_root
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_9DA0E
jmp loc_9DC67
loc_9DA0E:
mov rax, [rbp+var_40]
movss xmm0, cs:dword_150008
movss dword ptr [rax+28h], xmm0
mov rax, [rbp+var_40]
mov dword ptr [rax+8], 2
mov rax, [rbp+var_40]
mov dword ptr [rax+44h], 1
mov rax, [rbp+var_40]
mov qword ptr [rax], 0
mov rax, [rbp+var_40]
mov dword ptr [rax+4Ch], 0
mov rax, [rbp+var_40]
mov dword ptr [rax+48h], 0
mov rax, [rbp+var_40]
mov qword ptr [rax+20h], 0
mov rax, [rbp+var_40]
mov qword ptr [rax+18h], 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_40]
mov qword ptr [rax+10h], 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_40]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_40]
mov qword ptr [rax+38h], 0
mov rcx, [rbp+var_40]
mov rax, [rbp+var_38]
mov [rax+18h], rcx
mov rax, [rbp+var_38]
mov [rbp+var_60], rax
mov rax, [rbp+var_20]
mov [rbp+var_58], rax
mov eax, [rbp+var_24]
mov [rbp+var_4C], eax
cmp [rbp+var_14], 0FFFFFFFFh
jnz short loc_9DAC7
lea rax, ft_default_parser
mov [rbp+var_68], rax
jmp short loc_9DAE7
loc_9DAC7:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_14]
imul rcx, 70h ; 'p'
add rax, rcx
mov rax, [rax+38h]
mov [rbp+var_68], rax
loc_9DAE7:
mov edx, [rbp+var_4C]
mov rsi, [rbp+var_58]
mov rdi, [rbp+var_60]
mov rcx, [rbp+var_68]
call _ftb_parse_query
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_9DB13
jmp loc_9DC67
loc_9DB13:
mov rdi, [rbp+var_38]
add rdi, 30h ; '0'
mov rax, [rbp+var_38]
mov eax, [rax+84h]
add eax, 1
mov eax, eax
mov esi, eax
shl rsi, 3
call alloc_root
mov rcx, [rbp+var_38]
mov [rcx+70h], rax
cmp rax, 0
jnz short loc_9DB48
jmp loc_9DC67
loc_9DB48:
mov rdi, [rbp+var_38]
add rdi, 70h ; 'p'
mov rax, [rbp+var_38]
mov esi, [rax+84h]
xor ecx, ecx
lea r8, FTB_WORD_cmp
xor eax, eax
mov r9d, eax
mov edx, ecx
mov [rsp+80h+var_80], 0
mov [rsp+80h+var_78], 0
call reinit_queue
mov rax, [rbp+var_38]
mov rax, [rax+28h]
mov [rbp+var_48], rax
loc_9DB8A:
cmp [rbp+var_48], 0
jz short loc_9DBB0
mov rdi, [rbp+var_38]
add rdi, 70h ; 'p'
mov rsi, [rbp+var_48]
call queue_insert
mov rax, [rbp+var_48]
mov rax, [rax+38h]
mov [rbp+var_48], rax
jmp short loc_9DB8A
loc_9DBB0:
mov rdi, [rbp+var_38]
add rdi, 30h ; '0'
mov rax, [rbp+var_38]
mov eax, [rax+80h]
mov esi, eax
shl rsi, 3
call alloc_root
mov rcx, rax
mov rax, [rbp+var_38]
mov [rax+20h], rcx
mov rax, [rbp+var_38]
mov rdi, [rax+20h]
mov rax, [rbp+var_38]
mov rsi, [rax+70h]
add rsi, 8
mov rax, [rbp+var_38]
mov eax, [rax+80h]
mov edx, eax
shl rdx, 3
call _memcpy
mov rax, [rbp+var_38]
mov rdi, [rax+20h]
mov rax, [rbp+var_38]
mov eax, [rax+80h]
mov esi, eax
mov rax, [rbp+var_38]
mov r8, [rax+10h]
mov edx, 8
lea rcx, FTB_WORD_cmp_list
call my_qsort2
mov rax, [rbp+var_38]
cmp dword ptr [rax+80h], 2
jnb short loc_9DC4F
mov rax, [rbp+var_38]
movzx ecx, byte ptr [rax+344h]
and ecx, 0FFFFFFFEh
mov [rax+344h], cl
loc_9DC4F:
mov rax, [rbp+var_38]
mov dword ptr [rax+348h], 1
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
jmp short loc_9DC89
loc_9DC67:
mov rdi, [rbp+var_38]
add rdi, 30h ; '0'
xor eax, eax
mov esi, eax
call free_root
mov rdi, [rbp+var_38]
call my_free
mov [rbp+var_8], 0
loc_9DC89:
mov rax, [rbp+var_8]
add rsp, 80h
pop rbp
retn
| long long ft_init_boolean_search(
long long a1,
unsigned int a2,
long long a3,
unsigned int a4,
long long a5,
double a6)
{
int v6; // eax
long long v7; // rax
long long i; // [rsp+38h] [rbp-48h]
long long v10; // [rsp+40h] [rbp-40h]
long long v11; // [rsp+48h] [rbp-38h]
v11 = my_malloc(mi_key_memory_FTB, 848LL, 16LL);
if ( !v11 )
return 0LL;
*(_QWORD *)v11 = ft_vft_boolean;
*(_DWORD *)(v11 + 840) = 0;
*(_QWORD *)(v11 + 8) = a1;
*(_DWORD *)(v11 + 832) = a2;
*(_QWORD *)(v11 + 16) = a5;
*(_BYTE *)(v11 + 836) = 0;
*(_QWORD *)(v11 + 824) = -1LL;
memset(v11 + 160, 0LL, 664LL);
*(_QWORD *)(v11 + 40) = 0LL;
init_alloc_root(mi_key_memory_FTB, v11 + 48, 1024LL, 1024LL);
*(_DWORD *)(v11 + 132) = 0;
v10 = alloc_root(v11 + 48, 80LL);
if ( !v10 )
goto LABEL_15;
*(_QWORD *)&a6 = 1065353216LL;
*(_DWORD *)(v10 + 40) = 1065353216;
*(_DWORD *)(v10 + 8) = 2;
*(_DWORD *)(v10 + 68) = 1;
*(_QWORD *)v10 = 0LL;
*(_DWORD *)(v10 + 76) = 0;
*(_DWORD *)(v10 + 72) = 0;
*(_QWORD *)(v10 + 32) = 0LL;
*(_QWORD *)(v10 + 24) = -1LL;
*(_QWORD *)(v10 + 16) = -1LL;
*(_QWORD *)(v10 + 48) = 0LL;
*(_QWORD *)(v10 + 56) = 0LL;
*(_QWORD *)(v11 + 24) = v10;
v6 = a2 == -1
? ftb_parse_query(v11, a3, a4, &ft_default_parser)
: ftb_parse_query(v11, a3, a4, *(_QWORD *)(112LL * a2 + *(_QWORD *)(*(_QWORD *)a1 + 536LL) + 56));
if ( !v6
&& (v7 = alloc_root(v11 + 48, 8LL * (unsigned int)(*(_DWORD *)(v11 + 132) + 1)), (*(_QWORD *)(v11 + 112) = v7) != 0LL) )
{
reinit_queue(v11 + 112, *(_DWORD *)(v11 + 132), 0, 0, (unsigned int)FTB_WORD_cmp, 0, 0, 0);
for ( i = *(_QWORD *)(v11 + 40); i; i = *(_QWORD *)(i + 56) )
queue_insert(v11 + 112, i);
*(_QWORD *)(v11 + 32) = alloc_root(v11 + 48, 8LL * *(unsigned int *)(v11 + 128));
memcpy(*(_QWORD *)(v11 + 32), *(_QWORD *)(v11 + 112) + 8LL, 8LL * *(unsigned int *)(v11 + 128));
my_qsort2(*(_QWORD *)(v11 + 32), *(unsigned int *)(v11 + 128), 8LL, FTB_WORD_cmp_list, *(_QWORD *)(v11 + 16));
if ( *(_DWORD *)(v11 + 128) < 2u )
*(_BYTE *)(v11 + 836) &= ~1u;
*(_DWORD *)(v11 + 840) = 1;
return v11;
}
else
{
LABEL_15:
free_root(v11 + 48, 0LL);
my_free(v11, a6);
return 0LL;
}
}
| ft_init_boolean_search:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
LEA RAX,[0xd78f0c]
MOV EDI,dword ptr [RAX]
MOV ESI,0x350
MOV EDX,0x10
CALL 0x001f2e30
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x0019d93c
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0019dc89
LAB_0019d93c:
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[0x3b35d8]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x348],0x0
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x340],ECX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x0019d97f
LAB_0019d97f:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x344],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x338],-0x1
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0xa0
XOR ESI,ESI
MOV EDX,0x298
CALL 0x0012a2b0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x28],0x0
LEA RAX,[0xd78f0c]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x38]
ADD RSI,0x30
MOV ECX,0x400
XOR EAX,EAX
MOV R8D,EAX
MOV RDX,RCX
CALL 0x001ec770
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x84],0x0
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x30
MOV ESI,0x50
CALL 0x001eca30
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x0019da0e
JMP 0x0019dc67
LAB_0019da0e:
MOV RAX,qword ptr [RBP + -0x40]
MOVSS XMM0,dword ptr [0x00250008]
MOVSS dword ptr [RAX + 0x28],XMM0
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX + 0x8],0x2
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX + 0x44],0x1
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX + 0x4c],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX + 0x48],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x20],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x18],-0x1
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x10],-0x1
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x38],0x0
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x58],RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4c],EAX
CMP dword ptr [RBP + -0x14],-0x1
JNZ 0x0019dac7
LEA RAX,[0x3be160]
MOV qword ptr [RBP + -0x68],RAX
JMP 0x0019dae7
LAB_0019dac7:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x68],RAX
LAB_0019dae7:
MOV EDX,dword ptr [RBP + -0x4c]
MOV RSI,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x68]
CALL 0x0019dca0
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0019db13
JMP 0x0019dc67
LAB_0019db13:
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x30
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x84]
ADD EAX,0x1
MOV EAX,EAX
MOV ESI,EAX
SHL RSI,0x3
CALL 0x001eca30
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RCX + 0x70],RAX
CMP RAX,0x0
JNZ 0x0019db48
JMP 0x0019dc67
LAB_0019db48:
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x70
MOV RAX,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RAX + 0x84]
XOR ECX,ECX
LEA R8,[0x19ddb0]
XOR EAX,EAX
MOV R9D,EAX
MOV EDX,ECX
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
CALL 0x001f65a0
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x48],RAX
LAB_0019db8a:
CMP qword ptr [RBP + -0x48],0x0
JZ 0x0019dbb0
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x70
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x001f6720
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0019db8a
LAB_0019dbb0:
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x30
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x80]
MOV ESI,EAX
SHL RSI,0x3
CALL 0x001eca30
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RAX + 0x70]
ADD RSI,0x8
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x80]
MOV EDX,EAX
SHL RDX,0x3
CALL 0x0012a0a0
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x80]
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RAX + 0x10]
MOV EDX,0x8
LEA RCX,[0x19de80]
CALL 0x001ea750
MOV RAX,qword ptr [RBP + -0x38]
CMP dword ptr [RAX + 0x80],0x2
JNC 0x0019dc4f
MOV RAX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RAX + 0x344]
AND ECX,0xfffffffe
MOV byte ptr [RAX + 0x344],CL
LAB_0019dc4f:
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x348],0x1
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0019dc89
LAB_0019dc67:
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x30
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001ecfe0
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001f31b0
MOV qword ptr [RBP + -0x8],0x0
LAB_0019dc89:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x80
POP RBP
RET
|
int8 *
ft_init_boolean_search
(long *param_1,uint param_2,int8 param_3,int4 param_4,int8 param_5)
{
int iVar1;
int8 *puVar2;
int8 *puVar3;
long lVar4;
int8 uVar5;
int1 *local_70;
long local_50;
puVar2 = (int8 *)my_malloc(mi_key_memory_FTB,0x350,0x10);
if (puVar2 != (int8 *)0x0) {
*puVar2 = _ft_vft_boolean;
*(int4 *)(puVar2 + 0x69) = 0;
puVar2[1] = param_1;
*(uint *)(puVar2 + 0x68) = param_2;
puVar2[2] = param_5;
*(int1 *)((long)puVar2 + 0x344) = 0;
puVar2[0x67] = 0xffffffffffffffff;
memset(puVar2 + 0x14,0,0x298);
puVar2[5] = 0;
init_alloc_root(mi_key_memory_FTB,puVar2 + 6,0x400,0x400,0);
*(int4 *)((long)puVar2 + 0x84) = 0;
puVar3 = (int8 *)alloc_root(puVar2 + 6,0x50);
if (puVar3 != (int8 *)0x0) {
*(int4 *)(puVar3 + 5) = DAT_00250008;
*(int4 *)(puVar3 + 1) = 2;
*(int4 *)((long)puVar3 + 0x44) = 1;
*puVar3 = 0;
*(int4 *)((long)puVar3 + 0x4c) = 0;
*(int4 *)(puVar3 + 9) = 0;
puVar3[4] = 0;
puVar3[3] = 0xffffffffffffffff;
puVar3[2] = 0xffffffffffffffff;
puVar3[6] = 0;
puVar3[7] = 0;
puVar2[3] = puVar3;
if (param_2 == 0xffffffff) {
local_70 = ft_default_parser;
}
else {
local_70 = *(int1 **)(*(long *)(*param_1 + 0x218) + (ulong)param_2 * 0x70 + 0x38);
}
iVar1 = _ftb_parse_query(puVar2,param_3,param_4,local_70);
if (iVar1 == 0) {
lVar4 = alloc_root(puVar2 + 6,(ulong)(*(int *)((long)puVar2 + 0x84) + 1) << 3);
puVar2[0xe] = lVar4;
if (lVar4 != 0) {
reinit_queue(puVar2 + 0xe,*(int4 *)((long)puVar2 + 0x84),0,0,FTB_WORD_cmp,0,0,0);
for (local_50 = puVar2[5]; local_50 != 0; local_50 = *(long *)(local_50 + 0x38)) {
queue_insert(puVar2 + 0xe,local_50);
}
uVar5 = alloc_root(puVar2 + 6,(ulong)*(uint *)(puVar2 + 0x10) << 3);
puVar2[4] = uVar5;
memcpy((void *)puVar2[4],(void *)(puVar2[0xe] + 8),(ulong)*(uint *)(puVar2 + 0x10) << 3);
my_qsort2(puVar2[4],*(int4 *)(puVar2 + 0x10),8,FTB_WORD_cmp_list,puVar2[2]);
if (*(uint *)(puVar2 + 0x10) < 2) {
*(byte *)((long)puVar2 + 0x344) = *(byte *)((long)puVar2 + 0x344) & 0xfe;
}
*(int4 *)(puVar2 + 0x69) = 1;
return puVar2;
}
}
}
free_root(puVar2 + 6,0);
my_free(puVar2);
}
return (int8 *)0x0;
}
| |
39,559 | ggml_vec_dot_q2_K_q8_K | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c | void ggml_vec_dot_q2_K_q8_K(int n, float * restrict s, size_t bs, const void * restrict vx, size_t bx, const void * restrict vy, size_t by, int nrc) {
assert(nrc == 1);
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
const block_q2_K * restrict x = vx;
const block_q8_K * restrict y = vy;
const int nb = n / QK_K;
#ifdef __ARM_NEON
const uint8x16_t m3 = vdupq_n_u8(0x3);
const uint8x16_t m4 = vdupq_n_u8(0xF);
const int32x4_t vzero = vdupq_n_s32(0);
ggml_int8x16x2_t q2bytes;
uint8_t aux[16];
float sum = 0;
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const float dmin = -y[i].d * GGML_FP16_TO_FP32(x[i].dmin);
const uint8_t * restrict q2 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
const uint8_t * restrict sc = x[i].scales;
const uint8x16_t mins_and_scales = vld1q_u8(sc);
const uint8x16_t scales = vandq_u8(mins_and_scales, m4);
vst1q_u8(aux, scales);
const uint8x16_t mins = vshrq_n_u8(mins_and_scales, 4);
const ggml_int16x8x2_t q8sums = ggml_vld1q_s16_x2(y[i].bsums);
const ggml_int16x8x2_t mins16 = {{vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(mins))), vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(mins)))}};
const int32x4_t s0 = vaddq_s32(vmull_s16(vget_low_s16 (mins16.val[0]), vget_low_s16 (q8sums.val[0])),
vmull_s16(vget_high_s16(mins16.val[0]), vget_high_s16(q8sums.val[0])));
const int32x4_t s1 = vaddq_s32(vmull_s16(vget_low_s16 (mins16.val[1]), vget_low_s16 (q8sums.val[1])),
vmull_s16(vget_high_s16(mins16.val[1]), vget_high_s16(q8sums.val[1])));
sum += dmin * vaddvq_s32(vaddq_s32(s0, s1));
int isum = 0;
int is = 0;
// We use this macro instead of a function call because for some reason
// the code runs 2-3% slower, even if the function is declared inline
#define MULTIPLY_ACCUM_WITH_SCALE(index)\
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q2bytes.val[0], q8bytes.val[0])) * aux[is+(index)];\
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q2bytes.val[1], q8bytes.val[1])) * aux[is+1+(index)];
#define SHIFT_MULTIPLY_ACCUM_WITH_SCALE(shift, index)\
q8bytes = ggml_vld1q_s8_x2(q8); q8 += 32;\
q2bytes.val[0] = vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q2bits.val[0], (shift)), m3));\
q2bytes.val[1] = vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q2bits.val[1], (shift)), m3));\
MULTIPLY_ACCUM_WITH_SCALE((index));
for (int j = 0; j < QK_K/128; ++j) {
const ggml_uint8x16x2_t q2bits = ggml_vld1q_u8_x2(q2); q2 += 32;
ggml_int8x16x2_t q8bytes = ggml_vld1q_s8_x2(q8); q8 += 32;
q2bytes.val[0] = vreinterpretq_s8_u8(vandq_u8(q2bits.val[0], m3));
q2bytes.val[1] = vreinterpretq_s8_u8(vandq_u8(q2bits.val[1], m3));
MULTIPLY_ACCUM_WITH_SCALE(0);
SHIFT_MULTIPLY_ACCUM_WITH_SCALE(2, 2);
SHIFT_MULTIPLY_ACCUM_WITH_SCALE(4, 4);
SHIFT_MULTIPLY_ACCUM_WITH_SCALE(6, 6);
is += 8;
}
sum += d * isum;
}
*s = sum;
#elif defined __AVX2__
const __m256i m3 = _mm256_set1_epi8(3);
const __m128i m4 = _mm_set1_epi8(0xF);
__m256 acc = _mm256_setzero_ps();
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const float dmin = -y[i].d * GGML_FP16_TO_FP32(x[i].dmin);
const uint8_t * restrict q2 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
const __m128i mins_and_scales = _mm_loadu_si128((const __m128i*)x[i].scales);
const __m128i scales8 = _mm_and_si128(mins_and_scales, m4);
const __m128i mins8 = _mm_and_si128(_mm_srli_epi16(mins_and_scales, 4), m4);
const __m256i mins = _mm256_cvtepi8_epi16(mins8);
const __m256i prod = _mm256_madd_epi16(mins, _mm256_loadu_si256((const __m256i*)y[i].bsums));
acc = _mm256_fmadd_ps(_mm256_broadcast_ss(&dmin), _mm256_cvtepi32_ps(prod), acc);
const __m256i all_scales = _mm256_cvtepi8_epi16(scales8);
const __m128i l_scales = _mm256_extracti128_si256(all_scales, 0);
const __m128i h_scales = _mm256_extracti128_si256(all_scales, 1);
const __m256i scales[2] = {MM256_SET_M128I(l_scales, l_scales), MM256_SET_M128I(h_scales, h_scales)};
__m256i sumi = _mm256_setzero_si256();
for (int j = 0; j < QK_K/128; ++j) {
const __m256i q2bits = _mm256_loadu_si256((const __m256i*)q2); q2 += 32;
const __m256i q8_0 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q8_1 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q8_2 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q8_3 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q2_0 = _mm256_and_si256(q2bits, m3);
const __m256i q2_1 = _mm256_and_si256(_mm256_srli_epi16(q2bits, 2), m3);
const __m256i q2_2 = _mm256_and_si256(_mm256_srli_epi16(q2bits, 4), m3);
const __m256i q2_3 = _mm256_and_si256(_mm256_srli_epi16(q2bits, 6), m3);
__m256i p0 = _mm256_maddubs_epi16(q2_0, q8_0);
__m256i p1 = _mm256_maddubs_epi16(q2_1, q8_1);
__m256i p2 = _mm256_maddubs_epi16(q2_2, q8_2);
__m256i p3 = _mm256_maddubs_epi16(q2_3, q8_3);
p0 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(0)), p0);
p1 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(1)), p1);
p2 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(2)), p2);
p3 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(3)), p3);
p0 = _mm256_add_epi32(p0, p1);
p2 = _mm256_add_epi32(p2, p3);
sumi = _mm256_add_epi32(sumi, _mm256_add_epi32(p0, p2));
}
acc = _mm256_fmadd_ps(_mm256_broadcast_ss(&d), _mm256_cvtepi32_ps(sumi), acc);
}
*s = hsum_float_8(acc);
#elif defined __AVX__
const __m128i m3 = _mm_set1_epi8(0x3);
const __m128i m4 = _mm_set1_epi8(0xF);
const __m128i m2 = _mm_set1_epi8(0x2);
__m256 acc = _mm256_setzero_ps();
for (int i = 0; i < nb; ++i) {
const float dall = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const float dmin = -y[i].d * GGML_FP16_TO_FP32(x[i].dmin);
const uint8_t * restrict q2 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
// load mins and scales from block_q2_K.scales[QK_K/16]
const __m128i mins_and_scales = _mm_loadu_si128((const __m128i*)x[i].scales);
const __m128i scales16 = _mm_and_si128(mins_and_scales, m4);
const __m128i mins16 = _mm_and_si128(_mm_srli_epi16(mins_and_scales, 4), m4);
const __m128i mins_0 = _mm_cvtepi8_epi16(mins16);
const __m128i mins_1 = _mm_cvtepi8_epi16(_mm_unpackhi_epi64(mins16, mins16));
// summs = y[i].bsums * (x[i].scales >> 4) in 16bits*8*2 to 32bits*4*2
const __m128i summs_0 = _mm_madd_epi16(mins_0, _mm_loadu_si128((const __m128i*)&y[i].bsums[0]));
const __m128i summs_1 = _mm_madd_epi16(mins_1, _mm_loadu_si128((const __m128i*)&y[i].bsums[8]));
// sumf += -dmin * summs in 32bits*8
acc = _mm256_add_ps(_mm256_mul_ps(_mm256_broadcast_ss(&dmin), _mm256_cvtepi32_ps(MM256_SET_M128I(summs_1, summs_0))), acc);
const __m128i scales_0 = _mm_cvtepi8_epi16(scales16);
const __m128i scales_1 = _mm_cvtepi8_epi16(_mm_unpackhi_epi64(scales16, scales16));
const __m128i scales[2] = { scales_0, scales_1 };
__m128i sumi_0 = _mm_setzero_si128();
__m128i sumi_1 = _mm_setzero_si128();
for (int j = 0; j < QK_K/128; ++j) {
// load Q8 quants int8*16*8 from block_q8_K.qs[QK_K]
const __m128i q8_0 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_1 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_2 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_3 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_4 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_5 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_6 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_7 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
// load 2bits*16*8 from block_q2_K.qs[QK_K/4]
__m128i q2bits = _mm_loadu_si128((const __m128i*)q2); q2 += 16;
const __m128i q2_0 = _mm_and_si128(q2bits, m3);
const __m128i q2_2 = _mm_and_si128(_mm_srli_epi16(q2bits, 2), m3);
const __m128i q2_4 = _mm_and_si128(_mm_srli_epi16(q2bits, 4), m3);
const __m128i q2_6 = _mm_and_si128(_mm_srli_epi16(q2bits, 6), m3);
q2bits = _mm_loadu_si128((const __m128i*)q2); q2 += 16;
const __m128i q2_1 = _mm_and_si128(q2bits, m3);
const __m128i q2_3 = _mm_and_si128(_mm_srli_epi16(q2bits, 2), m3);
const __m128i q2_5 = _mm_and_si128(_mm_srli_epi16(q2bits, 4), m3);
const __m128i q2_7 = _mm_and_si128(_mm_srli_epi16(q2bits, 6), m3);
// isuml = q8[l] * ((q2[l] >> shift) & 3) in 8bits*16*8 to 16bits*8*8
__m128i p0 = _mm_maddubs_epi16(q2_0, q8_0);
__m128i p1 = _mm_maddubs_epi16(q2_1, q8_1);
__m128i p2 = _mm_maddubs_epi16(q2_2, q8_2);
__m128i p3 = _mm_maddubs_epi16(q2_3, q8_3);
__m128i p4 = _mm_maddubs_epi16(q2_4, q8_4);
__m128i p5 = _mm_maddubs_epi16(q2_5, q8_5);
__m128i p6 = _mm_maddubs_epi16(q2_6, q8_6);
__m128i p7 = _mm_maddubs_epi16(q2_7, q8_7);
// isum += (x[i].scales[is++] & 0xF) * isuml in 16bits*8*8 to 32bits*4*8
__m128i shuffle = _mm_set1_epi16(0x0100);
p0 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p0);
shuffle = _mm_add_epi16(shuffle, m2);
p1 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p1);
shuffle = _mm_add_epi16(shuffle, m2);
p2 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p2);
shuffle = _mm_add_epi16(shuffle, m2);
p3 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p3);
shuffle = _mm_add_epi16(shuffle, m2);
p4 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p4);
shuffle = _mm_add_epi16(shuffle, m2);
p5 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p5);
shuffle = _mm_add_epi16(shuffle, m2);
p6 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p6);
shuffle = _mm_add_epi16(shuffle, m2);
p7 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p7);
p0 = _mm_add_epi32(p0, p1);
p2 = _mm_add_epi32(p2, p3);
p4 = _mm_add_epi32(p4, p5);
p6 = _mm_add_epi32(p6, p7);
// isum in 32bits*4*2
sumi_0 = _mm_add_epi32(sumi_0, _mm_add_epi32(p0, p2));
sumi_1 = _mm_add_epi32(sumi_1, _mm_add_epi32(p4, p6));
}
// sumf += dall * isum - dmin * summs in 32bits
__m256i sumi = MM256_SET_M128I(sumi_1, sumi_0);
acc = _mm256_add_ps(_mm256_mul_ps(_mm256_broadcast_ss(&dall), _mm256_cvtepi32_ps(sumi)), acc);
}
*s = hsum_float_8(acc);
#elif defined __riscv_v_intrinsic
float sumf = 0;
uint8_t temp_01[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
for (int i = 0; i < nb; ++i) {
const uint8_t * q2 = x[i].qs;
const int8_t * q8 = y[i].qs;
const uint8_t * sc = x[i].scales;
const float dall = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const float dmin = -y[i].d * GGML_FP16_TO_FP32(x[i].dmin);
size_t vl = 16;
vuint8m1_t scales = __riscv_vle8_v_u8m1(sc, vl);
vuint8m1_t aux = __riscv_vand_vx_u8m1(scales, 0x0F, vl);
vint16m1_t q8sums = __riscv_vle16_v_i16m1(y[i].bsums, vl);
vuint8mf2_t scales_2 = __riscv_vle8_v_u8mf2(sc, vl);
vuint8mf2_t mins8 = __riscv_vsrl_vx_u8mf2(scales_2, 0x4, vl);
vint16m1_t mins = __riscv_vreinterpret_v_u16m1_i16m1(__riscv_vzext_vf2_u16m1(mins8, vl));
vint32m2_t prod = __riscv_vwmul_vv_i32m2(q8sums, mins, vl);
vint32m1_t vsums = __riscv_vredsum_vs_i32m2_i32m1(prod, __riscv_vmv_v_x_i32m1(0, 1), vl);
sumf += dmin * __riscv_vmv_x_s_i32m1_i32(vsums);
vl = 32;
vint32m1_t vzero = __riscv_vmv_v_x_i32m1(0, 1);
vuint8m1_t v_b = __riscv_vle8_v_u8m1(temp_01, vl);
uint8_t is=0;
int isum=0;
for (int j = 0; j < QK_K/128; ++j) {
// load Q2
vuint8m1_t q2_x = __riscv_vle8_v_u8m1(q2, vl);
vuint8m1_t q2_0 = __riscv_vand_vx_u8m1(q2_x, 0x03, vl);
vuint8m1_t q2_1 = __riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q2_x, 0x2, vl), 0x03 , vl);
vuint8m1_t q2_2 = __riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q2_x, 0x4, vl), 0x03 , vl);
vuint8m1_t q2_3 = __riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q2_x, 0x6, vl), 0x03 , vl);
// duplicate scale elements for product
vuint8m1_t sc0 = __riscv_vrgather_vv_u8m1(aux, __riscv_vadd_vx_u8m1(v_b, 0+is, vl), vl);
vuint8m1_t sc1 = __riscv_vrgather_vv_u8m1(aux, __riscv_vadd_vx_u8m1(v_b, 2+is, vl), vl);
vuint8m1_t sc2 = __riscv_vrgather_vv_u8m1(aux, __riscv_vadd_vx_u8m1(v_b, 4+is, vl), vl);
vuint8m1_t sc3 = __riscv_vrgather_vv_u8m1(aux, __riscv_vadd_vx_u8m1(v_b, 6+is, vl), vl);
vint16m2_t p0 = __riscv_vreinterpret_v_u16m2_i16m2(__riscv_vwmulu_vv_u16m2(q2_0, sc0, vl));
vint16m2_t p1 = __riscv_vreinterpret_v_u16m2_i16m2(__riscv_vwmulu_vv_u16m2(q2_1, sc1, vl));
vint16m2_t p2 = __riscv_vreinterpret_v_u16m2_i16m2(__riscv_vwmulu_vv_u16m2(q2_2, sc2, vl));
vint16m2_t p3 = __riscv_vreinterpret_v_u16m2_i16m2(__riscv_vwmulu_vv_u16m2(q2_3, sc3, vl));
// load Q8
vint8m1_t q8_0 = __riscv_vle8_v_i8m1(q8, vl);
vint8m1_t q8_1 = __riscv_vle8_v_i8m1(q8+32, vl);
vint8m1_t q8_2 = __riscv_vle8_v_i8m1(q8+64, vl);
vint8m1_t q8_3 = __riscv_vle8_v_i8m1(q8+96, vl);
vint32m4_t s0 = __riscv_vwmul_vv_i32m4(p0, __riscv_vwcvt_x_x_v_i16m2(q8_0, vl), vl);
vint32m4_t s1 = __riscv_vwmul_vv_i32m4(p1, __riscv_vwcvt_x_x_v_i16m2(q8_1, vl), vl);
vint32m4_t s2 = __riscv_vwmul_vv_i32m4(p2, __riscv_vwcvt_x_x_v_i16m2(q8_2, vl), vl);
vint32m4_t s3 = __riscv_vwmul_vv_i32m4(p3, __riscv_vwcvt_x_x_v_i16m2(q8_3, vl), vl);
vint32m1_t isum0 = __riscv_vredsum_vs_i32m4_i32m1(__riscv_vadd_vv_i32m4(s0, s1, vl), vzero, vl);
vint32m1_t isum1 = __riscv_vredsum_vs_i32m4_i32m1(__riscv_vadd_vv_i32m4(s2, s3, vl), isum0, vl);
isum += __riscv_vmv_x_s_i32m1_i32(isum1);
q2+=32; q8+=128; is=8;
}
sumf += dall * isum;
}
*s = sumf;
#elif defined(__POWER9_VECTOR__)
const vector signed char lowMask = vec_splats((signed char)0x3);
const vector signed char lowScaleMask = vec_splats((signed char)0xF);
const vector int v0 = vec_splats((int32_t)0);
const vector unsigned char v2 = vec_splats((unsigned char)0x2);
const vector unsigned char v6 = vec_splats((unsigned char)0x6);
const vector unsigned char v4 = vec_splats((unsigned char)0x4);
vector float vsumf0 = vec_splats(0.0f);
vector float vsumf1 = vec_splats(0.0f);
vector float vsumf2 = vec_splats(0.0f);
vector float vsumf3 = vec_splats(0.0f);
for (int i = 0; i < nb; ++i) {
vector float vxd = vec_splats(GGML_FP16_TO_FP32(x[i].d));
vector float vyd = vec_splats(y[i].d);
vector float vd = vec_mul(vxd, vyd);
vector float vxmin = vec_splats(GGML_FP16_TO_FP32(x[i].dmin));
vector float vdmin = vec_mul(vxmin, vyd);
vector signed short q8ysums0 = vec_xl( 0, y[i].bsums);
vector signed short q8ysums1 = vec_xl(16, y[i].bsums);
vector signed char q2xmins = (vector signed char)vec_xl( 0, x[i].scales);
vector signed char vscales = vec_and(q2xmins, lowScaleMask);
q2xmins = vec_sr(q2xmins, v4);
vector signed short q2xmins0 = vec_unpackh(q2xmins);
vector signed short q2xmins1 = vec_unpackl(q2xmins);
vector signed int prod0 = vec_mule(q2xmins0, q8ysums0);
vector signed int prod1 = vec_mulo(q2xmins0, q8ysums0);
vector signed int prod2 = vec_mule(q2xmins1, q8ysums1);
vector signed int prod3 = vec_mulo(q2xmins1, q8ysums1);
vsumf0 = vec_nmsub(vec_ctf(prod0, 0), vdmin, vsumf0);
vsumf1 = vec_nmsub(vec_ctf(prod1, 0), vdmin, vsumf1);
vsumf2 = vec_nmsub(vec_ctf(prod2, 0), vdmin, vsumf2);
vsumf3 = vec_nmsub(vec_ctf(prod3, 0), vdmin, vsumf3);
vector signed int vsumi0 = v0;
vector signed int vsumi1 = v0;
vector signed int vsumi2 = v0;
vector signed int vsumi3 = v0;
vector signed int vsumi4 = v0;
vector signed int vsumi5 = v0;
vector signed int vsumi6 = v0;
vector signed int vsumi7 = v0;
const uint8_t * restrict q2 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
for (int j = 0; j < QK_K/128; ++j) {
__builtin_prefetch(q2, 0, 1);
__builtin_prefetch(q8, 0, 1);
vector signed char qxs0 = (vector signed char)vec_xl( 0, q2);
vector signed char qxs1 = (vector signed char)vec_xl(16, q2);
q2 += 32;
vector unsigned char q2x00 = (vector unsigned char)vec_and(qxs0, lowMask);
vector unsigned char q2x01 = (vector unsigned char)vec_and(vec_sr(qxs0, v2), lowMask);
vector unsigned char q2x02 = (vector unsigned char)vec_and(vec_sr(qxs0, v4), lowMask);
vector unsigned char q2x03 = (vector unsigned char)vec_and(vec_sr(qxs0, v6), lowMask);
vector unsigned char q2x10 = (vector unsigned char)vec_and(qxs1, lowMask);
vector unsigned char q2x11 = (vector unsigned char)vec_and(vec_sr(qxs1, v2), lowMask);
vector unsigned char q2x12 = (vector unsigned char)vec_and(vec_sr(qxs1, v4), lowMask);
vector unsigned char q2x13 = (vector unsigned char)vec_and(vec_sr(qxs1, v6), lowMask);
vector signed char q8y00 = vec_xl( 0, q8);
vector signed char q8y10 = vec_xl( 16, q8);
vector signed char q8y01 = vec_xl( 32, q8);
vector signed char q8y11 = vec_xl( 48, q8);
vector signed char q8y02 = vec_xl( 64, q8);
vector signed char q8y12 = vec_xl( 80, q8);
vector signed char q8y03 = vec_xl( 96, q8);
vector signed char q8y13 = vec_xl(112, q8);
q8 += 128;
vector signed int qv0 = vec_msum(q8y00, q2x00, v0);
vector signed int qv1 = vec_msum(q8y01, q2x01, v0);
vector signed int qv2 = vec_msum(q8y02, q2x02, v0);
vector signed int qv3 = vec_msum(q8y03, q2x03, v0);
vector signed int qv4 = vec_msum(q8y10, q2x10, v0);
vector signed int qv5 = vec_msum(q8y11, q2x11, v0);
vector signed int qv6 = vec_msum(q8y12, q2x12, v0);
vector signed int qv7 = vec_msum(q8y13, q2x13, v0);
vector signed short vscales_07 = vec_unpackh(vscales);
vector signed int vscales_03 = vec_unpackh(vscales_07);
vector signed int vscales_47 = vec_unpackl(vscales_07);
vector signed int vs0 = vec_splat(vscales_03, 0);
vector signed int vs1 = vec_splat(vscales_03, 1);
vector signed int vs2 = vec_splat(vscales_03, 2);
vector signed int vs3 = vec_splat(vscales_03, 3);
vector signed int vs4 = vec_splat(vscales_47, 0);
vector signed int vs5 = vec_splat(vscales_47, 1);
vector signed int vs6 = vec_splat(vscales_47, 2);
vector signed int vs7 = vec_splat(vscales_47, 3);
vscales = vec_sld(vscales, vscales, 8);
vsumi0 = vec_add(vec_mul(qv0, vs0), vsumi0);
vsumi1 = vec_add(vec_mul(qv1, vs2), vsumi1);
vsumi2 = vec_add(vec_mul(qv2, vs4), vsumi2);
vsumi3 = vec_add(vec_mul(qv3, vs6), vsumi3);
vsumi4 = vec_add(vec_mul(qv4, vs1), vsumi4);
vsumi5 = vec_add(vec_mul(qv5, vs3), vsumi5);
vsumi6 = vec_add(vec_mul(qv6, vs5), vsumi6);
vsumi7 = vec_add(vec_mul(qv7, vs7), vsumi7);
}
vsumi0 = vec_add(vsumi0, vsumi4);
vsumi1 = vec_add(vsumi1, vsumi5);
vsumi2 = vec_add(vsumi2, vsumi6);
vsumi3 = vec_add(vsumi3, vsumi7);
vsumf0 = vec_madd(vec_ctf(vsumi0, 0), vd, vsumf0);
vsumf1 = vec_madd(vec_ctf(vsumi1, 0), vd, vsumf1);
vsumf2 = vec_madd(vec_ctf(vsumi2, 0), vd, vsumf2);
vsumf3 = vec_madd(vec_ctf(vsumi3, 0), vd, vsumf3);
}
vsumf0 = vec_add(vsumf0, vsumf2);
vsumf1 = vec_add(vsumf1, vsumf3);
vsumf0 = vec_add(vsumf0, vsumf1);
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 4));
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 8));
*s = vec_extract(vsumf0, 0);
#elif defined __loongarch_asx
const __m256i m3 = __lasx_xvreplgr2vr_b(3);
const __m128i m4 = __lsx_vreplgr2vr_b(0xF);
__m256 acc = (__m256)__lasx_xvldi(0);
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const float dmin = -y[i].d * GGML_FP16_TO_FP32(x[i].dmin);
const uint8_t * restrict q2 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
const __m128i mins_and_scales = __lsx_vld((const __m128i*)x[i].scales, 0);
const __m128i scales8 = __lsx_vand_v(mins_and_scales, m4);
const __m128i mins8 = __lsx_vand_v(__lsx_vsrli_h(mins_and_scales, 4), m4);
const __m256i mins = lasx_ext8_16(mins8);
const __m256i prod = lasx_madd_h(mins, __lasx_xvld((const __m256i*)y[i].bsums, 0));
acc = __lasx_xvfmadd_s(__lasx_xvreplfr2vr_s(dmin), __lasx_xvffint_s_w(prod), acc);
const __m256i all_scales = lasx_ext8_16(scales8);
const __m128i l_scales = lasx_extracti128(all_scales, 0);
const __m128i h_scales = lasx_extracti128(all_scales, 1);
const __m256i scales[2] = {lasx_insertf128(l_scales, l_scales), lasx_insertf128(h_scales, h_scales)};
__m256i sumi = __lasx_xvldi(0);
for (int j = 0; j < QK_K/128; ++j) {
const __m256i q2bits = __lasx_xvld((const __m256i*)q2, 0); q2 += 32;
const __m256i q8_0 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q8_1 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q8_2 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q8_3 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q2_0 = __lasx_xvand_v(q2bits, m3);
const __m256i q2_1 = __lasx_xvand_v(__lasx_xvsrli_h(q2bits, 2), m3);
const __m256i q2_2 = __lasx_xvand_v(__lasx_xvsrli_h(q2bits, 4), m3);
const __m256i q2_3 = __lasx_xvand_v(__lasx_xvsrli_h(q2bits, 6), m3);
__m256i p0 = lasx_maddubs_h(q2_0, q8_0);
__m256i p1 = lasx_maddubs_h(q2_1, q8_1);
__m256i p2 = lasx_maddubs_h(q2_2, q8_2);
__m256i p3 = lasx_maddubs_h(q2_3, q8_3);
p0 = lasx_madd_h(lasx_shuffle_b(scales[j], get_scale_shuffle_q3k(0)), p0);
p1 = lasx_madd_h(lasx_shuffle_b(scales[j], get_scale_shuffle_q3k(1)), p1);
p2 = lasx_madd_h(lasx_shuffle_b(scales[j], get_scale_shuffle_q3k(2)), p2);
p3 = lasx_madd_h(lasx_shuffle_b(scales[j], get_scale_shuffle_q3k(3)), p3);
p0 = __lasx_xvadd_w(p0, p1);
p2 = __lasx_xvadd_w(p2, p3);
sumi = __lasx_xvadd_w(sumi, __lasx_xvadd_w(p0, p2));
}
acc = __lasx_xvfmadd_s(__lasx_xvreplfr2vr_s(d), __lasx_xvffint_s_w(sumi), acc);
}
*s = hsum_float_8(acc);
#else
float sumf = 0;
for (int i = 0; i < nb; ++i) {
const uint8_t * q2 = x[i].qs;
const int8_t * q8 = y[i].qs;
const uint8_t * sc = x[i].scales;
int summs = 0;
for (int j = 0; j < 16; ++j) {
summs += y[i].bsums[j] * (sc[j] >> 4);
}
const float dall = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const float dmin = y[i].d * GGML_FP16_TO_FP32(x[i].dmin);
int isum = 0;
int is = 0;
int d;
for (int k = 0; k < QK_K/128; ++k) {
int shift = 0;
for (int j = 0; j < 4; ++j) {
d = sc[is++] & 0xF;
int isuml = 0;
for (int l = 0; l < 16; ++l) isuml += q8[l] * ((q2[l] >> shift) & 3);
isum += d * isuml;
d = sc[is++] & 0xF;
isuml = 0;
for (int l = 16; l < 32; ++l) isuml += q8[l] * ((q2[l] >> shift) & 3);
isum += d * isuml;
shift += 2;
q8 += 32;
}
q2 += 32;
}
sumf += dall * isum - dmin * summs;
}
*s = sumf;
#endif
} | O3 | c | ggml_vec_dot_q2_K_q8_K:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, 0x28(%rsp)
jne 0x332be
vxorps %xmm0, %xmm0, %xmm0
cmpl $0x100, %edi # imm = 0x100
jl 0x33298
shrl $0x8, %edi
leaq 0x10(%rcx), %rax
leaq 0x4(%r9), %rdx
xorl %r8d, %r8d
movq 0x15e57(%rip), %r10 # 0x48f68
vbroadcastss 0x3002(%rip), %xmm1 # 0x3611c
vpbroadcastb 0x74bf(%rip), %xmm2 # 0x3a5e2
vpbroadcastb 0x74b7(%rip), %ymm3 # 0x3a5e3
vmovdqa 0x72ac(%rip), %ymm4 # 0x3a3e0
vmovdqa 0x72c4(%rip), %ymm5 # 0x3a400
vmovdqa 0x72dc(%rip), %ymm6 # 0x3a420
vmovdqa 0x72f4(%rip), %ymm7 # 0x3a440
imulq $0x124, %r8, %r11 # imm = 0x124
vmovss (%r9,%r11), %xmm8
imulq $0x54, %r8, %rbx
movzwl 0x50(%rcx,%rbx), %r14d
vmovss (%r10,%r14,4), %xmm9
vxorps %xmm1, %xmm8, %xmm10
movzwl 0x52(%rcx,%rbx), %r14d
vmulss (%r10,%r14,4), %xmm10, %xmm10
vmovdqu (%rcx,%rbx), %xmm12
vpsrlw $0x4, %xmm12, %xmm11
vpand %xmm2, %xmm11, %xmm11
vpmovzxbw %xmm11, %ymm11 # ymm11 = xmm11[0],zero,xmm11[1],zero,xmm11[2],zero,xmm11[3],zero,xmm11[4],zero,xmm11[5],zero,xmm11[6],zero,xmm11[7],zero,xmm11[8],zero,xmm11[9],zero,xmm11[10],zero,xmm11[11],zero,xmm11[12],zero,xmm11[13],zero,xmm11[14],zero,xmm11[15],zero
vpmaddwd 0x104(%r9,%r11), %ymm11, %ymm11
vcvtdq2ps %ymm11, %ymm11
vpand %xmm2, %xmm12, %xmm12
vpmovzxbw %xmm12, %ymm12 # ymm12 = xmm12[0],zero,xmm12[1],zero,xmm12[2],zero,xmm12[3],zero,xmm12[4],zero,xmm12[5],zero,xmm12[6],zero,xmm12[7],zero,xmm12[8],zero,xmm12[9],zero,xmm12[10],zero,xmm12[11],zero,xmm12[12],zero,xmm12[13],zero,xmm12[14],zero,xmm12[15],zero
vpermq $0x44, %ymm12, %ymm14 # ymm14 = ymm12[0,1,0,1]
vpermq $0xee, %ymm12, %ymm12 # ymm12 = ymm12[2,3,2,3]
movb $0x1, %r11b
xorl %ebx, %ebx
vpxor %xmm13, %xmm13, %xmm13
vmovdqu (%rax,%rbx), %ymm15
vpsrlw $0x2, %ymm15, %ymm16
vpsrlw $0x4, %ymm15, %ymm17
vpsrlw $0x6, %ymm15, %ymm18
vpand %ymm3, %ymm15, %ymm15
vpmaddubsw (%rdx,%rbx,4), %ymm15, %ymm15
vpandq %ymm3, %ymm16, %ymm16
vpmaddubsw 0x20(%rdx,%rbx,4), %ymm16, %ymm16
vpandq %ymm3, %ymm17, %ymm17
vpmaddubsw 0x40(%rdx,%rbx,4), %ymm17, %ymm17
vpandq %ymm3, %ymm18, %ymm18
vpmaddubsw 0x60(%rdx,%rbx,4), %ymm18, %ymm18
vpshufb %ymm4, %ymm14, %ymm19
vpmaddwd %ymm15, %ymm19, %ymm15
vpaddd %ymm13, %ymm15, %ymm13
vpshufb %ymm5, %ymm14, %ymm15
vpmaddwd %ymm16, %ymm15, %ymm15
vpaddd %ymm15, %ymm13, %ymm13
vpshufb %ymm6, %ymm14, %ymm15
vpmaddwd %ymm17, %ymm15, %ymm15
vpshufb %ymm7, %ymm14, %ymm14
vpmaddwd %ymm18, %ymm14, %ymm14
vpaddd %ymm14, %ymm15, %ymm14
vpaddd %ymm14, %ymm13, %ymm13
addq $0x20, %rbx
vmovdqa %ymm12, %ymm14
testb $0x1, %r11b
movl $0x0, %r11d
jne 0x331bb
vmulss %xmm9, %xmm8, %xmm8
vbroadcastss %xmm10, %ymm9
vfmadd213ps %ymm0, %ymm9, %ymm11 # ymm11 = (ymm9 * ymm11) + ymm0
vbroadcastss %xmm8, %ymm8
vcvtdq2ps %ymm13, %ymm0
vfmadd213ps %ymm11, %ymm8, %ymm0 # ymm0 = (ymm8 * ymm0) + ymm11
incq %r8
addq $0x54, %rax
addq $0x124, %rdx # imm = 0x124
cmpq %rdi, %r8
jne 0x3314c
vextractf128 $0x1, %ymm0, %xmm1
vaddps %xmm0, %xmm1, %xmm0
vshufpd $0x1, %xmm0, %xmm0, %xmm1 # xmm1 = xmm0[1,0]
vaddps %xmm1, %xmm0, %xmm0
vhaddps %xmm0, %xmm0, %xmm0
vmovss %xmm0, (%rsi)
addq $0x8, %rsp
popq %rbx
popq %r14
vzeroupper
retq
leaq 0x3971(%rip), %rdi # 0x36c36
leaq 0xfd24(%rip), %rsi # 0x42ff0
leaq 0x102f2(%rip), %rcx # 0x435c5
movl $0x1067, %edx # imm = 0x1067
callq 0x83b0
| ggml_vec_dot_q2_K_q8_K:
push r14
push rbx
push rax
cmp [rsp+18h+arg_8], 1
jnz loc_332BE
vxorps xmm0, xmm0, xmm0
cmp edi, 100h
jl loc_33298
shr edi, 8
lea rax, [rcx+10h]
lea rdx, [r9+4]
xor r8d, r8d
mov r10, cs:ggml_table_f32_f16_ptr
vbroadcastss xmm1, dword ptr cs:byte_360F8+24h
vpbroadcastb xmm2, cs:byte_3A5E2
vpbroadcastb ymm3, cs:byte_3A5E3
vmovdqa ymm4, cs:ymmword_3A3E0
vmovdqa ymm5, cs:ymmword_3A400
vmovdqa ymm6, cs:ymmword_3A420
vmovdqa ymm7, cs:ymmword_3A440
loc_3314C:
imul r11, r8, 124h
vmovss xmm8, dword ptr [r9+r11]
imul rbx, r8, 54h ; 'T'
movzx r14d, word ptr [rcx+rbx+50h]
vmovss xmm9, dword ptr [r10+r14*4]
vxorps xmm10, xmm8, xmm1
movzx r14d, word ptr [rcx+rbx+52h]
vmulss xmm10, xmm10, dword ptr [r10+r14*4]
vmovdqu xmm12, xmmword ptr [rcx+rbx]
vpsrlw xmm11, xmm12, 4
vpand xmm11, xmm11, xmm2
vpmovzxbw ymm11, xmm11
vpmaddwd ymm11, ymm11, ymmword ptr [r9+r11+104h]
vcvtdq2ps ymm11, ymm11
vpand xmm12, xmm12, xmm2
vpmovzxbw ymm12, xmm12
vpermq ymm14, ymm12, 44h ; 'D'
vpermq ymm12, ymm12, 0EEh
mov r11b, 1
xor ebx, ebx
vpxor xmm13, xmm13, xmm13
loc_331BB:
vmovdqu ymm15, ymmword ptr [rax+rbx]
vpsrlw ymm16, ymm15, 2
vpsrlw ymm17, ymm15, 4
vpsrlw ymm18, ymm15, 6
vpand ymm15, ymm15, ymm3
vpmaddubsw ymm15, ymm15, ymmword ptr [rdx+rbx*4]
vpandq ymm16, ymm16, ymm3
vpmaddubsw ymm16, ymm16, ymmword ptr [rdx+rbx*4+20h]
vpandq ymm17, ymm17, ymm3
vpmaddubsw ymm17, ymm17, ymmword ptr [rdx+rbx*4+40h]
vpandq ymm18, ymm18, ymm3
vpmaddubsw ymm18, ymm18, ymmword ptr [rdx+rbx*4+60h]
vpshufb ymm19, ymm14, ymm4
vpmaddwd ymm15, ymm19, ymm15
vpaddd ymm13, ymm15, ymm13
vpshufb ymm15, ymm14, ymm5
vpmaddwd ymm15, ymm15, ymm16
vpaddd ymm13, ymm13, ymm15
vpshufb ymm15, ymm14, ymm6
vpmaddwd ymm15, ymm15, ymm17
vpshufb ymm14, ymm14, ymm7
vpmaddwd ymm14, ymm14, ymm18
vpaddd ymm14, ymm15, ymm14
vpaddd ymm13, ymm13, ymm14
add rbx, 20h ; ' '
vmovdqa ymm14, ymm12
test r11b, 1
mov r11d, 0
jnz loc_331BB
vmulss xmm8, xmm8, xmm9
vbroadcastss ymm9, xmm10
vfmadd213ps ymm11, ymm9, ymm0
vbroadcastss ymm8, xmm8
vcvtdq2ps ymm0, ymm13
vfmadd213ps ymm0, ymm8, ymm11
inc r8
add rax, 54h ; 'T'
add rdx, 124h
cmp r8, rdi
jnz loc_3314C
loc_33298:
vextractf128 xmm1, ymm0, 1
vaddps xmm0, xmm1, xmm0
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmovss dword ptr [rsi], xmm0
add rsp, 8
pop rbx
pop r14
vzeroupper
retn
loc_332BE:
lea rdi, aNrc1; "nrc == 1"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlVecDot_9; "void ggml_vec_dot_q2_K_q8_K(int, float "...
mov edx, 1067h
call ___assert_fail
| long long ggml_vec_dot_q2_K_q8_K(
int a1,
long long _RSI,
__m128 _XMM0,
long long a4,
long long _RCX,
long long a6,
long long _R9,
int a8,
int a9)
{
long long result; // rax
long long v13; // rdi
long long v14; // rdx
long long v15; // r8
char v41; // r11
bool v67; // zf
if ( a9 != 1 )
__assert_fail(
"nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c",
4199LL,
"void ggml_vec_dot_q2_K_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)");
__asm { vxorps xmm0, xmm0, xmm0 }
if ( a1 >= 256 )
{
v13 = (unsigned int)a1 >> 8;
result = _RCX + 16;
v14 = _R9 + 4;
v15 = 0LL;
_R10 = &ggml_table_f32_f16;
__asm
{
vbroadcastss xmm1, dword ptr cs:byte_360F8+24h
vpbroadcastb xmm2, cs:byte_3A5E2
vpbroadcastb ymm3, cs:byte_3A5E3
vmovdqa ymm4, cs:ymmword_3A3E0
vmovdqa ymm5, cs:ymmword_3A400
vmovdqa ymm6, cs:ymmword_3A420
vmovdqa ymm7, cs:ymmword_3A440
}
do
{
_R11 = 292 * v15;
__asm { vmovss xmm8, dword ptr [r9+r11] }
_RBX = 84 * v15;
_R14 = *(unsigned __int16 *)(_RCX + 84 * v15 + 80);
__asm
{
vmovss xmm9, dword ptr [r10+r14*4]
vxorps xmm10, xmm8, xmm1
vmulss xmm10, xmm10, dword ptr [r10+r14*4]
vmovdqu xmm12, xmmword ptr [rcx+rbx]
vpsrlw xmm11, xmm12, 4
vpand xmm11, xmm11, xmm2
vpmovzxbw ymm11, xmm11
vpmaddwd ymm11, ymm11, ymmword ptr [r9+r11+104h]
vcvtdq2ps ymm11, ymm11
vpand xmm12, xmm12, xmm2
vpmovzxbw ymm12, xmm12
vpermq ymm14, ymm12, 44h ; 'D'
vpermq ymm12, ymm12, 0EEh
}
v41 = 1;
_RBX = 0LL;
__asm { vpxor xmm13, xmm13, xmm13 }
do
{
__asm
{
vmovdqu ymm15, ymmword ptr [rax+rbx]
vpsrlw ymm16, ymm15, 2
vpsrlw ymm17, ymm15, 4
vpsrlw ymm18, ymm15, 6
vpand ymm15, ymm15, ymm3
vpmaddubsw ymm15, ymm15, ymmword ptr [rdx+rbx*4]
vpandq ymm16, ymm16, ymm3
vpmaddubsw ymm16, ymm16, ymmword ptr [rdx+rbx*4+20h]
vpandq ymm17, ymm17, ymm3
vpmaddubsw ymm17, ymm17, ymmword ptr [rdx+rbx*4+40h]
vpandq ymm18, ymm18, ymm3
vpmaddubsw ymm18, ymm18, ymmword ptr [rdx+rbx*4+60h]
vpshufb ymm19, ymm14, ymm4
vpmaddwd ymm15, ymm19, ymm15
vpaddd ymm13, ymm15, ymm13
vpshufb ymm15, ymm14, ymm5
vpmaddwd ymm15, ymm15, ymm16
vpaddd ymm13, ymm13, ymm15
vpshufb ymm15, ymm14, ymm6
vpmaddwd ymm15, ymm15, ymm17
vpshufb ymm14, ymm14, ymm7
vpmaddwd ymm14, ymm14, ymm18
vpaddd ymm14, ymm15, ymm14
vpaddd ymm13, ymm13, ymm14
}
_RBX += 32LL;
__asm { vmovdqa ymm14, ymm12 }
v67 = (v41 & 1) == 0;
v41 = 0;
}
while ( !v67 );
__asm
{
vmulss xmm8, xmm8, xmm9
vbroadcastss ymm9, xmm10
vfmadd213ps ymm11, ymm9, ymm0
vbroadcastss ymm8, xmm8
vcvtdq2ps ymm0, ymm13
vfmadd213ps ymm0, ymm8, ymm11
}
++v15;
result += 84LL;
v14 += 292LL;
}
while ( v15 != v13 );
}
__asm
{
vextractf128 xmm1, ymm0, 1
vaddps xmm0, xmm1, xmm0
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmovss dword ptr [rsi], xmm0
vzeroupper
}
return result;
}
| ggml_vec_dot_q2_K_q8_K:
PUSH R14
PUSH RBX
PUSH RAX
CMP dword ptr [RSP + 0x28],0x1
JNZ 0x001332be
VXORPS XMM0,XMM0,XMM0
CMP EDI,0x100
JL 0x00133298
SHR EDI,0x8
LEA RAX,[RCX + 0x10]
LEA RDX,[R9 + 0x4]
XOR R8D,R8D
MOV R10,qword ptr [0x00148f68]
VBROADCASTSS XMM1,dword ptr [0x0013611c]
VPBROADCASTB XMM2,byte ptr [0x0013a5e2]
VPBROADCASTB YMM3,byte ptr [0x0013a5e3]
VMOVDQA YMM4,ymmword ptr [0x0013a3e0]
VMOVDQA YMM5,ymmword ptr [0x0013a400]
VMOVDQA YMM6,ymmword ptr [0x0013a420]
VMOVDQA YMM7,ymmword ptr [0x0013a440]
LAB_0013314c:
IMUL R11,R8,0x124
VMOVSS XMM8,dword ptr [R9 + R11*0x1]
IMUL RBX,R8,0x54
MOVZX R14D,word ptr [RCX + RBX*0x1 + 0x50]
VMOVSS XMM9,dword ptr [R10 + R14*0x4]
VXORPS XMM10,XMM8,XMM1
MOVZX R14D,word ptr [RCX + RBX*0x1 + 0x52]
VMULSS XMM10,XMM10,dword ptr [R10 + R14*0x4]
VMOVDQU XMM12,xmmword ptr [RCX + RBX*0x1]
VPSRLW XMM11,XMM12,0x4
VPAND XMM11,XMM11,XMM2
VPMOVZXBW YMM11,XMM11
VPMADDWD YMM11,YMM11,ymmword ptr [R9 + R11*0x1 + 0x104]
VCVTDQ2PS YMM11,YMM11
VPAND XMM12,XMM12,XMM2
VPMOVZXBW YMM12,XMM12
VPERMQ YMM14,YMM12,0x44
VPERMQ YMM12,YMM12,0xee
MOV R11B,0x1
XOR EBX,EBX
VPXOR XMM13,XMM13,XMM13
LAB_001331bb:
VMOVDQU YMM15,ymmword ptr [RAX + RBX*0x1]
VPSRLW YMM0,YMM15,0x2
VPSRLW YMM1,YMM15,0x4
VPSRLW YMM2,YMM15,0x6
VPAND YMM15,YMM15,YMM3
VPMADDUBSW YMM15,YMM15,ymmword ptr [RDX + RBX*0x4]
VPANDQ YMM0,YMM0,YMM3
VPMADDUBSW YMM0,YMM0,ymmword ptr [RDX + RBX*0x4 + 0x20]
VPANDQ YMM1,YMM1,YMM3
VPMADDUBSW YMM1,YMM1,ymmword ptr [RDX + RBX*0x4 + 0x40]
VPANDQ YMM2,YMM2,YMM3
VPMADDUBSW YMM2,YMM2,ymmword ptr [RDX + RBX*0x4 + 0x60]
VPSHUFB YMM3,YMM14,YMM4
VPMADDWD YMM15,YMM3,YMM15
VPADDD YMM13,YMM15,YMM13
VPSHUFB YMM15,YMM14,YMM5
VPMADDWD YMM15,YMM15,YMM0
VPADDD YMM13,YMM13,YMM15
VPSHUFB YMM15,YMM14,YMM6
VPMADDWD YMM15,YMM15,YMM1
VPSHUFB YMM14,YMM14,YMM7
VPMADDWD YMM14,YMM14,YMM2
VPADDD YMM14,YMM15,YMM14
VPADDD YMM13,YMM13,YMM14
ADD RBX,0x20
VMOVDQA YMM14,YMM12
TEST R11B,0x1
MOV R11D,0x0
JNZ 0x001331bb
VMULSS XMM8,XMM8,XMM9
VBROADCASTSS YMM9,XMM10
VFMADD213PS YMM11,YMM9,YMM0
VBROADCASTSS YMM8,XMM8
VCVTDQ2PS YMM0,YMM13
VFMADD213PS YMM0,YMM8,YMM11
INC R8
ADD RAX,0x54
ADD RDX,0x124
CMP R8,RDI
JNZ 0x0013314c
LAB_00133298:
VEXTRACTF128 XMM1,YMM0,0x1
VADDPS XMM0,XMM1,XMM0
VSHUFPD XMM1,XMM0,XMM0,0x1
VADDPS XMM0,XMM0,XMM1
VHADDPS XMM0,XMM0,XMM0
VMOVSS dword ptr [RSI],XMM0
ADD RSP,0x8
POP RBX
POP R14
VZEROUPPER
RET
LAB_001332be:
LEA RDI,[0x136c36]
LEA RSI,[0x142ff0]
LEA RCX,[0x1435c5]
MOV EDX,0x1067
CALL 0x001083b0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_vec_dot_q2_K_q8_K
(uint param_1,int4 *param_2,int8 param_3,long param_4,int8 param_5,
long param_6,int8 param_7,int param_8)
{
float fVar1;
float fVar2;
int1 auVar3 [32];
bool bVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
ulong uVar9;
bool bVar10;
int1 auVar11 [32];
int1 auVar12 [32];
int1 auVar13 [32];
int1 auVar14 [32];
int1 auVar15 [32];
int1 auVar16 [32];
int1 auVar17 [16];
int1 auVar18 [16];
int1 auVar19 [64];
int1 auVar20 [64];
int1 auVar21 [32];
int1 auVar22 [64];
int1 auVar23 [32];
int1 auVar24 [16];
int1 auVar25 [64];
if (param_8 != 1) {
/* WARNING: Subroutine does not return */
__assert_fail("nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c"
,0x1067,
"void ggml_vec_dot_q2_K_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)"
);
}
auVar24 = ZEXT816(0) << 0x40;
if (0xff < (int)param_1) {
lVar5 = param_4 + 0x10;
lVar6 = param_6 + 4;
uVar9 = 0;
auVar19 = ZEXT1664(CONCAT412(DAT_0013611c,
CONCAT48(DAT_0013611c,CONCAT44(DAT_0013611c,DAT_0013611c))));
auVar20 = ZEXT1664(CONCAT115(DAT_0013a5e2,
CONCAT114(DAT_0013a5e2,
CONCAT113(DAT_0013a5e2,
CONCAT112(DAT_0013a5e2,
CONCAT111(DAT_0013a5e2,
CONCAT110(DAT_0013a5e2,
CONCAT19(
DAT_0013a5e2,
CONCAT18(DAT_0013a5e2,
CONCAT17(DAT_0013a5e2,
CONCAT16(DAT_0013a5e2,
CONCAT15(DAT_0013a5e2,
CONCAT14(
DAT_0013a5e2,
CONCAT13(DAT_0013a5e2,
CONCAT12(DAT_0013a5e2,
CONCAT11(DAT_0013a5e2,
DAT_0013a5e2)))))))))))
)))));
auVar22 = ZEXT3264(CONCAT131(DAT_0013a5e3,
CONCAT130(DAT_0013a5e3,
CONCAT129(DAT_0013a5e3,
CONCAT128(DAT_0013a5e3,
CONCAT127(DAT_0013a5e3,
CONCAT126(DAT_0013a5e3,
CONCAT125(
DAT_0013a5e3,
CONCAT124(DAT_0013a5e3,
CONCAT123(DAT_0013a5e3,
CONCAT122(DAT_0013a5e3,
CONCAT121(
DAT_0013a5e3,
CONCAT120(DAT_0013a5e3,
CONCAT119(DAT_0013a5e3,
CONCAT118(DAT_0013a5e3,
CONCAT117(
DAT_0013a5e3,
CONCAT116(DAT_0013a5e3,
CONCAT115(DAT_0013a5e3,
CONCAT114(DAT_0013a5e3,
CONCAT113(
DAT_0013a5e3,
CONCAT112(DAT_0013a5e3,
CONCAT111(DAT_0013a5e3,
CONCAT110(DAT_0013a5e3,
CONCAT19(
DAT_0013a5e3,
CONCAT18(DAT_0013a5e3,
CONCAT17(DAT_0013a5e3,
CONCAT16(DAT_0013a5e3,
CONCAT15(DAT_0013a5e3,
CONCAT14(
DAT_0013a5e3,
CONCAT13(DAT_0013a5e3,
CONCAT12(DAT_0013a5e3,
CONCAT11(DAT_0013a5e3,
DAT_0013a5e3)))))))))))
)))))))))))))))))))));
do {
fVar1 = *(float *)(param_6 + uVar9 * 0x124);
lVar7 = uVar9 * 0x54;
fVar2 = (float)((uint)fVar1 ^ auVar19._0_4_) *
*(float *)(PTR_ggml_table_f32_f16_00148f68 +
(ulong)*(ushort *)(param_4 + 0x52 + lVar7) * 4);
auVar24 = vpsrlw_avx(*(int1 (*) [16])(param_4 + lVar7),4);
auVar24 = vpand_avx(auVar24,auVar20._0_16_);
auVar3 = vpmovzxbw_avx2(auVar24);
auVar3 = vpmaddwd_avx2(auVar3,*(int1 (*) [32])(param_6 + 0x104 + uVar9 * 0x124));
auVar3 = vcvtdq2ps_avx(auVar3);
auVar24 = vpand_avx(*(int1 (*) [16])(param_4 + lVar7),auVar20._0_16_);
auVar23 = vpmovzxbw_avx2(auVar24);
auVar16 = vpermq_avx2(auVar23,0x44);
auVar23 = vpermq_avx2(auVar23,0xee);
lVar8 = 0;
auVar25 = ZEXT1664((int1 [16])0x0);
bVar4 = true;
do {
bVar10 = bVar4;
auVar15 = *(int1 (*) [32])(lVar5 + lVar8);
auVar11 = vpsrlw_avx512vl(auVar15,2);
auVar12 = vpsrlw_avx512vl(auVar15,4);
auVar13 = vpsrlw_avx512vl(auVar15,6);
auVar21 = auVar22._0_32_;
auVar15 = vpand_avx2(auVar15,auVar21);
auVar15 = vpmaddubsw_avx2(auVar15,*(int1 (*) [32])(lVar6 + lVar8 * 4));
auVar11 = vpandq_avx512vl(auVar11,auVar21);
auVar14 = vpmaddubsw_avx512vl(auVar11,*(int1 (*) [32])(lVar6 + 0x20 + lVar8 * 4));
auVar11 = vpandq_avx512vl(auVar12,auVar21);
auVar12 = vpmaddubsw_avx512vl(auVar11,*(int1 (*) [32])(lVar6 + 0x40 + lVar8 * 4));
auVar19 = ZEXT3264(auVar12);
auVar11 = vpandq_avx512vl(auVar13,auVar21);
auVar13 = vpmaddubsw_avx512vl(auVar11,*(int1 (*) [32])(lVar6 + 0x60 + lVar8 * 4));
auVar20 = ZEXT3264(auVar13);
auVar11 = vpshufb_avx512vl(auVar16,_DAT_0013a3e0);
auVar22 = ZEXT3264(auVar11);
auVar15 = vpmaddwd_avx512vl(auVar11,auVar15);
auVar15 = vpaddd_avx2(auVar15,auVar25._0_32_);
auVar11 = vpshufb_avx2(auVar16,_DAT_0013a400);
auVar11 = vpmaddwd_avx512vl(auVar11,auVar14);
auVar15 = vpaddd_avx2(auVar15,auVar11);
auVar11 = vpshufb_avx2(auVar16,_DAT_0013a420);
auVar11 = vpmaddwd_avx512vl(auVar11,auVar12);
auVar16 = vpshufb_avx2(auVar16,_DAT_0013a440);
auVar16 = vpmaddwd_avx512vl(auVar16,auVar13);
auVar16 = vpaddd_avx2(auVar11,auVar16);
auVar15 = vpaddd_avx2(auVar15,auVar16);
auVar25 = ZEXT3264(auVar15);
lVar8 = lVar8 + 0x20;
auVar16 = auVar23;
bVar4 = false;
} while (bVar10);
fVar1 = fVar1 * *(float *)(PTR_ggml_table_f32_f16_00148f68 +
(ulong)*(ushort *)(param_4 + 0x50 + lVar7) * 4);
auVar16._4_4_ = fVar2;
auVar16._0_4_ = fVar2;
auVar16._8_4_ = fVar2;
auVar16._12_4_ = fVar2;
auVar16._16_4_ = fVar2;
auVar16._20_4_ = fVar2;
auVar16._24_4_ = fVar2;
auVar16._28_4_ = fVar2;
auVar24 = vfmadd213ps_fma(auVar3,auVar16,auVar14);
auVar23._4_4_ = fVar1;
auVar23._0_4_ = fVar1;
auVar23._8_4_ = fVar1;
auVar23._12_4_ = fVar1;
auVar23._16_4_ = fVar1;
auVar23._20_4_ = fVar1;
auVar23._24_4_ = fVar1;
auVar23._28_4_ = fVar1;
auVar3 = vcvtdq2ps_avx(auVar15);
auVar24 = vfmadd213ps_fma(auVar3,auVar23,ZEXT1632(auVar24));
uVar9 = uVar9 + 1;
lVar5 = lVar5 + 0x54;
lVar6 = lVar6 + 0x124;
} while (uVar9 != param_1 >> 8);
}
auVar17._0_4_ = auVar24._0_4_ + 0.0;
auVar17._4_4_ = auVar24._4_4_ + 0.0;
auVar17._8_4_ = auVar24._8_4_ + 0.0;
auVar17._12_4_ = auVar24._12_4_ + 0.0;
auVar24 = vshufpd_avx(auVar17,auVar17,1);
auVar18._0_4_ = auVar17._0_4_ + auVar24._0_4_;
auVar18._4_4_ = auVar17._4_4_ + auVar24._4_4_;
auVar18._8_4_ = auVar17._8_4_ + auVar24._8_4_;
auVar18._12_4_ = auVar17._12_4_ + auVar24._12_4_;
auVar24 = vhaddps_avx(auVar18,auVar18);
*param_2 = auVar24._0_4_;
return;
}
| |
39,560 | uf_endspace | eloqsql/storage/myisam/mi_packrec.c | static void uf_endspace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
uint spaces;
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
if (to+spaces != end)
decode_bytes(rec,bit_buff,to,end-spaces);
bfill((uchar*) end-spaces,spaces,' ');
} | O0 | c | uf_endspace:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jb 0xbd40b
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %esi
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
subl %esi, %ecx
movl %ecx, 0x4(%rdx)
shrl %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, %edx
leaq 0x20223d(%rip), %rcx # 0x2bf640
andl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
jmp 0xbd41e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0xbab50
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jbe 0xbd440
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0xbd493
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
je 0xbd473
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
movl %eax, %r8d
xorl %eax, %eax
subq %r8, %rax
addq %rax, %rcx
callq 0xbcab0
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %edx
movl $0x20, %esi
callq 0x2a2c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| uf_endspace_0:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+1Ch]
jb short loc_BD40B
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+1Ch]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
sub ecx, esi
mov [rdx+4], ecx
shr eax, cl
mov rcx, [rbp+var_8]
mov ecx, [rcx+1Ch]
mov edx, ecx
lea rcx, mask_0
and eax, [rcx+rdx*4]
mov [rbp+var_28], eax
jmp short loc_BD41E
loc_BD40B:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+1Ch]
call fill_and_get_bits_0
mov [rbp+var_28], eax
loc_BD41E:
mov ecx, [rbp+var_28]
mov [rbp+var_24], ecx
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
cmp rax, [rbp+var_20]
jbe short loc_BD440
mov rax, [rbp+var_10]
mov dword ptr [rax+28h], 1
jmp short loc_BD493
loc_BD440:
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
add rax, rcx
cmp rax, [rbp+var_20]
jz short loc_BD473
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov eax, [rbp+var_24]
mov r8d, eax
xor eax, eax
sub rax, r8
add rcx, rax
call decode_bytes_0
loc_BD473:
mov rdi, [rbp+var_20]
mov eax, [rbp+var_24]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rdi, rax
mov eax, [rbp+var_24]
mov edx, eax
mov esi, 20h ; ' '
call _memset
loc_BD493:
add rsp, 30h
pop rbp
retn
| long long uf_endspace_0(long long a1, unsigned int *a2, _BYTE *a3, _BYTE *a4)
{
unsigned int v4; // eax
int v5; // ecx
long long result; // rax
unsigned int bits_0; // [rsp+8h] [rbp-28h]
if ( a2[1] < *(_DWORD *)(a1 + 28) )
{
bits_0 = fill_and_get_bits_0(a2, *(_DWORD *)(a1 + 28));
}
else
{
v4 = *a2;
v5 = a2[1] - *(_DWORD *)(a1 + 28);
a2[1] = v5;
bits_0 = mask_0[*(unsigned int *)(a1 + 28)] & (v4 >> v5);
}
if ( &a3[bits_0] <= a4 )
{
if ( &a3[bits_0] != a4 )
decode_bytes_0(a1, (long long)a2, a3, &a4[-bits_0]);
return memset(&a4[-bits_0], 32LL, bits_0);
}
else
{
result = (long long)a2;
a2[10] = 1;
}
return result;
}
| uf_endspace:
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 qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x1c]
JC 0x001bd40b
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x1c]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
SUB ECX,ESI
MOV dword ptr [RDX + 0x4],ECX
SHR EAX,CL
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x1c]
MOV EDX,ECX
LEA RCX,[0x3bf640]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001bd41e
LAB_001bd40b:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x1c]
CALL 0x001bab50
MOV dword ptr [RBP + -0x28],EAX
LAB_001bd41e:
MOV ECX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001bd440
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],0x1
JMP 0x001bd493
LAB_001bd440:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001bd473
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV R8D,EAX
XOR EAX,EAX
SUB RAX,R8
ADD RCX,RAX
CALL 0x001bcab0
LAB_001bd473:
MOV RDI,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RDI,RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
MOV ESI,0x20
CALL 0x0012a2c0
LAB_001bd493:
ADD RSP,0x30
POP RBP
RET
|
void uf_endspace(long param_1,uint *param_2,long param_3,ulong param_4)
{
uint uVar1;
uint local_30;
if (param_2[1] < *(uint *)(param_1 + 0x1c)) {
local_30 = fill_and_get_bits(param_2,*(int4 *)(param_1 + 0x1c));
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x1c);
param_2[1] = uVar1;
local_30 = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x1c) * 4);
}
if (param_4 < param_3 + (ulong)local_30) {
param_2[10] = 1;
}
else {
if (param_3 + (ulong)local_30 != param_4) {
decode_bytes(param_1,param_2,param_3,param_4 - local_30);
}
memset((void *)(param_4 - local_30),0x20,(ulong)local_30);
}
return;
}
| |
39,561 | rw_pr_rdlock | eloqsql/mysys/thr_rwlock.c | int rw_pr_rdlock(rw_pr_lock_t *rwlock)
{
pthread_mutex_lock(&rwlock->lock);
/*
The fact that we were able to acquire 'lock' mutex means
that there are no active writers and we can acquire rd-lock.
Increment active readers counter to prevent requests for
wr-lock from succeeding and unlock mutex.
*/
rwlock->active_readers++;
pthread_mutex_unlock(&rwlock->lock);
return 0;
} | O0 | c | rw_pr_rdlock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a220
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rdi
callq 0x2a1f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| rw_pr_rdlock:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
call _pthread_mutex_lock
mov rax, [rbp+var_8]
mov ecx, [rax+58h]
add ecx, 1
mov [rax+58h], ecx
mov rdi, [rbp+var_8]
call _pthread_mutex_unlock
xor eax, eax
add rsp, 10h
pop rbp
retn
| long long rw_pr_rdlock(long long a1)
{
pthread_mutex_lock(a1);
++*(_DWORD *)(a1 + 88);
pthread_mutex_unlock(a1);
return 0LL;
}
| rw_pr_rdlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012a220
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x58]
ADD ECX,0x1
MOV dword ptr [RAX + 0x58],ECX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012a1f0
XOR EAX,EAX
ADD RSP,0x10
POP RBP
RET
|
int8 rw_pr_rdlock(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
*(int *)((long)param_1 + 0x58) = *(int *)((long)param_1 + 0x58) + 1;
pthread_mutex_unlock(param_1);
return 0;
}
| |
39,562 | GAParameter8080Reg8::GAParameter8080Reg8(char const*) | goodasm/galang8080.cpp | GAParameter8080Reg8::GAParameter8080Reg8(const char* mask){
setMask(mask);
} | O3 | cpp | GAParameter8080Reg8::GAParameter8080Reg8(char const*):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x10b090
movq -0x38(%rbp), %rdi
leaq 0x75aa0(%rip), %rax # 0x14b718
addq $0x10, %rax
movq %rax, (%rdi)
addq $0xb0, %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x44989(%rip), %rsi # 0x11a61e
callq 0xe710
jmp 0xd5c9c
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x18(%rbp)
leaq 0x40e41(%rip), %rsi # 0x116af0
callq 0xe710
jmp 0xd5cb6
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x18(%rbp)
leaq 0x49501(%rip), %rsi # 0x11f1ca
callq 0xe710
jmp 0xd5cd0
movq -0x30(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x18(%rbp)
leaq 0x3d9b9(%rip), %rsi # 0x11369c
callq 0xe710
jmp 0xd5cea
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x18(%rbp)
leaq 0x3cd36(%rip), %rsi # 0x112a33
callq 0xe710
jmp 0xd5d04
movq -0x30(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x18(%rbp)
leaq 0x3cd37(%rip), %rsi # 0x112a4e
callq 0xe710
jmp 0xd5d1e
movq -0x30(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x18(%rbp)
leaq 0x454d8(%rip), %rsi # 0x11b20c
callq 0xe710
jmp 0xd5d3b
movq -0x30(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x18(%rbp)
leaq 0x41ae1(%rip), %rsi # 0x117832
callq 0xe710
jmp 0xd5d58
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x109170
jmp 0xd5d67
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rcx
movq %rdx, -0x48(%rbp)
movq %rax, %rdx
movq -0x48(%rbp), %rax
movq %rdx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
cmpq %rax, %rcx
movq %rax, -0x40(%rbp)
je 0xd5db2
movq -0x40(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0x50(%rbp)
callq 0xe770
movq -0x30(%rbp), %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x40(%rbp)
jne 0xd5d90
jmp 0xd5df3
movq %rdx, %rcx
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
addq $0xc0, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0x60(%rbp)
callq 0xe770
movq -0x30(%rbp), %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x58(%rbp)
jne 0xd5dcf
jmp 0xd5df3
movq -0x38(%rbp), %rdi
callq 0x1091b0
movq -0x20(%rbp), %rdi
callq 0x7210
nopw %cs:(%rax,%rax)
| _ZN19GAParameter8080Reg8C2EPKc:
push rbp; Alternative name is 'GAParameter8080Reg8::GAParameter8080Reg8(char const*)'
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]; this
mov [rbp+var_38], rdi
call _ZN11GAParameterC2Ev; GAParameter::GAParameter(void)
mov rdi, [rbp+var_38]
lea rax, _ZTV19GAParameter8080Reg8; `vtable for'GAParameter8080Reg8
add rax, 10h
mov [rdi], rax
add rdi, 0B0h; this
mov [rbp+var_30], rdi
mov [rbp+var_18], rdi
lea rsi, aLdIx16B+0Eh; char *
call _ZN7QStringC2EPKc; QString::QString(char const*)
jmp short $+2
loc_D5C9C:
mov rdi, [rbp+var_30]
add rdi, 18h; this
mov [rbp+var_18], rdi
lea rsi, aMov0xffC+0Ah; char *
call _ZN7QStringC2EPKc; QString::QString(char const*)
jmp short $+2
loc_D5CB6:
mov rdi, [rbp+var_30]
add rdi, 30h ; '0'; this
mov [rbp+var_18], rdi
lea rsi, aD+2; char *
call _ZN7QStringC2EPKc; QString::QString(char const*)
jmp short $+2
loc_D5CD0:
mov rdi, [rbp+var_30]
add rdi, 48h ; 'H'; this
mov [rbp+var_18], rdi
lea rsi, aLae+2; char *
call _ZN7QStringC2EPKc; QString::QString(char const*)
jmp short $+2
loc_D5CEA:
mov rdi, [rbp+var_30]
add rdi, 60h ; '`'; this
mov [rbp+var_18], rdi
lea rsi, aXchAH+7; char *
call _ZN7QStringC2EPKc; QString::QString(char const*)
jmp short $+2
loc_D5D04:
mov rdi, [rbp+var_30]
add rdi, 78h ; 'x'; this
mov [rbp+var_18], rdi
lea rsi, aXchAL+7; char *
call _ZN7QStringC2EPKc; QString::QString(char const*)
jmp short $+2
loc_D5D1E:
mov rdi, [rbp+var_30]
add rdi, 90h; this
mov [rbp+var_18], rdi
lea rsi, aResBit0Hl+0Ah; char *
call _ZN7QStringC2EPKc; QString::QString(char const*)
jmp short $+2
loc_D5D3B:
mov rdi, [rbp+var_30]
add rdi, 0A8h; this
mov [rbp+var_18], rdi
lea rsi, aLdHlA_0+0Ah; char *
call _ZN7QStringC2EPKc; QString::QString(char const*)
jmp short $+2
loc_D5D58:
mov rdi, [rbp+var_38]; this
mov rsi, [rbp+var_10]; char *
call _ZN11GAParameter7setMaskEPKc; GAParameter::setMask(char const*)
jmp short $+2
loc_D5D67:
add rsp, 60h
pop rbp
retn
mov rcx, [rbp+var_30]
mov [rbp+var_48], rdx
mov rdx, rax
mov rax, [rbp+var_48]
mov [rbp+var_20], rdx
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
cmp rcx, rax
mov [rbp+var_40], rax
jz short loc_D5DB2
loc_D5D90:
mov rdi, [rbp+var_40]
add rdi, 0FFFFFFFFFFFFFFE8h; this
mov [rbp+var_50], rdi
call _ZN7QStringD2Ev; QString::~QString()
mov rcx, [rbp+var_30]
mov rax, [rbp+var_50]
cmp rax, rcx
mov [rbp+var_40], rax
jnz short loc_D5D90
loc_D5DB2:
jmp short loc_D5DF3
mov rcx, rdx
mov rdx, rax
mov rax, [rbp+var_30]
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
add rax, 0C0h
mov [rbp+var_58], rax
loc_D5DCF:
mov rdi, [rbp+var_58]
add rdi, 0FFFFFFFFFFFFFFE8h; this
mov [rbp+var_60], rdi
call _ZN7QStringD2Ev; QString::~QString()
mov rcx, [rbp+var_30]
mov rax, [rbp+var_60]
cmp rax, rcx
mov [rbp+var_58], rax
jnz short loc_D5DCF
jmp short $+2
loc_D5DF3:
mov rdi, [rbp+var_38]; this
call _ZN11GAParameterD2Ev; GAParameter::~GAParameter()
mov rdi, [rbp+var_20]
call __Unwind_Resume
| void GAParameter8080Reg8::GAParameter8080Reg8(GAParameter8080Reg8 *this, const char *a2)
{
GAParameter::GAParameter(this);
*(_QWORD *)this = &`vtable for'GAParameter8080Reg8 + 2;
QString::QString((GAParameter8080Reg8 *)((char *)this + 176), "b");
QString::QString((GAParameter8080Reg8 *)((char *)this + 200), "c");
QString::QString((GAParameter8080Reg8 *)((char *)this + 224), "d");
QString::QString((GAParameter8080Reg8 *)((char *)this + 248), "e");
QString::QString((GAParameter8080Reg8 *)((char *)this + 272), "h");
QString::QString((GAParameter8080Reg8 *)((char *)this + 296), "l");
QString::QString((GAParameter8080Reg8 *)((char *)this + 320), "@hl");
QString::QString((GAParameter8080Reg8 *)((char *)this + 344), "a");
GAParameter::setMask(this, a2);
}
| GAParameter8080Reg8:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RDI
CALL 0x0020b090
MOV RDI,qword ptr [RBP + -0x38]
LEA RAX,[0x24b718]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
ADD RDI,0xb0
MOV qword ptr [RBP + -0x30],RDI
MOV qword ptr [RBP + -0x18],RDI
LAB_001d5c8e:
LEA RSI,[0x21a61e]
CALL 0x0010e710
JMP 0x001d5c9c
LAB_001d5c9c:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x18
MOV qword ptr [RBP + -0x18],RDI
LEA RSI,[0x216af0]
CALL 0x0010e710
JMP 0x001d5cb6
LAB_001d5cb6:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x30
MOV qword ptr [RBP + -0x18],RDI
LEA RSI,[0x21f1ca]
CALL 0x0010e710
JMP 0x001d5cd0
LAB_001d5cd0:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x48
MOV qword ptr [RBP + -0x18],RDI
LEA RSI,[0x21369c]
CALL 0x0010e710
JMP 0x001d5cea
LAB_001d5cea:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x60
MOV qword ptr [RBP + -0x18],RDI
LEA RSI,[0x212a33]
CALL 0x0010e710
JMP 0x001d5d04
LAB_001d5d04:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x78
MOV qword ptr [RBP + -0x18],RDI
LEA RSI,[0x212a4e]
CALL 0x0010e710
JMP 0x001d5d1e
LAB_001d5d1e:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x90
MOV qword ptr [RBP + -0x18],RDI
LEA RSI,[0x21b20c]
CALL 0x0010e710
JMP 0x001d5d3b
LAB_001d5d3b:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0xa8
MOV qword ptr [RBP + -0x18],RDI
LEA RSI,[0x217832]
CALL 0x0010e710
JMP 0x001d5d58
LAB_001d5d58:
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
LAB_001d5d60:
CALL 0x00209170
LAB_001d5d65:
JMP 0x001d5d67
LAB_001d5d67:
ADD RSP,0x60
POP RBP
RET
|
/* GAParameter8080Reg8::GAParameter8080Reg8(char const*) */
void __thiscall GAParameter8080Reg8::GAParameter8080Reg8(GAParameter8080Reg8 *this,char *param_1)
{
GAParameter::GAParameter((GAParameter *)this);
*(int ***)this = &PTR_decode_0024b728;
/* try { // try from 001d5c8e to 001d5d55 has its CatchHandler @ 001d5d6d */
QString::QString((QString *)(this + 0xb0),"b");
QString::QString((QString *)(this + 200),"c");
QString::QString((QString *)(this + 0xe0),"d");
QString::QString((QString *)(this + 0xf8),"e");
QString::QString((QString *)(this + 0x110),"h");
QString::QString((QString *)(this + 0x128),"l");
QString::QString((QString *)(this + 0x140),"@hl");
QString::QString((QString *)(this + 0x158),"a");
/* try { // try from 001d5d60 to 001d5d64 has its CatchHandler @ 001d5db4 */
GAParameter::setMask((GAParameter *)this,param_1);
return;
}
| |
39,563 | mod_fast | bluesky950520[P]quickjs/libbf.c | static inline limb_t mod_fast(dlimb_t r,
limb_t m, limb_t m_inv)
{
limb_t a1, q, t0, r1, r0;
a1 = r >> NTT_MOD_LOG2_MIN;
q = ((dlimb_t)a1 * m_inv) >> LIMB_BITS;
r = r - (dlimb_t)q * m - m * 2;
r1 = r >> LIMB_BITS;
t0 = (slimb_t)r1 >> 1;
r += m & t0;
r0 = r;
r1 = r >> LIMB_BITS;
r0 += m & r1;
return r0;
} | O2 | c | mod_fast:
movq %rsi, %rax
shldq $0x3, %rdi, %rax
movq %rdx, %r8
mulq %rcx
movq %rdx, %rax
mulq %r8
leaq (%r8,%r8), %rcx
addq %rcx, %rax
adcq $0x0, %rdx
subq %rax, %rdi
sbbq %rdx, %rsi
movq %rsi, %rax
sarq %rax
andq %r8, %rax
addq %rdi, %rax
adcq $0x0, %rsi
andq %r8, %rsi
addq %rsi, %rax
retq
| mod_fast:
mov rax, rsi
shld rax, rdi, 3
mov r8, rdx
mul rcx
mov rax, rdx
mul r8
lea rcx, [r8+r8]
add rax, rcx
adc rdx, 0
sub rdi, rax
sbb rsi, rdx
mov rax, rsi
sar rax, 1
and rax, r8
add rax, rdi
adc rsi, 0
and rsi, r8
add rax, rsi
retn
| long long mod_fast(__int128 a1, unsigned long long a2, unsigned long long a3)
{
unsigned __int128 v4; // rax
unsigned __int128 v5; // kr00_16
v4 = a2 * ((a3 * (unsigned __int128)(unsigned long long)(a1 >> 61)) >> 64);
v5 = a1 - (2 * a2 + v4) + (a2 & ((long long)((a1 - (2 * a2 + v4)) >> 64) >> 1));
return (a2 & *((_QWORD *)&v5 + 1)) + v5;
}
| mod_fast:
MOV RAX,RSI
SHLD RAX,RDI,0x3
MOV R8,RDX
MUL RCX
MOV RAX,RDX
MUL R8
LEA RCX,[R8 + R8*0x1]
ADD RAX,RCX
ADC RDX,0x0
SUB RDI,RAX
SBB RSI,RDX
MOV RAX,RSI
SAR RAX,0x1
AND RAX,R8
ADD RAX,RDI
ADC RSI,0x0
AND RSI,R8
ADD RAX,RSI
RET
|
long mod_fast(ulong param_1,long param_2,ulong param_3,ulong param_4)
{
int1 auVar1 [16];
int1 auVar2 [16];
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
ulong uVar6;
long lVar7;
ulong uVar8;
auVar1._8_8_ = 0;
auVar1._0_8_ = param_2 << 3 | param_1 >> 0x3d;
auVar3._8_8_ = 0;
auVar3._0_8_ = param_4;
auVar2._8_8_ = 0;
auVar2._0_8_ = SUB168(auVar1 * auVar3,8);
auVar4._8_8_ = 0;
auVar4._0_8_ = param_3;
auVar5._8_8_ = 0;
auVar5._0_8_ = param_3 * 2;
auVar5 = auVar2 * auVar4 + auVar5;
uVar6 = auVar5._0_8_;
uVar8 = param_1 - uVar6;
lVar7 = (param_2 - auVar5._8_8_) - (ulong)(param_1 < uVar6);
uVar6 = lVar7 >> 1 & param_3;
return uVar6 + uVar8 + (lVar7 + (ulong)CARRY8(uVar6,uVar8) & param_3);
}
| |
39,564 | blst_p1_mult | corpus-core[P]colibri-stateless/build_O1/_deps/blst-src/src/e1.c | void blst_p1_mult(POINTonE1 *out, const POINTonE1 *a,
const byte *scalar, size_t nbits)
{
if (nbits < 176) {
if (nbits)
POINTonE1_mult_w4(out, a, scalar, nbits);
else
vec_zero(out, sizeof(*out));
} else if (nbits <= 256) {
union { vec256 l; pow256 s; } val;
size_t i, j, top, mask = (size_t)0 - 1;
/* this is not about constant-time-ness, but branch optimization */
for (top = (nbits + 7)/8, i=0, j=0; i<sizeof(val.s);) {
val.s[i++] = scalar[j] & mask;
mask = 0 - ((i - top) >> (8*sizeof(top)-1));
j += 1 & mask;
}
if (check_mod_256(val.s, BLS12_381_r)) /* z^4 is the formal limit */
POINTonE1_mult_glv(out, a, val.s);
else /* should never be the case, added for formal completeness */
POINTonE1_mult_w5(out, a, scalar, nbits);
vec_zero(val.l, sizeof(val));
} else { /* should never be the case, added for formal completeness */
POINTonE1_mult_w5(out, a, scalar, nbits);
}
} | O1 | c | blst_p1_mult:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0xaf, %rcx
ja 0x5d6ff
testq %r14, %r14
je 0x5d77e
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5d7c9
cmpq $0x100, %r14 # imm = 0x100
ja 0x5d761
leaq 0x7(%r14), %rax
shrq $0x3, %rax
movb $-0x1, %sil
movl $0x1, %ecx
xorl %edx, %edx
andb (%r12,%rdx), %sil
movb %sil, -0x41(%rbp,%rcx)
xorl %esi, %esi
cmpq %rax, %rcx
setb %sil
addq %rsi, %rdx
negb %sil
incq %rcx
cmpq $0x21, %rcx
jne 0x5d71a
leaq 0x30f0e(%rip), %rsi # 0x8e650
leaq -0x40(%rbp), %rdi
callq 0x78e80
testq %rax, %rax
je 0x5d793
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5da0d
jmp 0x5d7a4
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5de50
xorl %eax, %eax
movq $0x0, (%rbx,%rax,8)
incq %rax
cmpq $0x12, %rax
jne 0x5d780
jmp 0x5d7bc
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x5de50
xorl %eax, %eax
movq $0x0, -0x40(%rbp,%rax,8)
incq %rax
cmpq $0x4, %rax
jne 0x5d7a6
leaq -0x40(%rbp), %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| blst_p1_mult:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov r14, rcx
mov r12, rdx
mov r15, rsi
mov rbx, rdi
cmp rcx, 0AFh
ja short loc_5D6FF
test r14, r14
jz loc_5D77E
mov rdi, rbx
mov rsi, r15
mov rdx, r12
mov rcx, r14
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp POINTonE1_mult_w4
loc_5D6FF:
cmp r14, 100h
ja short loc_5D761
lea rax, [r14+7]
shr rax, 3
mov sil, 0FFh
mov ecx, 1
xor edx, edx
loc_5D71A:
and sil, [r12+rdx]
mov [rbp+rcx+var_41], sil
xor esi, esi
cmp rcx, rax
setb sil
add rdx, rsi
neg sil
inc rcx
cmp rcx, 21h ; '!'
jnz short loc_5D71A
lea rsi, BLS12_381_r
lea rdi, [rbp+var_40]
call check_mod_256
test rax, rax
jz short loc_5D793
lea rdx, [rbp+var_40]
mov rdi, rbx
mov rsi, r15
call POINTonE1_mult_glv
jmp short loc_5D7A4
loc_5D761:
mov rdi, rbx
mov rsi, r15
mov rdx, r12
mov rcx, r14
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp POINTonE1_mult_w5
loc_5D77E:
xor eax, eax
loc_5D780:
mov qword ptr [rbx+rax*8], 0
inc rax
cmp rax, 12h
jnz short loc_5D780
jmp short loc_5D7BC
loc_5D793:
mov rdi, rbx
mov rsi, r15
mov rdx, r12
mov rcx, r14
call POINTonE1_mult_w5
loc_5D7A4:
xor eax, eax
loc_5D7A6:
mov [rbp+rax*8+var_40], 0
inc rax
cmp rax, 4
jnz short loc_5D7A6
lea rax, [rbp+var_40]
loc_5D7BC:
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long blst_p1_mult(long long a1, long long a2, long long a3, unsigned long long a4)
{
long long result; // rax
unsigned long long v8; // rax
char v9; // si
unsigned long long v10; // rcx
long long v11; // rdx
long long v12; // rsi
long long i; // rax
char v14; // [rsp+1h] [rbp-41h]
_QWORD v15[8]; // [rsp+2h] [rbp-40h] BYREF
if ( a4 > 0xAF )
{
if ( a4 > 0x100 )
{
return POINTonE1_mult_w5(a1, a2, a3, a4);
}
else
{
v8 = (a4 + 7) >> 3;
v9 = -1;
v10 = 1LL;
v11 = 0LL;
do
{
*(&v14 + v10) = *(_BYTE *)(a3 + v11) & v9;
v12 = v10 < v8;
v11 += v12;
v9 = -(char)v12;
++v10;
}
while ( v10 != 33 );
if ( check_mod_256(v15, &BLS12_381_r, v11) )
POINTonE1_mult_glv(a1, a2, v15);
else
POINTonE1_mult_w5(a1, a2, a3, a4);
for ( i = 0LL; i != 4; ++i )
v15[i] = 0LL;
return (long long)v15;
}
}
else if ( a4 )
{
return POINTonE1_mult_w4(a1, a2, a3, a4);
}
else
{
for ( result = 0LL; result != 18; ++result )
*(_QWORD *)(a1 + 8 * result) = 0LL;
}
return result;
}
| blst_p1_mult:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV R14,RCX
MOV R12,RDX
MOV R15,RSI
MOV RBX,RDI
CMP RCX,0xaf
JA 0x0015d6ff
TEST R14,R14
JZ 0x0015d77e
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
MOV RCX,R14
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x0015d7c9
LAB_0015d6ff:
CMP R14,0x100
JA 0x0015d761
LEA RAX,[R14 + 0x7]
SHR RAX,0x3
MOV SIL,0xff
MOV ECX,0x1
XOR EDX,EDX
LAB_0015d71a:
AND SIL,byte ptr [R12 + RDX*0x1]
MOV byte ptr [RBP + RCX*0x1 + -0x41],SIL
XOR ESI,ESI
CMP RCX,RAX
SETC SIL
ADD RDX,RSI
NEG SIL
INC RCX
CMP RCX,0x21
JNZ 0x0015d71a
LEA RSI,[0x18e650]
LEA RDI,[RBP + -0x40]
CALL 0x00178e80
TEST RAX,RAX
JZ 0x0015d793
LEA RDX,[RBP + -0x40]
MOV RDI,RBX
MOV RSI,R15
CALL 0x0015da0d
JMP 0x0015d7a4
LAB_0015d761:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
MOV RCX,R14
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x0015de50
LAB_0015d77e:
XOR EAX,EAX
LAB_0015d780:
MOV qword ptr [RBX + RAX*0x8],0x0
INC RAX
CMP RAX,0x12
JNZ 0x0015d780
JMP 0x0015d7bc
LAB_0015d793:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
MOV RCX,R14
CALL 0x0015de50
LAB_0015d7a4:
XOR EAX,EAX
LAB_0015d7a6:
MOV qword ptr [RBP + RAX*0x8 + -0x40],0x0
INC RAX
CMP RAX,0x4
JNZ 0x0015d7a6
LEA RAX,[RBP + -0x40]
LAB_0015d7bc:
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
byte * blst_p1_mult(long param_1,int8 param_2,long param_3,ulong param_4)
{
byte *pbVar1;
long lVar2;
ulong uVar3;
byte bVar4;
bool bVar5;
int8 uStack_50;
byte local_48 [32];
if (param_4 < 0xb0) {
if (param_4 != 0) {
pbVar1 = (byte *)POINTonE1_mult_w4(param_1,param_2,param_3,param_4);
return pbVar1;
}
lVar2 = 0;
do {
*(int8 *)(param_1 + lVar2 * 8) = 0;
lVar2 = lVar2 + 1;
} while (lVar2 != 0x12);
pbVar1 = (byte *)0x12;
}
else {
if (0x100 < param_4) {
pbVar1 = (byte *)POINTonE1_mult_w5(param_1,param_2,param_3,param_4);
return pbVar1;
}
bVar4 = 0xff;
uVar3 = 1;
lVar2 = 0;
do {
local_48[uVar3 - 1] = bVar4 & *(byte *)(param_3 + lVar2);
bVar5 = uVar3 < param_4 + 7 >> 3;
lVar2 = lVar2 + (ulong)bVar5;
bVar4 = -bVar5;
uVar3 = uVar3 + 1;
} while (uVar3 != 0x21);
uStack_50 = 0x15d74b;
lVar2 = check_mod_256(local_48,BLS12_381_r);
if (lVar2 == 0) {
uStack_50 = 0x15d7a4;
POINTonE1_mult_w5(param_1,param_2,param_3,param_4);
}
else {
uStack_50 = 0x15d75f;
POINTonE1_mult_glv(param_1,param_2,local_48);
}
lVar2 = 0;
do {
pbVar1 = local_48 + lVar2 * 8;
pbVar1[0] = 0;
pbVar1[1] = 0;
pbVar1[2] = 0;
pbVar1[3] = 0;
pbVar1[4] = 0;
pbVar1[5] = 0;
pbVar1[6] = 0;
pbVar1[7] = 0;
lVar2 = lVar2 + 1;
} while (lVar2 != 4);
pbVar1 = local_48;
}
return pbVar1;
}
| |
39,565 | JS_ConcatString1 | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_ConcatString1(JSContext *ctx,
const JSString *p1, const JSString *p2)
{
JSString *p;
uint32_t len;
int is_wide_char;
len = p1->len + p2->len;
if (len > JS_STRING_LEN_MAX)
return JS_ThrowRangeError(ctx, "invalid string length");
is_wide_char = p1->is_wide_char | p2->is_wide_char;
p = js_alloc_string(ctx, len, is_wide_char);
if (!p)
return JS_EXCEPTION;
if (!is_wide_char) {
memcpy(p->u.str8, p1->u.str8, p1->len);
memcpy(p->u.str8 + p1->len, p2->u.str8, p2->len);
p->u.str8[len] = '\0';
} else {
copy_str16(p->u.str16, p1, 0, p1->len);
copy_str16(p->u.str16 + p1->len, p2, 0, p2->len);
}
return JS_MKPTR(JS_TAG_STRING, p);
} | O0 | c | JS_ConcatString1:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movq 0x10(%rsp), %rcx
movq 0x4(%rcx), %rcx
andq $0x7fffffff, %rcx # imm = 0x7FFFFFFF
addl %ecx, %eax
movl %eax, 0x4(%rsp)
cmpl $0x3fffffff, 0x4(%rsp) # imm = 0x3FFFFFFF
jbe 0x71534
movq 0x20(%rsp), %rdi
leaq 0x9c4b0(%rip), %rsi # 0x10d9ce
movb $0x0, %al
callq 0x29670
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
jmp 0x71689
movq 0x18(%rsp), %rax
movq 0x4(%rax), %rax
shrq $0x1f, %rax
andq $0x1, %rax
movzbl %al, %eax
movq 0x10(%rsp), %rcx
movq 0x4(%rcx), %rcx
shrq $0x1f, %rcx
andq $0x1, %rcx
movzbl %cl, %ecx
orl %ecx, %eax
movl %eax, (%rsp)
movq 0x20(%rsp), %rdi
movl 0x4(%rsp), %esi
movl (%rsp), %edx
callq 0x29760
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x71595
movl $0x0, 0x28(%rsp)
movq $0x6, 0x30(%rsp)
jmp 0x71689
cmpl $0x0, (%rsp)
jne 0x71613
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
addq $0x18, %rsi
movq 0x18(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %eax
movl %eax, %edx
callq 0xe5b0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
cltq
addq %rax, %rdi
movq 0x10(%rsp), %rsi
addq $0x18, %rsi
movq 0x10(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %eax
movl %eax, %edx
callq 0xe5b0
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movb $0x0, 0x18(%rax,%rcx)
jmp 0x71676
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %ecx
xorl %edx, %edx
callq 0x716a0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
cltq
shlq %rax
addq %rax, %rdi
movq 0x10(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %ecx
xorl %edx, %edx
callq 0x716a0
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $-0x7, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| JS_ConcatString1:
sub rsp, 38h
mov [rsp+38h+var_18], rdi
mov [rsp+38h+var_20], rsi
mov [rsp+38h+var_28], rdx
mov rax, [rsp+38h+var_20]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov rcx, [rsp+38h+var_28]
mov rcx, [rcx+4]
and rcx, 7FFFFFFFh
add eax, ecx
mov [rsp+38h+var_34], eax
cmp [rsp+38h+var_34], 3FFFFFFFh
jbe short loc_71534
mov rdi, [rsp+38h+var_18]
lea rsi, aInvalidStringL; "invalid string length"
mov al, 0
call JS_ThrowRangeError
mov [rsp+38h+var_10], rax
mov [rsp+38h+var_8], rdx
jmp loc_71689
loc_71534:
mov rax, [rsp+38h+var_20]
mov rax, [rax+4]
shr rax, 1Fh
and rax, 1
movzx eax, al
mov rcx, [rsp+38h+var_28]
mov rcx, [rcx+4]
shr rcx, 1Fh
and rcx, 1
movzx ecx, cl
or eax, ecx
mov [rsp+38h+var_38], eax
mov rdi, [rsp+38h+var_18]
mov esi, [rsp+38h+var_34]
mov edx, [rsp+38h+var_38]
call js_alloc_string
mov [rsp+38h+var_30], rax
cmp [rsp+38h+var_30], 0
jnz short loc_71595
mov dword ptr [rsp+38h+var_10], 0
mov [rsp+38h+var_8], 6
jmp loc_71689
loc_71595:
cmp [rsp+38h+var_38], 0
jnz short loc_71613
mov rdi, [rsp+38h+var_30]
add rdi, 18h
mov rsi, [rsp+38h+var_20]
add rsi, 18h
mov rax, [rsp+38h+var_20]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov eax, eax
mov edx, eax
call _memcpy
mov rdi, [rsp+38h+var_30]
add rdi, 18h
mov rax, [rsp+38h+var_20]
mov rax, [rax+4]
and rax, 7FFFFFFFh
cdqe
add rdi, rax
mov rsi, [rsp+38h+var_28]
add rsi, 18h
mov rax, [rsp+38h+var_28]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov eax, eax
mov edx, eax
call _memcpy
mov rax, [rsp+38h+var_30]
mov ecx, [rsp+38h+var_34]
mov byte ptr [rax+rcx+18h], 0
jmp short loc_71676
loc_71613:
mov rdi, [rsp+38h+var_30]
add rdi, 18h
mov rsi, [rsp+38h+var_20]
mov rax, [rsp+38h+var_20]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov ecx, eax
xor edx, edx
call copy_str16
mov rdi, [rsp+38h+var_30]
add rdi, 18h
mov rax, [rsp+38h+var_20]
mov rax, [rax+4]
and rax, 7FFFFFFFh
cdqe
shl rax, 1
add rdi, rax
mov rsi, [rsp+38h+var_28]
mov rax, [rsp+38h+var_28]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov ecx, eax
xor edx, edx
call copy_str16
loc_71676:
mov rax, [rsp+38h+var_30]
mov [rsp+38h+var_10], rax
mov [rsp+38h+var_8], 0FFFFFFFFFFFFFFF9h
loc_71689:
mov rax, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_8]
add rsp, 38h
retn
| long long JS_ConcatString1(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
long long a14)
{
long long v14; // rcx
char v16; // [rsp+0h] [rbp-38h]
unsigned int v17; // [rsp+0h] [rbp-38h]
unsigned int v18; // [rsp+4h] [rbp-34h]
long long v19; // [rsp+8h] [rbp-30h]
long long v21; // [rsp+28h] [rbp-10h]
v14 = *(_QWORD *)(a3 + 4) & 0x7FFFFFFFLL;
v18 = v14 + (*(_QWORD *)(a2 + 4) & 0x7FFFFFFF);
if ( v18 > 0x3FFFFFFF )
return JS_ThrowRangeError(
a1,
(long long)"invalid string length",
a3,
v14,
a13,
a14,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
v16);
v17 = (*(_QWORD *)(a3 + 4) & 0x80000000LL) != 0 || (*(_QWORD *)(a2 + 4) & 0x80000000LL) != 0;
v19 = js_alloc_string(a1, v18, v17);
if ( v19 )
{
if ( v17 )
{
copy_str16(v19 + 24, a2, 0LL, *(_DWORD *)(a2 + 4) & 0x7FFFFFFF);
copy_str16(2LL * (*(_QWORD *)(a2 + 4) & 0x7FFFFFFF) + v19 + 24, a3, 0LL, *(_DWORD *)(a3 + 4) & 0x7FFFFFFF);
}
else
{
memcpy(v19 + 24, a2 + 24, *(_DWORD *)(a2 + 4) & 0x7FFFFFFF);
memcpy((*(_QWORD *)(a2 + 4) & 0x7FFFFFFF) + v19 + 24, a3 + 24, *(_DWORD *)(a3 + 4) & 0x7FFFFFFF);
*(_BYTE *)(v19 + v18 + 24) = 0;
}
return v19;
}
else
{
LODWORD(v21) = 0;
}
return v21;
}
| JS_ConcatString1:
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV RCX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RCX + 0x4]
AND RCX,0x7fffffff
ADD EAX,ECX
MOV dword ptr [RSP + 0x4],EAX
CMP dword ptr [RSP + 0x4],0x3fffffff
JBE 0x00171534
MOV RDI,qword ptr [RSP + 0x20]
LEA RSI,[0x20d9ce]
MOV AL,0x0
CALL 0x00129670
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
JMP 0x00171689
LAB_00171534:
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x4]
SHR RAX,0x1f
AND RAX,0x1
MOVZX EAX,AL
MOV RCX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RCX + 0x4]
SHR RCX,0x1f
AND RCX,0x1
MOVZX ECX,CL
OR EAX,ECX
MOV dword ptr [RSP],EAX
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RSP + 0x4]
MOV EDX,dword ptr [RSP]
CALL 0x00129760
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00171595
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x6
JMP 0x00171689
LAB_00171595:
CMP dword ptr [RSP],0x0
JNZ 0x00171613
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x18
MOV RSI,qword ptr [RSP + 0x18]
ADD RSI,0x18
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV EAX,EAX
MOV EDX,EAX
CALL 0x0010e5b0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x18
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
CDQE
ADD RDI,RAX
MOV RSI,qword ptr [RSP + 0x10]
ADD RSI,0x18
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV EAX,EAX
MOV EDX,EAX
CALL 0x0010e5b0
MOV RAX,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RSP + 0x4]
MOV byte ptr [RAX + RCX*0x1 + 0x18],0x0
JMP 0x00171676
LAB_00171613:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x18
MOV RSI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV ECX,EAX
XOR EDX,EDX
CALL 0x001716a0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x18
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
CDQE
SHL RAX,0x1
ADD RDI,RAX
MOV RSI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV ECX,EAX
XOR EDX,EDX
CALL 0x001716a0
LAB_00171676:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],-0x7
LAB_00171689:
MOV RAX,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
int1 [16] JS_ConcatString1(int8 param_1,long param_2,long param_3)
{
byte bVar1;
uint uVar2;
long lVar3;
int1 auVar4 [16];
int4 local_10;
int4 uStack_c;
int8 local_8;
uVar2 = ((uint)*(int8 *)(param_2 + 4) & 0x7fffffff) +
((uint)*(int8 *)(param_3 + 4) & 0x7fffffff);
if (uVar2 < 0x40000000) {
bVar1 = (byte)(*(ulong *)(param_2 + 4) >> 0x1f) & 1 |
(byte)(*(ulong *)(param_3 + 4) >> 0x1f) & 1;
lVar3 = js_alloc_string(param_1,uVar2,bVar1);
if (lVar3 == 0) {
local_10 = 0;
local_8 = 6;
}
else {
if (bVar1 == 0) {
memcpy((void *)(lVar3 + 0x18),(void *)(param_2 + 0x18),
(ulong)((uint)*(int8 *)(param_2 + 4) & 0x7fffffff));
memcpy((void *)(lVar3 + 0x18 + (long)(int)((uint)*(int8 *)(param_2 + 4) & 0x7fffffff))
,(void *)(param_3 + 0x18),(ulong)((uint)*(int8 *)(param_3 + 4) & 0x7fffffff));
*(int1 *)(lVar3 + 0x18 + (ulong)uVar2) = 0;
}
else {
copy_str16(lVar3 + 0x18,param_2,0,(uint)*(int8 *)(param_2 + 4) & 0x7fffffff);
copy_str16(lVar3 + 0x18 + (long)(int)((uint)*(int8 *)(param_2 + 4) & 0x7fffffff) * 2,
param_3,0,(uint)*(int8 *)(param_3 + 4) & 0x7fffffff);
}
local_10 = (int4)lVar3;
uStack_c = (int4)((ulong)lVar3 >> 0x20);
local_8 = 0xfffffffffffffff9;
}
}
else {
auVar4 = JS_ThrowRangeError(param_1,"invalid string length");
local_8 = auVar4._8_8_;
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
}
auVar4._4_4_ = uStack_c;
auVar4._0_4_ = local_10;
auVar4._8_8_ = local_8;
return auVar4;
}
| |
39,566 | minja::Value::push_back(minja::Value const&) | llama.cpp/common/minja/minja.hpp | void push_back(const Value& v) {
if (!array_)
throw std::runtime_error("Value is not an array: " + dump());
array_->push_back(v);
} | O3 | cpp | minja::Value::push_back(minja::Value const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc284b
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xc2be2
movl $0x10, %edi
callq 0x21630
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xb6084
leaq 0x5f058(%rip), %rsi # 0x1218c9
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xaf924
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x21450
xorl %ebp, %ebp
movq 0xa2729(%rip), %rsi # 0x164fc0
movq 0xa26da(%rip), %rdx # 0x164f78
movq %rbx, %rdi
callq 0x21a50
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc28c4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21170
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc28df
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21170
testb %bpl, %bpl
jne 0xc2909
jmp 0xc2911
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc2909
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21170
jmp 0xc2909
movq %rax, %r14
movq %rbx, %rdi
callq 0x21f00
movq %r14, %rdi
callq 0x21af0
nop
| _ZN5minja5Value9push_backERKS0_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
mov rdi, [rdi+10h]
test rdi, rdi
jz short loc_C284B
add rsp, 40h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN5minja5ValueESaIS1_EE9push_backERKS1_; std::vector<minja::Value>::push_back(minja::Value const&)
loc_C284B:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr_0; "Value is not an array: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C28C4
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C28C4:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C28DF
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C28DF:
test bpl, bpl
jnz short loc_C2909
jmp short loc_C2911
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C2909
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_C2909
mov r14, rax
loc_C2909:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_C2911:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::push_back(minja::Value *this, const minja::Value *a2)
{
long long v3; // rdi
void *exception; // rbx
_BYTE v6[16]; // [rsp+0h] [rbp-58h] BYREF
_QWORD v7[2]; // [rsp+20h] [rbp-38h] BYREF
v3 = *((_QWORD *)this + 2);
if ( !v3 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v6, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>(v7, (long long)"Value is not an array: ", (long long)v6);
std::runtime_error::runtime_error(exception, v7);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return std::vector<minja::Value>::push_back(v3, a2);
}
| push_back:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x10]
TEST RDI,RDI
JZ 0x001c284b
ADD RSP,0x40
POP RBX
POP R14
POP RBP
JMP 0x001c2be2
LAB_001c284b:
MOV EDI,0x10
CALL 0x00121630
MOV RBX,RAX
LAB_001c2858:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001b6084
LAB_001c286a:
LEA RSI,[0x2218c9]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001af924
MOV BPL,0x1
LAB_001c2881:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00121450
XOR EBP,EBP
MOV RSI,qword ptr [0x00264fc0]
MOV RDX,qword ptr [0x00264f78]
MOV RDI,RBX
CALL 0x00121a50
|
/* minja::Value::push_back(minja::Value const&) */
void __thiscall minja::Value::push_back(Value *this,Value *param_1)
{
runtime_error *this_00;
int1 auStack_58 [32];
string local_38 [32];
if (*(vector<minja::Value,std::allocator<minja::Value>> **)(this + 0x10) !=
(vector<minja::Value,std::allocator<minja::Value>> *)0x0) {
std::vector<minja::Value,std::allocator<minja::Value>>::push_back
(*(vector<minja::Value,std::allocator<minja::Value>> **)(this + 0x10),param_1);
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001c2858 to 001c2869 has its CatchHandler @ 001c2906 */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 001c286a to 001c287d has its CatchHandler @ 001c28e6 */
std::operator+((char *)local_38,(string *)"Value is not an array: ");
/* try { // try from 001c2881 to 001c28a5 has its CatchHandler @ 001c28a6 */
std::runtime_error::runtime_error(this_00,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00264fc0,PTR__runtime_error_00264f78);
}
| |
39,567 | my_coll_parser_scan_character_list | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_character_list(MY_COLL_RULE_PARSER *p,
my_wc_t *pwc, size_t limit,
const char *name)
{
if (my_coll_parser_curr(p)->term != MY_COLL_LEXEM_CHAR)
return my_coll_parser_expected_error(p, MY_COLL_LEXEM_CHAR);
if (!my_coll_rule_expand(pwc, limit, my_coll_parser_curr(p)->code))
return my_coll_parser_too_long_error(p, name);
if (!my_coll_parser_scan_term(p, MY_COLL_LEXEM_CHAR))
return 0;
while (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_CHAR)
{
if (!my_coll_rule_expand(pwc, limit, my_coll_parser_curr(p)->code))
return my_coll_parser_too_long_error(p, name);
my_coll_parser_scan(p);
}
return 1;
} | O3 | c | my_coll_parser_scan_character_list:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x5, (%rdi)
jne 0x40929
movq %rcx, %r14
movq %rdx, %r12
testq %rdx, %rdx
je 0x4090b
movq %rsi, %r13
movslq 0x24(%rbx), %rax
xorl %ecx, %ecx
cmpq $0x0, (%r13,%rcx,8)
je 0x40962
incq %rcx
cmpq %rcx, %r12
jne 0x408fb
addq $0xf8, %rbx
leaq 0x1e37a(%rip), %rdx # 0x5ec93
xorl %r15d, %r15d
movl $0x80, %esi
movq %rbx, %rdi
movq %r14, %rcx
jmp 0x40949
addq $0xf8, %rbx
leaq 0x1e36b(%rip), %rdx # 0x5eca2
leaq 0x1e37a(%rip), %rcx # 0x5ecb8
xorl %r15d, %r15d
movl $0x80, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5a352
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%r13,%rcx,8)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x40635
testl %eax, %eax
je 0x409d8
movl $0x1, %r15d
cmpl $0x5, (%rbx)
jne 0x40950
leaq 0x28(%rbx), %rdx
movslq 0x24(%rbx), %rax
xorl %ecx, %ecx
cmpq $0x0, (%r13,%rcx,8)
je 0x409a2
incq %rcx
cmpq %rcx, %r12
jne 0x4098d
jmp 0x4090b
movq %rax, (%r13,%rcx,8)
movq 0x20(%rdx), %rax
movq %rax, 0x20(%rbx)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rdx, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x403d7
movq -0x30(%rbp), %rdx
cmpl $0x5, (%rbx)
je 0x40987
jmp 0x40950
xorl %r15d, %r15d
jmp 0x40950
| my_coll_parser_scan_character_list:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
cmp dword ptr [rdi], 5
jnz short loc_40929
mov r14, rcx
mov r12, rdx
test rdx, rdx
jz short loc_4090B
mov r13, rsi
movsxd rax, dword ptr [rbx+24h]
xor ecx, ecx
loc_408FB:
cmp qword ptr [r13+rcx*8+0], 0
jz short loc_40962
inc rcx
cmp r12, rcx
jnz short loc_408FB
loc_4090B:
add rbx, 0F8h
lea rdx, aSIsTooLong; "%s is too long"
xor r15d, r15d
mov esi, 80h
mov rdi, rbx
mov rcx, r14
jmp short loc_40949
loc_40929:
add rbx, 0F8h
lea rdx, aSExpected; "%s expected"
lea rcx, aCharacter; "Character"
xor r15d, r15d
mov esi, 80h
mov rdi, rbx
loc_40949:
xor eax, eax
call my_snprintf
loc_40950:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_40962:
mov [r13+rcx*8+0], rax
mov rdi, rbx
mov esi, 5
call my_coll_parser_scan_term
test eax, eax
jz short loc_409D8
mov r15d, 1
cmp dword ptr [rbx], 5
jnz short loc_40950
lea rdx, [rbx+28h]
loc_40987:
movsxd rax, dword ptr [rbx+24h]
xor ecx, ecx
loc_4098D:
cmp qword ptr [r13+rcx*8+0], 0
jz short loc_409A2
inc rcx
cmp r12, rcx
jnz short loc_4098D
jmp loc_4090B
loc_409A2:
mov [r13+rcx*8+0], rax
mov rax, [rdx+20h]
mov [rbx+20h], rax
movups xmm0, xmmword ptr [rdx]
movups xmm1, xmmword ptr [rdx+10h]
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
mov [rbp+var_30], rdx
mov rdi, [rbp+var_30]
call my_coll_lexem_next
mov rdx, [rbp+var_30]
cmp dword ptr [rbx], 5
jz short loc_40987
jmp loc_40950
loc_409D8:
xor r15d, r15d
jmp loc_40950
| long long my_coll_parser_scan_character_list(long long a1, long long a2, long long a3, int a4, int a5, int a6)
{
long long v8; // rcx
const char *v9; // rdx
unsigned int v10; // r15d
int v11; // edi
const char *v12; // rcx
long long v14; // rdx
long long v15; // rcx
__int128 v16; // xmm0
long long v17; // [rsp+0h] [rbp-30h]
if ( *(_DWORD *)a1 != 5 )
{
v9 = "%s expected";
v12 = "Character";
v10 = 0;
v11 = a1 + 248;
goto LABEL_8;
}
if ( !a3 )
{
LABEL_6:
v9 = "%s is too long";
v10 = 0;
v11 = a1 + 248;
LODWORD(v12) = a4;
LABEL_8:
my_snprintf(v11, 128, (_DWORD)v9, (_DWORD)v12, a5, a6);
return v10;
}
v8 = 0LL;
while ( *(_QWORD *)(a2 + 8 * v8) )
{
if ( a3 == ++v8 )
goto LABEL_6;
}
*(_QWORD *)(a2 + 8 * v8) = *(int *)(a1 + 36);
if ( (unsigned int)my_coll_parser_scan_term(a1, 5) )
{
v10 = 1;
if ( *(_DWORD *)a1 == 5 )
{
v14 = a1 + 40;
do
{
v15 = 0LL;
while ( *(_QWORD *)(a2 + 8 * v15) )
{
if ( a3 == ++v15 )
goto LABEL_6;
}
*(_QWORD *)(a2 + 8 * v15) = *(int *)(a1 + 36);
*(_QWORD *)(a1 + 32) = *(_QWORD *)(v14 + 32);
v16 = *(_OWORD *)v14;
*(_OWORD *)(a1 + 16) = *(_OWORD *)(v14 + 16);
*(_OWORD *)a1 = v16;
v17 = v14;
my_coll_lexem_next(v14);
v14 = v17;
}
while ( *(_DWORD *)a1 == 5 );
}
}
else
{
return 0;
}
return v10;
}
| my_coll_parser_scan_character_list:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP dword ptr [RDI],0x5
JNZ 0x00140929
MOV R14,RCX
MOV R12,RDX
TEST RDX,RDX
JZ 0x0014090b
MOV R13,RSI
MOVSXD RAX,dword ptr [RBX + 0x24]
XOR ECX,ECX
LAB_001408fb:
CMP qword ptr [R13 + RCX*0x8],0x0
JZ 0x00140962
INC RCX
CMP R12,RCX
JNZ 0x001408fb
LAB_0014090b:
ADD RBX,0xf8
LEA RDX,[0x15ec93]
XOR R15D,R15D
MOV ESI,0x80
MOV RDI,RBX
MOV RCX,R14
JMP 0x00140949
LAB_00140929:
ADD RBX,0xf8
LEA RDX,[0x15eca2]
LEA RCX,[0x15ecb8]
XOR R15D,R15D
MOV ESI,0x80
MOV RDI,RBX
LAB_00140949:
XOR EAX,EAX
CALL 0x0015a352
LAB_00140950:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00140962:
MOV qword ptr [R13 + RCX*0x8],RAX
MOV RDI,RBX
MOV ESI,0x5
CALL 0x00140635
TEST EAX,EAX
JZ 0x001409d8
MOV R15D,0x1
CMP dword ptr [RBX],0x5
JNZ 0x00140950
LEA RDX,[RBX + 0x28]
LAB_00140987:
MOVSXD RAX,dword ptr [RBX + 0x24]
XOR ECX,ECX
LAB_0014098d:
CMP qword ptr [R13 + RCX*0x8],0x0
JZ 0x001409a2
INC RCX
CMP R12,RCX
JNZ 0x0014098d
JMP 0x0014090b
LAB_001409a2:
MOV qword ptr [R13 + RCX*0x8],RAX
MOV RAX,qword ptr [RDX + 0x20]
MOV qword ptr [RBX + 0x20],RAX
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS XMM1,xmmword ptr [RDX + 0x10]
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
MOV qword ptr [RBP + -0x30],RDX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001403d7
MOV RDX,qword ptr [RBP + -0x30]
CMP dword ptr [RBX],0x5
JZ 0x00140987
JMP 0x00140950
LAB_001409d8:
XOR R15D,R15D
JMP 0x00140950
|
int8 my_coll_parser_scan_character_list(int *param_1,long param_2,long param_3,char *param_4)
{
int iVar1;
long lVar2;
char *pcVar3;
if (*param_1 == 5) {
if (param_3 != 0) {
lVar2 = 0;
do {
if (*(long *)(param_2 + lVar2 * 8) == 0) {
*(long *)(param_2 + lVar2 * 8) = (long)param_1[9];
iVar1 = my_coll_parser_scan_term(param_1,5);
if (iVar1 == 0) {
return 0;
}
if (*param_1 != 5) {
return 1;
}
do {
lVar2 = 0;
while (*(long *)(param_2 + lVar2 * 8) != 0) {
lVar2 = lVar2 + 1;
if (param_3 == lVar2) goto LAB_0014090b;
}
*(long *)(param_2 + lVar2 * 8) = (long)param_1[9];
*(int8 *)(param_1 + 8) = *(int8 *)(param_1 + 0x12);
param_1[4] = param_1[0xe];
param_1[5] = param_1[0xf];
param_1[6] = param_1[0x10];
param_1[7] = param_1[0x11];
*param_1 = param_1[10];
param_1[1] = param_1[0xb];
param_1[2] = param_1[0xc];
param_1[3] = param_1[0xd];
my_coll_lexem_next(param_1 + 10);
if (*param_1 != 5) {
return 1;
}
} while( true );
}
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
LAB_0014090b:
pcVar3 = "%s is too long";
}
else {
pcVar3 = "%s expected";
param_4 = "Character";
}
my_snprintf(param_1 + 0x3e,0x80,pcVar3,param_4);
return 0;
}
| |
39,568 | init_dumping_mysql_tables | eloqsql/client/mysqldump.c | static int init_dumping_mysql_tables(char *qdatabase)
{
DBUG_ENTER("init_dumping_mysql_tables");
if (opt_drop_database)
fprintf(md_result_file,
"\n/*!50106 SET @save_log_output=@@LOG_OUTPUT*/;\n"
"/*M!100203 EXECUTE IMMEDIATE IF(@@LOG_OUTPUT='TABLE' AND (@@SLOW_QUERY_LOG=1 OR @@GENERAL_LOG=1),"
"\"SET GLOBAL LOG_OUTPUT='NONE'\", \"DO 0\") */;\n");
DBUG_RETURN(init_dumping_tables(qdatabase));
} | O0 | c | init_dumping_mysql_tables:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpb $0x0, 0x3c20fe(%rip) # 0x401821
je 0x3f73a
movq 0x3c1d84(%rip), %rdi # 0x4014b0
leaq 0x9cd7d(%rip), %rsi # 0xdc4b0
movb $0x0, %al
callq 0x381d0
jmp 0x3f73c
movq -0x8(%rbp), %rdi
callq 0x3f760
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| init_dumping_mysql_tables:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
cmp cs:opt_drop_database, 0
jz short loc_3F73A
mov rdi, cs:md_result_file
lea rsi, a50106SetSaveLo; "\n/*!50106 SET @save_log_output=@@LOG_O"...
mov al, 0
call _fprintf
loc_3F73A:
jmp short $+2
loc_3F73C:
mov rdi, [rbp+var_8]
call init_dumping_tables
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
add rsp, 10h
pop rbp
retn
| long long init_dumping_mysql_tables(long long a1)
{
if ( opt_drop_database )
fprintf(
md_result_file,
"\n"
"/*!50106 SET @save_log_output=@@LOG_OUTPUT*/;\n"
"/*M!100203 EXECUTE IMMEDIATE IF(@@LOG_OUTPUT='TABLE' AND (@@SLOW_QUERY_LOG=1 OR @@GENERAL_LOG=1),\"SET GLOBAL LOG_"
"OUTPUT='NONE'\", \"DO 0\") */;\n");
return (unsigned int)init_dumping_tables(a1);
}
| init_dumping_mysql_tables:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
CMP byte ptr [0x00501821],0x0
JZ 0x0013f73a
MOV RDI,qword ptr [0x005014b0]
LEA RSI,[0x1dc4b0]
MOV AL,0x0
CALL 0x001381d0
LAB_0013f73a:
JMP 0x0013f73c
LAB_0013f73c:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0013f760
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD RSP,0x10
POP RBP
RET
|
int4 init_dumping_mysql_tables(int8 param_1)
{
int4 uVar1;
if (opt_drop_database != '\0') {
fprintf(md_result_file,
"\n/*!50106 SET @save_log_output=@@LOG_OUTPUT*/;\n/*M!100203 EXECUTE IMMEDIATE IF(@@LOG_OUTPUT=\'TABLE\' AND (@@SLOW_QUERY_LOG=1 OR @@GENERAL_LOG=1),\"SET GLOBAL LOG_OUTPUT=\'NONE\'\", \"DO 0\") */;\n"
);
}
uVar1 = init_dumping_tables(param_1);
return uVar1;
}
| |
39,569 | init_block | eloqsql/storage/heap/hp_create.c | static void init_block(HP_BLOCK *block, uint reclength, ulong min_records,
ulong max_records)
{
ulong i,recbuffer,records_in_block;
/*
If not min_records and max_records are given, optimize for 1000 rows
*/
if (!min_records)
min_records= MY_MIN(1000, max_records);
if (!max_records)
max_records= MY_MAX(min_records, 1000);
/*
We don't want too few records_in_block as otherwise the overhead of
of the HP_PTRS block will be too notable
*/
records_in_block= MY_MAX(1000, min_records);
records_in_block= MY_MIN(records_in_block, max_records);
/* If big max_records is given, allocate bigger blocks */
records_in_block= MY_MAX(records_in_block, max_records / 10);
/* We don't want too few blocks per row either */
if (records_in_block < 10)
records_in_block= 10;
recbuffer= (uint) (reclength + sizeof(uchar**) - 1) & ~(sizeof(uchar**) - 1);
/*
Don't allocate more than my_default_record_cache_size per level.
The + 1 is there to ensure that we get at least 1 row per level (for
the exceptional case of very long rows)
*/
if ((ulonglong) records_in_block*recbuffer >
(my_default_record_cache_size-sizeof(HP_PTRS)*HP_MAX_LEVELS))
records_in_block= (my_default_record_cache_size - sizeof(HP_PTRS) *
HP_MAX_LEVELS) / recbuffer + 1;
block->records_in_block= records_in_block;
block->recbuffer= recbuffer;
block->last_allocated= 0L;
for (i= 0; i <= HP_MAX_LEVELS; i++)
block->level_info[i].records_under_level=
(!i ? 1 : i == 1 ? records_in_block :
HP_PTRS_IN_NOD * block->level_info[i - 1].records_under_level);
} | O3 | c | init_block:
movl $0x3e8, %eax # imm = 0x3E8
cmpq %rax, %rcx
movl $0x3e8, %r8d # imm = 0x3E8
cmovbq %rcx, %r8
testq %rdx, %rdx
cmovneq %rdx, %r8
cmpq $0x3e9, %r8 # imm = 0x3E9
cmovbq %rax, %r8
testq %rcx, %rcx
cmoveq %r8, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rdx
shrq $0x3, %rdx
cmpq %rcx, %r8
cmovbq %r8, %rcx
cmpq %rdx, %r8
cmovbeq %rdx, %rcx
cmpq $0xb, %rcx
movl $0xa, %eax
cmovaeq %rcx, %rax
addl $0x7, %esi
andl $-0x8, %esi
movq %rax, %rdx
imulq %rsi, %rdx
leaq 0x2d02a2(%rip), %r8 # 0x2f63c0
movq $-0x1000, %rcx # imm = 0xF000
addq (%r8), %rcx
cmpq %rcx, %rdx
jbe 0x26138
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
incq %rax
pushq %rbp
movq %rsp, %rbp
movq %rax, 0x88(%rdi)
movl %esi, 0x84(%rdi)
movq $0x0, 0x90(%rdi)
addq $-0x8, %rdi
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x26171
movq %rax, %rdx
cmpq $0x1, %rcx
je 0x26176
movq (%rdi), %rdx
shlq $0x7, %rdx
jmp 0x26176
movl $0x1, %edx
movq %rdx, 0x18(%rdi)
addq $0x18, %rdi
incq %rcx
cmpq $0x5, %rcx
jne 0x2615a
popq %rbp
retq
| init_block:
mov eax, 3E8h
cmp rcx, rax
mov r8d, 3E8h
cmovb r8, rcx
test rdx, rdx
cmovnz r8, rdx
cmp r8, 3E9h
cmovb r8, rax
test rcx, rcx
cmovz rcx, r8
mov rdx, 0CCCCCCCCCCCCCCCDh
mov rax, rcx
mul rdx
shr rdx, 3
cmp r8, rcx
cmovb rcx, r8
cmp r8, rdx
cmovbe rcx, rdx
cmp rcx, 0Bh
mov eax, 0Ah
cmovnb rax, rcx
add esi, 7
and esi, 0FFFFFFF8h
mov rdx, rax
imul rdx, rsi
lea r8, my_default_record_cache_size
mov rcx, 0FFFFFFFFFFFFF000h
add rcx, [r8]
cmp rdx, rcx
jbe short loc_26138
mov rax, rcx
xor edx, edx
div rsi
inc rax
loc_26138:
push rbp
mov rbp, rsp
mov [rdi+88h], rax
mov [rdi+84h], esi
mov qword ptr [rdi+90h], 0
add rdi, 0FFFFFFFFFFFFFFF8h
xor ecx, ecx
loc_2615A:
test rcx, rcx
jz short loc_26171
mov rdx, rax
cmp rcx, 1
jz short loc_26176
mov rdx, [rdi]
shl rdx, 7
jmp short loc_26176
loc_26171:
mov edx, 1
loc_26176:
mov [rdi+18h], rdx
add rdi, 18h
inc rcx
cmp rcx, 5
jnz short loc_2615A
pop rbp
retn
| unsigned long long init_block(long long a1, int a2, unsigned long long a3, unsigned long long a4)
{
unsigned long long v4; // r8
unsigned long long v5; // rdx
unsigned long long result; // rax
unsigned long long v7; // rsi
_QWORD *v8; // rdi
long long i; // rcx
long long v10; // rdx
v4 = 1000LL;
if ( a4 < 0x3E8 )
v4 = a4;
if ( a3 )
v4 = a3;
if ( v4 < 0x3E9 )
v4 = 1000LL;
if ( !a4 )
a4 = v4;
v5 = a4 / 0xA;
if ( v4 < a4 )
a4 = v4;
if ( v4 <= v5 )
a4 = v5;
result = 10LL;
if ( a4 >= 0xB )
result = a4;
v7 = (a2 + 7) & 0xFFFFFFF8;
if ( v7 * result > my_default_record_cache_size - 4096LL )
result = (my_default_record_cache_size - 4096LL) / v7 + 1;
*(_QWORD *)(a1 + 136) = result;
*(_DWORD *)(a1 + 132) = v7;
*(_QWORD *)(a1 + 144) = 0LL;
v8 = (_QWORD *)(a1 - 8);
for ( i = 0LL; i != 5; ++i )
{
if ( i )
{
v10 = result;
if ( i != 1 )
v10 = *v8 << 7;
}
else
{
v10 = 1LL;
}
v8[3] = v10;
v8 += 3;
}
return result;
}
| init_block:
MOV EAX,0x3e8
CMP RCX,RAX
MOV R8D,0x3e8
CMOVC R8,RCX
TEST RDX,RDX
CMOVNZ R8,RDX
CMP R8,0x3e9
CMOVC R8,RAX
TEST RCX,RCX
CMOVZ RCX,R8
MOV RDX,-0x3333333333333333
MOV RAX,RCX
MUL RDX
SHR RDX,0x3
CMP R8,RCX
CMOVC RCX,R8
CMP R8,RDX
CMOVBE RCX,RDX
CMP RCX,0xb
MOV EAX,0xa
CMOVNC RAX,RCX
ADD ESI,0x7
AND ESI,0xfffffff8
MOV RDX,RAX
IMUL RDX,RSI
LEA R8,[0x3f63c0]
MOV RCX,-0x1000
ADD RCX,qword ptr [R8]
CMP RDX,RCX
JBE 0x00126138
MOV RAX,RCX
XOR EDX,EDX
DIV RSI
INC RAX
LAB_00126138:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RDI + 0x88],RAX
MOV dword ptr [RDI + 0x84],ESI
MOV qword ptr [RDI + 0x90],0x0
ADD RDI,-0x8
XOR ECX,ECX
LAB_0012615a:
TEST RCX,RCX
JZ 0x00126171
MOV RDX,RAX
CMP RCX,0x1
JZ 0x00126176
MOV RDX,qword ptr [RDI]
SHL RDX,0x7
JMP 0x00126176
LAB_00126171:
MOV EDX,0x1
LAB_00126176:
MOV qword ptr [RDI + 0x18],RDX
ADD RDI,0x18
INC RCX
CMP RCX,0x5
JNZ 0x0012615a
POP RBP
RET
|
void init_block(long param_1,int param_2,ulong param_3,ulong param_4)
{
ulong uVar1;
long lVar2;
ulong uVar3;
uint uVar4;
long *plVar5;
ulong uVar6;
uVar6 = 1000;
if (param_4 < 1000) {
uVar6 = param_4;
}
if (param_3 != 0) {
uVar6 = param_3;
}
if (uVar6 < 0x3e9) {
uVar6 = 1000;
}
if (param_4 == 0) {
param_4 = uVar6;
}
uVar1 = param_4;
if (uVar6 < param_4) {
uVar1 = uVar6;
}
if (uVar6 <= param_4 / 10) {
uVar1 = param_4 / 10;
}
uVar6 = 10;
if (10 < uVar1) {
uVar6 = uVar1;
}
uVar4 = param_2 + 7U & 0xfffffff8;
uVar3 = uVar6 * uVar4;
uVar1 = my_default_record_cache_size - 0x1000;
if (uVar1 <= uVar3 && uVar3 - uVar1 != 0) {
uVar6 = uVar1 / uVar4 + 1;
}
*(ulong *)(param_1 + 0x88) = uVar6;
*(uint *)(param_1 + 0x84) = uVar4;
*(int8 *)(param_1 + 0x90) = 0;
plVar5 = (long *)(param_1 + -8);
lVar2 = 0;
do {
if (lVar2 == 0) {
uVar1 = 1;
}
else {
uVar1 = uVar6;
if (lVar2 != 1) {
uVar1 = *plVar5 << 7;
}
}
plVar5[3] = uVar1;
plVar5 = plVar5 + 3;
lVar2 = lVar2 + 1;
} while (lVar2 != 5);
return;
}
| |
39,570 | mysql_list_dbs_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_list_dbs_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_list_dbs,
(parms->mysql, parms->wild),
parms->mysql,
MYSQL_RES *,
r_ptr)
} | O0 | c | mysql_list_dbs_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3a780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
| mysql_list_dbs_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov rsi, [rax+8]
call mysql_list_dbs
mov [rbp+var_18], rax
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+8], rcx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| long long mysql_list_dbs_start_internal(long long a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-20h]
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
*(_QWORD *)(v2 + 8) = mysql_list_dbs(*(_QWORD *)a1, *(const char **)(a1 + 8));
result = v2;
*(_DWORD *)v2 = 0;
return result;
}
| mysql_list_dbs_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x0013a780
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_list_dbs_start_internal(long *param_1)
{
int4 *puVar1;
int8 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_list_dbs(*param_1,param_1[1]);
*(int8 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
| |
39,571 | mariadb_get_infov | eloqsql/libmariadb/libmariadb/mariadb_lib.c | my_bool mariadb_get_infov(MYSQL *mysql, enum mariadb_value value, void *arg, ...)
{
va_list ap;
va_start(ap, arg);
switch(value) {
case MARIADB_MAX_ALLOWED_PACKET:
*((size_t *)arg)= (size_t)max_allowed_packet;
break;
case MARIADB_NET_BUFFER_LENGTH:
*((size_t *)arg)= (size_t)net_buffer_length;
break;
case MARIADB_CONNECTION_ERROR_ID:
if (!mysql)
goto error;
*((unsigned int *)arg)= mysql->net.last_errno;
break;
case MARIADB_CONNECTION_ERROR:
if (!mysql)
goto error;
*((char **)arg)= mysql->net.last_error;
break;
case MARIADB_CONNECTION_SQLSTATE:
if (!mysql)
goto error;
*((char **)arg)= mysql->net.sqlstate;
break;
case MARIADB_CONNECTION_TLS_VERSION:
#ifdef HAVE_TLS
if (mysql && mysql->net.pvio && mysql->net.pvio->ctls)
*((char **)arg)= (char *)ma_pvio_tls_get_protocol_version(mysql->net.pvio->ctls);
else
#endif
goto error;
break;
case MARIADB_CONNECTION_TLS_VERSION_ID:
#ifdef HAVE_TLS
if (mysql && mysql->net.pvio && mysql->net.pvio->ctls)
*((unsigned int *)arg)= ma_pvio_tls_get_protocol_version_id(mysql->net.pvio->ctls);
else
#endif
goto error;
break;
case MARIADB_TLS_LIBRARY:
#ifdef HAVE_TLS
*((const char **)arg)= tls_library_version;
#else
*((const char **)arg)= "Off";
#endif
break;
case MARIADB_CLIENT_VERSION:
*((const char **)arg)= MARIADB_CLIENT_VERSION_STR;
break;
case MARIADB_CLIENT_VERSION_ID:
*((size_t *)arg)= MARIADB_VERSION_ID;
break;
case MARIADB_CONNECTION_SERVER_VERSION:
if (mysql)
*((char **)arg)= mysql->server_version;
else
goto error;
break;
case MARIADB_CONNECTION_SERVER_TYPE:
if (mysql)
*((const char **)arg)= mariadb_connection(mysql) ? "MariaDB" : "MySQL";
else
goto error;
break;
case MARIADB_CONNECTION_SERVER_VERSION_ID:
if (mysql)
*((size_t *)arg)= mariadb_server_version_id(mysql);
else
goto error;
break;
case MARIADB_CONNECTION_PROTOCOL_VERSION_ID:
if (mysql)
*((unsigned int *)arg)= mysql->protocol_version;
else
goto error;
break;
case MARIADB_CONNECTION_MARIADB_CHARSET_INFO:
if (mysql)
mariadb_get_charset_info(mysql, (MY_CHARSET_INFO *)arg);
else
goto error;
break;
case MARIADB_CONNECTION_SOCKET:
if (mysql)
*((my_socket *)arg)= mariadb_get_socket(mysql);
else
goto error;
break;
case MARIADB_CONNECTION_TYPE:
if (mysql && mysql->net.pvio)
*((int *)arg)= (int)mysql->net.pvio->type;
else
goto error;
break;
case MARIADB_CONNECTION_ASYNC_TIMEOUT_MS:
if (mysql && mysql->options.extension && mysql->options.extension->async_context)
*((unsigned int *)arg)= mysql->options.extension->async_context->timeout_value;
break;
case MARIADB_CONNECTION_ASYNC_TIMEOUT:
if (mysql && mysql->options.extension && mysql->options.extension->async_context)
{
unsigned int timeout= mysql->options.extension->async_context->timeout_value;
if (timeout > UINT_MAX - 999)
*((unsigned int *)arg)= (timeout - 1)/1000 + 1;
else
*((unsigned int *)arg)= (timeout+999)/1000;
}
break;
case MARIADB_CHARSET_NAME:
{
char *name;
name= va_arg(ap, char *);
if (name)
*((MARIADB_CHARSET_INFO **)arg)= (MARIADB_CHARSET_INFO *)mysql_find_charset_name(name);
else
goto error;
}
break;
case MARIADB_CHARSET_ID:
{
unsigned int nr;
nr= va_arg(ap, unsigned int);
*((MARIADB_CHARSET_INFO **)arg)= (MARIADB_CHARSET_INFO *)mysql_find_charset_nr(nr);
}
break;
case MARIADB_CONNECTION_SSL_CIPHER:
#ifdef HAVE_TLS
if (mysql && mysql->net.pvio && mysql->net.pvio->ctls)
*((char **)arg)= (char *)ma_pvio_tls_cipher(mysql->net.pvio->ctls);
else
#endif
*((char **)arg)= NULL;
break;
case MARIADB_CLIENT_ERRORS:
*((char ***)arg)= (char **)client_errors;
break;
case MARIADB_CONNECTION_INFO:
if (mysql)
*((char **)arg)= (char *)mysql->info;
else
goto error;
break;
case MARIADB_CONNECTION_PVIO_TYPE:
if (mysql && mysql->net.pvio)
*((unsigned int *)arg)= (unsigned int)mysql->net.pvio->type;
else
goto error;
break;
case MARIADB_CONNECTION_SCHEMA:
if (mysql)
*((char **)arg)= mysql->db;
else
goto error;
break;
case MARIADB_CONNECTION_USER:
if (mysql)
*((char **)arg)= mysql->user;
else
goto error;
break;
case MARIADB_CONNECTION_PORT:
if (mysql)
*((unsigned int *)arg)= mysql->port;
else
goto error;
break;
case MARIADB_CONNECTION_UNIX_SOCKET:
if (mysql)
*((char **)arg)= mysql->unix_socket;
else
goto error;
break;
case MARIADB_CONNECTION_HOST:
if (mysql)
*((char **)arg)= mysql->host;
else
goto error;
break;
case MARIADB_CONNECTION_SERVER_STATUS:
if (mysql)
*((unsigned int *)arg)= mysql->server_status;
else
goto error;
break;
case MARIADB_CONNECTION_SERVER_CAPABILITIES:
if (mysql)
*((unsigned long *)arg)= mysql->server_capabilities;
else
goto error;
break;
case MARIADB_CONNECTION_EXTENDED_SERVER_CAPABILITIES:
if (mysql)
*((unsigned long *)arg)= mysql->extension->mariadb_server_capabilities;
else
goto error;
break;
case MARIADB_CONNECTION_CLIENT_CAPABILITIES:
if (mysql)
*((unsigned long *)arg)= mysql->client_flag;
else
goto error;
break;
case MARIADB_CONNECTION_BYTES_READ:
*((size_t *)arg)= mysql->net.pvio->bytes_read;
break;
case MARIADB_CONNECTION_BYTES_SENT:
*((size_t *)arg)= mysql->net.pvio->bytes_sent;
break;
default:
va_end(ap);
return(-1);
}
va_end(ap);
return(0);
error:
va_end(ap);
return(-1);
} | O3 | c | mariadb_get_infov:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
leaq -0xd0(%rbp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x1c87a
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %rdx, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movabsq $0x3000000018, %rax # imm = 0x3000000018
movq %rax, -0x20(%rbp)
movb $-0x1, %al
cmpl $0x23, %esi
ja 0x1cc2d
movl %esi, %ecx
leaq 0x1b5a0(%rip), %rdx # 0x37e48
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
testq %rdi, %rdi
je 0x1cc2d
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1cc2d
movl 0x20(%rcx), %eax
jmp 0x1cbca
movq (%rdi), %rax
movq 0x68(%rax), %rax
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2d
movq 0x2b8(%rdi), %rax
jmp 0x1cc28
movq (%rdi), %rax
movq 0x60(%rax), %rax
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2d
movq 0x2d0(%rdi), %rax
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2d
movq 0x2e8(%rdi), %rax
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2d
movq 0x368(%rdi), %rax
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2d
movq 0x2e0(%rdi), %rax
jmp 0x1cc28
movq $0x18902, (%rbx) # imm = 0x18902
jmp 0x1cc2b
testq %rdi, %rdi
je 0x1cc2d
movl 0x360(%rdi), %eax
jmp 0x1cbca
testq %rdi, %rdi
je 0x1cc2d
movl 0x90(%rdi), %eax
jmp 0x1cbca
leaq 0x2c0e6(%rip), %rax # 0x48a70
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2d
callq 0x1588b
testb %al, %al
leaq 0x182b0(%rip), %rax # 0x34c56
leaq 0x18299(%rip), %rcx # 0x34c46
cmoveq %rax, %rcx
movq %rcx, (%rbx)
jmp 0x1cc2b
leaq 0x1829c(%rip), %rax # 0x34c5c
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2d
movq %rbx, %rsi
callq 0x1c61c
jmp 0x1cc2b
movl -0x20(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x1cbfa
movq %rcx, %rax
addq -0x10(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x20(%rbp)
jmp 0x1cc06
movl -0x20(%rbp), %edx
cmpq $0x28, %rdx
ja 0x1cc0f
movq %rdx, %rcx
addq -0x10(%rbp), %rcx
addl $0x8, %edx
movl %edx, -0x20(%rbp)
jmp 0x1cc1b
testq %rdi, %rdi
je 0x1cc2d
movq 0x370(%rdi), %rax
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2d
movq 0x2d0(%rdi), %rdi
callq 0x1bd21
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cbf1
movq (%rdi), %rax
testq %rax, %rax
je 0x1cbf1
movq 0x38(%rax), %rdi
testq %rdi, %rdi
je 0x1cbf1
callq 0x1d9f2
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2b
movq 0x480(%rdi), %rax
testq %rax, %rax
je 0x1cc2b
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x1cc2b
movl 0x10(%rax), %eax
cmpl $0xfffffc19, %eax # imm = 0xFFFFFC19
jb 0x1cc37
decl %eax
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
shrq $0x26, %rax
incl %eax
jmp 0x1cc47
leaq 0x2ddfd(%rip), %rax # 0x4a8c0
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2d
movl 0x378(%rdi), %eax
jmp 0x1cbca
testq %rdi, %rdi
je 0x1cc2b
movq 0x480(%rdi), %rax
testq %rax, %rax
je 0x1cc2b
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x1cc2b
movl 0x10(%rax), %eax
jmp 0x1cbca
testq %rdi, %rdi
je 0x1cc2d
callq 0x1c7ce
jmp 0x1cbca
testq %rdi, %rdi
je 0x1cc2d
movq 0x2b0(%rdi), %rax
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2d
addq $0x97, %rdi
jmp 0x1cbaa
testq %rdi, %rdi
je 0x1cc2d
movl 0x380(%rdi), %eax
jmp 0x1cbca
testq %rdi, %rdi
je 0x1cc2d
movq 0x4f0(%rdi), %rax
movq 0x70(%rax), %rax
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2d
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1cc2d
movq 0x38(%rcx), %rdi
testq %rdi, %rdi
je 0x1cc2d
callq 0x1da10
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2d
addq $0x297, %rdi # imm = 0x297
movq %rdi, (%rbx)
jmp 0x1cc2b
testq %rdi, %rdi
je 0x1cc2d
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1cc2d
movq 0x38(%rcx), %rdi
testq %rdi, %rdi
je 0x1cc2d
callq 0x1da06
movl %eax, (%rbx)
jmp 0x1cc2b
leaq 0x2be43(%rip), %rax # 0x48a18
jmp 0x1cbde
leaq 0x2be52(%rip), %rax # 0x48a30
movq (%rax), %rax
jmp 0x1cc28
testq %rdi, %rdi
je 0x1cc2d
movq 0x2c8(%rdi), %rax
jmp 0x1cc28
movq $0x0, (%rbx)
jmp 0x1cc2b
movq -0x18(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movl (%rax), %edi
callq 0x3013e
jmp 0x1cc28
movq -0x18(%rbp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, -0x18(%rbp)
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x1cc2d
callq 0x301c2
movq %rax, (%rbx)
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
addl $0x3e7, %eax # imm = 0x3E7
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
shrq $0x26, %rax
movl %eax, (%rbx)
jmp 0x1cc2b
| mariadb_get_infov:
push rbp
mov rbp, rsp
push rbx
sub rsp, 0C8h
mov rbx, rdx
lea rdx, [rbp+var_D0]
mov [rdx+18h], rcx
mov [rdx+20h], r8
mov [rdx+28h], r9
test al, al
jz short loc_1C87A
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_1C87A:
mov [rbp+var_10], rdx
lea rax, [rbp+arg_0]
mov [rbp+var_18], rax
mov rax, 3000000018h
mov [rbp+var_20], rax
mov al, 0FFh
cmp esi, 23h; switch 36 cases
ja def_1C8AF; jumptable 000000000001C8AF default case
mov ecx, esi
lea rdx, jpt_1C8AF
movsxd rcx, ds:(jpt_1C8AF - 37E48h)[rdx+rcx*4]
add rcx, rdx
jmp rcx; switch jump
loc_1C8B1:
test rdi, rdi; jumptable 000000000001C8AF cases 14,25
jz def_1C8AF; jumptable 000000000001C8AF default case
mov rcx, [rdi]
test rcx, rcx
jz def_1C8AF; jumptable 000000000001C8AF default case
mov eax, [rcx+20h]
jmp loc_1CBCA
loc_1C8CE:
mov rax, [rdi]; jumptable 000000000001C8AF case 35
mov rax, [rax+68h]
jmp loc_1CC28
loc_1C8DA:
test rdi, rdi; jumptable 000000000001C8AF case 27
jz def_1C8AF; jumptable 000000000001C8AF default case
mov rax, [rdi+2B8h]
jmp loc_1CC28
loc_1C8EF:
mov rax, [rdi]; jumptable 000000000001C8AF case 34
mov rax, [rax+60h]
jmp loc_1CC28
loc_1C8FB:
test rdi, rdi; jumptable 000000000001C8AF case 17
jz def_1C8AF; jumptable 000000000001C8AF default case
mov rax, [rdi+2D0h]
jmp loc_1CC28
loc_1C910:
test rdi, rdi; jumptable 000000000001C8AF case 15
jz def_1C8AF; jumptable 000000000001C8AF default case
mov rax, [rdi+2E8h]
jmp loc_1CC28
loc_1C925:
test rdi, rdi; jumptable 000000000001C8AF case 33
jz def_1C8AF; jumptable 000000000001C8AF default case
mov rax, [rdi+368h]
jmp loc_1CC28
loc_1C93A:
test rdi, rdi; jumptable 000000000001C8AF case 11
jz def_1C8AF; jumptable 000000000001C8AF default case
mov rax, [rdi+2E0h]
jmp loc_1CC28
loc_1C94F:
mov qword ptr [rbx], offset loc_18902; jumptable 000000000001C8AF case 4
jmp loc_1CC2B
loc_1C95B:
test rdi, rdi; jumptable 000000000001C8AF case 12
jz def_1C8AF; jumptable 000000000001C8AF default case
mov eax, [rdi+360h]
jmp loc_1CBCA
loc_1C96F:
test rdi, rdi; jumptable 000000000001C8AF case 9
jz def_1C8AF; jumptable 000000000001C8AF default case
mov eax, [rdi+90h]
jmp loc_1CBCA
loc_1C983:
lea rax, client_errors; jumptable 000000000001C8AF case 2
jmp loc_1CC28
loc_1C98F:
test rdi, rdi; jumptable 000000000001C8AF case 16
jz def_1C8AF; jumptable 000000000001C8AF default case
call mariadb_connection
test al, al
lea rax, aMysql; "MySQL"
lea rcx, aMariadb; "MariaDB"
cmovz rcx, rax
mov [rbx], rcx
jmp loc_1CC2B
loc_1C9B9:
lea rax, a10610; jumptable 000000000001C8AF case 3
jmp loc_1CC28
loc_1C9C5:
test rdi, rdi; jumptable 000000000001C8AF case 7
jz def_1C8AF; jumptable 000000000001C8AF default case
mov rsi, rbx
call mariadb_get_charset_info
jmp loc_1CC2B
loc_1C9DB:
mov ecx, dword ptr [rbp+var_20]; jumptable 000000000001C8AF case 0
cmp rcx, 28h ; '('
ja loc_1CBFA
mov rax, rcx
add rax, [rbp+var_10]
add ecx, 8
mov dword ptr [rbp+var_20], ecx
jmp loc_1CC06
loc_1C9FA:
mov edx, dword ptr [rbp+var_20]; jumptable 000000000001C8AF case 1
cmp rdx, 28h ; '('
ja loc_1CC0F
mov rcx, rdx
add rcx, [rbp+var_10]
add edx, 8
mov dword ptr [rbp+var_20], edx
jmp loc_1CC1B
loc_1CA19:
test rdi, rdi; jumptable 000000000001C8AF case 31
jz def_1C8AF; jumptable 000000000001C8AF default case
mov rax, [rdi+370h]
jmp loc_1CC28
loc_1CA2E:
test rdi, rdi; jumptable 000000000001C8AF case 18
jz def_1C8AF; jumptable 000000000001C8AF default case
mov rdi, [rdi+2D0h]
call mariadb_server_version_id
jmp loc_1CC28
loc_1CA48:
test rdi, rdi; jumptable 000000000001C8AF case 21
jz loc_1CBF1
mov rax, [rdi]
test rax, rax
jz loc_1CBF1
mov rdi, [rax+38h]
test rdi, rdi
jz loc_1CBF1
call ma_pvio_tls_cipher
jmp loc_1CC28
loc_1CA74:
test rdi, rdi; jumptable 000000000001C8AF case 5
jz loc_1CC2B
mov rax, [rdi+480h]
test rax, rax
jz loc_1CC2B
mov rax, [rax+28h]
test rax, rax
jz loc_1CC2B
mov eax, [rax+10h]
cmp eax, 0FFFFFC19h
jb loc_1CC37
dec eax
imul rax, 10624DD3h
shr rax, 26h
inc eax
jmp loc_1CC47
loc_1CABC:
lea rax, tls_library_version; jumptable 000000000001C8AF case 22
jmp loc_1CC28
loc_1CAC8:
test rdi, rdi; jumptable 000000000001C8AF case 13
jz def_1C8AF; jumptable 000000000001C8AF default case
mov eax, [rdi+378h]
jmp loc_1CBCA
loc_1CADC:
test rdi, rdi; jumptable 000000000001C8AF case 6
jz loc_1CC2B
mov rax, [rdi+480h]
test rax, rax
jz loc_1CC2B
mov rax, [rax+28h]
test rax, rax
jz loc_1CC2B
mov eax, [rax+10h]
jmp loc_1CBCA
loc_1CB0A:
test rdi, rdi; jumptable 000000000001C8AF case 19
jz def_1C8AF; jumptable 000000000001C8AF default case
call mariadb_get_socket
jmp loc_1CBCA
loc_1CB1D:
test rdi, rdi; jumptable 000000000001C8AF case 10
jz def_1C8AF; jumptable 000000000001C8AF default case
mov rax, [rdi+2B0h]
jmp loc_1CC28
loc_1CB32:
test rdi, rdi; jumptable 000000000001C8AF case 8
jz def_1C8AF; jumptable 000000000001C8AF default case
add rdi, 97h
jmp short loc_1CBAA
loc_1CB44:
test rdi, rdi; jumptable 000000000001C8AF case 30
jz def_1C8AF; jumptable 000000000001C8AF default case
mov eax, [rdi+380h]
jmp short loc_1CBCA
loc_1CB55:
test rdi, rdi; jumptable 000000000001C8AF case 32
jz def_1C8AF; jumptable 000000000001C8AF default case
mov rax, [rdi+4F0h]
mov rax, [rax+70h]
jmp loc_1CC28
loc_1CB6E:
test rdi, rdi; jumptable 000000000001C8AF case 23
jz def_1C8AF; jumptable 000000000001C8AF default case
mov rcx, [rdi]
test rcx, rcx
jz def_1C8AF; jumptable 000000000001C8AF default case
mov rdi, [rcx+38h]
test rdi, rdi
jz def_1C8AF; jumptable 000000000001C8AF default case
call ma_pvio_tls_get_protocol_version
jmp loc_1CC28
loc_1CB9A:
test rdi, rdi; jumptable 000000000001C8AF case 20
jz def_1C8AF; jumptable 000000000001C8AF default case
add rdi, 297h
loc_1CBAA:
mov [rbx], rdi
jmp short loc_1CC2B
loc_1CBAF:
test rdi, rdi; jumptable 000000000001C8AF case 24
jz short def_1C8AF; jumptable 000000000001C8AF default case
mov rcx, [rdi]
test rcx, rcx
jz short def_1C8AF; jumptable 000000000001C8AF default case
mov rdi, [rcx+38h]
test rdi, rdi
jz short def_1C8AF; jumptable 000000000001C8AF default case
call ma_pvio_tls_get_protocol_version_id
loc_1CBCA:
mov [rbx], eax
jmp short loc_1CC2B
loc_1CBCE:
lea rax, max_allowed_packet; jumptable 000000000001C8AF case 28
jmp short loc_1CBDE
loc_1CBD7:
lea rax, net_buffer_length; jumptable 000000000001C8AF case 29
loc_1CBDE:
mov rax, [rax]
jmp short loc_1CC28
loc_1CBE3:
test rdi, rdi; jumptable 000000000001C8AF case 26
jz short def_1C8AF; jumptable 000000000001C8AF default case
mov rax, [rdi+2C8h]
jmp short loc_1CC28
loc_1CBF1:
mov qword ptr [rbx], 0
jmp short loc_1CC2B
loc_1CBFA:
mov rax, [rbp+var_18]
lea rcx, [rax+8]
mov [rbp+var_18], rcx
loc_1CC06:
mov edi, [rax]
call mysql_find_charset_nr
jmp short loc_1CC28
loc_1CC0F:
mov rcx, [rbp+var_18]
lea rdx, [rcx+8]
mov [rbp+var_18], rdx
loc_1CC1B:
mov rdi, [rcx]
test rdi, rdi
jz short def_1C8AF; jumptable 000000000001C8AF default case
call mysql_find_charset_name
loc_1CC28:
mov [rbx], rax
loc_1CC2B:
xor eax, eax
def_1C8AF:
add rsp, 0C8h; jumptable 000000000001C8AF default case
pop rbx
pop rbp
retn
loc_1CC37:
add eax, 3E7h
imul rax, 10624DD3h
shr rax, 26h
loc_1CC47:
mov [rbx], eax
jmp short loc_1CC2B
| long long mariadb_get_infov(
long long a1,
int a2,
const char **a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
long long result; // rax
int socket; // eax
const char *charset_nr; // rax
bool v19; // al
const char *v20; // rcx
char *v21; // rax
char *v22; // rcx
long long v23; // rax
long long v24; // rax
unsigned int v25; // eax
unsigned int v26; // eax
long long v27; // rax
long long v28; // rax
long long v29; // rdi
const char **v30; // rax
char v31; // [rsp+0h] [rbp-D0h] BYREF
long long v32; // [rsp+18h] [rbp-B8h]
long long v33; // [rsp+20h] [rbp-B0h]
long long v34; // [rsp+28h] [rbp-A8h]
__m128 v35; // [rsp+30h] [rbp-A0h]
__m128 v36; // [rsp+40h] [rbp-90h]
__m128 v37; // [rsp+50h] [rbp-80h]
__m128 v38; // [rsp+60h] [rbp-70h]
__m128 v39; // [rsp+70h] [rbp-60h]
__m128 v40; // [rsp+80h] [rbp-50h]
__m128 v41; // [rsp+90h] [rbp-40h]
__m128 v42; // [rsp+A0h] [rbp-30h]
long long v43; // [rsp+B0h] [rbp-20h]
char *v44; // [rsp+B8h] [rbp-18h]
char *v45; // [rsp+C0h] [rbp-10h]
v35 = a7;
v36 = a8;
v37 = a9;
v38 = a10;
v39 = a11;
v40 = a12;
v41 = a13;
v42 = a14;
v32 = a4;
v33 = a5;
v34 = a6;
v45 = &v31;
v44 = &a15;
result = 0x30000000FFLL;
v43 = 0x3000000018LL;
switch ( a2 )
{
case 0:
if ( (unsigned int)v43 > 0x28uLL )
{
v21 = v44;
v44 += 8;
}
else
{
v21 = &v45[(unsigned int)v43];
LODWORD(v43) = v43 + 8;
}
charset_nr = (const char *)mysql_find_charset_nr(*(unsigned int *)v21);
goto LABEL_87;
case 1:
if ( (unsigned int)v43 > 0x28uLL )
{
v22 = v44;
v44 += 8;
}
else
{
v22 = &v45[(unsigned int)v43];
LODWORD(v43) = v43 + 8;
}
if ( !*(_QWORD *)v22 )
return result;
charset_nr = (const char *)mysql_find_charset_name(*(_QWORD *)v22);
goto LABEL_87;
case 2:
charset_nr = (const char *)client_errors;
goto LABEL_87;
case 3:
charset_nr = "10.6.10";
goto LABEL_87;
case 4:
*a3 = (const char *)&loc_18902;
return 0LL;
case 5:
if ( a1 )
{
v23 = *(_QWORD *)(a1 + 1152);
if ( v23 )
{
v24 = *(_QWORD *)(v23 + 40);
if ( v24 )
{
v25 = *(_DWORD *)(v24 + 16);
if ( v25 < 0xFFFFFC19 )
v26 = (v25 + 999) / 0x3E8;
else
v26 = (v25 - 1) / 0x3E8 + 1;
*(_DWORD *)a3 = v26;
}
}
}
return 0LL;
case 6:
if ( !a1 )
return 0LL;
v27 = *(_QWORD *)(a1 + 1152);
if ( !v27 )
return 0LL;
v28 = *(_QWORD *)(v27 + 40);
if ( !v28 )
return 0LL;
socket = *(_DWORD *)(v28 + 16);
goto LABEL_75;
case 7:
if ( !a1 )
return result;
mariadb_get_charset_info(a1, (long long)a3);
return 0LL;
case 8:
if ( !a1 )
return result;
v29 = a1 + 151;
goto LABEL_70;
case 9:
if ( !a1 )
return result;
socket = *(_DWORD *)(a1 + 144);
goto LABEL_75;
case 10:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 688);
goto LABEL_87;
case 11:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 736);
goto LABEL_87;
case 12:
if ( !a1 )
return result;
socket = *(_DWORD *)(a1 + 864);
goto LABEL_75;
case 13:
if ( !a1 )
return result;
socket = *(_DWORD *)(a1 + 888);
goto LABEL_75;
case 14:
case 25:
if ( !a1 || !*(_QWORD *)a1 )
return result;
socket = *(_DWORD *)(*(_QWORD *)a1 + 32LL);
goto LABEL_75;
case 15:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 744);
goto LABEL_87;
case 16:
if ( !a1 )
return result;
v19 = mariadb_connection(a1);
v20 = "MariaDB";
if ( !v19 )
v20 = "MySQL";
*a3 = v20;
return 0LL;
case 17:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 720);
goto LABEL_87;
case 18:
if ( !a1 )
return result;
charset_nr = (const char *)mariadb_server_version_id(*(_QWORD *)(a1 + 720));
goto LABEL_87;
case 19:
if ( !a1 )
return result;
socket = mariadb_get_socket((long long *)a1);
goto LABEL_75;
case 20:
if ( !a1 )
return result;
v29 = a1 + 663;
LABEL_70:
*a3 = (const char *)v29;
return 0LL;
case 21:
if ( a1 && *(_QWORD *)a1 && *(_QWORD *)(*(_QWORD *)a1 + 56LL) )
{
charset_nr = (const char *)ma_pvio_tls_cipher();
LABEL_87:
*a3 = charset_nr;
}
else
{
*a3 = 0LL;
}
return 0LL;
case 22:
charset_nr = (const char *)&tls_library_version;
goto LABEL_87;
case 23:
if ( !a1 || !*(_QWORD *)a1 || !*(_QWORD *)(*(_QWORD *)a1 + 56LL) )
return result;
charset_nr = (const char *)ma_pvio_tls_get_protocol_version();
goto LABEL_87;
case 24:
if ( !a1 || !*(_QWORD *)a1 || !*(_QWORD *)(*(_QWORD *)a1 + 56LL) )
return result;
socket = ma_pvio_tls_get_protocol_version_id();
goto LABEL_75;
case 26:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 712);
goto LABEL_87;
case 27:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 696);
goto LABEL_87;
case 28:
v30 = (const char **)&max_allowed_packet;
goto LABEL_78;
case 29:
v30 = (const char **)&net_buffer_length;
LABEL_78:
charset_nr = *v30;
goto LABEL_87;
case 30:
if ( !a1 )
return result;
socket = *(_DWORD *)(a1 + 896);
LABEL_75:
*(_DWORD *)a3 = socket;
return 0LL;
case 31:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 880);
goto LABEL_87;
case 32:
if ( !a1 )
return result;
charset_nr = *(const char **)(*(_QWORD *)(a1 + 1264) + 112LL);
goto LABEL_87;
case 33:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 872);
goto LABEL_87;
case 34:
charset_nr = *(const char **)(*(_QWORD *)a1 + 96LL);
goto LABEL_87;
case 35:
charset_nr = *(const char **)(*(_QWORD *)a1 + 104LL);
goto LABEL_87;
default:
return result;
}
}
| mariadb_get_infov:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xc8
MOV RBX,RDX
LEA RDX,[RBP + -0xd0]
MOV qword ptr [RDX + 0x18],RCX
MOV qword ptr [RDX + 0x20],R8
MOV qword ptr [RDX + 0x28],R9
TEST AL,AL
JZ 0x0011c87a
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_0011c87a:
MOV qword ptr [RBP + -0x10],RDX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,0x3000000018
MOV qword ptr [RBP + -0x20],RAX
MOV AL,0xff
CMP ESI,0x23
JA 0x0011cc2d
MOV ECX,ESI
LEA RDX,[0x137e48]
MOVSXD RCX,dword ptr [RDX + RCX*0x4]
ADD RCX,RDX
switchD:
JMP RCX
caseD_e:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RCX,qword ptr [RDI]
TEST RCX,RCX
JZ 0x0011cc2d
MOV EAX,dword ptr [RCX + 0x20]
JMP 0x0011cbca
caseD_23:
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x68]
JMP 0x0011cc28
caseD_1b:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RAX,qword ptr [RDI + 0x2b8]
JMP 0x0011cc28
caseD_22:
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x60]
JMP 0x0011cc28
caseD_11:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RAX,qword ptr [RDI + 0x2d0]
JMP 0x0011cc28
caseD_f:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RAX,qword ptr [RDI + 0x2e8]
JMP 0x0011cc28
caseD_21:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RAX,qword ptr [RDI + 0x368]
JMP 0x0011cc28
caseD_b:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RAX,qword ptr [RDI + 0x2e0]
JMP 0x0011cc28
caseD_4:
MOV qword ptr [RBX],0x18902
JMP 0x0011cc2b
caseD_c:
TEST RDI,RDI
JZ 0x0011cc2d
MOV EAX,dword ptr [RDI + 0x360]
JMP 0x0011cbca
caseD_9:
TEST RDI,RDI
JZ 0x0011cc2d
MOV EAX,dword ptr [RDI + 0x90]
JMP 0x0011cbca
caseD_2:
LEA RAX,[0x148a70]
JMP 0x0011cc28
caseD_10:
TEST RDI,RDI
JZ 0x0011cc2d
CALL 0x0011588b
TEST AL,AL
LEA RAX,[0x134c56]
LEA RCX,[0x134c46]
CMOVZ RCX,RAX
MOV qword ptr [RBX],RCX
JMP 0x0011cc2b
caseD_3:
LEA RAX,[0x134c5c]
JMP 0x0011cc28
caseD_7:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RSI,RBX
CALL 0x0011c61c
JMP 0x0011cc2b
caseD_0:
MOV ECX,dword ptr [RBP + -0x20]
CMP RCX,0x28
JA 0x0011cbfa
MOV RAX,RCX
ADD RAX,qword ptr [RBP + -0x10]
ADD ECX,0x8
MOV dword ptr [RBP + -0x20],ECX
JMP 0x0011cc06
caseD_1:
MOV EDX,dword ptr [RBP + -0x20]
CMP RDX,0x28
JA 0x0011cc0f
MOV RCX,RDX
ADD RCX,qword ptr [RBP + -0x10]
ADD EDX,0x8
MOV dword ptr [RBP + -0x20],EDX
JMP 0x0011cc1b
caseD_1f:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RAX,qword ptr [RDI + 0x370]
JMP 0x0011cc28
caseD_12:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RDI,qword ptr [RDI + 0x2d0]
CALL 0x0011bd21
JMP 0x0011cc28
caseD_15:
TEST RDI,RDI
JZ 0x0011cbf1
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0011cbf1
MOV RDI,qword ptr [RAX + 0x38]
TEST RDI,RDI
JZ 0x0011cbf1
CALL 0x0011d9f2
JMP 0x0011cc28
caseD_5:
TEST RDI,RDI
JZ 0x0011cc2b
MOV RAX,qword ptr [RDI + 0x480]
TEST RAX,RAX
JZ 0x0011cc2b
MOV RAX,qword ptr [RAX + 0x28]
TEST RAX,RAX
JZ 0x0011cc2b
MOV EAX,dword ptr [RAX + 0x10]
CMP EAX,0xfffffc19
JC 0x0011cc37
DEC EAX
IMUL RAX,RAX,0x10624dd3
SHR RAX,0x26
INC EAX
JMP 0x0011cc47
caseD_16:
LEA RAX,[0x14a8c0]
JMP 0x0011cc28
caseD_d:
TEST RDI,RDI
JZ 0x0011cc2d
MOV EAX,dword ptr [RDI + 0x378]
JMP 0x0011cbca
caseD_6:
TEST RDI,RDI
JZ 0x0011cc2b
MOV RAX,qword ptr [RDI + 0x480]
TEST RAX,RAX
JZ 0x0011cc2b
MOV RAX,qword ptr [RAX + 0x28]
TEST RAX,RAX
JZ 0x0011cc2b
MOV EAX,dword ptr [RAX + 0x10]
JMP 0x0011cbca
caseD_13:
TEST RDI,RDI
JZ 0x0011cc2d
CALL 0x0011c7ce
JMP 0x0011cbca
caseD_a:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RAX,qword ptr [RDI + 0x2b0]
JMP 0x0011cc28
caseD_8:
TEST RDI,RDI
JZ 0x0011cc2d
ADD RDI,0x97
JMP 0x0011cbaa
caseD_1e:
TEST RDI,RDI
JZ 0x0011cc2d
MOV EAX,dword ptr [RDI + 0x380]
JMP 0x0011cbca
caseD_20:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RAX,qword ptr [RDI + 0x4f0]
MOV RAX,qword ptr [RAX + 0x70]
JMP 0x0011cc28
caseD_17:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RCX,qword ptr [RDI]
TEST RCX,RCX
JZ 0x0011cc2d
MOV RDI,qword ptr [RCX + 0x38]
TEST RDI,RDI
JZ 0x0011cc2d
CALL 0x0011da10
JMP 0x0011cc28
caseD_14:
TEST RDI,RDI
JZ 0x0011cc2d
ADD RDI,0x297
LAB_0011cbaa:
MOV qword ptr [RBX],RDI
JMP 0x0011cc2b
caseD_18:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RCX,qword ptr [RDI]
TEST RCX,RCX
JZ 0x0011cc2d
MOV RDI,qword ptr [RCX + 0x38]
TEST RDI,RDI
JZ 0x0011cc2d
CALL 0x0011da06
LAB_0011cbca:
MOV dword ptr [RBX],EAX
JMP 0x0011cc2b
caseD_1c:
LEA RAX,[0x148a18]
JMP 0x0011cbde
caseD_1d:
LEA RAX,[0x148a30]
LAB_0011cbde:
MOV RAX,qword ptr [RAX]
JMP 0x0011cc28
caseD_1a:
TEST RDI,RDI
JZ 0x0011cc2d
MOV RAX,qword ptr [RDI + 0x2c8]
JMP 0x0011cc28
LAB_0011cbf1:
MOV qword ptr [RBX],0x0
JMP 0x0011cc2b
LAB_0011cbfa:
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RBP + -0x18],RCX
LAB_0011cc06:
MOV EDI,dword ptr [RAX]
CALL 0x0013013e
JMP 0x0011cc28
LAB_0011cc0f:
MOV RCX,qword ptr [RBP + -0x18]
LEA RDX,[RCX + 0x8]
MOV qword ptr [RBP + -0x18],RDX
LAB_0011cc1b:
MOV RDI,qword ptr [RCX]
TEST RDI,RDI
JZ 0x0011cc2d
CALL 0x001301c2
LAB_0011cc28:
MOV qword ptr [RBX],RAX
LAB_0011cc2b:
XOR EAX,EAX
default:
ADD RSP,0xc8
POP RBX
POP RBP
RET
LAB_0011cc37:
ADD EAX,0x3e7
IMUL RAX,RAX,0x10624dd3
SHR RAX,0x26
LAB_0011cc47:
MOV dword ptr [RBX],EAX
JMP 0x0011cc2b
|
/* WARNING: Removing unreachable block (ram,0x0011cbfa) */
/* WARNING: Removing unreachable block (ram,0x0011cc0f) */
/* WARNING: Heritage AFTER dead removal. Example location: s0xffffffffffffff40 : 0x0011cc06 */
/* WARNING: Restarted to delay deadcode elimination for space: stack */
int8
mariadb_get_infov(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
long *param_9,int4 param_10,uint *param_11,int8 param_12,
int8 param_13,int8 param_14)
{
int4 uVar1;
char in_AL;
char cVar2;
uint uVar3;
int8 uVar4;
int1 *puVar5;
long *plVar6;
char *pcVar7;
long lVar8;
int1 local_d8 [24];
long local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int8 local_28;
int1 *local_20;
int1 *local_18;
local_18 = local_d8;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
local_20 = &stack0x00000008;
local_28 = 0x3000000018;
uVar4 = 0x30000000ff;
local_b8 = param_13;
local_b0 = param_14;
switch(param_10) {
case 0:
local_28 = 0x3000000020;
uVar1 = (int4)local_c0;
local_c0 = param_12;
puVar5 = (int1 *)mysql_find_charset_nr(uVar1);
break;
case 1:
local_28 = 0x3000000020;
if (local_c0 == 0) {
return 0x30000000ff;
}
local_c0 = param_12;
puVar5 = (int1 *)mysql_find_charset_name();
break;
case 2:
puVar5 = (int1 *)&client_errors;
break;
case 3:
puVar5 = "10.6.10";
break;
case 4:
param_11[0] = 0x18902;
param_11[1] = 0;
goto LAB_0011cc2b;
case 5:
if (((param_9 != (long *)0x0) && (param_9[0x90] != 0)) &&
(lVar8 = *(long *)(param_9[0x90] + 0x28), lVar8 != 0)) {
uVar3 = *(uint *)(lVar8 + 0x10);
if (uVar3 < 0xfffffc19) {
uVar3 = (uVar3 + 999) / 1000;
}
else {
uVar3 = (uVar3 - 1) / 1000 + 1;
}
*param_11 = uVar3;
}
goto LAB_0011cc2b;
case 6:
if (((param_9 != (long *)0x0) && (param_9[0x90] != 0)) &&
(lVar8 = *(long *)(param_9[0x90] + 0x28), lVar8 != 0)) {
uVar3 = *(uint *)(lVar8 + 0x10);
goto LAB_0011cbca;
}
goto LAB_0011cc2b;
case 7:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
local_c0 = param_12;
mariadb_get_charset_info(param_9,param_11);
goto LAB_0011cc2b;
case 8:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
lVar8 = (long)param_9 + 0x97;
goto LAB_0011cbaa;
case 9:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
uVar3 = *(uint *)(param_9 + 0x12);
goto LAB_0011cbca;
case 10:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x56];
break;
case 0xb:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x5c];
break;
case 0xc:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
uVar3 = *(uint *)(param_9 + 0x6c);
goto LAB_0011cbca;
case 0xd:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
uVar3 = *(uint *)(param_9 + 0x6f);
goto LAB_0011cbca;
case 0xe:
case 0x19:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
if (*param_9 == 0) {
return 0x30000000ff;
}
uVar3 = *(uint *)(*param_9 + 0x20);
goto LAB_0011cbca;
case 0xf:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x5d];
break;
case 0x10:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
local_c0 = param_12;
cVar2 = mariadb_connection();
pcVar7 = "MariaDB";
if (cVar2 == '\0') {
pcVar7 = "MySQL";
}
*(char **)param_11 = pcVar7;
goto LAB_0011cc2b;
case 0x11:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x5a];
break;
case 0x12:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
local_c0 = param_12;
puVar5 = (int1 *)mariadb_server_version_id(param_9[0x5a]);
break;
case 0x13:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
local_c0 = param_12;
uVar3 = mariadb_get_socket();
goto LAB_0011cbca;
case 0x14:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
lVar8 = (long)param_9 + 0x297;
LAB_0011cbaa:
*(long *)param_11 = lVar8;
goto LAB_0011cc2b;
case 0x15:
if (((param_9 != (long *)0x0) && (*param_9 != 0)) && (*(long *)(*param_9 + 0x38) != 0)) {
local_c0 = param_12;
puVar5 = (int1 *)ma_pvio_tls_cipher();
break;
}
param_11[0] = 0;
param_11[1] = 0;
goto LAB_0011cc2b;
case 0x16:
puVar5 = tls_library_version;
break;
case 0x17:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
if (*param_9 == 0) {
return 0x30000000ff;
}
if (*(long *)(*param_9 + 0x38) == 0) {
return 0x30000000ff;
}
local_c0 = param_12;
puVar5 = (int1 *)ma_pvio_tls_get_protocol_version();
break;
case 0x18:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
if (*param_9 == 0) {
return 0x30000000ff;
}
if (*(long *)(*param_9 + 0x38) == 0) {
return 0x30000000ff;
}
local_c0 = param_12;
uVar3 = ma_pvio_tls_get_protocol_version_id();
goto LAB_0011cbca;
case 0x1a:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x59];
break;
case 0x1b:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x57];
break;
case 0x1c:
plVar6 = &max_allowed_packet;
goto LAB_0011cbde;
case 0x1d:
plVar6 = &net_buffer_length;
LAB_0011cbde:
puVar5 = (int1 *)*plVar6;
break;
case 0x1e:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
uVar3 = *(uint *)(param_9 + 0x70);
LAB_0011cbca:
*param_11 = uVar3;
goto LAB_0011cc2b;
case 0x1f:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x6e];
break;
case 0x20:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = *(int1 **)(param_9[0x9e] + 0x70);
break;
case 0x21:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x6d];
break;
case 0x22:
puVar5 = *(int1 **)(*param_9 + 0x60);
break;
case 0x23:
puVar5 = *(int1 **)(*param_9 + 0x68);
break;
default:
goto switchD_0011c8af_default;
}
*(int1 **)param_11 = puVar5;
LAB_0011cc2b:
uVar4 = 0;
switchD_0011c8af_default:
return uVar4;
}
| |
39,572 | js_class_has_bytecode | bluesky950520[P]quickjs/quickjs.c | static BOOL js_class_has_bytecode(JSClassID class_id)
{
return (class_id == JS_CLASS_BYTECODE_FUNCTION ||
class_id == JS_CLASS_GENERATOR_FUNCTION ||
class_id == JS_CLASS_ASYNC_FUNCTION ||
class_id == JS_CLASS_ASYNC_GENERATOR_FUNCTION);
} | O0 | c | js_class_has_bytecode:
movl %edi, -0x4(%rsp)
movb $0x1, %al
cmpl $0xd, -0x4(%rsp)
movb %al, -0x5(%rsp)
je 0x4a277
movb $0x1, %al
cmpl $0x10, -0x4(%rsp)
movb %al, -0x5(%rsp)
je 0x4a277
movb $0x1, %al
cmpl $0x34, -0x4(%rsp)
movb %al, -0x5(%rsp)
je 0x4a277
cmpl $0x38, -0x4(%rsp)
sete %al
movb %al, -0x5(%rsp)
movb -0x5(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
retq
nopw %cs:(%rax,%rax)
| js_class_has_bytecode:
mov [rsp+var_4], edi
mov al, 1
cmp [rsp+var_4], 0Dh
mov [rsp+var_5], al
jz short loc_4A277
mov al, 1
cmp [rsp+var_4], 10h
mov [rsp+var_5], al
jz short loc_4A277
mov al, 1
cmp [rsp+var_4], 34h ; '4'
mov [rsp+var_5], al
jz short loc_4A277
cmp [rsp+var_4], 38h ; '8'
setz al
mov [rsp+var_5], al
loc_4A277:
mov al, [rsp+var_5]
and al, 1
movzx eax, al
retn
| _BOOL8 js_class_has_bytecode(int a1)
{
bool v2; // [rsp+1h] [rbp-5h]
v2 = 1;
if ( a1 != 13 )
{
v2 = 1;
if ( a1 != 16 )
{
v2 = 1;
if ( a1 != 52 )
return a1 == 56;
}
}
return v2;
}
| js_class_has_bytecode:
MOV dword ptr [RSP + -0x4],EDI
MOV AL,0x1
CMP dword ptr [RSP + -0x4],0xd
MOV byte ptr [RSP + -0x5],AL
JZ 0x0014a277
MOV AL,0x1
CMP dword ptr [RSP + -0x4],0x10
MOV byte ptr [RSP + -0x5],AL
JZ 0x0014a277
MOV AL,0x1
CMP dword ptr [RSP + -0x4],0x34
MOV byte ptr [RSP + -0x5],AL
JZ 0x0014a277
CMP dword ptr [RSP + -0x4],0x38
SETZ AL
MOV byte ptr [RSP + -0x5],AL
LAB_0014a277:
MOV AL,byte ptr [RSP + -0x5]
AND AL,0x1
MOVZX EAX,AL
RET
|
bool js_class_has_bytecode(int param_1)
{
int1 local_5;
local_5 = true;
if (((param_1 != 0xd) && (local_5 = true, param_1 != 0x10)) && (local_5 = true, param_1 != 0x34))
{
local_5 = param_1 == 0x38;
}
return local_5;
}
| |
39,573 | skip | eloqsql/libmariadb/unittest/mytap/tap.c | void
skip(int how_many, char const *const fmt, ...)
{
char reason[80];
if (fmt && *fmt)
{
va_list ap;
va_start(ap, fmt);
vsnprintf(reason, sizeof(reason), fmt, ap);
va_end(ap);
}
else
reason[0] = '\0';
while (how_many-- > 0)
{
va_list ap;
memset((char*) &ap, 0, sizeof(ap)); /* Keep compiler happy */
vemit_tap(1, NULL, ap);
emit_dir("skip", reason);
emit_endl();
}
} | O3 | c | skip:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %edi, %ebx
movq %rdx, -0x140(%rbp)
movq %rcx, -0x138(%rbp)
movq %r8, -0x130(%rbp)
movq %r9, -0x128(%rbp)
testb %al, %al
je 0x1826c
movaps %xmm0, -0x120(%rbp)
movaps %xmm1, -0x110(%rbp)
movaps %xmm2, -0x100(%rbp)
movaps %xmm3, -0xf0(%rbp)
movaps %xmm4, -0xe0(%rbp)
movaps %xmm5, -0xd0(%rbp)
movaps %xmm6, -0xc0(%rbp)
movaps %xmm7, -0xb0(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
testq %rsi, %rsi
je 0x182ca
movq %rsi, %r10
cmpb $0x0, (%rsi)
je 0x182ca
leaq -0x150(%rbp), %rax
leaq -0xa0(%rbp), %r9
movq %rax, 0x10(%r9)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r9)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%r9)
leaq -0x80(%rbp), %rdi
movl $0x50, %esi
movl $0x50, %ecx
movl $0x1, %edx
movq %r10, %r8
callq 0x13380
jmp 0x182ce
movb $0x0, -0x80(%rbp)
testl %ebx, %ebx
jle 0x1835a
incl %ebx
movq 0x33cd1(%rip), %r13 # 0x4bfb0
leaq 0x1f4ae(%rip), %r15 # 0x37794
leaq -0x80(%rbp), %r14
leaq 0x1f4a2(%rip), %r12 # 0x37793
movq (%r13), %rdi
movl 0x35e1c(%rip), %r8d # 0x4e118
incl %r8d
movl %r8d, 0x35e12(%rip) # 0x4e118
movl $0x1, %esi
leaq 0x20d4b(%rip), %rdx # 0x3905d
movq %r15, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x13740
movq (%r13), %rdi
movl $0x1, %esi
leaq 0x20d41(%rip), %rdx # 0x39070
leaq 0x20cd7(%rip), %rcx # 0x3900d
movq %r14, %r8
xorl %eax, %eax
callq 0x13740
movq (%r13), %rdi
movl $0x1, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x13740
decl %ebx
cmpl $0x1, %ebx
ja 0x182f1
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x1837b
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| skip:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 128h
mov ebx, edi
mov [rbp+var_140], rdx
mov [rbp+var_138], rcx
mov [rbp+var_130], r8
mov [rbp+var_128], r9
test al, al
jz short loc_1826C
movaps [rbp+var_120], xmm0
movaps [rbp+var_110], xmm1
movaps [rbp+var_100], xmm2
movaps [rbp+var_F0], xmm3
movaps [rbp+var_E0], xmm4
movaps [rbp+var_D0], xmm5
movaps [rbp+var_C0], xmm6
movaps [rbp+var_B0], xmm7
loc_1826C:
mov rax, fs:28h
mov [rbp+var_30], rax
test rsi, rsi
jz short loc_182CA
mov r10, rsi
cmp byte ptr [rsi], 0
jz short loc_182CA
lea rax, [rbp+var_150]
lea r9, [rbp+var_A0]
mov [r9+10h], rax
lea rax, [rbp+arg_0]
mov [r9+8], rax
mov rax, 3000000010h
mov [r9], rax
lea rdi, [rbp+var_80]
mov esi, 50h ; 'P'
mov ecx, 50h ; 'P'
mov edx, 1
mov r8, r10
call ___vsnprintf_chk
jmp short loc_182CE
loc_182CA:
mov [rbp+var_80], 0
loc_182CE:
test ebx, ebx
jle loc_1835A
inc ebx
mov r13, cs:stdout_ptr
lea r15, aExecuteTestWit+29h; ""
lea r14, [rbp+var_80]
lea r12, aExecuteTestWit+28h; "\n"
loc_182F1:
mov rdi, [r13+0]
mov r8d, cs:dword_4E118
inc r8d
mov cs:dword_4E118, r8d
mov esi, 1
lea rdx, aSokDS; "%sok %d%s"
mov rcx, r15
mov r9, r15
xor eax, eax
call ___fprintf_chk
mov rdi, [r13+0]
mov esi, 1
lea rdx, aSS_1; " # %s %s"
lea rcx, aSkip; "skip"
mov r8, r14
xor eax, eax
call ___fprintf_chk
mov rdi, [r13+0]
mov esi, 1
mov rdx, r12
xor eax, eax
call ___fprintf_chk
dec ebx
cmp ebx, 1
ja short loc_182F1
loc_1835A:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_1837B
add rsp, 128h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1837B:
call ___stack_chk_fail
| unsigned long long skip(int a1, _BYTE *a2, ...)
{
unsigned int v2; // ebx
va_list va; // [rsp+B0h] [rbp-A0h] BYREF
char v5[80]; // [rsp+D0h] [rbp-80h] BYREF
unsigned long long v6; // [rsp+120h] [rbp-30h]
v6 = __readfsqword(0x28u);
if ( a2 && *a2 )
{
va_start(va, a2);
__vsnprintf_chk(v5, 80LL, 1LL, 80LL, a2, va);
}
else
{
v5[0] = 0;
}
if ( a1 > 0 )
{
v2 = a1 + 1;
do
{
__fprintf_chk(stdout, 1LL, "%sok %d%s", "", ++dword_4E118, "");
__fprintf_chk(stdout, 1LL, " # %s %s", "skip", v5);
__fprintf_chk(stdout, 1LL, "\n");
--v2;
}
while ( v2 > 1 );
}
return __readfsqword(0x28u);
}
| skip:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x128
MOV EBX,EDI
MOV qword ptr [RBP + -0x140],RDX
MOV qword ptr [RBP + -0x138],RCX
MOV qword ptr [RBP + -0x130],R8
MOV qword ptr [RBP + -0x128],R9
TEST AL,AL
JZ 0x0011826c
MOVAPS xmmword ptr [RBP + -0x120],XMM0
MOVAPS xmmword ptr [RBP + -0x110],XMM1
MOVAPS xmmword ptr [RBP + -0x100],XMM2
MOVAPS xmmword ptr [RBP + -0xf0],XMM3
MOVAPS xmmword ptr [RBP + -0xe0],XMM4
MOVAPS xmmword ptr [RBP + -0xd0],XMM5
MOVAPS xmmword ptr [RBP + -0xc0],XMM6
MOVAPS xmmword ptr [RBP + -0xb0],XMM7
LAB_0011826c:
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
TEST RSI,RSI
JZ 0x001182ca
MOV R10,RSI
CMP byte ptr [RSI],0x0
JZ 0x001182ca
LEA RAX,[RBP + -0x150]
LEA R9,[RBP + -0xa0]
MOV qword ptr [R9 + 0x10],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [R9 + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [R9],RAX
LEA RDI,[RBP + -0x80]
MOV ESI,0x50
MOV ECX,0x50
MOV EDX,0x1
MOV R8,R10
CALL 0x00113380
JMP 0x001182ce
LAB_001182ca:
MOV byte ptr [RBP + -0x80],0x0
LAB_001182ce:
TEST EBX,EBX
JLE 0x0011835a
INC EBX
MOV R13,qword ptr [0x0014bfb0]
LEA R15,[0x137794]
LEA R14,[RBP + -0x80]
LEA R12,[0x137793]
LAB_001182f1:
MOV RDI,qword ptr [R13]
MOV R8D,dword ptr [0x0014e118]
INC R8D
MOV dword ptr [0x0014e118],R8D
MOV ESI,0x1
LEA RDX,[0x13905d]
MOV RCX,R15
MOV R9,R15
XOR EAX,EAX
CALL 0x00113740
MOV RDI,qword ptr [R13]
MOV ESI,0x1
LEA RDX,[0x139070]
LEA RCX,[0x13900d]
MOV R8,R14
XOR EAX,EAX
CALL 0x00113740
MOV RDI,qword ptr [R13]
MOV ESI,0x1
MOV RDX,R12
XOR EAX,EAX
CALL 0x00113740
DEC EBX
CMP EBX,0x1
JA 0x001182f1
LAB_0011835a:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0011837b
ADD RSP,0x128
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011837b:
CALL 0x00113500
|
void skip(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,int param_9,
char *param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
int *puVar1;
char in_AL;
uint uVar2;
long in_FS_OFFSET;
int1 local_158 [16];
int8 local_148;
int8 local_140;
int8 local_138;
int8 local_130;
int8 local_128;
int8 local_118;
int8 local_108;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int1 *local_a0;
int1 *local_98;
int1 local_88 [80];
long local_38;
if (in_AL != '\0') {
local_128 = param_1;
local_118 = param_2;
local_108 = param_3;
local_f8 = param_4;
local_e8 = param_5;
local_d8 = param_6;
local_c8 = param_7;
local_b8 = param_8;
}
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_148 = param_11;
local_140 = param_12;
local_138 = param_13;
local_130 = param_14;
if ((param_10 == (char *)0x0) || (*param_10 == '\0')) {
local_88[0] = 0;
}
else {
local_98 = local_158;
local_a0 = &stack0x00000008;
local_a8 = 0x3000000010;
__vsnprintf_chk(local_88,0x50,1,0x50,param_10);
}
puVar1 = PTR_stdout_0014bfb0;
if (0 < param_9) {
uVar2 = param_9 + 1;
do {
DAT_0014e118 = DAT_0014e118 + 1;
__fprintf_chk(*(int8 *)puVar1,1,"%sok %d%s","",DAT_0014e118,"");
__fprintf_chk(*(int8 *)puVar1,1," # %s %s",&DAT_0013900d,local_88);
__fprintf_chk(*(int8 *)puVar1,1,"\n");
uVar2 = uVar2 - 1;
} while (1 < uVar2);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
39,574 | my_snprintf_utf32 | eloqsql/strings/ctype-ucs2.c | static size_t
my_snprintf_utf32(CHARSET_INFO *cs __attribute__((unused)),
char* to, size_t n, const char* fmt, ...)
{
size_t ret;
va_list args;
va_start(args,fmt);
ret= my_vsnprintf_utf32(to, n, fmt, args);
va_end(args);
return ret;
} | O0 | c | my_snprintf_utf32:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x5b7eb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x30, -0x3c(%rbp)
movl $0x20, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x5f8e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
| my_snprintf_utf32:
push rbp
mov rbp, rsp
sub rsp, 0F0h
test al, al
jz short loc_5B7EB
movaps [rbp+var_C0], xmm0
movaps [rbp+var_B0], xmm1
movaps [rbp+var_A0], xmm2
movaps [rbp+var_90], xmm3
movaps [rbp+var_80], xmm4
movaps [rbp+var_70], xmm5
movaps [rbp+var_60], xmm6
movaps [rbp+var_50], xmm7
loc_5B7EB:
mov [rbp+var_C8], r9
mov [rbp+var_D0], r8
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
lea rax, [rbp+var_F0]
mov [rbp+var_30], rax
lea rax, [rbp+arg_0]
mov [rbp+var_38], rax
mov [rbp+var_3C], 30h ; '0'
mov [rbp+var_40], 20h ; ' '
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
lea rcx, [rbp+var_40]
call my_vsnprintf_utf32
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rsp, 0F0h
pop rbp
retn
| long long my_snprintf_utf32(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char v16; // [rsp+0h] [rbp-F0h] BYREF
long long v17; // [rsp+20h] [rbp-D0h]
long long v18; // [rsp+28h] [rbp-C8h]
__m128 v19; // [rsp+30h] [rbp-C0h]
__m128 v20; // [rsp+40h] [rbp-B0h]
__m128 v21; // [rsp+50h] [rbp-A0h]
__m128 v22; // [rsp+60h] [rbp-90h]
__m128 v23; // [rsp+70h] [rbp-80h]
__m128 v24; // [rsp+80h] [rbp-70h]
__m128 v25; // [rsp+90h] [rbp-60h]
__m128 v26; // [rsp+A0h] [rbp-50h]
_DWORD v27[2]; // [rsp+B0h] [rbp-40h] BYREF
char *v28; // [rsp+B8h] [rbp-38h]
char *v29; // [rsp+C0h] [rbp-30h]
long long v30; // [rsp+D0h] [rbp-20h]
long long v31; // [rsp+D8h] [rbp-18h]
long long v32; // [rsp+E0h] [rbp-10h]
long long v33; // [rsp+E8h] [rbp-8h]
v19 = a7;
v20 = a8;
v21 = a9;
v22 = a10;
v23 = a11;
v24 = a12;
v25 = a13;
v26 = a14;
v18 = a6;
v17 = a5;
v33 = a1;
v32 = a2;
v31 = a3;
v30 = a4;
v29 = &v16;
v28 = &a15;
v27[1] = 48;
v27[0] = 32;
return my_vsnprintf_utf32(a2, a3, a4, v27);
}
| my_snprintf_utf32:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xf0
TEST AL,AL
JZ 0x0015b7eb
MOVAPS xmmword ptr [RBP + -0xc0],XMM0
MOVAPS xmmword ptr [RBP + -0xb0],XMM1
MOVAPS xmmword ptr [RBP + -0xa0],XMM2
MOVAPS xmmword ptr [RBP + -0x90],XMM3
MOVAPS xmmword ptr [RBP + -0x80],XMM4
MOVAPS xmmword ptr [RBP + -0x70],XMM5
MOVAPS xmmword ptr [RBP + -0x60],XMM6
MOVAPS xmmword ptr [RBP + -0x50],XMM7
LAB_0015b7eb:
MOV qword ptr [RBP + -0xc8],R9
MOV qword ptr [RBP + -0xd0],R8
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
LEA RAX,[RBP + -0xf0]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x3c],0x30
MOV dword ptr [RBP + -0x40],0x20
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
LEA RCX,[RBP + -0x40]
CALL 0x0015f8e0
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0xf0
POP RBP
RET
|
int8
my_snprintf_utf32(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
int8 uVar1;
int1 local_f8 [32];
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int4 local_48;
int4 local_44;
int1 *local_40;
int1 *local_38;
int8 local_28;
int8 local_20;
int8 local_18;
int8 local_10;
if (in_AL != '\0') {
local_c8 = param_1;
local_b8 = param_2;
local_a8 = param_3;
local_98 = param_4;
local_88 = param_5;
local_78 = param_6;
local_68 = param_7;
local_58 = param_8;
}
local_38 = local_f8;
local_40 = &stack0x00000008;
local_44 = 0x30;
local_48 = 0x20;
local_d8 = param_13;
local_d0 = param_14;
local_28 = param_12;
local_20 = param_11;
local_18 = param_10;
local_10 = param_9;
uVar1 = my_vsnprintf_utf32(param_10,param_11,param_12,&local_48);
return uVar1;
}
| |
39,575 | JS_NewAtomInt64 | bluesky950520[P]quickjs/quickjs.c | static JSAtom JS_NewAtomInt64(JSContext *ctx, int64_t n)
{
if ((uint64_t)n <= JS_ATOM_MAX_INT) {
return __JS_AtomFromUInt32((uint32_t)n);
} else {
char buf[24];
size_t len = i64toa(buf, n);
JSValue val = js_new_string8_len(ctx, buf, len);
if (JS_IsException(val))
return JS_ATOM_NULL;
return __JS_NewAtom(ctx->rt, JS_VALUE_GET_STRING(val),
JS_ATOM_TYPE_STRING);
}
} | O0 | c | JS_NewAtomInt64:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
cmpq $0x7fffffff, 0x40(%rsp) # imm = 0x7FFFFFFF
ja 0x30b3b
movq 0x40(%rsp), %rax
movl %eax, %edi
callq 0x272f0
movl %eax, 0x54(%rsp)
jmp 0x30ba9
leaq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1e850
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
movl %eax, %edx
callq 0x27300
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x30b8d
movl $0x0, 0x54(%rsp)
jmp 0x30ba9
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x27390
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_NewAtomInt64:
sub rsp, 58h
mov [rsp+58h+var_10], rdi
mov [rsp+58h+var_18], rsi
cmp [rsp+58h+var_18], 7FFFFFFFh
ja short loc_30B3B
mov rax, [rsp+58h+var_18]
mov edi, eax
call __JS_AtomFromUInt32
mov [rsp+58h+var_4], eax
jmp short loc_30BA9
loc_30B3B:
lea rdi, [rsp+58h+var_38]
mov rsi, [rsp+58h+var_18]
call i64toa
mov [rsp+58h+var_40], rax
mov rdi, [rsp+58h+var_10]
lea rsi, [rsp+58h+var_38]
mov rax, [rsp+58h+var_40]
mov edx, eax
call js_new_string8_len
mov [rsp+58h+var_50], rax
mov [rsp+58h+var_48], rdx
mov rdi, [rsp+58h+var_50]
mov rsi, [rsp+58h+var_48]
call JS_IsException_1
cmp eax, 0
jz short loc_30B8D
mov [rsp+58h+var_4], 0
jmp short loc_30BA9
loc_30B8D:
mov rax, [rsp+58h+var_10]
mov rdi, [rax+18h]
mov rsi, [rsp+58h+var_50]
mov edx, 1
call __JS_NewAtom
mov [rsp+58h+var_4], eax
loc_30BA9:
mov eax, [rsp+58h+var_4]
add rsp, 58h
retn
| long long JS_NewAtomInt64(long long a1, unsigned long long a2)
{
int v2; // edx
long long v4; // [rsp+8h] [rbp-50h]
unsigned int v5; // [rsp+18h] [rbp-40h]
unsigned long long v6[4]; // [rsp+20h] [rbp-38h] BYREF
unsigned long long v7; // [rsp+40h] [rbp-18h]
long long v8; // [rsp+48h] [rbp-10h]
v8 = a1;
v7 = a2;
if ( a2 > 0x7FFFFFFF )
{
v5 = i64toa(v6, v7);
v4 = js_new_string8_len(v8, (long long)v6, v5);
if ( JS_IsException_1(v4, v2) )
return 0;
else
return (unsigned int)_JS_NewAtom(*(_QWORD *)(v8 + 24), v4, 1);
}
else
{
return (unsigned int)_JS_AtomFromUInt32(v7);
}
}
| JS_NewAtomInt64:
SUB RSP,0x58
MOV qword ptr [RSP + 0x48],RDI
MOV qword ptr [RSP + 0x40],RSI
CMP qword ptr [RSP + 0x40],0x7fffffff
JA 0x00130b3b
MOV RAX,qword ptr [RSP + 0x40]
MOV EDI,EAX
CALL 0x001272f0
MOV dword ptr [RSP + 0x54],EAX
JMP 0x00130ba9
LAB_00130b3b:
LEA RDI,[RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x40]
CALL 0x0011e850
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x18]
MOV EDX,EAX
CALL 0x00127300
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x00130b8d
MOV dword ptr [RSP + 0x54],0x0
JMP 0x00130ba9
LAB_00130b8d:
MOV RAX,qword ptr [RSP + 0x48]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
MOV EDX,0x1
CALL 0x00127390
MOV dword ptr [RSP + 0x54],EAX
LAB_00130ba9:
MOV EAX,dword ptr [RSP + 0x54]
ADD RSP,0x58
RET
|
int4 JS_NewAtomInt64(long param_1,ulong param_2)
{
int4 uVar1;
int iVar2;
int1 auVar3 [16];
int1 local_38 [32];
ulong local_18;
long local_10;
int4 local_4;
local_18 = param_2;
local_10 = param_1;
if (param_2 < 0x80000000) {
local_4 = __JS_AtomFromUInt32(param_2 & 0xffffffff);
}
else {
uVar1 = i64toa(local_38,param_2);
auVar3 = js_new_string8_len(local_10,local_38,uVar1);
iVar2 = JS_IsException(auVar3._0_8_,auVar3._8_8_);
if (iVar2 == 0) {
local_4 = __JS_NewAtom(*(int8 *)(local_10 + 0x18),auVar3._0_8_,1);
}
else {
local_4 = 0;
}
}
return local_4;
}
| |
39,576 | JS_NewAtomInt64 | bluesky950520[P]quickjs/quickjs.c | static JSAtom JS_NewAtomInt64(JSContext *ctx, int64_t n)
{
if ((uint64_t)n <= JS_ATOM_MAX_INT) {
return __JS_AtomFromUInt32((uint32_t)n);
} else {
char buf[24];
size_t len = i64toa(buf, n);
JSValue val = js_new_string8_len(ctx, buf, len);
if (JS_IsException(val))
return JS_ATOM_NULL;
return __JS_NewAtom(ctx->rt, JS_VALUE_GET_STRING(val),
JS_ATOM_TYPE_STRING);
}
} | O1 | c | JS_NewAtomInt64:
cmpq $0x7fffffff, %rsi # imm = 0x7FFFFFFF
ja 0x23687
orl $0x80000000, %esi # imm = 0x80000000
jmp 0x236d3
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1b1f4
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x1f5c9
movq %rax, 0x8(%rsp)
xorl %esi, %esi
cmpl $0x6, %edx
je 0x236cc
movq 0x18(%rbx), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x1f629
movl %eax, %esi
addq $0x28, %rsp
popq %rbx
popq %r14
movl %esi, %eax
retq
| JS_NewAtomInt64:
cmp rsi, 7FFFFFFFh
ja short loc_23687
or esi, 80000000h
jmp short loc_236D3
loc_23687:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
lea r14, [rsp+38h+var_28]
mov rdi, r14
call i64toa
mov rdi, rbx
mov rsi, r14
mov edx, eax
call js_new_string8_len
mov [rsp+38h+var_30], rax
xor esi, esi
cmp edx, 6
jz short loc_236CC
mov rdi, [rbx+18h]
mov rsi, [rsp+38h+var_30]
mov edx, 1
call __JS_NewAtom
mov esi, eax
loc_236CC:
add rsp, 28h
pop rbx
pop r14
loc_236D3:
mov eax, esi
retn
| long long JS_NewAtomInt64(long long a1, unsigned long long a2)
{
unsigned int v2; // esi
unsigned int v3; // eax
int v4; // edx
long long v6; // [rsp+0h] [rbp-30h]
_QWORD v7[5]; // [rsp+8h] [rbp-28h] BYREF
if ( a2 > 0x7FFFFFFF )
{
v3 = i64toa(v7, a2);
v6 = js_new_string8_len(a1, (long long)v7, v3);
v2 = 0;
if ( v4 != 6 )
return (unsigned int)_JS_NewAtom(*(_QWORD *)(a1 + 24), v6, 1LL);
}
else
{
return (unsigned int)a2 | 0x80000000;
}
return v2;
}
| JS_NewAtomInt64:
CMP RSI,0x7fffffff
JA 0x00123687
OR ESI,0x80000000
JMP 0x001236d3
LAB_00123687:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RSP + 0x10]
MOV RDI,R14
CALL 0x0011b1f4
MOV RDI,RBX
MOV RSI,R14
MOV EDX,EAX
CALL 0x0011f5c9
MOV qword ptr [RSP + 0x8],RAX
XOR ESI,ESI
CMP EDX,0x6
JZ 0x001236cc
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
MOV EDX,0x1
CALL 0x0011f629
MOV ESI,EAX
LAB_001236cc:
ADD RSP,0x28
POP RBX
POP R14
LAB_001236d3:
MOV EAX,ESI
RET
|
uint JS_NewAtomInt64(long param_1,ulong param_2)
{
int4 uVar1;
uint uVar2;
int1 auVar3 [12];
int1 local_28 [24];
if (param_2 < 0x80000000) {
uVar2 = (uint)param_2 | 0x80000000;
}
else {
uVar1 = i64toa(local_28);
auVar3 = js_new_string8_len(param_1,local_28,uVar1);
uVar2 = 0;
if (auVar3._8_4_ != 6) {
uVar2 = __JS_NewAtom(*(int8 *)(param_1 + 0x18),auVar3._0_8_,1);
}
}
return uVar2;
}
| |
39,577 | 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>::parse<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)>, bool, bool) | llama.cpp/common/json.hpp | JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json parse(InputType&& i,
const parser_callback_t cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false)
{
basic_json result;
parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
return result;
} | 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>::parse<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)>, bool, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x1, %esi
callq 0x84776
movq %rbx, %rdi
movl $0x1, %esi
callq 0x84776
movq (%r12), %r15
movq 0x8(%r12), %r12
movq %rsp, %rdi
movq %r13, %rsi
callq 0x84118
addq %r15, %r12
movzbl %r14b, %r8d
movzbl %bpl, %r9d
leaq 0x20(%rsp), %rdi
movq %rsp, %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x8406c
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x84176
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x849be
movq -0x18(%r14), %rax
testq %rax, %rax
je 0xb61b1
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb61c8
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb620c
jmp 0xb620c
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x84748
jmp 0xb61f3
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb6217
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xb6217
movq %rax, %rdi
callq 0x27f2f
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x84776
movq %rbx, %rdi
callq 0x88e90
movq %r14, %rdi
callq 0x21af0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5parseIS9_EESD_OT_St8functionIFbiNS0_6detail13parse_event_tERSD_EEbb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov ebp, r8d
mov r14d, ecx
mov r13, rdx
mov r12, rsi
mov rbx, rdi
mov byte ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
mov 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 r15, [r12]
mov r12, [r12+8]
mov rdi, rsp
mov rsi, r13
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEC2ERKSJ_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::function(std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)> const&)
add r12, r15
movzx r8d, r14b
movzx r9d, bpl
lea rdi, [rsp+118h+var_F8]
mov rcx, rsp
mov rsi, r15
mov rdx, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6parserINS0_6detail22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcS9_EEEEEENSF_6parserISD_T_EESO_St8functionIFbiNSF_13parse_event_tERSD_EEbb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)>,bool,bool)
lea rdi, [rsp+118h+var_F8]; int
mov esi, 1
mov rdx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5parseEbRSF_; nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::parse(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>&)
lea r14, [rsp+118h+var_D0]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~lexer()
mov rax, [r14-18h]
test rax, rax
jz short loc_B61B1
lea rdi, [rsp+118h+var_F8]
mov rsi, rdi
mov edx, 3
call rax
loc_B61B1:
mov rax, [rsp+118h+var_108]
test rax, rax
jz short loc_B61C8
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_B61C8:
mov rax, rbx
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_B620C
jmp short loc_B620C
mov r14, rax
lea rdi, [rsp+118h+var_F8]
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~parser()
jmp short loc_B61F3
mov r14, rax
loc_B61F3:
mov rax, [rsp+118h+var_108]
test rax, rax
jz short loc_B6217
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_B6217
loc_B620C:
mov rdi, rax
call __clang_call_terminate
mov r14, rax
loc_B6217:
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov 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>::parse<std::string>(
long long a1,
long long *a2,
long long a3,
unsigned __int8 a4,
unsigned __int8 a5)
{
long long v8; // r15
long long v9; // r12
__int128 v11; // [rsp+0h] [rbp-118h] BYREF
void ( *v12)(__int128 *, __int128 *, long long); // [rsp+10h] [rbp-108h]
int v13[4]; // [rsp+20h] [rbp-F8h] BYREF
void ( *v14)(int *, int *, long long); // [rsp+30h] [rbp-E8h]
_QWORD v15[26]; // [rsp+48h] [rbp-D0h] BYREF
*(_BYTE *)a1 = 0;
*(_QWORD *)(a1 + 8) = 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);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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);
v8 = *a2;
v9 = a2[1];
std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::function(
&v11,
a3);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>(
(long long)v13,
v8,
v8 + v9,
&v11,
a4,
a5);
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::parse(
(long long)v13,
1,
(_BYTE *)a1);
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~lexer(v15);
if ( v14 )
v14(v13, v13, 3LL);
if ( v12 )
v12(&v11, &v11, 3LL);
return a1;
}
| parse<std::__cxx11::string>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV EBP,R8D
MOV R14D,ECX
MOV R13,RDX
MOV R12,RSI
MOV RBX,RDI
MOV byte ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV ESI,0x1
CALL 0x00184776
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00184776
MOV R15,qword ptr [R12]
MOV R12,qword ptr [R12 + 0x8]
LAB_001b6151:
MOV RDI,RSP
MOV RSI,R13
CALL 0x00184118
ADD R12,R15
LAB_001b615f:
MOVZX R8D,R14B
MOVZX R9D,BPL
LEA RDI,[RSP + 0x20]
MOV RCX,RSP
MOV RSI,R15
MOV RDX,R12
CALL 0x0018406c
LAB_001b617a:
LEA RDI,[RSP + 0x20]
MOV ESI,0x1
MOV RDX,RBX
CALL 0x00184176
LEA R14,[RSP + 0x48]
MOV RDI,R14
CALL 0x001849be
MOV RAX,qword ptr [R14 + -0x18]
TEST RAX,RAX
JZ 0x001b61b1
LAB_001b61a2:
LEA RDI,[RSP + 0x20]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001b61b1:
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x001b61c8
LAB_001b61bb:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001b61c8:
MOV RAX,RBX
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::parse<std::__cxx11::string >(std::__cxx11::string&&, std::function<bool (int,
nlohmann::json_abi_v3_11_3::detail::parse_event_t,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&)>, bool, bool) */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>
::parse<std::__cxx11::string>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,long *param_1,function *param_3,int1 param_4,int1 param_5)
{
long lVar1;
long lVar2;
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
afStack_118 [16];
code *local_108;
parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
local_f8 [16];
code *local_e8;
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>>>
local_d0 [160];
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0;
*(int8 *)(this + 8) = 0;
assert_invariant(SUB81(this,0));
assert_invariant(SUB81(this,0));
lVar1 = *param_1;
lVar2 = param_1[1];
/* try { // try from 001b6151 to 001b615b has its CatchHandler @ 001b6214 */
std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::function(afStack_118,param_3);
/* try { // try from 001b615f to 001b6179 has its CatchHandler @ 001b61f0 */
parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
(local_f8,lVar1,lVar2 + lVar1,afStack_118,param_4,param_5);
/* try { // try from 001b617a to 001b618b has its CatchHandler @ 001b61e1 */
detail::
parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::parse(local_f8,true,(basic_json *)this);
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>>>
::~lexer(local_d0);
if (local_e8 != (code *)0x0) {
/* try { // try from 001b61a2 to 001b61b0 has its CatchHandler @ 001b61df */
(*local_e8)(local_f8,local_f8,3);
}
if (local_108 != (code *)0x0) {
/* try { // try from 001b61bb to 001b61c7 has its CatchHandler @ 001b61dd */
(*local_108)(afStack_118,afStack_118,3);
}
return this;
}
| |
39,578 | my_ftell | eloqsql/mysys/my_fstream.c | my_off_t my_ftell(FILE *stream, myf MyFlags __attribute__((unused)))
{
long long pos;
DBUG_ENTER("my_ftell");
DBUG_PRINT("my",("stream:%p MyFlags: %lu", stream, MyFlags));
pos=IF_WIN(_ftelli64(stream),ftell(stream));
DBUG_PRINT("exit",("ftell: %lld",pos));
DBUG_RETURN((my_off_t) pos);
} | O3 | c | my_ftell:
pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0x2bbb0
nop
| my_ftell:
push rbp
mov rbp, rsp
pop rbp
jmp _ftello64
| long long my_ftell(long long a1)
{
return ftello64(a1);
}
| my_ftell:
PUSH RBP
MOV RBP,RSP
POP RBP
JMP 0x0012bbb0
|
void my_ftell(FILE *param_1)
{
ftello64(param_1);
return;
}
| |
39,579 | diff | eloqsql/strings/dtoa.c | static Bigint *diff(Bigint *a, Bigint *b, Stack_alloc *alloc)
{
Bigint *c;
int i, wa, wb;
ULong *xa, *xae, *xb, *xbe, *xc;
ULLong borrow, y;
i= cmp(a,b);
if (!i)
{
c= Balloc(0, alloc);
c->wds= 1;
c->p.x[0]= 0;
return c;
}
if (i < 0)
{
c= a;
a= b;
b= c;
i= 1;
}
else
i= 0;
c= Balloc(a->k, alloc);
c->sign= i;
wa= a->wds;
xa= a->p.x;
xae= xa + wa;
wb= b->wds;
xb= b->p.x;
xbe= xb + wb;
xc= c->p.x;
borrow= 0;
do
{
y= (ULLong)*xa++ - *xb++ - borrow;
borrow= y >> 32 & (ULong)1;
*xc++= (ULong) (y & FFFFFFFF);
}
while (xb < xbe);
while (xa < xae)
{
y= *xa++ - borrow;
borrow= y >> 32 & (ULong)1;
*xc++= (ULong) (y & FFFFFFFF);
}
while (!*--xc)
wa--;
c->wds= wa;
return c;
} | O3 | c | diff:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x14(%rdi), %eax
movslq 0x14(%rsi), %rdi
subl %edi, %eax
jne 0xd4f5b
movq (%rbx), %rax
leaq (%rax,%rdi,4), %rcx
movq (%rsi), %r8
leaq (%r8,%rdi,4), %rdi
addq $-0x4, %rdi
movl -0x4(%rcx), %r8d
movl (%rdi), %r9d
cmpl %r9d, %r8d
jne 0xd4f51
addq $-0x4, %rcx
addq $-0x4, %rdi
cmpq %rax, %rcx
ja 0xd4f19
xorl %edi, %edi
movq %rdx, %rsi
callq 0xd49d8
movl $0x1, 0x14(%rax)
movq (%rax), %rcx
movl $0x0, (%rcx)
jmp 0xd4ff7
xorl %eax, %eax
cmpl %r9d, %r8d
sbbl %eax, %eax
orl $0x1, %eax
movl %eax, %r14d
shrl $0x1f, %r14d
testl %eax, %eax
movq %rsi, %r15
cmovsq %rbx, %r15
cmovsq %rsi, %rbx
movl 0x8(%rbx), %edi
movq %rdx, %rsi
callq 0xd49d8
movl %r14d, 0x10(%rax)
movslq 0x14(%rbx), %rcx
movq (%rbx), %r8
movslq 0x14(%r15), %rdx
movq (%r15), %r9
leaq (%r9,%rdx,4), %r10
movq (%rax), %rdx
xorl %edi, %edi
movq %r8, %rsi
movl (%r9), %r11d
addq %rdi, %r11
movl (%rsi), %edi
addq $0x4, %rsi
addq $0x4, %r9
subq %r11, %rdi
movl %edi, (%rdx)
shrq $0x20, %rdi
andl $0x1, %edi
addq $0x4, %rdx
cmpq %r10, %r9
jb 0xd4f98
leaq (%r8,%rcx,4), %r8
cmpq %r8, %rsi
jae 0xd4fe3
movl (%rsi), %r9d
addq $0x4, %rsi
subq %rdi, %r9
movq %r9, %rdi
shrq $0x20, %rdi
andl $0x1, %edi
movl %r9d, (%rdx)
addq $0x4, %rdx
jmp 0xd4fc1
incl %ecx
addq $-0x4, %rdx
decl %ecx
cmpl $0x0, (%rdx)
leaq -0x4(%rdx), %rdx
je 0xd4fe9
movl %ecx, 0x14(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| diff:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov eax, [rdi+14h]
movsxd rdi, dword ptr [rsi+14h]
sub eax, edi
jnz short loc_D4F5B
mov rax, [rbx]
lea rcx, [rax+rdi*4]
mov r8, [rsi]
lea rdi, [r8+rdi*4]
add rdi, 0FFFFFFFFFFFFFFFCh
loc_D4F19:
mov r8d, [rcx-4]
mov r9d, [rdi]
cmp r8d, r9d
jnz short loc_D4F51
add rcx, 0FFFFFFFFFFFFFFFCh
add rdi, 0FFFFFFFFFFFFFFFCh
cmp rcx, rax
ja short loc_D4F19
xor edi, edi
mov rsi, rdx
call Balloc
mov dword ptr [rax+14h], 1
mov rcx, [rax]
mov dword ptr [rcx], 0
jmp loc_D4FF7
loc_D4F51:
xor eax, eax
cmp r8d, r9d
sbb eax, eax
or eax, 1
loc_D4F5B:
mov r14d, eax
shr r14d, 1Fh
test eax, eax
mov r15, rsi
cmovs r15, rbx
cmovs rbx, rsi
mov edi, [rbx+8]
mov rsi, rdx
call Balloc
mov [rax+10h], r14d
movsxd rcx, dword ptr [rbx+14h]
mov r8, [rbx]
movsxd rdx, dword ptr [r15+14h]
mov r9, [r15]
lea r10, [r9+rdx*4]
mov rdx, [rax]
xor edi, edi
mov rsi, r8
loc_D4F98:
mov r11d, [r9]
add r11, rdi
mov edi, [rsi]
add rsi, 4
add r9, 4
sub rdi, r11
mov [rdx], edi
shr rdi, 20h
and edi, 1
add rdx, 4
cmp r9, r10
jb short loc_D4F98
lea r8, [r8+rcx*4]
loc_D4FC1:
cmp rsi, r8
jnb short loc_D4FE3
mov r9d, [rsi]
add rsi, 4
sub r9, rdi
mov rdi, r9
shr rdi, 20h
and edi, 1
mov [rdx], r9d
add rdx, 4
jmp short loc_D4FC1
loc_D4FE3:
inc ecx
add rdx, 0FFFFFFFFFFFFFFFCh
loc_D4FE9:
dec ecx
cmp dword ptr [rdx], 0
lea rdx, [rdx-4]
jz short loc_D4FE9
mov [rax+14h], ecx
loc_D4FF7:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long diff(unsigned int **a1, unsigned int **a2, long long a3)
{
unsigned int **v3; // rbx
int v4; // eax
long long v5; // rdi
int v6; // eax
unsigned long long v7; // rcx
unsigned int *i; // rdi
unsigned int v9; // r8d
long long result; // rax
unsigned int v11; // r14d
unsigned int **v12; // r15
long long v13; // rcx
unsigned int *v14; // r8
unsigned int *v15; // r9
unsigned long long v16; // r10
_DWORD *v17; // rdx
long long v18; // rdi
unsigned int *v19; // rsi
long long v20; // r11
long long v21; // rdi
long long v22; // rdi
unsigned long long v23; // r8
long long v24; // r9
long long v25; // r9
int v26; // ecx
_DWORD *v27; // rdx
v3 = a1;
v4 = *((_DWORD *)a1 + 5);
v5 = *((int *)a2 + 5);
v6 = v4 - v5;
if ( !v6 )
{
v7 = (unsigned long long)&(*v3)[v5];
for ( i = &(*a2)[v5 - 1]; ; --i )
{
v9 = *(_DWORD *)(v7 - 4);
if ( v9 != *i )
break;
v7 -= 4LL;
if ( v7 <= (unsigned long long)*v3 )
{
result = Balloc(0, a3);
*(_DWORD *)(result + 20) = 1;
**(_DWORD **)result = 0;
return result;
}
}
v6 = v9 < *i ? -1 : 1;
}
v11 = (unsigned int)v6 >> 31;
v12 = a2;
if ( v6 < 0 )
{
v12 = v3;
v3 = a2;
}
result = Balloc(*((_DWORD *)v3 + 2), a3);
*(_DWORD *)(result + 16) = v11;
v13 = *((int *)v3 + 5);
v14 = *v3;
v15 = *v12;
v16 = (unsigned long long)&(*v12)[*((int *)v12 + 5)];
v17 = *(_DWORD **)result;
v18 = 0LL;
v19 = *v3;
do
{
v20 = v18 + *v15;
v21 = *v19++;
++v15;
v22 = v21 - v20;
*v17 = v22;
v18 = BYTE4(v22) & 1;
++v17;
}
while ( (unsigned long long)v15 < v16 );
v23 = (unsigned long long)&v14[v13];
while ( (unsigned long long)v19 < v23 )
{
v24 = *v19++;
v25 = v24 - v18;
v18 = BYTE4(v25) & 1;
*v17++ = v25;
}
v26 = v13 + 1;
v27 = v17 - 1;
do
--v26;
while ( *v27-- == 0 );
*(_DWORD *)(result + 20) = v26;
return result;
}
| diff:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0x14]
MOVSXD RDI,dword ptr [RSI + 0x14]
SUB EAX,EDI
JNZ 0x001d4f5b
MOV RAX,qword ptr [RBX]
LEA RCX,[RAX + RDI*0x4]
MOV R8,qword ptr [RSI]
LEA RDI,[R8 + RDI*0x4]
ADD RDI,-0x4
LAB_001d4f19:
MOV R8D,dword ptr [RCX + -0x4]
MOV R9D,dword ptr [RDI]
CMP R8D,R9D
JNZ 0x001d4f51
ADD RCX,-0x4
ADD RDI,-0x4
CMP RCX,RAX
JA 0x001d4f19
XOR EDI,EDI
MOV RSI,RDX
CALL 0x001d49d8
MOV dword ptr [RAX + 0x14],0x1
MOV RCX,qword ptr [RAX]
MOV dword ptr [RCX],0x0
JMP 0x001d4ff7
LAB_001d4f51:
XOR EAX,EAX
CMP R8D,R9D
SBB EAX,EAX
OR EAX,0x1
LAB_001d4f5b:
MOV R14D,EAX
SHR R14D,0x1f
TEST EAX,EAX
MOV R15,RSI
CMOVS R15,RBX
CMOVS RBX,RSI
MOV EDI,dword ptr [RBX + 0x8]
MOV RSI,RDX
CALL 0x001d49d8
MOV dword ptr [RAX + 0x10],R14D
MOVSXD RCX,dword ptr [RBX + 0x14]
MOV R8,qword ptr [RBX]
MOVSXD RDX,dword ptr [R15 + 0x14]
MOV R9,qword ptr [R15]
LEA R10,[R9 + RDX*0x4]
MOV RDX,qword ptr [RAX]
XOR EDI,EDI
MOV RSI,R8
LAB_001d4f98:
MOV R11D,dword ptr [R9]
ADD R11,RDI
MOV EDI,dword ptr [RSI]
ADD RSI,0x4
ADD R9,0x4
SUB RDI,R11
MOV dword ptr [RDX],EDI
SHR RDI,0x20
AND EDI,0x1
ADD RDX,0x4
CMP R9,R10
JC 0x001d4f98
LEA R8,[R8 + RCX*0x4]
LAB_001d4fc1:
CMP RSI,R8
JNC 0x001d4fe3
MOV R9D,dword ptr [RSI]
ADD RSI,0x4
SUB R9,RDI
MOV RDI,R9
SHR RDI,0x20
AND EDI,0x1
MOV dword ptr [RDX],R9D
ADD RDX,0x4
JMP 0x001d4fc1
LAB_001d4fe3:
INC ECX
ADD RDX,-0x4
LAB_001d4fe9:
DEC ECX
CMP dword ptr [RDX],0x0
LEA RDX,[RDX + -0x4]
JZ 0x001d4fe9
MOV dword ptr [RAX + 0x14],ECX
LAB_001d4ff7:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void diff(ulong *param_1,ulong *param_2,int8 param_3)
{
uint uVar1;
uint *puVar2;
uint uVar3;
int8 *puVar4;
int iVar5;
ulong uVar6;
int *piVar7;
ulong *puVar8;
uint *puVar9;
uint *puVar10;
long lVar11;
uint *puVar12;
iVar5 = *(int *)((long)param_2 + 0x14);
uVar3 = *(int *)((long)param_1 + 0x14) - iVar5;
if (uVar3 == 0) {
uVar6 = *param_1 + (long)iVar5 * 4;
puVar10 = (uint *)(*param_2 + (long)iVar5 * 4);
do {
puVar10 = puVar10 + -1;
if (*(uint *)(uVar6 - 4) != *puVar10) {
uVar3 = -(uint)(*(uint *)(uVar6 - 4) < *puVar10) | 1;
goto LAB_001d4f5b;
}
uVar6 = uVar6 - 4;
} while (*param_1 < uVar6);
puVar4 = (int8 *)Balloc(0,param_3);
*(int4 *)((long)puVar4 + 0x14) = 1;
*(int4 *)*puVar4 = 0;
}
else {
LAB_001d4f5b:
puVar8 = param_1;
if ((int)uVar3 < 0) {
puVar8 = param_2;
param_2 = param_1;
}
puVar4 = (int8 *)Balloc((int)puVar8[1],param_3);
*(uint *)(puVar4 + 2) = uVar3 >> 0x1f;
iVar5 = *(int *)((long)puVar8 + 0x14);
puVar2 = (uint *)*puVar8;
puVar12 = (uint *)*param_2;
puVar10 = puVar12 + *(int *)((long)param_2 + 0x14);
piVar7 = (int *)*puVar4;
uVar6 = 0;
puVar9 = puVar2;
do {
uVar3 = *puVar12;
uVar1 = *puVar9;
puVar9 = puVar9 + 1;
puVar12 = puVar12 + 1;
lVar11 = (ulong)uVar1 - (uVar3 + uVar6);
*piVar7 = (int)lVar11;
uVar6 = (ulong)((uint)((ulong)lVar11 >> 0x20) & 1);
piVar7 = piVar7 + 1;
} while (puVar12 < puVar10);
for (; puVar9 < puVar2 + iVar5; puVar9 = puVar9 + 1) {
lVar11 = *puVar9 - uVar6;
uVar6 = (ulong)((uint)((ulong)lVar11 >> 0x20) & 1);
*piVar7 = (int)lVar11;
piVar7 = piVar7 + 1;
}
iVar5 = iVar5 + 1;
do {
piVar7 = piVar7 + -1;
iVar5 = iVar5 + -1;
} while (*piVar7 == 0);
*(int *)((long)puVar4 + 0x14) = iVar5;
}
return;
}
| |
39,580 | minja::Parser::consumeTokenGroups(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling) | monkey531[P]llama/common/./minja.hpp | std::vector<std::string> consumeTokenGroups(const std::regex & regex, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
std::smatch match;
if (std::regex_search(it, end, match, regex) && match.position() == 0) {
it += match[0].length();
std::vector<std::string> ret;
for (size_t i = 0, n = match.size(); i < n; ++i) {
ret.push_back(match[i].str());
}
return ret;
}
it = start;
return {};
} | O2 | cpp | minja::Parser::consumeTokenGroups(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %r12
movq %rsi, %rdi
movl %ecx, %esi
callq 0x398f8
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x52e61
testb %al, %al
je 0x2f02c
movq %rsp, %rdi
xorl %esi, %esi
callq 0x30320
testq %rax, %rax
je 0x2f055
movq %r12, 0x20(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rsp, %rdi
callq 0x53390
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rax, %rdx
subq %rcx, %rdx
leaq -0x48(%rax), %rsi
cmpq $0x48, %rdx
movq %rcx, %rdx
cmoveq %rsi, %rdx
cmpq %rcx, %rax
cmoveq %rsi, %rdx
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
xorl %r14d, %r14d
cmpb $0x0, 0x10(%rdx)
cmoveq %r14, %rsi
addq %rsi, 0x20(%r15)
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
pushq $0x18
popq %r12
subq %rcx, %rax
je 0x2f0b0
cqto
idivq %r12
movq %rax, %r14
addq $-0x3, %r14
xorl %r13d, %r13d
leaq 0x28(%rsp), %r15
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x2f03b
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
subq %rsi, %rcx
je 0x2f0e7
movq %rcx, %rax
cqto
idivq %r12
addq $-0x3, %rax
cmpq %rbp, %rax
jbe 0x2f0e7
addq %r13, %rsi
jmp 0x2f0ee
addq %rcx, %rsi
addq $-0x48, %rsi
movq %r15, %rdi
callq 0x39966
movq %rbx, %rdi
movq %r15, %rsi
callq 0x399a0
movq %r15, %rdi
callq 0x20d78
incq %rbp
addq $0x18, %r13
jmp 0x2f0ba
movq %rax, %r14
jmp 0x2f131
movq %rax, %r14
jmp 0x2f129
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x20d78
movq %rbx, %rdi
callq 0x2f142
movq %rsp, %rdi
callq 0x53390
movq %r14, %rdi
callq 0x20b90
nop
| _ZN5minja6Parser18consumeTokenGroupsERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov r12, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
xorps xmm0, xmm0
mov rdx, rsp
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
mov rsi, [r15+18h]
mov rdi, [r15+20h]
mov rcx, r14
xor r8d, r8d
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEELNS_20_RegexExecutorPolicyE0ELb0EEEbT_SI_RNS5_13match_resultsISI_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type)
test al, al
jz short loc_2F02C
mov rdi, rsp
xor esi, esi
call _ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE8positionEm; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::position(ulong)
test rax, rax
jz short loc_2F055
loc_2F02C:
mov [r15+20h], r12
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
and qword ptr [rbx+10h], 0
loc_2F03B:
mov rdi, rsp
call _ZNSt12_Vector_baseINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::_Vector_base<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~_Vector_base()
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2F055:
mov rcx, [rsp+78h+var_78]
mov rax, [rsp+78h+var_70]
mov rdx, rax
sub rdx, rcx
lea rsi, [rax-48h]
cmp rdx, 48h ; 'H'
mov rdx, rcx
cmovz rdx, rsi
cmp rax, rcx
cmovz rdx, rsi
mov rsi, [rdx+8]
sub rsi, [rdx]
xor r14d, r14d
cmp byte ptr [rdx+10h], 0
cmovz rsi, r14
add [r15+20h], rsi
and qword ptr [rbx+10h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
push 18h
pop r12
sub rax, rcx
jz short loc_2F0B0
cqo
idiv r12
mov r14, rax
add r14, 0FFFFFFFFFFFFFFFDh
loc_2F0B0:
xor r13d, r13d
lea r15, [rsp+78h+var_50]
xor ebp, ebp
loc_2F0BA:
cmp r14, rbp
jz loc_2F03B
mov rsi, [rsp+78h+var_78]
mov rcx, [rsp+78h+var_70]
sub rcx, rsi
jz short loc_2F0E7
mov rax, rcx
cqo
idiv r12
add rax, 0FFFFFFFFFFFFFFFDh
cmp rax, rbp
jbe short loc_2F0E7
add rsi, r13
jmp short loc_2F0EE
loc_2F0E7:
add rsi, rcx
add rsi, 0FFFFFFFFFFFFFFB8h
loc_2F0EE:
mov rdi, r15
call _ZNKSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEE3strEv; std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>::str(void)
mov rdi, rbx
mov rsi, r15
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, r15; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
inc rbp
add r13, 18h
jmp short loc_2F0BA
mov r14, rax
jmp short loc_2F131
mov r14, rax
jmp short loc_2F129
mov r14, rax
lea rdi, [rsp+arg_20]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_2F129:
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_2F131:
mov rdi, rsp
call _ZNSt12_Vector_baseINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::_Vector_base<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~_Vector_base()
mov rdi, r14
call __Unwind_Resume
| long long minja::Parser::consumeTokenGroups(long long a1, long long a2, int a3, unsigned int a4)
{
long long v6; // r12
int v7; // r9d
__int128 v9; // kr00_16
long long v10; // rdx
long long v11; // rsi
long long v12; // r14
long long v13; // rax
long long v14; // r13
unsigned long long i; // rbp
long long v16; // rcx
long long v17; // rsi
_OWORD v18[2]; // [rsp+0h] [rbp-78h] BYREF
_BYTE v19[80]; // [rsp+28h] [rbp-50h] BYREF
v6 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
memset(v18, 0, sizeof(v18));
if ( (unsigned __int8)std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(
*(_QWORD *)(a2 + 32),
*(_QWORD *)(a2 + 24),
(unsigned int)v18,
a3,
0,
v7,
0)
&& !std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::position(v18, 0LL) )
{
v9 = v18[0];
v10 = *(_QWORD *)&v18[0];
if ( *((_QWORD *)&v18[0] + 1) - *(_QWORD *)&v18[0] == 72LL )
v10 = *((_QWORD *)&v18[0] + 1) - 72LL;
if ( *((_QWORD *)&v18[0] + 1) == *(_QWORD *)&v18[0] )
v10 = *((_QWORD *)&v18[0] + 1) - 72LL;
v11 = *(_QWORD *)(v10 + 8) - *(_QWORD *)v10;
v12 = 0LL;
if ( !*(_BYTE *)(v10 + 16) )
v11 = 0LL;
*(_QWORD *)(a2 + 32) += v11;
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v13 = *((_QWORD *)&v9 + 1) - v9;
if ( *((_QWORD *)&v9 + 1) != (_QWORD)v9 )
{
v10 = v13 % 24;
v12 = v13 / 24 - 3;
}
v14 = 0LL;
for ( i = 0LL; v12 != i; ++i )
{
v16 = *((_QWORD *)&v18[0] + 1) - *(_QWORD *)&v18[0];
if ( *((_QWORD *)&v18[0] + 1) == *(_QWORD *)&v18[0] || (v10 = v16 % 24, v16 / 24 - 3 <= i) )
v17 = *((_QWORD *)&v18[0] + 1) - 72LL;
else
v17 = v14 + *(_QWORD *)&v18[0];
std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>::str(v19, v17, v10);
std::vector<std::string>::emplace_back<std::string>(a1, v19);
std::string::~string(v19);
v14 += 24LL;
}
}
else
{
*(_QWORD *)(a2 + 32) = v6;
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
}
std::_Vector_base<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~_Vector_base(v18);
return a1;
}
| consumeTokenGroups:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV R12,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x001398f8
XORPS XMM0,XMM0
MOV RDX,RSP
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
MOV RSI,qword ptr [R15 + 0x18]
MOV RDI,qword ptr [R15 + 0x20]
LAB_0012f00e:
MOV RCX,R14
XOR R8D,R8D
CALL 0x00152e61
TEST AL,AL
JZ 0x0012f02c
MOV RDI,RSP
XOR ESI,ESI
CALL 0x00130320
TEST RAX,RAX
JZ 0x0012f055
LAB_0012f02c:
MOV qword ptr [R15 + 0x20],R12
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
AND qword ptr [RBX + 0x10],0x0
LAB_0012f03b:
MOV RDI,RSP
CALL 0x00153390
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012f055:
MOV RCX,qword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x8]
MOV RDX,RAX
SUB RDX,RCX
LEA RSI,[RAX + -0x48]
CMP RDX,0x48
MOV RDX,RCX
CMOVZ RDX,RSI
CMP RAX,RCX
CMOVZ RDX,RSI
MOV RSI,qword ptr [RDX + 0x8]
SUB RSI,qword ptr [RDX]
XOR R14D,R14D
CMP byte ptr [RDX + 0x10],0x0
CMOVZ RSI,R14
ADD qword ptr [R15 + 0x20],RSI
AND qword ptr [RBX + 0x10],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
PUSH 0x18
POP R12
SUB RAX,RCX
JZ 0x0012f0b0
CQO
IDIV R12
MOV R14,RAX
ADD R14,-0x3
LAB_0012f0b0:
XOR R13D,R13D
LEA R15,[RSP + 0x28]
XOR EBP,EBP
LAB_0012f0ba:
CMP R14,RBP
JZ 0x0012f03b
MOV RSI,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
SUB RCX,RSI
JZ 0x0012f0e7
MOV RAX,RCX
CQO
IDIV R12
ADD RAX,-0x3
CMP RAX,RBP
JBE 0x0012f0e7
ADD RSI,R13
JMP 0x0012f0ee
LAB_0012f0e7:
ADD RSI,RCX
ADD RSI,-0x48
LAB_0012f0ee:
MOV RDI,R15
CALL 0x00139966
LAB_0012f0f6:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001399a0
LAB_0012f101:
MOV RDI,R15
CALL 0x00120d78
INC RBP
ADD R13,0x18
JMP 0x0012f0ba
|
/* minja::Parser::consumeTokenGroups(std::__cxx11::basic_regex<char,
std::__cxx11::regex_traits<char> > const&, minja::SpaceHandling) */
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *
minja::Parser::consumeTokenGroups
(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *param_1,
Parser *param_2,int8 param_3,int4 param_4)
{
int8 uVar1;
bool bVar2;
long lVar3;
long *plVar4;
long lVar5;
long *local_78;
long *plStack_70;
int8 local_68;
int8 uStack_60;
string local_50 [32];
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
local_68 = 0;
uStack_60 = 0;
local_78 = (long *)0x0;
plStack_70 = (long *)0x0;
/* try { // try from 0012f00e to 0012f026 has its CatchHandler @ 0012f112 */
bVar2 = std::__detail::
__regex_algo_impl<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>,char,std::__cxx11::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>
(*(int8 *)(param_2 + 0x20),*(int8 *)(param_2 + 0x18),&local_78,
param_3,0);
if ((bVar2) &&
(lVar3 = std::__cxx11::
match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
::position((match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
*)&local_78,0), lVar3 == 0)) {
plVar4 = local_78;
if ((long)plStack_70 - (long)local_78 == 0x48) {
plVar4 = plStack_70 + -9;
}
if (plStack_70 == local_78) {
plVar4 = plStack_70 + -9;
}
lVar5 = 0;
lVar3 = plVar4[1] - *plVar4;
if ((char)plVar4[2] == '\0') {
lVar3 = lVar5;
}
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + lVar3;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
if ((long)plStack_70 - (long)local_78 != 0) {
lVar5 = ((long)plStack_70 - (long)local_78) / 0x18 + -3;
}
for (lVar3 = 0; lVar5 != lVar3; lVar3 = lVar3 + 1) {
/* try { // try from 0012f0ee to 0012f0f5 has its CatchHandler @ 0012f117 */
std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>::str()
;
/* try { // try from 0012f0f6 to 0012f100 has its CatchHandler @ 0012f11c */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>(param_1,local_50);
std::__cxx11::string::~string(local_50);
}
}
else {
*(int8 *)(param_2 + 0x20) = uVar1;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
}
std::
_Vector_base<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
::~_Vector_base((_Vector_base<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
*)&local_78);
return param_1;
}
| |
39,581 | cpu_get_num_physical_cores() | monkey531[P]llama/common/common.cpp | std::string string_from(bool value) {
return value ? "true" : "false";
} | O2 | cpp | cpu_get_num_physical_cores():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
leaq 0x58(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
xorl %esi, %esi
leaq 0x60(%rsp), %r14
leaq 0x80(%rsp), %r12
leaq 0x8(%rsp), %rbp
leaq 0xa0(%rsp), %rbx
pushq $0x8
popq %r15
xorl %r13d, %r13d
incl %r13d
je 0x52eb3
movq %r14, %rdi
callq 0x5845a
movq %r12, %rdi
leaq 0x5ecce(%rip), %rsi # 0xb1ad0
movq %r14, %rdx
callq 0x58436
movq %rbp, %rdi
movq %r12, %rsi
leaq 0x5ecd5(%rip), %rdx # 0xb1aec
callq 0x380bc
movq %rbx, %rdi
movq %rbp, %rsi
movl %r15d, %edx
callq 0x23e10
movq %rbp, %rdi
callq 0x241b8
movq %r12, %rdi
callq 0x241b8
movq %r14, %rdi
callq 0x241b8
leaq 0x118(%rsp), %rdi
callq 0x231d0
testb %al, %al
je 0x52ea6
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x23140
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x52e8e
leaq 0x28(%rsp), %rdi
movq %rbp, %rsi
callq 0x88bfe
movq %rbp, %rdi
callq 0x241b8
movq %rbx, %rdi
callq 0x23210
movl %r13d, %esi
jmp 0x52de7
leaq 0xa0(%rsp), %rdi
callq 0x23210
movq 0x40(%rsp), %rbx
testq %rbx, %rbx
jne 0x52ed4
callq 0x23be0
cmpl $0x5, %eax
setae %cl
movl %eax, %edx
shrl %cl, %edx
testl %eax, %eax
pushq $0x4
popq %rbx
cmovnel %edx, %ebx
leaq 0x28(%rsp), %rdi
callq 0x5c364
movl %ebx, %eax
addq $0x2a8, %rsp # imm = 0x2A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x52f41
movq %rax, %rbx
jmp 0x52f0e
movq %rax, %rbx
jmp 0x52f1b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x241b8
leaq 0x80(%rsp), %rdi
callq 0x241b8
leaq 0x60(%rsp), %rdi
callq 0x241b8
jmp 0x52f41
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x241b8
leaq 0xa0(%rsp), %rdi
callq 0x23210
leaq 0x28(%rsp), %rdi
callq 0x5c364
movq %rbx, %rdi
callq 0x23f80
| _Z26cpu_get_num_physical_coresv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2A8h
lea rax, [rsp+2D8h+var_280]
mov [rax-30h], rax
mov qword ptr [rax-28h], 1
xorps xmm0, xmm0
movups xmmword ptr [rax-20h], xmm0
mov dword ptr [rax-10h], 3F800000h
movups xmmword ptr [rax-8], xmm0
xor esi, esi; unsigned int
lea r14, [rsp+2D8h+var_278]
lea r12, [rsp+2D8h+var_258]
lea rbp, [rsp+2D8h+var_2D0]
lea rbx, [rsp+2D8h+var_238]
push 8
pop r15
xor r13d, r13d
loc_52DE7:
inc r13d
jz loc_52EB3
mov rdi, r14; this
call _ZNSt7__cxx119to_stringEj; std::to_string(uint)
mov rdi, r12
lea rsi, aSysDevicesSyst; "/sys/devices/system/cpu/cpu"
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov rdi, rbp
mov rsi, r12
lea rdx, aTopologyThread; "/topology/thread_siblings"
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov rdi, rbx
mov rsi, rbp
mov edx, r15d
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEEC1ERKNSt7__cxx1112basic_stringIcS1_SaIcEEESt13_Ios_Openmode; std::ifstream::basic_ifstream(std::string const&,std::_Ios_Openmode)
mov rdi, rbp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+2D8h+var_1C0]
call __ZNKSt12__basic_fileIcE7is_openEv; std::__basic_file<char>::is_open(void)
test al, al
jz short loc_52EA6
lea rax, [rsp+2D8h+var_2C0]
mov [rsp+2D8h+var_2D0], rax
and [rsp+2D8h+var_2C8], 0
mov [rsp+2D8h+var_2C0], 0
mov rdi, rbx
mov rsi, rbp
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &)
mov rcx, [rax]
mov rcx, [rcx-18h]
test byte ptr [rax+rcx+20h], 5
jnz short loc_52E8E
lea rdi, [rsp+2D8h+var_2B0]
mov rsi, rbp
call _ZNSt8__detail12_Insert_baseINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_SaIS6_ENS_9_IdentityESt8equal_toIS6_ESt4hashIS6_ENS_18_Mod_range_hashingENS_20_Default_ranged_hashENS_20_Prime_rehash_policyENS_17_Hashtable_traitsILb1ELb1ELb1EEEE6insertERKS6_; std::__detail::_Insert_base<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::insert(std::string const&)
loc_52E8E:
mov rdi, rbp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
mov esi, r13d
jmp loc_52DE7
loc_52EA6:
lea rdi, [rsp+2D8h+var_238]; this
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
loc_52EB3:
mov rbx, [rsp+2D8h+var_298]
test rbx, rbx
jnz short loc_52ED4
call __ZNSt6thread20hardware_concurrencyEv; std::thread::hardware_concurrency(void)
cmp eax, 5
setnb cl
mov edx, eax
shr edx, cl
test eax, eax
push 4
pop rbx
cmovnz ebx, edx
loc_52ED4:
lea rdi, [rsp+2D8h+var_2B0]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEED2Ev; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable()
mov eax, ebx
add rsp, 2A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
jmp short loc_52F41
mov rbx, rax
jmp short loc_52F0E
mov rbx, rax
jmp short loc_52F1B
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_52F0E:
lea rdi, [rsp+arg_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_52F1B:
lea rdi, [rsp+arg_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_52F41
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+arg_98]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
loc_52F41:
lea rdi, [rsp+arg_20]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEED2Ev; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable()
mov rdi, rbx
call __Unwind_Resume
| long long cpu_get_num_physical_cores(std::thread *a1)
{
unsigned long long v1; // rsi
unsigned int i; // r13d
_QWORD *v3; // rax
unsigned int v4; // ebx
unsigned int v5; // eax
_QWORD v7[2]; // [rsp+8h] [rbp-2D0h] BYREF
char v8; // [rsp+18h] [rbp-2C0h] BYREF
_QWORD v9[2]; // [rsp+28h] [rbp-2B0h] BYREF
__int128 v10; // [rsp+38h] [rbp-2A0h]
int v11; // [rsp+48h] [rbp-290h]
__int128 v12; // [rsp+50h] [rbp-288h] BYREF
_BYTE v13[32]; // [rsp+60h] [rbp-278h] BYREF
_BYTE v14[32]; // [rsp+80h] [rbp-258h] BYREF
_BYTE v15[120]; // [rsp+A0h] [rbp-238h] BYREF
_BYTE v16[448]; // [rsp+118h] [rbp-1C0h] BYREF
v9[0] = (char *)&v12 + 8;
v9[1] = 1LL;
v10 = 0LL;
v11 = 1065353216;
v12 = 0LL;
v1 = 0LL;
for ( i = 0; ++i; v1 = i )
{
std::to_string((std::__cxx11 *)v13, v1);
std::operator+<char>(v14, "/sys/devices/system/cpu/cpu", v13);
std::operator+<char>((long long)v7, (long long)v14, (long long)"/topology/thread_siblings");
v1 = (unsigned long long)v7;
std::ifstream::basic_ifstream(v15, v7, 8LL);
std::string::~string(v7);
std::string::~string(v14);
std::string::~string(v13);
if ( !(unsigned __int8)std::__basic_file<char>::is_open(v16) )
{
a1 = (std::thread *)v15;
std::ifstream::~ifstream(v15);
break;
}
v7[0] = &v8;
v7[1] = 0LL;
v8 = 0;
v3 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(v15, v7);
if ( (*((_BYTE *)v3 + *(_QWORD *)(*v3 - 24LL) + 32) & 5) == 0 )
std::__detail::_Insert_base<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::insert(
v9,
v7);
std::string::~string(v7);
a1 = (std::thread *)v15;
std::ifstream::~ifstream(v15);
}
v4 = DWORD2(v10);
if ( !*((_QWORD *)&v10 + 1) )
{
v5 = std::thread::hardware_concurrency(a1);
v4 = 4;
if ( v5 )
v4 = v5 >> (v5 >= 5);
}
std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable(
v9,
v1);
return v4;
}
| cpu_get_num_physical_cores:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x2a8
LEA RAX,[RSP + 0x58]
MOV qword ptr [RAX + -0x30],RAX
MOV qword ptr [RAX + -0x28],0x1
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + -0x20],XMM0
MOV dword ptr [RAX + -0x10],0x3f800000
MOVUPS xmmword ptr [RAX + -0x8],XMM0
XOR ESI,ESI
LEA R14,[RSP + 0x60]
LEA R12,[RSP + 0x80]
LEA RBP,[RSP + 0x8]
LEA RBX,[RSP + 0xa0]
PUSH 0x8
POP R15
XOR R13D,R13D
LAB_00152de7:
INC R13D
JZ 0x00152eb3
LAB_00152df0:
MOV RDI,R14
CALL 0x0015845a
LAB_00152df8:
MOV RDI,R12
LEA RSI,[0x1b1ad0]
MOV RDX,R14
CALL 0x00158436
LAB_00152e0a:
MOV RDI,RBP
MOV RSI,R12
LEA RDX,[0x1b1aec]
CALL 0x001380bc
LAB_00152e1c:
MOV RDI,RBX
MOV RSI,RBP
MOV EDX,R15D
CALL 0x00123e10
MOV RDI,RBP
CALL 0x001241b8
MOV RDI,R12
CALL 0x001241b8
MOV RDI,R14
CALL 0x001241b8
LEA RDI,[RSP + 0x118]
CALL 0x001231d0
TEST AL,AL
JZ 0x00152ea6
LEA RAX,[RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
AND qword ptr [RSP + 0x10],0x0
MOV byte ptr [RSP + 0x18],0x0
LAB_00152e68:
MOV RDI,RBX
MOV RSI,RBP
CALL 0x00123140
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
TEST byte ptr [RAX + RCX*0x1 + 0x20],0x5
JNZ 0x00152e8e
LEA RDI,[RSP + 0x28]
MOV RSI,RBP
CALL 0x00188bfe
LAB_00152e8e:
MOV RDI,RBP
CALL 0x001241b8
MOV RDI,RBX
CALL 0x00123210
MOV ESI,R13D
JMP 0x00152de7
LAB_00152ea6:
LEA RDI,[RSP + 0xa0]
CALL 0x00123210
LAB_00152eb3:
MOV RBX,qword ptr [RSP + 0x40]
TEST RBX,RBX
JNZ 0x00152ed4
CALL 0x00123be0
CMP EAX,0x5
SETNC CL
MOV EDX,EAX
SHR EDX,CL
TEST EAX,EAX
PUSH 0x4
POP RBX
CMOVNZ EBX,EDX
LAB_00152ed4:
LEA RDI,[RSP + 0x28]
CALL 0x0015c364
MOV EAX,EBX
ADD RSP,0x2a8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* cpu_get_num_physical_cores() */
ulong cpu_get_num_physical_cores(void)
{
char cVar1;
uint uVar2;
istream *piVar3;
ulong uVar4;
int1 *local_2d0;
int8 local_2c8;
int1 local_2c0 [16];
int8 *local_2b0;
int8 local_2a8;
int8 local_2a0;
ulong uStack_298;
int4 local_290;
int8 local_288;
int8 uStack_280;
__cxx11 local_278 [32];
string local_258 [32];
istream local_238 [520];
local_2b0 = &uStack_280;
local_2a8 = 1;
local_2a0 = 0;
uStack_298 = 0;
local_290 = 0x3f800000;
local_288 = 0;
uStack_280 = 0;
uVar2 = 0;
do {
if (uVar2 + 1 == 0) {
LAB_00152eb3:
uVar4 = uStack_298;
if (uStack_298 == 0) {
uVar2 = std::thread::hardware_concurrency();
uVar4 = 4;
if (uVar2 != 0) {
uVar4 = (ulong)(uVar2 >> (4 < uVar2));
}
}
std::
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
::~_Hashtable((_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
*)&local_2b0);
return uVar4 & 0xffffffff;
}
/* try { // try from 00152df0 to 00152df7 has its CatchHandler @ 00152ef2 */
std::__cxx11::to_string(local_278,uVar2);
/* try { // try from 00152df8 to 00152e09 has its CatchHandler @ 00152efc */
std::operator+((char *)local_258,(string *)"/sys/devices/system/cpu/cpu");
/* try { // try from 00152e0a to 00152e1b has its CatchHandler @ 00152ef7 */
std::operator+((string *)&local_2d0,(char *)local_258);
/* try { // try from 00152e1c to 00152e29 has its CatchHandler @ 00152f01 */
std::ifstream::ifstream((ifstream *)local_238,(string *)&local_2d0,8);
std::__cxx11::string::~string((string *)&local_2d0);
std::__cxx11::string::~string(local_258);
std::__cxx11::string::~string((string *)local_278);
cVar1 = std::__basic_file<char>::is_open();
if (cVar1 == '\0') {
std::ifstream::~ifstream((ifstream *)local_238);
goto LAB_00152eb3;
}
local_2d0 = local_2c0;
local_2c8 = 0;
local_2c0[0] = 0;
/* try { // try from 00152e68 to 00152e8d has its CatchHandler @ 00152f27 */
piVar3 = std::getline<char,std::char_traits<char>,std::allocator<char>>
(local_238,(string *)&local_2d0);
if (((byte)piVar3[*(long *)(*(long *)piVar3 + -0x18) + 0x20] & 5) == 0) {
std::__detail::
_Insert_base<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
::insert((string *)&local_2b0);
}
std::__cxx11::string::~string((string *)&local_2d0);
std::ifstream::~ifstream((ifstream *)local_238);
uVar2 = uVar2 + 1;
} while( true );
}
| |
39,582 | testing::internal::SharedPayload<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::Destroy(testing::internal::SharedPayloadBase*) | seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h | static void Destroy(SharedPayloadBase* shared) {
delete static_cast<SharedPayload*>(shared);
} | O1 | c | testing::internal::SharedPayload<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::Destroy(testing::internal::SharedPayloadBase*):
testq %rdi, %rdi
je 0x3cd85
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x3cd77
movq (%rax), %rsi
incq %rsi
callq 0x94c0
movl $0x28, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x94c0
retq
| _ZN7testing8internal13SharedPayloadINS0_9EqMatcherINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEE7DestroyEPNS0_17SharedPayloadBaseE:
test rdi, rdi
jz short locret_3CD85
push rbx
mov rbx, rdi
mov rdi, [rdi+8]; void *
lea rax, [rbx+18h]
cmp rdi, rax
jz short loc_3CD77
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3CD77:
mov esi, 28h ; '('; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
locret_3CD85:
retn
| void testing::internal::SharedPayload<testing::internal::EqMatcher<std::string>>::Destroy(_QWORD *a1)
{
_QWORD *v2; // rdi
if ( a1 )
{
v2 = (_QWORD *)a1[1];
if ( v2 != a1 + 3 )
operator delete(v2, a1[3] + 1LL);
operator delete(a1, 0x28uLL);
}
}
| Destroy:
TEST RDI,RDI
JZ 0x0013cd85
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
LEA RAX,[RBX + 0x18]
CMP RDI,RAX
JZ 0x0013cd77
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x001094c0
LAB_0013cd77:
MOV ESI,0x28
MOV RDI,RBX
POP RBX
JMP 0x001094c0
LAB_0013cd85:
RET
|
/* testing::internal::SharedPayload<testing::internal::EqMatcher<std::__cxx11::string >
>::Destroy(testing::internal::SharedPayloadBase*) */
void testing::internal::SharedPayload<testing::internal::EqMatcher<std::__cxx11::string>>::Destroy
(SharedPayloadBase *param_1)
{
if (param_1 != (SharedPayloadBase *)0x0) {
if (*(SharedPayloadBase **)(param_1 + 8) != param_1 + 0x18) {
operator_delete(*(SharedPayloadBase **)(param_1 + 8),*(long *)(param_1 + 0x18) + 1);
}
operator_delete(param_1,0x28);
return;
}
return;
}
| |
39,583 | my_strerror | eloqsql/strings/my_vsnprintf.c | const char* my_strerror(char *buf, size_t len, int nr)
{
char *msg= NULL;
buf[0]= '\0'; /* failsafe */
if (nr <= 0)
{
strmake(buf, (nr == 0 ?
"Internal error/check (Not system error)" :
"Internal error < 0 (Not system error)"),
len-1);
return buf;
}
/*
These (handler-) error messages are shared by perror, as required
by the principle of least surprise.
*/
if ((nr >= HA_ERR_FIRST) && (nr <= HA_ERR_LAST))
{
msg= (char *) handler_error_messages[nr - HA_ERR_FIRST];
strmake(buf, msg, len - 1);
}
else
{
/*
On Windows, do things the Windows way. On a system that supports both
the GNU and the XSI variant, use whichever was configured (GNU); if
this choice is not advertised, use the default (POSIX/XSI). Testing
for __GNUC__ is not sufficient to determine whether this choice exists.
*/
#if defined(_WIN32)
strerror_s(buf, len, nr);
#elif ((defined _POSIX_C_SOURCE && (_POSIX_C_SOURCE >= 200112L)) || \
(defined _XOPEN_SOURCE && (_XOPEN_SOURCE >= 600))) && \
! defined _GNU_SOURCE
strerror_r(nr, buf, len); /* I can build with or without GNU */
#elif defined(__GLIBC__) && defined (_GNU_SOURCE)
char *r= strerror_r(nr, buf, len);
if (r != buf) /* Want to help, GNU? */
strmake(buf, r, len - 1); /* Then don't. */
#else
strerror_r(nr, buf, len);
#endif
}
/*
strerror() return values are implementation-dependent, so let's
be pragmatic.
*/
if (!buf[0])
strmake(buf, "unknown error", len - 1);
return buf;
} | O0 | c | my_strerror:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0x1c(%rbp)
jg 0x7633e
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %ecx
leaq 0x692e(%rip), %rsi # 0x7cc44
leaq 0x68ff(%rip), %rax # 0x7cc1c
cmpl $0x0, %ecx
cmoveq %rax, %rsi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
callq 0x76f60
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x763da
cmpl $0x78, -0x1c(%rbp)
jl 0x7637c
cmpl $0xc6, -0x1c(%rbp)
jg 0x7637c
movl -0x1c(%rbp), %eax
subl $0x78, %eax
movslq %eax, %rcx
leaq 0x30e233(%rip), %rax # 0x384590
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
callq 0x76f60
jmp 0x763b1
movl -0x1c(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x240d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x763af
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
callq 0x76f60
jmp 0x763b1
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x763d2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
leaq 0x689d(%rip), %rsi # 0x7cc6a
callq 0x76f60
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_strerror:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], 0
mov rax, [rbp+var_10]
mov byte ptr [rax], 0
cmp [rbp+var_1C], 0
jg short loc_7633E
mov rdi, [rbp+var_10]
mov ecx, [rbp+var_1C]
lea rsi, aInternalError0; "Internal error < 0 (Not system error)"
lea rax, aInternalErrorC; "Internal error/check (Not system error)"
cmp ecx, 0
cmovz rsi, rax
mov rdx, [rbp+var_18]
sub rdx, 1
call strmake
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_763DA
loc_7633E:
cmp [rbp+var_1C], 78h ; 'x'
jl short loc_7637C
cmp [rbp+var_1C], 0C6h
jg short loc_7637C
mov eax, [rbp+var_1C]
sub eax, 78h ; 'x'
movsxd rcx, eax
lea rax, handler_error_messages
mov rax, [rax+rcx*8]
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_18]
sub rdx, 1
call strmake
jmp short loc_763B1
loc_7637C:
mov edi, [rbp+var_1C]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call _strerror_r
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
cmp rax, [rbp+var_10]
jz short loc_763AF
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_18]
sub rdx, 1
call strmake
loc_763AF:
jmp short $+2
loc_763B1:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jnz short loc_763D2
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
sub rdx, 1
lea rsi, aUnknownError; "unknown error"
call strmake
loc_763D2:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_763DA:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| _BYTE * my_strerror(_BYTE *a1, long long a2, int a3)
{
const char *v3; // rsi
long long v5; // [rsp+0h] [rbp-30h]
*a1 = 0;
if ( a3 > 0 )
{
if ( a3 < 120 || a3 > 198 )
{
v5 = strerror_r((unsigned int)a3, a1, a2);
if ( (_BYTE *)v5 != a1 )
strmake(a1, v5, a2 - 1);
}
else
{
strmake(a1, handler_error_messages[a3 - 120], a2 - 1);
}
if ( !*a1 )
strmake(a1, "unknown error", a2 - 1);
return a1;
}
else
{
v3 = "Internal error < 0 (Not system error)";
if ( !a3 )
v3 = "Internal error/check (Not system error)";
strmake(a1, v3, a2 - 1);
return a1;
}
}
| my_strerror:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x0
CMP dword ptr [RBP + -0x1c],0x0
JG 0x0017633e
MOV RDI,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x1c]
LEA RSI,[0x17cc44]
LEA RAX,[0x17cc1c]
CMP ECX,0x0
CMOVZ RSI,RAX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,0x1
CALL 0x00176f60
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001763da
LAB_0017633e:
CMP dword ptr [RBP + -0x1c],0x78
JL 0x0017637c
CMP dword ptr [RBP + -0x1c],0xc6
JG 0x0017637c
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x78
MOVSXD RCX,EAX
LEA RAX,[0x484590]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,0x1
CALL 0x00176f60
JMP 0x001763b1
LAB_0017637c:
MOV EDI,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001240d0
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x10]
JZ 0x001763af
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,0x1
CALL 0x00176f60
LAB_001763af:
JMP 0x001763b1
LAB_001763b1:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JNZ 0x001763d2
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,0x1
LEA RSI,[0x17cc6a]
CALL 0x00176f60
LAB_001763d2:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_001763da:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
char * my_strerror(char *param_1,size_t param_2,int param_3)
{
char *pcVar1;
*param_1 = '\0';
if (param_3 < 1) {
pcVar1 = "Internal error < 0 (Not system error)";
if (param_3 == 0) {
pcVar1 = "Internal error/check (Not system error)";
}
strmake(param_1,pcVar1,param_2 - 1);
}
else {
if ((param_3 < 0x78) || (0xc6 < param_3)) {
pcVar1 = strerror_r(param_3,param_1,param_2);
if (pcVar1 != param_1) {
strmake(param_1,pcVar1,param_2 - 1);
}
}
else {
strmake(param_1,*(int8 *)(handler_error_messages + (long)(param_3 + -0x78) * 8),
param_2 - 1);
}
if (*param_1 == '\0') {
strmake(param_1,"unknown error",param_2 - 1);
}
}
return param_1;
}
| |
39,584 | 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>>>>>::lexer(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>>>>&&, bool) | monkey531[P]llama/common/./json.hpp | explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{} | O1 | 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>>>>>::lexer(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>>>>&&, bool):
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movb %dl, 0x10(%rdi)
movl $0xffffffff, 0x14(%rdi) # imm = 0xFFFFFFFF
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movb %al, 0x60(%rdi)
leaq 0x13d41(%rip), %rcx # 0xabeb5
movq %rcx, 0x70(%rdi)
movups %xmm0, 0x78(%rdi)
movq %rax, 0x88(%rdi)
callq 0x18cf0
movq (%rax), %rax
testq %rax, %rax
je 0x98195
movsbl (%rax), %eax
jmp 0x9819a
movl $0x2e, %eax
movl %eax, 0x90(%rbx)
popq %rbx
retq
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEEC2EOSM_b:
push rbx
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmmword ptr [rdi], xmm0
mov [rdi+10h], dl
mov dword ptr [rdi+14h], 0FFFFFFFFh
xor eax, eax
mov [rdi+18h], al
lea rcx, [rdi+60h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+40h], xmm0
mov [rdi+50h], rcx
mov [rdi+58h], rax
mov [rdi+60h], al
lea rcx, aEndIndexOutOfB+19h; ""
mov [rdi+70h], rcx
movups xmmword ptr [rdi+78h], xmm0
mov [rdi+88h], rax
call _localeconv
mov rax, [rax]
test rax, rax
jz short loc_98195
movsx eax, byte ptr [rax]
jmp short loc_9819A
loc_98195:
mov eax, 2Eh ; '.'
loc_9819A:
mov [rbx+90h], eax
pop rbx
retn
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::lexer(
long long a1,
_OWORD *a2,
char a3)
{
char *v3; // rax
long long result; // rax
*(_OWORD *)a1 = *a2;
*(_BYTE *)(a1 + 16) = a3;
*(_DWORD *)(a1 + 20) = -1;
*(_BYTE *)(a1 + 24) = 0;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
*(_QWORD *)(a1 + 112) = "";
*(_OWORD *)(a1 + 120) = 0LL;
*(_QWORD *)(a1 + 136) = 0LL;
v3 = *(char **)localeconv(a1);
if ( v3 )
result = (unsigned int)*v3;
else
result = 46LL;
*(_DWORD *)(a1 + 144) = result;
return result;
}
| lexer:
PUSH RBX
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS xmmword ptr [RDI],XMM0
MOV byte ptr [RDI + 0x10],DL
MOV dword ptr [RDI + 0x14],0xffffffff
XOR EAX,EAX
MOV byte ptr [RDI + 0x18],AL
LEA RCX,[RDI + 0x60]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOV qword ptr [RDI + 0x50],RCX
MOV qword ptr [RDI + 0x58],RAX
MOV byte ptr [RDI + 0x60],AL
LEA RCX,[0x1abeb5]
MOV qword ptr [RDI + 0x70],RCX
MOVUPS xmmword ptr [RDI + 0x78],XMM0
MOV qword ptr [RDI + 0x88],RAX
CALL 0x00118cf0
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00198195
MOVSX EAX,byte ptr [RAX]
JMP 0x0019819a
LAB_00198195:
MOV EAX,0x2e
LAB_0019819a:
MOV dword ptr [RBX + 0x90],EAX
POP RBX
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 > >
>::lexer(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > >&&, bool) */
void __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>>>
::lexer(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this,iterator_input_adapter *param_1,bool param_2)
{
int8 uVar1;
int iVar2;
lconv *plVar3;
uVar1 = *(int8 *)(param_1 + 8);
*(int8 *)this = *(int8 *)param_1;
*(int8 *)(this + 8) = uVar1;
this[0x10] = (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>>>
)param_2;
*(int4 *)(this + 0x14) = 0xffffffff;
this[0x18] = (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>>>
)0x0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
**)(this + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (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>>>
)0x0;
*(char **)(this + 0x70) = "";
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
plVar3 = localeconv();
if (plVar3->decimal_point == (char *)0x0) {
iVar2 = 0x2e;
}
else {
iVar2 = (int)*plVar3->decimal_point;
}
*(int *)(this + 0x90) = iVar2;
return;
}
| |
39,585 | my_dirend | eloqsql/mysys/my_lib.c | void my_dirend(MY_DIR *dir)
{
MY_DIR_HANDLE *dirh= (MY_DIR_HANDLE*) dir;
DBUG_ENTER("my_dirend");
if (dirh)
{
delete_dynamic(&dirh->array);
free_root(&dirh->root, MYF(0));
my_free(dirh);
}
DBUG_VOID_RETURN;
} | O3 | c | my_dirend:
testq %rdi, %rdi
je 0x9f390
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x919ec
leaq 0x38(%rbx), %rdi
xorl %esi, %esi
callq 0x9cadf
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9fbaa
retq
| my_dirend:
test rdi, rdi
jz short locret_9F390
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
add rdi, 10h
call delete_dynamic
lea rdi, [rbx+38h]
xor esi, esi
call free_root
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp my_free
locret_9F390:
retn
| long long my_dirend(long long a1)
{
long long result; // rax
if ( a1 )
{
delete_dynamic((long long *)(a1 + 16));
free_root((_QWORD *)(a1 + 56), 0);
return my_free(a1);
}
return result;
}
| my_dirend:
TEST RDI,RDI
JZ 0x0019f390
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
ADD RDI,0x10
CALL 0x001919ec
LEA RDI,[RBX + 0x38]
XOR ESI,ESI
CALL 0x0019cadf
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0019fbaa
LAB_0019f390:
RET
|
void my_dirend(long param_1)
{
if (param_1 != 0) {
delete_dynamic(param_1 + 0x10);
free_root(param_1 + 0x38,0);
my_free(param_1);
return;
}
return;
}
| |
39,586 | unicode_script | bluesky950520[P]quickjs/libunicode.c | int unicode_script(CharRange *cr,
const char *script_name, BOOL is_ext)
{
int script_idx;
const uint8_t *p, *p_end;
uint32_t c, c1, b, n, v, v_len, i, type;
CharRange cr1_s = { 0 }, *cr1 = NULL;
CharRange cr2_s = { 0 }, *cr2 = &cr2_s;
BOOL is_common;
script_idx = unicode_find_name(unicode_script_name_table, script_name);
if (script_idx < 0)
return -2;
/* Note: we remove the "Unknown" Script */
script_idx += UNICODE_SCRIPT_Unknown + 1;
is_common = (script_idx == UNICODE_SCRIPT_Common ||
script_idx == UNICODE_SCRIPT_Inherited);
if (is_ext) {
cr1 = &cr1_s;
cr_init(cr1, cr->mem_opaque, cr->realloc_func);
cr_init(cr2, cr->mem_opaque, cr->realloc_func);
} else {
cr1 = cr;
}
p = unicode_script_table;
p_end = unicode_script_table + countof(unicode_script_table);
c = 0;
while (p < p_end) {
b = *p++;
type = b >> 7;
n = b & 0x7f;
if (n < 96) {
} else if (n < 112) {
n = (n - 96) << 8;
n |= *p++;
n += 96;
} else {
n = (n - 112) << 16;
n |= *p++ << 8;
n |= *p++;
n += 96 + (1 << 12);
}
if (type == 0)
v = 0;
else
v = *p++;
c1 = c + n + 1;
if (v == script_idx) {
if (cr_add_interval(cr1, c, c1))
goto fail;
}
c = c1;
}
if (is_ext) {
/* add the script extensions */
p = unicode_script_ext_table;
p_end = unicode_script_ext_table + countof(unicode_script_ext_table);
c = 0;
while (p < p_end) {
b = *p++;
if (b < 128) {
n = b;
} else if (b < 128 + 64) {
n = (b - 128) << 8;
n |= *p++;
n += 128;
} else {
n = (b - 128 - 64) << 16;
n |= *p++ << 8;
n |= *p++;
n += 128 + (1 << 14);
}
c1 = c + n + 1;
v_len = *p++;
if (is_common) {
if (v_len != 0) {
if (cr_add_interval(cr2, c, c1))
goto fail;
}
} else {
for(i = 0; i < v_len; i++) {
if (p[i] == script_idx) {
if (cr_add_interval(cr2, c, c1))
goto fail;
break;
}
}
}
p += v_len;
c = c1;
}
if (is_common) {
/* remove all the characters with script extensions */
if (cr_invert(cr2))
goto fail;
if (cr_op(cr, cr1->points, cr1->len, cr2->points, cr2->len,
CR_OP_INTER))
goto fail;
} else {
if (cr_op(cr, cr1->points, cr1->len, cr2->points, cr2->len,
CR_OP_UNION))
goto fail;
}
cr_free(cr1);
cr_free(cr2);
}
return 0;
fail:
if (is_ext) {
cr_free(cr1);
cr_free(cr2);
}
goto fail;
} | O2 | c | unicode_script:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0xb317(%rip), %rdi # 0x8ebe0
callq 0x83bb5
testl %eax, %eax
js 0x83937
movl %eax, %r8d
leaq 0x18(%r14), %rcx
leaq 0x10(%r14), %rax
testl %ebx, %ebx
movq %r14, 0x48(%rsp)
je 0x8393f
movq (%rax), %rax
leaq 0x60(%rsp), %rdi
movq (%rcx), %rcx
leaq 0x68(%rsp), %rdx
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rdx)
testq %rcx, %rcx
leaq -0x946(%rip), %rsi # 0x82fc1
cmovneq %rcx, %rsi
movq %rax, -0x8(%rdx)
movq %rsi, (%rdx)
movaps %xmm0, 0x10(%rsp)
movq %rax, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
jmp 0x8394e
pushq $-0x2
popq %rbx
jmp 0x83b10
movq %rax, 0x38(%rsp)
movq %rcx, 0x40(%rsp)
movq %r14, 0x8(%rsp)
leal 0x1(%r8), %r9d
xorl %r15d, %r15d
leaq 0xbc34(%rip), %r13 # 0x8f590
xorl %r12d, %r12d
movq %r8, %rbp
movl %r9d, %r14d
cmpq $0xaf2, %r12 # imm = 0xAF2
jg 0x83a01
movl %r15d, %esi
leaq 0x1(%r12), %rdx
movzbl (%r12,%r13), %ecx
movl %ecx, %eax
andl $0x7f, %eax
cmpb $0x60, %al
jae 0x8398d
movq %rdx, %r12
jmp 0x839c0
movzbl (%rdx,%r13), %edx
cmpb $0x6f, %al
ja 0x839a6
shll $0x8, %eax
addq $0x2, %r12
addl %edx, %eax
addl $0xffffa060, %eax # imm = 0xFFFFA060
jmp 0x839c0
shll $0x10, %eax
shll $0x8, %edx
movzbl 0x2(%r12,%r13), %edi
addq $0x3, %r12
orl %eax, %edi
leal (%rdx,%rdi), %eax
addl $0xff901060, %eax # imm = 0xFF901060
testb %cl, %cl
js 0x839cd
leal (%rsi,%rax), %r15d
incl %r15d
jmp 0x83965
movzbl (%r12,%r13), %ecx
incq %r12
leal (%rsi,%rax), %r15d
incl %r15d
cmpl %ecx, %r9d
jne 0x83965
movq 0x8(%rsp), %rdi
movl %r15d, %edx
callq 0x83c49
movl %r14d, %r9d
movq %rbp, %r8
testl %eax, %eax
je 0x83965
jmp 0x83b4a
testl %ebx, %ebx
je 0x83b0e
xorl %r13d, %r13d
leaq 0xc67d(%rip), %r10 # 0x90090
xorl %eax, %eax
cmpq $0x4e4, %rax # imm = 0x4E4
jg 0x83ad1
movl %r13d, %esi
leaq 0x1(%rax), %r12
movzbl (%rax,%r10), %ecx
testb %cl, %cl
jns 0x83a6a
movzbl (%r12,%r10), %edx
cmpb $-0x41, %cl
ja 0x83a4c
shll $0x8, %ecx
addq $0x2, %rax
addl %edx, %ecx
addl $0xffff8080, %ecx # imm = 0xFFFF8080
jmp 0x83a67
shll $0x10, %ecx
shll $0x8, %edx
movzbl 0x2(%rax,%r10), %edi
addq $0x3, %rax
orl %ecx, %edi
leal (%rdx,%rdi), %ecx
addl $0xff404080, %ecx # imm = 0xFF404080
movq %rax, %r12
leal (%rsi,%rcx), %r13d
incl %r13d
movzbl (%r12,%r10), %r15d
incq %r12
cmpl $0x18, %r8d
je 0x83a85
cmpl $0x39, %r8d
jne 0x83a8c
testq %r15, %r15
jne 0x83aa4
jmp 0x83ac6
xorl %eax, %eax
cmpq %rax, %r15
je 0x83ac6
leaq (%r12,%rax), %rcx
movzbl (%r10,%rcx), %ecx
incq %rax
cmpl %ecx, %r9d
jne 0x83a8e
leaq 0x10(%rsp), %rdi
movl %r13d, %edx
callq 0x83c49
leaq 0xc5d8(%rip), %r10 # 0x90090
movl %r14d, %r9d
movq %rbp, %r8
testl %eax, %eax
jne 0x83b4a
addq %r15, %r12
movq %r12, %rax
jmp 0x83a15
cmpl $0x39, %r8d
je 0x83add
cmpl $0x18, %r8d
jne 0x83b21
leaq 0x10(%rsp), %rdi
callq 0x83250
testl %eax, %eax
jne 0x83b4a
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movl (%rax), %edx
movq 0x18(%rsp), %r12
movl 0x10(%rsp), %r8d
pushq $0x1
popq %r9
movq 0x48(%rsp), %rdi
movq %r12, %rcx
jmp 0x83b41
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movl (%rax), %edx
movq 0x18(%rsp), %r12
movl 0x10(%rsp), %r8d
movq 0x48(%rsp), %rdi
movq %r12, %rcx
xorl %r9d, %r9d
callq 0x83065
testl %eax, %eax
je 0x83b86
movq 0x38(%rsp), %r13
movq 0x40(%rsp), %rbp
movq 0x28(%rsp), %r14
movq 0x18(%rsp), %r15
movq 0x20(%rsp), %r12
testl %ebx, %ebx
je 0x83b63
movq (%r13), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq *(%rbp)
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq *%r14
jmp 0x83b63
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
xorl %ebx, %ebx
xorl %edx, %edx
movq 0x40(%rsp), %rax
callq *(%rax)
movq 0x20(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq *0x28(%rsp)
jmp 0x83b10
| unicode_script:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov ebx, edx
mov r14, rdi
xorps xmm0, xmm0
movaps [rsp+0A8h+var_48], xmm0
movaps [rsp+0A8h+var_58], xmm0
movaps [rsp+0A8h+var_88], xmm0
movaps [rsp+0A8h+var_98], xmm0
lea rdi, unicode_script_name_table; "Adlam,Adlm"
call unicode_find_name
test eax, eax
js short loc_83937
mov r8d, eax
lea rcx, [r14+18h]
lea rax, [r14+10h]
test ebx, ebx
mov [rsp+0A8h+var_60], r14
jz short loc_8393F
mov rax, [rax]
lea rdi, [rsp+0A8h+var_48]
mov rcx, [rcx]
lea rdx, [rsp+0A8h+var_48+8]
xorps xmm0, xmm0
movaps xmmword ptr [rdx-18h], xmm0
test rcx, rcx
lea rsi, cr_default_realloc
cmovnz rsi, rcx
mov [rdx-8], rax
mov [rdx], rsi
movaps [rsp+0A8h+var_98], xmm0
mov qword ptr [rsp+0A8h+var_88], rax
mov qword ptr [rsp+0A8h+var_88+8], rsi
lea rax, [rsp+0A8h+var_58]
mov [rsp+0A8h+var_A0], rax
mov [rsp+0A8h+var_68], rdx
mov [rsp+0A8h+var_70], rdi
jmp short loc_8394E
loc_83937:
push 0FFFFFFFFFFFFFFFEh
pop rbx
jmp loc_83B10
loc_8393F:
mov [rsp+0A8h+var_70], rax
mov [rsp+0A8h+var_68], rcx
mov [rsp+0A8h+var_A0], r14
loc_8394E:
lea r9d, [r8+1]
xor r15d, r15d
lea r13, unicode_script_table
xor r12d, r12d
mov rbp, r8
mov r14d, r9d
loc_83965:
cmp r12, 0AF2h
jg loc_83A01
mov esi, r15d
lea rdx, [r12+1]
movzx ecx, byte ptr [r12+r13]
mov eax, ecx
and eax, 7Fh
cmp al, 60h ; '`'
jnb short loc_8398D
mov r12, rdx
jmp short loc_839C0
loc_8398D:
movzx edx, byte ptr [rdx+r13]
cmp al, 6Fh ; 'o'
ja short loc_839A6
shl eax, 8
add r12, 2
add eax, edx
add eax, 0FFFFA060h
jmp short loc_839C0
loc_839A6:
shl eax, 10h
shl edx, 8
movzx edi, byte ptr [r12+r13+2]
add r12, 3
or edi, eax
lea eax, [rdx+rdi]
add eax, 0FF901060h
loc_839C0:
test cl, cl
js short loc_839CD
lea r15d, [rsi+rax]
inc r15d
jmp short loc_83965
loc_839CD:
movzx ecx, byte ptr [r12+r13]
inc r12
lea r15d, [rsi+rax]
inc r15d
cmp r9d, ecx
jnz short loc_83965
mov rdi, [rsp+0A8h+var_A0]
mov edx, r15d
call cr_add_interval
mov r9d, r14d
mov r8, rbp
test eax, eax
jz loc_83965
jmp loc_83B4A
loc_83A01:
test ebx, ebx
jz loc_83B0E
xor r13d, r13d
lea r10, unicode_script_ext_table
xor eax, eax
loc_83A15:
cmp rax, 4E4h
jg loc_83AD1
mov esi, r13d
lea r12, [rax+1]
movzx ecx, byte ptr [rax+r10]
test cl, cl
jns short loc_83A6A
movzx edx, byte ptr [r12+r10]
cmp cl, 0BFh
ja short loc_83A4C
shl ecx, 8
add rax, 2
add ecx, edx
add ecx, 0FFFF8080h
jmp short loc_83A67
loc_83A4C:
shl ecx, 10h
shl edx, 8
movzx edi, byte ptr [rax+r10+2]
add rax, 3
or edi, ecx
lea ecx, [rdx+rdi]
add ecx, 0FF404080h
loc_83A67:
mov r12, rax
loc_83A6A:
lea r13d, [rsi+rcx]
inc r13d
movzx r15d, byte ptr [r12+r10]
inc r12
cmp r8d, 18h
jz short loc_83A85
cmp r8d, 39h ; '9'
jnz short loc_83A8C
loc_83A85:
test r15, r15
jnz short loc_83AA4
jmp short loc_83AC6
loc_83A8C:
xor eax, eax
loc_83A8E:
cmp r15, rax
jz short loc_83AC6
lea rcx, [r12+rax]
movzx ecx, byte ptr [r10+rcx]
inc rax
cmp r9d, ecx
jnz short loc_83A8E
loc_83AA4:
lea rdi, [rsp+0A8h+var_98]
mov edx, r13d
call cr_add_interval
lea r10, unicode_script_ext_table
mov r9d, r14d
mov r8, rbp
test eax, eax
jnz loc_83B4A
loc_83AC6:
add r12, r15
mov rax, r12
jmp loc_83A15
loc_83AD1:
cmp r8d, 39h ; '9'
jz short loc_83ADD
cmp r8d, 18h
jnz short loc_83B21
loc_83ADD:
lea rdi, [rsp+0A8h+var_98]
call cr_invert
test eax, eax
jnz short loc_83B4A
mov rax, [rsp+0A8h+var_A0]
mov rsi, [rax+8]
mov edx, [rax]
mov r12, qword ptr [rsp+0A8h+var_98+8]
mov r8d, dword ptr [rsp+0A8h+var_98]
push 1
pop r9
mov rdi, [rsp+0A8h+var_60]
mov rcx, r12
jmp short loc_83B41
loc_83B0E:
xor ebx, ebx
loc_83B10:
mov eax, ebx
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_83B21:
mov rax, [rsp+0A8h+var_A0]
mov rsi, [rax+8]
mov edx, [rax]
mov r12, qword ptr [rsp+0A8h+var_98+8]
mov r8d, dword ptr [rsp+0A8h+var_98]
mov rdi, [rsp+0A8h+var_60]
mov rcx, r12
xor r9d, r9d
loc_83B41:
call cr_op
test eax, eax
jz short loc_83B86
loc_83B4A:
mov r13, [rsp+0A8h+var_70]
mov rbp, [rsp+0A8h+var_68]
mov r14, qword ptr [rsp+0A8h+var_88+8]
mov r15, qword ptr [rsp+0A8h+var_98+8]
mov r12, qword ptr [rsp+0A8h+var_88]
loc_83B63:
test ebx, ebx
jz short loc_83B63
mov rdi, [r13+0]
mov rax, [rsp+0A8h+var_A0]
mov rsi, [rax+8]
xor edx, edx
call qword ptr [rbp+0]
mov rdi, r12
mov rsi, r15
xor edx, edx
call r14
jmp short loc_83B63
loc_83B86:
mov rax, [rsp+0A8h+var_70]
mov rdi, [rax]
mov rax, [rsp+0A8h+var_A0]
mov rsi, [rax+8]
xor ebx, ebx
xor edx, edx
mov rax, [rsp+0A8h+var_68]
call qword ptr [rax]
mov rdi, qword ptr [rsp+0A8h+var_88]
mov rsi, r12
xor edx, edx
call qword ptr [rsp+0A8h+var_88+8]
jmp loc_83B10
| long long unicode_script(long long a1, long long a2, int a3)
{
int name; // eax
long long v5; // r8
long long v6; // rax
long long ( *v7)(long long, long long, long long); // rcx
long long ( *v8)(long long, long long, long long); // rsi
unsigned int v9; // ebx
long long v10; // r9
unsigned int v11; // r15d
long long v12; // r12
long long v13; // rbp
unsigned int v14; // r14d
long long v15; // rsi
char v16; // cl
int v17; // eax
int v18; // edx
int v19; // edi
int v20; // ecx
int v21; // eax
long long v22; // rcx
unsigned int v23; // r13d
long long i; // rax
long long v25; // rsi
long long v26; // r12
int v27; // ecx
int v28; // edx
long long v29; // rax
int v30; // edi
long long v31; // r15
long long v32; // r12
long long v33; // rax
int v34; // ecx
int v35; // eax
long long v36; // rsi
int v37; // edx
long long v38; // r12
int v39; // r8d
int v40; // r9d
const char *v41; // rdi
long long v42; // rcx
_QWORD *v44; // r13
void ( **v45)(_QWORD, _QWORD, _QWORD, long long, long long, long long); // rbp
void ( *v46)(long long, long long, _QWORD); // r14
long long v47; // r15
long long j; // r12
__int128 *v49; // [rsp+8h] [rbp-A0h]
__int128 v50; // [rsp+10h] [rbp-98h] BYREF
__int128 v51; // [rsp+20h] [rbp-88h]
_QWORD *v52; // [rsp+38h] [rbp-70h]
char *v53; // [rsp+40h] [rbp-68h]
const char *v54; // [rsp+48h] [rbp-60h]
__int128 v55; // [rsp+50h] [rbp-58h] BYREF
_OWORD v56[4]; // [rsp+60h] [rbp-48h] BYREF
v56[0] = 0LL;
v55 = 0LL;
v51 = 0LL;
v50 = 0LL;
name = unicode_find_name("Adlam,Adlm");
if ( name < 0 )
{
return (unsigned int)-2;
}
else
{
v5 = (unsigned int)name;
v54 = (const char *)a1;
if ( a3 )
{
v6 = *(_QWORD *)(a1 + 16);
v7 = *(long long ( **)(long long, long long, long long))(a1 + 24);
v55 = 0LL;
v8 = cr_default_realloc;
if ( v7 )
v8 = v7;
*(_QWORD *)&v56[0] = v6;
*((_QWORD *)&v56[0] + 1) = v8;
v50 = 0LL;
*(_QWORD *)&v51 = v6;
*((_QWORD *)&v51 + 1) = v8;
v49 = &v55;
v53 = (char *)v56 + 8;
v52 = v56;
}
else
{
v52 = (_QWORD *)(a1 + 16);
v53 = (char *)(a1 + 24);
v49 = (__int128 *)a1;
}
LODWORD(v10) = v5 + 1;
v11 = 0;
v12 = 0LL;
v13 = v5;
v14 = v5 + 1;
while ( v12 <= 2802 )
{
v15 = v11;
v16 = unicode_script_table[v12];
v17 = v16 & 0x7F;
if ( (unsigned __int8)v17 >= 0x60u )
{
v18 = unicode_script_table[v12 + 1];
if ( (unsigned __int8)v17 > 0x6Fu )
{
v19 = unicode_script_table[v12 + 2];
v12 += 3LL;
v17 = (v18 << 8) + ((v17 << 16) | v19) - 7335840;
}
else
{
v12 += 2LL;
v17 = v18 + (v17 << 8) - 24480;
}
}
else
{
++v12;
}
if ( v16 < 0 )
{
v20 = unicode_script_table[v12++];
v11 += v17 + 1;
if ( (_DWORD)v10 == v20 )
{
v21 = cr_add_interval(v49, v15, v11);
v10 = v14;
v5 = v13;
if ( v21 )
goto LABEL_45;
}
}
else
{
v11 += v17 + 1;
}
}
if ( a3 )
{
v23 = 0;
for ( i = 0LL; i <= 1252; i = v31 + v32 )
{
v25 = v23;
v26 = i + 1;
v27 = unicode_script_ext_table[i];
if ( (v27 & 0x80u) != 0 )
{
v28 = unicode_script_ext_table[v26];
if ( (unsigned __int8)v27 > 0xBFu )
{
v30 = unicode_script_ext_table[i + 2];
v29 = i + 3;
v27 = (v28 << 8) + ((v27 << 16) | v30) - 12566400;
}
else
{
v29 = i + 2;
v27 = v28 + (v27 << 8) - 32640;
}
v26 = v29;
}
v23 += v27 + 1;
v31 = unicode_script_ext_table[v26];
v32 = v26 + 1;
if ( (_DWORD)v5 == 24 || (_DWORD)v5 == 57 )
{
if ( v31 )
{
LABEL_35:
v35 = cr_add_interval(&v50, v25, v23);
v10 = v14;
v5 = v13;
if ( v35 )
goto LABEL_45;
}
}
else
{
v33 = 0LL;
while ( v31 != v33 )
{
v34 = unicode_script_ext_table[v32 + v33++];
if ( (_DWORD)v10 == v34 )
goto LABEL_35;
}
}
}
if ( (_DWORD)v5 == 57 || (_DWORD)v5 == 24 )
{
if ( (unsigned int)cr_invert((int *)&v50) )
{
LABEL_45:
v44 = v52;
v45 = (void ( **)(_QWORD, _QWORD, _QWORD, long long, long long, long long))v53;
v46 = (void ( *)(long long, long long, _QWORD))*((_QWORD *)&v51 + 1);
v47 = *((_QWORD *)&v50 + 1);
for ( j = v51; ; v46(j, v47, 0LL) )
{
while ( !a3 )
;
(*v45)(*v44, *((_QWORD *)v49 + 1), 0LL, v22, v5, v10);
}
}
v36 = *((_QWORD *)v49 + 1);
v37 = *(_DWORD *)v49;
v38 = *((_QWORD *)&v50 + 1);
v39 = v50;
v40 = 1;
v41 = v54;
v42 = *((_QWORD *)&v50 + 1);
}
else
{
v36 = *((_QWORD *)v49 + 1);
v37 = *(_DWORD *)v49;
v38 = *((_QWORD *)&v50 + 1);
v39 = v50;
v41 = v54;
v42 = *((_QWORD *)&v50 + 1);
v40 = 0;
}
if ( (unsigned int)cr_op(v41, v36, v37, v42, v39, v40) )
goto LABEL_45;
v9 = 0;
(*(void ( **)(_QWORD, _QWORD, _QWORD))v53)(*v52, *((_QWORD *)v49 + 1), 0LL);
(*((void ( **)(_QWORD, long long, _QWORD))&v51 + 1))(v51, v38, 0LL);
}
else
{
return 0;
}
}
return v9;
}
| unicode_script:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV EBX,EDX
MOV R14,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
LEA RDI,[0x18ebe0]
CALL 0x00183bb5
TEST EAX,EAX
JS 0x00183937
MOV R8D,EAX
LEA RCX,[R14 + 0x18]
LEA RAX,[R14 + 0x10]
TEST EBX,EBX
MOV qword ptr [RSP + 0x48],R14
JZ 0x0018393f
MOV RAX,qword ptr [RAX]
LEA RDI,[RSP + 0x60]
MOV RCX,qword ptr [RCX]
LEA RDX,[RSP + 0x68]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RDX + -0x18],XMM0
TEST RCX,RCX
LEA RSI,[0x182fc1]
CMOVNZ RSI,RCX
MOV qword ptr [RDX + -0x8],RAX
MOV qword ptr [RDX],RSI
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RSI
LEA RAX,[RSP + 0x50]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x38],RDI
JMP 0x0018394e
LAB_00183937:
PUSH -0x2
POP RBX
JMP 0x00183b10
LAB_0018393f:
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RCX
MOV qword ptr [RSP + 0x8],R14
LAB_0018394e:
LEA R9D,[R8 + 0x1]
XOR R15D,R15D
LEA R13,[0x18f590]
XOR R12D,R12D
MOV RBP,R8
MOV R14D,R9D
LAB_00183965:
CMP R12,0xaf2
JG 0x00183a01
MOV ESI,R15D
LEA RDX,[R12 + 0x1]
MOVZX ECX,byte ptr [R12 + R13*0x1]
MOV EAX,ECX
AND EAX,0x7f
CMP AL,0x60
JNC 0x0018398d
MOV R12,RDX
JMP 0x001839c0
LAB_0018398d:
MOVZX EDX,byte ptr [RDX + R13*0x1]
CMP AL,0x6f
JA 0x001839a6
SHL EAX,0x8
ADD R12,0x2
ADD EAX,EDX
ADD EAX,0xffffa060
JMP 0x001839c0
LAB_001839a6:
SHL EAX,0x10
SHL EDX,0x8
MOVZX EDI,byte ptr [R12 + R13*0x1 + 0x2]
ADD R12,0x3
OR EDI,EAX
LEA EAX,[RDX + RDI*0x1]
ADD EAX,0xff901060
LAB_001839c0:
TEST CL,CL
JS 0x001839cd
LEA R15D,[RSI + RAX*0x1]
INC R15D
JMP 0x00183965
LAB_001839cd:
MOVZX ECX,byte ptr [R12 + R13*0x1]
INC R12
LEA R15D,[RSI + RAX*0x1]
INC R15D
CMP R9D,ECX
JNZ 0x00183965
MOV RDI,qword ptr [RSP + 0x8]
MOV EDX,R15D
CALL 0x00183c49
MOV R9D,R14D
MOV R8,RBP
TEST EAX,EAX
JZ 0x00183965
JMP 0x00183b4a
LAB_00183a01:
TEST EBX,EBX
JZ 0x00183b0e
XOR R13D,R13D
LEA R10,[0x190090]
XOR EAX,EAX
LAB_00183a15:
CMP RAX,0x4e4
JG 0x00183ad1
MOV ESI,R13D
LEA R12,[RAX + 0x1]
MOVZX ECX,byte ptr [RAX + R10*0x1]
TEST CL,CL
JNS 0x00183a6a
MOVZX EDX,byte ptr [R12 + R10*0x1]
CMP CL,0xbf
JA 0x00183a4c
SHL ECX,0x8
ADD RAX,0x2
ADD ECX,EDX
ADD ECX,0xffff8080
JMP 0x00183a67
LAB_00183a4c:
SHL ECX,0x10
SHL EDX,0x8
MOVZX EDI,byte ptr [RAX + R10*0x1 + 0x2]
ADD RAX,0x3
OR EDI,ECX
LEA ECX,[RDX + RDI*0x1]
ADD ECX,0xff404080
LAB_00183a67:
MOV R12,RAX
LAB_00183a6a:
LEA R13D,[RSI + RCX*0x1]
INC R13D
MOVZX R15D,byte ptr [R12 + R10*0x1]
INC R12
CMP R8D,0x18
JZ 0x00183a85
CMP R8D,0x39
JNZ 0x00183a8c
LAB_00183a85:
TEST R15,R15
JNZ 0x00183aa4
JMP 0x00183ac6
LAB_00183a8c:
XOR EAX,EAX
LAB_00183a8e:
CMP R15,RAX
JZ 0x00183ac6
LEA RCX,[R12 + RAX*0x1]
MOVZX ECX,byte ptr [R10 + RCX*0x1]
INC RAX
CMP R9D,ECX
JNZ 0x00183a8e
LAB_00183aa4:
LEA RDI,[RSP + 0x10]
MOV EDX,R13D
CALL 0x00183c49
LEA R10,[0x190090]
MOV R9D,R14D
MOV R8,RBP
TEST EAX,EAX
JNZ 0x00183b4a
LAB_00183ac6:
ADD R12,R15
MOV RAX,R12
JMP 0x00183a15
LAB_00183ad1:
CMP R8D,0x39
JZ 0x00183add
CMP R8D,0x18
JNZ 0x00183b21
LAB_00183add:
LEA RDI,[RSP + 0x10]
CALL 0x00183250
TEST EAX,EAX
JNZ 0x00183b4a
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX + 0x8]
MOV EDX,dword ptr [RAX]
MOV R12,qword ptr [RSP + 0x18]
MOV R8D,dword ptr [RSP + 0x10]
PUSH 0x1
POP R9
MOV RDI,qword ptr [RSP + 0x48]
MOV RCX,R12
JMP 0x00183b41
LAB_00183b0e:
XOR EBX,EBX
LAB_00183b10:
MOV EAX,EBX
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00183b21:
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX + 0x8]
MOV EDX,dword ptr [RAX]
MOV R12,qword ptr [RSP + 0x18]
MOV R8D,dword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x48]
MOV RCX,R12
XOR R9D,R9D
LAB_00183b41:
CALL 0x00183065
TEST EAX,EAX
JZ 0x00183b86
LAB_00183b4a:
MOV R13,qword ptr [RSP + 0x38]
MOV RBP,qword ptr [RSP + 0x40]
MOV R14,qword ptr [RSP + 0x28]
MOV R15,qword ptr [RSP + 0x18]
MOV R12,qword ptr [RSP + 0x20]
LAB_00183b63:
TEST EBX,EBX
JZ 0x00183b63
MOV RDI,qword ptr [R13]
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX + 0x8]
XOR EDX,EDX
CALL qword ptr [RBP]
MOV RDI,R12
MOV RSI,R15
XOR EDX,EDX
CALL R14
JMP 0x00183b63
LAB_00183b86:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX + 0x8]
XOR EBX,EBX
XOR EDX,EDX
MOV RAX,qword ptr [RSP + 0x40]
CALL qword ptr [RAX]
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,R12
XOR EDX,EDX
CALL qword ptr [RSP + 0x28]
JMP 0x00183b10
|
int4 unicode_script(int8 *param_1,int8 param_2,int param_3)
{
byte *pbVar1;
byte bVar2;
int4 uVar3;
code *pcVar4;
code **ppcVar5;
int8 *puVar6;
int8 uVar7;
int iVar8;
uint uVar9;
int iVar10;
long lVar11;
ulong uVar12;
int8 uVar13;
int8 uVar14;
long lVar15;
int iVar16;
ulong uVar17;
int8 *local_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
code *pcStack_80;
int8 *local_70;
code **local_68;
int8 *local_60;
int8 local_58;
int8 uStack_50;
int8 local_48;
code *apcStack_40 [2];
local_48 = 0;
apcStack_40[0] = (code *)0x0;
local_58 = 0;
uStack_50 = 0;
local_88 = 0;
pcStack_80 = (code *)0x0;
local_98 = 0;
uStack_90 = 0;
iVar8 = unicode_find_name(&unicode_script_name_table);
if (iVar8 < 0) {
return 0xfffffffe;
}
local_68 = (code **)(param_1 + 3);
local_70 = param_1 + 2;
local_a0 = param_1;
if (param_3 != 0) {
local_88 = *local_70;
local_70 = &local_48;
pcVar4 = *local_68;
local_68 = apcStack_40;
local_58 = 0;
uStack_50 = 0;
pcStack_80 = cr_default_realloc;
if (pcVar4 != (code *)0x0) {
pcStack_80 = pcVar4;
}
local_98 = 0;
uStack_90 = 0;
local_a0 = &local_58;
local_48 = local_88;
apcStack_40[0] = pcStack_80;
}
lVar15 = 0;
local_60 = param_1;
iVar16 = 0;
do {
while( true ) {
iVar10 = iVar16;
if (0xaf2 < lVar15) {
if (param_3 == 0) {
return 0;
}
lVar15 = 0;
iVar16 = 0;
goto LAB_00183a15;
}
pbVar1 = &unicode_script_table + lVar15;
uVar9 = *pbVar1 & 0x7f;
lVar11 = lVar15 + 1;
if (0x5f < (byte)uVar9) {
if ((byte)uVar9 < 0x70) {
uVar9 = (uVar9 * 0x100 + (uint)(byte)(&DAT_0018f591)[lVar15]) - 0x5fa0;
lVar11 = lVar15 + 2;
}
else {
uVar9 = ((uint)(byte)(&DAT_0018f591)[lVar15] * 0x100 +
((uint)(byte)(&DAT_0018f592)[lVar15] | uVar9 << 0x10)) - 0x6fefa0;
lVar11 = lVar15 + 3;
}
}
lVar15 = lVar11;
if ((char)*pbVar1 < '\0') break;
iVar16 = iVar10 + uVar9 + 1;
}
pbVar1 = &unicode_script_table + lVar15;
lVar15 = lVar15 + 1;
iVar16 = iVar10 + uVar9 + 1;
} while ((iVar8 + 1U != (uint)*pbVar1) ||
(iVar10 = cr_add_interval(local_a0,iVar10,iVar16), ppcVar5 = local_68, puVar6 = local_70,
pcVar4 = pcStack_80, uVar13 = local_88, uVar14 = uStack_90, iVar10 == 0));
LAB_00183b63:
do {
do {
} while (param_3 == 0);
(**ppcVar5)(*puVar6,local_a0[1],0);
(*pcVar4)(uVar13,uVar14,0);
} while( true );
LAB_00183a15:
if (0x4e4 < lVar15) goto LAB_00183ad1;
lVar11 = lVar15 + 1;
bVar2 = (&unicode_script_ext_table)[lVar15];
uVar9 = (uint)bVar2;
if ((char)bVar2 < '\0') {
if (bVar2 < 0xc0) {
lVar11 = lVar15 + 2;
uVar9 = ((uint)bVar2 * 0x100 + (uint)(byte)(&DAT_00190091)[lVar15]) - 0x7f80;
}
else {
lVar11 = lVar15 + 3;
uVar9 = ((uint)(byte)(&DAT_00190091)[lVar15] * 0x100 +
((uint)(byte)(&DAT_00190092)[lVar15] | (uint)bVar2 << 0x10)) - 0xbfbf80;
}
}
iVar10 = iVar16 + uVar9 + 1;
uVar17 = (ulong)(byte)(&unicode_script_ext_table)[lVar11];
if ((iVar8 == 0x18) || (iVar8 == 0x39)) {
if (uVar17 != 0) goto LAB_00183aa4;
}
else {
uVar12 = 0;
do {
if (uVar17 == uVar12) goto LAB_00183ac6;
lVar15 = lVar11 + 1 + uVar12;
uVar12 = uVar12 + 1;
} while (iVar8 + 1U != (uint)(byte)(&unicode_script_ext_table)[lVar15]);
LAB_00183aa4:
iVar16 = cr_add_interval(&local_98,iVar16,iVar10);
ppcVar5 = local_68;
puVar6 = local_70;
pcVar4 = pcStack_80;
uVar13 = local_88;
uVar14 = uStack_90;
if (iVar16 != 0) goto LAB_00183b63;
}
LAB_00183ac6:
lVar15 = lVar11 + 1 + uVar17;
iVar16 = iVar10;
goto LAB_00183a15;
LAB_00183ad1:
if ((iVar8 == 0x39) || (iVar8 == 0x18)) {
iVar8 = cr_invert(&local_98);
ppcVar5 = local_68;
puVar6 = local_70;
pcVar4 = pcStack_80;
uVar13 = local_88;
uVar14 = uStack_90;
if (iVar8 != 0) goto LAB_00183b63;
uVar13 = local_a0[1];
uVar3 = *(int4 *)local_a0;
uVar14 = 1;
}
else {
uVar13 = local_a0[1];
uVar3 = *(int4 *)local_a0;
uVar14 = 0;
}
uVar7 = uStack_90;
iVar8 = cr_op(local_60,uVar13,uVar3,uStack_90,(int4)local_98,uVar14);
ppcVar5 = local_68;
puVar6 = local_70;
pcVar4 = pcStack_80;
uVar13 = local_88;
uVar14 = uStack_90;
if (iVar8 == 0) {
(**local_68)(*local_70,local_a0[1],0);
(*pcStack_80)(local_88,uVar7,0);
return 0;
}
goto LAB_00183b63;
}
| |
39,587 | unicode_script | bluesky950520[P]quickjs/libunicode.c | int unicode_script(CharRange *cr,
const char *script_name, BOOL is_ext)
{
int script_idx;
const uint8_t *p, *p_end;
uint32_t c, c1, b, n, v, v_len, i, type;
CharRange cr1_s = { 0 }, *cr1 = NULL;
CharRange cr2_s = { 0 }, *cr2 = &cr2_s;
BOOL is_common;
script_idx = unicode_find_name(unicode_script_name_table, script_name);
if (script_idx < 0)
return -2;
/* Note: we remove the "Unknown" Script */
script_idx += UNICODE_SCRIPT_Unknown + 1;
is_common = (script_idx == UNICODE_SCRIPT_Common ||
script_idx == UNICODE_SCRIPT_Inherited);
if (is_ext) {
cr1 = &cr1_s;
cr_init(cr1, cr->mem_opaque, cr->realloc_func);
cr_init(cr2, cr->mem_opaque, cr->realloc_func);
} else {
cr1 = cr;
}
p = unicode_script_table;
p_end = unicode_script_table + countof(unicode_script_table);
c = 0;
while (p < p_end) {
b = *p++;
type = b >> 7;
n = b & 0x7f;
if (n < 96) {
} else if (n < 112) {
n = (n - 96) << 8;
n |= *p++;
n += 96;
} else {
n = (n - 112) << 16;
n |= *p++ << 8;
n |= *p++;
n += 96 + (1 << 12);
}
if (type == 0)
v = 0;
else
v = *p++;
c1 = c + n + 1;
if (v == script_idx) {
if (cr_add_interval(cr1, c, c1))
goto fail;
}
c = c1;
}
if (is_ext) {
/* add the script extensions */
p = unicode_script_ext_table;
p_end = unicode_script_ext_table + countof(unicode_script_ext_table);
c = 0;
while (p < p_end) {
b = *p++;
if (b < 128) {
n = b;
} else if (b < 128 + 64) {
n = (b - 128) << 8;
n |= *p++;
n += 128;
} else {
n = (b - 128 - 64) << 16;
n |= *p++ << 8;
n |= *p++;
n += 128 + (1 << 14);
}
c1 = c + n + 1;
v_len = *p++;
if (is_common) {
if (v_len != 0) {
if (cr_add_interval(cr2, c, c1))
goto fail;
}
} else {
for(i = 0; i < v_len; i++) {
if (p[i] == script_idx) {
if (cr_add_interval(cr2, c, c1))
goto fail;
break;
}
}
}
p += v_len;
c = c1;
}
if (is_common) {
/* remove all the characters with script extensions */
if (cr_invert(cr2))
goto fail;
if (cr_op(cr, cr1->points, cr1->len, cr2->points, cr2->len,
CR_OP_INTER))
goto fail;
} else {
if (cr_op(cr, cr1->points, cr1->len, cr2->points, cr2->len,
CR_OP_UNION))
goto fail;
}
cr_free(cr1);
cr_free(cr2);
}
return 0;
fail:
if (is_ext) {
cr_free(cr1);
cr_free(cr2);
}
goto fail;
} | O3 | c | unicode_script:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edx, %ebx
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
leaq 0xc2f8(%rip), %rdi # 0xabc50
callq 0x9fd60
testl %eax, %eax
js 0x9f9d6
movl %eax, %r10d
leaq 0x18(%r12), %rax
leaq 0x10(%r12), %r15
testl %ebx, %ebx
movq %r12, 0x78(%rsp)
je 0x9f9e0
movq (%r15), %rsi
leaq 0x90(%rsp), %rdx
movq (%rax), %rax
leaq 0x98(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rcx)
testq %rax, %rax
leaq -0xa3e(%rip), %rdi # 0x9ef60
cmovneq %rax, %rdi
movq %rsi, -0x8(%rcx)
movq %rdi, (%rcx)
movaps %xmm0, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdi, 0x20(%rsp)
movq %rdi, 0x48(%rsp)
leaq 0x80(%rsp), %rbp
movq %rcx, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
jmp 0x9f9ff
movl $0xfffffffe, %ebx # imm = 0xFFFFFFFE
jmp 0x9fd4c
movq %r15, 0x58(%rsp)
movq %rax, 0x60(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq %r12, %rbp
leal 0x1(%r10), %r9d
leaq 0xcbf6(%rip), %r14 # 0xac600
xorl %ecx, %ecx
xorl %r15d, %r15d
movl %ebx, 0x4(%rsp)
movq %r10, 0x68(%rsp)
movl %r9d, 0x14(%rsp)
leaq 0x1(%rcx), %r12
movzbl (%rcx,%r14), %edx
movl %edx, %eax
andl $0x7f, %eax
cmpb $0x60, %al
jb 0x9fa65
movzbl (%r12,%r14), %esi
cmpb $0x6f, %al
ja 0x9fa48
shll $0x8, %eax
addq $0x2, %rcx
addl %esi, %eax
addl $0xffffa060, %eax # imm = 0xFFFFA060
jmp 0x9fa62
shll $0x10, %eax
shll $0x8, %esi
movzbl 0x2(%rcx,%r14), %edi
addq $0x3, %rcx
orl %eax, %edi
leal (%rsi,%rdi), %eax
addl $0xff901060, %eax # imm = 0xFF901060
movq %rcx, %r12
testb %dl, %dl
js 0x9fa72
leal (%r15,%rax), %r13d
incl %r13d
jmp 0x9fad0
movzbl (%r12,%r14), %ecx
incq %r12
leal (%r15,%rax), %r13d
incl %r13d
cmpl %ecx, %r9d
jne 0x9fad0
movl (%rbp), %eax
leal 0x2(%rax), %esi
cmpl 0x4(%rbp), %esi
jle 0x9fab2
movq %rbp, %rdi
callq 0x9ef7b
testl %eax, %eax
jne 0x9fcbb
movl (%rbp), %eax
movl 0x4(%rsp), %ebx
movq 0x68(%rsp), %r10
movl 0x14(%rsp), %r9d
movq 0x8(%rbp), %rcx
leal 0x1(%rax), %edx
movl %edx, (%rbp)
cltq
movl %r15d, (%rcx,%rax,4)
movslq (%rbp), %rax
leal 0x1(%rax), %edx
movl %edx, (%rbp)
movl %r13d, (%rcx,%rax,4)
movq %r12, %rcx
movl %r13d, %r15d
cmpq $0xaf3, %r12 # imm = 0xAF3
jl 0x9fa1d
testl %ebx, %ebx
je 0x9fc4d
movq %rbp, 0x18(%rsp)
xorl %ebx, %ebx
leaq 0xd607(%rip), %rsi # 0xad100
xorl %edi, %edi
xorl %r12d, %r12d
xorl %edx, %edx
xorl %r15d, %r15d
movl %edx, %r13d
leaq 0x1(%r12), %rcx
movzbl (%r12,%rsi), %eax
testb %al, %al
jns 0x9fb49
movzbl (%rcx,%rsi), %ecx
cmpb $-0x41, %al
ja 0x9fb2c
shll $0x8, %eax
addq $0x2, %r12
addl %ecx, %eax
addl $0xffff8080, %eax # imm = 0xFFFF8080
jmp 0x9fb46
shll $0x10, %eax
shll $0x8, %ecx
movzbl 0x2(%r12,%rsi), %edx
addq $0x3, %r12
orl %eax, %edx
leal (%rcx,%rdx), %eax
addl $0xff404080, %eax # imm = 0xFF404080
movq %r12, %rcx
leal (%rax,%r13), %edx
incl %edx
movzbl (%rcx,%rsi), %r14d
movq %rcx, %r12
incq %r12
cmpl $0x18, %r10d
je 0x9fb6a
cmpl $0x39, %r10d
jne 0x9fbf7
testq %r14, %r14
je 0x9fbe5
leal 0x2(%r15), %ebp
cmpl %edi, %ebp
jle 0x9fbd7
movq %r14, 0x70(%rsp)
movq %rbx, %rsi
movl %edx, %r14d
leal (%rdi,%rdi,2), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, %ebp
cmovgl %ebp, %ecx
movq %rcx, %rbx
movslq %ecx, %rdx
shlq $0x2, %rdx
movq 0x28(%rsp), %rdi
movq %rsi, 0x8(%rsp)
callq *0x20(%rsp)
movl 0x4(%rsp), %ecx
testq %rax, %rax
je 0x9fccd
movq 0x68(%rsp), %r10
movl 0x14(%rsp), %r9d
leaq 0xd537(%rip), %rsi # 0xad100
movq %rbx, %rdi
movl %r14d, %edx
movq %rax, %rbx
movq 0x70(%rsp), %r14
movslq %r15d, %rax
movl %r13d, (%rbx,%rax,4)
movl %edx, 0x4(%rbx,%rax,4)
movl %ebp, %r15d
addq %r14, %r12
cmpq $0x4e5, %r12 # imm = 0x4E5
jl 0x9fb03
jmp 0x9fc19
testq %r14, %r14
je 0x9fbe5
xorl %eax, %eax
leaq (%r12,%rax), %rcx
movzbl (%rsi,%rcx), %ecx
cmpl %ecx, %r9d
je 0x9fb6f
incq %rax
cmpq %rax, %r14
jne 0x9fbfe
jmp 0x9fbe5
movl %edi, 0x34(%rsp)
movq %rbx, 0x38(%rsp)
movl %r15d, 0x30(%rsp)
cmpl $0x39, %r10d
je 0x9fc33
cmpl $0x18, %r10d
jne 0x9fc54
leaq 0x30(%rsp), %rdi
callq 0x9f213
testl %eax, %eax
je 0x9fc84
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x9fcb5
xorl %ebx, %ebx
jmp 0x9fd4c
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movl (%rax), %edx
movq 0x78(%rsp), %rdi
movq %rbx, %rcx
movl %r15d, %r8d
xorl %r9d, %r9d
callq 0x9f009
testl %eax, %eax
movl 0x4(%rsp), %ecx
movq %rbx, 0x8(%rsp)
jne 0x9fccd
jmp 0x9fd20
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movl (%rax), %edx
movq 0x38(%rsp), %rcx
movl 0x30(%rsp), %r8d
movq 0x78(%rsp), %rdi
movq %rcx, %rbp
movl $0x1, %r9d
callq 0x9f009
testl %eax, %eax
movq %rbp, 0x8(%rsp)
je 0x9fd0c
movl 0x4(%rsp), %ecx
jmp 0x9fccd
movq %rbp, 0x18(%rsp)
movl 0x4(%rsp), %ecx
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rbx
movq 0x58(%rsp), %r15
movq 0x8(%rsp), %rbp
movq 0x60(%rsp), %r14
movq 0x40(%rsp), %r12
movq 0x48(%rsp), %r13
testl %ecx, %ecx
je 0x9fceb
movq (%r15), %rdi
movq 0x8(%rbx), %rsi
xorl %edx, %edx
callq *(%r14)
movq %r12, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq *%r13
movl 0x4(%rsp), %ecx
jmp 0x9fceb
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
xorl %ebx, %ebx
xorl %edx, %edx
movq 0x60(%rsp), %rax
callq *(%rax)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq *0x20(%rsp)
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| unicode_script:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov ebx, edx
mov r12, rdi
xorps xmm0, xmm0
movaps [rsp+0D8h+var_48], xmm0
movaps [rsp+0D8h+var_58], xmm0
movaps [rsp+0D8h+var_98], xmm0
movaps [rsp+0D8h+var_A8], xmm0
lea rdi, unicode_script_name_table; "Adlam,Adlm"
call unicode_find_name
test eax, eax
js short loc_9F9D6
mov r10d, eax
lea rax, [r12+18h]
lea r15, [r12+10h]
test ebx, ebx
mov [rsp+0D8h+var_60], r12
jz short loc_9F9E0
mov rsi, [r15]
lea rdx, [rsp+0D8h+var_48]
mov rax, [rax]
lea rcx, [rsp+0D8h+var_48+8]
xorps xmm0, xmm0
movaps xmmword ptr [rcx-18h], xmm0
test rax, rax
lea rdi, cr_default_realloc
cmovnz rdi, rax
mov [rcx-8], rsi
mov [rcx], rdi
movaps [rsp+0D8h+var_A8], xmm0
mov [rsp+0D8h+var_B0], rsi
mov qword ptr [rsp+0D8h+var_98], rsi
mov [rsp+0D8h+var_B8], rdi
mov qword ptr [rsp+0D8h+var_98+8], rdi
lea rbp, [rsp+0D8h+var_58]
mov [rsp+0D8h+var_78], rcx
mov [rsp+0D8h+var_80], rdx
jmp short loc_9F9FF
loc_9F9D6:
mov ebx, 0FFFFFFFEh
jmp loc_9FD4C
loc_9F9E0:
mov [rsp+0D8h+var_80], r15
mov [rsp+0D8h+var_78], rax
mov [rsp+0D8h+var_B0], 0
mov [rsp+0D8h+var_B8], 0
mov rbp, r12
loc_9F9FF:
lea r9d, [r10+1]
lea r14, unicode_script_table
xor ecx, ecx
xor r15d, r15d
mov [rsp+0D8h+var_D4], ebx
mov [rsp+0D8h+var_70], r10
mov [rsp+0D8h+var_C4], r9d
loc_9FA1D:
lea r12, [rcx+1]
movzx edx, byte ptr [rcx+r14]
mov eax, edx
and eax, 7Fh
cmp al, 60h ; '`'
jb short loc_9FA65
movzx esi, byte ptr [r12+r14]
cmp al, 6Fh ; 'o'
ja short loc_9FA48
shl eax, 8
add rcx, 2
add eax, esi
add eax, 0FFFFA060h
jmp short loc_9FA62
loc_9FA48:
shl eax, 10h
shl esi, 8
movzx edi, byte ptr [rcx+r14+2]
add rcx, 3
or edi, eax
lea eax, [rsi+rdi]
add eax, 0FF901060h
loc_9FA62:
mov r12, rcx
loc_9FA65:
test dl, dl
js short loc_9FA72
lea r13d, [r15+rax]
inc r13d
jmp short loc_9FAD0
loc_9FA72:
movzx ecx, byte ptr [r12+r14]
inc r12
lea r13d, [r15+rax]
inc r13d
cmp r9d, ecx
jnz short loc_9FAD0
mov eax, [rbp+0]
lea esi, [rax+2]
cmp esi, [rbp+4]
jle short loc_9FAB2
mov rdi, rbp
call cr_realloc
test eax, eax
jnz loc_9FCBB
mov eax, [rbp+0]
mov ebx, [rsp+0D8h+var_D4]
mov r10, [rsp+0D8h+var_70]
mov r9d, [rsp+0D8h+var_C4]
loc_9FAB2:
mov rcx, [rbp+8]
lea edx, [rax+1]
mov [rbp+0], edx
cdqe
mov [rcx+rax*4], r15d
movsxd rax, dword ptr [rbp+0]
lea edx, [rax+1]
mov [rbp+0], edx
mov [rcx+rax*4], r13d
loc_9FAD0:
mov rcx, r12
mov r15d, r13d
cmp r12, 0AF3h
jl loc_9FA1D
test ebx, ebx
jz loc_9FC4D
mov [rsp+0D8h+var_C0], rbp
xor ebx, ebx
lea rsi, unicode_script_ext_table
xor edi, edi
xor r12d, r12d
xor edx, edx
xor r15d, r15d
loc_9FB03:
mov r13d, edx
lea rcx, [r12+1]
movzx eax, byte ptr [r12+rsi]
test al, al
jns short loc_9FB49
movzx ecx, byte ptr [rcx+rsi]
cmp al, 0BFh
ja short loc_9FB2C
shl eax, 8
add r12, 2
add eax, ecx
add eax, 0FFFF8080h
jmp short loc_9FB46
loc_9FB2C:
shl eax, 10h
shl ecx, 8
movzx edx, byte ptr [r12+rsi+2]
add r12, 3
or edx, eax
lea eax, [rcx+rdx]
add eax, 0FF404080h
loc_9FB46:
mov rcx, r12
loc_9FB49:
lea edx, [rax+r13]
inc edx
movzx r14d, byte ptr [rcx+rsi]
mov r12, rcx
inc r12
cmp r10d, 18h
jz short loc_9FB6A
cmp r10d, 39h ; '9'
jnz loc_9FBF7
loc_9FB6A:
test r14, r14
jz short loc_9FBE5
loc_9FB6F:
lea ebp, [r15+2]
cmp ebp, edi
jle short loc_9FBD7
mov [rsp+0D8h+var_68], r14
mov rsi, rbx
mov r14d, edx
lea eax, [rdi+rdi*2]
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
cmp ebp, ecx
cmovg ecx, ebp
mov rbx, rcx
movsxd rdx, ecx
shl rdx, 2
mov rdi, [rsp+0D8h+var_B0]
mov [rsp+0D8h+var_D0], rsi
call [rsp+0D8h+var_B8]
mov ecx, [rsp+0D8h+var_D4]
test rax, rax
jz loc_9FCCD
mov r10, [rsp+0D8h+var_70]
mov r9d, [rsp+0D8h+var_C4]
lea rsi, unicode_script_ext_table
mov rdi, rbx
mov edx, r14d
mov rbx, rax
mov r14, [rsp+0D8h+var_68]
loc_9FBD7:
movsxd rax, r15d
mov [rbx+rax*4], r13d
mov [rbx+rax*4+4], edx
mov r15d, ebp
loc_9FBE5:
add r12, r14
cmp r12, 4E5h
jl loc_9FB03
jmp short loc_9FC19
loc_9FBF7:
test r14, r14
jz short loc_9FBE5
xor eax, eax
loc_9FBFE:
lea rcx, [r12+rax]
movzx ecx, byte ptr [rsi+rcx]
cmp r9d, ecx
jz loc_9FB6F
inc rax
cmp r14, rax
jnz short loc_9FBFE
jmp short loc_9FBE5
loc_9FC19:
mov dword ptr [rsp+0D8h+var_A8+4], edi
mov qword ptr [rsp+0D8h+var_A8+8], rbx
mov dword ptr [rsp+0D8h+var_A8], r15d
cmp r10d, 39h ; '9'
jz short loc_9FC33
cmp r10d, 18h
jnz short loc_9FC54
loc_9FC33:
lea rdi, [rsp+0D8h+var_A8]
call cr_invert
test eax, eax
jz short loc_9FC84
mov rax, qword ptr [rsp+0D8h+var_A8+8]
mov [rsp+0D8h+var_D0], rax
jmp short loc_9FCB5
loc_9FC4D:
xor ebx, ebx
jmp loc_9FD4C
loc_9FC54:
mov rax, [rsp+0D8h+var_C0]
mov rsi, [rax+8]
mov edx, [rax]
mov rdi, [rsp+0D8h+var_60]
mov rcx, rbx
mov r8d, r15d
xor r9d, r9d
call cr_op
test eax, eax
mov ecx, [rsp+0D8h+var_D4]
mov [rsp+0D8h+var_D0], rbx
jnz short loc_9FCCD
jmp loc_9FD20
loc_9FC84:
mov rax, [rsp+0D8h+var_C0]
mov rsi, [rax+8]
mov edx, [rax]
mov rcx, qword ptr [rsp+0D8h+var_A8+8]
mov r8d, dword ptr [rsp+0D8h+var_A8]
mov rdi, [rsp+0D8h+var_60]
mov rbp, rcx
mov r9d, 1
call cr_op
test eax, eax
mov [rsp+0D8h+var_D0], rbp
jz short loc_9FD0C
loc_9FCB5:
mov ecx, [rsp+0D8h+var_D4]
jmp short loc_9FCCD
loc_9FCBB:
mov [rsp+0D8h+var_C0], rbp
mov ecx, [rsp+0D8h+var_D4]
mov [rsp+0D8h+var_D0], 0
loc_9FCCD:
mov rbx, [rsp+0D8h+var_C0]
mov r15, [rsp+0D8h+var_80]
mov rbp, [rsp+0D8h+var_D0]
mov r14, [rsp+0D8h+var_78]
mov r12, qword ptr [rsp+0D8h+var_98]
mov r13, qword ptr [rsp+0D8h+var_98+8]
loc_9FCEB:
test ecx, ecx
jz short loc_9FCEB
mov rdi, [r15]
mov rsi, [rbx+8]
xor edx, edx
call qword ptr [r14]
mov rdi, r12
mov rsi, rbp
xor edx, edx
call r13
mov ecx, [rsp+0D8h+var_D4]
jmp short loc_9FCEB
loc_9FD0C:
mov rax, qword ptr [rsp+0D8h+var_98]
mov [rsp+0D8h+var_B0], rax
mov rax, qword ptr [rsp+0D8h+var_98+8]
mov [rsp+0D8h+var_B8], rax
loc_9FD20:
mov rax, [rsp+0D8h+var_80]
mov rdi, [rax]
mov rax, [rsp+0D8h+var_C0]
mov rsi, [rax+8]
xor ebx, ebx
xor edx, edx
mov rax, [rsp+0D8h+var_78]
call qword ptr [rax]
mov rdi, [rsp+0D8h+var_B0]
mov rsi, [rsp+0D8h+var_D0]
xor edx, edx
call [rsp+0D8h+var_B8]
loc_9FD4C:
mov eax, ebx
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long unicode_script(int *a1, long long a2, unsigned int a3)
{
int name; // eax
long long v5; // r10
long long v6; // rsi
long long ( *v7)(long long, long long, long long); // rax
long long ( *v8)(long long, long long, long long); // rdi
__int128 *v9; // rbp
unsigned int v10; // ebx
int v11; // r9d
long long v12; // rcx
int v13; // r15d
long long v14; // r12
char v15; // dl
int v16; // eax
int v17; // esi
long long v18; // rcx
int v19; // edi
int v20; // r13d
int v21; // ecx
int v22; // eax
int v23; // esi
long long v24; // rcx
long long v25; // rax
long long v26; // rbx
int v27; // edi
long long v28; // r12
int v29; // edx
int v30; // r15d
int v31; // r13d
long long v32; // rcx
int v33; // eax
int v34; // ecx
long long v35; // r12
int v36; // edx
long long v37; // r14
long long v38; // r12
long long v39; // rsi
int v40; // r14d
int v41; // ecx
int v42; // ebx
long long v43; // rax
long long v44; // rcx
long long v45; // rax
int v46; // eax
_QWORD *v47; // r15
void ( **v48)(_QWORD, _QWORD, _QWORD); // r14
__int128 v49; // kr00_16
unsigned int v51; // [rsp+4h] [rbp-D4h]
long long v52; // [rsp+8h] [rbp-D0h]
int v53; // [rsp+14h] [rbp-C4h]
__int128 *v54; // [rsp+18h] [rbp-C0h]
long long ( *v55)(long long, long long, long long); // [rsp+20h] [rbp-B8h]
long long v56; // [rsp+28h] [rbp-B0h]
__int128 v57; // [rsp+30h] [rbp-A8h] BYREF
__int128 v58; // [rsp+40h] [rbp-98h]
_QWORD *v59; // [rsp+58h] [rbp-80h]
char *v60; // [rsp+60h] [rbp-78h]
long long v61; // [rsp+68h] [rbp-70h]
long long v62; // [rsp+70h] [rbp-68h]
const char *v63; // [rsp+78h] [rbp-60h]
__int128 v64; // [rsp+80h] [rbp-58h] BYREF
_OWORD v65[4]; // [rsp+90h] [rbp-48h] BYREF
v65[0] = 0LL;
v64 = 0LL;
v58 = 0LL;
v57 = 0LL;
name = unicode_find_name("Adlam,Adlm");
if ( name < 0 )
return (unsigned int)-2;
v5 = (unsigned int)name;
v63 = (const char *)a1;
if ( a3 )
{
v6 = *((_QWORD *)a1 + 2);
v7 = (long long ( *)(long long, long long, long long))*((_QWORD *)a1 + 3);
v64 = 0LL;
v8 = cr_default_realloc;
if ( v7 )
v8 = v7;
*(_QWORD *)&v65[0] = v6;
*((_QWORD *)&v65[0] + 1) = v8;
v57 = 0LL;
v56 = v6;
*(_QWORD *)&v58 = v6;
v55 = v8;
*((_QWORD *)&v58 + 1) = v8;
v9 = &v64;
v60 = (char *)v65 + 8;
v59 = v65;
}
else
{
v59 = a1 + 4;
v60 = (char *)(a1 + 6);
v56 = 0LL;
v55 = 0LL;
v9 = (__int128 *)a1;
}
v11 = v5 + 1;
v12 = 0LL;
v13 = 0;
v51 = a3;
v61 = v5;
v53 = v5 + 1;
do
{
v14 = v12 + 1;
v15 = unicode_script_table[v12];
v16 = v15 & 0x7F;
if ( (unsigned __int8)v16 >= 0x60u )
{
v17 = unicode_script_table[v14];
if ( (unsigned __int8)v16 > 0x6Fu )
{
v19 = unicode_script_table[v12 + 2];
v18 = v12 + 3;
v16 = (v17 << 8) + ((v16 << 16) | v19) - 7335840;
}
else
{
v18 = v12 + 2;
v16 = v17 + (v16 << 8) - 24480;
}
v14 = v18;
}
if ( v15 < 0 )
{
v21 = unicode_script_table[v14++];
v20 = v13 + v16 + 1;
if ( v11 == v21 )
{
v22 = *(_DWORD *)v9;
v23 = *(_DWORD *)v9 + 2;
if ( v23 > *((_DWORD *)v9 + 1) )
{
if ( (unsigned int)cr_realloc((long long)v9, v23) )
{
v54 = v9;
LODWORD(v44) = v51;
v52 = 0LL;
goto LABEL_55;
}
v22 = *(_DWORD *)v9;
a3 = v51;
LODWORD(v5) = v61;
v11 = v53;
}
v24 = *((_QWORD *)v9 + 1);
*(_DWORD *)v9 = v22 + 1;
*(_DWORD *)(v24 + 4LL * v22) = v13;
v25 = *(int *)v9;
*(_DWORD *)v9 = v25 + 1;
*(_DWORD *)(v24 + 4 * v25) = v20;
}
}
else
{
v20 = v13 + v16 + 1;
}
v12 = v14;
v13 = v20;
}
while ( v14 < 2803 );
if ( !a3 )
return 0;
v54 = v9;
v26 = 0LL;
v27 = 0;
v28 = 0LL;
v29 = 0;
v30 = 0;
do
{
v31 = v29;
v32 = v28 + 1;
v33 = unicode_script_ext_table[v28];
if ( (v33 & 0x80u) != 0 )
{
v34 = unicode_script_ext_table[v32];
if ( (unsigned __int8)v33 > 0xBFu )
{
v36 = unicode_script_ext_table[v28 + 2];
v35 = v28 + 3;
v33 = (v34 << 8) + ((v33 << 16) | v36) - 12566400;
}
else
{
v35 = v28 + 2;
v33 = v34 + (v33 << 8) - 32640;
}
v32 = v35;
}
v29 = v33 + v31 + 1;
v37 = unicode_script_ext_table[v32];
v38 = v32 + 1;
if ( (_DWORD)v5 == 24 || (_DWORD)v5 == 57 )
{
if ( !unicode_script_ext_table[v32] )
goto LABEL_38;
}
else
{
if ( !unicode_script_ext_table[v32] )
goto LABEL_38;
v45 = 0LL;
while ( v11 != unicode_script_ext_table[v38 + v45] )
{
if ( v37 == ++v45 )
goto LABEL_38;
}
}
if ( v30 + 2 > v27 )
{
v62 = unicode_script_ext_table[v32];
v39 = v26;
v40 = v29;
v41 = 3 * v27 / 2;
if ( v30 + 2 > v41 )
v41 = v30 + 2;
v42 = v41;
v52 = v39;
v43 = v55(v56, v39, 4LL * v41);
LODWORD(v44) = v51;
if ( !v43 )
goto LABEL_55;
LODWORD(v5) = v61;
v11 = v53;
v27 = v42;
v29 = v40;
v26 = v43;
v37 = v62;
}
*(_DWORD *)(v26 + 4LL * v30) = v31;
*(_DWORD *)(v26 + 4LL * v30 + 4) = v29;
v30 += 2;
LABEL_38:
v28 = v37 + v38;
}
while ( v28 < 1253 );
*((_QWORD *)&v57 + 1) = v26;
*(_QWORD *)&v57 = __PAIR64__(v27, v30);
if ( (_DWORD)v5 == 57 || (_DWORD)v5 == 24 )
{
if ( (unsigned int)cr_invert((int *)&v57) )
{
v52 = *((_QWORD *)&v57 + 1);
goto LABEL_53;
}
v52 = *((_QWORD *)&v57 + 1);
if ( (unsigned int)cr_op(v63, *((_QWORD *)v9 + 1), *(_DWORD *)v9, *((long long *)&v57 + 1), v57, 1) )
{
LABEL_53:
LODWORD(v44) = v51;
goto LABEL_55;
}
v55 = (long long ( *)(long long, long long, long long))*((_QWORD *)&v58 + 1);
v56 = v58;
}
else
{
v46 = cr_op(v63, *((_QWORD *)v9 + 1), *(_DWORD *)v9, v26, v30, 0);
v44 = v51;
v52 = v26;
if ( v46 )
{
LABEL_55:
v47 = v59;
v48 = (void ( **)(_QWORD, _QWORD, _QWORD))v60;
v49 = v58;
while ( 1 )
{
while ( !(_DWORD)v44 )
;
(*v48)(*v47, *((_QWORD *)v54 + 1), 0LL);
(*((void ( **)(_QWORD, long long, _QWORD))&v49 + 1))(v49, v52, 0LL);
LODWORD(v44) = v51;
}
}
}
v10 = 0;
(*(void ( **)(_QWORD, _QWORD, _QWORD, long long))v60)(*v59, *((_QWORD *)v9 + 1), 0LL, v44);
v55(v56, v52, 0LL);
return v10;
}
| unicode_script:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV EBX,EDX
MOV R12,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
LEA RDI,[0x1abc50]
CALL 0x0019fd60
TEST EAX,EAX
JS 0x0019f9d6
MOV R10D,EAX
LEA RAX,[R12 + 0x18]
LEA R15,[R12 + 0x10]
TEST EBX,EBX
MOV qword ptr [RSP + 0x78],R12
JZ 0x0019f9e0
MOV RSI,qword ptr [R15]
LEA RDX,[RSP + 0x90]
MOV RAX,qword ptr [RAX]
LEA RCX,[RSP + 0x98]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RCX + -0x18],XMM0
TEST RAX,RAX
LEA RDI,[0x19ef60]
CMOVNZ RDI,RAX
MOV qword ptr [RCX + -0x8],RSI
MOV qword ptr [RCX],RDI
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x40],RSI
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x48],RDI
LEA RBP,[RSP + 0x80]
MOV qword ptr [RSP + 0x60],RCX
MOV qword ptr [RSP + 0x58],RDX
JMP 0x0019f9ff
LAB_0019f9d6:
MOV EBX,0xfffffffe
JMP 0x0019fd4c
LAB_0019f9e0:
MOV qword ptr [RSP + 0x58],R15
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x20],0x0
MOV RBP,R12
LAB_0019f9ff:
LEA R9D,[R10 + 0x1]
LEA R14,[0x1ac600]
XOR ECX,ECX
XOR R15D,R15D
MOV dword ptr [RSP + 0x4],EBX
MOV qword ptr [RSP + 0x68],R10
MOV dword ptr [RSP + 0x14],R9D
LAB_0019fa1d:
LEA R12,[RCX + 0x1]
MOVZX EDX,byte ptr [RCX + R14*0x1]
MOV EAX,EDX
AND EAX,0x7f
CMP AL,0x60
JC 0x0019fa65
MOVZX ESI,byte ptr [R12 + R14*0x1]
CMP AL,0x6f
JA 0x0019fa48
SHL EAX,0x8
ADD RCX,0x2
ADD EAX,ESI
ADD EAX,0xffffa060
JMP 0x0019fa62
LAB_0019fa48:
SHL EAX,0x10
SHL ESI,0x8
MOVZX EDI,byte ptr [RCX + R14*0x1 + 0x2]
ADD RCX,0x3
OR EDI,EAX
LEA EAX,[RSI + RDI*0x1]
ADD EAX,0xff901060
LAB_0019fa62:
MOV R12,RCX
LAB_0019fa65:
TEST DL,DL
JS 0x0019fa72
LEA R13D,[R15 + RAX*0x1]
INC R13D
JMP 0x0019fad0
LAB_0019fa72:
MOVZX ECX,byte ptr [R12 + R14*0x1]
INC R12
LEA R13D,[R15 + RAX*0x1]
INC R13D
CMP R9D,ECX
JNZ 0x0019fad0
MOV EAX,dword ptr [RBP]
LEA ESI,[RAX + 0x2]
CMP ESI,dword ptr [RBP + 0x4]
JLE 0x0019fab2
MOV RDI,RBP
CALL 0x0019ef7b
TEST EAX,EAX
JNZ 0x0019fcbb
MOV EAX,dword ptr [RBP]
MOV EBX,dword ptr [RSP + 0x4]
MOV R10,qword ptr [RSP + 0x68]
MOV R9D,dword ptr [RSP + 0x14]
LAB_0019fab2:
MOV RCX,qword ptr [RBP + 0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP],EDX
CDQE
MOV dword ptr [RCX + RAX*0x4],R15D
MOVSXD RAX,dword ptr [RBP]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP],EDX
MOV dword ptr [RCX + RAX*0x4],R13D
LAB_0019fad0:
MOV RCX,R12
MOV R15D,R13D
CMP R12,0xaf3
JL 0x0019fa1d
TEST EBX,EBX
JZ 0x0019fc4d
MOV qword ptr [RSP + 0x18],RBP
XOR EBX,EBX
LEA RSI,[0x1ad100]
XOR EDI,EDI
XOR R12D,R12D
XOR EDX,EDX
XOR R15D,R15D
LAB_0019fb03:
MOV R13D,EDX
LEA RCX,[R12 + 0x1]
MOVZX EAX,byte ptr [R12 + RSI*0x1]
TEST AL,AL
JNS 0x0019fb49
MOVZX ECX,byte ptr [RCX + RSI*0x1]
CMP AL,0xbf
JA 0x0019fb2c
SHL EAX,0x8
ADD R12,0x2
ADD EAX,ECX
ADD EAX,0xffff8080
JMP 0x0019fb46
LAB_0019fb2c:
SHL EAX,0x10
SHL ECX,0x8
MOVZX EDX,byte ptr [R12 + RSI*0x1 + 0x2]
ADD R12,0x3
OR EDX,EAX
LEA EAX,[RCX + RDX*0x1]
ADD EAX,0xff404080
LAB_0019fb46:
MOV RCX,R12
LAB_0019fb49:
LEA EDX,[RAX + R13*0x1]
INC EDX
MOVZX R14D,byte ptr [RCX + RSI*0x1]
MOV R12,RCX
INC R12
CMP R10D,0x18
JZ 0x0019fb6a
CMP R10D,0x39
JNZ 0x0019fbf7
LAB_0019fb6a:
TEST R14,R14
JZ 0x0019fbe5
LAB_0019fb6f:
LEA EBP,[R15 + 0x2]
CMP EBP,EDI
JLE 0x0019fbd7
MOV qword ptr [RSP + 0x70],R14
MOV RSI,RBX
MOV R14D,EDX
LEA EAX,[RDI + RDI*0x2]
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
CMP EBP,ECX
CMOVG ECX,EBP
MOV RBX,RCX
MOVSXD RDX,ECX
SHL RDX,0x2
MOV RDI,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RSI
CALL qword ptr [RSP + 0x20]
MOV ECX,dword ptr [RSP + 0x4]
TEST RAX,RAX
JZ 0x0019fccd
MOV R10,qword ptr [RSP + 0x68]
MOV R9D,dword ptr [RSP + 0x14]
LEA RSI,[0x1ad100]
MOV RDI,RBX
MOV EDX,R14D
MOV RBX,RAX
MOV R14,qword ptr [RSP + 0x70]
LAB_0019fbd7:
MOVSXD RAX,R15D
MOV dword ptr [RBX + RAX*0x4],R13D
MOV dword ptr [RBX + RAX*0x4 + 0x4],EDX
MOV R15D,EBP
LAB_0019fbe5:
ADD R12,R14
CMP R12,0x4e5
JL 0x0019fb03
JMP 0x0019fc19
LAB_0019fbf7:
TEST R14,R14
JZ 0x0019fbe5
XOR EAX,EAX
LAB_0019fbfe:
LEA RCX,[R12 + RAX*0x1]
MOVZX ECX,byte ptr [RSI + RCX*0x1]
CMP R9D,ECX
JZ 0x0019fb6f
INC RAX
CMP R14,RAX
JNZ 0x0019fbfe
JMP 0x0019fbe5
LAB_0019fc19:
MOV dword ptr [RSP + 0x34],EDI
MOV qword ptr [RSP + 0x38],RBX
MOV dword ptr [RSP + 0x30],R15D
CMP R10D,0x39
JZ 0x0019fc33
CMP R10D,0x18
JNZ 0x0019fc54
LAB_0019fc33:
LEA RDI,[RSP + 0x30]
CALL 0x0019f213
TEST EAX,EAX
JZ 0x0019fc84
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0019fcb5
LAB_0019fc4d:
XOR EBX,EBX
JMP 0x0019fd4c
LAB_0019fc54:
MOV RAX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX + 0x8]
MOV EDX,dword ptr [RAX]
MOV RDI,qword ptr [RSP + 0x78]
MOV RCX,RBX
MOV R8D,R15D
XOR R9D,R9D
CALL 0x0019f009
TEST EAX,EAX
MOV ECX,dword ptr [RSP + 0x4]
MOV qword ptr [RSP + 0x8],RBX
JNZ 0x0019fccd
JMP 0x0019fd20
LAB_0019fc84:
MOV RAX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX + 0x8]
MOV EDX,dword ptr [RAX]
MOV RCX,qword ptr [RSP + 0x38]
MOV R8D,dword ptr [RSP + 0x30]
MOV RDI,qword ptr [RSP + 0x78]
MOV RBP,RCX
MOV R9D,0x1
CALL 0x0019f009
TEST EAX,EAX
MOV qword ptr [RSP + 0x8],RBP
JZ 0x0019fd0c
LAB_0019fcb5:
MOV ECX,dword ptr [RSP + 0x4]
JMP 0x0019fccd
LAB_0019fcbb:
MOV qword ptr [RSP + 0x18],RBP
MOV ECX,dword ptr [RSP + 0x4]
MOV qword ptr [RSP + 0x8],0x0
LAB_0019fccd:
MOV RBX,qword ptr [RSP + 0x18]
MOV R15,qword ptr [RSP + 0x58]
MOV RBP,qword ptr [RSP + 0x8]
MOV R14,qword ptr [RSP + 0x60]
MOV R12,qword ptr [RSP + 0x40]
MOV R13,qword ptr [RSP + 0x48]
LAB_0019fceb:
TEST ECX,ECX
JZ 0x0019fceb
MOV RDI,qword ptr [R15]
MOV RSI,qword ptr [RBX + 0x8]
XOR EDX,EDX
CALL qword ptr [R14]
MOV RDI,R12
MOV RSI,RBP
XOR EDX,EDX
CALL R13
MOV ECX,dword ptr [RSP + 0x4]
JMP 0x0019fceb
LAB_0019fd0c:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x20],RAX
LAB_0019fd20:
MOV RAX,qword ptr [RSP + 0x58]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX + 0x8]
XOR EBX,EBX
XOR EDX,EDX
MOV RAX,qword ptr [RSP + 0x60]
CALL qword ptr [RAX]
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x8]
XOR EDX,EDX
CALL qword ptr [RSP + 0x20]
LAB_0019fd4c:
MOV EAX,EBX
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 unicode_script(int *param_1,int8 param_2,int param_3)
{
int iVar1;
byte *pbVar2;
byte bVar3;
code *pcVar4;
code **ppcVar5;
int *piVar6;
int8 uVar7;
uint uVar8;
uint uVar9;
int iVar10;
long lVar11;
ulong uVar12;
int iVar13;
int iVar14;
int *piVar15;
ulong uVar16;
long lVar17;
ulong uVar18;
int iVar19;
long local_d0;
code *local_b8;
int8 local_b0;
int8 local_a8;
long lStack_a0;
int8 local_98;
code *pcStack_90;
int *local_80;
code **local_78;
ulong local_70;
ulong local_68;
int *local_60;
int local_58 [4];
int8 local_48;
code *apcStack_40 [2];
local_48 = 0;
apcStack_40[0] = (code *)0x0;
local_58[0] = 0;
local_58[1] = 0;
local_58[2] = 0;
local_58[3] = 0;
local_98 = 0;
pcStack_90 = (code *)0x0;
local_a8 = 0;
lStack_a0 = 0;
uVar8 = unicode_find_name();
if ((int)uVar8 < 0) {
return 0xfffffffe;
}
uVar16 = (ulong)uVar8;
local_78 = (code **)(param_1 + 6);
local_80 = param_1 + 4;
if (param_3 == 0) {
local_b0 = 0;
local_b8 = (code *)0x0;
piVar15 = param_1;
}
else {
local_b0 = *(int8 *)local_80;
local_80 = (int *)&local_48;
pcVar4 = *local_78;
local_78 = apcStack_40;
local_58[0] = 0;
local_58[1] = 0;
local_58[2] = 0;
local_58[3] = 0;
local_b8 = cr_default_realloc;
if (pcVar4 != (code *)0x0) {
local_b8 = pcVar4;
}
local_48 = local_b0;
apcStack_40[0] = local_b8;
local_a8 = 0;
lStack_a0 = 0;
piVar15 = local_58;
local_98 = local_b0;
pcStack_90 = local_b8;
}
lVar11 = 0;
iVar13 = 0;
local_70 = uVar16;
local_60 = param_1;
do {
pbVar2 = &unicode_script_table + lVar11;
uVar9 = *pbVar2 & 0x7f;
lVar17 = lVar11 + 1;
if (0x5f < (byte)uVar9) {
if ((byte)uVar9 < 0x70) {
uVar9 = (uVar9 * 0x100 + (uint)(byte)(&DAT_001ac601)[lVar11]) - 0x5fa0;
lVar17 = lVar11 + 2;
}
else {
uVar9 = ((uint)(byte)(&DAT_001ac601)[lVar11] * 0x100 +
((uint)(byte)(&DAT_001ac602)[lVar11] | uVar9 << 0x10)) - 0x6fefa0;
lVar17 = lVar11 + 3;
}
}
lVar11 = lVar17;
if ((char)*pbVar2 < '\0') {
pbVar2 = &unicode_script_table + lVar11;
lVar11 = lVar11 + 1;
iVar19 = iVar13 + uVar9 + 1;
if (uVar8 + 1 == (uint)*pbVar2) {
iVar10 = *piVar15;
if (piVar15[1] < iVar10 + 2) {
iVar10 = cr_realloc();
if (iVar10 != 0) {
local_d0 = 0;
ppcVar5 = local_78;
piVar6 = local_80;
pcVar4 = pcStack_90;
uVar7 = local_98;
goto LAB_0019fceb;
}
iVar10 = *piVar15;
uVar16 = local_70;
}
lVar17 = *(long *)(piVar15 + 2);
*piVar15 = iVar10 + 1;
*(int *)(lVar17 + (long)iVar10 * 4) = iVar13;
iVar13 = *piVar15;
*piVar15 = iVar13 + 1;
*(int *)(lVar17 + (long)iVar13 * 4) = iVar19;
}
}
else {
iVar19 = iVar13 + uVar9 + 1;
}
iVar13 = iVar19;
} while (lVar11 < 0xaf3);
if (param_3 == 0) {
return 0;
}
local_d0 = 0;
iVar13 = 0;
lVar11 = 0;
iVar19 = 0;
iVar10 = 0;
do {
lVar17 = lVar11 + 1;
bVar3 = (&unicode_script_ext_table)[lVar11];
uVar9 = (uint)bVar3;
if ((char)bVar3 < '\0') {
if (bVar3 < 0xc0) {
lVar17 = lVar11 + 2;
uVar9 = ((uint)bVar3 * 0x100 + (uint)(byte)(&DAT_001ad101)[lVar11]) - 0x7f80;
}
else {
lVar17 = lVar11 + 3;
uVar9 = ((uint)(byte)(&DAT_001ad101)[lVar11] * 0x100 +
((uint)(byte)(&DAT_001ad102)[lVar11] | (uint)bVar3 << 0x10)) - 0xbfbf80;
}
}
iVar14 = uVar9 + iVar10 + 1;
uVar18 = (ulong)(byte)(&unicode_script_ext_table)[lVar17];
if (((int)uVar16 == 0x18) || ((int)uVar16 == 0x39)) {
if (uVar18 != 0) {
LAB_0019fb6f:
iVar1 = iVar19 + 2;
lVar11 = local_d0;
if (iVar13 < iVar1) {
iVar13 = (iVar13 * 3) / 2;
if (iVar13 < iVar1) {
iVar13 = iVar1;
}
local_68 = uVar18;
lVar11 = (*local_b8)(local_b0,local_d0,(long)iVar13 << 2);
uVar16 = local_70;
uVar18 = local_68;
ppcVar5 = local_78;
piVar6 = local_80;
pcVar4 = pcStack_90;
uVar7 = local_98;
if (lVar11 == 0) goto LAB_0019fceb;
}
*(int *)(lVar11 + (long)iVar19 * 4) = iVar10;
*(int *)(lVar11 + 4 + (long)iVar19 * 4) = iVar14;
local_d0 = lVar11;
iVar19 = iVar1;
}
}
else if (uVar18 != 0) {
uVar12 = 0;
do {
if (uVar8 + 1 == (uint)(byte)(&unicode_script_ext_table)[lVar17 + 1 + uVar12])
goto LAB_0019fb6f;
uVar12 = uVar12 + 1;
} while (uVar18 != uVar12);
}
lVar11 = lVar17 + 1 + uVar18;
iVar10 = iVar14;
} while (lVar11 < 0x4e5);
local_a8 = CONCAT44(iVar13,iVar19);
lStack_a0 = local_d0;
if (((int)uVar16 == 0x39) || ((int)uVar16 == 0x18)) {
iVar13 = cr_invert(&local_a8);
local_d0 = lStack_a0;
if (iVar13 == 0) {
iVar13 = cr_op(local_60,*(int8 *)(piVar15 + 2),*piVar15,lStack_a0,local_a8 & 0xffffffff,
1);
if (iVar13 == 0) {
local_b0 = local_98;
local_b8 = pcStack_90;
goto LAB_0019fd20;
}
}
ppcVar5 = local_78;
piVar6 = local_80;
pcVar4 = pcStack_90;
uVar7 = local_98;
}
else {
iVar13 = cr_op(local_60,*(int8 *)(piVar15 + 2),*piVar15,local_d0,iVar19,0);
ppcVar5 = local_78;
piVar6 = local_80;
pcVar4 = pcStack_90;
uVar7 = local_98;
if (iVar13 == 0) {
LAB_0019fd20:
(**local_78)(*(int8 *)local_80,*(int8 *)(piVar15 + 2),0);
(*local_b8)(local_b0,local_d0,0);
return 0;
}
}
LAB_0019fceb:
do {
do {
} while (param_3 == 0);
(**ppcVar5)(*(int8 *)piVar6,*(int8 *)(piVar15 + 2),0);
(*pcVar4)(uVar7,local_d0,0);
} while( true );
}
| |
39,588 | mi_uint7korr | eloqsql/include/byte_order_generic_x86_64.h | static inline ulonglong mi_uint7korr(const void *p)
{
ulonglong a= *(uint32 *) p;
ulonglong b= *(uint16 *) (4 + (char *) p);
ulonglong c= *(6 + (uchar *) p);
ulonglong v= (a | (b << 32) | (c << 48)) << 8;
asm ("bswapq %0" : "=r" (v) : "0" (v));
return v;
} | O0 | c | mi_uint7korr:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %eax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x6(%rax), %eax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq $0x20, %rcx
orq %rcx, %rax
movq -0x20(%rbp), %rcx
shlq $0x30, %rcx
orq %rcx, %rax
shlq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
bswapq %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| mi_uint7korr_0:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov eax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
movzx eax, word ptr [rax+4]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+6]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rcx, [rbp+var_18]
shl rcx, 20h
or rax, rcx
mov rcx, [rbp+var_20]
shl rcx, 30h
or rax, rcx
shl rax, 8
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
bswap rax
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
pop rbp
retn
| unsigned long long mi_uint7korr_0(unsigned int *a1)
{
return _byteswap_uint64((((unsigned long long)*((unsigned __int8 *)a1 + 6) << 48) | ((unsigned long long)*((unsigned __int16 *)a1 + 2) << 32) | *a1) << 8);
}
| mi_uint7korr:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,word ptr [RAX + 0x4]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x6]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
SHL RCX,0x20
OR RAX,RCX
MOV RCX,qword ptr [RBP + -0x20]
SHL RCX,0x30
OR RAX,RCX
SHL RAX,0x8
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
BSWAP RAX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
POP RBP
RET
|
ulong mi_uint7korr(uint7 *param_1)
{
ulong uVar1;
uVar1 = (ulong)*param_1 << 8;
return uVar1 >> 0x38 | (uVar1 & 0xff000000000000) >> 0x28 | (uVar1 & 0xff0000000000) >> 0x18 |
(uVar1 & 0xff00000000) >> 8 | (uVar1 & 0xff000000) << 8 | (uVar1 & 0xff0000) << 0x18 |
(uVar1 & 0xff00) << 0x28;
}
| |
39,589 | YAML::Node::IsSequence() const | aimrt_mujoco_sim/_deps/yaml-cpp-src/include/yaml-cpp/node/node.h | bool IsSequence() const { return Type() == NodeType::Sequence; } | O3 | c | YAML::Node::IsSequence() const:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x9f1b2
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x9f1a8
movq (%rax), %rax
movq (%rax), %rcx
cmpl $0x3, 0x10(%rcx)
sete %al
andb (%rcx), %al
jmp 0x9f1aa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x40, %edi
callq 0x80f20
movq %rax, %rbx
addq $0x8, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x9b2ee
leaq 0x1fb0a3(%rip), %rsi # 0x29a278
leaq 0x76638(%rip), %rdx # 0x115814
movq %rbx, %rdi
callq 0x83970
movq %rax, %r14
movq %rbx, %rdi
callq 0x816f0
movq %r14, %rdi
callq 0x83b70
nop
| _ZNK4YAML4Node10IsSequenceEv:
push r14
push rbx
push rax
mov r14, rdi
cmp byte ptr [rdi], 0
jz short loc_9F1B2
mov rax, [r14+38h]
test rax, rax
jz short loc_9F1A8
mov rax, [rax]
mov rcx, [rax]
cmp dword ptr [rcx+10h], 3
setz al
and al, [rcx]
jmp short loc_9F1AA
loc_9F1A8:
xor eax, eax
loc_9F1AA:
add rsp, 8
pop rbx
pop r14
retn
loc_9F1B2:
mov edi, 40h ; '@'; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
add r14, 8
mov rdi, rax
mov rsi, r14
call _ZN4YAML11InvalidNodeC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; YAML::InvalidNode::InvalidNode(std::string const&)
lea rsi, _ZTIN4YAML11InvalidNodeE; lptinfo
lea rdx, _ZN4YAML9ExceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
| char YAML::Node::IsSequence(YAML::Node *this)
{
long long v1; // rax
void *exception; // rbx
int v4; // edx
int v5; // ecx
int v6; // r8d
int v7; // r9d
if ( !*(_BYTE *)this )
{
exception = __cxa_allocate_exception(0x40uLL);
YAML::InvalidNode::InvalidNode((_DWORD)exception, (_DWORD)this + 8, v4, v5, v6, v7);
__cxa_throw(exception, (struct type_info *)&`typeinfo for'YAML::InvalidNode, YAML::Exception::~Exception);
}
v1 = *((_QWORD *)this + 7);
if ( v1 )
return ***(_BYTE ***)v1 & (*(_DWORD *)(**(_QWORD **)v1 + 16LL) == 3);
else
return 0;
}
| IsSequence:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
CMP byte ptr [RDI],0x0
JZ 0x0019f1b2
MOV RAX,qword ptr [R14 + 0x38]
TEST RAX,RAX
JZ 0x0019f1a8
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX]
CMP dword ptr [RCX + 0x10],0x3
SETZ AL
AND AL,byte ptr [RCX]
JMP 0x0019f1aa
LAB_0019f1a8:
XOR EAX,EAX
LAB_0019f1aa:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0019f1b2:
MOV EDI,0x40
CALL 0x00180f20
MOV RBX,RAX
ADD R14,0x8
LAB_0019f1c3:
MOV RDI,RAX
MOV RSI,R14
CALL 0x0019b2ee
LAB_0019f1ce:
LEA RSI,[0x39a278]
LEA RDX,[0x215814]
MOV RDI,RBX
CALL 0x00183970
|
/* YAML::Node::IsSequence() const */
int8 __thiscall YAML::Node::IsSequence(Node *this)
{
int8 *puVar1;
byte *pbVar2;
int8 uVar3;
InvalidNode *this_00;
if (*this != (Node)0x0) {
if (*(int8 **)(this + 0x38) == (int8 *)0x0) {
uVar3 = 0;
}
else {
puVar1 = (int8 *)**(int8 **)(this + 0x38);
pbVar2 = (byte *)*puVar1;
uVar3 = CONCAT71((int7)((ulong)puVar1 >> 8),*(int *)(pbVar2 + 0x10) == 3 & *pbVar2);
}
return uVar3;
}
this_00 = (InvalidNode *)__cxa_allocate_exception(0x40);
/* try { // try from 0019f1c3 to 0019f1cd has its CatchHandler @ 0019f1e4 */
InvalidNode::InvalidNode(this_00,(string *)(this + 8));
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,&InvalidNode::typeinfo,BadInsert::~BadInsert);
}
| |
39,590 | apply_one_rule | eloqsql/strings/ctype-uca.c | static my_bool
apply_one_rule(MY_CHARSET_LOADER *loader,
MY_COLL_RULES *rules, MY_COLL_RULE *r,
MY_UCA_WEIGHT_LEVEL *dst)
{
size_t nweights;
size_t nreset= my_coll_rule_reset_length(r); /* Length of reset sequence */
size_t nshift= my_coll_rule_shift_length(r); /* Length of shift sequence */
uint16 *to;
my_bool rc;
if ((rules->shift_after_method == my_shift_method_expand && r->diff[0]) ||
r->before_level == 1)
{
/*
Suppose we have this rule: &B[before primary] < C
i.e. we need to put C before B, but after A, so
the result order is: A < C < B.
Let primary weight of B be [BBBB].
We cannot just use [BBBB-1] as weight for C:
DUCET does not have enough unused weights between any two characters,
so using [BBBB-1] will likely make C equal to the previous character,
which is A, so we'll get this order instead of the desired: A = C < B.
To guarantee that that C is sorted after A, we'll use expansion
with a kind of "biggest possible character".
As "biggest possible character" we'll use "last_non_ignorable":
We'll compose weight for C as: [BBBB-1][MMMM+1]
where [MMMM] is weight for "last_non_ignorable".
We also do the same trick for "reset after" if the collation
option says so. E.g. for the rules "&B < C", weight for
C will be calculated as: [BBBB][MMMM+1]
At this point we only need to store codepoints
'B' and 'last_non_ignorable'. Actual weights for 'C'
will be calculated according to the above formula later,
in create_tailoring().
*/
if (!my_coll_rule_expand(r->base, MY_UCA_MAX_EXPANSION,
rules->uca->last_non_ignorable))
{
my_charset_loader_error_for_rule(loader, r, "Expansion", r->base, nreset);
return TRUE;
}
nreset= my_coll_rule_reset_length(r);
}
if (nshift >= 2) /* Contraction */
{
MY_CONTRACTIONS *contractions= &dst->contractions;
to= my_uca_init_one_contraction(contractions,
r->curr, (uint)nshift, r->with_context);
/* Store weights of the "reset to" character */
dst->contractions.nitems--; /* Temporarily hide - it's incomplete */
rc= my_char_weight_put(dst,
to, MY_UCA_CONTRACTION_MAX_WEIGHT_SIZE, &nweights,
r->base, nreset);
dst->contractions.nitems++; /* Activate, now it's complete */
}
else
{
my_wc_t pagec= (r->curr[0] >> 8);
DBUG_ASSERT(dst->weights[pagec]);
to= my_char_weight_addr(dst, r->curr[0]);
/* Store weights of the "reset to" character */
rc= my_char_weight_put(dst, to, dst->lengths[pagec], &nweights, r->base, nreset);
}
if (rc)
{
my_charset_loader_error_for_rule(loader, r, "Expansion", r->base, nreset);
return rc;
}
/* Apply level difference. */
return apply_shift(loader, rules, r, dst->levelno, to, nweights);
} | O0 | c | apply_one_rule:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x496b0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x496d0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0x49089
movq -0x20(%rbp), %rax
cmpl $0x0, 0x80(%rax)
jne 0x49097
movq -0x20(%rbp), %rax
cmpq $0x1, 0x90(%rax)
jne 0x490e8
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x78(%rax), %rdx
movl $0xa, %esi
callq 0x48a90
cmpl $0x0, %eax
jne 0x490db
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %r8
leaq 0x33878(%rip), %rdx # 0x7c945
callq 0x49700
movb $0x1, -0x1(%rbp)
jmp 0x49208
movq -0x20(%rbp), %rdi
callq 0x496b0
movq %rax, -0x38(%rbp)
cmpq $0x2, -0x40(%rbp)
jb 0x49164
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x50, %rsi
movq -0x40(%rbp), %rax
movl %eax, %edx
movq -0x20(%rbp), %rax
movsbl 0x98(%rax), %ecx
callq 0x49220
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x20(%rbp), %r8
movq -0x38(%rbp), %r9
movl $0x11, %edx
leaq -0x30(%rbp), %rcx
callq 0x497c0
movb %al, -0x49(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x491bb
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
shrq $0x8, %rax
movq %rax, -0x60(%rbp)
jmp 0x49176
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movl %eax, %esi
callq 0x46f80
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %edx
movq -0x20(%rbp), %r8
movq -0x38(%rbp), %r9
leaq -0x30(%rbp), %rcx
callq 0x497c0
movb %al, -0x49(%rbp)
cmpb $0x0, -0x49(%rbp)
je 0x491e5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %r8
leaq 0x3376d(%rip), %rdx # 0x7c945
callq 0x49700
movb -0x49(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x49208
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x48(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x499c0
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| apply_one_rule:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rdi, [rbp+var_20]
call my_coll_rule_reset_length
mov [rbp+var_38], rax
mov rdi, [rbp+var_20]
call my_coll_rule_shift_length
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
cmp dword ptr [rax+30h], 1
jnz short loc_49089
mov rax, [rbp+var_20]
cmp dword ptr [rax+80h], 0
jnz short loc_49097
loc_49089:
mov rax, [rbp+var_20]
cmp qword ptr [rax+90h], 1
jnz short loc_490E8
loc_49097:
mov rdi, [rbp+var_20]
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rdx, [rax+78h]
mov esi, 0Ah
call my_coll_rule_expand
cmp eax, 0
jnz short loc_490DB
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_38]
lea rdx, aExpansion; "Expansion"
call my_charset_loader_error_for_rule
mov [rbp+var_1], 1
jmp loc_49208
loc_490DB:
mov rdi, [rbp+var_20]
call my_coll_rule_reset_length
mov [rbp+var_38], rax
loc_490E8:
cmp [rbp+var_40], 2
jb short loc_49164
mov rax, [rbp+var_28]
add rax, 18h
mov [rbp+var_58], rax
mov rdi, [rbp+var_58]
mov rsi, [rbp+var_20]
add rsi, 50h ; 'P'
mov rax, [rbp+var_40]
mov edx, eax
mov rax, [rbp+var_20]
movsx ecx, byte ptr [rax+98h]
call my_uca_init_one_contraction
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov rcx, [rax+18h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+18h], rcx
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_48]
mov r8, [rbp+var_20]
mov r9, [rbp+var_38]
mov edx, 11h
lea rcx, [rbp+var_30]
call my_char_weight_put
mov [rbp+var_49], al
mov rax, [rbp+var_28]
mov rcx, [rax+18h]
add rcx, 1
mov [rax+18h], rcx
jmp short loc_491BB
loc_49164:
mov rax, [rbp+var_20]
mov rax, [rax+50h]
shr rax, 8
mov [rbp+var_60], rax
jmp short $+2
loc_49176:
mov rdi, [rbp+var_28]
mov rax, [rbp+var_20]
mov rax, [rax+50h]
mov esi, eax
call my_char_weight_addr
mov [rbp+var_48], rax
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_48]
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rcx, [rbp+var_60]
movzx eax, byte ptr [rax+rcx]
mov edx, eax
mov r8, [rbp+var_20]
mov r9, [rbp+var_38]
lea rcx, [rbp+var_30]
call my_char_weight_put
mov [rbp+var_49], al
loc_491BB:
cmp [rbp+var_49], 0
jz short loc_491E5
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_38]
lea rdx, aExpansion; "Expansion"
call my_charset_loader_error_for_rule
mov al, [rbp+var_49]
mov [rbp+var_1], al
jmp short loc_49208
loc_491E5:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_28]
mov ecx, [rax+30h]
mov r8, [rbp+var_48]
mov r9, [rbp+var_30]
call apply_shift
mov [rbp+var_1], al
loc_49208:
mov al, [rbp+var_1]
add rsp, 60h
pop rbp
retn
| char apply_one_rule(long long a1, long long a2, long long a3, _QWORD *a4)
{
long long v5; // [rsp+0h] [rbp-60h]
char v6; // [rsp+17h] [rbp-49h]
long long inited; // [rsp+18h] [rbp-48h]
unsigned long long v8; // [rsp+20h] [rbp-40h]
long long v9; // [rsp+28h] [rbp-38h]
long long v10; // [rsp+30h] [rbp-30h] BYREF
_QWORD *v11; // [rsp+38h] [rbp-28h]
long long v12; // [rsp+40h] [rbp-20h]
long long v13; // [rsp+48h] [rbp-18h]
long long v14; // [rsp+50h] [rbp-10h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = a4;
v9 = my_coll_rule_reset_length(a3);
v8 = my_coll_rule_shift_length(v12);
if ( *(_DWORD *)(a2 + 48) == 1 && *(_DWORD *)(v12 + 128) || *(_QWORD *)(v12 + 144) == 1LL )
{
if ( !(unsigned int)my_coll_rule_expand(v12, 0xAuLL, *(_QWORD *)(*(_QWORD *)(v13 + 8) + 120LL)) )
{
my_charset_loader_error_for_rule(v14, v12, "Expansion", v12, v9);
return 1;
}
v9 = my_coll_rule_reset_length(v12);
}
if ( v8 < 2 )
{
v5 = *(_QWORD *)(v12 + 80) >> 8;
inited = my_char_weight_addr(v11, *(_QWORD *)(v12 + 80));
v6 = my_char_weight_put(v11, inited, *(unsigned __int8 *)(v11[1] + v5), &v10, v12, v9);
}
else
{
inited = my_uca_init_one_contraction(v11 + 3, v12 + 80, (unsigned int)v8, (unsigned int)*(char *)(v12 + 152));
--v11[3];
v6 = my_char_weight_put(v11, inited, 17LL, &v10, v12, v9);
++v11[3];
}
if ( !v6 )
return apply_shift(v14, v13, v12, *((unsigned int *)v11 + 12), inited, v10);
my_charset_loader_error_for_rule(v14, v12, "Expansion", v12, v9);
return v6;
}
| apply_one_rule:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001496b0
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001496d0
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x30],0x1
JNZ 0x00149089
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x80],0x0
JNZ 0x00149097
LAB_00149089:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x90],0x1
JNZ 0x001490e8
LAB_00149097:
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RAX + 0x78]
MOV ESI,0xa
CALL 0x00148a90
CMP EAX,0x0
JNZ 0x001490db
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x38]
LEA RDX,[0x17c945]
CALL 0x00149700
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00149208
LAB_001490db:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001496b0
MOV qword ptr [RBP + -0x38],RAX
LAB_001490e8:
CMP qword ptr [RBP + -0x40],0x2
JC 0x00149164
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x18
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x50
MOV RAX,qword ptr [RBP + -0x40]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RAX + 0x98]
CALL 0x00149220
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x18],RCX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x48]
MOV R8,qword ptr [RBP + -0x20]
MOV R9,qword ptr [RBP + -0x38]
MOV EDX,0x11
LEA RCX,[RBP + -0x30]
CALL 0x001497c0
MOV byte ptr [RBP + -0x49],AL
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,0x1
MOV qword ptr [RAX + 0x18],RCX
JMP 0x001491bb
LAB_00149164:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x50]
SHR RAX,0x8
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00149176
LAB_00149176:
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x50]
MOV ESI,EAX
CALL 0x00146f80
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x60]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV EDX,EAX
MOV R8,qword ptr [RBP + -0x20]
MOV R9,qword ptr [RBP + -0x38]
LEA RCX,[RBP + -0x30]
CALL 0x001497c0
MOV byte ptr [RBP + -0x49],AL
LAB_001491bb:
CMP byte ptr [RBP + -0x49],0x0
JZ 0x001491e5
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x38]
LEA RDX,[0x17c945]
CALL 0x00149700
MOV AL,byte ptr [RBP + -0x49]
MOV byte ptr [RBP + -0x1],AL
JMP 0x00149208
LAB_001491e5:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x30]
MOV R8,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x30]
CALL 0x001499c0
MOV byte ptr [RBP + -0x1],AL
LAB_00149208:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x60
POP RBP
RET
|
int8 apply_one_rule(int8 param_1,long param_2,long param_3,long param_4)
{
char extraout_AL;
int iVar1;
ulong uVar2;
int7 extraout_var;
int8 uVar3;
int7 uVar4;
int7 extraout_var_00;
char local_51;
int8 local_50;
int8 local_40;
int8 local_38;
long local_30;
long local_28;
long local_20;
int8 local_18;
char local_9;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_40 = my_coll_rule_reset_length(param_3);
uVar2 = my_coll_rule_shift_length(local_28);
if (((*(int *)(local_20 + 0x30) == 1) && (*(int *)(local_28 + 0x80) != 0)) ||
(*(long *)(local_28 + 0x90) == 1)) {
iVar1 = my_coll_rule_expand(local_28,10,*(int8 *)(*(long *)(local_20 + 8) + 0x78));
if (iVar1 == 0) {
my_charset_loader_error_for_rule(local_18,local_28,"Expansion",local_28,local_40);
local_9 = '\x01';
uVar4 = extraout_var;
goto LAB_00149208;
}
local_40 = my_coll_rule_reset_length(local_28);
}
if (uVar2 < 2) {
uVar2 = *(ulong *)(local_28 + 0x50);
local_50 = my_char_weight_addr(local_30,*(ulong *)(local_28 + 0x50) & 0xffffffff);
local_51 = my_char_weight_put(local_30,local_50,
*(int1 *)(*(long *)(local_30 + 8) + (uVar2 >> 8)),&local_38,
local_28,local_40);
}
else {
local_50 = my_uca_init_one_contraction
(local_30 + 0x18,local_28 + 0x50,uVar2 & 0xffffffff,
(int)*(char *)(local_28 + 0x98));
*(long *)(local_30 + 0x18) = *(long *)(local_30 + 0x18) + -1;
local_51 = my_char_weight_put(local_30,local_50,0x11,&local_38,local_28,local_40);
*(long *)(local_30 + 0x18) = *(long *)(local_30 + 0x18) + 1;
}
if (local_51 == '\0') {
apply_shift(local_18,local_20,local_28,*(int4 *)(local_30 + 0x30),local_50,local_38);
uVar4 = extraout_var_00;
local_9 = extraout_AL;
}
else {
uVar3 = my_charset_loader_error_for_rule(local_18,local_28,"Expansion",local_28,local_40);
uVar4 = (int7)((ulong)uVar3 >> 8);
local_9 = local_51;
}
LAB_00149208:
return CONCAT71(uVar4,local_9);
}
| |
39,591 | minja::Value::to_bool() const | monkey531[P]llama/common/minja.hpp | bool to_bool() const {
if (is_null()) return false;
if (is_boolean()) return get<bool>();
if (is_number()) return get<double>() != 0;
if (is_string()) return !get<std::string>().empty();
if (is_array()) return !empty();
return true;
} | O3 | cpp | minja::Value::to_bool() const:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rsi
cmpq $0x0, 0x20(%rdi)
movq 0x10(%rdi), %rax
movb 0x40(%rdi), %cl
jne 0x89ce6
testq %rax, %rax
jne 0x89ce6
testb %cl, %cl
jne 0x89ce6
cmpq $0x0, 0x30(%rsi)
jne 0x89ce6
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cmpb $0x4, %cl
jne 0x89cfa
movq %rsi, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x8ae06
leal -0x5(%rcx), %edx
cmpb $0x2, %dl
ja 0x89d1d
movq %rsi, %rdi
callq 0x89f7c
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movq %xmm1, %rbx
andl $0x1, %ebx
jmp 0x89cdc
cmpb $0x3, %cl
jne 0x89d53
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8af16
cmpq $0x0, 0x8(%r14)
setne %bl
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x89cdc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1ba60
jmp 0x89cdc
testq %rax, %rax
je 0x89d6a
movq %rsi, %rdi
callq 0x8b020
movl %eax, %ebx
xorb $0x1, %bl
jmp 0x89cdc
movb $0x1, %bl
jmp 0x89cdc
nop
| _ZNK5minja5Value7to_boolEv:
push r14
push rbx
sub rsp, 28h
mov rsi, rdi
cmp qword ptr [rdi+20h], 0
mov rax, [rdi+10h]
mov cl, [rdi+40h]
jnz short loc_89CE6
test rax, rax
jnz short loc_89CE6
test cl, cl
jnz short loc_89CE6
cmp qword ptr [rsi+30h], 0
jnz short loc_89CE6
xor ebx, ebx
loc_89CDC:
mov eax, ebx
add rsp, 28h
pop rbx
pop r14
retn
loc_89CE6:
cmp cl, 4
jnz short loc_89CFA
mov rdi, rsi
add rsp, 28h
pop rbx
pop r14
jmp _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
loc_89CFA:
lea edx, [rcx-5]
cmp dl, 2
ja short loc_89D1D
mov rdi, rsi
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
xorpd xmm1, xmm1
cmpneqsd xmm1, xmm0
movq rbx, xmm1
and ebx, 1
jmp short loc_89CDC
loc_89D1D:
cmp cl, 3
jnz short loc_89D53
lea r14, [rsp+38h+var_30]
mov rdi, r14
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
cmp qword ptr [r14+8], 0
setnz bl
mov rdi, [r14]; void *
lea rax, [rsp+38h+var_20]
cmp rdi, rax
jz short loc_89CDC
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_89CDC
loc_89D53:
test rax, rax
jz short loc_89D6A
mov rdi, rsi; this
call _ZNK5minja5Value5emptyEv; minja::Value::empty(void)
mov ebx, eax
xor bl, 1
jmp loc_89CDC
loc_89D6A:
mov bl, 1
jmp loc_89CDC
| long long minja::Value::to_bool(minja::Value *this)
{
unsigned int v1; // ebx
long long v2; // rax
char v3; // cl
__m128d v5; // xmm0
void *v6[2]; // [rsp+8h] [rbp-30h] BYREF
long long v7; // [rsp+18h] [rbp-20h] BYREF
v2 = *((_QWORD *)this + 2);
v3 = *((_BYTE *)this + 64);
if ( !*((_QWORD *)this + 4) && !v2 && !v3 && !*((_QWORD *)this + 6) )
return 0;
if ( v3 != 4 )
{
if ( (unsigned __int8)(v3 - 5) > 2u )
{
if ( v3 == 3 )
{
minja::Value::get<std::string>(v6, this);
LOBYTE(v1) = v6[1] != 0LL;
if ( v6[0] != &v7 )
operator delete(v6[0], v7 + 1);
}
else if ( v2 )
{
v1 = minja::Value::empty(this);
LOBYTE(v1) = v1 ^ 1;
}
else
{
LOBYTE(v1) = 1;
}
}
else
{
v5.m128d_f64[0] = minja::Value::get<double>(this);
return *(_OWORD *)&_mm_cmpneq_sd((__m128d)0LL, v5) & 1;
}
return v1;
}
return minja::Value::get<bool>(this);
}
| to_bool:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RSI,RDI
CMP qword ptr [RDI + 0x20],0x0
MOV RAX,qword ptr [RDI + 0x10]
MOV CL,byte ptr [RDI + 0x40]
JNZ 0x00189ce6
TEST RAX,RAX
JNZ 0x00189ce6
TEST CL,CL
JNZ 0x00189ce6
CMP qword ptr [RSI + 0x30],0x0
JNZ 0x00189ce6
XOR EBX,EBX
LAB_00189cdc:
MOV EAX,EBX
ADD RSP,0x28
POP RBX
POP R14
RET
LAB_00189ce6:
CMP CL,0x4
JNZ 0x00189cfa
MOV RDI,RSI
ADD RSP,0x28
POP RBX
POP R14
JMP 0x0018ae06
LAB_00189cfa:
LEA EDX,[RCX + -0x5]
CMP DL,0x2
JA 0x00189d1d
MOV RDI,RSI
CALL 0x00189f7c
XORPD XMM1,XMM1
CMPNEQSD XMM1,XMM0
MOVQ RBX,XMM1
AND EBX,0x1
JMP 0x00189cdc
LAB_00189d1d:
CMP CL,0x3
JNZ 0x00189d53
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x0018af16
CMP qword ptr [R14 + 0x8],0x0
SETNZ BL
MOV RDI,qword ptr [R14]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x00189cdc
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011ba60
JMP 0x00189cdc
LAB_00189d53:
TEST RAX,RAX
JZ 0x00189d6a
MOV RDI,RSI
CALL 0x0018b020
MOV EBX,EAX
XOR BL,0x1
JMP 0x00189cdc
LAB_00189d6a:
MOV BL,0x1
JMP 0x00189cdc
|
/* minja::Value::to_bool() const */
byte __thiscall minja::Value::to_bool(Value *this)
{
Value VVar1;
bool bVar2;
byte bVar3;
double dVar4;
long *local_30;
long local_28;
long local_20 [2];
VVar1 = this[0x40];
if ((((*(long *)(this + 0x20) == 0) && (*(long *)(this + 0x10) == 0)) && (VVar1 == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
bVar3 = 0;
}
else {
if (VVar1 == (Value)0x4) {
bVar2 = get<bool>(this);
return bVar2;
}
if ((byte)((char)VVar1 - 5U) < 3) {
dVar4 = get<double>(this);
bVar3 = -(dVar4 != 0.0) & 1;
}
else if (VVar1 == (Value)0x3) {
get<std::__cxx11::string>();
bVar3 = local_28 != 0;
if (local_30 != local_20) {
operator_delete(local_30,local_20[0] + 1);
}
}
else if (*(long *)(this + 0x10) == 0) {
bVar3 = 1;
}
else {
bVar3 = empty(this);
bVar3 = bVar3 ^ 1;
}
}
return bVar3;
}
| |
39,592 | strmake | eloqsql/strings/strmake.c | char *strmake(register char *dst, register const char *src, size_t length)
{
while (length--)
{
if (! (*dst++ = *src++))
{
#ifdef EXTRA_DEBUG
/*
'length' is the maximum length of the string; the buffer needs
to be one character larger to accommodate the terminating
'\0'. This is easy to get wrong, so we make sure we write to
the entire length of the buffer to identify incorrect
buffer-sizes. We only initialism the "unused" part of the
buffer here, a) for efficiency, and b) because dst==src is
allowed, so initializing the entire buffer would overwrite the
source-string. Also, we write a character rather than '\0' as
this makes spotting these problems in the results easier.
If we are using purify/valgrind, we only set one character at
end to be able to detect also wrong accesses after the end of
dst.
*/
if (length)
{
#ifdef HAVE_valgrind
dst[length-1]= 'Z';
#else
bfill(dst, length-1, (int) 'Z');
#endif /* HAVE_valgrind */
}
#endif /* EXTRA_DEBUG */
return dst-1;
}
}
*dst=0;
return dst;
} | O0 | c | strmake:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
je 0xc876b
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %al, (%rcx)
cmpb $0x0, %al
jne 0xc8769
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xc877a
jmp 0xc8720
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
| strmake:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
loc_C8720:
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_20], rcx
cmp rax, 0
jz short loc_C876B
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov al, [rax]
mov rcx, [rbp+var_10]
mov rdx, rcx
add rdx, 1
mov [rbp+var_10], rdx
mov [rcx], al
cmp al, 0
jnz short loc_C8769
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_8], rax
jmp short loc_C877A
loc_C8769:
jmp short loc_C8720
loc_C876B:
mov rax, [rbp+var_10]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_C877A:
mov rax, [rbp+var_8]
pop rbp
retn
| _BYTE * strmake(_BYTE *a1, _BYTE *a2, long long a3)
{
_BYTE *v4; // rax
_BYTE *v5; // rcx
while ( a3-- )
{
v4 = a2++;
LOBYTE(v4) = *v4;
v5 = a1++;
*v5 = (_BYTE)v4;
if ( !(_BYTE)v4 )
return a1 - 1;
}
*a1 = 0;
return a1;
}
| strmake:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
LAB_001c8720:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RBP + -0x20],RCX
CMP RAX,0x0
JZ 0x001c876b
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV AL,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RCX],AL
CMP AL,0x0
JNZ 0x001c8769
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001c877a
LAB_001c8769:
JMP 0x001c8720
LAB_001c876b:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_001c877a:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
char * strmake(char *param_1,char *param_2,long param_3)
{
char cVar1;
char *pcVar2;
long local_28;
char *local_20;
char *local_18;
local_28 = param_3;
local_20 = param_2;
pcVar2 = param_1;
do {
local_18 = pcVar2;
if (local_28 == 0) {
*local_18 = '\0';
return local_18;
}
cVar1 = *local_20;
*local_18 = cVar1;
local_28 = local_28 + -1;
local_20 = local_20 + 1;
pcVar2 = local_18 + 1;
} while (cVar1 != '\0');
return local_18;
}
| |
39,593 | sqrt_fp | corpus-core[P]colibri-stateless/build_O1/_deps/blst-src/src/sqrt.c | static bool_t sqrt_fp(vec384 out, const vec384 inp)
{
vec384 t0, t1;
bool_t ret;
recip_sqrt_fp_3mod4(t0, inp);
mul_fp(t0, t0, inp);
sqr_fp(t1, t0);
ret = vec_is_equal(t1, inp, sizeof(t1));
vec_copy(out, t0, sizeof(t0));
return ret;
} | O1 | c | sqrt_fp:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1df26(%rip), %rdx # 0x3fff0
leaq -0x90(%rbp), %r14
movl $0x17b, %ecx # imm = 0x17B
movq %r14, %rdi
callq 0x265df
leaq 0x1da3b(%rip), %rcx # 0x3fb20
movabsq $-0x760c000300030003, %r13 # imm = 0x89F3FFFCFFFCFFFD
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %r8
callq 0x34be0
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
leaq 0x1da0f(%rip), %rdx # 0x3fb20
movq %r13, %rcx
callq 0x34460
movl $0x30, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x306c0
movaps (%r14), %xmm0
movaps 0x10(%r14), %xmm1
movaps 0x20(%r14), %xmm2
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm2, 0x20(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| sqrt_fp:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r15, rsi
mov rbx, rdi
lea rdx, recip_sqrt_fp_3mod4_BLS_12_381_P_minus_3_div_4
lea r14, [rbp+var_90]
mov ecx, 17Bh
mov rdi, r14
call exp_mont_384
lea rcx, BLS12_381_P
mov r13, 89F3FFFCFFFCFFFDh
mov rdi, r14
mov rsi, r14
mov rdx, r15
mov r8, r13
call mul_mont_384
lea r12, [rbp+var_60]
mov rdi, r12
mov rsi, r14
lea rdx, BLS12_381_P
mov rcx, r13
call sqr_mont_384
mov edx, 30h ; '0'
mov rdi, r12
mov rsi, r15
call vec_is_equal_16x
movaps xmm0, xmmword ptr [r14]
movaps xmm1, xmmword ptr [r14+10h]
movaps xmm2, xmmword ptr [r14+20h]
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx+20h], xmm2
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long sqrt_fp(_OWORD *a1, long long a2)
{
long long result; // rax
__int128 v3; // xmm1
__int128 v4; // xmm2
_OWORD v5[3]; // [rsp+0h] [rbp-90h] BYREF
_BYTE v6[96]; // [rsp+30h] [rbp-60h] BYREF
exp_mont_384(v5, a2, &recip_sqrt_fp_3mod4_BLS_12_381_P_minus_3_div_4, 379LL);
mul_mont_384(v5, v5, a2, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
sqr_mont_384(v6, v5, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
result = vec_is_equal_16x(v6, a2, 48LL);
v3 = v5[1];
v4 = v5[2];
*a1 = v5[0];
a1[1] = v3;
a1[2] = v4;
return result;
}
| sqrt_fp:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R15,RSI
MOV RBX,RDI
LEA RDX,[0x13fff0]
LEA R14,[RBP + -0x90]
MOV ECX,0x17b
MOV RDI,R14
CALL 0x001265df
LEA RCX,[0x13fb20]
MOV R13,-0x760c000300030003
MOV RDI,R14
MOV RSI,R14
MOV RDX,R15
MOV R8,R13
CALL 0x00134be0
LEA R12,[RBP + -0x60]
MOV RDI,R12
MOV RSI,R14
LEA RDX,[0x13fb20]
MOV RCX,R13
CALL 0x00134460
MOV EDX,0x30
MOV RDI,R12
MOV RSI,R15
CALL 0x001306c0
MOVAPS XMM0,xmmword ptr [R14]
MOVAPS XMM1,xmmword ptr [R14 + 0x10]
MOVAPS XMM2,xmmword ptr [R14 + 0x20]
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX + 0x20],XMM2
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void sqrt_fp(int8 *param_1,int8 param_2)
{
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int1 local_68 [56];
exp_mont_384(&local_98,param_2,recip_sqrt_fp_3mod4_BLS_12_381_P_minus_3_div_4,0x17b);
mul_mont_384(&local_98,&local_98,param_2,BLS12_381_P,0x89f3fffcfffcfffd);
sqr_mont_384(local_68,&local_98,BLS12_381_P,0x89f3fffcfffcfffd);
vec_is_equal_16x(local_68,param_2,0x30);
*param_1 = local_98;
param_1[1] = uStack_90;
param_1[2] = local_88;
param_1[3] = uStack_80;
param_1[4] = local_78;
param_1[5] = uStack_70;
return;
}
| |
39,594 | quantize_row_q8_1_ref | monkey531[P]llama/ggml/src/ggml-quants.c | void quantize_row_q8_1_ref(const float * restrict x, block_q8_1 * restrict y, int64_t k) {
assert(QK8_1 == 32);
assert(k % QK8_1 == 0);
const int nb = k / QK8_1;
for (int i = 0; i < nb; i++) {
float amax = 0.0f; // absolute max
for (int j = 0; j < QK8_1; j++) {
const float v = x[i*QK8_1 + j];
amax = MAX(amax, fabsf(v));
}
const float d = amax / ((1 << 7) - 1);
const float id = d ? 1.0f/d : 0.0f;
y[i].d = GGML_FP32_TO_FP16(d);
int sum = 0;
for (int j = 0; j < QK8_1/2; ++j) {
const float v0 = x[i*QK8_1 + j]*id;
const float v1 = x[i*QK8_1 + QK8_1/2 + j]*id;
y[i].qs[ j] = roundf(v0);
y[i].qs[QK8_1/2 + j] = roundf(v1);
sum += y[i].qs[ j];
sum += y[i].qs[QK8_1/2 + j];
}
y[i].s = GGML_FP32_TO_FP16(sum*d);
}
} | O0 | c | quantize_row_q8_1_ref:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x40(%rsp), %rax
movl $0x20, %ecx
cqto
idivq %rcx
movl %eax, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x6f30a
xorps %xmm0, %xmm0
movss %xmm0, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
cmpl $0x20, 0x30(%rsp)
jge 0x6f12c
movq 0x50(%rsp), %rax
movl 0x38(%rsp), %ecx
shll $0x5, %ecx
addl 0x30(%rsp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x2c(%rsp)
movss 0x34(%rsp), %xmm0
movss 0x2c(%rsp), %xmm1
movaps 0x44f4b(%rip), %xmm2 # 0xb4030
pand %xmm2, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x6f0fc
movss 0x34(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
jmp 0x6f113
movss 0x2c(%rsp), %xmm0
movaps 0x44f27(%rip), %xmm1 # 0xb4030
pand %xmm1, %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x10(%rsp), %xmm0
movss %xmm0, 0x34(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x6f0ad
movss 0x34(%rsp), %xmm0
movss 0x49586(%rip), %xmm1 # 0xb86c0
divss %xmm1, %xmm0
movss %xmm0, 0x28(%rsp)
movss 0x28(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x6f156
jp 0x6f156
jmp 0x6f16c
movss 0x452ca(%rip), %xmm0 # 0xb4428
divss 0x28(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x6f177
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x6f177
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movss 0x28(%rsp), %xmm0
callq 0x6e480
movw %ax, %cx
movq 0x48(%rsp), %rax
movslq 0x38(%rsp), %rdx
imulq $0x24, %rdx, %rdx
addq %rdx, %rax
movw %cx, (%rax)
movl $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x10, 0x1c(%rsp)
jge 0x6f2d1
movq 0x50(%rsp), %rax
movl 0x38(%rsp), %ecx
shll $0x5, %ecx
movl 0x1c(%rsp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss 0x24(%rsp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x50(%rsp), %rax
movl 0x38(%rsp), %esi
shll $0x5, %esi
movl 0x1c(%rsp), %ecx
movl %ecx, %edx
movl %esi, %ecx
leal 0x10(%rcx,%rdx), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss 0x24(%rsp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x18(%rsp), %xmm0
callq 0x43dd0
cvttss2si %xmm0, %eax
movb %al, %dl
movq 0x48(%rsp), %rax
movslq 0x38(%rsp), %rcx
leaq (%rcx,%rcx,8), %rcx
leaq (%rax,%rcx,4), %rcx
movslq 0x1c(%rsp), %rax
movb %dl, 0x4(%rax,%rcx)
movss 0x14(%rsp), %xmm0
callq 0x43dd0
cvttss2si %xmm0, %eax
movb %al, %dl
movq 0x48(%rsp), %rax
movslq 0x38(%rsp), %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movl 0x1c(%rsp), %ecx
addl $0x10, %ecx
movslq %ecx, %rcx
movb %dl, 0x4(%rax,%rcx)
movq 0x48(%rsp), %rax
movslq 0x38(%rsp), %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq 0x1c(%rsp), %rcx
movsbl 0x4(%rax,%rcx), %eax
addl 0x20(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movslq 0x38(%rsp), %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movl 0x1c(%rsp), %ecx
addl $0x10, %ecx
movslq %ecx, %rcx
movsbl 0x4(%rax,%rcx), %eax
addl 0x20(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x6f1b5
cvtsi2ssl 0x20(%rsp), %xmm0
mulss 0x28(%rsp), %xmm0
callq 0x6e480
movw %ax, %cx
movq 0x48(%rsp), %rax
movslq 0x38(%rsp), %rdx
imulq $0x24, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x2(%rax)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x6f08e
addq $0x58, %rsp
retq
nop
| quantize_row_q8_1_ref:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov [rsp+58h+var_18], rdx
mov rax, [rsp+58h+var_18]
mov ecx, 20h ; ' '
cqo
idiv rcx
mov [rsp+58h+var_1C], eax
mov [rsp+58h+var_20], 0
loc_6F08E:
mov eax, [rsp+58h+var_20]
cmp eax, [rsp+58h+var_1C]
jge loc_6F30A
xorps xmm0, xmm0
movss [rsp+58h+var_24], xmm0
mov [rsp+58h+var_28], 0
loc_6F0AD:
cmp [rsp+58h+var_28], 20h ; ' '
jge short loc_6F12C
mov rax, [rsp+58h+var_8]
mov ecx, [rsp+58h+var_20]
shl ecx, 5
add ecx, [rsp+58h+var_28]
movsxd rcx, ecx
movss xmm0, dword ptr [rax+rcx*4]
movss [rsp+58h+var_2C], xmm0
movss xmm0, [rsp+58h+var_24]
movss xmm1, [rsp+58h+var_2C]
movaps xmm2, cs:xmmword_B4030
pand xmm1, xmm2
ucomiss xmm0, xmm1
jbe short loc_6F0FC
movss xmm0, [rsp+58h+var_24]
movss [rsp+58h+var_48], xmm0
jmp short loc_6F113
loc_6F0FC:
movss xmm0, [rsp+58h+var_2C]
movaps xmm1, cs:xmmword_B4030
pand xmm0, xmm1
movss [rsp+58h+var_48], xmm0
loc_6F113:
movss xmm0, [rsp+58h+var_48]
movss [rsp+58h+var_24], xmm0
mov eax, [rsp+58h+var_28]
add eax, 1
mov [rsp+58h+var_28], eax
jmp short loc_6F0AD
loc_6F12C:
movss xmm0, [rsp+58h+var_24]
movss xmm1, cs:dword_B86C0
divss xmm0, xmm1
movss [rsp+58h+var_30], xmm0
movss xmm0, [rsp+58h+var_30]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jnz short loc_6F156
jp short loc_6F156
jmp short loc_6F16C
loc_6F156:
movss xmm0, cs:dword_B4428
divss xmm0, [rsp+58h+var_30]
movss [rsp+58h+var_4C], xmm0
jmp short loc_6F177
loc_6F16C:
xorps xmm0, xmm0
movss [rsp+58h+var_4C], xmm0
jmp short $+2
loc_6F177:
movss xmm0, [rsp+58h+var_4C]
movss [rsp+58h+var_34], xmm0
movss xmm0, [rsp+58h+var_30]
call ggml_compute_fp32_to_fp16_0
mov cx, ax
mov rax, [rsp+58h+var_10]
movsxd rdx, [rsp+58h+var_20]
imul rdx, 24h ; '$'
add rax, rdx
mov [rax], cx
mov [rsp+58h+var_38], 0
mov [rsp+58h+var_3C], 0
loc_6F1B5:
cmp [rsp+58h+var_3C], 10h
jge loc_6F2D1
mov rax, [rsp+58h+var_8]
mov ecx, [rsp+58h+var_20]
shl ecx, 5
mov edx, [rsp+58h+var_3C]
add ecx, edx
movsxd rcx, ecx
movss xmm0, dword ptr [rax+rcx*4]
movss xmm1, [rsp+58h+var_34]
mulss xmm0, xmm1
movss [rsp+58h+var_40], xmm0
mov rax, [rsp+58h+var_8]
mov esi, [rsp+58h+var_20]
shl esi, 5
mov ecx, [rsp+58h+var_3C]
mov edx, ecx
mov ecx, esi
lea ecx, [rcx+rdx+10h]
movsxd rcx, ecx
movss xmm0, dword ptr [rax+rcx*4]
movss xmm1, [rsp+58h+var_34]
mulss xmm0, xmm1
movss [rsp+58h+var_44], xmm0
movss xmm0, [rsp+58h+var_40]
call _roundf
cvttss2si eax, xmm0
mov dl, al
mov rax, [rsp+58h+var_10]
movsxd rcx, [rsp+58h+var_20]
lea rcx, [rcx+rcx*8]
lea rcx, [rax+rcx*4]
movsxd rax, [rsp+58h+var_3C]
mov [rax+rcx+4], dl
movss xmm0, [rsp+58h+var_44]
call _roundf
cvttss2si eax, xmm0
mov dl, al
mov rax, [rsp+58h+var_10]
movsxd rcx, [rsp+58h+var_20]
imul rcx, 24h ; '$'
add rax, rcx
mov ecx, [rsp+58h+var_3C]
add ecx, 10h
movsxd rcx, ecx
mov [rax+rcx+4], dl
mov rax, [rsp+58h+var_10]
movsxd rcx, [rsp+58h+var_20]
imul rcx, 24h ; '$'
add rax, rcx
movsxd rcx, [rsp+58h+var_3C]
movsx eax, byte ptr [rax+rcx+4]
add eax, [rsp+58h+var_38]
mov [rsp+58h+var_38], eax
mov rax, [rsp+58h+var_10]
movsxd rcx, [rsp+58h+var_20]
imul rcx, 24h ; '$'
add rax, rcx
mov ecx, [rsp+58h+var_3C]
add ecx, 10h
movsxd rcx, ecx
movsx eax, byte ptr [rax+rcx+4]
add eax, [rsp+58h+var_38]
mov [rsp+58h+var_38], eax
mov eax, [rsp+58h+var_3C]
add eax, 1
mov [rsp+58h+var_3C], eax
jmp loc_6F1B5
loc_6F2D1:
cvtsi2ss xmm0, [rsp+58h+var_38]
mulss xmm0, [rsp+58h+var_30]
call ggml_compute_fp32_to_fp16_0
mov cx, ax
mov rax, [rsp+58h+var_10]
movsxd rdx, [rsp+58h+var_20]
imul rdx, 24h ; '$'
add rax, rdx
mov [rax+2], cx
mov eax, [rsp+58h+var_20]
add eax, 1
mov [rsp+58h+var_20], eax
jmp loc_6F08E
loc_6F30A:
add rsp, 58h
retn
| long long quantize_row_q8_1_ref(long long a1, long long a2, long long a3)
{
long long result; // rax
float v4; // [rsp+Ch] [rbp-4Ch]
unsigned __int32 v5; // [rsp+10h] [rbp-48h]
float v6; // [rsp+14h] [rbp-44h]
int k; // [rsp+1Ch] [rbp-3Ch]
int v8; // [rsp+20h] [rbp-38h]
float v9; // [rsp+28h] [rbp-30h]
unsigned int v10; // [rsp+2Ch] [rbp-2Ch]
int j; // [rsp+30h] [rbp-28h]
float v12; // [rsp+34h] [rbp-24h]
unsigned int i; // [rsp+38h] [rbp-20h]
int v14; // [rsp+3Ch] [rbp-1Ch]
v14 = a3 / 32;
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= v14 )
break;
v12 = 0.0;
for ( j = 0; j < 32; ++j )
{
v10 = *(_DWORD *)(a1 + 4LL * (int)(j + 32 * i));
if ( v12 <= *(float *)_mm_and_si128((__m128i)v10, (__m128i)xmmword_B4030).m128i_i32 )
v5 = _mm_and_si128((__m128i)v10, (__m128i)xmmword_B4030).m128i_u32[0];
else
v5 = LODWORD(v12);
v12 = *(float *)&v5;
}
v9 = v12 / 127.0;
if ( (float)(v12 / 127.0) == 0.0 )
v4 = 0.0;
else
v4 = 1.0 / v9;
*(_WORD *)(36LL * (int)i + a2) = ggml_compute_fp32_to_fp16_0(v9);
v8 = 0;
for ( k = 0; k < 16; ++k )
{
v6 = *(float *)(a1 + 4LL * (int)(32 * i + k + 16)) * v4;
*(_BYTE *)(k + a2 + 36LL * (int)i + 4) = (int)roundf(*(float *)(a1 + 4LL * (int)(k + 32 * i)) * v4);
*(_BYTE *)(36LL * (int)i + a2 + k + 16 + 4) = (int)roundf(v6);
v8 += *(char *)(36LL * (int)i + a2 + k + 4) + *(char *)(36LL * (int)i + a2 + k + 16 + 4);
}
*(_WORD *)(36LL * (int)i + a2 + 2) = ggml_compute_fp32_to_fp16_0((float)v8 * v9);
}
return result;
}
| quantize_row_q8_1_ref:
SUB RSP,0x58
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV ECX,0x20
CQO
IDIV RCX
MOV dword ptr [RSP + 0x3c],EAX
MOV dword ptr [RSP + 0x38],0x0
LAB_0016f08e:
MOV EAX,dword ptr [RSP + 0x38]
CMP EAX,dword ptr [RSP + 0x3c]
JGE 0x0016f30a
XORPS XMM0,XMM0
MOVSS dword ptr [RSP + 0x34],XMM0
MOV dword ptr [RSP + 0x30],0x0
LAB_0016f0ad:
CMP dword ptr [RSP + 0x30],0x20
JGE 0x0016f12c
MOV RAX,qword ptr [RSP + 0x50]
MOV ECX,dword ptr [RSP + 0x38]
SHL ECX,0x5
ADD ECX,dword ptr [RSP + 0x30]
MOVSXD RCX,ECX
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
MOVSS dword ptr [RSP + 0x2c],XMM0
MOVSS XMM0,dword ptr [RSP + 0x34]
MOVSS XMM1,dword ptr [RSP + 0x2c]
MOVAPS XMM2,xmmword ptr [0x001b4030]
PAND XMM1,XMM2
UCOMISS XMM0,XMM1
JBE 0x0016f0fc
MOVSS XMM0,dword ptr [RSP + 0x34]
MOVSS dword ptr [RSP + 0x10],XMM0
JMP 0x0016f113
LAB_0016f0fc:
MOVSS XMM0,dword ptr [RSP + 0x2c]
MOVAPS XMM1,xmmword ptr [0x001b4030]
PAND XMM0,XMM1
MOVSS dword ptr [RSP + 0x10],XMM0
LAB_0016f113:
MOVSS XMM0,dword ptr [RSP + 0x10]
MOVSS dword ptr [RSP + 0x34],XMM0
MOV EAX,dword ptr [RSP + 0x30]
ADD EAX,0x1
MOV dword ptr [RSP + 0x30],EAX
JMP 0x0016f0ad
LAB_0016f12c:
MOVSS XMM0,dword ptr [RSP + 0x34]
MOVSS XMM1,dword ptr [0x001b86c0]
DIVSS XMM0,XMM1
MOVSS dword ptr [RSP + 0x28],XMM0
MOVSS XMM0,dword ptr [RSP + 0x28]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JNZ 0x0016f156
JP 0x0016f156
JMP 0x0016f16c
LAB_0016f156:
MOVSS XMM0,dword ptr [0x001b4428]
DIVSS XMM0,dword ptr [RSP + 0x28]
MOVSS dword ptr [RSP + 0xc],XMM0
JMP 0x0016f177
LAB_0016f16c:
XORPS XMM0,XMM0
MOVSS dword ptr [RSP + 0xc],XMM0
JMP 0x0016f177
LAB_0016f177:
MOVSS XMM0,dword ptr [RSP + 0xc]
MOVSS dword ptr [RSP + 0x24],XMM0
MOVSS XMM0,dword ptr [RSP + 0x28]
CALL 0x0016e480
MOV CX,AX
MOV RAX,qword ptr [RSP + 0x48]
MOVSXD RDX,dword ptr [RSP + 0x38]
IMUL RDX,RDX,0x24
ADD RAX,RDX
MOV word ptr [RAX],CX
MOV dword ptr [RSP + 0x20],0x0
MOV dword ptr [RSP + 0x1c],0x0
LAB_0016f1b5:
CMP dword ptr [RSP + 0x1c],0x10
JGE 0x0016f2d1
MOV RAX,qword ptr [RSP + 0x50]
MOV ECX,dword ptr [RSP + 0x38]
SHL ECX,0x5
MOV EDX,dword ptr [RSP + 0x1c]
ADD ECX,EDX
MOVSXD RCX,ECX
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
MOVSS XMM1,dword ptr [RSP + 0x24]
MULSS XMM0,XMM1
MOVSS dword ptr [RSP + 0x18],XMM0
MOV RAX,qword ptr [RSP + 0x50]
MOV ESI,dword ptr [RSP + 0x38]
SHL ESI,0x5
MOV ECX,dword ptr [RSP + 0x1c]
MOV EDX,ECX
MOV ECX,ESI
LEA ECX,[RCX + RDX*0x1 + 0x10]
MOVSXD RCX,ECX
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
MOVSS XMM1,dword ptr [RSP + 0x24]
MULSS XMM0,XMM1
MOVSS dword ptr [RSP + 0x14],XMM0
MOVSS XMM0,dword ptr [RSP + 0x18]
CALL 0x00143dd0
CVTTSS2SI EAX,XMM0
MOV DL,AL
MOV RAX,qword ptr [RSP + 0x48]
MOVSXD RCX,dword ptr [RSP + 0x38]
LEA RCX,[RCX + RCX*0x8]
LEA RCX,[RAX + RCX*0x4]
MOVSXD RAX,dword ptr [RSP + 0x1c]
MOV byte ptr [RAX + RCX*0x1 + 0x4],DL
MOVSS XMM0,dword ptr [RSP + 0x14]
CALL 0x00143dd0
CVTTSS2SI EAX,XMM0
MOV DL,AL
MOV RAX,qword ptr [RSP + 0x48]
MOVSXD RCX,dword ptr [RSP + 0x38]
IMUL RCX,RCX,0x24
ADD RAX,RCX
MOV ECX,dword ptr [RSP + 0x1c]
ADD ECX,0x10
MOVSXD RCX,ECX
MOV byte ptr [RAX + RCX*0x1 + 0x4],DL
MOV RAX,qword ptr [RSP + 0x48]
MOVSXD RCX,dword ptr [RSP + 0x38]
IMUL RCX,RCX,0x24
ADD RAX,RCX
MOVSXD RCX,dword ptr [RSP + 0x1c]
MOVSX EAX,byte ptr [RAX + RCX*0x1 + 0x4]
ADD EAX,dword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x20],EAX
MOV RAX,qword ptr [RSP + 0x48]
MOVSXD RCX,dword ptr [RSP + 0x38]
IMUL RCX,RCX,0x24
ADD RAX,RCX
MOV ECX,dword ptr [RSP + 0x1c]
ADD ECX,0x10
MOVSXD RCX,ECX
MOVSX EAX,byte ptr [RAX + RCX*0x1 + 0x4]
ADD EAX,dword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x20],EAX
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x0016f1b5
LAB_0016f2d1:
CVTSI2SS XMM0,dword ptr [RSP + 0x20]
MULSS XMM0,dword ptr [RSP + 0x28]
CALL 0x0016e480
MOV CX,AX
MOV RAX,qword ptr [RSP + 0x48]
MOVSXD RDX,dword ptr [RSP + 0x38]
IMUL RDX,RDX,0x24
ADD RAX,RDX
MOV word ptr [RAX + 0x2],CX
MOV EAX,dword ptr [RSP + 0x38]
ADD EAX,0x1
MOV dword ptr [RSP + 0x38],EAX
JMP 0x0016f08e
LAB_0016f30a:
ADD RSP,0x58
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void quantize_row_q8_1_ref(long param_1,long param_2,long param_3)
{
uint uVar1;
float fVar2;
int2 uVar3;
float fVar4;
int8 extraout_XMM0_Qa;
int8 extraout_XMM0_Qb;
int1 auVar5 [16];
int1 auVar6 [16];
int4 local_4c;
int4 local_48;
int4 local_3c;
int4 local_38;
int4 local_28;
int4 local_24;
int4 local_20;
int1 extraout_var [12];
for (local_20 = 0; local_20 < (int)(param_3 / 0x20); local_20 = local_20 + 1) {
local_24 = 0.0;
for (local_28 = 0; local_28 < 0x20; local_28 = local_28 + 1) {
uVar1 = *(uint *)(param_1 + (long)(local_20 * 0x20 + local_28) * 4);
if (local_24 <= (float)(uVar1 & _DAT_001b4030)) {
local_48 = (float)(uVar1 & _DAT_001b4030);
}
else {
local_48 = local_24;
}
local_24 = local_48;
}
local_24 = local_24 / DAT_001b86c0;
if ((local_24 != 0.0) || (NAN(local_24))) {
local_4c = DAT_001b4428 / local_24;
}
else {
local_4c = 0.0;
}
uVar3 = ggml_compute_fp32_to_fp16();
auVar5._8_8_ = extraout_XMM0_Qb;
auVar5._0_8_ = extraout_XMM0_Qa;
*(int2 *)(param_2 + (long)local_20 * 0x24) = uVar3;
local_38 = 0;
for (local_3c = 0; auVar6._4_12_ = auVar5._4_12_, local_3c < 0x10; local_3c = local_3c + 1) {
fVar2 = *(float *)(param_1 + (long)(local_20 * 0x20 + 0x10 + local_3c) * 4);
fVar4 = roundf(*(float *)(param_1 + (long)(local_20 * 0x20 + local_3c) * 4) * local_4c);
*(char *)((long)local_3c + 4 + param_2 + (long)local_20 * 0x24) = (char)(int)fVar4;
auVar5._0_4_ = roundf(fVar2 * local_4c);
auVar5._4_12_ = extraout_var;
*(char *)(param_2 + (long)local_20 * 0x24 + 4 + (long)(local_3c + 0x10)) =
(char)(int)auVar5._0_4_;
local_38 = (int)*(char *)(param_2 + (long)local_20 * 0x24 + 4 + (long)(local_3c + 0x10)) +
*(char *)(param_2 + (long)local_20 * 0x24 + 4 + (long)local_3c) + local_38;
}
auVar6._0_4_ = (float)local_38 * local_24;
uVar3 = ggml_compute_fp32_to_fp16(auVar6._0_8_);
*(int2 *)(param_2 + (long)local_20 * 0x24 + 2) = uVar3;
}
return;
}
| |
39,595 | my_mb_wc_cp932 | eloqsql/strings/ctype-cp932.c | static int
my_mb_wc_cp932(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e){
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII: [00-7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
/* JIS-X-0201 Half width Katakana: [A1..DF] -> [U+FF61..U+FF9F] */
if (hi >= 0xA1 && hi <= 0xDF)
{
*pwc= cp932_to_unicode[hi];
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
/* JIS-X-0208-MS [81..9F,E0..FC][40..7E,80..FC] */
if (!(pwc[0]= cp932_to_unicode[(hi << 8) + s[1]]))
return (iscp932head(hi) && iscp932tail(s[1])) ? -2 : MY_CS_ILSEQ;
return 2;
} | O0 | c | my_mb_wc_cp932:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x13a76a
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x13a8c8
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x80, %eax
jge 0x13a792
movslq -0x2c(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x13a8c8
cmpl $0xa1, -0x2c(%rbp)
jl 0x13a7c8
cmpl $0xdf, -0x2c(%rbp)
jg 0x13a7c8
movslq -0x2c(%rbp), %rcx
leaq 0x691f1(%rip), %rax # 0x1a39a0
movzwl (%rax,%rcx,2), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x13a8c8
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x13a7e2
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x13a8c8
movl -0x2c(%rbp), %eax
shll $0x8, %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x691a4(%rip), %rax # 0x1a39a0
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x13a8c1
movl -0x2c(%rbp), %eax
movzbl %al, %ecx
movl $0x81, %eax
cmpl %ecx, %eax
jg 0x13a82d
movl -0x2c(%rbp), %eax
movzbl %al, %eax
cmpl $0x9f, %eax
jle 0x13a854
movl -0x2c(%rbp), %eax
movzbl %al, %edx
xorl %eax, %eax
movl $0xe0, %ecx
cmpl %edx, %ecx
movb %al, -0x2d(%rbp)
jg 0x13a8ac
movl -0x2c(%rbp), %eax
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0xfc, %ecx
movb %al, -0x2d(%rbp)
jg 0x13a8ac
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x40, %eax
cmpl %ecx, %eax
jg 0x13a877
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x7e, %ecx
movb %al, -0x2e(%rbp)
jle 0x13a8a6
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %edx
xorl %eax, %eax
movl $0x80, %ecx
cmpl %edx, %ecx
movb %al, -0x2f(%rbp)
jg 0x13a8a0
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xfc, %eax
setle %al
movb %al, -0x2f(%rbp)
movb -0x2f(%rbp), %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %dl
xorl %eax, %eax
movl $0xfffffffe, %ecx # imm = 0xFFFFFFFE
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x13a8c8
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| my_mb_wc_cp932:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_13A76A
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_13A8C8
loc_13A76A:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
cmp eax, 80h
jge short loc_13A792
movsxd rcx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_13A8C8
loc_13A792:
cmp [rbp+var_2C], 0A1h
jl short loc_13A7C8
cmp [rbp+var_2C], 0DFh
jg short loc_13A7C8
movsxd rcx, [rbp+var_2C]
lea rax, cp932_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_13A8C8
loc_13A7C8:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_13A7E2
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_13A8C8
loc_13A7E2:
mov eax, [rbp+var_2C]
shl eax, 8
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+1]
add eax, ecx
movsxd rcx, eax
lea rax, cp932_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jnz loc_13A8C1
mov eax, [rbp+var_2C]
movzx ecx, al
mov eax, 81h
cmp eax, ecx
jg short loc_13A82D
mov eax, [rbp+var_2C]
movzx eax, al
cmp eax, 9Fh
jle short loc_13A854
loc_13A82D:
mov eax, [rbp+var_2C]
movzx edx, al
xor eax, eax
mov ecx, 0E0h
cmp ecx, edx
mov [rbp+var_2D], al
jg short loc_13A8AC
mov eax, [rbp+var_2C]
movzx ecx, al
xor eax, eax
cmp ecx, 0FCh
mov [rbp+var_2D], al
jg short loc_13A8AC
loc_13A854:
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov eax, 40h ; '@'
cmp eax, ecx
jg short loc_13A877
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov al, 1
cmp ecx, 7Eh ; '~'
mov [rbp+var_2E], al
jle short loc_13A8A6
loc_13A877:
mov rax, [rbp+var_20]
movzx edx, byte ptr [rax+1]
xor eax, eax
mov ecx, 80h
cmp ecx, edx
mov [rbp+var_2F], al
jg short loc_13A8A0
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0FCh
setle al
mov [rbp+var_2F], al
loc_13A8A0:
mov al, [rbp+var_2F]
mov [rbp+var_2E], al
loc_13A8A6:
mov al, [rbp+var_2E]
mov [rbp+var_2D], al
loc_13A8AC:
mov dl, [rbp+var_2D]
xor eax, eax
mov ecx, 0FFFFFFFEh
test dl, 1
cmovnz eax, ecx
mov [rbp+var_4], eax
jmp short loc_13A8C8
loc_13A8C1:
mov [rbp+var_4], 2
loc_13A8C8:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_mb_wc_cp932(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long v4; // rax
unsigned int v5; // eax
bool v7; // [rsp+1h] [rbp-2Fh]
char v8; // [rsp+2h] [rbp-2Eh]
char v9; // [rsp+3h] [rbp-2Dh]
unsigned int v10; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
v10 = *a3;
if ( v10 >= 0x80 )
{
if ( *a3 < 0xA1u || *a3 > 0xDFu )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v4 = cp932_to_unicode[a3[1] + (v10 << 8)];
*a2 = v4;
if ( v4 )
{
return 2;
}
else
{
if ( (unsigned __int8)v10 >= 0x81u && (unsigned __int8)v10 <= 0x9Fu
|| (v9 = 0, (unsigned __int8)v10 >= 0xE0u) && (v9 = 0, (unsigned __int8)v10 <= 0xFCu) )
{
if ( a3[1] < 0x40u || (v8 = 1, a3[1] > 0x7Eu) )
{
v7 = 0;
if ( a3[1] >= 0x80u )
v7 = a3[1] <= 0xFCu;
v8 = v7;
}
v9 = v8;
}
v5 = 0;
if ( (v9 & 1) != 0 )
return (unsigned int)-2;
return v5;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
*a2 = cp932_to_unicode[*a3];
return 1;
}
}
else
{
*a2 = *a3;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| |||
39,596 | my_mb_wc_cp932 | eloqsql/strings/ctype-cp932.c | static int
my_mb_wc_cp932(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e){
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII: [00-7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
/* JIS-X-0201 Half width Katakana: [A1..DF] -> [U+FF61..U+FF9F] */
if (hi >= 0xA1 && hi <= 0xDF)
{
*pwc= cp932_to_unicode[hi];
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
/* JIS-X-0208-MS [81..9F,E0..FC][40..7E,80..FC] */
if (!(pwc[0]= cp932_to_unicode[(hi << 8) + s[1]]))
return (iscp932head(hi) && iscp932tail(s[1])) ? -2 : MY_CS_ILSEQ;
return 2;
} | O3 | c | my_mb_wc_cp932:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xcc86f
movzbl (%rdx), %edi
testb %dil, %dil
js 0xcc855
movq %rdi, (%rsi)
jmp 0xcc86a
leal 0x5f(%rdi), %eax
cmpb $0x3e, %al
ja 0xcc871
leaq 0x524ad(%rip), %rax # 0x11ed10
movzwl (%rax,%rdi,2), %eax
movq %rax, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0xcc86f
movzbl 0x1(%rdx), %eax
movl %edi, %ecx
shll $0x9, %ecx
leal (%rcx,%rax,2), %eax
leaq 0x5247e(%rip), %rcx # 0x11ed10
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0xcc86f
cmpb $-0x80, %dil
setne %al
cmpb $-0x60, %dil
setb %cl
andb %al, %cl
addb $0x20, %dil
cmpb $0x1d, %dil
setb %sil
orb %cl, %sil
xorl %eax, %eax
cmpb $0x1, %sil
jne 0xcc86f
movb 0x1(%rdx), %cl
leal -0x40(%rcx), %edx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpb $0x3f, %dl
jb 0xcc86f
movl $0x0, %eax
testb %cl, %cl
jns 0xcc86f
xorl %eax, %eax
cmpb $-0x3, %cl
setae %al
leal -0x2(,%rax,2), %eax
jmp 0xcc86f
| my_mb_wc_cp932:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_CC86F
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_CC855
mov [rsi], rdi
jmp short loc_CC86A
loc_CC855:
lea eax, [rdi+5Fh]
cmp al, 3Eh ; '>'
ja short loc_CC871
lea rax, cp932_to_unicode
movzx eax, word ptr [rax+rdi*2]
mov [rsi], rax
loc_CC86A:
mov eax, 1
loc_CC86F:
pop rbp
retn
loc_CC871:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_CC86F
movzx eax, byte ptr [rdx+1]
mov ecx, edi
shl ecx, 9
lea eax, [rcx+rax*2]
lea rcx, cp932_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_CC86F
cmp dil, 80h
setnz al
cmp dil, 0A0h
setb cl
and cl, al
add dil, 20h ; ' '
cmp dil, 1Dh
setb sil
or sil, cl
xor eax, eax
cmp sil, 1
jnz short loc_CC86F
mov cl, [rdx+1]
lea edx, [rcx-40h]
mov eax, 0FFFFFFFEh
cmp dl, 3Fh ; '?'
jb short loc_CC86F
mov eax, 0
test cl, cl
jns short loc_CC86F
xor eax, eax
cmp cl, 0FDh
setnb al
lea eax, ds:0FFFFFFFFFFFFFFFEh[rax*2]
jmp loc_CC86F
| long long my_mb_wc_cp932(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
char v7; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x3Eu )
{
*a2 = cp932_to_unicode[v5];
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = cp932_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
{
result = 0LL;
if ( (_BYTE)v5 != 0x80 && (unsigned __int8)v5 < 0xA0u || (unsigned __int8)(v5 + 32) < 0x1Du )
{
v7 = a3[1];
result = 4294967294LL;
if ( (unsigned __int8)(v7 - 64) >= 0x3Fu )
{
result = 0LL;
if ( v7 < 0 )
return 2 * (unsigned int)((unsigned __int8)v7 >= 0xFDu) - 2;
}
}
}
}
}
return result;
}
| my_mb_wc_cp932:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001cc86f
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x001cc855
MOV qword ptr [RSI],RDI
JMP 0x001cc86a
LAB_001cc855:
LEA EAX,[RDI + 0x5f]
CMP AL,0x3e
JA 0x001cc871
LEA RAX,[0x21ed10]
MOVZX EAX,word ptr [RAX + RDI*0x2]
MOV qword ptr [RSI],RAX
LAB_001cc86a:
MOV EAX,0x1
LAB_001cc86f:
POP RBP
RET
LAB_001cc871:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001cc86f
MOVZX EAX,byte ptr [RDX + 0x1]
MOV ECX,EDI
SHL ECX,0x9
LEA EAX,[RCX + RAX*0x2]
LEA RCX,[0x21ed10]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x001cc86f
CMP DIL,0x80
SETNZ AL
CMP DIL,0xa0
SETC CL
AND CL,AL
ADD DIL,0x20
CMP DIL,0x1d
SETC SIL
OR SIL,CL
XOR EAX,EAX
CMP SIL,0x1
JNZ 0x001cc86f
MOV CL,byte ptr [RDX + 0x1]
LEA EDX,[RCX + -0x40]
MOV EAX,0xfffffffe
CMP DL,0x3f
JC 0x001cc86f
MOV EAX,0x0
TEST CL,CL
JNS 0x001cc86f
XOR EAX,EAX
CMP CL,0xfd
SETNC AL
LEA EAX,[-0x2 + RAX*0x2]
JMP 0x001cc86f
|
int my_mb_wc_cp932(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if (0x3e < (byte)(bVar1 + 0x5f)) {
if (param_4 < param_3 + 2) {
return -0x66;
}
uVar2 = *(ushort *)(cp932_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 2;
}
if (0x1c < (byte)(bVar1 + 0x20) && (0x9f < bVar1 || bVar1 == 0x80)) {
return 0;
}
bVar1 = param_3[1];
if ((byte)(bVar1 - 0x40) < 0x3f) {
return -2;
}
if (-1 < (char)bVar1) {
return 0;
}
return (uint)(0xfc < bVar1) * 2 + -2;
}
*param_2 = (ulong)*(ushort *)(cp932_to_unicode + (ulong)bVar1 * 2);
}
else {
*param_2 = (ulong)bVar1;
}
iVar3 = 1;
}
return iVar3;
}
| |
39,597 | calc_record_size | eloqsql/storage/maria/ma_blockrec.c | static void calc_record_size(MARIA_HA *info, const uchar *record,
MARIA_ROW *row)
{
MARIA_SHARE *share= info->s;
uchar *field_length_data;
MARIA_COLUMNDEF *column, *end_column;
uint *null_field_lengths= row->null_field_lengths;
ulong *blob_lengths= row->blob_lengths;
DBUG_ENTER("calc_record_size");
row->normal_length= row->char_length= row->varchar_length=
row->blob_length= row->extents_count= 0;
/* Create empty bitmap and calculate length of each varlength/char field */
bzero(row->empty_bits, share->base.pack_bytes);
field_length_data= row->field_lengths;
for (column= share->columndef + share->base.fixed_not_null_fields,
end_column= share->columndef + share->base.fields;
column < end_column; column++, null_field_lengths++)
{
if ((record[column->null_pos] & column->null_bit))
{
if (column->type != FIELD_BLOB)
*null_field_lengths= 0;
else
*blob_lengths++= 0;
continue;
}
switch (column->type) {
case FIELD_CHECK:
case FIELD_NORMAL: /* Fixed length field */
case FIELD_ZERO:
DBUG_ASSERT(column->empty_bit == 0);
/* fall through */
case FIELD_SKIP_PRESPACE: /* Not packed */
row->normal_length+= column->length;
*null_field_lengths= column->length;
break;
case FIELD_SKIP_ZERO: /* Fixed length field */
if (memcmp(record+ column->offset, maria_zero_string,
column->length) == 0)
{
row->empty_bits[column->empty_pos] |= column->empty_bit;
*null_field_lengths= 0;
}
else
{
row->normal_length+= column->length;
*null_field_lengths= column->length;
}
break;
case FIELD_SKIP_ENDSPACE: /* CHAR */
{
const uchar *pos, *end;
for (pos= record + column->offset, end= pos + column->length;
end > pos && end[-1] == ' '; end--)
;
if (pos == end) /* If empty string */
{
row->empty_bits[column->empty_pos]|= column->empty_bit;
*null_field_lengths= 0;
}
else
{
uint length= (uint) (end - pos);
if (column->length <= 255)
*field_length_data++= (uchar) length;
else
{
int2store(field_length_data, length);
field_length_data+= 2;
}
row->char_length+= length;
*null_field_lengths= length;
}
break;
}
case FIELD_VARCHAR:
{
uint length, field_length_data_length;
const uchar *field_pos= record + column->offset;
/* 256 is correct as this includes the length uchar */
field_length_data[0]= field_pos[0];
if (column->length <= 256)
{
length= (uint) (uchar) *field_pos;
field_length_data_length= 1;
}
else
{
length= uint2korr(field_pos);
field_length_data[1]= field_pos[1];
field_length_data_length= 2;
}
*null_field_lengths= length;
if (!length)
{
row->empty_bits[column->empty_pos]|= column->empty_bit;
break;
}
row->varchar_length+= length;
*null_field_lengths= length;
field_length_data+= field_length_data_length;
break;
}
case FIELD_BLOB:
{
const uchar *field_pos= record + column->offset;
uint size_length= column->length - portable_sizeof_char_ptr;
ulong blob_length= _ma_calc_blob_length(size_length, field_pos);
*blob_lengths++= blob_length;
if (!blob_length)
row->empty_bits[column->empty_pos]|= column->empty_bit;
else
{
row->blob_length+= blob_length;
memcpy(field_length_data, field_pos, size_length);
field_length_data+= size_length;
}
break;
}
default:
DBUG_ASSERT(0);
}
}
row->field_lengths_length= (uint) (field_length_data - row->field_lengths);
/*
- info->row_base_length is base information we must have on a page in first
extent:
- flag byte (1) + is_nulls_extended (0 | 1) + null_bytes + pack_bytes +
table_checksum (0 | 1)
- row->min_length is minimum amount of data we must store on
a page. bitmap code will ensure we get at list this much +
total number of extents and one extent information
- fixed_not_null_fields_length is length of fixed length fields that can't
be compacted
- head_length is the amount of data for the head page
(ie, all fields except blobs)
*/
row->min_length= (info->row_base_length +
(share->base.max_field_lengths ?
size_to_store_key_length(row->field_lengths_length) :
0));
row->head_length= (row->min_length +
share->base.fixed_not_null_fields_length +
row->field_lengths_length +
row->normal_length +
row->char_length + row->varchar_length);
row->total_length= (row->head_length + row->blob_length);
if (row->total_length < share->base.min_block_length)
row->total_length= share->base.min_block_length;
DBUG_PRINT("exit", ("head_length: %lu total_length: %lu",
(ulong) row->head_length, (ulong) row->total_length));
DBUG_VOID_RETURN;
} | O3 | c | calc_record_size:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, -0x68(%rbp)
movq (%rdi), %rbx
movq 0x48(%rdx), %rdi
movq 0x58(%rdx), %r14
movq 0x60(%rdx), %r12
movl $0x0, 0xac(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdx)
movups %xmm0, 0x80(%rdx)
movl 0x3f4(%rbx), %edx
xorl %esi, %esi
callq 0x292b0
movq 0x50(%r13), %rsi
movl 0x3c8(%rbx), %ecx
movl 0x3cc(%rbx), %eax
cmpl %ecx, %eax
jae 0x5c222
leaq 0x70(%r13), %r9
movq %rbx, -0x60(%rbp)
movq 0x588(%rbx), %rdx
imulq $0x38, %rcx, %r10
addq %rdx, %r10
imulq $0x38, %rax, %rbx
addq %rdx, %rbx
leaq 0x841de(%rip), %r11 # 0xe01b8
movq %r9, -0x48(%rbp)
movq %r10, -0x40(%rbp)
movq %r13, -0x58(%rbp)
movq %r15, -0x50(%rbp)
movzwl 0xe(%rbx), %ecx
movb 0x12(%rbx), %dl
movl (%rbx), %eax
testb %dl, (%r15,%rcx)
je 0x5c00f
cmpl $0x4, %eax
jne 0x5c036
movq $0x0, (%r12)
addq $0x8, %r12
jmp 0x5c207
cmpl $0x9, %eax
ja 0x5c207
movl %eax, %eax
movslq (%r11,%rax,4), %rax
addq %r11, %rax
jmpq *%rax
movzwl 0x8(%rbx), %eax
addq %rax, (%r9)
movzwl 0x8(%rbx), %eax
movl %eax, (%r14)
jmp 0x5c207
movl $0x0, (%r14)
jmp 0x5c207
movq %r12, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movl 0x4(%rbx), %edi
addq %r15, %rdi
movzwl 0x8(%rbx), %r12d
leaq 0x39fc24(%rip), %rsi # 0x3fbc80
movq %r12, %rdx
callq 0x29550
testl %eax, %eax
je 0x5c182
movq -0x48(%rbp), %r9
addq %r12, (%r9)
movzwl 0x8(%rbx), %eax
movl %eax, (%r14)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %r12
jmp 0x5c1c3
movq %rsi, -0x38(%rbp)
movl 0x4(%rbx), %r13d
addq %r15, %r13
movzwl 0x8(%rbx), %r15d
addl $-0x8, %r15d
movl %r15d, %edi
movq %r13, %rsi
callq 0x3a377
movq %rax, (%r12)
addq $0x8, %r12
movq %r12, -0x30(%rbp)
testq %rax, %rax
je 0x5c1a1
movq -0x58(%rbp), %rcx
addq %rax, 0x88(%rcx)
movl %r15d, %r15d
movq -0x38(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %rcx, %r13
movq %r15, %rdx
callq 0x29090
movq %r12, %rsi
addq %r15, %rsi
jmp 0x5c1b7
movl 0x4(%rbx), %eax
movb (%r15,%rax), %cl
movb %cl, (%rsi)
cmpw $0x100, 0x8(%rbx) # imm = 0x100
ja 0x5c15a
movzbl (%r15,%rax), %eax
movl $0x1, %ecx
jmp 0x5c167
movq %rsi, %r8
movl 0x4(%rbx), %eax
addq %r15, %rax
movzwl 0x8(%rbx), %ecx
movq %rax, %rsi
xorl %edi, %edi
movq %rdi, %rdx
leaq (%rsi,%rcx), %rdi
cmpq %rax, %rdi
jbe 0x5c133
leaq 0x1(%rdx), %rdi
cmpb $0x20, -0x1(%rsi,%rcx)
leaq -0x1(%rsi), %rsi
je 0x5c118
movq %rcx, %rax
subq %rdx, %rax
je 0x5c1e0
cmpl $0xff, %ecx
movq %r8, %rsi
ja 0x5c1f5
subl %edx, %ecx
movb %cl, (%rsi)
incq %rsi
jmp 0x5c1fe
movzwl (%r15,%rax), %eax
movb %ah, 0x1(%rsi)
movl $0x2, %ecx
movl %eax, (%r14)
testl %eax, %eax
je 0x5c1d0
movl %eax, %edx
addq %rdx, 0x80(%r13)
movl %eax, (%r14)
addq %rcx, %rsi
jmp 0x5c207
movb 0x13(%rbx), %al
movq 0x48(%r13), %rcx
movzwl 0x10(%rbx), %edx
orb %al, (%rcx,%rdx)
movl $0x0, (%r14)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %r12
jmp 0x5c1bf
movb 0x13(%rbx), %al
movq -0x58(%rbp), %r13
movq 0x48(%r13), %rcx
movzwl 0x10(%rbx), %edx
orb %al, (%rcx,%rdx)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %r12
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %r9
movq -0x40(%rbp), %r10
leaq 0x83fea(%rip), %r11 # 0xe01b8
jmp 0x5c207
movb 0x13(%rbx), %al
movq 0x48(%r13), %rcx
movzwl 0x10(%rbx), %edx
orb %al, (%rcx,%rdx)
jmp 0x5c207
movb 0x13(%rbx), %al
movq 0x48(%r13), %rcx
movzwl 0x10(%rbx), %edx
orb %al, (%rcx,%rdx)
xorl %eax, %eax
movq %r8, %rsi
jmp 0x5c204
subl %edx, %ecx
movw %cx, (%rsi)
addq $0x2, %rsi
movl %eax, %ecx
addq %rcx, 0x78(%r13)
movl %eax, (%r14)
addq $0x38, %rbx
addq $0x4, %r14
cmpq %r10, %rbx
jb 0x5bfea
movq 0x50(%r13), %rax
movq -0x60(%rbp), %rbx
jmp 0x5c225
movq %rsi, %rax
subq %rax, %rsi
movl %esi, 0xa8(%r13)
xorl %eax, %eax
cmpl $0xff, %esi
setae %al
xorl %ecx, %ecx
cmpl $0x0, 0x3d4(%rbx)
leaq 0x1(%rax,%rax), %rax
cmovneq %rax, %rcx
movq -0x68(%rbp), %rax
addq 0x610(%rax), %rcx
movq %rcx, 0x68(%r13)
movl 0x3d0(%rbx), %eax
addq %rsi, %rax
addq 0x70(%r13), %rax
addq %rcx, %rax
addq 0x78(%r13), %rax
addq 0x80(%r13), %rax
movl %eax, 0xa0(%r13)
movl %eax, %eax
addq 0x88(%r13), %rax
movq %rax, 0x90(%r13)
movq 0x3b8(%rbx), %rcx
cmpq %rcx, %rax
cmovbeq %rcx, %rax
movq %rax, 0x90(%r13)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| calc_record_size:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r13, rdx
mov r15, rsi
mov [rbp+var_68], rdi
mov rbx, [rdi]
mov rdi, [rdx+48h]
mov r14, [rdx+58h]
mov r12, [rdx+60h]
mov dword ptr [rdx+0ACh], 0
xorps xmm0, xmm0
movups xmmword ptr [rdx+70h], xmm0
movups xmmword ptr [rdx+80h], xmm0
mov edx, [rbx+3F4h]
xor esi, esi
call _memset
mov rsi, [r13+50h]
mov ecx, [rbx+3C8h]
mov eax, [rbx+3CCh]
cmp eax, ecx
jnb loc_5C222
lea r9, [r13+70h]
mov [rbp+var_60], rbx
mov rdx, [rbx+588h]
imul r10, rcx, 38h ; '8'
add r10, rdx
imul rbx, rax, 38h ; '8'
add rbx, rdx
lea r11, jpt_5C021
mov [rbp+var_48], r9
mov [rbp+var_40], r10
mov [rbp+var_58], r13
mov [rbp+var_50], r15
loc_5BFEA:
movzx ecx, word ptr [rbx+0Eh]
mov dl, [rbx+12h]
mov eax, [rbx]
test [r15+rcx], dl
jz short loc_5C00F
cmp eax, 4
jnz short loc_5C036
mov qword ptr [r12], 0
add r12, 8
jmp def_5C021; jumptable 000000000005C021 default case, cases 5,6
loc_5C00F:
cmp eax, 9; switch 10 cases
ja def_5C021; jumptable 000000000005C021 default case, cases 5,6
mov eax, eax
movsxd rax, ds:(jpt_5C021 - 0E01B8h)[r11+rax*4]
add rax, r11
jmp rax; switch jump
loc_5C023:
movzx eax, word ptr [rbx+8]; jumptable 000000000005C021 cases 0,2,7,9
add [r9], rax
movzx eax, word ptr [rbx+8]
mov [r14], eax
jmp def_5C021; jumptable 000000000005C021 default case, cases 5,6
loc_5C036:
mov dword ptr [r14], 0
jmp def_5C021; jumptable 000000000005C021 default case, cases 5,6
loc_5C042:
mov [rbp+var_30], r12; jumptable 000000000005C021 case 3
mov [rbp+var_38], rsi
mov edi, [rbx+4]
add rdi, r15
movzx r12d, word ptr [rbx+8]
lea rsi, maria_zero_string
mov rdx, r12
call _bcmp
test eax, eax
jz loc_5C182
mov r9, [rbp+var_48]
add [r9], r12
movzx eax, word ptr [rbx+8]
mov [r14], eax
mov rsi, [rbp+var_38]
mov r12, [rbp+var_30]
jmp loc_5C1C3
loc_5C087:
mov [rbp+var_38], rsi; jumptable 000000000005C021 case 4
mov r13d, [rbx+4]
add r13, r15
movzx r15d, word ptr [rbx+8]
add r15d, 0FFFFFFF8h
mov edi, r15d
mov rsi, r13
call _ma_calc_blob_length
mov [r12], rax
add r12, 8
mov [rbp+var_30], r12
test rax, rax
jz loc_5C1A1
mov rcx, [rbp+var_58]
add [rcx+88h], rax
mov r15d, r15d
mov r12, [rbp+var_38]
mov rdi, r12
mov rsi, r13
mov r13, rcx
mov rdx, r15
call _memcpy
mov rsi, r12
add rsi, r15
jmp loc_5C1B7
loc_5C0E9:
mov eax, [rbx+4]; jumptable 000000000005C021 case 8
mov cl, [r15+rax]
mov [rsi], cl
cmp word ptr [rbx+8], 100h
ja short loc_5C15A
movzx eax, byte ptr [r15+rax]
mov ecx, 1
jmp short loc_5C167
loc_5C106:
mov r8, rsi; jumptable 000000000005C021 case 1
mov eax, [rbx+4]
add rax, r15
movzx ecx, word ptr [rbx+8]
mov rsi, rax
xor edi, edi
loc_5C118:
mov rdx, rdi
lea rdi, [rsi+rcx]
cmp rdi, rax
jbe short loc_5C133
lea rdi, [rdx+1]
cmp byte ptr [rsi+rcx-1], 20h ; ' '
lea rsi, [rsi-1]
jz short loc_5C118
loc_5C133:
mov rax, rcx
sub rax, rdx
jz loc_5C1E0
cmp ecx, 0FFh
mov rsi, r8
ja loc_5C1F5
sub ecx, edx
mov [rsi], cl
inc rsi
jmp loc_5C1FE
loc_5C15A:
movzx eax, word ptr [r15+rax]
mov [rsi+1], ah
mov ecx, 2
loc_5C167:
mov [r14], eax
test eax, eax
jz short loc_5C1D0
mov edx, eax
add [r13+80h], rdx
mov [r14], eax
add rsi, rcx
jmp def_5C021; jumptable 000000000005C021 default case, cases 5,6
loc_5C182:
mov al, [rbx+13h]
mov rcx, [r13+48h]
movzx edx, word ptr [rbx+10h]
or [rcx+rdx], al
mov dword ptr [r14], 0
mov rsi, [rbp+var_38]
mov r12, [rbp+var_30]
jmp short loc_5C1BF
loc_5C1A1:
mov al, [rbx+13h]
mov r13, [rbp+var_58]
mov rcx, [r13+48h]
movzx edx, word ptr [rbx+10h]
or [rcx+rdx], al
mov rsi, [rbp+var_38]
loc_5C1B7:
mov r12, [rbp+var_30]
mov r15, [rbp+var_50]
loc_5C1BF:
mov r9, [rbp+var_48]
loc_5C1C3:
mov r10, [rbp+var_40]
lea r11, jpt_5C021
jmp short def_5C021; jumptable 000000000005C021 default case, cases 5,6
loc_5C1D0:
mov al, [rbx+13h]
mov rcx, [r13+48h]
movzx edx, word ptr [rbx+10h]
or [rcx+rdx], al
jmp short def_5C021; jumptable 000000000005C021 default case, cases 5,6
loc_5C1E0:
mov al, [rbx+13h]
mov rcx, [r13+48h]
movzx edx, word ptr [rbx+10h]
or [rcx+rdx], al
xor eax, eax
mov rsi, r8
jmp short loc_5C204
loc_5C1F5:
sub ecx, edx
mov [rsi], cx
add rsi, 2
loc_5C1FE:
mov ecx, eax
add [r13+78h], rcx
loc_5C204:
mov [r14], eax
def_5C021:
add rbx, 38h ; '8'; jumptable 000000000005C021 default case, cases 5,6
add r14, 4
cmp rbx, r10
jb loc_5BFEA
mov rax, [r13+50h]
mov rbx, [rbp+var_60]
jmp short loc_5C225
loc_5C222:
mov rax, rsi
loc_5C225:
sub rsi, rax
mov [r13+0A8h], esi
xor eax, eax
cmp esi, 0FFh
setnb al
xor ecx, ecx
cmp dword ptr [rbx+3D4h], 0
lea rax, [rax+rax+1]
cmovnz rcx, rax
mov rax, [rbp+var_68]
add rcx, [rax+610h]
mov [r13+68h], rcx
mov eax, [rbx+3D0h]
add rax, rsi
add rax, [r13+70h]
add rax, rcx
add rax, [r13+78h]
add rax, [r13+80h]
mov [r13+0A0h], eax
mov eax, eax
add rax, [r13+88h]
mov [r13+90h], rax
mov rcx, [rbx+3B8h]
cmp rax, rcx
cmovbe rax, rcx
mov [r13+90h], rax
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long calc_record_size(long long *a1, long long a2, long long a3)
{
long long v3; // r13
long long v5; // rbx
long long v6; // rdi
unsigned int *v7; // r14
unsigned long long *v8; // r12
_BYTE *v9; // rsi
long long v10; // rcx
long long v11; // rax
_QWORD *v12; // r9
long long v13; // rdx
unsigned long long v14; // r10
int *v15; // rbx
int v16; // eax
long long v17; // r12
unsigned __int8 *v18; // r13
unsigned int v19; // r15d
unsigned long long v20; // rax
unsigned __int8 *v21; // rsi
long long v22; // rax
unsigned int v23; // eax
long long v24; // rcx
_WORD *v25; // r8
long long v26; // rcx
long long v27; // rsi
long long v28; // rdi
long long v29; // rdx
bool v30; // zf
unsigned int v31; // eax
long long v32; // rax
_BYTE *v33; // rsi
long long v34; // rcx
long long v35; // rcx
_BYTE *v36; // rax
unsigned long long result; // rax
long long v39; // [rsp+10h] [rbp-60h]
long long v40; // [rsp+18h] [rbp-58h]
long long v41; // [rsp+20h] [rbp-50h]
_QWORD *v42; // [rsp+28h] [rbp-48h]
unsigned long long v43; // [rsp+30h] [rbp-40h]
_BYTE *v44; // [rsp+38h] [rbp-38h]
unsigned long long *v45; // [rsp+40h] [rbp-30h]
v3 = a3;
v5 = *a1;
v6 = *(_QWORD *)(a3 + 72);
v7 = *(unsigned int **)(a3 + 88);
v8 = *(unsigned long long **)(a3 + 96);
*(_DWORD *)(a3 + 172) = 0;
*(_OWORD *)(a3 + 112) = 0LL;
*(_OWORD *)(a3 + 128) = 0LL;
memset(v6, 0LL, *(unsigned int *)(v5 + 1012));
v9 = *(_BYTE **)(v3 + 80);
v10 = *(unsigned int *)(v5 + 968);
v11 = *(unsigned int *)(v5 + 972);
if ( (unsigned int)v11 >= (unsigned int)v10 )
{
v32 = *(_QWORD *)(v3 + 80);
}
else
{
v12 = (_QWORD *)(v3 + 112);
v39 = v5;
v13 = *(_QWORD *)(v5 + 1416);
v14 = v13 + 56 * v10;
v15 = (int *)(v13 + 56 * v11);
v42 = (_QWORD *)(v3 + 112);
v43 = v14;
v40 = v3;
v41 = a2;
do
{
v16 = *v15;
if ( (*((_BYTE *)v15 + 18) & *(_BYTE *)(a2 + *((unsigned __int16 *)v15 + 7))) != 0 )
{
if ( v16 == 4 )
*v8++ = 0LL;
else
*v7 = 0;
}
else
{
switch ( v16 )
{
case 0:
case 2:
case 7:
case 9:
*v12 += *((unsigned __int16 *)v15 + 4);
*v7 = *((unsigned __int16 *)v15 + 4);
break;
case 1:
v25 = v9;
v26 = *((unsigned __int16 *)v15 + 4);
v27 = a2 + (unsigned int)v15[1];
v28 = 0LL;
do
{
v29 = v28;
if ( v27 + v26 <= a2 + (unsigned long long)(unsigned int)v15[1] )
break;
++v28;
v30 = *(_BYTE *)(v27 + v26 - 1) == 32;
--v27;
}
while ( v30 );
v31 = v26 - v29;
if ( v26 == v29 )
{
*(_BYTE *)(*(_QWORD *)(v3 + 72) + *((unsigned __int16 *)v15 + 8)) |= *((_BYTE *)v15 + 19);
v31 = 0;
v9 = v25;
}
else
{
if ( (unsigned int)v26 > 0xFF )
{
*v25 = v26 - v29;
v9 = v25 + 1;
}
else
{
*(_BYTE *)v25 = v26 - v29;
v9 = (char *)v25 + 1;
}
*(_QWORD *)(v3 + 120) += v31;
}
*v7 = v31;
break;
case 3:
v45 = v8;
v17 = *((unsigned __int16 *)v15 + 4);
if ( (unsigned int)bcmp(a2 + (unsigned int)v15[1], &maria_zero_string, v17) )
{
v12 = v42;
*v42 += v17;
*v7 = *((unsigned __int16 *)v15 + 4);
v8 = v45;
goto LABEL_28;
}
*(_BYTE *)(*(_QWORD *)(v3 + 72) + *((unsigned __int16 *)v15 + 8)) |= *((_BYTE *)v15 + 19);
*v7 = 0;
v8 = v45;
goto LABEL_27;
case 4:
v44 = v9;
v18 = (unsigned __int8 *)(a2 + (unsigned int)v15[1]);
v19 = *((unsigned __int16 *)v15 + 4) - 8;
v20 = ma_calc_blob_length(v19, v18);
*v8 = v20;
if ( v20 )
{
*(_QWORD *)(v40 + 136) += v20;
v21 = v18;
v3 = v40;
memcpy(v44, v21, v19);
v9 = &v44[v19];
}
else
{
v3 = v40;
*(_BYTE *)(*(_QWORD *)(v40 + 72) + *((unsigned __int16 *)v15 + 8)) |= *((_BYTE *)v15 + 19);
}
++v8;
a2 = v41;
LABEL_27:
v12 = v42;
LABEL_28:
v14 = v43;
break;
case 8:
v22 = (unsigned int)v15[1];
*v9 = *(_BYTE *)(a2 + v22);
if ( *((_WORD *)v15 + 4) > 0x100u )
{
v23 = *(unsigned __int16 *)(a2 + v22);
v9[1] = BYTE1(v23);
v24 = 2LL;
}
else
{
v23 = *(unsigned __int8 *)(a2 + v22);
v24 = 1LL;
}
*v7 = v23;
if ( v23 )
{
*(_QWORD *)(v3 + 128) += v23;
*v7 = v23;
v9 += v24;
}
else
{
*(_BYTE *)(*(_QWORD *)(v3 + 72) + *((unsigned __int16 *)v15 + 8)) |= *((_BYTE *)v15 + 19);
}
break;
default:
break;
}
}
v15 += 14;
++v7;
}
while ( (unsigned long long)v15 < v14 );
v32 = *(_QWORD *)(v3 + 80);
v5 = v39;
}
v33 = &v9[-v32];
*(_DWORD *)(v3 + 168) = (_DWORD)v33;
v34 = 0LL;
if ( *(_DWORD *)(v5 + 980) )
v34 = 2LL * ((unsigned int)v33 >= 0xFF) + 1;
v35 = a1[194] + v34;
*(_QWORD *)(v3 + 104) = v35;
v36 = &v33[*(unsigned int *)(v5 + 976) + *(_QWORD *)(v3 + 112) + v35 + *(_QWORD *)(v3 + 120) + *(_QWORD *)(v3 + 128)];
*(_DWORD *)(v3 + 160) = (_DWORD)v36;
result = *(_QWORD *)(v3 + 136) + (unsigned int)v36;
*(_QWORD *)(v3 + 144) = result;
if ( result <= *(_QWORD *)(v5 + 952) )
result = *(_QWORD *)(v5 + 952);
*(_QWORD *)(v3 + 144) = result;
return result;
}
| calc_record_size:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R13,RDX
MOV R15,RSI
MOV qword ptr [RBP + -0x68],RDI
MOV RBX,qword ptr [RDI]
MOV RDI,qword ptr [RDX + 0x48]
MOV R14,qword ptr [RDX + 0x58]
MOV R12,qword ptr [RDX + 0x60]
MOV dword ptr [RDX + 0xac],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDX + 0x70],XMM0
MOVUPS xmmword ptr [RDX + 0x80],XMM0
MOV EDX,dword ptr [RBX + 0x3f4]
XOR ESI,ESI
CALL 0x001292b0
MOV RSI,qword ptr [R13 + 0x50]
MOV ECX,dword ptr [RBX + 0x3c8]
MOV EAX,dword ptr [RBX + 0x3cc]
CMP EAX,ECX
JNC 0x0015c222
LEA R9,[R13 + 0x70]
MOV qword ptr [RBP + -0x60],RBX
MOV RDX,qword ptr [RBX + 0x588]
IMUL R10,RCX,0x38
ADD R10,RDX
IMUL RBX,RAX,0x38
ADD RBX,RDX
LEA R11,[0x1e01b8]
MOV qword ptr [RBP + -0x48],R9
MOV qword ptr [RBP + -0x40],R10
MOV qword ptr [RBP + -0x58],R13
MOV qword ptr [RBP + -0x50],R15
LAB_0015bfea:
MOVZX ECX,word ptr [RBX + 0xe]
MOV DL,byte ptr [RBX + 0x12]
MOV EAX,dword ptr [RBX]
TEST byte ptr [R15 + RCX*0x1],DL
JZ 0x0015c00f
CMP EAX,0x4
JNZ 0x0015c036
MOV qword ptr [R12],0x0
ADD R12,0x8
JMP 0x0015c207
LAB_0015c00f:
CMP EAX,0x9
JA 0x0015c207
MOV EAX,EAX
MOVSXD RAX,dword ptr [R11 + RAX*0x4]
ADD RAX,R11
switchD:
JMP RAX
caseD_0:
MOVZX EAX,word ptr [RBX + 0x8]
ADD qword ptr [R9],RAX
MOVZX EAX,word ptr [RBX + 0x8]
MOV dword ptr [R14],EAX
JMP 0x0015c207
LAB_0015c036:
MOV dword ptr [R14],0x0
JMP 0x0015c207
caseD_3:
MOV qword ptr [RBP + -0x30],R12
MOV qword ptr [RBP + -0x38],RSI
MOV EDI,dword ptr [RBX + 0x4]
ADD RDI,R15
MOVZX R12D,word ptr [RBX + 0x8]
LEA RSI,[0x4fbc80]
MOV RDX,R12
CALL 0x00129550
TEST EAX,EAX
JZ 0x0015c182
MOV R9,qword ptr [RBP + -0x48]
ADD qword ptr [R9],R12
MOVZX EAX,word ptr [RBX + 0x8]
MOV dword ptr [R14],EAX
MOV RSI,qword ptr [RBP + -0x38]
MOV R12,qword ptr [RBP + -0x30]
JMP 0x0015c1c3
caseD_4:
MOV qword ptr [RBP + -0x38],RSI
MOV R13D,dword ptr [RBX + 0x4]
ADD R13,R15
MOVZX R15D,word ptr [RBX + 0x8]
ADD R15D,-0x8
MOV EDI,R15D
MOV RSI,R13
CALL 0x0013a377
MOV qword ptr [R12],RAX
ADD R12,0x8
MOV qword ptr [RBP + -0x30],R12
TEST RAX,RAX
JZ 0x0015c1a1
MOV RCX,qword ptr [RBP + -0x58]
ADD qword ptr [RCX + 0x88],RAX
MOV R15D,R15D
MOV R12,qword ptr [RBP + -0x38]
MOV RDI,R12
MOV RSI,R13
MOV R13,RCX
MOV RDX,R15
CALL 0x00129090
MOV RSI,R12
ADD RSI,R15
JMP 0x0015c1b7
caseD_8:
MOV EAX,dword ptr [RBX + 0x4]
MOV CL,byte ptr [R15 + RAX*0x1]
MOV byte ptr [RSI],CL
CMP word ptr [RBX + 0x8],0x100
JA 0x0015c15a
MOVZX EAX,byte ptr [R15 + RAX*0x1]
MOV ECX,0x1
JMP 0x0015c167
caseD_1:
MOV R8,RSI
MOV EAX,dword ptr [RBX + 0x4]
ADD RAX,R15
MOVZX ECX,word ptr [RBX + 0x8]
MOV RSI,RAX
XOR EDI,EDI
LAB_0015c118:
MOV RDX,RDI
LEA RDI,[RSI + RCX*0x1]
CMP RDI,RAX
JBE 0x0015c133
LEA RDI,[RDX + 0x1]
CMP byte ptr [RSI + RCX*0x1 + -0x1],0x20
LEA RSI,[RSI + -0x1]
JZ 0x0015c118
LAB_0015c133:
MOV RAX,RCX
SUB RAX,RDX
JZ 0x0015c1e0
CMP ECX,0xff
MOV RSI,R8
JA 0x0015c1f5
SUB ECX,EDX
MOV byte ptr [RSI],CL
INC RSI
JMP 0x0015c1fe
LAB_0015c15a:
MOVZX EAX,word ptr [R15 + RAX*0x1]
MOV byte ptr [RSI + 0x1],AH
MOV ECX,0x2
LAB_0015c167:
MOV dword ptr [R14],EAX
TEST EAX,EAX
JZ 0x0015c1d0
MOV EDX,EAX
ADD qword ptr [R13 + 0x80],RDX
MOV dword ptr [R14],EAX
ADD RSI,RCX
JMP 0x0015c207
LAB_0015c182:
MOV AL,byte ptr [RBX + 0x13]
MOV RCX,qword ptr [R13 + 0x48]
MOVZX EDX,word ptr [RBX + 0x10]
OR byte ptr [RCX + RDX*0x1],AL
MOV dword ptr [R14],0x0
MOV RSI,qword ptr [RBP + -0x38]
MOV R12,qword ptr [RBP + -0x30]
JMP 0x0015c1bf
LAB_0015c1a1:
MOV AL,byte ptr [RBX + 0x13]
MOV R13,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [R13 + 0x48]
MOVZX EDX,word ptr [RBX + 0x10]
OR byte ptr [RCX + RDX*0x1],AL
MOV RSI,qword ptr [RBP + -0x38]
LAB_0015c1b7:
MOV R12,qword ptr [RBP + -0x30]
MOV R15,qword ptr [RBP + -0x50]
LAB_0015c1bf:
MOV R9,qword ptr [RBP + -0x48]
LAB_0015c1c3:
MOV R10,qword ptr [RBP + -0x40]
LEA R11,[0x1e01b8]
JMP 0x0015c207
LAB_0015c1d0:
MOV AL,byte ptr [RBX + 0x13]
MOV RCX,qword ptr [R13 + 0x48]
MOVZX EDX,word ptr [RBX + 0x10]
OR byte ptr [RCX + RDX*0x1],AL
JMP 0x0015c207
LAB_0015c1e0:
MOV AL,byte ptr [RBX + 0x13]
MOV RCX,qword ptr [R13 + 0x48]
MOVZX EDX,word ptr [RBX + 0x10]
OR byte ptr [RCX + RDX*0x1],AL
XOR EAX,EAX
MOV RSI,R8
JMP 0x0015c204
LAB_0015c1f5:
SUB ECX,EDX
MOV word ptr [RSI],CX
ADD RSI,0x2
LAB_0015c1fe:
MOV ECX,EAX
ADD qword ptr [R13 + 0x78],RCX
LAB_0015c204:
MOV dword ptr [R14],EAX
caseD_5:
ADD RBX,0x38
ADD R14,0x4
CMP RBX,R10
JC 0x0015bfea
MOV RAX,qword ptr [R13 + 0x50]
MOV RBX,qword ptr [RBP + -0x60]
JMP 0x0015c225
LAB_0015c222:
MOV RAX,RSI
LAB_0015c225:
SUB RSI,RAX
MOV dword ptr [R13 + 0xa8],ESI
XOR EAX,EAX
CMP ESI,0xff
SETNC AL
XOR ECX,ECX
CMP dword ptr [RBX + 0x3d4],0x0
LEA RAX,[RAX + RAX*0x1 + 0x1]
CMOVNZ RCX,RAX
MOV RAX,qword ptr [RBP + -0x68]
ADD RCX,qword ptr [RAX + 0x610]
MOV qword ptr [R13 + 0x68],RCX
MOV EAX,dword ptr [RBX + 0x3d0]
ADD RAX,RSI
ADD RAX,qword ptr [R13 + 0x70]
ADD RAX,RCX
ADD RAX,qword ptr [R13 + 0x78]
ADD RAX,qword ptr [R13 + 0x80]
MOV dword ptr [R13 + 0xa0],EAX
MOV EAX,EAX
ADD RAX,qword ptr [R13 + 0x88]
MOV qword ptr [R13 + 0x90],RAX
MOV RCX,qword ptr [RBX + 0x3b8]
CMP RAX,RCX
CMOVBE RAX,RCX
MOV qword ptr [R13 + 0x90],RAX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void calc_record_size(long *param_1,long param_2,long param_3)
{
long *plVar1;
byte *pbVar2;
long lVar3;
ushort uVar4;
long lVar5;
int iVar6;
uint uVar7;
ulong uVar8;
short *psVar9;
ulong uVar10;
long lVar11;
long lVar12;
int *piVar13;
uint uVar14;
short *__dest;
long lVar15;
long *plVar16;
uint *puVar17;
uint uVar18;
lVar5 = *param_1;
puVar17 = *(uint **)(param_3 + 0x58);
plVar16 = *(long **)(param_3 + 0x60);
*(int4 *)(param_3 + 0xac) = 0;
*(int8 *)(param_3 + 0x70) = 0;
*(int8 *)(param_3 + 0x78) = 0;
*(int8 *)(param_3 + 0x80) = 0;
*(int8 *)(param_3 + 0x88) = 0;
memset(*(void **)(param_3 + 0x48),0,(ulong)*(uint *)(lVar5 + 0x3f4));
psVar9 = *(short **)(param_3 + 0x50);
uVar14 = *(uint *)(lVar5 + 0x3c8);
__dest = psVar9;
if (*(uint *)(lVar5 + 0x3cc) < uVar14) {
plVar1 = (long *)(param_3 + 0x70);
lVar12 = *(long *)(lVar5 + 0x588);
piVar13 = (int *)((ulong)*(uint *)(lVar5 + 0x3cc) * 0x38 + lVar12);
do {
if ((*(byte *)(param_2 + (ulong)*(ushort *)((long)piVar13 + 0xe)) &
*(byte *)((long)piVar13 + 0x12)) == 0) {
switch(*piVar13) {
case 0:
case 2:
case 7:
case 9:
*plVar1 = *plVar1 + (ulong)*(ushort *)(piVar13 + 2);
*puVar17 = (uint)*(ushort *)(piVar13 + 2);
break;
case 1:
uVar4 = *(ushort *)(piVar13 + 2);
uVar8 = (ulong)uVar4;
uVar10 = (ulong)(uint)piVar13[1] + param_2;
lVar11 = 0;
do {
lVar15 = lVar11;
if (uVar10 + uVar8 <= (ulong)(uint)piVar13[1] + param_2) break;
lVar3 = uVar10 - 1;
uVar10 = uVar10 - 1;
lVar11 = lVar15 + 1;
} while (*(char *)(lVar3 + uVar8) == ' ');
uVar8 = uVar8 - lVar15;
if (uVar8 == 0) {
pbVar2 = (byte *)(*(long *)(param_3 + 0x48) + (ulong)*(ushort *)(piVar13 + 4));
*pbVar2 = *pbVar2 | *(byte *)((long)piVar13 + 0x13);
uVar8 = 0;
}
else {
if (uVar4 < 0x100) {
*(char *)__dest = (char)uVar4 - (char)lVar15;
__dest = (short *)((long)__dest + 1);
}
else {
*__dest = uVar4 - (short)lVar15;
__dest = __dest + 1;
}
*(long *)(param_3 + 0x78) = *(long *)(param_3 + 0x78) + (uVar8 & 0xffffffff);
}
*puVar17 = (uint)uVar8;
break;
case 3:
uVar4 = *(ushort *)(piVar13 + 2);
iVar6 = bcmp((void *)((ulong)(uint)piVar13[1] + param_2),maria_zero_string,(ulong)uVar4);
if (iVar6 == 0) {
pbVar2 = (byte *)(*(long *)(param_3 + 0x48) + (ulong)*(ushort *)(piVar13 + 4));
*pbVar2 = *pbVar2 | *(byte *)((long)piVar13 + 0x13);
*puVar17 = 0;
}
else {
*plVar1 = *plVar1 + (ulong)uVar4;
*puVar17 = (uint)*(ushort *)(piVar13 + 2);
}
break;
case 4:
uVar7 = piVar13[1];
uVar18 = *(ushort *)(piVar13 + 2) - 8;
lVar11 = _ma_calc_blob_length(uVar18,(void *)((ulong)uVar7 + param_2));
*plVar16 = lVar11;
plVar16 = plVar16 + 1;
if (lVar11 == 0) {
pbVar2 = (byte *)(*(long *)(param_3 + 0x48) + (ulong)*(ushort *)(piVar13 + 4));
*pbVar2 = *pbVar2 | *(byte *)((long)piVar13 + 0x13);
}
else {
*(long *)(param_3 + 0x88) = *(long *)(param_3 + 0x88) + lVar11;
memcpy(__dest,(void *)((ulong)uVar7 + param_2),(ulong)uVar18);
__dest = (short *)((long)__dest + (ulong)uVar18);
}
break;
case 8:
uVar10 = (ulong)(uint)piVar13[1];
*(char *)__dest = *(char *)(param_2 + uVar10);
if (*(ushort *)(piVar13 + 2) < 0x101) {
uVar7 = (uint)*(byte *)(param_2 + uVar10);
lVar11 = 1;
}
else {
uVar7 = (uint)*(ushort *)(param_2 + uVar10);
*(char *)((long)__dest + 1) = (char)(*(ushort *)(param_2 + uVar10) >> 8);
lVar11 = 2;
}
*puVar17 = uVar7;
if (uVar7 == 0) {
pbVar2 = (byte *)(*(long *)(param_3 + 0x48) + (ulong)*(ushort *)(piVar13 + 4));
*pbVar2 = *pbVar2 | *(byte *)((long)piVar13 + 0x13);
}
else {
*(long *)(param_3 + 0x80) = *(long *)(param_3 + 0x80) + (ulong)uVar7;
*puVar17 = uVar7;
__dest = (short *)((long)__dest + lVar11);
}
}
}
else if (*piVar13 == 4) {
*plVar16 = 0;
plVar16 = plVar16 + 1;
}
else {
*puVar17 = 0;
}
piVar13 = piVar13 + 0xe;
puVar17 = puVar17 + 1;
} while (piVar13 < (int *)((ulong)uVar14 * 0x38 + lVar12));
psVar9 = *(short **)(param_3 + 0x50);
}
uVar14 = (int)__dest - (int)psVar9;
*(uint *)(param_3 + 0xa8) = uVar14;
lVar12 = 0;
if (*(int *)(lVar5 + 0x3d4) != 0) {
lVar12 = (ulong)(0xfe < uVar14) * 2 + 1;
}
lVar11 = param_1[0xc2];
*(long *)(param_3 + 0x68) = lVar12 + lVar11;
uVar14 = *(int *)(lVar5 + 0x3d0) + uVar14 + (int)*(int8 *)(param_3 + 0x70) +
(int)(lVar12 + lVar11) + (int)*(int8 *)(param_3 + 0x78) +
(int)*(int8 *)(param_3 + 0x80);
*(uint *)(param_3 + 0xa0) = uVar14;
uVar10 = (ulong)uVar14 + *(long *)(param_3 + 0x88);
*(ulong *)(param_3 + 0x90) = uVar10;
if (uVar10 <= *(ulong *)(lVar5 + 0x3b8)) {
uVar10 = *(ulong *)(lVar5 + 0x3b8);
}
*(ulong *)(param_3 + 0x90) = uVar10;
return;
}
| |
39,598 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) | llama.cpp/common/json.hpp | void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
{
//not initialized (e.g. due to exception in the ctor)
return;
}
if (t == value_t::array || t == value_t::object)
{
// flatten the current json_value to a heap-allocated stack
std::vector<basic_json> stack;
// move the top-level items to stack
if (t == value_t::array)
{
stack.reserve(array->size());
std::move(array->begin(), array->end(), std::back_inserter(stack));
}
else
{
stack.reserve(object->size());
for (auto&& it : *object)
{
stack.push_back(std::move(it.second));
}
}
while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
stack.pop_back();
// if current_item is array/object, move
// its children to the stack to be processed later
if (current_item.is_array())
{
std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
current_item.m_data.m_value.array->clear();
}
else if (current_item.is_object())
{
for (auto&& it : *current_item.m_data.m_value.object)
{
stack.push_back(std::move(it.second));
}
current_item.m_data.m_value.object->clear();
}
// it's now safe that current_item get destructed
// since it doesn't have any children
}
}
switch (t)
{
case value_t::object:
{
AllocatorType<object_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
break;
}
case value_t::array:
{
AllocatorType<array_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
break;
}
case value_t::string:
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
break;
}
case value_t::binary:
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
break;
}
case value_t::null:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::discarded:
default:
{
break;
}
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, %esi
sete %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x894b0
movl %esi, %r14d
testq %rax, %rax
sete %cl
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
testb %cl, %sil
jne 0x894b0
movq %rdi, %rbx
leal -0x1(%r14), %ecx
cmpb $0x1, %cl
ja 0x8942b
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x4, %rsi
cmpb $0x2, %r14b
jne 0x892d1
movq %rsp, %rdi
callq 0x894f4
movq (%rbx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
subq %r15, %r13
sarq $0x4, %r13
testq %r13, %r13
jle 0x89312
incq %r13
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x884c0
addq $0x10, %r15
decq %r13
cmpq $0x1, %r13
ja 0x892b7
jmp 0x89312
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rax
movq %rsp, %rdi
movq %rax, %rsi
callq 0x894f4
movq (%rbx), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x89312
movq %rsp, %r15
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x884c0
addq $0x30, %r12
cmpq %r13, %r12
jne 0x892fc
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
je 0x89423
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq -0x10(%r13), %rdi
movups -0x10(%r13), %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %esi, %esi
callq 0x846aa
movb $0x0, -0x10(%r13)
movq $0x0, -0x8(%r13)
movq %r15, %rdi
movl $0x1, %esi
callq 0x846aa
movq 0x8(%rsp), %r13
addq $-0x10, %r13
movq %r13, 0x8(%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x846aa
movq %r13, %rdi
callq 0x88dc4
movzbl 0x20(%rsp), %eax
cmpl $0x1, %eax
je 0x893cc
cmpl $0x2, %eax
jne 0x89402
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
subq %r13, %rbp
sarq $0x4, %rbp
testq %rbp, %rbp
jle 0x893c2
incq %rbp
movq %r12, %rdi
movq %r13, %rsi
callq 0x884c0
addq $0x10, %r13
decq %rbp
cmpq $0x1, %rbp
jg 0x893a2
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq %r13, %rsi
callq 0x89648
jmp 0x89402
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
cmpq %rbp, %r13
je 0x893fa
leaq 0x20(%r13), %rsi
movq %r12, %rdi
callq 0x884c0
addq $0x30, %r13
cmpq %rbp, %r13
jne 0x893dd
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq %r13, %rsi
callq 0x8968e
movq %r15, %rdi
xorl %esi, %esi
callq 0x846aa
movq %r15, %rdi
callq 0x88dc4
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
jne 0x89329
movq %rsp, %rdi
callq 0x895f6
movzbl %r14b, %eax
decl %eax
cmpl $0x7, %eax
ja 0x894b0
leaq 0x89c03(%rip), %rcx # 0x113040
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x89748
jmp 0x8946d
movq (%rbx), %rdi
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x89470
movq (%rcx), %rsi
incq %rsi
movq %rax, %rdi
callq 0x20170
movq (%rbx), %rdi
movl $0x20, %esi
jmp 0x894ab
movq (%rbx), %rdi
callq 0x895f6
movq (%rbx), %rdi
movl $0x18, %esi
jmp 0x894ab
movq (%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x894a6
movq 0x10(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x20170
movq (%rbx), %rdi
movl $0x28, %esi
callq 0x20170
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x894c3
jmp 0x894c3
movq %rax, %rbx
jmp 0x894e4
jmp 0x894ca
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x846aa
movq %r14, %rdi
callq 0x88dc4
movq %rsp, %rdi
callq 0x895f6
movq %rbx, %rdi
callq 0x20ae0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
cmp esi, 1
setz cl
mov rax, [rdi]
test rax, rax
setz dl
test cl, dl
jnz def_89444; jumptable 0000000000089444 default case, cases 4-7
mov r14d, esi
test rax, rax
setz cl
mov edx, r14d
and dl, 0FEh
cmp dl, 2
setz dl
cmp r14b, 8
setz sil
or sil, dl
test sil, cl
jnz def_89444; jumptable 0000000000089444 default case, cases 4-7
mov rbx, rdi
lea ecx, [r14-1]
cmp cl, 1
ja loc_8942B
xorps xmm0, xmm0
movaps [rsp+68h+var_68], xmm0
mov [rsp+68h+var_58], 0
mov rsi, [rax+8]
sub rsi, [rax]
sar rsi, 4
cmp r14b, 2
jnz short loc_892D1
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; 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>>::reserve(ulong)
mov rax, [rbx]
mov r15, [rax]
mov r13, [rax+8]
sub r13, r15
sar r13, 4
test r13, r13
jle short loc_89312
inc r13
mov r12, rsp
loc_892B7:
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
add r15, 10h
dec r13
cmp r13, 1
ja short loc_892B7
jmp short loc_89312
loc_892D1:
mov rax, 0AAAAAAAAAAAAAAABh
imul rax, rsi
mov rdi, rsp
mov rsi, rax
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; 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>>::reserve(ulong)
mov rax, [rbx]
mov r12, [rax]
mov r13, [rax+8]
cmp r12, r13
jz short loc_89312
mov r15, rsp
loc_892FC:
lea rsi, [r12+20h]
mov rdi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
add r12, 30h ; '0'
cmp r12, r13
jnz short loc_892FC
loc_89312:
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jz loc_89423
lea r15, [rsp+68h+var_48]
mov r12, rsp
loc_89329:
lea rdi, [r13-10h]
movups xmm0, xmmword ptr [r13-10h]
movaps [rsp+68h+var_48], xmm0
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r13-10h], 0
mov qword ptr [r13-8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov r13, qword ptr [rsp+68h+var_68+8]
add r13, 0FFFFFFFFFFFFFFF0h
mov qword ptr [rsp+68h+var_68+8], r13
mov rdi, r13
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_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, r13
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()
movzx eax, byte ptr [rsp+68h+var_48]
cmp eax, 1
jz short loc_893CC
cmp eax, 2
jnz short loc_89402
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
mov rbp, [rdi+8]
sub rbp, r13
sar rbp, 4
test rbp, rbp
jle short loc_893C2
inc rbp
loc_893A2:
mov rdi, r12
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
add r13, 10h
dec rbp
cmp rbp, 1
jg short loc_893A2
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
loc_893C2:
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE15_M_erase_at_endEPSD_; 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>>::_M_erase_at_end(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>*)
jmp short loc_89402
loc_893CC:
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
mov rbp, [rdi+8]
cmp r13, rbp
jz short loc_893FA
loc_893DD:
lea rsi, [r13+20h]
mov rdi, r12
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
add r13, 30h ; '0'
cmp r13, rbp
jnz short loc_893DD
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
loc_893FA:
mov rsi, r13
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE15_M_erase_at_endEPSG_; 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>>>::_M_erase_at_end(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>>*)
loc_89402:
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jnz loc_89329
loc_89423:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; 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>>::~vector()
loc_8942B:
movzx eax, r14b
dec eax; switch 8 cases
cmp eax, 7
ja short def_89444; jumptable 0000000000089444 default case, cases 4-7
lea rcx, jpt_89444
movsxd rax, ds:(jpt_89444 - 113040h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_89446:
mov rdi, [rbx]; jumptable 0000000000089444 case 1
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EED2Ev; 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>>>::~vector()
jmp short loc_8946D
loc_89450:
mov rdi, [rbx]; jumptable 0000000000089444 case 3
mov rax, [rdi]
lea rcx, [rdi+10h]
cmp rax, rcx
jz short loc_89470
mov rsi, [rcx]
inc rsi; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_8946D:
mov rdi, [rbx]
loc_89470:
mov esi, 20h ; ' '
jmp short loc_894AB
loc_89477:
mov rdi, [rbx]; jumptable 0000000000089444 case 2
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; 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>>::~vector()
mov rdi, [rbx]
mov esi, 18h
jmp short loc_894AB
loc_89489:
mov rdi, [rbx]; jumptable 0000000000089444 case 8
mov rax, [rdi]
test rax, rax
jz short loc_894A6
mov rsi, [rdi+10h]
sub rsi, rax; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [rbx]; void *
loc_894A6:
mov esi, 28h ; '('; unsigned __int64
loc_894AB:
call __ZdlPvm; operator delete(void *,ulong)
def_89444:
add rsp, 38h; jumptable 0000000000089444 default case, cases 4-7
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_894C3
jmp short $+2
loc_894C3:
mov rbx, rax
jmp short loc_894E4
jmp short $+2
loc_894CA:
mov rbx, rax
lea r14, [rsp+arg_18]
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()
loc_894E4:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; 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>>::~vector()
mov rdi, rbx
call __Unwind_Resume
| void nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value::destroy(
long long **a1,
int a2)
{
long long *v2; // rax
char v3; // r14
long long v5; // rsi
long long v6; // r15
long long v7; // r13
long long v8; // r13
bool v9; // cf
long long v10; // r12
long long i; // r13
long long j; // r13
char *v13; // r13
long long v14; // rdi
long long v15; // r13
long long v16; // rbp
long long v17; // rbp
long long v18; // rdi
long long v19; // r13
long long v20; // rbp
void **v21; // rdi
_QWORD *v22; // rcx
unsigned long long v23; // rsi
long long v24; // rax
__int128 v25; // [rsp+0h] [rbp-68h] BYREF
long long v26; // [rsp+10h] [rbp-58h]
_OWORD v27[4]; // [rsp+20h] [rbp-48h] BYREF
v2 = *a1;
if ( *a1 != 0LL || a2 != 1 )
{
v3 = a2;
if ( v2 != 0LL || (a2 & 0xFE) != 2 && (_BYTE)a2 != 8 )
{
if ( (unsigned __int8)(a2 - 1) <= 1u )
{
v25 = 0LL;
v26 = 0LL;
v5 = (v2[1] - *v2) >> 4;
if ( v3 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v25,
v5);
v6 = **a1;
v7 = ((*a1)[1] - v6) >> 4;
if ( v7 > 0 )
{
v8 = v7 + 1;
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(long long)&v25,
v6);
v6 += 16LL;
v9 = v8-- == 1;
}
while ( !v9 && v8 != 1 );
}
}
else
{
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>>::reserve(
&v25,
0xAAAAAAAAAAAAAAABLL * v5);
v10 = **a1;
for ( i = (*a1)[1]; v10 != i; v10 += 48LL )
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(long long)&v25,
v10 + 32);
}
for ( j = *((_QWORD *)&v25 + 1); (_QWORD)v25 != *((_QWORD *)&v25 + 1); j = *((_QWORD *)&v25 + 1) )
{
v27[0] = *(_OWORD *)(j - 16);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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 *)(j - 16));
*(_BYTE *)(j - 16) = 0;
*(_QWORD *)(j - 8) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
v13 = (char *)(*((_QWORD *)&v25 + 1) - 16LL);
*((_QWORD *)&v25 + 1) = v13;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v13);
if ( LOBYTE(v27[0]) == 1 )
{
v18 = *((_QWORD *)&v27[0] + 1);
v19 = **((_QWORD **)&v27[0] + 1);
v20 = *(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 8LL);
if ( **((_QWORD **)&v27[0] + 1) != v20 )
{
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(long long)&v25,
v19 + 32);
v19 += 48LL;
}
while ( v19 != v20 );
v18 = *((_QWORD *)&v27[0] + 1);
v19 = **((_QWORD **)&v27[0] + 1);
}
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>>>::_M_erase_at_end(
v18,
v19);
}
else if ( LOBYTE(v27[0]) == 2 )
{
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
v16 = (long long)(*(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 8LL) - **((_QWORD **)&v27[0] + 1)) >> 4;
if ( v16 > 0 )
{
v17 = v16 + 1;
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(long long)&v25,
v15);
v15 += 16LL;
--v17;
}
while ( v17 > 1 );
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
}
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>>::_M_erase_at_end(
v14,
v15);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v27);
}
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>>::~vector(&v25);
}
switch ( v3 )
{
case 1:
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>>>::~vector(*a1);
goto LABEL_29;
case 2:
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(*a1);
v21 = (void **)*a1;
v23 = 24LL;
goto LABEL_35;
case 3:
v21 = (void **)*a1;
v22 = *a1 + 2;
if ( (_QWORD *)**a1 != v22 )
{
operator delete((void *)**a1, *v22 + 1LL);
LABEL_29:
v21 = (void **)*a1;
}
v23 = 32LL;
goto LABEL_35;
case 8:
v21 = (void **)*a1;
v24 = **a1;
if ( v24 )
{
operator delete((void *)**a1, (unsigned long long)v21[2] - v24);
v21 = (void **)*a1;
}
v23 = 40LL;
LABEL_35:
operator delete(v21, v23);
break;
default:
return;
}
}
}
}
| destroy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
CMP ESI,0x1
SETZ CL
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
SETZ DL
TEST CL,DL
JNZ 0x001894b0
MOV R14D,ESI
TEST RAX,RAX
SETZ CL
MOV EDX,R14D
AND DL,0xfe
CMP DL,0x2
SETZ DL
CMP R14B,0x8
SETZ SIL
OR SIL,DL
TEST SIL,CL
JNZ 0x001894b0
MOV RBX,RDI
LEA ECX,[R14 + -0x1]
CMP CL,0x1
JA 0x0018942b
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,qword ptr [RAX]
SAR RSI,0x4
CMP R14B,0x2
JNZ 0x001892d1
LAB_00189293:
MOV RDI,RSP
CALL 0x001894f4
MOV RAX,qword ptr [RBX]
MOV R15,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
SUB R13,R15
SAR R13,0x4
TEST R13,R13
JLE 0x00189312
INC R13
MOV R12,RSP
LAB_001892b7:
MOV RDI,R12
MOV RSI,R15
CALL 0x001884c0
ADD R15,0x10
DEC R13
CMP R13,0x1
JA 0x001892b7
JMP 0x00189312
LAB_001892d1:
MOV RAX,-0x5555555555555555
IMUL RAX,RSI
LAB_001892df:
MOV RDI,RSP
MOV RSI,RAX
CALL 0x001894f4
MOV RAX,qword ptr [RBX]
MOV R12,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
CMP R12,R13
JZ 0x00189312
MOV R15,RSP
LAB_001892fc:
LEA RSI,[R12 + 0x20]
LAB_00189301:
MOV RDI,R15
CALL 0x001884c0
ADD R12,0x30
CMP R12,R13
JNZ 0x001892fc
LAB_00189312:
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JZ 0x00189423
LEA R15,[RSP + 0x20]
MOV R12,RSP
LAB_00189329:
LEA RDI,[R13 + -0x10]
MOVUPS XMM0,xmmword ptr [R13 + -0x10]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
XOR ESI,ESI
CALL 0x001846aa
MOV byte ptr [R13 + -0x10],0x0
MOV qword ptr [R13 + -0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x001846aa
MOV R13,qword ptr [RSP + 0x8]
ADD R13,-0x10
MOV qword ptr [RSP + 0x8],R13
MOV RDI,R13
XOR ESI,ESI
CALL 0x001846aa
MOV RDI,R13
CALL 0x00188dc4
MOVZX EAX,byte ptr [RSP + 0x20]
CMP EAX,0x1
JZ 0x001893cc
CMP EAX,0x2
JNZ 0x00189402
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
SUB RBP,R13
SAR RBP,0x4
TEST RBP,RBP
JLE 0x001893c2
INC RBP
LAB_001893a2:
MOV RDI,R12
MOV RSI,R13
CALL 0x001884c0
ADD R13,0x10
DEC RBP
CMP RBP,0x1
JG 0x001893a2
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
LAB_001893c2:
MOV RSI,R13
CALL 0x00189648
JMP 0x00189402
LAB_001893cc:
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
CMP R13,RBP
JZ 0x001893fa
LAB_001893dd:
LEA RSI,[R13 + 0x20]
LAB_001893e1:
MOV RDI,R12
CALL 0x001884c0
LAB_001893e9:
ADD R13,0x30
CMP R13,RBP
JNZ 0x001893dd
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
LAB_001893fa:
MOV RSI,R13
CALL 0x0018968e
LAB_00189402:
MOV RDI,R15
XOR ESI,ESI
CALL 0x001846aa
MOV RDI,R15
CALL 0x00188dc4
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JNZ 0x00189329
LAB_00189423:
MOV RDI,RSP
CALL 0x001895f6
LAB_0018942b:
MOVZX EAX,R14B
DEC EAX
CMP EAX,0x7
JA 0x001894b0
LEA RCX,[0x213040]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBX]
CALL 0x00189748
JMP 0x0018946d
caseD_3:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
LEA RCX,[RDI + 0x10]
CMP RAX,RCX
JZ 0x00189470
MOV RSI,qword ptr [RCX]
INC RSI
MOV RDI,RAX
CALL 0x00120170
LAB_0018946d:
MOV RDI,qword ptr [RBX]
LAB_00189470:
MOV ESI,0x20
JMP 0x001894ab
caseD_2:
MOV RDI,qword ptr [RBX]
CALL 0x001895f6
MOV RDI,qword ptr [RBX]
MOV ESI,0x18
JMP 0x001894ab
caseD_8:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001894a6
MOV RSI,qword ptr [RDI + 0x10]
SUB RSI,RAX
MOV RDI,RAX
CALL 0x00120170
MOV RDI,qword ptr [RBX]
LAB_001894a6:
MOV ESI,0x28
LAB_001894ab:
CALL 0x00120170
caseD_4:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) */
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>
::json_value::destroy(json_value *this,uint param_2)
{
long *plVar1;
long lVar2;
pair *ppVar3;
void *pvVar4;
byte bVar5;
ulong uVar6;
bool bVar7;
int8 *puVar8;
long lVar9;
data *pdVar10;
pair *ppVar11;
basic_json *pbVar12;
data *local_68;
data *pdStack_60;
int8 local_58;
int8 local_48;
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>>>
*pvStack_40;
plVar1 = *(long **)this;
if (param_2 == 1 && plVar1 == (long *)0x0) {
return;
}
bVar5 = (byte)param_2;
if ((bVar5 == 8 || (bVar5 & 0xfe) == 2) && plVar1 == (long *)0x0) {
return;
}
if ((byte)(bVar5 - 1) < 2) {
local_68 = (data *)0x0;
pdStack_60 = (data *)0x0;
local_58 = 0;
uVar6 = plVar1[1] - *plVar1 >> 4;
if (bVar5 == 2) {
/* try { // try from 00189293 to 0018929a has its CatchHandler @ 001894bf */
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>>>
::reserve((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>>>
*)&local_68,uVar6);
pbVar12 = (basic_json *)**(long **)this;
lVar9 = (*(long **)this)[1] - (long)pbVar12 >> 4;
if (0 < lVar9) {
uVar6 = lVar9 + 1;
do {
/* try { // try from 001892b7 to 001892c1 has its CatchHandler @ 001894c3 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar12);
pbVar12 = pbVar12 + 0x10;
uVar6 = uVar6 - 1;
} while (1 < uVar6);
}
}
else {
/* try { // try from 001892df to 001892e9 has its CatchHandler @ 001894bf */
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>>>
::reserve((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>>>
*)&local_68,uVar6 * -0x5555555555555555);
lVar2 = (*(long **)this)[1];
for (lVar9 = **(long **)this; lVar9 != lVar2; lVar9 = lVar9 + 0x30) {
/* try { // try from 00189301 to 00189308 has its CatchHandler @ 001894c1 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(lVar9 + 0x20));
}
}
if (local_68 != pdStack_60) {
do {
pdVar10 = pdStack_60;
local_48 = *(int8 *)(pdStack_60 + -0x10);
pvStack_40 = *(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>>>
**)(pdStack_60 + -8);
assert_invariant((bool)((char)pdStack_60 + -0x10));
pdVar10[-0x10] = (data)0x0;
*(int8 *)(pdVar10 + -8) = 0;
bVar7 = SUB81((data *)&local_48,0);
assert_invariant(bVar7);
pdVar10 = pdStack_60 + -0x10;
pdStack_60 = pdVar10;
assert_invariant(SUB81(pdVar10,0));
data::~data(pdVar10);
if (local_48._0_1_ == (data)0x1) {
ppVar11 = *(pair **)pvStack_40;
ppVar3 = *(pair **)(pvStack_40 + 8);
if (ppVar11 != ppVar3) {
do {
/* try { // try from 001893e1 to 001893e8 has its CatchHandler @ 001894ca */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(ppVar11 + 0x20));
ppVar11 = ppVar11 + 0x30;
} while (ppVar11 != ppVar3);
ppVar11 = *(pair **)pvStack_40;
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::_M_erase_at_end((vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)pvStack_40,ppVar11);
}
else if (local_48._0_1_ == (data)0x2) {
pbVar12 = *(basic_json **)pvStack_40;
lVar9 = *(long *)(pvStack_40 + 8) - (long)pbVar12 >> 4;
if (0 < lVar9) {
lVar9 = lVar9 + 1;
do {
/* try { // try from 001893a2 to 001893ac has its CatchHandler @ 001894c8 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar12);
pbVar12 = pbVar12 + 0x10;
lVar9 = lVar9 + -1;
} while (1 < lVar9);
pbVar12 = *(basic_json **)pvStack_40;
}
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>>>
::_M_erase_at_end(pvStack_40,pbVar12);
}
assert_invariant(bVar7);
data::~data((data *)&local_48);
} while (local_68 != pdStack_60);
}
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>>>
::~vector((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>>>
*)&local_68);
}
switch(param_2 & 0xff) {
case 1:
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::~vector(*(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)this);
LAB_0018946d:
puVar8 = *(int8 **)this;
goto LAB_00189470;
case 2:
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>>>
::~vector(*(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);
puVar8 = *(int8 **)this;
uVar6 = 0x18;
break;
case 3:
puVar8 = *(int8 **)this;
if ((long *)*puVar8 != puVar8 + 2) {
operator_delete((long *)*puVar8,puVar8[2] + 1);
goto LAB_0018946d;
}
LAB_00189470:
uVar6 = 0x20;
break;
default:
goto switchD_00189444_caseD_4;
case 8:
puVar8 = *(int8 **)this;
pvVar4 = (void *)*puVar8;
if (pvVar4 != (void *)0x0) {
operator_delete(pvVar4,puVar8[2] - (long)pvVar4);
puVar8 = *(int8 **)this;
}
uVar6 = 0x28;
}
operator_delete(puVar8,uVar6);
switchD_00189444_caseD_4:
return;
}
| |
39,599 | list_delete | eloqsql/libmariadb/libmariadb/ma_list.c | LIST *list_delete(LIST *root, LIST *element)
{
if (element->prev)
element->prev->next=element->next;
else
root=element->next;
if (element->next)
element->next->prev=element->prev;
return root;
} | O3 | c | list_delete:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
movq %rcx, %rax
testq %rdx, %rdx
je 0x2180e
movq %rcx, 0x8(%rdx)
movq %rdi, %rax
testq %rcx, %rcx
je 0x21819
movq (%rsi), %rdx
movq %rdx, (%rcx)
popq %rbp
retq
| list_delete:
push rbp
mov rbp, rsp
mov rdx, [rsi]
mov rcx, [rsi+8]
mov rax, rcx
test rdx, rdx
jz short loc_2180E
mov [rdx+8], rcx
mov rax, rdi
loc_2180E:
test rcx, rcx
jz short loc_21819
mov rdx, [rsi]
mov [rcx], rdx
loc_21819:
pop rbp
retn
| _QWORD * list_delete(_QWORD *a1, _QWORD *a2)
{
_QWORD *v2; // rcx
_QWORD *result; // rax
v2 = (_QWORD *)a2[1];
result = v2;
if ( *a2 )
{
*(_QWORD *)(*a2 + 8LL) = v2;
result = a1;
}
if ( v2 )
*v2 = *a2;
return result;
}
| list_delete:
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RSI]
MOV RCX,qword ptr [RSI + 0x8]
MOV RAX,RCX
TEST RDX,RDX
JZ 0x0012180e
MOV qword ptr [RDX + 0x8],RCX
MOV RAX,RDI
LAB_0012180e:
TEST RCX,RCX
JZ 0x00121819
MOV RDX,qword ptr [RSI]
MOV qword ptr [RCX],RDX
LAB_00121819:
POP RBP
RET
|
long * list_delete(long *param_1,long *param_2)
{
long *plVar1;
long *plVar2;
plVar1 = (long *)param_2[1];
plVar2 = plVar1;
if (*param_2 != 0) {
*(long **)(*param_2 + 8) = plVar1;
plVar2 = param_1;
}
if (plVar1 != (long *)0x0) {
*plVar1 = *param_2;
}
return plVar2;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.