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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
26,000 | ntt_conv | bluesky950520[P]quickjs/libbf.c | static int ntt_conv(BFNTTState *s, NTTLimb *buf1, NTTLimb *buf2,
int k, int k_tot, limb_t m_idx)
{
limb_t n1, n2, i;
int k1, k2;
if (k <= NTT_TRIG_K_MAX) {
k1 = k;
} else {
/* recursive split of the FFT */
k1 = bf_min(k / 2, NTT_TRIG_K_MAX);
}
k2 = k - k1;
n1 = (limb_t)1 << k1;
n2 = (limb_t)1 << k2;
if (ntt_fft_partial(s, buf1, k1, k2, n1, n2, 0, m_idx))
return -1;
if (ntt_fft_partial(s, buf2, k1, k2, n1, n2, 0, m_idx))
return -1;
if (k2 == 0) {
ntt_vec_mul(s, buf1, buf2, k, k_tot, m_idx);
} else {
for(i = 0; i < n1; i++) {
ntt_conv(s, buf1 + i * n2, buf2 + i * n2, k2, k_tot, m_idx);
}
}
if (ntt_fft_partial(s, buf1, k1, k2, n1, n2, 1, m_idx))
return -1;
return 0;
} | O1 | c | ntt_conv:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r10
movl %r8d, 0x4(%rsp)
movl %ecx, %r13d
movq %rdx, 0x20(%rsp)
movl %ecx, %eax
shrl %eax
cmpq $0x13, %rax
movl $0x13, %r14d
cmovlq %rax, %r14
cmpl $0x14, %ecx
cmovll %ecx, %r14d
movl %ecx, %ebp
subl %r14d, %ebp
movl $0x1, %ebx
movl $0x1, %r12d
movl %r14d, %ecx
shlq %cl, %r12
movl %ebp, %ecx
shlq %cl, %rbx
movq %rdi, 0x8(%rsp)
movq %rsi, 0x18(%rsp)
movl %r14d, %edx
movl %ebp, %ecx
movq %r12, %r8
movq %rbx, %r9
movq %r10, 0x10(%rsp)
pushq %r10
pushq $0x0
callq 0x93dbd
addq $0x10, %rsp
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x93816
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %r12, %r8
movq %rbx, %r9
pushq 0x10(%rsp)
pushq $0x0
callq 0x93dbd
addq $0x10, %rsp
testl %eax, %eax
jne 0x93816
movq %rbx, 0x30(%rsp)
movq 0x20(%rsp), %r9
cmpl %r14d, %r13d
movq %r14, 0x28(%rsp)
jne 0x937a2
movslq 0x10(%rsp), %rax
leaq 0xf982(%rip), %rcx # 0xa3060
movq (%rcx,%rax,8), %r8
movq 0x8(%rsp), %rcx
movq 0x8(%rcx,%rax,8), %rdx
imulq $0x340, %rax, %rax # imm = 0x340
addq %rcx, %rax
movl 0x4(%rsp), %ecx
shlq $0x4, %rcx
movq 0x26f0(%rcx,%rax), %r10
movq 0x26f8(%rcx,%rax), %r11
movl %r13d, %ecx
leaq (%r8,%r8), %r15
movl $0x1, %r13d
movq %r12, %rbx
movq %rdx, %r12
movq 0x18(%rsp), %r14
movq -0x8(%r14,%r13,8), %rax
cmpq %r8, %rax
movq %r8, %rdx
movl $0x0, %esi
cmovbq %rsi, %rdx
subq %rdx, %rax
mulq -0x8(%r9,%r13,8)
movq %rax, %rdi
movq %rdx, %rsi
movq %rdx, %rax
shldq $0x3, %rdi, %rax
mulq %r12
movq %rdx, %rax
mulq %r8
addq %r15, %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 %rax, %rsi
movq %rsi, %rax
mulq %r11
imulq %r10, %rsi
imulq %r8, %rdx
movq %r13, %rax
shrq %cl, %rax
subq %rdx, %rsi
movq %rsi, -0x8(%r14,%r13,8)
incq %r13
testq %rax, %rax
je 0x93726
jmp 0x937e8
xorl %r15d, %r15d
movq %r9, %r13
movq %r12, %rbx
movq 0x18(%rsp), %r14
movl 0x4(%rsp), %r12d
movq %r15, %rax
movl %ebp, %ecx
shlq %cl, %rax
leaq (%r14,%rax,8), %rsi
leaq (,%rax,8), %rdx
addq %r13, %rdx
movq 0x8(%rsp), %rdi
movl %ebp, %ecx
movl %r12d, %r8d
movq 0x10(%rsp), %r9
callq 0x93607
incq %r15
cmpq %r15, %rbx
jne 0x937b5
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq 0x28(%rsp), %rdx
movl %ebp, %ecx
movq %rbx, %r8
movq 0x30(%rsp), %r9
pushq 0x10(%rsp)
pushq $0x1
callq 0x93dbd
addq $0x10, %rsp
xorl %r15d, %r15d
negl %eax
sbbl %r15d, %r15d
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ntt_conv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r10, r9
mov [rsp+68h+var_64], r8d
mov r13d, ecx
mov [rsp+68h+var_48], rdx
mov eax, ecx
shr eax, 1
cmp rax, 13h
mov r14d, 13h
cmovl r14, rax
cmp ecx, 14h
cmovl r14d, ecx
mov ebp, ecx
sub ebp, r14d
mov ebx, 1
mov r12d, 1
mov ecx, r14d
shl r12, cl
mov ecx, ebp
shl rbx, cl
mov [rsp+68h+var_60], rdi
mov [rsp+68h+var_50], rsi
mov edx, r14d
mov ecx, ebp
mov r8, r12
mov r9, rbx
mov [rsp+68h+var_58], r10
push r10
push 0
call ntt_fft_partial
add rsp, 10h
mov r15d, 0FFFFFFFFh
test eax, eax
jnz loc_93816
mov rdi, [rsp+68h+var_60]
mov rsi, [rsp+68h+var_48]
mov edx, r14d
mov ecx, ebp
mov r8, r12
mov r9, rbx
push [rsp+68h+var_58]
push 0
call ntt_fft_partial
add rsp, 10h
test eax, eax
jnz loc_93816
mov [rsp+68h+var_38], rbx
mov r9, [rsp+68h+var_48]
cmp r13d, r14d
mov [rsp+68h+var_40], r14
jnz loc_937A2
movsxd rax, dword ptr [rsp+68h+var_58]
lea rcx, ntt_mods
mov r8, [rcx+rax*8]
mov rcx, [rsp+68h+var_60]
mov rdx, [rcx+rax*8+8]
imul rax, 340h
add rax, rcx
mov ecx, [rsp+68h+var_64]
shl rcx, 4
mov r10, [rcx+rax+26F0h]
mov r11, [rcx+rax+26F8h]
mov ecx, r13d
lea r15, [r8+r8]
mov r13d, 1
mov rbx, r12
mov r12, rdx
mov r14, [rsp+68h+var_50]
loc_93726:
mov rax, [r14+r13*8-8]
cmp rax, r8
mov rdx, r8
mov esi, 0
cmovb rdx, rsi
sub rax, rdx
mul qword ptr [r9+r13*8-8]
mov rdi, rax
mov rsi, rdx
mov rax, rdx
shld rax, rdi, 3
mul r12
mov rax, rdx
mul r8
add rax, r15
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 rsi, rax
mov rax, rsi
mul r11
imul rsi, r10
imul rdx, r8
mov rax, r13
shr rax, cl
sub rsi, rdx
mov [r14+r13*8-8], rsi
inc r13
test rax, rax
jz short loc_93726
jmp short loc_937E8
loc_937A2:
xor r15d, r15d
mov r13, r9
mov rbx, r12
mov r14, [rsp+68h+var_50]
mov r12d, [rsp+68h+var_64]
loc_937B5:
mov rax, r15
mov ecx, ebp
shl rax, cl
lea rsi, [r14+rax*8]
lea rdx, ds:0[rax*8]
add rdx, r13
mov rdi, [rsp+68h+var_60]
mov ecx, ebp
mov r8d, r12d
mov r9, [rsp+68h+var_58]
call ntt_conv
inc r15
cmp rbx, r15
jnz short loc_937B5
loc_937E8:
mov rdi, [rsp+68h+var_60]
mov rsi, r14
mov rdx, [rsp+68h+var_40]
mov ecx, ebp
mov r8, rbx
mov r9, [rsp+68h+var_38]
push [rsp+68h+var_58]
push 1
call ntt_fft_partial
add rsp, 10h
xor r15d, r15d
neg eax
sbb r15d, r15d
loc_93816:
mov eax, r15d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ntt_conv(long long a1, long long a2, long long a3, int a4, unsigned int a5, long long a6)
{
int v7; // r14d
unsigned int v8; // ebp
long long v9; // rbx
unsigned int v10; // r15d
unsigned long long v11; // r8
long long v12; // rax
long long v13; // rcx
long long v14; // r10
unsigned long long v15; // r11
char v16; // cl
unsigned long long v17; // r13
long long v18; // rbx
unsigned long long v19; // r12
int v20; // r14d
unsigned long long v21; // rax
unsigned long long v22; // rdx
unsigned __int128 v23; // kr00_16
unsigned long long v24; // rax
long long v25; // rsi
long long v26; // rdx
unsigned long long v27; // rax
long long v28; // r15
int v34; // [rsp+28h] [rbp-40h]
int v35; // [rsp+30h] [rbp-38h]
v7 = 19;
if ( (unsigned int)a4 >> 1 < 0x13uLL )
v7 = (unsigned int)a4 >> 1;
if ( a4 < 20 )
v7 = a4;
v8 = a4 - v7;
v9 = 1LL << ((unsigned __int8)a4 - (unsigned __int8)v7);
v10 = -1;
if ( !(unsigned int)ntt_fft_partial(a1, a2, v7, a4 - v7, 1LL << v7, v9, 0, a6)
&& !(unsigned int)ntt_fft_partial(a1, a3, v7, v8, 1LL << v7, v9, 0, a6) )
{
v35 = v9;
v34 = v7;
if ( a4 == v7 )
{
v11 = ntt_mods[(int)a6];
v12 = a1 + 832LL * (int)a6;
v13 = 16LL * a5;
v14 = *(_QWORD *)(v13 + v12 + 9968);
v15 = *(_QWORD *)(v13 + v12 + 9976);
v16 = a4;
v17 = 1LL;
v18 = 1LL << v7;
v19 = *(_QWORD *)(a1 + 8LL * (int)a6 + 8);
v20 = a2;
do
{
v21 = *(_QWORD *)(a2 + 8 * v17 - 8);
v22 = v11;
if ( v21 < v11 )
v22 = 0LL;
v23 = *(unsigned long long *)(a3 + 8 * v17 - 8) * (unsigned __int128)(v21 - v22)
- (2 * v11
+ v11
* ((v19
* (unsigned __int128)(unsigned long long)((__int128)(*(unsigned long long *)(a3 + 8 * v17 - 8)
* (unsigned __int128)(v21 - v22)) >> 61)) >> 64))
+ (v11 & ((long long)((*(unsigned long long *)(a3 + 8 * v17 - 8) * (unsigned __int128)(v21 - v22)
- (2 * v11
+ v11
* ((v19
* (unsigned __int128)(unsigned long long)((__int128)(*(unsigned long long *)(a3 + 8 * v17 - 8)
* (unsigned __int128)(v21 - v22)) >> 61)) >> 64))) >> 64) >> 1));
v24 = v23 + (v11 & *((_QWORD *)&v23 + 1));
v25 = v14 * v24;
v26 = v11 * ((v15 * (unsigned __int128)v24) >> 64);
v27 = v17 >> v16;
*(_QWORD *)(a2 + 8 * v17++ - 8) = v25 - v26;
}
while ( !v27 );
}
else
{
v28 = 0LL;
v18 = 1LL << v7;
v20 = a2;
do
{
ntt_conv(a1, a2 + 8 * (v28 << v8), a3 + 8 * (v28 << v8), v8, a5, a6);
++v28;
}
while ( v18 != v28 );
}
return (unsigned int)-((unsigned int)ntt_fft_partial(a1, v20, v34, v8, v18, v35, 1, a6) != 0);
}
return v10;
}
| ntt_conv:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R10,R9
MOV dword ptr [RSP + 0x4],R8D
MOV R13D,ECX
MOV qword ptr [RSP + 0x20],RDX
MOV EAX,ECX
SHR EAX,0x1
CMP RAX,0x13
MOV R14D,0x13
CMOVL R14,RAX
CMP ECX,0x14
CMOVL R14D,ECX
MOV EBP,ECX
SUB EBP,R14D
MOV EBX,0x1
MOV R12D,0x1
MOV ECX,R14D
SHL R12,CL
MOV ECX,EBP
SHL RBX,CL
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV EDX,R14D
MOV ECX,EBP
MOV R8,R12
MOV R9,RBX
MOV qword ptr [RSP + 0x10],R10
PUSH R10
PUSH 0x0
CALL 0x00193dbd
ADD RSP,0x10
MOV R15D,0xffffffff
TEST EAX,EAX
JNZ 0x00193816
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x20]
MOV EDX,R14D
MOV ECX,EBP
MOV R8,R12
MOV R9,RBX
PUSH qword ptr [RSP + 0x10]
PUSH 0x0
CALL 0x00193dbd
ADD RSP,0x10
TEST EAX,EAX
JNZ 0x00193816
MOV qword ptr [RSP + 0x30],RBX
MOV R9,qword ptr [RSP + 0x20]
CMP R13D,R14D
MOV qword ptr [RSP + 0x28],R14
JNZ 0x001937a2
MOVSXD RAX,dword ptr [RSP + 0x10]
LEA RCX,[0x1a3060]
MOV R8,qword ptr [RCX + RAX*0x8]
MOV RCX,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RCX + RAX*0x8 + 0x8]
IMUL RAX,RAX,0x340
ADD RAX,RCX
MOV ECX,dword ptr [RSP + 0x4]
SHL RCX,0x4
MOV R10,qword ptr [RCX + RAX*0x1 + 0x26f0]
MOV R11,qword ptr [RCX + RAX*0x1 + 0x26f8]
MOV ECX,R13D
LEA R15,[R8 + R8*0x1]
MOV R13D,0x1
MOV RBX,R12
MOV R12,RDX
MOV R14,qword ptr [RSP + 0x18]
LAB_00193726:
MOV RAX,qword ptr [R14 + R13*0x8 + -0x8]
CMP RAX,R8
MOV RDX,R8
MOV ESI,0x0
CMOVC RDX,RSI
SUB RAX,RDX
MUL qword ptr [R9 + R13*0x8 + -0x8]
MOV RDI,RAX
MOV RSI,RDX
MOV RAX,RDX
SHLD RAX,RDI,0x3
MUL R12
MOV RAX,RDX
MUL R8
ADD RAX,R15
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 RSI,RAX
MOV RAX,RSI
MUL R11
IMUL RSI,R10
IMUL RDX,R8
MOV RAX,R13
SHR RAX,CL
SUB RSI,RDX
MOV qword ptr [R14 + R13*0x8 + -0x8],RSI
INC R13
TEST RAX,RAX
JZ 0x00193726
JMP 0x001937e8
LAB_001937a2:
XOR R15D,R15D
MOV R13,R9
MOV RBX,R12
MOV R14,qword ptr [RSP + 0x18]
MOV R12D,dword ptr [RSP + 0x4]
LAB_001937b5:
MOV RAX,R15
MOV ECX,EBP
SHL RAX,CL
LEA RSI,[R14 + RAX*0x8]
LEA RDX,[RAX*0x8]
ADD RDX,R13
MOV RDI,qword ptr [RSP + 0x8]
MOV ECX,EBP
MOV R8D,R12D
MOV R9,qword ptr [RSP + 0x10]
CALL 0x00193607
INC R15
CMP RBX,R15
JNZ 0x001937b5
LAB_001937e8:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R14
MOV RDX,qword ptr [RSP + 0x28]
MOV ECX,EBP
MOV R8,RBX
MOV R9,qword ptr [RSP + 0x30]
PUSH qword ptr [RSP + 0x10]
PUSH 0x1
CALL 0x00193dbd
ADD RSP,0x10
XOR R15D,R15D
NEG EAX
SBB R15D,R15D
LAB_00193816:
MOV EAX,R15D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int ntt_conv(long param_1,long param_2,long param_3,uint param_4,uint param_5,int8 param_6)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
int1 auVar9 [16];
int1 auVar10 [16];
int1 auVar11 [16];
int1 auVar12 [16];
int1 auVar13 [16];
int iVar14;
int iVar15;
long lVar16;
long lVar17;
ulong uVar18;
ulong uVar19;
long lVar20;
int iVar21;
long lVar22;
ulong uVar23;
uint uVar24;
int local_58;
uVar24 = 0x13;
if (param_4 >> 1 < 0x13) {
uVar24 = param_4 >> 1;
}
if ((int)param_4 < 0x14) {
uVar24 = param_4;
}
iVar21 = param_4 - uVar24;
lVar22 = 1L << ((byte)uVar24 & 0x3f);
lVar20 = 1L << ((byte)iVar21 & 0x3f);
iVar14 = ntt_fft_partial(param_1,param_2,uVar24,iVar21,lVar22,lVar20,0,param_6);
iVar15 = -1;
if ((iVar14 == 0) &&
(iVar14 = ntt_fft_partial(param_1,param_3,uVar24,iVar21,lVar22,lVar20,0,param_6), iVar14 == 0))
{
if (param_4 == uVar24) {
local_58 = (int)param_6;
lVar16 = (long)local_58;
uVar1 = (&ntt_mods)[lVar16];
uVar2 = *(ulong *)(param_1 + 8 + lVar16 * 8);
lVar17 = lVar16 * 0x340 + param_1;
lVar16 = *(long *)((ulong)param_5 * 0x10 + 0x26f0 + lVar17);
uVar3 = *(ulong *)((ulong)param_5 * 0x10 + 0x26f8 + lVar17);
auVar12._8_8_ = 0;
auVar12._0_8_ = uVar1 * 2;
uVar23 = 1;
do {
uVar18 = *(ulong *)(param_2 + -8 + uVar23 * 8);
uVar19 = uVar1;
if (uVar18 < uVar1) {
uVar19 = 0;
}
auVar4._8_8_ = 0;
auVar4._0_8_ = uVar18 - uVar19;
auVar8._8_8_ = 0;
auVar8._0_8_ = *(ulong *)(param_3 + -8 + uVar23 * 8);
auVar4 = auVar4 * auVar8;
auVar5._8_8_ = 0;
auVar5._0_8_ = auVar4._8_8_ << 3 | auVar4._0_8_ >> 0x3d;
auVar9._8_8_ = 0;
auVar9._0_8_ = uVar2;
auVar6._8_8_ = 0;
auVar6._0_8_ = SUB168(auVar5 * auVar9,8);
auVar10._8_8_ = 0;
auVar10._0_8_ = uVar1;
auVar4 = auVar4 - (auVar6 * auVar10 + auVar12);
auVar13._8_8_ = 0;
auVar13._0_8_ = auVar4._8_8_ >> 1 & uVar1;
auVar4 = auVar4 + auVar13;
uVar19 = (auVar4._8_8_ & uVar1) + auVar4._0_8_;
auVar7._8_8_ = 0;
auVar7._0_8_ = uVar19;
auVar11._8_8_ = 0;
auVar11._0_8_ = uVar3;
uVar18 = uVar23 >> ((byte)param_4 & 0x3f);
*(ulong *)(param_2 + -8 + uVar23 * 8) = uVar19 * lVar16 - SUB168(auVar7 * auVar11,8) * uVar1
;
uVar23 = uVar23 + 1;
} while (uVar18 == 0);
}
else {
lVar16 = 0;
do {
lVar17 = lVar16 << ((byte)iVar21 & 0x3f);
ntt_conv(param_1,param_2 + lVar17 * 8,lVar17 * 8 + param_3,iVar21,param_5,param_6);
lVar16 = lVar16 + 1;
} while (lVar22 != lVar16);
}
iVar15 = ntt_fft_partial(param_1,param_2,uVar24,iVar21,lVar22,lVar20,1,param_6);
iVar15 = -(uint)(iVar15 != 0);
}
return iVar15;
}
| |
26,001 | ntt_conv | bluesky950520[P]quickjs/libbf.c | static int ntt_conv(BFNTTState *s, NTTLimb *buf1, NTTLimb *buf2,
int k, int k_tot, limb_t m_idx)
{
limb_t n1, n2, i;
int k1, k2;
if (k <= NTT_TRIG_K_MAX) {
k1 = k;
} else {
/* recursive split of the FFT */
k1 = bf_min(k / 2, NTT_TRIG_K_MAX);
}
k2 = k - k1;
n1 = (limb_t)1 << k1;
n2 = (limb_t)1 << k2;
if (ntt_fft_partial(s, buf1, k1, k2, n1, n2, 0, m_idx))
return -1;
if (ntt_fft_partial(s, buf2, k1, k2, n1, n2, 0, m_idx))
return -1;
if (k2 == 0) {
ntt_vec_mul(s, buf1, buf2, k, k_tot, m_idx);
} else {
for(i = 0; i < n1; i++) {
ntt_conv(s, buf1 + i * n2, buf2 + i * n2, k2, k_tot, m_idx);
}
}
if (ntt_fft_partial(s, buf1, k1, k2, n1, n2, 1, m_idx))
return -1;
return 0;
} | O2 | c | ntt_conv:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r10
movl %r8d, 0x8(%rsp)
movl %ecx, %r15d
movq %rdx, 0x20(%rsp)
movq %rsi, %r14
movl %ecx, %eax
shrl %eax
cmpl $0x13, %eax
pushq $0x13
popq %rbp
cmovbl %eax, %ebp
cmpl $0x14, %ecx
cmovll %ecx, %ebp
movl %ecx, %r13d
subl %ebp, %r13d
pushq $0x1
popq %rbx
movq %rbx, %r12
movl %ebp, %ecx
shlq %cl, %r12
movl %r13d, %ecx
shlq %cl, %rbx
movq %rdi, 0x28(%rsp)
movl %ebp, %edx
movl %r13d, %ecx
movq %r12, %r8
movq %rbx, %r9
movq %r10, (%rsp)
pushq %r10
pushq $0x0
callq 0x7b228
popq %rcx
popq %rdx
pushq $-0x1
popq %rcx
testl %eax, %eax
jne 0x7ad28
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %ebp, %edx
movl %r13d, %ecx
movq %r12, %r8
movq %rbx, %r9
pushq (%rsp)
pushq $0x0
callq 0x7b228
pushq $-0x1
popq %rcx
addq $0x10, %rsp
testl %eax, %eax
jne 0x7ad28
movq %r12, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq 0x28(%rsp), %rbx
cmpl $0x14, %r15d
jge 0x7acb4
movq (%rsp), %r10
movslq %r10d, %rax
leaq 0xf3af(%rip), %rcx # 0x89fa0
movq (%rcx,%rax,8), %r12
movq %rbx, %rdi
movq 0x8(%rbx,%rax,8), %rcx
movq %rcx, 0x40(%rsp)
imulq $0x340, %rax, %rax # imm = 0x340
addq %rbx, %rax
movl 0x8(%rsp), %ecx
shlq $0x4, %rcx
movq 0x26f0(%rcx,%rax), %rdx
movq %rdx, 0x38(%rsp)
movq 0x26f8(%rcx,%rax), %rax
movq %rax, 0x30(%rsp)
movl %r15d, %eax
movq %rax, 0x8(%rsp)
xorl %r15d, %r15d
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %r9
movq 0x10(%rsp), %r8
movq %r15, %rax
movq 0x8(%rsp), %rcx
shrq %cl, %rax
testq %rax, %rax
jne 0x7ad0f
movq (%r14,%r15,8), %rdi
cmpq %r12, %rdi
movl $0x0, %eax
cmovaeq %r12, %rax
subq %rax, %rdi
movq (%rdx,%r15,8), %rsi
movq %r12, %rdx
movq 0x40(%rsp), %rcx
callq 0x7b1d8
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
movq %rbx, %rdi
movq (%rsp), %r10
movq %rax, %rcx
mulq 0x30(%rsp)
imulq 0x38(%rsp), %rcx
imulq %r12, %rdx
subq %rdx, %rcx
movq 0x20(%rsp), %rdx
movq %rcx, (%r14,%r15,8)
incq %r15
jmp 0x7ac48
xorl %r15d, %r15d
movq (%rsp), %r10
movq %rbx, %rdi
movq 0x18(%rsp), %r9
movq 0x10(%rsp), %r8
movl 0x8(%rsp), %r12d
cmpq %r15, %r8
je 0x7ad0f
movq %r15, %rax
movl %r13d, %ecx
shlq %cl, %rax
leaq (%r14,%rax,8), %rsi
movq 0x20(%rsp), %rcx
leaq (%rcx,%rax,8), %rdx
movq %rbx, %rdi
movl %r13d, %ecx
movl %r12d, %r8d
movq %r10, %r9
callq 0x7ab27
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
movq %rbx, %rdi
movq (%rsp), %r10
incq %r15
jmp 0x7accd
movq %r14, %rsi
movl %ebp, %edx
movl %r13d, %ecx
pushq %r10
pushq $0x1
callq 0x7b228
popq %rcx
popq %rdx
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
movl %ecx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ntt_conv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r10, r9
mov dword ptr [rsp+78h+var_70], r8d
mov r15d, ecx
mov [rsp+78h+var_58], rdx
mov r14, rsi
mov eax, ecx
shr eax, 1
cmp eax, 13h
push 13h
pop rbp
cmovb ebp, eax
cmp ecx, 14h
cmovl ebp, ecx
mov r13d, ecx
sub r13d, ebp
push 1
pop rbx
mov r12, rbx
mov ecx, ebp
shl r12, cl
mov ecx, r13d
shl rbx, cl
mov [rsp+78h+var_50], rdi
mov edx, ebp
mov ecx, r13d
mov r8, r12
mov r9, rbx
mov [rsp+78h+var_78], r10
push r10
push 0
call ntt_fft_partial
pop rcx
pop rdx
push 0FFFFFFFFFFFFFFFFh
pop rcx
test eax, eax
jnz loc_7AD28
mov rdi, [rsp+78h+var_50]
mov rsi, [rsp+78h+var_58]
mov edx, ebp
mov ecx, r13d
mov r8, r12
mov r9, rbx
push [rsp+78h+var_78]
push 0
call ntt_fft_partial
push 0FFFFFFFFFFFFFFFFh
pop rcx
add rsp, 10h
test eax, eax
jnz loc_7AD28
mov [rsp+78h+var_68], r12
mov [rsp+78h+var_60], rbx
mov rbx, [rsp+78h+var_50]
cmp r15d, 14h
jge loc_7ACB4
mov r10, [rsp+78h+var_78]
movsxd rax, r10d
lea rcx, ntt_mods
mov r12, [rcx+rax*8]
mov rdi, rbx
mov rcx, [rbx+rax*8+8]
mov [rsp+78h+var_38], rcx
imul rax, 340h
add rax, rbx
mov ecx, dword ptr [rsp+78h+var_70]
shl rcx, 4
mov rdx, [rcx+rax+26F0h]
mov [rsp+78h+var_40], rdx
mov rax, [rcx+rax+26F8h]
mov [rsp+78h+var_48], rax
mov eax, r15d
mov [rsp+78h+var_70], rax
xor r15d, r15d
mov rdx, [rsp+78h+var_58]
mov r9, [rsp+78h+var_60]
mov r8, [rsp+78h+var_68]
loc_7AC48:
mov rax, r15
mov rcx, [rsp+78h+var_70]
shr rax, cl
test rax, rax
jnz loc_7AD0F
mov rdi, [r14+r15*8]
cmp rdi, r12
mov eax, 0
cmovnb rax, r12
sub rdi, rax
mov rsi, [rdx+r15*8]
mov rdx, r12
mov rcx, [rsp+78h+var_38]
call mul_mod_fast
mov r8, [rsp+78h+var_68]
mov r9, [rsp+78h+var_60]
mov rdi, rbx
mov r10, [rsp+78h+var_78]
mov rcx, rax
mul [rsp+78h+var_48]
imul rcx, [rsp+78h+var_40]
imul rdx, r12
sub rcx, rdx
mov rdx, [rsp+78h+var_58]
mov [r14+r15*8], rcx
inc r15
jmp short loc_7AC48
loc_7ACB4:
xor r15d, r15d
mov r10, [rsp+78h+var_78]
mov rdi, rbx
mov r9, [rsp+78h+var_60]
mov r8, [rsp+78h+var_68]
mov r12d, dword ptr [rsp+78h+var_70]
loc_7ACCD:
cmp r8, r15
jz short loc_7AD0F
mov rax, r15
mov ecx, r13d
shl rax, cl
lea rsi, [r14+rax*8]
mov rcx, [rsp+78h+var_58]
lea rdx, [rcx+rax*8]
mov rdi, rbx
mov ecx, r13d
mov r8d, r12d
mov r9, r10
call ntt_conv
mov r8, [rsp+78h+var_68]
mov r9, [rsp+78h+var_60]
mov rdi, rbx
mov r10, [rsp+78h+var_78]
inc r15
jmp short loc_7ACCD
loc_7AD0F:
mov rsi, r14
mov edx, ebp
mov ecx, r13d
push r10
push 1
call ntt_fft_partial
pop rcx
pop rdx
xor ecx, ecx
neg eax
sbb ecx, ecx
loc_7AD28:
mov eax, ecx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ntt_conv(unsigned long long a1, long long a2, long long a3, int a4, unsigned int a5, long long a6)
{
int v7; // ebp
unsigned int v8; // r13d
long long v9; // rbx
int v10; // eax
unsigned int v11; // ecx
int v12; // eax
long long v13; // r10
unsigned long long v14; // r12
unsigned long long v15; // rax
long long v16; // rcx
unsigned long long v17; // r15
long long v18; // rdx
int v19; // r9d
long long v20; // r8
unsigned long long v21; // rax
long long v22; // rax
long long v23; // r15
char v27; // [rsp+8h] [rbp-70h]
unsigned long long v29; // [rsp+28h] [rbp-50h]
unsigned long long v30; // [rsp+30h] [rbp-48h]
long long v31; // [rsp+38h] [rbp-40h]
long long v32; // [rsp+40h] [rbp-38h]
v7 = 19;
if ( (unsigned int)a4 >> 1 < 0x13 )
v7 = (unsigned int)a4 >> 1;
if ( a4 < 20 )
v7 = a4;
v8 = a4 - v7;
v9 = 1LL << ((unsigned __int8)a4 - (unsigned __int8)v7);
v29 = a1;
v10 = ntt_fft_partial(a1, a2, v7, a4 - v7, 1LL << v7, v9, 0, a6);
v11 = -1;
if ( !v10 )
{
v12 = ntt_fft_partial(a1, a3, v7, v8, 1LL << v7, v9, 0, a6);
v11 = -1;
if ( !v12 )
{
if ( a4 >= 20 )
{
v23 = 0LL;
v13 = a6;
v19 = v9;
v20 = 1LL << v7;
while ( v20 != v23 )
{
ntt_conv(v29, a2 + 8 * (v23 << v8), a3 + 8 * (v23 << v8), v8, a5, v13);
v20 = 1LL << v7;
v19 = v9;
LODWORD(a1) = v29;
v13 = a6;
++v23;
}
}
else
{
v13 = a6;
v14 = ntt_mods[(int)a6];
v32 = *(_QWORD *)(a1 + 8LL * (int)a6 + 8);
v15 = a1 + 832LL * (int)a6;
v16 = 16LL * a5;
v31 = *(_QWORD *)(v16 + v15 + 9968);
v30 = *(_QWORD *)(v16 + v15 + 9976);
v27 = a4;
v17 = 0LL;
v18 = a3;
v19 = v9;
LODWORD(v20) = 1LL << v7;
while ( !(v17 >> v27) )
{
a1 = *(_QWORD *)(a2 + 8 * v17);
v21 = 0LL;
if ( a1 >= v14 )
v21 = v14;
v22 = mul_mod_fast(a1 - v21, *(_QWORD *)(v18 + 8 * v17), v14, v32);
LODWORD(v20) = 1LL << v7;
v19 = v9;
LODWORD(a1) = v29;
v13 = a6;
v18 = a3;
*(_QWORD *)(a2 + 8 * v17++) = v31 * v22 - v14 * ((v30 * (unsigned __int128)(unsigned long long)v22) >> 64);
}
}
return (unsigned int)-((unsigned int)ntt_fft_partial(a1, a2, v7, v8, v20, v19, 1, v13) != 0);
}
}
return v11;
}
| ntt_conv:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R10,R9
MOV dword ptr [RSP + 0x8],R8D
MOV R15D,ECX
MOV qword ptr [RSP + 0x20],RDX
MOV R14,RSI
MOV EAX,ECX
SHR EAX,0x1
CMP EAX,0x13
PUSH 0x13
POP RBP
CMOVC EBP,EAX
CMP ECX,0x14
CMOVL EBP,ECX
MOV R13D,ECX
SUB R13D,EBP
PUSH 0x1
POP RBX
MOV R12,RBX
MOV ECX,EBP
SHL R12,CL
MOV ECX,R13D
SHL RBX,CL
MOV qword ptr [RSP + 0x28],RDI
MOV EDX,EBP
MOV ECX,R13D
MOV R8,R12
MOV R9,RBX
MOV qword ptr [RSP],R10
PUSH R10
PUSH 0x0
CALL 0x0017b228
POP RCX
POP RDX
PUSH -0x1
POP RCX
TEST EAX,EAX
JNZ 0x0017ad28
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x20]
MOV EDX,EBP
MOV ECX,R13D
MOV R8,R12
MOV R9,RBX
PUSH qword ptr [RSP]
PUSH 0x0
CALL 0x0017b228
PUSH -0x1
POP RCX
ADD RSP,0x10
TEST EAX,EAX
JNZ 0x0017ad28
MOV qword ptr [RSP + 0x10],R12
MOV qword ptr [RSP + 0x18],RBX
MOV RBX,qword ptr [RSP + 0x28]
CMP R15D,0x14
JGE 0x0017acb4
MOV R10,qword ptr [RSP]
MOVSXD RAX,R10D
LEA RCX,[0x189fa0]
MOV R12,qword ptr [RCX + RAX*0x8]
MOV RDI,RBX
MOV RCX,qword ptr [RBX + RAX*0x8 + 0x8]
MOV qword ptr [RSP + 0x40],RCX
IMUL RAX,RAX,0x340
ADD RAX,RBX
MOV ECX,dword ptr [RSP + 0x8]
SHL RCX,0x4
MOV RDX,qword ptr [RCX + RAX*0x1 + 0x26f0]
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RCX + RAX*0x1 + 0x26f8]
MOV qword ptr [RSP + 0x30],RAX
MOV EAX,R15D
MOV qword ptr [RSP + 0x8],RAX
XOR R15D,R15D
MOV RDX,qword ptr [RSP + 0x20]
MOV R9,qword ptr [RSP + 0x18]
MOV R8,qword ptr [RSP + 0x10]
LAB_0017ac48:
MOV RAX,R15
MOV RCX,qword ptr [RSP + 0x8]
SHR RAX,CL
TEST RAX,RAX
JNZ 0x0017ad0f
MOV RDI,qword ptr [R14 + R15*0x8]
CMP RDI,R12
MOV EAX,0x0
CMOVNC RAX,R12
SUB RDI,RAX
MOV RSI,qword ptr [RDX + R15*0x8]
MOV RDX,R12
MOV RCX,qword ptr [RSP + 0x40]
CALL 0x0017b1d8
MOV R8,qword ptr [RSP + 0x10]
MOV R9,qword ptr [RSP + 0x18]
MOV RDI,RBX
MOV R10,qword ptr [RSP]
MOV RCX,RAX
MUL qword ptr [RSP + 0x30]
IMUL RCX,qword ptr [RSP + 0x38]
IMUL RDX,R12
SUB RCX,RDX
MOV RDX,qword ptr [RSP + 0x20]
MOV qword ptr [R14 + R15*0x8],RCX
INC R15
JMP 0x0017ac48
LAB_0017acb4:
XOR R15D,R15D
MOV R10,qword ptr [RSP]
MOV RDI,RBX
MOV R9,qword ptr [RSP + 0x18]
MOV R8,qword ptr [RSP + 0x10]
MOV R12D,dword ptr [RSP + 0x8]
LAB_0017accd:
CMP R8,R15
JZ 0x0017ad0f
MOV RAX,R15
MOV ECX,R13D
SHL RAX,CL
LEA RSI,[R14 + RAX*0x8]
MOV RCX,qword ptr [RSP + 0x20]
LEA RDX,[RCX + RAX*0x8]
MOV RDI,RBX
MOV ECX,R13D
MOV R8D,R12D
MOV R9,R10
CALL 0x0017ab27
MOV R8,qword ptr [RSP + 0x10]
MOV R9,qword ptr [RSP + 0x18]
MOV RDI,RBX
MOV R10,qword ptr [RSP]
INC R15
JMP 0x0017accd
LAB_0017ad0f:
MOV RSI,R14
MOV EDX,EBP
MOV ECX,R13D
PUSH R10
PUSH 0x1
CALL 0x0017b228
POP RCX
POP RDX
XOR ECX,ECX
NEG EAX
SBB ECX,ECX
LAB_0017ad28:
MOV EAX,ECX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int ntt_conv(long param_1,long param_2,long param_3,uint param_4,uint param_5,int8 param_6)
{
ulong uVar1;
int8 uVar2;
ulong uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
int iVar6;
int iVar7;
long lVar8;
long lVar9;
ulong uVar10;
ulong uVar11;
long lVar12;
uint uVar13;
long lVar14;
int iVar15;
ulong uVar16;
uVar13 = 0x13;
if (param_4 >> 1 < 0x13) {
uVar13 = param_4 >> 1;
}
if ((int)param_4 < 0x14) {
uVar13 = param_4;
}
iVar15 = param_4 - uVar13;
lVar14 = 1L << ((byte)uVar13 & 0x3f);
lVar12 = 1L << ((byte)iVar15 & 0x3f);
iVar6 = ntt_fft_partial(param_1,param_2,uVar13,iVar15,lVar14,lVar12,0,param_6);
iVar7 = -1;
if (iVar6 == 0) {
iVar6 = ntt_fft_partial(param_1,param_3,uVar13,iVar15,lVar14,lVar12,0,param_6);
iVar7 = -1;
if (iVar6 == 0) {
if ((int)param_4 < 0x14) {
lVar8 = (long)(int)param_6;
uVar1 = (&ntt_mods)[lVar8];
uVar2 = *(int8 *)(param_1 + 8 + lVar8 * 8);
lVar9 = lVar8 * 0x340 + param_1;
lVar8 = *(long *)((ulong)param_5 * 0x10 + 0x26f0 + lVar9);
uVar3 = *(ulong *)((ulong)param_5 * 0x10 + 0x26f8 + lVar9);
for (uVar16 = 0; uVar16 >> ((byte)param_4 & 0x3f) == 0; uVar16 = uVar16 + 1) {
uVar11 = *(ulong *)(param_2 + uVar16 * 8);
uVar10 = 0;
if (uVar1 <= uVar11) {
uVar10 = uVar1;
}
uVar11 = mul_mod_fast(uVar11 - uVar10,*(int8 *)(param_3 + uVar16 * 8),uVar1,uVar2);
auVar4._8_8_ = 0;
auVar4._0_8_ = uVar11;
auVar5._8_8_ = 0;
auVar5._0_8_ = uVar3;
*(ulong *)(param_2 + uVar16 * 8) = uVar11 * lVar8 - SUB168(auVar4 * auVar5,8) * uVar1;
}
}
else {
for (lVar8 = 0; lVar14 != lVar8; lVar8 = lVar8 + 1) {
lVar9 = lVar8 << ((byte)iVar15 & 0x3f);
ntt_conv(param_1,param_2 + lVar9 * 8,param_3 + lVar9 * 8,iVar15,param_5,param_6);
}
}
iVar7 = ntt_fft_partial(param_1,param_2,uVar13,iVar15,lVar14,lVar12,1,param_6);
iVar7 = -(uint)(iVar7 != 0);
}
}
return iVar7;
}
| |
26,002 | int testing::internal::CountIf<std::vector<testing::TestInfo*, std::allocator<testing::TestInfo*>>, bool (*)(testing::TestInfo const*)>(std::vector<testing::TestInfo*, std::allocator<testing::TestInfo*>> const&, bool (*)(testing::TestInfo const*)) | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-internal-inl.h | inline int CountIf(const Container& c, Predicate predicate) {
// Implemented as an explicit loop since std::count_if() in libCstd on
// Solaris has a non-standard signature.
int count = 0;
for (auto it = c.begin(); it != c.end(); ++it) {
if (predicate(*it)) ++count;
}
return count;
} | O0 | c | int testing::internal::CountIf<std::vector<testing::TestInfo*, std::allocator<testing::TestInfo*>>, bool (*)(testing::TestInfo const*)>(std::vector<testing::TestInfo*, std::allocator<testing::TestInfo*>> const&, bool (*)(testing::TestInfo const*)):
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x30(%rsp), %rdi
callq 0x69870
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x698e0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x698a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x4bb7b
jmp 0x4bbbb
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x69910
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rdi
callq *%rax
testb $0x1, %al
jne 0x4bba2
jmp 0x4bbad
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4bbaf
leaq 0x18(%rsp), %rdi
callq 0x69920
jmp 0x4bb55
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| _ZN7testing8internal7CountIfISt6vectorIPNS_8TestInfoESaIS4_EEPFbPKS3_EEEiRKT_T0_:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_14], 0
mov rdi, [rsp+38h+var_8]
call _ZNKSt6vectorIPN7testing8TestInfoESaIS2_EE5beginEv; std::vector<testing::TestInfo *>::begin(void)
mov [rsp+38h+var_20], rax
loc_4BB55:
mov rdi, [rsp+38h+var_8]
call _ZNKSt6vectorIPN7testing8TestInfoESaIS2_EE3endEv; std::vector<testing::TestInfo *>::end(void)
mov [rsp+38h+var_28], rax
lea rdi, [rsp+38h+var_20]
lea rsi, [rsp+38h+var_28]
call _ZN9__gnu_cxxeqIPKPN7testing8TestInfoESt6vectorIS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T0_EESE_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
xor al, 0FFh
test al, 1
jnz short loc_4BB7B
jmp short loc_4BBBB
loc_4BB7B:
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_30], rax
lea rdi, [rsp+38h+var_20]
call _ZNK9__gnu_cxx17__normal_iteratorIPKPN7testing8TestInfoESt6vectorIS3_SaIS3_EEEdeEv; __gnu_cxx::__normal_iterator<testing::TestInfo * const*,std::vector<testing::TestInfo *>>::operator*(void)
mov rcx, rax
mov rax, [rsp+38h+var_30]
mov rdi, [rcx]
call rax
test al, 1
jnz short loc_4BBA2
jmp short loc_4BBAD
loc_4BBA2:
mov eax, [rsp+38h+var_14]
add eax, 1
mov [rsp+38h+var_14], eax
loc_4BBAD:
jmp short $+2
loc_4BBAF:
lea rdi, [rsp+38h+var_20]
call _ZN9__gnu_cxx17__normal_iteratorIPKPN7testing8TestInfoESt6vectorIS3_SaIS3_EEEppEv; __gnu_cxx::__normal_iterator<testing::TestInfo * const*,std::vector<testing::TestInfo *>>::operator++(void)
jmp short loc_4BB55
loc_4BBBB:
mov eax, [rsp+38h+var_14]
add rsp, 38h
retn
| long long testing::internal::CountIf<std::vector<testing::TestInfo *>,bool (*)(testing::TestInfo const*)>(
long long a1,
long long ( *a2)(_QWORD))
{
_QWORD *v2; // rax
long long ( *v4)(_QWORD); // [rsp+8h] [rbp-30h]
long long v5; // [rsp+10h] [rbp-28h] BYREF
long long i; // [rsp+18h] [rbp-20h] BYREF
unsigned int v7; // [rsp+24h] [rbp-14h]
long long ( *v8)(_QWORD); // [rsp+28h] [rbp-10h]
long long v9; // [rsp+30h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = 0;
for ( i = std::vector<testing::TestInfo *>::begin(a1);
;
__gnu_cxx::__normal_iterator<testing::TestInfo * const*,std::vector<testing::TestInfo *>>::operator++(&i) )
{
v5 = std::vector<testing::TestInfo *>::end(v9);
if ( (__gnu_cxx::operator==<testing::TestInfo * const*,std::vector<testing::TestInfo *>>(&i, &v5) & 1) != 0 )
break;
v4 = v8;
v2 = (_QWORD *)__gnu_cxx::__normal_iterator<testing::TestInfo * const*,std::vector<testing::TestInfo *>>::operator*(&i);
if ( (v4(*v2) & 1) != 0 )
++v7;
}
return v7;
}
| CountIf<std::vector<testing::TestInfo*,std::allocator<testing::TestInfo*>>,bool(*)(testing::TestInfo_const*)>:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV dword ptr [RSP + 0x24],0x0
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x00169870
MOV qword ptr [RSP + 0x18],RAX
LAB_0014bb55:
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x001698e0
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0x10]
CALL 0x001698a0
XOR AL,0xff
TEST AL,0x1
JNZ 0x0014bb7b
JMP 0x0014bbbb
LAB_0014bb7b:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x18]
CALL 0x00169910
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RCX]
CALL RAX
TEST AL,0x1
JNZ 0x0014bba2
JMP 0x0014bbad
LAB_0014bba2:
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
LAB_0014bbad:
JMP 0x0014bbaf
LAB_0014bbaf:
LEA RDI,[RSP + 0x18]
CALL 0x00169920
JMP 0x0014bb55
LAB_0014bbbb:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x38
RET
|
/* int testing::internal::CountIf<std::vector<testing::TestInfo*, std::allocator<testing::TestInfo*>
>, bool (*)(testing::TestInfo const*)>(std::vector<testing::TestInfo*,
std::allocator<testing::TestInfo*> > const&, bool (*)(testing::TestInfo const*)) */
int testing::internal::
CountIf<std::vector<testing::TestInfo*,std::allocator<testing::TestInfo*>>,bool(*)(testing::TestInfo_const*)>
(vector *param_1,_func_bool_TestInfo_ptr *param_2)
{
_func_bool_TestInfo_ptr *p_Var1;
byte bVar2;
bool bVar3;
int8 *puVar4;
int8 local_28;
int8 local_20;
int local_14;
_func_bool_TestInfo_ptr *local_10;
vector *local_8;
local_14 = 0;
local_10 = param_2;
local_8 = param_1;
local_20 = std::vector<testing::TestInfo*,std::allocator<testing::TestInfo*>>::begin
((vector<testing::TestInfo*,std::allocator<testing::TestInfo*>> *)param_1);
while( true ) {
local_28 = std::vector<testing::TestInfo*,std::allocator<testing::TestInfo*>>::end
((vector<testing::TestInfo*,std::allocator<testing::TestInfo*>> *)local_8);
bVar2 = _ZN9__gnu_cxxeqIPKPN7testing8TestInfoESt6vectorIS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T0_EESE_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
(&local_20,&local_28);
p_Var1 = local_10;
if (((bVar2 ^ 0xff) & 1) == 0) break;
puVar4 = (int8 *)
__gnu_cxx::
__normal_iterator<testing::TestInfo*const*,std::vector<testing::TestInfo*,std::allocator<testing::TestInfo*>>>
::operator*((__normal_iterator<testing::TestInfo*const*,std::vector<testing::TestInfo*,std::allocator<testing::TestInfo*>>>
*)&local_20);
bVar3 = (*p_Var1)((TestInfo *)*puVar4);
if (bVar3) {
local_14 = local_14 + 1;
}
__gnu_cxx::
__normal_iterator<testing::TestInfo*const*,std::vector<testing::TestInfo*,std::allocator<testing::TestInfo*>>>
::operator++((__normal_iterator<testing::TestInfo*const*,std::vector<testing::TestInfo*,std::allocator<testing::TestInfo*>>>
*)&local_20);
}
return local_14;
}
| |
26,003 | miller_loop_n | corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/pairing.c | static void miller_loop_n(vec384fp12 ret, const POINTonE2_affine Q[],
const POINTonE1_affine P[], size_t n)
{
#if !defined(__STDC_VERSION__) || __STDC_VERSION__<199901 \
|| defined(__STDC_NO_VLA__)
POINTonE2 *T = alloca(n*sizeof(POINTonE2));
POINTonE1_affine *Px2 = alloca(n*sizeof(POINTonE1_affine));
#else
POINTonE2 T[n];
POINTonE1_affine Px2[n];
#endif
size_t i;
if ((n == 1) && (vec_is_zero(&Q[0], sizeof(Q[0])) |
vec_is_zero(&P[0], sizeof(P[0]))) ) {
/*
* Special case of infinite aggregated signature, pair the additive
* group's identity with the multiplicative group's identity.
*/
vec_copy(ret, BLS12_381_Rx.p12, sizeof(vec384fp12));
return;
}
for (i = 0; i < n; i++) {
/* Move common expression from line evaluation to line_by_Px2. */
add_fp(Px2[i].X, P[i].X, P[i].X);
neg_fp(Px2[i].X, Px2[i].X);
add_fp(Px2[i].Y, P[i].Y, P[i].Y);
vec_copy(T[i].X, Q[i].X, 2*sizeof(T[i].X));
vec_copy(T[i].Z, BLS12_381_Rx.p2, sizeof(T[i].Z));
}
/* first step is ret = 1^2*line, which is replaced with ret = line */
start_dbl_n(ret, T, Px2, n); /* 0x2 */
add_n_dbl_n(ret, T, Q, Px2, n, 2); /* ..0xc */
add_n_dbl_n(ret, T, Q, Px2, n, 3); /* ..0x68 */
add_n_dbl_n(ret, T, Q, Px2, n, 9); /* ..0xd200 */
add_n_dbl_n(ret, T, Q, Px2, n, 32); /* ..0xd20100000000 */
add_n_dbl_n(ret, T, Q, Px2, n, 16); /* ..0xd201000000010000 */
conjugate_fp12(ret); /* account for z being negative */
} | O2 | c | miller_loop_n:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, -0x30(%rbp)
movq %rsp, %r13
imulq $0x120, %rcx, %rax # imm = 0x120
subq %rax, %r13
movq %r13, %rsp
movq %rsp, %rcx
imulq $0x60, %r14, %rax
subq %rax, %rcx
movq %rcx, %rsp
cmpq $0x1, %r14
movq %r14, -0x50(%rbp)
movq %rsi, -0x48(%rbp)
movq %r13, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
jne 0x1d059
movl $0xc0, %esi
movq %r12, %rdi
callq 0x17a59
movq %rax, %r15
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x17a59
orq %r15, %rax
movq %r12, %r15
movq %r13, %r12
movq -0x38(%rbp), %r13
je 0x1d0cf
leaq 0x1db0b(%rip), %rsi # 0x3ab48
movl $0x240, %edx # imm = 0x240
movq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x179b9
movq %r12, %r15
movq %r13, %r12
movq %rcx, %r13
jmp 0x1d0cf
movq %r13, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x1d3dc
pushq $0x1
popq %rdx
movq %r13, %rdi
movq %r13, %rsi
callq 0x1d3ed
leaq 0x30(%r13), %rdi
leaq 0x30(%rbx), %rdx
movq %rdx, %rsi
callq 0x1d3dc
movl $0xc0, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x179b9
movl $0xc0, %eax
leaq (%r12,%rax), %rdi
leaq 0x1da98(%rip), %rsi # 0x3ab48
pushq $0x60
popq %rdx
callq 0x179b9
addq $0x60, %r13
addq $0x60, %rbx
addq $0x120, %r12 # imm = 0x120
movl $0xc0, %eax
addq %rax, %r15
subq $0x1, %r14
jae 0x1d064
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq -0x40(%rbp), %r12
movq %r12, %rsi
movq -0x38(%rbp), %r13
movq %r13, %rdx
movq -0x50(%rbp), %r14
movq %r14, %rcx
callq 0x1d3fe
pushq $0x2
popq %r9
movq %rbx, %rdi
movq %r12, %rsi
movq -0x48(%rbp), %r15
movq %r15, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x1d4cd
pushq $0x3
popq %r9
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x1d4cd
pushq $0x9
popq %r9
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x1d4cd
pushq $0x20
popq %r9
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x1d4cd
pushq $0x10
popq %r9
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x1d4cd
movq %rbx, %rdi
callq 0x1cb57
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| miller_loop_n:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rcx
mov rbx, rdx
mov r12, rsi
mov [rbp+var_30], rdi
mov r13, rsp
imul rax, rcx, 120h
sub r13, rax
mov rsp, r13
mov rcx, rsp
imul rax, r14, 60h ; '`'
sub rcx, rax
mov rsp, rcx
cmp r14, 1
mov [rbp+var_50], r14
mov [rbp+var_48], rsi
mov [rbp+var_40], r13
mov [rbp+var_38], rcx
jnz short loc_1D059
mov esi, 0C0h
mov rdi, r12
call vec_is_zero
mov r15, rax
push 60h ; '`'
pop rsi
mov rdi, rbx
call vec_is_zero
or rax, r15
mov r15, r12
mov r12, r13
mov r13, [rbp+var_38]
jz loc_1D0CF
lea rsi, BLS12_381_Rx
mov edx, 240h
mov rdi, [rbp+var_30]
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp vec_copy
loc_1D059:
mov r15, r12
mov r12, r13
mov r13, rcx
jmp short loc_1D0CF
loc_1D064:
mov rdi, r13
mov rsi, rbx
mov rdx, rbx
call add_fp
push 1
pop rdx
mov rdi, r13
mov rsi, r13
call cneg_fp
lea rdi, [r13+30h]
lea rdx, [rbx+30h]
mov rsi, rdx
call add_fp
mov edx, 0C0h
mov rdi, r12
mov rsi, r15
call vec_copy
mov eax, 0C0h
lea rdi, [r12+rax]
lea rsi, BLS12_381_Rx
push 60h ; '`'
pop rdx
call vec_copy
add r13, 60h ; '`'
add rbx, 60h ; '`'
add r12, 120h
mov eax, 0C0h
add r15, rax
loc_1D0CF:
sub r14, 1
jnb short loc_1D064
mov rbx, [rbp+var_30]
mov rdi, rbx
mov r12, [rbp+var_40]
mov rsi, r12
mov r13, [rbp+var_38]
mov rdx, r13
mov r14, [rbp+var_50]
mov rcx, r14
call start_dbl_n
push 2
pop r9
mov rdi, rbx
mov rsi, r12
mov r15, [rbp+var_48]
mov rdx, r15
mov rcx, r13
mov r8, r14
call add_n_dbl_n
push 3
pop r9
mov rdi, rbx
mov rsi, r12
mov rdx, r15
mov rcx, r13
mov r8, r14
call add_n_dbl_n
push 9
pop r9
mov rdi, rbx
mov rsi, r12
mov rdx, r15
mov rcx, r13
mov r8, r14
call add_n_dbl_n
push 20h ; ' '
pop r9
mov rdi, rbx
mov rsi, r12
mov rdx, r15
mov rcx, r13
mov r8, r14
call add_n_dbl_n
push 10h
pop r9
mov rdi, rbx
mov rsi, r12
mov rdx, r15
mov rcx, r13
mov r8, r14
call add_n_dbl_n
mov rdi, rbx
call conjugate_fp12
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long miller_loop_n(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // r14
long long *v6; // r13
long long *v7; // rcx
unsigned long long is_zero; // r15
unsigned long long v9; // rax
long long v10; // r15
long long v11; // r12
long long *v12; // r13
long long v15; // rbx
long long *v16; // r12
long long *v17; // r13
long long v18; // r14
long long v19; // r15
long long v20; // [rsp+0h] [rbp-50h] BYREF
long long v21; // [rsp+8h] [rbp-48h]
long long *v22; // [rsp+10h] [rbp-40h]
long long *v23; // [rsp+18h] [rbp-38h]
long long v24; // [rsp+20h] [rbp-30h]
v4 = a4;
v24 = a1;
v6 = &v20 - 36 * a4;
v7 = &v20 - 12 * a4;
v20 = v4;
v21 = a2;
v22 = v6;
v23 = v7;
if ( v4 == 1 )
{
is_zero = vec_is_zero(a2, 0xC0uLL);
v9 = is_zero | vec_is_zero(a3, 0x60uLL);
v10 = a2;
v11 = (long long)v6;
v12 = v23;
if ( v9 )
return vec_copy(v24, (long long)&BLS12_381_Rx, 0x240uLL);
}
else
{
v10 = a2;
v11 = (long long)v6;
v12 = v7;
}
while ( v4-- != 0 )
{
add_fp(v12, a3, a3);
cneg_fp(v12, v12, 1LL);
add_fp(v12 + 6, a3 + 48, a3 + 48);
vec_copy(v11, v10, 0xC0uLL);
vec_copy(v11 + 192, (long long)&BLS12_381_Rx, 0x60uLL);
v12 += 12;
a3 += 96LL;
v11 += 288LL;
v10 += 192LL;
}
v15 = v24;
v16 = v22;
v17 = v23;
v18 = v20;
start_dbl_n(v24, v22, v23, v20);
v19 = v21;
add_n_dbl_n(v15, v16, v21, v17, v18, 2LL);
add_n_dbl_n(v15, v16, v19, v17, v18, 3LL);
add_n_dbl_n(v15, v16, v19, v17, v18, 9LL);
add_n_dbl_n(v15, v16, v19, v17, v18, 32LL);
add_n_dbl_n(v15, v16, v19, v17, v18, 16LL);
return conjugate_fp12(v15);
}
| miller_loop_n:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RCX
MOV RBX,RDX
MOV R12,RSI
MOV qword ptr [RBP + -0x30],RDI
MOV R13,RSP
IMUL RAX,RCX,0x120
SUB R13,RAX
MOV RSP,R13
MOV RCX,RSP
IMUL RAX,R14,0x60
SUB RCX,RAX
MOV RSP,RCX
CMP R14,0x1
MOV qword ptr [RBP + -0x50],R14
MOV qword ptr [RBP + -0x48],RSI
MOV qword ptr [RBP + -0x40],R13
MOV qword ptr [RBP + -0x38],RCX
JNZ 0x0011d059
MOV ESI,0xc0
MOV RDI,R12
CALL 0x00117a59
MOV R15,RAX
PUSH 0x60
POP RSI
MOV RDI,RBX
CALL 0x00117a59
OR RAX,R15
MOV R15,R12
MOV R12,R13
MOV R13,qword ptr [RBP + -0x38]
JZ 0x0011d0cf
LEA RSI,[0x13ab48]
MOV EDX,0x240
MOV RDI,qword ptr [RBP + -0x30]
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001179b9
LAB_0011d059:
MOV R15,R12
MOV R12,R13
MOV R13,RCX
JMP 0x0011d0cf
LAB_0011d064:
MOV RDI,R13
MOV RSI,RBX
MOV RDX,RBX
CALL 0x0011d3dc
PUSH 0x1
POP RDX
MOV RDI,R13
MOV RSI,R13
CALL 0x0011d3ed
LEA RDI,[R13 + 0x30]
LEA RDX,[RBX + 0x30]
MOV RSI,RDX
CALL 0x0011d3dc
MOV EDX,0xc0
MOV RDI,R12
MOV RSI,R15
CALL 0x001179b9
MOV EAX,0xc0
LEA RDI,[R12 + RAX*0x1]
LEA RSI,[0x13ab48]
PUSH 0x60
POP RDX
CALL 0x001179b9
ADD R13,0x60
ADD RBX,0x60
ADD R12,0x120
MOV EAX,0xc0
ADD R15,RAX
LAB_0011d0cf:
SUB R14,0x1
JNC 0x0011d064
MOV RBX,qword ptr [RBP + -0x30]
MOV RDI,RBX
MOV R12,qword ptr [RBP + -0x40]
MOV RSI,R12
MOV R13,qword ptr [RBP + -0x38]
MOV RDX,R13
MOV R14,qword ptr [RBP + -0x50]
MOV RCX,R14
CALL 0x0011d3fe
PUSH 0x2
POP R9
MOV RDI,RBX
MOV RSI,R12
MOV R15,qword ptr [RBP + -0x48]
MOV RDX,R15
MOV RCX,R13
MOV R8,R14
CALL 0x0011d4cd
PUSH 0x3
POP R9
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
MOV RCX,R13
MOV R8,R14
CALL 0x0011d4cd
PUSH 0x9
POP R9
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
MOV RCX,R13
MOV R8,R14
CALL 0x0011d4cd
PUSH 0x20
POP R9
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
MOV RCX,R13
MOV R8,R14
CALL 0x0011d4cd
PUSH 0x10
POP R9
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
MOV RCX,R13
MOV R8,R14
CALL 0x0011d4cd
MOV RDI,RBX
CALL 0x0011cb57
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Type propagation algorithm not settling */
void miller_loop_n(int8 param_1,long param_2,long param_3,long param_4)
{
int8 uVar1;
int8 uVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
bool bVar9;
int8 uStack_60;
long local_58;
long local_50;
long local_48;
long local_40;
int8 local_38;
lVar7 = (long)&local_58 + param_4 * -0x120;
lVar6 = lVar7 + param_4 * -0x60;
lVar8 = lVar6;
local_58 = param_4;
local_50 = param_2;
local_48 = lVar7;
local_40 = lVar6;
local_38 = param_1;
if (param_4 == 1) {
*(int8 *)(lVar6 + -8) = 0x11d015;
lVar4 = vec_is_zero(param_2,0xc0);
*(int8 *)(lVar6 + -8) = 0x60;
uVar1 = *(int8 *)(lVar6 + -8);
*(int8 *)(lVar6 + -8) = 0x11d023;
lVar5 = vec_is_zero(param_3,uVar1);
lVar8 = local_40;
if (lVar5 != 0 || lVar4 != 0) {
vec_copy(local_38,BLS12_381_Rx,0x240);
return;
}
}
while (uVar1 = local_38, lVar3 = local_40, lVar5 = local_48, lVar4 = local_58,
bVar9 = param_4 != 0, param_4 = param_4 + -1, bVar9) {
*(int8 *)(lVar6 + -8) = 0x11d072;
add_fp(lVar8,param_3,param_3);
*(int8 *)(lVar6 + -8) = 1;
uVar1 = *(int8 *)(lVar6 + -8);
*(int8 *)(lVar6 + -8) = 0x11d080;
cneg_fp(lVar8,lVar8,uVar1);
*(int8 *)(lVar6 + -8) = 0x11d090;
add_fp(lVar8 + 0x30,param_3 + 0x30);
*(int8 *)(lVar6 + -8) = 0x11d0a0;
vec_copy(lVar7,param_2,0xc0);
*(int8 *)(lVar6 + -8) = 0x60;
uVar1 = *(int8 *)(lVar6 + -8);
*(int8 *)(lVar6 + -8) = 0x11d0b8;
vec_copy(lVar7 + 0xc0,BLS12_381_Rx,uVar1);
param_3 = param_3 + 0x60;
lVar7 = lVar7 + 0x120;
param_2 = param_2 + 0xc0;
lVar8 = lVar8 + 0x60;
}
*(int8 *)(lVar6 + -8) = 0x11d0f6;
start_dbl_n(uVar1,lVar5,lVar3,lVar4);
*(int8 *)(lVar6 + -8) = 2;
lVar8 = local_50;
uVar2 = *(int8 *)(lVar6 + -8);
*(int8 *)(lVar6 + -8) = 0x11d112;
add_n_dbl_n(uVar1,lVar5,lVar8,lVar3,lVar4,uVar2);
*(int8 *)(lVar6 + -8) = 3;
uVar2 = *(int8 *)(lVar6 + -8);
*(int8 *)(lVar6 + -8) = 0x11d12a;
add_n_dbl_n(uVar1,lVar5,lVar8,lVar3,lVar4,uVar2);
*(int8 *)(lVar6 + -8) = 9;
uVar2 = *(int8 *)(lVar6 + -8);
*(int8 *)(lVar6 + -8) = 0x11d142;
add_n_dbl_n(uVar1,lVar5,lVar8,lVar3,lVar4,uVar2);
*(int8 *)(lVar6 + -8) = 0x20;
uVar2 = *(int8 *)(lVar6 + -8);
*(int8 *)(lVar6 + -8) = 0x11d15a;
add_n_dbl_n(uVar1,lVar5,lVar8,lVar3,lVar4,uVar2);
*(int8 *)(lVar6 + -8) = 0x10;
uVar2 = *(int8 *)(lVar6 + -8);
*(int8 *)(lVar6 + -8) = 0x11d172;
add_n_dbl_n(uVar1,lVar5,lVar8,lVar3,lVar4,uVar2);
*(int8 *)(lVar6 + -8) = 0x11d17a;
conjugate_fp12(uVar1);
return;
}
| |
26,004 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) | llama.cpp/common/json.hpp | inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
diyfp M_minus, diyfp w, diyfp M_plus)
{
static_assert(kAlpha >= -60, "internal error");
static_assert(kGamma <= -32, "internal error");
// Generates the digits (and the exponent) of a decimal floating-point
// number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
// w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
//
// <--------------------------- delta ---->
// <---- dist --------->
// --------------[------------------+-------------------]--------------
// M- w M+
//
// Grisu2 generates the digits of M+ from left to right and stops as soon as
// V is in [M-,M+].
JSON_ASSERT(M_plus.e >= kAlpha);
JSON_ASSERT(M_plus.e <= kGamma);
std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
// Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
//
// M+ = f * 2^e
// = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
// = ((p1 ) * 2^-e + (p2 )) * 2^e
// = p1 + p2 * 2^e
const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
// 1)
//
// Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
JSON_ASSERT(p1 > 0);
std::uint32_t pow10{};
const int k = find_largest_pow10(p1, pow10);
// 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
//
// p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
// = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1))
//
// M+ = p1 + p2 * 2^e
// = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e
// = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
// = d[k-1] * 10^(k-1) + ( rest) * 2^e
//
// Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
//
// p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
//
// but stop as soon as
//
// rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
int n = k;
while (n > 0)
{
// Invariants:
// M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
// pow10 = 10^(n-1) <= p1 < 10^n
//
const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
//
// M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
// = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
//
JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
//
p1 = r;
n--;
//
// M+ = buffer * 10^n + (p1 + p2 * 2^e)
// pow10 = 10^n
//
// Now check if enough digits have been generated.
// Compute
//
// p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
//
// Note:
// Since rest and delta share the same exponent e, it suffices to
// compare the significands.
const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
if (rest <= delta)
{
// V = buffer * 10^n, with M- <= V <= M+.
decimal_exponent += n;
// We may now just stop. But instead look if the buffer could be
// decremented to bring V closer to w.
//
// pow10 = 10^n is now 1 ulp in the decimal representation V.
// The rounding procedure works with diyfp's with an implicit
// exponent of e.
//
// 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
//
const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
grisu2_round(buffer, length, dist, delta, rest, ten_n);
return;
}
pow10 /= 10;
//
// pow10 = 10^(n-1) <= p1 < 10^n
// Invariants restored.
}
// 2)
//
// The digits of the integral part have been generated:
//
// M+ = d[k-1]...d[1]d[0] + p2 * 2^e
// = buffer + p2 * 2^e
//
// Now generate the digits of the fractional part p2 * 2^e.
//
// Note:
// No decimal point is generated: the exponent is adjusted instead.
//
// p2 actually represents the fraction
//
// p2 * 2^e
// = p2 / 2^-e
// = d[-1] / 10^1 + d[-2] / 10^2 + ...
//
// Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
//
// p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
// + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
//
// using
//
// 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
// = ( d) * 2^-e + ( r)
//
// or
// 10^m * p2 * 2^e = d + r * 2^e
//
// i.e.
//
// M+ = buffer + p2 * 2^e
// = buffer + 10^-m * (d + r * 2^e)
// = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
//
// and stop as soon as 10^-m * r * 2^e <= delta * 2^e
JSON_ASSERT(p2 > delta);
int m = 0;
for (;;)
{
// Invariant:
// M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
// = buffer * 10^-m + 10^-m * (p2 ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
//
JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
p2 *= 10;
const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
//
// M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
// = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
p2 = r;
m++;
//
// M+ = buffer * 10^-m + 10^-m * p2 * 2^e
// Invariant restored.
// Check if enough digits have been generated.
//
// 10^-m * p2 * 2^e <= delta * 2^e
// p2 * 2^e <= 10^m * delta * 2^e
// p2 <= 10^m * delta
delta *= 10;
dist *= 10;
if (p2 <= delta)
{
break;
}
}
// V = buffer * 10^-m, with M- <= V <= M+.
decimal_exponent -= m;
// 1 ulp in the decimal representation is now 10^-m.
// Since delta and dist are now scaled by 10^m, we need to do the
// same with ulp in order to keep the units in sync.
//
// 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
//
const std::uint64_t ten_m = one.f;
grisu2_round(buffer, length, dist, delta, p2, ten_m);
// By construction this algorithm generates the shortest possible decimal
// number (Loitsch, Theorem 6.2) which rounds back to w.
// For an input number of precision p, at least
//
// N = 1 + ceil(p * log_10(2))
//
// decimal digits are sufficient to identify all binary floating-point
// numbers (Matula, "In-and-Out conversions").
// This implies that the algorithm does not produce more than N decimal
// digits.
//
// N = 17 for p = 53 (IEEE double precision)
// N = 9 for p = 24 (IEEE single precision)
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movl %r8d, 0x10(%rsp)
movl 0x68(%rsp), %eax
cmpl $-0x3d, %eax
jle 0x7fbf2
movq %rdx, (%rsp)
cmpl $-0x1f, %eax
jge 0x7fc0e
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %r13
leaq 0x50(%rsp), %rbp
leaq 0x8(%rsp), %rsi
movq %r13, %rdi
callq 0x7fc62
movq %rax, %r12
movq %r13, %rdi
movq %rbp, %rsi
callq 0x7fc62
xorl %ecx, %ecx
subl 0x8(%r13), %ecx
movl $0x1, %r9d
shlq %cl, %r9
movq (%r13), %r8
movq %r8, %rdx
shrq %cl, %rdx
testl %edx, %edx
je 0x7fc2a
movq %rax, %r10
leaq -0x1(%r9), %rsi
cmpl $0x3b9ac9ff, %edx # imm = 0x3B9AC9FF
jbe 0x7f9fb
movl $0x3b9aca00, %edi # imm = 0x3B9ACA00
movl $0xa, %r13d
jmp 0x7faa0
cmpl $0x5f5e0ff, %edx # imm = 0x5F5E0FF
jbe 0x7fa13
movl $0x5f5e100, %edi # imm = 0x5F5E100
movl $0x9, %r13d
jmp 0x7faa0
cmpl $0x98967f, %edx # imm = 0x98967F
jbe 0x7fa28
movl $0x989680, %edi # imm = 0x989680
movl $0x8, %r13d
jmp 0x7faa0
cmpl $0xf423f, %edx # imm = 0xF423F
jbe 0x7fa3d
movl $0xf4240, %edi # imm = 0xF4240
movl $0x7, %r13d
jmp 0x7faa0
cmpl $0x1869f, %edx # imm = 0x1869F
jbe 0x7fa52
movl $0x186a0, %edi # imm = 0x186A0
movl $0x6, %r13d
jmp 0x7faa0
cmpl $0x270f, %edx # imm = 0x270F
jbe 0x7fa67
movl $0x2710, %edi # imm = 0x2710
movl $0x5, %r13d
jmp 0x7faa0
cmpl $0x3e7, %edx # imm = 0x3E7
jbe 0x7fa7c
movl $0x3e8, %edi # imm = 0x3E8
movl $0x4, %r13d
jmp 0x7faa0
cmpl $0x63, %edx
jbe 0x7fa8e
movl $0x64, %edi
movl $0x3, %r13d
jmp 0x7faa0
xorl %r13d, %r13d
cmpl $0xa, %edx
setae %r13b
leal 0x1(%r13,%r13,8), %edi
incl %r13d
andq %rsi, %r8
incl %r13d
movl $0xcccccccd, %ebp # imm = 0xCCCCCCCD
movl %edx, %eax
xorl %edx, %edx
divl %edi
cmpl $0xa, %eax
jae 0x7fb99
movslq (%r14), %r15
leal 0x1(%r15), %r11d
movl %r11d, (%r14)
movl %edx, %r11d
shlq %cl, %r11
orb $0x30, %al
movb %al, (%rbx,%r15)
addq %r8, %r11
cmpq %r12, %r11
jbe 0x7fb62
movl %edi, %edi
imulq %rbp, %rdi
shrq $0x23, %rdi
decl %r13d
cmpl $0x1, %r13d
ja 0x7faab
cmpq %r12, %r8
jbe 0x7fc46
xorl %eax, %eax
movabsq $0x199999999999999a, %rdx # imm = 0x199999999999999A
cmpq %rdx, %r8
jae 0x7fbb5
addq %r8, %r8
leaq (%r8,%r8,4), %r8
movq %r8, %rdi
shrq %cl, %rdi
cmpq $0xa, %rdi
jae 0x7fbd1
andq %rsi, %r8
orb $0x30, %dil
movslq (%r14), %r11
leal 0x1(%r11), %ebp
movl %ebp, (%r14)
movb %dil, (%rbx,%r11)
addq %r12, %r12
leaq (%r12,%r12,4), %r12
addq %r10, %r10
leaq (%r10,%r10,4), %r10
decl %eax
cmpq %r12, %r8
ja 0x7fb04
movq (%rsp), %rcx
addl %eax, (%rcx)
movl (%r14), %esi
movq %rbx, %rdi
movq %r10, %rdx
movq %r12, %rcx
jmp 0x7fb85
movq (%rsp), %rdx
movl (%rdx), %eax
addl %r13d, %eax
addl $-0x2, %eax
movl %eax, (%rdx)
movl %edi, %r9d
shlq %cl, %r9
movl (%r14), %esi
movq %rbx, %rdi
movq %r10, %rdx
movq %r12, %rcx
movq %r11, %r8
callq 0x7fcac
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9b9d8(%rip), %rdi # 0x11b578
leaq 0x9ba0c(%rip), %rdx # 0x11b5b3
leaq 0x9d037(%rip), %rcx # 0x11cbe5
movl $0x44a3, %esi # imm = 0x44A3
jmp 0x7fbeb
leaq 0x9b9bc(%rip), %rdi # 0x11b578
leaq 0x9b9f0(%rip), %rdx # 0x11b5b3
leaq 0x9d02d(%rip), %rcx # 0x11cbf7
movl $0x4505, %esi # imm = 0x4505
jmp 0x7fbeb
leaq 0x9b9a0(%rip), %rdi # 0x11b578
leaq 0x9b9d4(%rip), %rdx # 0x11b5b3
leaq 0x9cfff(%rip), %rcx # 0x11cbe5
movl $0x450e, %esi # imm = 0x450E
xorl %eax, %eax
callq 0x21e70
leaq 0x9b97f(%rip), %rdi # 0x11b578
leaq 0x9b9b3(%rip), %rdx # 0x11b5b3
leaq 0x9cfb1(%rip), %rcx # 0x11cbb8
movl $0x4469, %esi # imm = 0x4469
jmp 0x7fbeb
leaq 0x9b963(%rip), %rdi # 0x11b578
leaq 0x9b997(%rip), %rdx # 0x11b5b3
leaq 0x9cfa8(%rip), %rcx # 0x11cbcb
movl $0x446a, %esi # imm = 0x446A
jmp 0x7fbeb
leaq 0x9b947(%rip), %rdi # 0x11b578
leaq 0x9b97b(%rip), %rdx # 0x11b5b3
leaq 0x9cf9f(%rip), %rcx # 0x11cbde
movl $0x447f, %esi # imm = 0x447F
jmp 0x7fbeb
leaq 0x9b92b(%rip), %rdi # 0x11b578
leaq 0x9b95f(%rip), %rdx # 0x11b5b3
leaq 0x9cf91(%rip), %rcx # 0x11cbec
movl $0x44fa, %esi # imm = 0x44FA
jmp 0x7fbeb
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl16grisu2_digit_genEPcRiS4_NS2_5diyfpES5_S5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rcx
mov [rsp+48h+var_38], r8d
mov eax, [rsp+48h+arg_18]
cmp eax, 0FFFFFFC3h
jle loc_7FBF2
mov [rsp+48h+var_48], rdx; unsigned __int64
cmp eax, 0FFFFFFE1h
jge loc_7FC0E
mov r14, rsi
mov rbx, rdi
lea r13, [rsp+48h+arg_10]
lea rbp, [rsp+48h+arg_0]
lea rsi, [rsp+48h+var_40]
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3subERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov r12, rax
mov rdi, r13
mov rsi, rbp
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3subERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
xor ecx, ecx
sub ecx, [r13+8]
mov r9d, 1
shl r9, cl
mov r8, [r13+0]
mov rdx, r8
shr rdx, cl
test edx, edx
jz loc_7FC2A
mov r10, rax
lea rsi, [r9-1]
cmp edx, 3B9AC9FFh
jbe short loc_7F9FB
mov edi, 3B9ACA00h
mov r13d, 0Ah
jmp loc_7FAA0
loc_7F9FB:
cmp edx, 5F5E0FFh
jbe short loc_7FA13
mov edi, 5F5E100h
mov r13d, 9
jmp loc_7FAA0
loc_7FA13:
cmp edx, 98967Fh
jbe short loc_7FA28
mov edi, 989680h
mov r13d, 8
jmp short loc_7FAA0
loc_7FA28:
cmp edx, 0F423Fh
jbe short loc_7FA3D
mov edi, offset loc_F4240
mov r13d, 7
jmp short loc_7FAA0
loc_7FA3D:
cmp edx, 1869Fh
jbe short loc_7FA52
mov edi, 186A0h
mov r13d, 6
jmp short loc_7FAA0
loc_7FA52:
cmp edx, 270Fh
jbe short loc_7FA67
mov edi, 2710h
mov r13d, 5
jmp short loc_7FAA0
loc_7FA67:
cmp edx, 3E7h
jbe short loc_7FA7C
mov edi, 3E8h
mov r13d, 4
jmp short loc_7FAA0
loc_7FA7C:
cmp edx, 63h ; 'c'
jbe short loc_7FA8E
mov edi, 64h ; 'd'
mov r13d, 3
jmp short loc_7FAA0
loc_7FA8E:
xor r13d, r13d
cmp edx, 0Ah
setnb r13b
lea edi, [r13+r13*8+1]
inc r13d
loc_7FAA0:
and r8, rsi
inc r13d
mov ebp, 0CCCCCCCDh
loc_7FAAB:
mov eax, edx
xor edx, edx
div edi
cmp eax, 0Ah
jnb loc_7FB99
movsxd r15, dword ptr [r14]
lea r11d, [r15+1]
mov [r14], r11d
mov r11d, edx
shl r11, cl
or al, 30h
mov [rbx+r15], al
add r11, r8
cmp r11, r12
jbe loc_7FB62
mov edi, edi
imul rdi, rbp
shr rdi, 23h
dec r13d
cmp r13d, 1
ja short loc_7FAAB
cmp r8, r12
jbe loc_7FC46
xor eax, eax
mov rdx, 199999999999999Ah
loc_7FB04:
cmp r8, rdx
jnb loc_7FBB5
add r8, r8
lea r8, [r8+r8*4]
mov rdi, r8
shr rdi, cl
cmp rdi, 0Ah
jnb loc_7FBD1
and r8, rsi
or dil, 30h
movsxd r11, dword ptr [r14]
lea ebp, [r11+1]
mov [r14], ebp
mov [rbx+r11], dil
add r12, r12
lea r12, [r12+r12*4]
add r10, r10
lea r10, [r10+r10*4]
dec eax
cmp r8, r12
ja short loc_7FB04
mov rcx, [rsp+48h+var_48]
add [rcx], eax
mov esi, [r14]
mov rdi, rbx
mov rdx, r10
mov rcx, r12
jmp short loc_7FB85
loc_7FB62:
mov rdx, [rsp+48h+var_48]
mov eax, [rdx]
add eax, r13d
add eax, 0FFFFFFFEh
mov [rdx], eax
mov r9d, edi
shl r9, cl; unsigned __int64
mov esi, [r14]; char *
mov rdi, rbx; this
mov rdx, r10; int
mov rcx, r12; unsigned __int64
mov r8, r11; unsigned __int64
loc_7FB85:
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl12grisu2_roundEPcimmmm; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(char *,int,ulong,ulong,ulong,ulong)
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7FB99:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aD9; "d <= 9"
mov esi, 44A3h
jmp short loc_7FBEB
loc_7FBB5:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aP2StdNumericLi; "p2 <= (std::numeric_limits<std::uint64_"...
mov esi, 4505h
jmp short loc_7FBEB
loc_7FBD1:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aD9; "d <= 9"
mov esi, 450Eh
loc_7FBEB:
xor eax, eax
call _ggml_abort
loc_7FBF2:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEKalpha; "M_plus.e >= kAlpha"
mov esi, 4469h
jmp short loc_7FBEB
loc_7FC0E:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEKgamma; "M_plus.e <= kGamma"
mov esi, 446Ah
jmp short loc_7FBEB
loc_7FC2A:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aP10; "p1 > 0"
mov esi, 447Fh
jmp short loc_7FBEB
loc_7FC46:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aP2Delta; "p2 > delta"
mov esi, 44FAh
jmp short loc_7FBEB
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *this,
unsigned int *a2,
_DWORD *a3,
long long a4,
int a5,
long long a6,
char a7,
int a8,
unsigned long long a9,
int a10)
{
unsigned long long v12; // r12
int v13; // eax
int v14; // ecx
unsigned long long v15; // r9
unsigned long long v16; // rdx
int v17; // r10d
unsigned long long v18; // rsi
void *v19; // rdi
int v20; // r13d
BOOL v21; // r13d
unsigned long long v22; // r8
unsigned int v23; // r13d
unsigned int v24; // eax
unsigned int v25; // eax
long long v26; // r15
unsigned long long v27; // r11
int v28; // eax
unsigned long long v29; // r8
unsigned long long v30; // rdi
long long v31; // r11
char *v32; // rsi
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *v33; // rdi
int v34; // edx
unsigned long long v35; // rcx
long long v38; // [rsp+8h] [rbp-40h] BYREF
int v39; // [rsp+10h] [rbp-38h]
v38 = a4;
v39 = a5;
if ( a10 <= -61 )
{
while ( 1 )
LABEL_36:
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17513LL,
"GGML_ASSERT(%s) failed",
"M_plus.e >= kAlpha");
}
if ( a10 >= -31 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17514LL,
"GGML_ASSERT(%s) failed",
"M_plus.e <= kGamma");
goto LABEL_36;
}
v12 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(&a9, &v38);
v13 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(&a9, &a7);
v14 = -a10;
v15 = 1LL << -(char)a10;
v16 = a9 >> -(char)a10;
if ( !(_DWORD)v16 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17535LL,
"GGML_ASSERT(%s) failed",
"p1 > 0");
goto LABEL_36;
}
v17 = v13;
v18 = v15 - 1;
if ( (unsigned int)v16 <= 0x3B9AC9FF )
{
if ( (unsigned int)v16 <= 0x5F5E0FF )
{
if ( (unsigned int)v16 <= 0x98967F )
{
if ( (unsigned int)v16 <= 0xF423F )
{
if ( (unsigned int)v16 <= 0x1869F )
{
if ( (unsigned int)v16 <= 0x270F )
{
if ( (unsigned int)v16 <= 0x3E7 )
{
if ( (unsigned int)v16 <= 0x63 )
{
v21 = (unsigned int)v16 >= 0xA;
LODWORD(v19) = 9 * v21 + 1;
v20 = v21 + 1;
}
else
{
LODWORD(v19) = 100;
v20 = 3;
}
}
else
{
LODWORD(v19) = 1000;
v20 = 4;
}
}
else
{
LODWORD(v19) = 10000;
v20 = 5;
}
}
else
{
LODWORD(v19) = 100000;
v20 = 6;
}
}
else
{
v19 = &loc_F4240;
v20 = 7;
}
}
else
{
LODWORD(v19) = 10000000;
v20 = 8;
}
}
else
{
LODWORD(v19) = 100000000;
v20 = 9;
}
}
else
{
LODWORD(v19) = 1000000000;
v20 = 10;
}
v22 = v18 & a9;
v23 = v20 + 1;
do
{
v24 = v16;
LODWORD(v16) = (unsigned int)v16 % (unsigned int)v19;
v25 = v24 / (unsigned int)v19;
if ( v25 >= 0xA )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17571LL,
"GGML_ASSERT(%s) failed",
"d <= 9");
goto LABEL_36;
}
v26 = (int)*a2;
*a2 = v26 + 1;
*((_BYTE *)this + v26) = v25 | 0x30;
v27 = v22 + ((unsigned long long)(unsigned int)v16 << v14);
if ( v27 <= v12 )
{
*a3 = v23 + *a3 - 2;
v15 = (unsigned long long)(unsigned int)v19 << v14;
v32 = (char *)*a2;
v33 = this;
v34 = v17;
v35 = v12;
v22 = v27;
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(
v33,
v32,
v34,
v35,
v22,
v15,
(unsigned long long)a3);
}
LODWORD(v19) = (unsigned int)v19 / 0xA;
--v23;
}
while ( v23 > 1 );
if ( v22 <= v12 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17658LL,
"GGML_ASSERT(%s) failed",
"p2 > delta");
goto LABEL_36;
}
v28 = 0;
while ( 2 )
{
if ( v22 >= 0x199999999999999ALL )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17669LL,
"GGML_ASSERT(%s) failed",
"p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10");
goto LABEL_36;
}
v29 = 10 * v22;
v30 = v29 >> v14;
if ( v29 >> v14 >= 0xA )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17678LL,
"GGML_ASSERT(%s) failed",
"d <= 9");
goto LABEL_36;
}
v22 = v18 & v29;
v31 = (int)*a2;
*a2 = v31 + 1;
*((_BYTE *)this + v31) = v30 | 0x30;
v12 *= 10LL;
v17 *= 10;
--v28;
if ( v22 > v12 )
continue;
break;
}
*a3 += v28;
v32 = (char *)*a2;
v33 = this;
v34 = v17;
v35 = v12;
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(v33, v32, v34, v35, v22, v15, (unsigned long long)a3);
}
| grisu2_digit_gen:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RCX
MOV dword ptr [RSP + 0x10],R8D
MOV EAX,dword ptr [RSP + 0x68]
CMP EAX,-0x3d
JLE 0x0017fbf2
MOV qword ptr [RSP],RDX
CMP EAX,-0x1f
JGE 0x0017fc0e
MOV R14,RSI
MOV RBX,RDI
LEA R13,[RSP + 0x60]
LEA RBP,[RSP + 0x50]
LEA RSI,[RSP + 0x8]
MOV RDI,R13
CALL 0x0017fc62
MOV R12,RAX
MOV RDI,R13
MOV RSI,RBP
CALL 0x0017fc62
XOR ECX,ECX
SUB ECX,dword ptr [R13 + 0x8]
MOV R9D,0x1
SHL R9,CL
MOV R8,qword ptr [R13]
MOV RDX,R8
SHR RDX,CL
TEST EDX,EDX
JZ 0x0017fc2a
MOV R10,RAX
LEA RSI,[R9 + -0x1]
CMP EDX,0x3b9ac9ff
JBE 0x0017f9fb
MOV EDI,0x3b9aca00
MOV R13D,0xa
JMP 0x0017faa0
LAB_0017f9fb:
CMP EDX,0x5f5e0ff
JBE 0x0017fa13
MOV EDI,0x5f5e100
MOV R13D,0x9
JMP 0x0017faa0
LAB_0017fa13:
CMP EDX,0x98967f
JBE 0x0017fa28
MOV EDI,0x989680
MOV R13D,0x8
JMP 0x0017faa0
LAB_0017fa28:
CMP EDX,0xf423f
JBE 0x0017fa3d
MOV EDI,0xf4240
MOV R13D,0x7
JMP 0x0017faa0
LAB_0017fa3d:
CMP EDX,0x1869f
JBE 0x0017fa52
MOV EDI,0x186a0
MOV R13D,0x6
JMP 0x0017faa0
LAB_0017fa52:
CMP EDX,0x270f
JBE 0x0017fa67
MOV EDI,0x2710
MOV R13D,0x5
JMP 0x0017faa0
LAB_0017fa67:
CMP EDX,0x3e7
JBE 0x0017fa7c
MOV EDI,0x3e8
MOV R13D,0x4
JMP 0x0017faa0
LAB_0017fa7c:
CMP EDX,0x63
JBE 0x0017fa8e
MOV EDI,0x64
MOV R13D,0x3
JMP 0x0017faa0
LAB_0017fa8e:
XOR R13D,R13D
CMP EDX,0xa
SETNC R13B
LEA EDI,[R13 + R13*0x8 + 0x1]
INC R13D
LAB_0017faa0:
AND R8,RSI
INC R13D
MOV EBP,0xcccccccd
LAB_0017faab:
MOV EAX,EDX
XOR EDX,EDX
DIV EDI
CMP EAX,0xa
JNC 0x0017fb99
MOVSXD R15,dword ptr [R14]
LEA R11D,[R15 + 0x1]
MOV dword ptr [R14],R11D
MOV R11D,EDX
SHL R11,CL
OR AL,0x30
MOV byte ptr [RBX + R15*0x1],AL
ADD R11,R8
CMP R11,R12
JBE 0x0017fb62
MOV EDI,EDI
IMUL RDI,RBP
SHR RDI,0x23
DEC R13D
CMP R13D,0x1
JA 0x0017faab
CMP R8,R12
JBE 0x0017fc46
XOR EAX,EAX
MOV RDX,0x199999999999999a
LAB_0017fb04:
CMP R8,RDX
JNC 0x0017fbb5
ADD R8,R8
LEA R8,[R8 + R8*0x4]
MOV RDI,R8
SHR RDI,CL
CMP RDI,0xa
JNC 0x0017fbd1
AND R8,RSI
OR DIL,0x30
MOVSXD R11,dword ptr [R14]
LEA EBP,[R11 + 0x1]
MOV dword ptr [R14],EBP
MOV byte ptr [RBX + R11*0x1],DIL
ADD R12,R12
LEA R12,[R12 + R12*0x4]
ADD R10,R10
LEA R10,[R10 + R10*0x4]
DEC EAX
CMP R8,R12
JA 0x0017fb04
MOV RCX,qword ptr [RSP]
ADD dword ptr [RCX],EAX
MOV ESI,dword ptr [R14]
MOV RDI,RBX
MOV RDX,R10
MOV RCX,R12
JMP 0x0017fb85
LAB_0017fb62:
MOV RDX,qword ptr [RSP]
MOV EAX,dword ptr [RDX]
ADD EAX,R13D
ADD EAX,-0x2
MOV dword ptr [RDX],EAX
MOV R9D,EDI
SHL R9,CL
MOV ESI,dword ptr [R14]
MOV RDI,RBX
MOV RDX,R10
MOV RCX,R12
MOV R8,R11
LAB_0017fb85:
CALL 0x0017fcac
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017fb99:
LEA RDI,[0x21b578]
LEA RDX,[0x21b5b3]
LEA RCX,[0x21cbe5]
MOV ESI,0x44a3
JMP 0x0017fbeb
LAB_0017fbb5:
LEA RDI,[0x21b578]
LEA RDX,[0x21b5b3]
LEA RCX,[0x21cbf7]
MOV ESI,0x4505
JMP 0x0017fbeb
LAB_0017fbd1:
LEA RDI,[0x21b578]
LEA RDX,[0x21b5b3]
LEA RCX,[0x21cbe5]
MOV ESI,0x450e
LAB_0017fbeb:
XOR EAX,EAX
CALL 0x00121e70
LAB_0017fbf2:
LEA RDI,[0x21b578]
LEA RDX,[0x21b5b3]
LEA RCX,[0x21cbb8]
MOV ESI,0x4469
JMP 0x0017fbeb
LAB_0017fc0e:
LEA RDI,[0x21b578]
LEA RDX,[0x21b5b3]
LEA RCX,[0x21cbcb]
MOV ESI,0x446a
JMP 0x0017fbeb
LAB_0017fc2a:
LEA RDI,[0x21b578]
LEA RDX,[0x21b5b3]
LEA RCX,[0x21cbde]
MOV ESI,0x447f
JMP 0x0017fbeb
LAB_0017fc46:
LEA RDI,[0x21b578]
LEA RDX,[0x21b5b3]
LEA RCX,[0x21cbec]
MOV ESI,0x44fa
JMP 0x0017fbeb
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen
(char *param_1,int *param_2,int *param_3,int8 param_4,int4 param_5)
{
int iVar1;
byte bVar2;
int iVar3;
ulong uVar4;
ulong uVar5;
char *pcVar6;
ulong uVar7;
int8 uVar8;
ulong uVar9;
ulong uVar10;
ulong uVar11;
ulong uVar12;
uint uVar13;
ulong in_stack_00000018;
int in_stack_00000020;
int8 local_40;
int4 local_38;
local_40 = param_4;
local_38 = param_5;
if (in_stack_00000020 < -0x3c) {
pcVar6 = "M_plus.e >= kAlpha";
uVar8 = 0x4469;
}
else if (in_stack_00000020 < -0x1f) {
uVar4 = diyfp::sub((diyfp *)&stack0x00000018,(diyfp *)&local_40);
uVar5 = diyfp::sub((diyfp *)&stack0x00000018,&stack0x00000008);
bVar2 = -(char)in_stack_00000020;
uVar11 = 1L << (bVar2 & 0x3f);
uVar7 = in_stack_00000018 >> (bVar2 & 0x3f);
uVar13 = (uint)uVar7;
if (uVar13 == 0) {
pcVar6 = "p1 > 0";
uVar8 = 0x447f;
}
else {
if (uVar13 < 1000000000) {
if (uVar13 < 100000000) {
if (uVar13 < 10000000) {
if (uVar13 < 1000000) {
if (uVar13 < 100000) {
if (uVar13 < 10000) {
if (uVar13 < 1000) {
if (uVar13 < 100) {
uVar9 = (ulong)(9 < uVar13) * 9 + 1;
iVar3 = (9 < uVar13) + 1;
}
else {
uVar9 = 100;
iVar3 = 3;
}
}
else {
uVar9 = 1000;
iVar3 = 4;
}
}
else {
uVar9 = 10000;
iVar3 = 5;
}
}
else {
uVar9 = 100000;
iVar3 = 6;
}
}
else {
uVar9 = 1000000;
iVar3 = 7;
}
}
else {
uVar9 = 10000000;
iVar3 = 8;
}
}
else {
uVar9 = 100000000;
iVar3 = 9;
}
}
else {
uVar9 = 1000000000;
iVar3 = 10;
}
uVar10 = in_stack_00000018 & uVar11 - 1;
uVar13 = iVar3 + 1;
do {
uVar12 = (uVar7 & 0xffffffff) / uVar9;
uVar7 = (uVar7 & 0xffffffff) % uVar9;
if (9 < (uint)uVar12) {
pcVar6 = "d <= 9";
uVar8 = 0x44a3;
goto LAB_0017fbeb;
}
iVar3 = *param_2;
*param_2 = iVar3 + 1;
param_1[iVar3] = (byte)uVar12 | 0x30;
uVar12 = (uVar7 << (bVar2 & 0x3f)) + uVar10;
if (uVar12 <= uVar4) {
*param_3 = *param_3 + uVar13 + -2;
uVar11 = uVar9 << (bVar2 & 0x3f);
iVar3 = *param_2;
goto LAB_0017fb85;
}
uVar9 = uVar9 / 10;
uVar13 = uVar13 - 1;
} while (1 < uVar13);
if (uVar4 < uVar10) {
iVar3 = 0;
while( true ) {
if (0x1999999999999999 < uVar10) {
pcVar6 = "p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10";
uVar8 = 0x4505;
goto LAB_0017fbeb;
}
uVar7 = uVar10 * 10 >> (bVar2 & 0x3f);
if (9 < uVar7) break;
uVar10 = uVar10 * 10 & uVar11 - 1;
iVar1 = *param_2;
*param_2 = iVar1 + 1;
param_1[iVar1] = (byte)uVar7 | 0x30;
uVar4 = uVar4 * 10;
uVar5 = uVar5 * 10;
iVar3 = iVar3 + -1;
if (uVar10 <= uVar4) {
*param_3 = *param_3 + iVar3;
iVar3 = *param_2;
uVar12 = uVar10;
LAB_0017fb85:
grisu2_round(param_1,iVar3,uVar5,uVar4,uVar12,uVar11);
return;
}
}
pcVar6 = "d <= 9";
uVar8 = 0x450e;
}
else {
pcVar6 = "p2 > delta";
uVar8 = 0x44fa;
}
}
}
else {
pcVar6 = "M_plus.e <= kGamma";
uVar8 = 0x446a;
}
LAB_0017fbeb:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",uVar8,
"GGML_ASSERT(%s) failed",pcVar6);
}
| |
26,005 | test_case::eval(ggml_backend*, ggml_backend*, char const*) | monkey531[P]llama/tests/test-backend-ops.cpp | bool eval(ggml_backend_t backend1, ggml_backend_t backend2, const char * op_name) {
mode = MODE_TEST;
ggml_init_params params = {
/* .mem_size = */ ggml_tensor_overhead()*128 + ggml_graph_overhead(),
/* .mem_base = */ NULL,
/* .no_alloc = */ true,
};
ggml_context * ctx = ggml_init(params);
GGML_ASSERT(ctx);
gf = ggml_new_graph(ctx);
// pre-graph sentinel
add_sentinel(ctx);
ggml_tensor * out = build_graph(ctx);
if (op_name != nullptr && op_desc(out) != op_name) {
//printf(" %s: skipping\n", op_desc(out).c_str());
ggml_free(ctx);
return true;
}
printf(" %s(%s): ", op_desc(out).c_str(), vars().c_str());
fflush(stdout);
// check if the backends support the ops
bool supported = true;
for (ggml_backend_t backend : {backend1, backend2}) {
for (ggml_tensor * t = ggml_get_first_tensor(ctx); t != NULL; t = ggml_get_next_tensor(ctx, t)) {
if (!ggml_backend_supports_op(backend, t)) {
printf("not supported [%s] ", ggml_backend_name(backend));
supported = false;
break;
}
}
}
if (!supported) {
printf("\n");
ggml_free(ctx);
return true;
}
// post-graph sentinel
add_sentinel(ctx);
// allocate
ggml_backend_buffer_t buf = ggml_backend_alloc_ctx_tensors(ctx, backend1);
if (buf == NULL) {
printf("failed to allocate tensors [%s] ", ggml_backend_name(backend1));
ggml_free(ctx);
return false;
}
// build graph
ggml_build_forward_expand(gf, out);
// add sentinels as graph nodes so that they are checked in the callback
for (ggml_tensor * sentinel : sentinels) {
ggml_graph_add_node(gf, sentinel);
}
// randomize tensors
initialize_tensors(ctx);
// compare
struct callback_userdata {
bool ok;
double max_err;
ggml_backend_t backend1;
ggml_backend_t backend2;
};
callback_userdata ud {
true,
max_nmse_err(),
backend1,
backend2
};
auto callback = [](int index, ggml_tensor * t1, ggml_tensor * t2, void * user_data) -> bool {
callback_userdata * ud = (callback_userdata *) user_data;
const char * bn1 = ggml_backend_name(ud->backend1);
const char * bn2 = ggml_backend_name(ud->backend2);
if (t1->op == GGML_OP_NONE) {
// sentinels must be unchanged
std::vector<uint8_t> t1_data(ggml_nbytes(t1));
std::vector<uint8_t> t2_data(ggml_nbytes(t2));
ggml_backend_tensor_get(t1, t1_data.data(), 0, ggml_nbytes(t1));
ggml_backend_tensor_get(t2, t2_data.data(), 0, ggml_nbytes(t2));
if (memcmp(t1_data.data(), t2_data.data(), ggml_nbytes(t1)) != 0) {
printf("sentinel mismatch: %s ", t1->name);
ud->ok = false;
return true;
}
}
std::vector<float> f1 = tensor_to_float(t1);
std::vector<float> f2 = tensor_to_float(t2);
for (size_t i = 0; i < f1.size(); i++) {
// check for nans
if (std::isnan(f1[i]) || std::isnan(f2[i])) {
printf("[%s] NaN at index %zu (%s=%f %s=%f) ", ggml_op_desc(t1), i, bn1, f1[i], bn2, f2[i]);
ud->ok = false;
return true;
}
// check for infs: both must be inf of the same sign, or both must be finite
if (isinf_or_max(f1[i]) || isinf_or_max(f2[i])) {
if (isinf_or_max(f1[i]) && isinf_or_max(f2[i])) {
if (std::signbit(f1[i]) != std::signbit(f2[i])) {
printf("[%s] inf sign mismatch: %s=%f %s=%f ", ggml_op_desc(t1), bn1, f1[i], bn2, f2[i]);
ud->ok = false;
return true;
}
} else {
printf("[%s] inf mismatch: %s=%f %s=%f ", ggml_op_desc(t1), bn1, f1[i], bn2, f2[i]);
ud->ok = false;
return true;
}
}
}
double err = nmse(f1.data(), f2.data(), f1.size());
if (err > ud->max_err) {
printf("[%s] NMSE = %.9f > %.9f ", ggml_op_desc(t1), err, ud->max_err);
//for (int i = 0; i < (int) f1.size(); i++) {
// printf("%5d %9.6f %9.6f, diff = %9.6f\n", i, f1[i], f2[i], f1[i] - f2[i]);
//}
//printf("\n");
//exit(1);
ud->ok = false;
}
return true;
GGML_UNUSED(index);
};
const bool cmp_ok = ggml_backend_compare_graph_backend(backend1, backend2, gf, callback, &ud);
if (!cmp_ok) {
printf("compare failed ");
}
ggml_backend_buffer_free(buf);
ggml_free(ctx);
if (ud.ok && cmp_ok) {
printf("\033[1;32mOK\033[0m\n");
return true;
}
printf("\033[1;31mFAIL\033[0m\n");
return false;
} | O1 | cpp | test_case::eval(ggml_backend*, ggml_backend*, char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movl $0x0, 0x18(%rdi)
callq 0xda60
movq %rax, %rbx
shlq $0x7, %rbx
callq 0xd260
addq %rbx, %rax
movq %rax, 0x50(%rsp)
movq $0x0, 0x58(%rsp)
movb $0x1, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0xd500
testq %rax, %rax
je 0x17ec1
movq %rax, %rbx
movq %r14, 0x20(%rsp)
movq %rax, %rdi
callq 0xd990
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1bc8c
movq (%r12), %rax
movq %r12, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq %rax, %r13
testq %rbp, %rbp
je 0x17c4a
movq (%r12), %rax
leaq 0x88(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *0x10(%rax)
movq %r14, %rdi
movq %rbp, %rsi
callq 0xd160
testl %eax, %eax
setne %r14b
jmp 0x17c4d
xorl %r14d, %r14d
testq %rbp, %rbp
je 0x17c73
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17c73
movq 0x98(%rsp), %rsi
incq %rsi
callq 0xd5e0
testb %r14b, %r14b
jne 0x17de7
movq %r15, 0x18(%rsp)
movq (%r12), %rax
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r13, 0x48(%rsp)
movq %r13, %rdx
callq *0x10(%rax)
movq (%r14), %r14
movq (%r12), %rax
leaq 0x68(%rsp), %rdi
movq %r12, %rsi
callq *0x18(%rax)
leaq 0x78(%rsp), %r15
movq -0x10(%r15), %rdx
leaq 0x2e579(%rip), %rdi # 0x46236
movq %r14, %rsi
xorl %eax, %eax
callq 0xd040
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x17cdd
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xd5e0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
movq 0x18(%rsp), %r14
je 0x17cfd
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xd5e0
movq 0x3d26c(%rip), %rax # 0x54f70
movq (%rax), %rdi
callq 0xd700
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %r14, 0x30(%rsp)
movb $0x1, %bpl
xorl %r13d, %r13d
movq 0x28(%rsp,%r13), %r15
movq %rbx, %rdi
callq 0xd1f0
testq %rax, %rax
je 0x17d75
movq %rax, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xd670
testb %al, %al
je 0x17d5a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd5d0
movq %rax, %r14
testq %rax, %rax
jne 0x17d36
jmp 0x17d75
movq %r15, %rdi
callq 0xd8a0
xorl %ebp, %ebp
leaq 0x2e4d6(%rip), %rdi # 0x46241
movq %rax, %rsi
xorl %eax, %eax
callq 0xd040
addq $0x8, %r13
cmpq $0x10, %r13
jne 0x17d21
testb $0x1, %bpl
je 0x17ddd
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1bc8c
movq %rbx, %rdi
movq 0x20(%rsp), %r13
movq %r13, %rsi
callq 0xd470
testq %rax, %rax
je 0x17e99
movq %rax, %rbp
movq 0x8(%r12), %rdi
movq 0x48(%rsp), %rsi
callq 0xd220
movq 0x20(%r12), %r14
movq 0x28(%r12), %r15
cmpq %r15, %r14
je 0x17e06
movq (%r14), %rsi
movq 0x8(%r12), %rdi
callq 0xd340
addq $0x8, %r14
jmp 0x17dc5
movl $0xa, %edi
callq 0xd830
movq %rbx, %rdi
callq 0xd0c0
movb $0x1, %bpl
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rax
movq %r12, %rdi
movq %rbx, %rsi
callq *0x58(%rax)
leaq 0x28(%rsp), %r14
movb $0x1, (%r14)
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
movsd %xmm0, 0x8(%r14)
movq %r13, 0x10(%r14)
movq 0x18(%rsp), %rsi
movq %rsi, 0x18(%r14)
movq 0x8(%r12), %rdx
leaq 0x2bab5(%rip), %rcx # 0x438fa
movq %r13, %rdi
movq %r14, %r8
callq 0xd050
movl %eax, %r14d
testb %al, %al
jne 0x17e65
leaq 0x2e418(%rip), %rdi # 0x46276
xorl %eax, %eax
callq 0xd040
movq %rbp, %rdi
callq 0xda80
movq %rbx, %rdi
callq 0xd0c0
movb 0x28(%rsp), %bpl
andb %r14b, %bpl
leaq 0x2e845(%rip), %rax # 0x466c9
leaq 0x2e82e(%rip), %rdi # 0x466b9
cmovneq %rax, %rdi
callq 0xd8c0
jmp 0x17df2
movq %r13, %rdi
callq 0xd8a0
leaq 0x2e3ad(%rip), %rdi # 0x46255
xorl %ebp, %ebp
movq %rax, %rsi
xorl %eax, %eax
callq 0xd040
movq %rbx, %rdi
callq 0xd0c0
jmp 0x17df2
leaq 0x2dd00(%rip), %rdi # 0x45bc8
leaq 0x2dd4e(%rip), %rdx # 0x45c1d
leaq 0x2e35c(%rip), %rcx # 0x46232
movl $0x1ae, %esi # imm = 0x1AE
xorl %eax, %eax
callq 0xda20
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17f00
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xd5e0
movq %rbx, %rdi
callq 0xdb00
| _ZN9test_case4evalEP12ggml_backendS1_PKc:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov rbp, rcx
mov r15, rdx
mov r14, rsi
mov r12, rdi
mov dword ptr [rdi+18h], 0
call _ggml_tensor_overhead
mov rbx, rax
shl rbx, 7
call _ggml_graph_overhead
add rax, rbx
mov qword ptr [rsp+0D8h+var_88], rax
mov qword ptr [rsp+0D8h+var_88+8], 0
mov byte ptr [rsp+0D8h+var_78], 1
mov rax, [rsp+0D8h+var_78]
mov [rsp+0D8h+var_C8], rax
movups xmm0, [rsp+0D8h+var_88]
movups [rsp+0D8h+var_D8], xmm0
call _ggml_init
test rax, rax
jz loc_17EC1
mov rbx, rax
mov [rsp+0D8h+var_B8], r14
mov rdi, rax
call _ggml_new_graph
mov [r12+8], rax
mov rdi, r12
mov rsi, rbx
call _ZN9test_case12add_sentinelEP12ggml_context; test_case::add_sentinel(ggml_context *)
mov rax, [r12]
mov rdi, r12
mov rsi, rbx
call qword ptr [rax+20h]
mov r13, rax
test rbp, rbp
jz short loc_17C4A
mov rax, [r12]
lea r14, [rsp+0D8h+var_50]
mov rdi, r14
mov rsi, r12
mov rdx, r13
call qword ptr [rax+10h]
mov rdi, r14
mov rsi, rbp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
setnz r14b
jmp short loc_17C4D
loc_17C4A:
xor r14d, r14d
loc_17C4D:
test rbp, rbp
jz short loc_17C73
lea rax, [rsp+0D8h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_17C73
mov rsi, [rsp+0D8h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_17C73:
test r14b, r14b
jnz loc_17DE7
mov [rsp+0D8h+var_C0], r15
mov rax, [r12]
lea r14, [rsp+0D8h+var_B0]
mov rdi, r14
mov rsi, r12
mov [rsp+0D8h+var_90], r13
mov rdx, r13
call qword ptr [rax+10h]
mov r14, [r14]
mov rax, [r12]
lea rdi, [rsp+0D8h+var_70]
mov rsi, r12
call qword ptr [rax+18h]
lea r15, [rsp+0D8h+var_60]
mov rdx, [r15-10h]
lea rdi, aSS; " %s(%s): "
mov rsi, r14
xor eax, eax
call _printf
mov rdi, [r15-10h]; void *
cmp rdi, r15
jz short loc_17CDD
mov rsi, [rsp+0D8h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_17CDD:
lea rax, [rsp+0D8h+var_A0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
mov r14, [rsp+0D8h+var_C0]
jz short loc_17CFD
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_17CFD:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, [rsp+0D8h+var_B8]
mov [rsp+0D8h+var_B0], rax
mov [rsp+0D8h+var_A8], r14
mov bpl, 1
xor r13d, r13d
loc_17D21:
mov r15, [rsp+r13+0D8h+var_B0]
mov rdi, rbx
call _ggml_get_first_tensor
test rax, rax
jz short loc_17D75
mov r14, rax
loc_17D36:
mov rdi, r15
mov rsi, r14
call _ggml_backend_supports_op
test al, al
jz short loc_17D5A
mov rdi, rbx
mov rsi, r14
call _ggml_get_next_tensor
mov r14, rax
test rax, rax
jnz short loc_17D36
jmp short loc_17D75
loc_17D5A:
mov rdi, r15
call _ggml_backend_name
xor ebp, ebp
lea rdi, aNotSupportedS; "not supported [%s] "
mov rsi, rax
xor eax, eax
call _printf
loc_17D75:
add r13, 8
cmp r13, 10h
jnz short loc_17D21
test bpl, 1
jz short loc_17DDD
mov rdi, r12
mov rsi, rbx
call _ZN9test_case12add_sentinelEP12ggml_context; test_case::add_sentinel(ggml_context *)
mov rdi, rbx
mov r13, [rsp+0D8h+var_B8]
mov rsi, r13
call _ggml_backend_alloc_ctx_tensors
test rax, rax
jz loc_17E99
mov rbp, rax
mov rdi, [r12+8]
mov rsi, [rsp+0D8h+var_90]
call _ggml_build_forward_expand
mov r14, [r12+20h]
mov r15, [r12+28h]
loc_17DC5:
cmp r14, r15
jz short loc_17E06
mov rsi, [r14]
mov rdi, [r12+8]
call _ggml_graph_add_node
add r14, 8
jmp short loc_17DC5
loc_17DDD:
mov edi, 0Ah
call _putchar
loc_17DE7:
mov rdi, rbx
call _ggml_free
mov bpl, 1
loc_17DF2:
mov eax, ebp
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_17E06:
mov rax, [r12]
mov rdi, r12
mov rsi, rbx
call qword ptr [rax+58h]
lea r14, [rsp+0D8h+var_B0]
mov byte ptr [r14], 1
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+28h]
movsd qword ptr [r14+8], xmm0
mov [r14+10h], r13
mov rsi, [rsp+0D8h+var_C0]
mov [r14+18h], rsi
mov rdx, [r12+8]
lea rcx, _ZZN9test_case4evalEP12ggml_backendS1_PKcENUliP11ggml_tensorS5_PvE_8__invokeEiS5_S5_S6_; test_case::eval(ggml_backend *,ggml_backend *,char const*)::{lambda(int,ggml_tensor *,ggml_tensor *,void *)#1}::__invoke(int,ggml_tensor *,ggml_tensor *,void *)
mov rdi, r13
mov r8, r14
call _ggml_backend_compare_graph_backend
mov r14d, eax
test al, al
jnz short loc_17E65
lea rdi, aCompareFailed; "compare failed "
xor eax, eax
call _printf
loc_17E65:
mov rdi, rbp
call _ggml_backend_buffer_free
mov rdi, rbx
call _ggml_free
mov bpl, byte ptr [rsp+0D8h+var_B0]
and bpl, r14b
lea rax, a132mok0m; "\x1B[1;32mOK\x1B[0m"
lea rdi, a131mfail0m; "\x1B[1;31mFAIL\x1B[0m"
cmovnz rdi, rax
call _puts
jmp loc_17DF2
loc_17E99:
mov rdi, r13
call _ggml_backend_name
lea rdi, aFailedToAlloca; "failed to allocate tensors [%s] "
xor ebp, ebp
mov rsi, rax
xor eax, eax
call _printf
mov rdi, rbx
call _ggml_free
jmp loc_17DF2
loc_17EC1:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCtx; "ctx"
mov esi, 1AEh
xor eax, eax
call _ggml_abort
mov rbx, rax
lea rax, [rsp+0D8h+var_A0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_17F00
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_17F00:
mov rdi, rbx
call __Unwind_Resume
| long long test_case::eval(_QWORD *a1, _QWORD *a2, long long a3, long long a4)
{
long long v6; // rbx
long long v7; // rdx
long long v8; // rax
long long v9; // rbx
long long v10; // r13
bool v11; // r14
long long v12; // rax
const char *v13; // r14
long long i; // r13
_QWORD *v15; // r15
long long first_tensor; // rax
long long next_tensor; // r14
const char *v18; // rax
long long v19; // rax
_QWORD *v20; // r14
_QWORD *v21; // r15
unsigned __int8 v23; // r14
const char *v24; // rdi
const char *v25; // rax
long long v26; // rbx
long long v27; // [rsp+18h] [rbp-C0h]
_QWORD *v28; // [rsp+28h] [rbp-B0h] BYREF
double v29; // [rsp+30h] [rbp-A8h]
_QWORD v30[2]; // [rsp+38h] [rbp-A0h] BYREF
long long v31; // [rsp+48h] [rbp-90h]
__int128 v32; // [rsp+50h] [rbp-88h]
long long v33; // [rsp+60h] [rbp-78h]
char *v34; // [rsp+68h] [rbp-70h] BYREF
long long v35; // [rsp+78h] [rbp-60h] BYREF
void *v36[2]; // [rsp+88h] [rbp-50h] BYREF
long long v37; // [rsp+98h] [rbp-40h] BYREF
*((_DWORD *)a1 + 6) = 0;
v6 = ggml_tensor_overhead() << 7;
v32 = (unsigned long long)(v6 + ggml_graph_overhead());
LOBYTE(v33) = 1;
v8 = ggml_init(a1, a2, v7);
if ( !v8 )
{
v26 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/tests/test-backend-ops.cpp",
430LL,
"GGML_ASSERT(%s) failed",
"ctx");
if ( v28 != v30 )
operator delete(v28, v30[0] + 1LL);
_Unwind_Resume(v26);
}
v9 = v8;
a1[1] = ggml_new_graph(v8);
test_case::add_sentinel(a1, v9);
v10 = (*(long long ( **)(_QWORD *, long long))(*a1 + 32LL))(a1, v9);
if ( a4 )
{
(*(void ( **)(void **, _QWORD *, long long))(*a1 + 16LL))(v36, a1, v10);
v11 = (unsigned int)std::string::compare(v36, a4) != 0;
}
else
{
v11 = 0;
}
if ( a4 && v36[0] != &v37 )
operator delete(v36[0], v37 + 1);
if ( v11 )
goto LABEL_27;
v27 = a3;
v12 = *a1;
v31 = v10;
(*(void ( **)(_QWORD **, _QWORD *, long long))(v12 + 16))(&v28, a1, v10);
v13 = (const char *)v28;
(*(void ( **)(char **, _QWORD *))(*a1 + 24LL))(&v34, a1);
printf(" %s(%s): ", v13, v34);
if ( v34 != (char *)&v35 )
operator delete(v34, v35 + 1);
if ( v28 != v30 )
operator delete(v28, v30[0] + 1LL);
fflush(stdout);
v28 = a2;
v29 = *(double *)&a3;
LOBYTE(a4) = 1;
for ( i = 0LL; i != 2; ++i )
{
v15 = (&v28)[i];
first_tensor = ggml_get_first_tensor(v9);
if ( first_tensor )
{
next_tensor = first_tensor;
while ( (unsigned __int8)ggml_backend_supports_op(v15, next_tensor) )
{
next_tensor = ggml_get_next_tensor(v9, next_tensor);
if ( !next_tensor )
goto LABEL_20;
}
v18 = (const char *)ggml_backend_name(v15);
LODWORD(a4) = 0;
printf("not supported [%s] ", v18);
}
LABEL_20:
;
}
if ( (a4 & 1) == 0 )
{
putchar(10LL);
LABEL_27:
ggml_free(v9);
LOBYTE(a4) = 1;
return (unsigned int)a4;
}
test_case::add_sentinel(a1, v9);
v19 = ggml_backend_alloc_ctx_tensors(v9, a2);
if ( v19 )
{
a4 = v19;
ggml_build_forward_expand(a1[1], v31);
v20 = (_QWORD *)a1[4];
v21 = (_QWORD *)a1[5];
while ( v20 != v21 )
ggml_graph_add_node(a1[1], *v20++);
(*(void ( **)(_QWORD *, long long))(*a1 + 88LL))(a1, v9);
LOBYTE(v28) = 1;
v29 = (*(double ( **)(_QWORD *))(*a1 + 40LL))(a1);
v30[0] = a2;
v30[1] = v27;
v23 = ggml_backend_compare_graph_backend(
a2,
v27,
a1[1],
test_case::eval(ggml_backend *,ggml_backend *,char const*)::{lambda(int,ggml_tensor *,ggml_tensor *,void *)#1}::__invoke,
&v28);
if ( !v23 )
printf("compare failed ");
ggml_backend_buffer_free(a4);
ggml_free(v9);
LOBYTE(a4) = v23 & (unsigned __int8)v28;
v24 = "\x1B[1;31mFAIL\x1B[0m";
if ( (v23 & (unsigned __int8)v28) != 0 )
v24 = "\x1B[1;32mOK\x1B[0m";
puts(v24);
}
else
{
v25 = (const char *)ggml_backend_name(a2);
LODWORD(a4) = 0;
printf("failed to allocate tensors [%s] ", v25);
ggml_free(v9);
}
return (unsigned int)a4;
}
| eval:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV RBP,RCX
MOV R15,RDX
MOV R14,RSI
MOV R12,RDI
MOV dword ptr [RDI + 0x18],0x0
CALL 0x0010da60
MOV RBX,RAX
SHL RBX,0x7
CALL 0x0010d260
ADD RAX,RBX
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],0x0
MOV byte ptr [RSP + 0x60],0x1
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x50]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x0010d500
TEST RAX,RAX
JZ 0x00117ec1
MOV RBX,RAX
MOV qword ptr [RSP + 0x20],R14
MOV RDI,RAX
CALL 0x0010d990
MOV qword ptr [R12 + 0x8],RAX
MOV RDI,R12
MOV RSI,RBX
CALL 0x0011bc8c
MOV RAX,qword ptr [R12]
MOV RDI,R12
MOV RSI,RBX
CALL qword ptr [RAX + 0x20]
MOV R13,RAX
TEST RBP,RBP
JZ 0x00117c4a
MOV RAX,qword ptr [R12]
LEA R14,[RSP + 0x88]
MOV RDI,R14
MOV RSI,R12
MOV RDX,R13
CALL qword ptr [RAX + 0x10]
MOV RDI,R14
MOV RSI,RBP
CALL 0x0010d160
TEST EAX,EAX
SETNZ R14B
JMP 0x00117c4d
LAB_00117c4a:
XOR R14D,R14D
LAB_00117c4d:
TEST RBP,RBP
JZ 0x00117c73
LEA RAX,[RSP + 0x98]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00117c73
MOV RSI,qword ptr [RSP + 0x98]
INC RSI
CALL 0x0010d5e0
LAB_00117c73:
TEST R14B,R14B
JNZ 0x00117de7
MOV qword ptr [RSP + 0x18],R15
MOV RAX,qword ptr [R12]
LEA R14,[RSP + 0x28]
MOV RDI,R14
MOV RSI,R12
MOV qword ptr [RSP + 0x48],R13
MOV RDX,R13
CALL qword ptr [RAX + 0x10]
MOV R14,qword ptr [R14]
MOV RAX,qword ptr [R12]
LAB_00117ca2:
LEA RDI,[RSP + 0x68]
MOV RSI,R12
CALL qword ptr [RAX + 0x18]
LAB_00117cad:
LEA R15,[RSP + 0x78]
MOV RDX,qword ptr [R15 + -0x10]
LEA RDI,[0x146236]
MOV RSI,R14
XOR EAX,EAX
CALL 0x0010d040
MOV RDI,qword ptr [R15 + -0x10]
CMP RDI,R15
JZ 0x00117cdd
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x0010d5e0
LAB_00117cdd:
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
MOV R14,qword ptr [RSP + 0x18]
JZ 0x00117cfd
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0010d5e0
LAB_00117cfd:
MOV RAX,qword ptr [0x00154f70]
MOV RDI,qword ptr [RAX]
CALL 0x0010d700
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],R14
MOV BPL,0x1
XOR R13D,R13D
LAB_00117d21:
MOV R15,qword ptr [RSP + R13*0x1 + 0x28]
MOV RDI,RBX
CALL 0x0010d1f0
TEST RAX,RAX
JZ 0x00117d75
MOV R14,RAX
LAB_00117d36:
MOV RDI,R15
MOV RSI,R14
CALL 0x0010d670
TEST AL,AL
JZ 0x00117d5a
MOV RDI,RBX
MOV RSI,R14
CALL 0x0010d5d0
MOV R14,RAX
TEST RAX,RAX
JNZ 0x00117d36
JMP 0x00117d75
LAB_00117d5a:
MOV RDI,R15
CALL 0x0010d8a0
XOR EBP,EBP
LEA RDI,[0x146241]
MOV RSI,RAX
XOR EAX,EAX
CALL 0x0010d040
LAB_00117d75:
ADD R13,0x8
CMP R13,0x10
JNZ 0x00117d21
TEST BPL,0x1
JZ 0x00117ddd
MOV RDI,R12
MOV RSI,RBX
CALL 0x0011bc8c
MOV RDI,RBX
MOV R13,qword ptr [RSP + 0x20]
MOV RSI,R13
CALL 0x0010d470
TEST RAX,RAX
JZ 0x00117e99
MOV RBP,RAX
MOV RDI,qword ptr [R12 + 0x8]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x0010d220
MOV R14,qword ptr [R12 + 0x20]
MOV R15,qword ptr [R12 + 0x28]
LAB_00117dc5:
CMP R14,R15
JZ 0x00117e06
MOV RSI,qword ptr [R14]
MOV RDI,qword ptr [R12 + 0x8]
CALL 0x0010d340
ADD R14,0x8
JMP 0x00117dc5
LAB_00117ddd:
MOV EDI,0xa
CALL 0x0010d830
LAB_00117de7:
MOV RDI,RBX
CALL 0x0010d0c0
MOV BPL,0x1
LAB_00117df2:
MOV EAX,EBP
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00117e06:
MOV RAX,qword ptr [R12]
MOV RDI,R12
MOV RSI,RBX
CALL qword ptr [RAX + 0x58]
LEA R14,[RSP + 0x28]
MOV byte ptr [R14],0x1
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x28]
MOVSD qword ptr [R14 + 0x8],XMM0
MOV qword ptr [R14 + 0x10],R13
MOV RSI,qword ptr [RSP + 0x18]
MOV qword ptr [R14 + 0x18],RSI
MOV RDX,qword ptr [R12 + 0x8]
LEA RCX,[0x1438fa]
MOV RDI,R13
MOV R8,R14
CALL 0x0010d050
MOV R14D,EAX
TEST AL,AL
JNZ 0x00117e65
LEA RDI,[0x146276]
XOR EAX,EAX
CALL 0x0010d040
LAB_00117e65:
MOV RDI,RBP
CALL 0x0010da80
MOV RDI,RBX
CALL 0x0010d0c0
MOV BPL,byte ptr [RSP + 0x28]
AND BPL,R14B
LEA RAX,[0x1466c9]
LEA RDI,[0x1466b9]
CMOVNZ RDI,RAX
CALL 0x0010d8c0
JMP 0x00117df2
LAB_00117e99:
MOV RDI,R13
CALL 0x0010d8a0
LEA RDI,[0x146255]
XOR EBP,EBP
MOV RSI,RAX
XOR EAX,EAX
CALL 0x0010d040
MOV RDI,RBX
CALL 0x0010d0c0
JMP 0x00117df2
LAB_00117ec1:
LEA RDI,[0x145bc8]
LEA RDX,[0x145c1d]
LEA RCX,[0x146232]
MOV ESI,0x1ae
XOR EAX,EAX
CALL 0x0010da20
|
/* test_case::eval(ggml_backend*, ggml_backend*, char const*) */
ulong __thiscall
test_case::eval(test_case *this,ggml_backend *param_1,ggml_backend *param_2,char *param_3)
{
int8 *puVar1;
ggml_backend *pgVar2;
char cVar3;
byte bVar4;
int iVar5;
long lVar6;
ggml_context *pgVar7;
int8 uVar8;
long lVar9;
ulong uVar10;
char *__s;
int8 *puVar11;
bool bVar12;
ggml_backend *local_b0 [2];
ggml_backend *local_a0;
ggml_backend *local_98;
int8 local_90;
long local_88;
int8 uStack_80;
int1 local_78;
long *local_70 [2];
long local_60 [2];
long *local_50 [2];
long local_40 [2];
*(int4 *)(this + 0x18) = 0;
lVar6 = ggml_tensor_overhead();
local_88 = ggml_graph_overhead();
local_88 = local_88 + lVar6 * 0x80;
uStack_80 = 0;
local_78 = 1;
pgVar7 = (ggml_context *)ggml_init();
if (pgVar7 == (ggml_context *)0x0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/tests/test-backend-ops.cpp"
,0x1ae,"GGML_ASSERT(%s) failed",&DAT_00146232);
}
uVar8 = ggml_new_graph(pgVar7);
*(int8 *)(this + 8) = uVar8;
add_sentinel(this,pgVar7);
uVar8 = (**(code **)(*(long *)this + 0x20))(this,pgVar7);
if (param_3 == (char *)0x0) {
bVar12 = false;
}
else {
(**(code **)(*(long *)this + 0x10))(local_50,this,uVar8);
iVar5 = std::__cxx11::string::compare((char *)local_50);
bVar12 = iVar5 != 0;
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
}
if (!bVar12) {
local_90 = uVar8;
(**(code **)(*(long *)this + 0x10))(local_b0,this,uVar8);
pgVar2 = local_b0[0];
/* try { // try from 00117ca2 to 00117cac has its CatchHandler @ 00117ee2 */
(**(code **)(*(long *)this + 0x18))(local_70,this);
printf(" %s(%s): ",pgVar2,local_70[0]);
if (local_70[0] != local_60) {
operator_delete(local_70[0],local_60[0] + 1);
}
if (local_b0[0] != (ggml_backend *)&local_a0) {
operator_delete(local_b0[0],(long)local_a0 + 1);
}
fflush(*(FILE **)PTR_stdout_00154f70);
local_b0[0] = param_1;
local_b0[1] = param_2;
param_3 = (char *)CONCAT71((int7)((ulong)param_3 >> 8),1);
lVar6 = 0;
do {
uVar8 = *(int8 *)((long)local_b0 + lVar6);
for (lVar9 = ggml_get_first_tensor(pgVar7); lVar9 != 0;
lVar9 = ggml_get_next_tensor(pgVar7,lVar9)) {
cVar3 = ggml_backend_supports_op(uVar8,lVar9);
if (cVar3 == '\0') {
uVar8 = ggml_backend_name(uVar8);
param_3 = (char *)0x0;
printf("not supported [%s] ",uVar8);
break;
}
}
lVar6 = lVar6 + 8;
} while (lVar6 != 0x10);
if ((char)param_3 != '\0') {
add_sentinel(this,pgVar7);
lVar6 = ggml_backend_alloc_ctx_tensors(pgVar7,param_1);
if (lVar6 == 0) {
uVar8 = ggml_backend_name(param_1);
uVar10 = 0;
printf("failed to allocate tensors [%s] ",uVar8);
ggml_free(pgVar7);
}
else {
ggml_build_forward_expand(*(int8 *)(this + 8),local_90);
puVar1 = *(int8 **)(this + 0x28);
for (puVar11 = *(int8 **)(this + 0x20); puVar11 != puVar1; puVar11 = puVar11 + 1) {
ggml_graph_add_node(*(int8 *)(this + 8),*puVar11);
}
(**(code **)(*(long *)this + 0x58))(this,pgVar7);
local_b0[0] = (ggml_backend *)CONCAT71(local_b0[0]._1_7_,1);
local_b0[1] = (ggml_backend *)(**(code **)(*(long *)this + 0x28))(this);
local_a0 = param_1;
local_98 = param_2;
bVar4 = ggml_backend_compare_graph_backend
(param_1,param_2,*(int8 *)(this + 8),
eval(ggml_backend*,ggml_backend*,char_const*)::
{lambda(int,ggml_tensor*,ggml_tensor*,void*)#1}::__invoke,local_b0);
if (bVar4 == 0) {
printf("compare failed ");
}
ggml_backend_buffer_free(lVar6);
ggml_free(pgVar7);
uVar10 = CONCAT71((int7)((ulong)lVar6 >> 8),(byte)local_b0[0] & bVar4);
__s = "\x1b[1;31mFAIL\x1b[0m";
if (((byte)local_b0[0] & bVar4) != 0) {
__s = "\x1b[1;32mOK\x1b[0m";
}
puts(__s);
}
goto LAB_00117df2;
}
putchar(10);
}
ggml_free(pgVar7);
uVar10 = CONCAT71((int7)((ulong)param_3 >> 8),1);
LAB_00117df2:
return uVar10 & 0xffffffff;
}
| |
26,006 | deadlock | eloqsql/mysys/waiting_threads.c | static int deadlock(WT_THD *thd, WT_THD *blocker, uint depth,
uint max_depth)
{
struct deadlock_arg arg= {thd, max_depth, 0, 0};
int ret;
DBUG_ENTER("deadlock");
DBUG_ASSERT(depth < 2);
ret= deadlock_search(&arg, blocker, depth);
if (ret == WT_DEPTH_EXCEEDED)
{
increment_cycle_stats(WT_CYCLE_STATS, max_depth ==
*thd->deadlock_search_depth_long);
ret= WT_OK;
}
/*
if we started with depth==1, blocker was never considered for a victim
in deadlock_search(). Do it here.
*/
if (ret == WT_DEADLOCK && depth)
change_victim(blocker, &arg);
if (arg.last_locked_rc)
{
/*
Special return code if there's nobody to wait for.
depth == 0 means that we start the search from thd (thd == blocker).
ret == WT_OK means that no cycle was found and
arg.last_locked_rc == thd->waiting_for.
and arg.last_locked_rc->owners.elements == 0 means that
(applying the rule above) thd->waiting_for->owners.elements == 0,
and thd doesn't have anybody to wait for.
*/
if (depth == 0 && ret == WT_OK && arg.last_locked_rc->owners.elements == 0)
{
DBUG_ASSERT(thd == blocker);
DBUG_ASSERT(arg.last_locked_rc == thd->waiting_for);
ret= WT_FREE_TO_GO;
}
rc_unlock(arg.last_locked_rc);
}
/* notify the victim, if appropriate */
if (ret == WT_DEADLOCK && arg.victim != thd)
{
DBUG_PRINT("wt", ("killing %s", arg.victim->name));
arg.victim->killed= 1;
mysql_cond_broadcast(&arg.victim->waiting_for->cond);
rc_unlock(arg.victim->waiting_for);
ret= WT_OK;
}
DBUG_RETURN(ret);
} | O0 | c | deadlock:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
jmp 0x101586
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rdi
callq 0x101d60
movl %eax, -0x3c(%rbp)
cmpl $-0x2, -0x3c(%rbp)
jne 0x1015c6
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %esi
movl $0x20, %edi
callq 0x102000
movl $0x0, -0x3c(%rbp)
cmpl $-0x1, -0x3c(%rbp)
jne 0x1015df
cmpl $0x0, -0x14(%rbp)
je 0x1015df
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x102040
cmpq $0x0, -0x20(%rbp)
je 0x101617
cmpl $0x0, -0x14(%rbp)
jne 0x10160e
cmpl $0x0, -0x3c(%rbp)
jne 0x10160e
movq -0x20(%rbp), %rax
cmpl $0x0, 0xe8(%rax)
jne 0x10160e
jmp 0x101601
jmp 0x101603
jmp 0x101605
jmp 0x101607
movl $0xfffffffd, -0x3c(%rbp) # imm = 0xFFFFFFFD
movq -0x20(%rbp), %rdi
callq 0x1014a0
cmpl $-0x1, -0x3c(%rbp)
jne 0x10165b
movq -0x28(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x10165b
jmp 0x101629
jmp 0x10162b
movq -0x28(%rbp), %rax
movb $0x1, 0x60(%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdi
addq $0xa8, %rdi
callq 0x101b40
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1014a0
movl $0x0, -0x3c(%rbp)
jmp 0x10165d
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| deadlock:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
mov eax, [rbp+var_18]
mov [rbp+var_30], eax
mov [rbp+var_28], 0
mov [rbp+var_20], 0
jmp short $+2
loc_101586:
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
lea rdi, [rbp+var_38]
call deadlock_search
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0FFFFFFFEh
jnz short loc_1015C6
mov eax, [rbp+var_18]
mov rcx, [rbp+var_8]
mov rcx, [rcx+50h]
cmp rax, [rcx]
setz al
and al, 1
movzx esi, al
mov edi, 20h ; ' '
call increment_cycle_stats
mov [rbp+var_3C], 0
loc_1015C6:
cmp [rbp+var_3C], 0FFFFFFFFh
jnz short loc_1015DF
cmp [rbp+var_14], 0
jz short loc_1015DF
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_38]
call change_victim
loc_1015DF:
cmp [rbp+var_20], 0
jz short loc_101617
cmp [rbp+var_14], 0
jnz short loc_10160E
cmp [rbp+var_3C], 0
jnz short loc_10160E
mov rax, [rbp+var_20]
cmp dword ptr [rax+0E8h], 0
jnz short loc_10160E
jmp short $+2
loc_101601:
jmp short $+2
loc_101603:
jmp short $+2
loc_101605:
jmp short $+2
loc_101607:
mov [rbp+var_3C], 0FFFFFFFDh
loc_10160E:
mov rdi, [rbp+var_20]
call rc_unlock
loc_101617:
cmp [rbp+var_3C], 0FFFFFFFFh
jnz short loc_10165B
mov rax, [rbp+var_28]
cmp rax, [rbp+var_8]
jz short loc_10165B
jmp short $+2
loc_101629:
jmp short $+2
loc_10162B:
mov rax, [rbp+var_28]
mov byte ptr [rax+60h], 1
mov rax, [rbp+var_28]
mov rdi, [rax+28h]
add rdi, 0A8h
call inline_mysql_cond_broadcast_3
mov rax, [rbp+var_28]
mov rdi, [rax+28h]
call rc_unlock
mov [rbp+var_3C], 0
loc_10165B:
jmp short $+2
loc_10165D:
mov eax, [rbp+var_3C]
mov [rbp+var_40], eax
mov eax, [rbp+var_40]
add rsp, 40h
pop rbp
retn
| long long deadlock(long long a1, long long a2, unsigned int a3, int a4)
{
unsigned int v5; // [rsp+4h] [rbp-3Ch]
long long v6; // [rsp+8h] [rbp-38h] BYREF
int v7; // [rsp+10h] [rbp-30h]
long long v8; // [rsp+18h] [rbp-28h]
long long v9; // [rsp+20h] [rbp-20h]
int v10; // [rsp+28h] [rbp-18h]
unsigned int v11; // [rsp+2Ch] [rbp-14h]
long long v12; // [rsp+30h] [rbp-10h]
long long v13; // [rsp+38h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v6 = a1;
v7 = a4;
v8 = 0LL;
v9 = 0LL;
v5 = deadlock_search(&v6, a2, a3);
if ( v5 == -2 )
{
increment_cycle_stats(32LL, v10 == **(_QWORD **)(v13 + 80));
v5 = 0;
}
if ( v5 == -1 && v11 )
change_victim(v12, &v6);
if ( v9 )
{
if ( !v11 && !v5 && !*(_DWORD *)(v9 + 232) )
v5 = -3;
rc_unlock(v9);
}
if ( v5 == -1 && v8 != v13 )
{
*(_BYTE *)(v8 + 96) = 1;
inline_mysql_cond_broadcast_3(*(_QWORD *)(v8 + 40) + 168LL);
rc_unlock(*(_QWORD *)(v8 + 40));
return 0;
}
return v5;
}
| |||
26,007 | deadlock | eloqsql/mysys/waiting_threads.c | static int deadlock(WT_THD *thd, WT_THD *blocker, uint depth,
uint max_depth)
{
struct deadlock_arg arg= {thd, max_depth, 0, 0};
int ret;
DBUG_ENTER("deadlock");
DBUG_ASSERT(depth < 2);
ret= deadlock_search(&arg, blocker, depth);
if (ret == WT_DEPTH_EXCEEDED)
{
increment_cycle_stats(WT_CYCLE_STATS, max_depth ==
*thd->deadlock_search_depth_long);
ret= WT_OK;
}
/*
if we started with depth==1, blocker was never considered for a victim
in deadlock_search(). Do it here.
*/
if (ret == WT_DEADLOCK && depth)
change_victim(blocker, &arg);
if (arg.last_locked_rc)
{
/*
Special return code if there's nobody to wait for.
depth == 0 means that we start the search from thd (thd == blocker).
ret == WT_OK means that no cycle was found and
arg.last_locked_rc == thd->waiting_for.
and arg.last_locked_rc->owners.elements == 0 means that
(applying the rule above) thd->waiting_for->owners.elements == 0,
and thd doesn't have anybody to wait for.
*/
if (depth == 0 && ret == WT_OK && arg.last_locked_rc->owners.elements == 0)
{
DBUG_ASSERT(thd == blocker);
DBUG_ASSERT(arg.last_locked_rc == thd->waiting_for);
ret= WT_FREE_TO_GO;
}
rc_unlock(arg.last_locked_rc);
}
/* notify the victim, if appropriate */
if (ret == WT_DEADLOCK && arg.victim != thd)
{
DBUG_PRINT("wt", ("killing %s", arg.victim->name));
arg.victim->killed= 1;
mysql_cond_broadcast(&arg.victim->waiting_for->cond);
rc_unlock(arg.victim->waiting_for);
ret= WT_OK;
}
DBUG_RETURN(ret);
} | O3 | c | deadlock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r13d
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x48(%rbp), %rdi
movq %rbx, (%rdi)
movl %ecx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
callq 0xa8283
cmpl $-0x2, %eax
jne 0xa7d90
movl %r13d, %eax
movq 0x50(%rbx), %rcx
xorl %edx, %edx
cmpq %rax, (%rcx)
sete %dl
movl %edx, %eax
shll $0x7, %eax
leal (%rax,%rdx,4), %eax
leaq 0xb6313c(%rip), %rcx # 0xc0aec0
incl 0x80(%rcx,%rax)
xorl %r12d, %r12d
jmp 0xa7dcc
movl %eax, %r12d
cmpl $-0x1, %eax
setne %al
testl %r15d, %r15d
sete %cl
orb %al, %cl
jne 0xa7dcc
movq 0x58(%r14), %rcx
movq -0x38(%rbp), %rax
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
cmpq 0x58(%rax), %rcx
jae 0xa7dcc
cmpq -0x48(%rbp), %rax
je 0xa7e01
movq 0x28(%rax), %rdi
addq $0x18, %rdi
callq 0xa5412
jmp 0xa7e01
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xa7df7
orl %r12d, %r15d
jne 0xa7dee
xorl %eax, %eax
cmpl $0x0, 0xe8(%rdi)
setne %al
leal (%rax,%rax,2), %r12d
addl $-0x3, %r12d
addq $0x18, %rdi
callq 0xa5412
cmpl $-0x1, %r12d
jne 0xa7e42
movq -0x38(%rbp), %r14
cmpq %rbx, %r14
je 0xa7e3c
movb $0x1, 0x60(%r14)
movq 0x28(%r14), %rbx
movq 0xd8(%rbx), %rdi
addq $0xa8, %rbx
testq %rdi, %rdi
jne 0xa7e54
movq %rbx, %rdi
callq 0x296f0
movq 0x28(%r14), %rdi
addq $0x18, %rdi
callq 0xa5412
xorl %r12d, %r12d
jmp 0xa7e42
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e0265(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x178(%rax)
jmp 0xa7e22
| deadlock:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r13d, ecx
mov r15d, edx
mov r14, rsi
mov rbx, rdi
lea rdi, [rbp+var_48]
mov [rdi], rbx
mov [rdi+8], ecx
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
call deadlock_search
cmp eax, 0FFFFFFFEh
jnz short loc_A7D90
mov eax, r13d
mov rcx, [rbx+50h]
xor edx, edx
cmp [rcx], rax
setz dl
mov eax, edx
shl eax, 7
lea eax, [rax+rdx*4]
lea rcx, wt_cycle_stats
inc dword ptr [rcx+rax+80h]
xor r12d, r12d
jmp short loc_A7DCC
loc_A7D90:
mov r12d, eax
cmp eax, 0FFFFFFFFh
setnz al
test r15d, r15d
setz cl
or cl, al
jnz short loc_A7DCC
mov rcx, [r14+58h]
mov rax, [rbp+var_38]
mov r12d, 0FFFFFFFFh
cmp rcx, [rax+58h]
jnb short loc_A7DCC
cmp rax, [rbp+var_48]
jz short loc_A7E01
mov rdi, [rax+28h]
add rdi, 18h
call my_rw_unlock
jmp short loc_A7E01
loc_A7DCC:
mov rdi, [rbp+var_30]
test rdi, rdi
jz short loc_A7DF7
or r15d, r12d
jnz short loc_A7DEE
xor eax, eax
cmp dword ptr [rdi+0E8h], 0
setnz al
lea r12d, [rax+rax*2]
add r12d, 0FFFFFFFDh
loc_A7DEE:
add rdi, 18h
call my_rw_unlock
loc_A7DF7:
cmp r12d, 0FFFFFFFFh
jnz short loc_A7E42
mov r14, [rbp+var_38]
loc_A7E01:
cmp r14, rbx
jz short loc_A7E3C
mov byte ptr [r14+60h], 1
mov rbx, [r14+28h]
mov rdi, [rbx+0D8h]
add rbx, 0A8h
test rdi, rdi
jnz short loc_A7E54
loc_A7E22:
mov rdi, rbx
call _pthread_cond_broadcast
mov rdi, [r14+28h]
add rdi, 18h
call my_rw_unlock
xor r12d, r12d
jmp short loc_A7E42
loc_A7E3C:
mov r12d, 0FFFFFFFFh
loc_A7E42:
mov eax, r12d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A7E54:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+178h]
jmp short loc_A7E22
| long long deadlock(long long a1, long long a2, int a3, int a4)
{
long long v6; // r14
unsigned int v7; // eax
long long v8; // rax
unsigned int v9; // r12d
long long v10; // rbx
long long v11; // rdi
long long v12; // rbx
v6 = a2;
v7 = deadlock_search();
if ( v7 == -2 )
{
v8 = 132 * (unsigned int)(**(_QWORD **)(a1 + 80) == a4);
++*(_DWORD *)((char *)&wt_cycle_stats + v8 + 128);
v9 = 0;
}
else
{
v9 = v7;
if ( v7 == -1 && a3 != 0 )
{
v9 = -1;
if ( *(_QWORD *)(a2 + 88) < 0x40uLL )
{
if ( a1 )
my_rw_unlock(4380696LL);
goto LABEL_9;
}
}
}
if ( v9 != -1 )
return v9;
v6 = 0LL;
LABEL_9:
if ( v6 == a1 )
{
return (unsigned int)-1;
}
else
{
*(_BYTE *)(v6 + 96) = 1;
v10 = *(_QWORD *)(v6 + 40);
v11 = *(_QWORD *)(v10 + 216);
v12 = v10 + 168;
if ( v11 )
PSI_server[47]();
pthread_cond_broadcast(v12);
my_rw_unlock(*(_QWORD *)(v6 + 40) + 24LL);
return 0;
}
}
| deadlock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R13D,ECX
MOV R15D,EDX
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RBP + -0x48]
MOV qword ptr [RDI],RBX
MOV dword ptr [RDI + 0x8],ECX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
CALL 0x001a8283
CMP EAX,-0x2
JNZ 0x001a7d90
MOV EAX,R13D
MOV RCX,qword ptr [RBX + 0x50]
XOR EDX,EDX
CMP qword ptr [RCX],RAX
SETZ DL
MOV EAX,EDX
SHL EAX,0x7
LEA EAX,[RAX + RDX*0x4]
LEA RCX,[0xd0aec0]
INC dword ptr [RCX + RAX*0x1 + 0x80]
XOR R12D,R12D
JMP 0x001a7dcc
LAB_001a7d90:
MOV R12D,EAX
CMP EAX,-0x1
SETNZ AL
TEST R15D,R15D
SETZ CL
OR CL,AL
JNZ 0x001a7dcc
MOV RCX,qword ptr [R14 + 0x58]
MOV RAX,qword ptr [RBP + -0x38]
MOV R12D,0xffffffff
CMP RCX,qword ptr [RAX + 0x58]
JNC 0x001a7dcc
CMP RAX,qword ptr [RBP + -0x48]
JZ 0x001a7e01
MOV RDI,qword ptr [RAX + 0x28]
ADD RDI,0x18
CALL 0x001a5412
JMP 0x001a7e01
LAB_001a7dcc:
MOV RDI,qword ptr [RBP + -0x30]
TEST RDI,RDI
JZ 0x001a7df7
OR R15D,R12D
JNZ 0x001a7dee
XOR EAX,EAX
CMP dword ptr [RDI + 0xe8],0x0
SETNZ AL
LEA R12D,[RAX + RAX*0x2]
ADD R12D,-0x3
LAB_001a7dee:
ADD RDI,0x18
CALL 0x001a5412
LAB_001a7df7:
CMP R12D,-0x1
JNZ 0x001a7e42
MOV R14,qword ptr [RBP + -0x38]
LAB_001a7e01:
CMP R14,RBX
JZ 0x001a7e3c
MOV byte ptr [R14 + 0x60],0x1
MOV RBX,qword ptr [R14 + 0x28]
MOV RDI,qword ptr [RBX + 0xd8]
ADD RBX,0xa8
TEST RDI,RDI
JNZ 0x001a7e54
LAB_001a7e22:
MOV RDI,RBX
CALL 0x001296f0
MOV RDI,qword ptr [R14 + 0x28]
ADD RDI,0x18
CALL 0x001a5412
XOR R12D,R12D
JMP 0x001a7e42
LAB_001a7e3c:
MOV R12D,0xffffffff
LAB_001a7e42:
MOV EAX,R12D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a7e54:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x178]
JMP 0x001a7e22
|
/* WARNING: Removing unreachable block (ram,0x001a7dd5) */
/* WARNING: Removing unreachable block (ram,0x001a7dda) */
/* WARNING: Removing unreachable block (ram,0x001a7dee) */
int deadlock(long param_1,long param_2,int param_3,uint param_4)
{
long lVar1;
int iVar2;
bool bVar3;
iVar2 = deadlock_search();
if (iVar2 == -2) {
bVar3 = **(ulong **)(param_1 + 0x50) == (ulong)param_4;
*(int *)(wt_cycle_stats + (ulong)((uint)bVar3 * 0x80 + (uint)bVar3 * 4) + 0x80) =
*(int *)(wt_cycle_stats + (ulong)((uint)bVar3 * 0x80 + (uint)bVar3 * 4) + 0x80) + 1;
iVar2 = 0;
}
else if ((param_3 != 0 && iVar2 == -1) &&
(iVar2 = -1, *(ulong *)(param_2 + 0x58) < uRam0000000000000058)) {
if (param_1 != 0) {
my_rw_unlock(lRam0000000000000028 + 0x18);
}
goto LAB_001a7e01;
}
if (iVar2 != -1) {
return iVar2;
}
param_2 = 0;
LAB_001a7e01:
if (param_2 == param_1) {
iVar2 = -1;
}
else {
*(int1 *)(param_2 + 0x60) = 1;
lVar1 = *(long *)(param_2 + 0x28);
if (*(long *)(lVar1 + 0xd8) != 0) {
(**(code **)(PSI_server + 0x178))();
}
pthread_cond_broadcast((pthread_cond_t *)(lVar1 + 0xa8));
my_rw_unlock(*(long *)(param_2 + 0x28) + 0x18);
iVar2 = 0;
}
return iVar2;
}
| |
26,008 | mp_sub_ui | bluesky950520[P]quickjs/libbf.c | limb_t mp_sub_ui(limb_t *tab, limb_t b, mp_size_t n)
{
mp_size_t i;
limb_t k, a, v;
k=b;
for(i=0;i<n;i++) {
v = tab[i];
a = v - k;
k = a > v;
tab[i] = a;
if (k == 0)
break;
}
return k;
} | O2 | c | mp_sub_ui:
movq %rsi, %rax
xorl %ecx, %ecx
testq %rdx, %rdx
cmovleq %rcx, %rdx
pushq $0x1
popq %rsi
cmpq %rcx, %rdx
je 0x73ad9
subq %rax, (%rdi,%rcx,8)
leaq 0x1(%rcx), %rcx
movq %rsi, %rax
jb 0x73ac5
xorl %eax, %eax
retq
| mp_sub_ui:
mov rax, rsi
xor ecx, ecx
test rdx, rdx
cmovle rdx, rcx
push 1
pop rsi
loc_73AC5:
cmp rdx, rcx
jz short locret_73AD9
sub [rdi+rcx*8], rax
lea rcx, [rcx+1]
mov rax, rsi
jb short loc_73AC5
xor eax, eax
locret_73AD9:
retn
| unsigned long long mp_sub_ui(long long a1, unsigned long long a2, long long a3)
{
unsigned long long result; // rax
long long v4; // rcx
bool v5; // cf
result = a2;
v4 = 0LL;
if ( a3 <= 0 )
a3 = 0LL;
while ( a3 != v4 )
{
v5 = *(_QWORD *)(a1 + 8 * v4) < result;
*(_QWORD *)(a1 + 8 * v4++) -= result;
result = 1LL;
if ( !v5 )
return 0LL;
}
return result;
}
| mp_sub_ui:
MOV RAX,RSI
XOR ECX,ECX
TEST RDX,RDX
CMOVLE RDX,RCX
PUSH 0x1
POP RSI
LAB_00173ac5:
CMP RDX,RCX
JZ 0x00173ad9
SUB qword ptr [RDI + RCX*0x8],RAX
LEA RCX,[RCX + 0x1]
MOV RAX,RSI
JC 0x00173ac5
XOR EAX,EAX
LAB_00173ad9:
RET
|
ulong mp_sub_ui(long param_1,ulong param_2,long param_3)
{
ulong *puVar1;
long lVar2;
bool bVar3;
lVar2 = 0;
if (param_3 < 1) {
param_3 = lVar2;
}
do {
if (param_3 == lVar2) {
return param_2;
}
puVar1 = (ulong *)(param_1 + lVar2 * 8);
bVar3 = *puVar1 < param_2;
*puVar1 = *puVar1 - param_2;
lVar2 = lVar2 + 1;
param_2 = 1;
} while (bVar3);
return 0;
}
| |
26,009 | extent_to_bitmap_blocks | eloqsql/storage/maria/ma_blockrec.c | static my_bool extent_to_bitmap_blocks(MARIA_HA *info,
MARIA_BITMAP_BLOCKS *blocks,
pgcache_page_no_t head_page,
uint extent_count,
const uchar *extent_info)
{
MARIA_BITMAP_BLOCK *block, *start_block;
MARIA_SHARE *share= info->s;
uint i, tail_page;
DBUG_ENTER("extent_to_bitmap_blocks");
if (allocate_dynamic(&info->bitmap_blocks, extent_count + 2))
DBUG_RETURN(1);
block= blocks->block= dynamic_element(&info->bitmap_blocks, 0,
MARIA_BITMAP_BLOCK*);
blocks->count= extent_count + 1;
blocks->tail_page_skipped= blocks->page_skipped= 0;
block->page= head_page;
block->page_count= 1;
block->used= BLOCKUSED_USED | BLOCKUSED_USE_ORG_BITMAP;
/* Impossible value, will force storage of real value */
block->org_bitmap_value= 255;
start_block= block++;
for (i=0 ;
i++ < extent_count ;
block++, extent_info+= ROW_EXTENT_SIZE)
{
uint page_count= uint2korr(extent_info + ROW_EXTENT_PAGE_SIZE);
if (page_count & START_EXTENT_BIT)
{
page_count&= ~START_EXTENT_BIT;
start_block->sub_blocks= (uint) (block - start_block);
start_block= block;
}
block->page= page_korr(extent_info);
block->page_count= page_count;
block->sub_blocks= 0;
if (block->page_count == 0)
{
/* Extend allocated but not used by write_block_record() */
DBUG_ASSERT(block->page == 0);
/* This is the last block */
blocks->count= i;
break;
}
if ((tail_page= page_count & TAIL_BIT))
page_count= 1;
/* Check if wrong data */
if (block->page == 0 || page_count == 0 ||
(block->page + page_count) * share->block_size >
share->state.state.data_file_length)
{
DBUG_PRINT("error", ("page: %lu page_count: %u tail: %u length: %ld data_length: %ld",
(ulong) block->page,
(block->page_count & ~TAIL_BIT),
(uint) MY_TEST(block->page_count & TAIL_BIT),
(ulong) ((block->page + (page_count & ~TAIL_BIT)) *
share->block_size),
(ulong) share->state.state.data_file_length));
DBUG_RETURN(1);
}
if (tail_page)
{
block->org_bitmap_value= _ma_bitmap_get_page_bits(info, &share->bitmap,
block->page);
block->used= (BLOCKUSED_TAIL | BLOCKUSED_USED |
BLOCKUSED_USE_ORG_BITMAP);
}
else
{
my_bool res;
mysql_mutex_lock(&share->bitmap.bitmap_lock);
res= _ma_bitmap_set_full_page_bits(info, &share->bitmap,
block->page, page_count);
mysql_mutex_unlock(&share->bitmap.bitmap_lock);
if (res)
DBUG_RETURN(1);
block->used= BLOCKUSED_USED;
}
}
start_block->sub_blocks= (uint) (block - start_block);
DBUG_RETURN(0);
} | O3 | c | extent_to_bitmap_blocks:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movl %ecx, %r14d
movq %rdx, -0x30(%rbp)
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rax
movq %rax, -0x48(%rbp)
leaq 0x2c0(%rdi), %r15
leal 0x2(%r14), %esi
movq %r15, %rdi
callq 0x924a1
testb %al, %al
je 0x4fd46
movb $0x1, %al
jmp 0x4ff26
movq %r13, -0x40(%rbp)
movq (%r15), %rcx
movq %rcx, (%r12)
leal 0x1(%r14), %eax
movl %eax, 0x8(%r12)
movw $0x0, 0xc(%r12)
movq -0x30(%rbp), %rax
movq %rax, (%rcx)
movl $0x1, 0x8(%rcx)
movw $0xff03, 0x14(%rcx) # imm = 0xFF03
leaq 0x18(%rcx), %r15
testl %r14d, %r14d
movq %rcx, -0x38(%rbp)
je 0x4ff0f
movq %r12, -0x58(%rbp)
movq -0x48(%rbp), %rsi
leaq 0xa10(%rsi), %rax
movq %rax, -0x50(%rbp)
leaq 0xa98(%rsi), %rax
movq %rax, -0x30(%rbp)
negl %r14d
movq %r14, -0x60(%rbp)
leaq 0x18(%rcx), %r14
addq $0x5, %rbx
movl $0x1, %r12d
movzwl (%rbx), %r13d
btl $0xe, %r13d
jae 0x4fde7
andl $0xbfff, %r13d # imm = 0xBFFF
movq %r14, %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0x10(%rcx)
movq %r15, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movl -0x5(%rbx), %eax
movzbl -0x1(%rbx), %edx
shlq $0x20, %rdx
orq %rax, %rdx
movq %rdx, (%r15)
movl %r13d, 0x8(%r15)
movl $0x0, 0x10(%r15)
testl %r13d, %r13d
je 0x4ff07
testq %rdx, %rdx
je 0x4fd3f
cmpl $0x8000, %r13d # imm = 0x8000
movl $0x1, %eax
cmovbl %r13d, %eax
addq %rdx, %rax
movl 0x7bc(%rsi), %ecx
imulq %rax, %rcx
cmpq 0x40(%rsi), %rcx
ja 0x4fd3f
cmpl $0x8000, %r13d # imm = 0x8000
jae 0x4fe9c
cmpq $0x0, 0xad8(%rsi)
jne 0x4fedb
movq -0x30(%rbp), %rdi
callq 0x29210
movq (%r15), %rdx
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl %r13d, %ecx
callq 0x549e4
movl %eax, %r13d
movq -0x48(%rbp), %rax
movq 0xad8(%rax), %rdi
testq %rdi, %rdi
jne 0x4fef5
movq -0x30(%rbp), %rdi
callq 0x291d0
movb $0x1, %al
testb %r13b, %r13b
je 0x4feab
jmp 0x4ff26
movq -0x50(%rbp), %rsi
callq 0x547e9
movb %al, 0x15(%r15)
movb $0x7, %al
movb %al, 0x14(%r15)
addq $0x18, %r15
movq -0x60(%rbp), %rax
addl %r12d, %eax
incl %eax
movl %r12d, %ecx
incl %ecx
addq $0x18, %r14
addq $0x7, %rbx
movl %ecx, %r12d
cmpl $0x1, %eax
movq -0x48(%rbp), %rsi
jne 0x4fdba
jmp 0x4ff0f
movq -0x30(%rbp), %rdi
leaq 0x8a9f3(%rip), %rsi # 0xda8d9
movl $0x97d, %edx # imm = 0x97D
callq 0x2ebaf
jmp 0x4fe61
leaq 0x336114(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4fe87
movq -0x58(%rbp), %rax
movl %r12d, 0x8(%rax)
movq -0x38(%rbp), %rcx
subq %rcx, %r15
shrq $0x3, %r15
imull $0xaaaaaaab, %r15d, %eax # imm = 0xAAAAAAAB
movl %eax, 0x10(%rcx)
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| extent_to_bitmap_blocks:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, r8
mov r14d, ecx
mov [rbp+var_30], rdx
mov r12, rsi
mov r13, rdi
mov rax, [rdi]
mov [rbp+var_48], rax
lea r15, [rdi+2C0h]
lea esi, [r14+2]
mov rdi, r15
call allocate_dynamic
test al, al
jz short loc_4FD46
loc_4FD3F:
mov al, 1
jmp loc_4FF26
loc_4FD46:
mov [rbp+var_40], r13
mov rcx, [r15]
mov [r12], rcx
lea eax, [r14+1]
mov [r12+8], eax
mov word ptr [r12+0Ch], 0
mov rax, [rbp+var_30]
mov [rcx], rax
mov dword ptr [rcx+8], 1
mov word ptr [rcx+14h], 0FF03h
lea r15, [rcx+18h]
test r14d, r14d
mov [rbp+var_38], rcx
jz loc_4FF0F
mov [rbp+var_58], r12
mov rsi, [rbp+var_48]
lea rax, [rsi+0A10h]
mov [rbp+var_50], rax
lea rax, [rsi+0A98h]
mov [rbp+var_30], rax
neg r14d
mov [rbp+var_60], r14
lea r14, [rcx+18h]
add rbx, 5
mov r12d, 1
loc_4FDBA:
movzx r13d, word ptr [rbx]
bt r13d, 0Eh
jnb short loc_4FDE7
and r13d, 0BFFFh
mov rax, r14
mov rcx, [rbp+var_38]
sub rax, rcx
shr rax, 3
imul eax, 0AAAAAAABh
mov [rcx+10h], eax
mov [rbp+var_38], r15
loc_4FDE7:
mov rdi, [rbp+var_40]
mov eax, [rbx-5]
movzx edx, byte ptr [rbx-1]
shl rdx, 20h
or rdx, rax
mov [r15], rdx
mov [r15+8], r13d
mov dword ptr [r15+10h], 0
test r13d, r13d
jz loc_4FF07
test rdx, rdx
jz loc_4FD3F
cmp r13d, 8000h
mov eax, 1
cmovb eax, r13d
add rax, rdx
mov ecx, [rsi+7BCh]
imul rcx, rax
cmp rcx, [rsi+40h]
ja loc_4FD3F
cmp r13d, 8000h
jnb short loc_4FE9C
cmp qword ptr [rsi+0AD8h], 0
jnz loc_4FEDB
mov rdi, [rbp+var_30]
call _pthread_mutex_lock
loc_4FE61:
mov rdx, [r15]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_50]
mov ecx, r13d
call _ma_bitmap_set_full_page_bits
mov r13d, eax
mov rax, [rbp+var_48]
mov rdi, [rax+0AD8h]
test rdi, rdi
jnz short loc_4FEF5
loc_4FE87:
mov rdi, [rbp+var_30]
call _pthread_mutex_unlock
mov al, 1
test r13b, r13b
jz short loc_4FEAB
jmp loc_4FF26
loc_4FE9C:
mov rsi, [rbp+var_50]
call _ma_bitmap_get_page_bits
mov [r15+15h], al
mov al, 7
loc_4FEAB:
mov [r15+14h], al
add r15, 18h
mov rax, [rbp+var_60]
add eax, r12d
inc eax
mov ecx, r12d
inc ecx
add r14, 18h
add rbx, 7
mov r12d, ecx
cmp eax, 1
mov rsi, [rbp+var_48]
jnz loc_4FDBA
jmp short loc_4FF0F
loc_4FEDB:
mov rdi, [rbp+var_30]
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 97Dh
call psi_mutex_lock
jmp loc_4FE61
loc_4FEF5:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_4FE87
loc_4FF07:
mov rax, [rbp+var_58]
mov [rax+8], r12d
loc_4FF0F:
mov rcx, [rbp+var_38]
sub r15, rcx
shr r15, 3
imul eax, r15d, 0AAAAAAABh
mov [rcx+10h], eax
xor eax, eax
loc_4FF26:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char extent_to_bitmap_blocks(long long *a1, long long a2, long long a3, int a4, long long a5)
{
long long *v7; // r15
char result; // al
long long v9; // rcx
long long v10; // r15
long long v11; // rsi
long long v12; // r14
unsigned __int16 *v13; // rbx
int v14; // r12d
unsigned int v15; // r13d
unsigned long long v16; // rdx
long long v17; // rax
char v18; // r13
int v19; // eax
int v20; // [rsp+0h] [rbp-60h]
long long v22; // [rsp+10h] [rbp-50h]
long long v23; // [rsp+18h] [rbp-48h]
long long v24; // [rsp+28h] [rbp-38h]
long long v26; // [rsp+30h] [rbp-30h]
v23 = *a1;
v7 = a1 + 88;
if ( (unsigned __int8)allocate_dynamic(a1 + 88, (unsigned int)(a4 + 2)) )
return 1;
v9 = *v7;
*(_QWORD *)a2 = *v7;
*(_DWORD *)(a2 + 8) = a4 + 1;
*(_WORD *)(a2 + 12) = 0;
*(_QWORD *)v9 = a3;
*(_DWORD *)(v9 + 8) = 1;
*(_WORD *)(v9 + 20) = -253;
v10 = v9 + 24;
v24 = v9;
if ( a4 )
{
v11 = v23;
v22 = v23 + 2576;
v26 = v23 + 2712;
v20 = -a4;
v12 = v9 + 24;
v13 = (unsigned __int16 *)(a5 + 5);
v14 = 1;
while ( 1 )
{
v15 = *v13;
if ( (v15 & 0x4000) != 0 )
{
v15 &= 0xBFFFu;
*(_DWORD *)(v24 + 16) = -1431655765 * ((unsigned long long)(v12 - v24) >> 3);
v24 = v10;
}
v16 = *(unsigned int *)((char *)v13 - 5) | ((unsigned long long)*((unsigned __int8 *)v13 - 1) << 32);
*(_QWORD *)v10 = v16;
*(_DWORD *)(v10 + 8) = v15;
*(_DWORD *)(v10 + 16) = 0;
if ( !v15 )
break;
if ( !v16 )
return 1;
v17 = 1LL;
if ( v15 < 0x8000 )
v17 = v15;
if ( (v16 + v17) * *(unsigned int *)(v11 + 1980) > *(_QWORD *)(v11 + 64) )
return 1;
if ( v15 >= 0x8000 )
{
*(_BYTE *)(v10 + 21) = ma_bitmap_get_page_bits(a1, v22, v16);
result = 7;
}
else
{
if ( *(_QWORD *)(v11 + 2776) )
psi_mutex_lock(v26, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c", 0x97Du);
else
pthread_mutex_lock(v26);
v18 = ma_bitmap_set_full_page_bits(a1, v22, *(_QWORD *)v10, v15);
if ( *(_QWORD *)(v23 + 2776) )
PSI_server[44]();
pthread_mutex_unlock(v26);
result = 1;
if ( v18 )
return result;
}
*(_BYTE *)(v10 + 20) = result;
v10 += 24LL;
v19 = v14 + v20 + 1;
v12 += 24LL;
v13 = (unsigned __int16 *)((char *)v13 + 7);
++v14;
v11 = v23;
if ( v19 == 1 )
goto LABEL_24;
}
*(_DWORD *)(a2 + 8) = v14;
}
LABEL_24:
*(_DWORD *)(v24 + 16) = -1431655765 * ((unsigned long long)(v10 - v24) >> 3);
return 0;
}
| extent_to_bitmap_blocks:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,R8
MOV R14D,ECX
MOV qword ptr [RBP + -0x30],RDX
MOV R12,RSI
MOV R13,RDI
MOV RAX,qword ptr [RDI]
MOV qword ptr [RBP + -0x48],RAX
LEA R15,[RDI + 0x2c0]
LEA ESI,[R14 + 0x2]
MOV RDI,R15
CALL 0x001924a1
TEST AL,AL
JZ 0x0014fd46
LAB_0014fd3f:
MOV AL,0x1
JMP 0x0014ff26
LAB_0014fd46:
MOV qword ptr [RBP + -0x40],R13
MOV RCX,qword ptr [R15]
MOV qword ptr [R12],RCX
LEA EAX,[R14 + 0x1]
MOV dword ptr [R12 + 0x8],EAX
MOV word ptr [R12 + 0xc],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RCX],RAX
MOV dword ptr [RCX + 0x8],0x1
MOV word ptr [RCX + 0x14],0xff03
LEA R15,[RCX + 0x18]
TEST R14D,R14D
MOV qword ptr [RBP + -0x38],RCX
JZ 0x0014ff0f
MOV qword ptr [RBP + -0x58],R12
MOV RSI,qword ptr [RBP + -0x48]
LEA RAX,[RSI + 0xa10]
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[RSI + 0xa98]
MOV qword ptr [RBP + -0x30],RAX
NEG R14D
MOV qword ptr [RBP + -0x60],R14
LEA R14,[RCX + 0x18]
ADD RBX,0x5
MOV R12D,0x1
LAB_0014fdba:
MOVZX R13D,word ptr [RBX]
BT R13D,0xe
JNC 0x0014fde7
AND R13D,0xbfff
MOV RAX,R14
MOV RCX,qword ptr [RBP + -0x38]
SUB RAX,RCX
SHR RAX,0x3
IMUL EAX,EAX,-0x55555555
MOV dword ptr [RCX + 0x10],EAX
MOV qword ptr [RBP + -0x38],R15
LAB_0014fde7:
MOV RDI,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBX + -0x5]
MOVZX EDX,byte ptr [RBX + -0x1]
SHL RDX,0x20
OR RDX,RAX
MOV qword ptr [R15],RDX
MOV dword ptr [R15 + 0x8],R13D
MOV dword ptr [R15 + 0x10],0x0
TEST R13D,R13D
JZ 0x0014ff07
TEST RDX,RDX
JZ 0x0014fd3f
CMP R13D,0x8000
MOV EAX,0x1
CMOVC EAX,R13D
ADD RAX,RDX
MOV ECX,dword ptr [RSI + 0x7bc]
IMUL RCX,RAX
CMP RCX,qword ptr [RSI + 0x40]
JA 0x0014fd3f
CMP R13D,0x8000
JNC 0x0014fe9c
CMP qword ptr [RSI + 0xad8],0x0
JNZ 0x0014fedb
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00129210
LAB_0014fe61:
MOV RDX,qword ptr [R15]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x50]
MOV ECX,R13D
CALL 0x001549e4
MOV R13D,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [RAX + 0xad8]
TEST RDI,RDI
JNZ 0x0014fef5
LAB_0014fe87:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001291d0
MOV AL,0x1
TEST R13B,R13B
JZ 0x0014feab
JMP 0x0014ff26
LAB_0014fe9c:
MOV RSI,qword ptr [RBP + -0x50]
CALL 0x001547e9
MOV byte ptr [R15 + 0x15],AL
MOV AL,0x7
LAB_0014feab:
MOV byte ptr [R15 + 0x14],AL
ADD R15,0x18
MOV RAX,qword ptr [RBP + -0x60]
ADD EAX,R12D
INC EAX
MOV ECX,R12D
INC ECX
ADD R14,0x18
ADD RBX,0x7
MOV R12D,ECX
CMP EAX,0x1
MOV RSI,qword ptr [RBP + -0x48]
JNZ 0x0014fdba
JMP 0x0014ff0f
LAB_0014fedb:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x1da8d9]
MOV EDX,0x97d
CALL 0x0012ebaf
JMP 0x0014fe61
LAB_0014fef5:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014fe87
LAB_0014ff07:
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RAX + 0x8],R12D
LAB_0014ff0f:
MOV RCX,qword ptr [RBP + -0x38]
SUB R15,RCX
SHR R15,0x3
IMUL EAX,R15D,-0x55555555
MOV dword ptr [RCX + 0x10],EAX
XOR EAX,EAX
LAB_0014ff26:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
extent_to_bitmap_blocks(long *param_1,long *param_2,ulong param_3,int param_4,long param_5)
{
pthread_mutex_t *__mutex;
ushort uVar1;
long lVar2;
char cVar3;
int1 uVar4;
int8 uVar5;
ulong uVar6;
ulong uVar7;
ushort *puVar8;
int iVar9;
uint uVar10;
ulong *puVar11;
ulong *puVar12;
bool bVar13;
ulong *local_40;
lVar2 = *param_1;
cVar3 = allocate_dynamic(param_1 + 0x58,param_4 + 2);
if (cVar3 == '\0') {
puVar11 = (ulong *)param_1[0x58];
*param_2 = (long)puVar11;
*(int *)(param_2 + 1) = param_4 + 1;
*(int2 *)((long)param_2 + 0xc) = 0;
*puVar11 = param_3;
*(int4 *)(puVar11 + 1) = 1;
*(int2 *)((long)puVar11 + 0x14) = 0xff03;
puVar12 = puVar11 + 3;
local_40 = puVar11;
if (param_4 != 0) {
__mutex = (pthread_mutex_t *)(lVar2 + 0xa98);
puVar8 = (ushort *)(param_5 + 5);
iVar9 = 1;
do {
puVar11 = puVar11 + 3;
uVar1 = *puVar8;
uVar10 = (uint)uVar1;
if ((uVar1 >> 0xe & 1) != 0) {
uVar10 = uVar1 & 0xbfff;
*(int *)(local_40 + 2) = (int)((ulong)((long)puVar11 - (long)local_40) >> 3) * -0x55555555
;
local_40 = puVar12;
}
uVar7 = (ulong)*(uint5 *)((long)puVar8 + -5);
*puVar12 = uVar7;
*(uint *)(puVar12 + 1) = uVar10;
*(int4 *)(puVar12 + 2) = 0;
if (uVar10 == 0) {
*(int *)(param_2 + 1) = iVar9;
break;
}
if (uVar7 == 0) goto LAB_0014fd3f;
uVar6 = 1;
if (uVar10 < 0x8000) {
uVar6 = (ulong)uVar10;
}
uVar7 = (ulong)*(uint *)(lVar2 + 0x7bc) * (uVar6 + uVar7);
if (*(ulong *)(lVar2 + 0x40) <= uVar7 && uVar7 - *(ulong *)(lVar2 + 0x40) != 0)
goto LAB_0014fd3f;
if (uVar10 < 0x8000) {
if (*(long *)(lVar2 + 0xad8) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",
0x97d);
}
cVar3 = _ma_bitmap_set_full_page_bits(param_1,lVar2 + 0xa10,*puVar12,uVar10);
if (*(long *)(lVar2 + 0xad8) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
uVar4 = 1;
if (cVar3 != '\0') {
return 1;
}
}
else {
uVar4 = _ma_bitmap_get_page_bits(param_1,lVar2 + 0xa10);
*(int1 *)((long)puVar12 + 0x15) = uVar4;
uVar4 = 7;
}
*(int1 *)((long)puVar12 + 0x14) = uVar4;
puVar12 = puVar12 + 3;
puVar8 = (ushort *)((long)puVar8 + 7);
bVar13 = iVar9 != param_4;
iVar9 = iVar9 + 1;
} while (bVar13);
}
*(int *)(local_40 + 2) = (int)((ulong)((long)puVar12 - (long)local_40) >> 3) * -0x55555555;
uVar5 = 0;
}
else {
LAB_0014fd3f:
uVar5 = 1;
}
return uVar5;
}
| |
26,010 | YogaTest_copy_style_modified_Test::TestBody() | yoga-mod/tests/YGStyleTest.cpp | TEST(YogaTest, copy_style_modified) {
YGNodeRef node0 = YGNodeNew();
ASSERT_EQ(YGFlexDirectionColumn, YGNodeStyleGetFlexDirection(node0));
ASSERT_FALSE(YGNodeStyleGetMaxHeight(node0).unit != YGUnitUndefined);
YGNodeRef node1 = YGNodeNew();
YGNodeStyleSetFlexDirection(node1, YGFlexDirectionRow);
YGNodeStyleSetMaxHeight(node1, 10);
YGNodeCopyStyle(node0, node1);
ASSERT_EQ(YGFlexDirectionRow, YGNodeStyleGetFlexDirection(node0));
ASSERT_FLOAT_EQ(10, YGNodeStyleGetMaxHeight(node0).value);
YGNodeFree(node0);
YGNodeFree(node1);
} | O3 | cpp | YogaTest_copy_style_modified_Test::TestBody():
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
callq 0x366b25
movq %rax, %rbx
leaq -0x38(%rbp), %r14
movl $0x0, (%r14)
movq %rax, %rdi
callq 0x367b71
leaq -0x28(%rbp), %r8
movl %eax, (%r8)
leaq 0x2e07c9(%rip), %rsi # 0x39bc6b
leaq 0x2e3dcc(%rip), %rdx # 0x39f275
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rcx
callq 0x95bd2
cmpb $0x0, (%r15)
je 0xbb5d5
movq -0x50(%rbp), %rsi
testq %rsi, %rsi
je 0xbb4d4
leaq -0x50(%rbp), %rdi
callq 0x6fd1c
movq %rbx, %rdi
callq 0x368c3f
shrq $0x20, %rax
sete -0x38(%rbp)
movq $0x0, -0x30(%rbp)
jne 0xbb5f3
callq 0x366b25
movq %rax, %r14
movq %rax, %rdi
movl $0x2, %esi
callq 0x367b49
movss 0x2ddb05(%rip), %xmm0 # 0x399014
movq %r14, %rdi
callq 0x368bc9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x367ada
leaq -0x38(%rbp), %r15
movl $0x2, (%r15)
movq %rbx, %rdi
callq 0x367b71
leaq -0x28(%rbp), %r8
movl %eax, (%r8)
leaq 0x2e0fe8(%rip), %rsi # 0x39c52b
leaq 0x2e3d2b(%rip), %rdx # 0x39f275
leaq -0x58(%rbp), %r12
movq %r12, %rdi
movq %r15, %rcx
callq 0x95bd2
cmpb $0x0, (%r12)
je 0xbb6f1
movq -0x50(%rbp), %rsi
testq %rsi, %rsi
je 0xbb576
leaq -0x50(%rbp), %rdi
callq 0x6fd1c
movq %rbx, %rdi
callq 0x368c3f
movd %eax, %xmm1
leaq 0x2e4cac(%rip), %rsi # 0x3a0235
leaq 0x2e3d3f(%rip), %rdx # 0x39f2cf
leaq -0x58(%rbp), %r15
movss 0x2dda78(%rip), %xmm0 # 0x399014
movq %r15, %rdi
callq 0x73444
cmpb $0x0, (%r15)
je 0xbb708
movq -0x50(%rbp), %rsi
testq %rsi, %rsi
je 0xbb5c0
leaq -0x50(%rbp), %rdi
callq 0x6fd1c
movq %rbx, %rdi
callq 0x366cdc
movq %r14, %rdi
callq 0x366cdc
jmp 0xbb6e4
leaq -0x38(%rbp), %rdi
callq 0x37f68a
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xbb68c
movq (%rax), %r8
jmp 0xbb693
leaq -0x28(%rbp), %rdi
callq 0x37f68a
leaq -0x30(%rbp), %r14
leaq 0x2e3c91(%rip), %rdx # 0x39f298
leaq 0x2de43c(%rip), %rcx # 0x399a4a
leaq 0x2de42f(%rip), %r8 # 0x399a44
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x37bad6
movq -0x58(%rbp), %r8
leaq 0x2e3bf4(%rip), %rdx # 0x39f221
leaq -0x60(%rbp), %rdi
movl $0x2, %esi
movl $0x18, %ecx
callq 0x37cfa4
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x37bc92
leaq -0x60(%rbp), %rdi
callq 0x37d01c
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb66f
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x32440
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xbb67e
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x30(%rbp), %rsi
testq %rsi, %rsi
je 0xbb6e4
movq %r14, %rdi
jmp 0xbb6df
leaq 0x2edd17(%rip), %r8 # 0x3a93aa
leaq 0x2e3b87(%rip), %rdx # 0x39f221
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
movl $0x17, %ecx
callq 0x37cfa4
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x37bc92
leaq -0x28(%rbp), %rdi
callq 0x37d01c
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xbb6d2
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x50(%rbp), %rsi
testq %rsi, %rsi
je 0xbb6e4
leaq -0x50(%rbp), %rdi
callq 0x6fd1c
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x37f68a
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xbb71f
movq (%rax), %r8
jmp 0xbb726
leaq -0x38(%rbp), %rdi
callq 0x37f68a
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xbb752
movq (%rax), %r8
jmp 0xbb759
leaq 0x2edc84(%rip), %r8 # 0x3a93aa
leaq 0x2e3af4(%rip), %rdx # 0x39f221
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
movl $0x1f, %ecx
callq 0x37cfa4
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x37bc92
jmp 0xbb6ba
leaq 0x2edc51(%rip), %r8 # 0x3a93aa
leaq 0x2e3ac1(%rip), %rdx # 0x39f221
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
movl $0x20, %ecx
callq 0x37cfa4
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x37bc92
jmp 0xbb6ba
jmp 0xbb7e2
jmp 0xbb7f0
jmp 0xbb804
jmp 0xbb7e2
jmp 0xbb7f0
jmp 0xbb804
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x37d01c
jmp 0xbb7a2
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb7c0
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x32440
jmp 0xbb7c0
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xbb7cf
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x30(%rbp), %rsi
testq %rsi, %rsi
je 0xbb819
movq %r14, %rdi
jmp 0xbb814
movq %rax, %rbx
jmp 0xbb819
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x37d01c
jmp 0xbb7f3
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xbb807
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xbb807
movq %rax, %rbx
movq -0x50(%rbp), %rsi
testq %rsi, %rsi
je 0xbb819
leaq -0x50(%rbp), %rdi
callq 0x6fd1c
movq %rbx, %rdi
callq 0x32840
nop
| _ZN33YogaTest_copy_style_modified_Test8TestBodyEv:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 40h
call YGNodeNew
mov rbx, rax
lea r14, [rbp+var_38]
mov dword ptr [r14], 0
mov rdi, rax
call YGNodeStyleGetFlexDirection
lea r8, [rbp+var_28]
mov [r8], eax
lea rsi, aYgflexdirectio; "YGFlexDirectionColumn"
lea rdx, aYgnodestyleget_36; "YGNodeStyleGetFlexDirection(node0)"
lea r15, [rbp+var_58]
mov rdi, r15; this
mov rcx, r14
call _ZN7testing8internal11CmpHelperEQI15YGFlexDirectionS2_EENS_15AssertionResultEPKcS5_RKT_RKT0_; testing::internal::CmpHelperEQ<YGFlexDirection,YGFlexDirection>(char const*,char const*,YGFlexDirection const&,YGFlexDirection const&)
cmp byte ptr [r15], 0
jz loc_BB5D5
mov rsi, [rbp+var_50]
test rsi, rsi
jz short loc_BB4D4
lea rdi, [rbp+var_50]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_BB4D4:
mov rdi, rbx
call YGNodeStyleGetMaxHeight
shr rax, 20h
setz byte ptr [rbp+var_38]
mov [rbp+var_30], 0
jnz loc_BB5F3
call YGNodeNew
mov r14, rax
mov rdi, rax
mov esi, 2
call YGNodeStyleSetFlexDirection
movss xmm0, cs:dword_399014
mov rdi, r14
call YGNodeStyleSetMaxHeight
mov rdi, rbx; this
mov rsi, r14
call YGNodeCopyStyle
lea r15, [rbp+var_38]
mov dword ptr [r15], 2
mov rdi, rbx
call YGNodeStyleGetFlexDirection
lea r8, [rbp+var_28]
mov [r8], eax
lea rsi, aYgflexdirectio_0; "YGFlexDirectionRow"
lea rdx, aYgnodestyleget_36; "YGNodeStyleGetFlexDirection(node0)"
lea r12, [rbp+var_58]
mov rdi, r12; this
mov rcx, r15
call _ZN7testing8internal11CmpHelperEQI15YGFlexDirectionS2_EENS_15AssertionResultEPKcS5_RKT_RKT0_; testing::internal::CmpHelperEQ<YGFlexDirection,YGFlexDirection>(char const*,char const*,YGFlexDirection const&,YGFlexDirection const&)
cmp byte ptr [r12], 0
jz loc_BB6F1
mov rsi, [rbp+var_50]
test rsi, rsi
jz short loc_BB576
lea rdi, [rbp+var_50]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_BB576:
mov rdi, rbx
call YGNodeStyleGetMaxHeight
movd xmm1, eax
lea rsi, a10+1; "10"
lea rdx, aYgnodestyleget_37; "YGNodeStyleGetMaxHeight(node0).value"
lea r15, [rbp+var_58]
movss xmm0, cs:dword_399014
mov rdi, r15; this
call _ZN7testing8internal24CmpHelperFloatingPointEQIfEENS_15AssertionResultEPKcS4_T_S5_; testing::internal::CmpHelperFloatingPointEQ<float>(char const*,char const*,float,float)
cmp byte ptr [r15], 0
jz loc_BB708
mov rsi, [rbp+var_50]
test rsi, rsi
jz short loc_BB5C0
lea rdi, [rbp+var_50]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_BB5C0:
mov rdi, rbx; this
call YGNodeFree
mov rdi, r14; this
call YGNodeFree
jmp loc_BB6E4
loc_BB5D5:
lea rdi, [rbp+var_38]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rax, [rbp+var_50]
test rax, rax
jz loc_BB68C
mov r8, [rax]
jmp loc_BB693
loc_BB5F3:
lea rdi, [rbp+var_28]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
lea r14, [rbp+var_30]
lea rdx, aYgnodestyleget_38; "YGNodeStyleGetMaxHeight(node0).unit != "...
lea rcx, aTrue; "true"
lea r8, aFalse; "false"
lea rdi, [rbp+var_58]
lea rsi, [rbp+var_38]
call _ZN7testing8internal30GetBoolAssertionFailureMessageB5cxx11ERKNS_15AssertionResultEPKcS5_S5_; testing::internal::GetBoolAssertionFailureMessage(testing::AssertionResult const&,char const*,char const*,char const*)
mov r8, [rbp+var_58]
lea rdx, xmmword_39F221
lea rdi, [rbp+var_60]
mov esi, 2
mov ecx, 18h
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
lea rdi, [rbp+var_60]
lea rsi, [rbp+var_28]
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
lea rdi, [rbp+var_60]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
lea rax, [rbp+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB66F
mov rsi, [rbp+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BB66F:
mov rdi, [rbp+var_28]
test rdi, rdi
jz short loc_BB67E
mov rax, [rdi]
call qword ptr [rax+8]
loc_BB67E:
mov rsi, [rbp+var_30]
test rsi, rsi
jz short loc_BB6E4
mov rdi, r14
jmp short loc_BB6DF
loc_BB68C:
lea r8, aSFromSSMsTotal+1Ah; ""
loc_BB693:
lea rdx, xmmword_39F221
lea rdi, [rbp+var_28]
mov esi, 2
mov ecx, 17h
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_38]
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
loc_BB6BA:
lea rdi, [rbp+var_28]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
mov rdi, [rbp+var_38]
test rdi, rdi
jz short loc_BB6D2
mov rax, [rdi]
call qword ptr [rax+8]
loc_BB6D2:
mov rsi, [rbp+var_50]
test rsi, rsi
jz short loc_BB6E4
lea rdi, [rbp+var_50]
loc_BB6DF:
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_BB6E4:
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_BB6F1:
lea rdi, [rbp+var_38]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rax, [rbp+var_50]
test rax, rax
jz short loc_BB71F
mov r8, [rax]
jmp short loc_BB726
loc_BB708:
lea rdi, [rbp+var_38]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rax, [rbp+var_50]
test rax, rax
jz short loc_BB752
mov r8, [rax]
jmp short loc_BB759
loc_BB71F:
lea r8, aSFromSSMsTotal+1Ah; ""
loc_BB726:
lea rdx, xmmword_39F221
lea rdi, [rbp+var_28]
mov esi, 2
mov ecx, 1Fh
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_38]
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
jmp loc_BB6BA
loc_BB752:
lea r8, aSFromSSMsTotal+1Ah; ""
loc_BB759:
lea rdx, xmmword_39F221
lea rdi, [rbp+var_28]
mov esi, 2
mov ecx, 20h ; ' '
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_38]
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
jmp loc_BB6BA
jmp short loc_BB7E2
jmp short loc_BB7F0
jmp short loc_BB804
jmp short loc_BB7E2
jmp short loc_BB7F0
jmp short loc_BB804
mov rbx, rax
lea rdi, [rbp+var_60]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
jmp short loc_BB7A2
mov rbx, rax
loc_BB7A2:
lea rax, [rbp+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB7C0
mov rsi, [rbp+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BB7C0
mov rbx, rax
loc_BB7C0:
mov rdi, [rbp+var_28]
test rdi, rdi
jz short loc_BB7CF
mov rax, [rdi]
call qword ptr [rax+8]
loc_BB7CF:
mov rsi, [rbp+var_30]
test rsi, rsi
jz short loc_BB819
mov rdi, r14
jmp short loc_BB814
mov rbx, rax
jmp short loc_BB819
loc_BB7E2:
mov rbx, rax
lea rdi, [rbp+var_28]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
jmp short loc_BB7F3
loc_BB7F0:
mov rbx, rax
loc_BB7F3:
mov rdi, [rbp+var_38]
test rdi, rdi
jz short loc_BB807
mov rax, [rdi]
call qword ptr [rax+8]
jmp short loc_BB807
loc_BB804:
mov rbx, rax
loc_BB807:
mov rsi, [rbp+var_50]
test rsi, rsi
jz short loc_BB819
lea rdi, [rbp+var_50]
loc_BB814:
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_BB819:
mov rdi, rbx
call __Unwind_Resume
| void YogaTest_copy_style_modified_Test::TestBody(YogaTest_copy_style_modified_Test *this)
{
facebook::yoga::Node *v1; // rbx
unsigned long long v2; // rax
facebook::yoga::Node *v3; // r14
float v4; // eax
char *v5; // r8
double v6; // xmm0_8
char **v7; // rsi
char ***v8; // rdi
double v9; // xmm0_8
char *v10; // r8
char *v11; // r8
char v12[8]; // [rsp+0h] [rbp-60h] BYREF
long long *v13; // [rsp+8h] [rbp-58h] BYREF
char **v14; // [rsp+10h] [rbp-50h] BYREF
long long v15; // [rsp+18h] [rbp-48h] BYREF
long long v16; // [rsp+28h] [rbp-38h] BYREF
char **v17; // [rsp+30h] [rbp-30h] BYREF
_QWORD v18[5]; // [rsp+38h] [rbp-28h] BYREF
v1 = (facebook::yoga::Node *)YGNodeNew(this);
LODWORD(v16) = 0;
LODWORD(v18[0]) = YGNodeStyleGetFlexDirection(v1);
testing::internal::CmpHelperEQ<YGFlexDirection,YGFlexDirection>(
(testing *)&v13,
(long long)"YGFlexDirectionColumn",
(long long)"YGNodeStyleGetFlexDirection(node0)",
&v16,
v18);
if ( !(_BYTE)v13 )
{
testing::Message::Message((testing::Message *)&v16);
if ( v14 )
v5 = *v14;
else
v5 = "";
testing::internal::AssertHelper::AssertHelper(v18, 2LL, &xmmword_39F221, 23LL, v5);
v9 = testing::internal::AssertHelper::operator=(v18, &v16);
goto LABEL_22;
}
if ( v14 )
std::default_delete<std::string>::operator()((long long)&v14, (long long)v14);
v2 = (unsigned long long)YGNodeStyleGetMaxHeight(v1) >> 32;
LOBYTE(v16) = v2 == 0;
v17 = 0LL;
if ( !v2 )
{
v3 = (facebook::yoga::Node *)YGNodeNew(v1);
YGNodeStyleSetFlexDirection(v3, 2LL);
YGNodeStyleSetMaxHeight(v3, 10.0);
YGNodeCopyStyle(v1);
LODWORD(v16) = 2;
LODWORD(v18[0]) = YGNodeStyleGetFlexDirection(v1);
testing::internal::CmpHelperEQ<YGFlexDirection,YGFlexDirection>(
(testing *)&v13,
(long long)"YGFlexDirectionRow",
(long long)"YGNodeStyleGetFlexDirection(node0)",
&v16,
v18);
if ( (_BYTE)v13 )
{
if ( v14 )
std::default_delete<std::string>::operator()((long long)&v14, (long long)v14);
LODWORD(v4) = YGNodeStyleGetMaxHeight(v1);
testing::internal::CmpHelperFloatingPointEQ<float>(
(testing *)&v13,
(long long)"10",
(long long)"YGNodeStyleGetMaxHeight(node0).value",
10.0,
v4);
if ( (_BYTE)v13 )
{
if ( v14 )
std::default_delete<std::string>::operator()((long long)&v14, (long long)v14);
YGNodeFree(v1);
YGNodeFree(v3);
return;
}
testing::Message::Message((testing::Message *)&v16);
if ( v14 )
v11 = *v14;
else
v11 = "";
testing::internal::AssertHelper::AssertHelper(v18, 2LL, &xmmword_39F221, 32LL, v11);
v9 = testing::internal::AssertHelper::operator=(v18, &v16);
}
else
{
testing::Message::Message((testing::Message *)&v16);
if ( v14 )
v10 = *v14;
else
v10 = "";
testing::internal::AssertHelper::AssertHelper(v18, 2LL, &xmmword_39F221, 31LL, v10);
v9 = testing::internal::AssertHelper::operator=(v18, &v16);
}
LABEL_22:
testing::internal::AssertHelper::~AssertHelper((testing::internal::AssertHelper *)v18);
if ( v16 )
(*(void ( **)(long long, double))(*(_QWORD *)v16 + 8LL))(v16, v9);
v7 = v14;
if ( v14 )
{
v8 = &v14;
goto LABEL_26;
}
return;
}
testing::Message::Message((testing::Message *)v18);
testing::internal::GetBoolAssertionFailureMessage[abi:cxx11](
&v13,
&v16,
"YGNodeStyleGetMaxHeight(node0).unit != YGUnitUndefined",
"true",
"false");
testing::internal::AssertHelper::AssertHelper(v12, 2LL, &xmmword_39F221, 24LL, v13);
v6 = testing::internal::AssertHelper::operator=(v12, v18);
testing::internal::AssertHelper::~AssertHelper((testing::internal::AssertHelper *)v12);
if ( v13 != &v15 )
operator delete(v13, v15 + 1);
if ( v18[0] )
(*(void ( **)(_QWORD, double))(*(_QWORD *)v18[0] + 8LL))(v18[0], v6);
v7 = v17;
if ( v17 )
{
v8 = &v17;
LABEL_26:
std::default_delete<std::string>::operator()((long long)v8, (long long)v7);
}
}
| TestBody:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
CALL 0x00466b25
MOV RBX,RAX
LEA R14,[RBP + -0x38]
MOV dword ptr [R14],0x0
MOV RDI,RAX
CALL 0x00467b71
LEA R8,[RBP + -0x28]
MOV dword ptr [R8],EAX
LEA RSI,[0x49bc6b]
LEA RDX,[0x49f275]
LEA R15,[RBP + -0x58]
MOV RDI,R15
MOV RCX,R14
CALL 0x00195bd2
CMP byte ptr [R15],0x0
JZ 0x001bb5d5
MOV RSI,qword ptr [RBP + -0x50]
TEST RSI,RSI
JZ 0x001bb4d4
LEA RDI,[RBP + -0x50]
CALL 0x0016fd1c
LAB_001bb4d4:
MOV RDI,RBX
CALL 0x00468c3f
SHR RAX,0x20
SETZ byte ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],0x0
JNZ 0x001bb5f3
CALL 0x00466b25
MOV R14,RAX
MOV RDI,RAX
MOV ESI,0x2
CALL 0x00467b49
MOVSS XMM0,dword ptr [0x00499014]
MOV RDI,R14
CALL 0x00468bc9
MOV RDI,RBX
MOV RSI,R14
CALL 0x00467ada
LEA R15,[RBP + -0x38]
MOV dword ptr [R15],0x2
MOV RDI,RBX
CALL 0x00467b71
LEA R8,[RBP + -0x28]
MOV dword ptr [R8],EAX
LEA RSI,[0x49c52b]
LEA RDX,[0x49f275]
LEA R12,[RBP + -0x58]
MOV RDI,R12
MOV RCX,R15
CALL 0x00195bd2
CMP byte ptr [R12],0x0
JZ 0x001bb6f1
MOV RSI,qword ptr [RBP + -0x50]
TEST RSI,RSI
JZ 0x001bb576
LEA RDI,[RBP + -0x50]
CALL 0x0016fd1c
LAB_001bb576:
MOV RDI,RBX
CALL 0x00468c3f
MOVD XMM1,EAX
LEA RSI,[0x4a0235]
LEA RDX,[0x49f2cf]
LEA R15,[RBP + -0x58]
MOVSS XMM0,dword ptr [0x00499014]
MOV RDI,R15
CALL 0x00173444
CMP byte ptr [R15],0x0
JZ 0x001bb708
MOV RSI,qword ptr [RBP + -0x50]
TEST RSI,RSI
JZ 0x001bb5c0
LEA RDI,[RBP + -0x50]
CALL 0x0016fd1c
LAB_001bb5c0:
MOV RDI,RBX
CALL 0x00466cdc
MOV RDI,R14
CALL 0x00466cdc
JMP 0x001bb6e4
LAB_001bb5d5:
LEA RDI,[RBP + -0x38]
CALL 0x0047f68a
MOV RAX,qword ptr [RBP + -0x50]
TEST RAX,RAX
JZ 0x001bb68c
MOV R8,qword ptr [RAX]
JMP 0x001bb693
LAB_001bb5f3:
LEA RDI,[RBP + -0x28]
CALL 0x0047f68a
LAB_001bb5fc:
LEA R14,[RBP + -0x30]
LEA RDX,[0x49f298]
LEA RCX,[0x499a4a]
LEA R8,[0x499a44]
LEA RDI,[RBP + -0x58]
LEA RSI,[RBP + -0x38]
CALL 0x0047bad6
MOV R8,qword ptr [RBP + -0x58]
LAB_001bb626:
LEA RDX,[0x49f221]
LEA RDI,[RBP + -0x60]
MOV ESI,0x2
MOV ECX,0x18
CALL 0x0047cfa4
LAB_001bb640:
LEA RDI,[RBP + -0x60]
LEA RSI,[RBP + -0x28]
CALL 0x0047bc92
LAB_001bb64d:
LEA RDI,[RBP + -0x60]
CALL 0x0047d01c
LEA RAX,[RBP + -0x48]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001bb66f
MOV RSI,qword ptr [RBP + -0x48]
INC RSI
CALL 0x00132440
LAB_001bb66f:
MOV RDI,qword ptr [RBP + -0x28]
TEST RDI,RDI
JZ 0x001bb67e
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_001bb67e:
MOV RSI,qword ptr [RBP + -0x30]
TEST RSI,RSI
JZ 0x001bb6e4
MOV RDI,R14
JMP 0x001bb6df
LAB_001bb68c:
LEA R8,[0x4a93aa]
LAB_001bb693:
LEA RDX,[0x49f221]
LEA RDI,[RBP + -0x28]
MOV ESI,0x2
MOV ECX,0x17
CALL 0x0047cfa4
LAB_001bb6ad:
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x38]
CALL 0x0047bc92
LAB_001bb6ba:
LEA RDI,[RBP + -0x28]
CALL 0x0047d01c
MOV RDI,qword ptr [RBP + -0x38]
TEST RDI,RDI
JZ 0x001bb6d2
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_001bb6d2:
MOV RSI,qword ptr [RBP + -0x50]
TEST RSI,RSI
JZ 0x001bb6e4
LEA RDI,[RBP + -0x50]
LAB_001bb6df:
CALL 0x0016fd1c
LAB_001bb6e4:
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001bb6f1:
LEA RDI,[RBP + -0x38]
CALL 0x0047f68a
MOV RAX,qword ptr [RBP + -0x50]
TEST RAX,RAX
JZ 0x001bb71f
MOV R8,qword ptr [RAX]
JMP 0x001bb726
LAB_001bb708:
LEA RDI,[RBP + -0x38]
CALL 0x0047f68a
MOV RAX,qword ptr [RBP + -0x50]
TEST RAX,RAX
JZ 0x001bb752
MOV R8,qword ptr [RAX]
JMP 0x001bb759
LAB_001bb71f:
LEA R8,[0x4a93aa]
LAB_001bb726:
LEA RDX,[0x49f221]
LEA RDI,[RBP + -0x28]
MOV ESI,0x2
MOV ECX,0x1f
CALL 0x0047cfa4
LAB_001bb740:
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x38]
CALL 0x0047bc92
JMP 0x001bb6ba
LAB_001bb752:
LEA R8,[0x4a93aa]
LAB_001bb759:
LEA RDX,[0x49f221]
LEA RDI,[RBP + -0x28]
MOV ESI,0x2
MOV ECX,0x20
CALL 0x0047cfa4
LAB_001bb773:
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x38]
CALL 0x0047bc92
LAB_001bb780:
JMP 0x001bb6ba
|
/* YogaTest_copy_style_modified_Test::TestBody() */
void YogaTest_copy_style_modified_Test::TestBody(void)
{
bool bVar1;
float fVar2;
int8 uVar3;
ulong uVar4;
int8 uVar5;
default_delete<std::__cxx11::string> *this;
char *pcVar6;
AssertHelper local_68 [8];
internal local_60;
int7 uStack_5f;
string *local_58;
long local_50 [2];
int4 local_40;
int4 uStack_3c;
string *local_38;
int4 local_30;
int4 uStack_2c;
uVar3 = YGNodeNew();
local_40 = 0;
local_30 = YGNodeStyleGetFlexDirection(uVar3);
testing::internal::CmpHelperEQ<YGFlexDirection,YGFlexDirection>
(&local_60,"YGFlexDirectionColumn","YGNodeStyleGetFlexDirection(node0)",
(YGFlexDirection *)&local_40,(YGFlexDirection *)&local_30);
if (local_60 == (internal)0x0) {
/* try { // try from 001bb5d5 to 001bb5dd has its CatchHandler @ 001bb804 */
testing::Message::Message((Message *)&local_40);
if (local_58 == (string *)0x0) {
pcVar6 = "";
}
else {
pcVar6 = *(char **)local_58;
}
/* try { // try from 001bb693 to 001bb6ac has its CatchHandler @ 001bb7f0 */
testing::internal::AssertHelper::AssertHelper
((AssertHelper *)&local_30,2,
"/workspace/llm4binary/github2025/yoga-mod/tests/YGStyleTest.cpp",0x17,pcVar6);
/* try { // try from 001bb6ad to 001bb6b9 has its CatchHandler @ 001bb7e2 */
testing::internal::AssertHelper::operator=((AssertHelper *)&local_30,(Message *)&local_40);
}
else {
if (local_58 != (string *)0x0) {
std::default_delete<std::__cxx11::string>::operator()
((default_delete<std::__cxx11::string> *)&local_58,local_58);
}
uVar4 = YGNodeStyleGetMaxHeight(uVar3);
bVar1 = uVar4 >> 0x20 == 0;
local_40 = CONCAT31(local_40._1_3_,bVar1);
local_38 = (string *)0x0;
if (!bVar1) {
/* try { // try from 001bb5f3 to 001bb5fb has its CatchHandler @ 001bb7dd */
testing::Message::Message((Message *)&local_30);
/* try { // try from 001bb5fc to 001bb621 has its CatchHandler @ 001bb7bd */
this = (default_delete<std::__cxx11::string> *)&local_38;
testing::internal::GetBoolAssertionFailureMessage_abi_cxx11_
(&local_60,(AssertionResult *)&local_40,
"YGNodeStyleGetMaxHeight(node0).unit != YGUnitUndefined","true","false");
/* try { // try from 001bb626 to 001bb63f has its CatchHandler @ 001bb79f */
testing::internal::AssertHelper::AssertHelper
(local_68,2,"/workspace/llm4binary/github2025/yoga-mod/tests/YGStyleTest.cpp",0x18,
CONCAT71(uStack_5f,local_60));
/* try { // try from 001bb640 to 001bb64c has its CatchHandler @ 001bb791 */
testing::internal::AssertHelper::operator=(local_68,(Message *)&local_30);
testing::internal::AssertHelper::~AssertHelper(local_68);
if ((long *)CONCAT71(uStack_5f,local_60) != local_50) {
operator_delete((long *)CONCAT71(uStack_5f,local_60),local_50[0] + 1);
}
if ((long *)CONCAT44(uStack_2c,local_30) != (long *)0x0) {
(**(code **)(*(long *)CONCAT44(uStack_2c,local_30) + 8))();
}
local_58 = local_38;
if (local_38 == (string *)0x0) {
return;
}
goto LAB_001bb6df;
}
uVar5 = YGNodeNew();
YGNodeStyleSetFlexDirection(uVar5,2);
YGNodeStyleSetMaxHeight(DAT_00499014,uVar5);
YGNodeCopyStyle(uVar3,uVar5);
local_40 = 2;
local_30 = YGNodeStyleGetFlexDirection(uVar3);
testing::internal::CmpHelperEQ<YGFlexDirection,YGFlexDirection>
(&local_60,"YGFlexDirectionRow","YGNodeStyleGetFlexDirection(node0)",
(YGFlexDirection *)&local_40,(YGFlexDirection *)&local_30);
if (local_60 == (internal)0x0) {
/* try { // try from 001bb6f1 to 001bb6f9 has its CatchHandler @ 001bb78f */
testing::Message::Message((Message *)&local_40);
if (local_58 == (string *)0x0) {
pcVar6 = "";
}
else {
pcVar6 = *(char **)local_58;
}
/* try { // try from 001bb726 to 001bb73f has its CatchHandler @ 001bb78d */
testing::internal::AssertHelper::AssertHelper
((AssertHelper *)&local_30,2,
"/workspace/llm4binary/github2025/yoga-mod/tests/YGStyleTest.cpp",0x1f,pcVar6);
/* try { // try from 001bb740 to 001bb74c has its CatchHandler @ 001bb78b */
testing::internal::AssertHelper::operator=((AssertHelper *)&local_30,(Message *)&local_40);
}
else {
if (local_58 != (string *)0x0) {
std::default_delete<std::__cxx11::string>::operator()
((default_delete<std::__cxx11::string> *)&local_58,local_58);
}
fVar2 = (float)YGNodeStyleGetMaxHeight(uVar3);
testing::internal::CmpHelperFloatingPointEQ<float>
(&local_60,"10","YGNodeStyleGetMaxHeight(node0).value",DAT_00499014,fVar2);
if (local_60 != (internal)0x0) {
if (local_58 != (string *)0x0) {
std::default_delete<std::__cxx11::string>::operator()
((default_delete<std::__cxx11::string> *)&local_58,local_58);
}
YGNodeFree(uVar3);
YGNodeFree(uVar5);
return;
}
/* try { // try from 001bb708 to 001bb710 has its CatchHandler @ 001bb789 */
testing::Message::Message((Message *)&local_40);
if (local_58 == (string *)0x0) {
pcVar6 = "";
}
else {
pcVar6 = *(char **)local_58;
}
/* try { // try from 001bb759 to 001bb772 has its CatchHandler @ 001bb787 */
testing::internal::AssertHelper::AssertHelper
((AssertHelper *)&local_30,2,
"/workspace/llm4binary/github2025/yoga-mod/tests/YGStyleTest.cpp",0x20,pcVar6);
/* try { // try from 001bb773 to 001bb77f has its CatchHandler @ 001bb785 */
testing::internal::AssertHelper::operator=((AssertHelper *)&local_30,(Message *)&local_40);
}
}
testing::internal::AssertHelper::~AssertHelper((AssertHelper *)&local_30);
if ((long *)CONCAT44(uStack_3c,local_40) != (long *)0x0) {
(**(code **)(*(long *)CONCAT44(uStack_3c,local_40) + 8))();
}
if (local_58 == (string *)0x0) {
return;
}
this = (default_delete<std::__cxx11::string> *)&local_58;
LAB_001bb6df:
std::default_delete<std::__cxx11::string>::operator()(this,local_58);
return;
}
| |
26,011 | my_strndup | eloqsql/mysys/my_malloc.c | char *my_strndup(PSI_memory_key key, const char *from, size_t length, myf my_flags)
{
char *ptr;
DBUG_ENTER("my_strndup");
if ((ptr= (char*) my_malloc(key, length+1, my_flags)))
{
memcpy(ptr, from, length);
ptr[length]= 0;
}
DBUG_RETURN(ptr);
} | O0 | c | my_strndup:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq -0x20(%rbp), %rdx
callq 0x839a0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x83ee2
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x282b0
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x83ee4
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_strndup:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov edi, [rbp+var_4]
mov rsi, [rbp+var_18]
add rsi, 1
mov rdx, [rbp+var_20]
call my_malloc
mov [rbp+var_28], rax
cmp rax, 0
jz short loc_83EE2
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call _memcpy
mov rax, [rbp+var_28]
mov rcx, [rbp+var_18]
mov byte ptr [rax+rcx], 0
loc_83EE2:
jmp short $+2
loc_83EE4:
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
add rsp, 30h
pop rbp
retn
| long long my_strndup(unsigned int a1, long long a2, long long a3, int a4)
{
long long v5; // [rsp+8h] [rbp-28h]
v5 = my_malloc(a1, (const char *)(a3 + 1), a4);
if ( v5 )
{
memcpy(v5, a2, a3);
*(_BYTE *)(v5 + a3) = 0;
}
return v5;
}
| my_strndup:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x1
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001839a0
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JZ 0x00183ee2
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001282b0
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_00183ee2:
JMP 0x00183ee4
LAB_00183ee4:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x30
POP RBP
RET
|
void * my_strndup(int4 param_1,void *param_2,size_t param_3,int8 param_4)
{
void *__dest;
__dest = (void *)my_malloc(param_1,param_3 + 1,param_4);
if (__dest != (void *)0x0) {
memcpy(__dest,param_2,param_3);
*(int1 *)((long)__dest + param_3) = 0;
}
return __dest;
}
| |
26,012 | my_b_write | eloqsql/mysys/mf_iocache.c | int _my_b_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
size_t rest_length;
int res;
/* Always use my_b_flush_io_cache() to flush write_buffer! */
DBUG_ASSERT(Buffer != info->write_buffer);
if (info->pos_in_file + info->buffer_length > info->end_of_file)
{
my_errno=errno=EFBIG;
return info->error = -1;
}
rest_length= (size_t) (info->write_end - info->write_pos);
DBUG_ASSERT(Count >= rest_length);
memcpy(info->write_pos, Buffer, (size_t) rest_length);
Buffer+=rest_length;
Count-=rest_length;
info->write_pos+=rest_length;
if (my_b_flush_io_cache(info, 1))
return 1;
if (Count)
{
my_off_t old_pos_in_file= info->pos_in_file;
res= info->write_function(info, Buffer, Count);
Count-= (size_t) (info->pos_in_file - old_pos_in_file);
Buffer+= info->pos_in_file - old_pos_in_file;
}
else
res= 0;
if (!res && Count)
{
memcpy(info->write_pos, Buffer, Count);
info->write_pos+= Count;
}
return res;
} | O0 | c | my_b_write:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0xe08c6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq 0xe8(%rcx), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0xe0912
callq 0x2a760
movl $0x1b, (%rax)
callq 0xf5a70
movl $0x1b, (%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe0a22
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xe092b
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2a090
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xe0590
cmpl $0x0, %eax
je 0xe098a
movl $0x1, -0x4(%rbp)
jmp 0xe0a22
cmpq $0x0, -0x20(%rbp)
je 0xe09e3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
subq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq -0x38(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xe09ea
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xe0a1c
cmpq $0x0, -0x20(%rbp)
je 0xe0a1c
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a090
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _my_b_write:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
jmp short $+2
loc_E08C6:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
add rax, [rcx+0E8h]
mov rcx, [rbp+var_10]
cmp rax, [rcx+8]
jbe short loc_E0912
call ___errno_location
mov dword ptr [rax], 1Bh
call _my_thread_var
mov dword ptr [rax], 1Bh
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_E0A22
loc_E0912:
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+40h]
sub rax, rcx
mov [rbp+var_28], rax
jmp short $+2
loc_E092B:
mov rax, [rbp+var_10]
mov rdi, [rax+40h]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_28]
call _memcpy
mov rax, [rbp+var_28]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rcx, [rbp+var_28]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
add rcx, [rax+40h]
mov [rax+40h], rcx
mov rdi, [rbp+var_10]
mov esi, 1
call my_b_flush_io_cache
cmp eax, 0
jz short loc_E098A
mov [rbp+var_4], 1
jmp loc_E0A22
loc_E098A:
cmp [rbp+var_20], 0
jz short loc_E09E3
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov rax, [rax+0A8h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call rax
mov [rbp+var_2C], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
sub rcx, [rbp+var_38]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax]
sub rax, [rbp+var_38]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
jmp short loc_E09EA
loc_E09E3:
mov [rbp+var_2C], 0
loc_E09EA:
cmp [rbp+var_2C], 0
jnz short loc_E0A1C
cmp [rbp+var_20], 0
jz short loc_E0A1C
mov rax, [rbp+var_10]
mov rdi, [rax+40h]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _memcpy
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
add rcx, [rax+40h]
mov [rax+40h], rcx
loc_E0A1C:
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
loc_E0A22:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long my_b_write(long long a1, const char *a2, long long a3)
{
long long v4; // [rsp+8h] [rbp-38h]
unsigned int v5; // [rsp+14h] [rbp-2Ch]
long long v6; // [rsp+18h] [rbp-28h]
long long v8; // [rsp+20h] [rbp-20h]
const char *v9; // [rsp+28h] [rbp-18h]
if ( *(_QWORD *)(a1 + 232) + *(_QWORD *)a1 <= *(_QWORD *)(a1 + 8) )
{
v6 = *(_QWORD *)(a1 + 72) - *(_QWORD *)(a1 + 64);
memcpy(*(_QWORD *)(a1 + 64), a2, v6);
v9 = &a2[v6];
v8 = a3 - v6;
*(_QWORD *)(a1 + 64) += v6;
if ( (unsigned int)my_b_flush_io_cache(a1, 1) )
{
return 1;
}
else
{
if ( v8 )
{
v4 = *(_QWORD *)a1;
v5 = (*(long long ( **)(long long, const char *, long long))(a1 + 168))(a1, v9, v8);
v8 -= *(_QWORD *)a1 - v4;
v9 += *(_QWORD *)a1 - v4;
}
else
{
v5 = 0;
}
if ( !v5 && v8 )
{
memcpy(*(_QWORD *)(a1 + 64), v9, v8);
*(_QWORD *)(a1 + 64) += v8;
}
return v5;
}
}
else
{
*(_DWORD *)__errno_location() = 27;
*(_DWORD *)my_thread_var(a1, a2) = 27;
*(_DWORD *)(a1 + 228) = -1;
return (unsigned int)-1;
}
}
| _my_b_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
JMP 0x001e08c6
LAB_001e08c6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RCX + 0xe8]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x8]
JBE 0x001e0912
CALL 0x0012a760
MOV dword ptr [RAX],0x1b
CALL 0x001f5a70
MOV dword ptr [RAX],0x1b
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001e0a22
LAB_001e0912:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x40]
SUB RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001e092b
LAB_001e092b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x40]
MOV qword ptr [RAX + 0x40],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x1
CALL 0x001e0590
CMP EAX,0x0
JZ 0x001e098a
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e0a22
LAB_001e098a:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e09e3
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xa8]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL RAX
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
SUB RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
SUB RAX,qword ptr [RBP + -0x38]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001e09ea
LAB_001e09e3:
MOV dword ptr [RBP + -0x2c],0x0
LAB_001e09ea:
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x001e0a1c
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e0a1c
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0012a090
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x40]
MOV qword ptr [RAX + 0x40],RCX
LAB_001e0a1c:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
LAB_001e0a22:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int _my_b_write(long *param_1,void *param_2,long param_3)
{
long lVar1;
int iVar2;
int *piVar3;
int4 *puVar4;
size_t __n;
int local_34;
size_t local_28;
void *local_20;
int local_c;
if ((ulong)param_1[1] < (ulong)(*param_1 + param_1[0x1d])) {
piVar3 = __errno_location();
*piVar3 = 0x1b;
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x1b;
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
local_c = -1;
}
else {
__n = param_1[9] - param_1[8];
memcpy((void *)param_1[8],param_2,__n);
local_20 = (void *)(__n + (long)param_2);
param_3 = param_3 - __n;
param_1[8] = __n + param_1[8];
iVar2 = my_b_flush_io_cache(param_1,1);
if (iVar2 == 0) {
if (param_3 == 0) {
local_34 = 0;
local_28 = 0;
}
else {
lVar1 = *param_1;
local_34 = (*(code *)param_1[0x15])(param_1,local_20,param_3);
local_28 = param_3 - (*param_1 - lVar1);
local_20 = (void *)((*param_1 - lVar1) + (long)local_20);
}
if ((local_34 == 0) && (local_28 != 0)) {
memcpy((void *)param_1[8],local_20,local_28);
param_1[8] = local_28 + param_1[8];
}
local_c = local_34;
}
else {
local_c = 1;
}
}
return local_c;
}
| |
26,013 | my_b_write | eloqsql/mysys/mf_iocache.c | int _my_b_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
size_t rest_length;
int res;
/* Always use my_b_flush_io_cache() to flush write_buffer! */
DBUG_ASSERT(Buffer != info->write_buffer);
if (info->pos_in_file + info->buffer_length > info->end_of_file)
{
my_errno=errno=EFBIG;
return info->error = -1;
}
rest_length= (size_t) (info->write_end - info->write_pos);
DBUG_ASSERT(Count >= rest_length);
memcpy(info->write_pos, Buffer, (size_t) rest_length);
Buffer+=rest_length;
Count-=rest_length;
info->write_pos+=rest_length;
if (my_b_flush_io_cache(info, 1))
return 1;
if (Count)
{
my_off_t old_pos_in_file= info->pos_in_file;
res= info->write_function(info, Buffer, Count);
Count-= (size_t) (info->pos_in_file - old_pos_in_file);
Buffer+= info->pos_in_file - old_pos_in_file;
}
else
res= 0;
if (!res && Count)
{
memcpy(info->write_pos, Buffer, Count);
info->write_pos+= Count;
}
return res;
} | O3 | c | my_b_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe8(%rdi), %rax
addq (%rdi), %rax
cmpq 0x8(%rdi), %rax
jbe 0x953bf
callq 0x297b0
movl $0x1b, %r14d
movl %r14d, (%rax)
callq 0xa1672
movl %r14d, (%rax)
movl $0xffffffff, 0xe4(%rbx) # imm = 0xFFFFFFFF
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
jmp 0x95448
movq %rdx, %r14
movq %rsi, %r15
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %r13
subq %rdi, %r13
movq %r13, %rdx
callq 0x29080
addq %r13, 0x40(%rbx)
movl $0x1, %r12d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x950b1
testl %eax, %eax
jne 0x95448
xorl %r12d, %r12d
cmpq %r13, %r14
je 0x95448
addq %r13, %r15
subq %r13, %r14
movq (%rbx), %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0xa8(%rbx)
movl %eax, %r12d
movq (%rbx), %rax
subq %r13, %rax
testl %r12d, %r12d
sete %cl
subq %rax, %r14
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x95448
addq %rax, %r15
movq 0x40(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x29080
addq %r14, 0x40(%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _my_b_write:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov rax, [rdi+0E8h]
add rax, [rdi]
cmp rax, [rdi+8]
jbe short loc_953BF
call ___errno_location
mov r14d, 1Bh
mov [rax], r14d
call _my_thread_var
mov [rax], r14d
mov dword ptr [rbx+0E4h], 0FFFFFFFFh
mov r12d, 0FFFFFFFFh
jmp loc_95448
loc_953BF:
mov r14, rdx
mov r15, rsi
mov rdi, [rbx+40h]
mov r13, [rbx+48h]
sub r13, rdi
mov rdx, r13
call _memcpy
add [rbx+40h], r13
mov r12d, 1
mov rdi, rbx
mov esi, 1
call my_b_flush_io_cache
test eax, eax
jnz short loc_95448
xor r12d, r12d
cmp r14, r13
jz short loc_95448
add r15, r13
sub r14, r13
mov r13, [rbx]
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call qword ptr [rbx+0A8h]
mov r12d, eax
mov rax, [rbx]
sub rax, r13
test r12d, r12d
setz cl
sub r14, rax
setnz dl
and dl, cl
cmp dl, 1
jnz short loc_95448
add r15, rax
mov rdi, [rbx+40h]
mov rsi, r15
mov rdx, r14
call _memcpy
add [rbx+40h], r14
xor r12d, r12d
loc_95448:
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_b_write(long long a1, const char *a2, long long a3)
{
unsigned int v4; // r12d
long long v6; // rdi
long long v7; // r13
const char *v8; // r15
long long v9; // r14
long long v10; // r13
long long v11; // rax
long long v12; // r14
if ( *(_QWORD *)a1 + *(_QWORD *)(a1 + 232) <= *(_QWORD *)(a1 + 8) )
{
v6 = *(_QWORD *)(a1 + 64);
v7 = *(_QWORD *)(a1 + 72) - v6;
memcpy(v6, a2, v7);
*(_QWORD *)(a1 + 64) += v7;
v4 = 1;
if ( !(unsigned int)my_b_flush_io_cache((long long *)a1, 1) )
{
v4 = 0;
if ( a3 != v7 )
{
v8 = &a2[v7];
v9 = a3 - v7;
v10 = *(_QWORD *)a1;
v4 = (*(long long ( **)(long long, const char *, long long))(a1 + 168))(a1, v8, v9);
v11 = *(_QWORD *)a1 - v10;
v12 = v9 - v11;
if ( v4 == 0 && v12 != 0 )
{
memcpy(*(_QWORD *)(a1 + 64), &v8[v11], v12);
*(_QWORD *)(a1 + 64) += v12;
return 0;
}
}
}
}
else
{
*(_DWORD *)__errno_location(a1) = 27;
*(_DWORD *)my_thread_var(a1, a2) = 27;
*(_DWORD *)(a1 + 228) = -1;
return (unsigned int)-1;
}
return v4;
}
| _my_b_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0xe8]
ADD RAX,qword ptr [RDI]
CMP RAX,qword ptr [RDI + 0x8]
JBE 0x001953bf
CALL 0x001297b0
MOV R14D,0x1b
MOV dword ptr [RAX],R14D
CALL 0x001a1672
MOV dword ptr [RAX],R14D
MOV dword ptr [RBX + 0xe4],0xffffffff
MOV R12D,0xffffffff
JMP 0x00195448
LAB_001953bf:
MOV R14,RDX
MOV R15,RSI
MOV RDI,qword ptr [RBX + 0x40]
MOV R13,qword ptr [RBX + 0x48]
SUB R13,RDI
MOV RDX,R13
CALL 0x00129080
ADD qword ptr [RBX + 0x40],R13
MOV R12D,0x1
MOV RDI,RBX
MOV ESI,0x1
CALL 0x001950b1
TEST EAX,EAX
JNZ 0x00195448
XOR R12D,R12D
CMP R14,R13
JZ 0x00195448
ADD R15,R13
SUB R14,R13
MOV R13,qword ptr [RBX]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL qword ptr [RBX + 0xa8]
MOV R12D,EAX
MOV RAX,qword ptr [RBX]
SUB RAX,R13
TEST R12D,R12D
SETZ CL
SUB R14,RAX
SETNZ DL
AND DL,CL
CMP DL,0x1
JNZ 0x00195448
ADD R15,RAX
MOV RDI,qword ptr [RBX + 0x40]
MOV RSI,R15
MOV RDX,R14
CALL 0x00129080
ADD qword ptr [RBX + 0x40],R14
XOR R12D,R12D
LAB_00195448:
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int _my_b_write(long *param_1,void *param_2,size_t param_3)
{
long lVar1;
int iVar2;
int iVar3;
int *piVar4;
int4 *puVar5;
size_t __n;
size_t __n_00;
if ((ulong)param_1[1] < (ulong)(param_1[0x1d] + *param_1)) {
piVar4 = __errno_location();
*piVar4 = 0x1b;
puVar5 = (int4 *)_my_thread_var();
*puVar5 = 0x1b;
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
iVar3 = -1;
}
else {
__n = param_1[9] - param_1[8];
memcpy((void *)param_1[8],param_2,__n);
param_1[8] = param_1[8] + __n;
iVar3 = 1;
iVar2 = my_b_flush_io_cache(param_1,1);
if ((iVar2 == 0) && (iVar3 = 0, param_3 != __n)) {
lVar1 = *param_1;
iVar3 = (*(code *)param_1[0x15])(param_1,(long)param_2 + __n,param_3 - __n);
__n_00 = (param_3 - __n) - (*param_1 - lVar1);
if (__n_00 != 0 && iVar3 == 0) {
memcpy((void *)param_1[8],(void *)((long)param_2 + __n + (*param_1 - lVar1)),__n_00);
param_1[8] = param_1[8] + __n_00;
iVar3 = 0;
}
}
}
return iVar3;
}
| |
26,014 | minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!left) throw std::runtime_error("BinaryOpExpr.left is null");
if (!right) throw std::runtime_error("BinaryOpExpr.right is null");
auto l = left->evaluate(context);
auto do_eval = [&](const Value & l) -> Value {
if (op == Op::Is || op == Op::IsNot) {
auto t = dynamic_cast<VariableExpr*>(right.get());
if (!t) throw std::runtime_error("Right side of 'is' operator must be a variable");
auto eval = [&]() {
const auto & name = t->get_name();
if (name == "none") return l.is_null();
if (name == "boolean") return l.is_boolean();
if (name == "integer") return l.is_number_integer();
if (name == "float") return l.is_number_float();
if (name == "number") return l.is_number();
if (name == "string") return l.is_string();
if (name == "mapping") return l.is_object();
if (name == "iterable") return l.is_iterable();
if (name == "sequence") return l.is_array();
if (name == "defined") return !l.is_null();
throw std::runtime_error("Unknown type for 'is' operator: " + name);
};
auto value = eval();
return Value(op == Op::Is ? value : !value);
}
if (op == Op::And) {
if (!l.to_bool()) return Value(false);
return right->evaluate(context).to_bool();
} else if (op == Op::Or) {
if (l.to_bool()) return l;
return right->evaluate(context);
}
auto r = right->evaluate(context);
switch (op) {
case Op::StrConcat: return l.to_str() + r.to_str();
case Op::Add: return l + r;
case Op::Sub: return l - r;
case Op::Mul: return l * r;
case Op::Div: return l / r;
case Op::MulMul: return std::pow(l.get<double>(), r.get<double>());
case Op::DivDiv: return l.get<int64_t>() / r.get<int64_t>();
case Op::Mod: return l.get<int64_t>() % r.get<int64_t>();
case Op::Eq: return l == r;
case Op::Ne: return l != r;
case Op::Lt: return l < r;
case Op::Gt: return l > r;
case Op::Le: return l <= r;
case Op::Ge: return l >= r;
case Op::In: return (r.is_array() || r.is_object()) && r.contains(l);
case Op::NotIn: return !(r.is_array() && r.contains(l));
default: break;
}
throw std::runtime_error("Unknown binary operator");
};
if (l.is_callable()) {
return Value::callable([l, do_eval](const std::shared_ptr<Context> & context, ArgumentsValue & args) {
auto ll = l.call(context, args);
return do_eval(ll); //args[0].second);
});
} else {
return do_eval(l);
}
} | O3 | cpp | minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r15
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x56599
cmpq $0x0, 0x30(%r15)
je 0x565b7
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x3cabe
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
cmpq $0x0, 0x30(%r12)
je 0x564e5
leaq 0x88(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4e20c
movups 0x8(%rsp), %xmm0
leaq 0x88(%rsp), %rsi
movups %xmm0, 0x50(%rsi)
leaq 0x18(%rsp), %rdi
callq 0x5675c
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x566f0
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x56475
leaq 0x18(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0xc8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3ce3c
movq %r14, %rdi
callq 0x49a2a
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x5649d
callq 0x2ef66
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x564af
callq 0x2ef66
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x564c1
callq 0x2ef66
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x5650e
movq 0x85ac3(%rip), %rax # 0xdbf98
cmpb $0x0, (%rax)
je 0x564f9
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x56503
leaq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x56846
jmp 0x5650e
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x5650e
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x78(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3ce3c
movq %r14, %rdi
callq 0x49a2a
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x56533
callq 0x2ef66
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x56542
callq 0x2ef66
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x56551
callq 0x2ef66
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x56587
movq 0x85a36(%rip), %rax # 0xdbf98
cmpb $0x0, (%rax)
je 0x56572
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x5657c
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x56587
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x18350
movq %rax, %r14
leaq 0x54f66(%rip), %rsi # 0xab513
movq %rax, %rdi
callq 0x18260
jmp 0x565d3
movl $0x10, %edi
callq 0x18350
movq %rax, %r14
leaq 0x54f62(%rip), %rsi # 0xab52d
movq %rax, %rdi
callq 0x18260
movq 0x85a16(%rip), %rsi # 0xdbff0
movq 0x8598f(%rip), %rdx # 0xdbf70
movq %r14, %rdi
callq 0x18b30
jmp 0x56634
jmp 0x5661a
jmp 0x565ef
movq %rax, %rbx
movq %r14, %rdi
callq 0x184f0
jmp 0x56641
movq %rax, %rbx
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x56625
leaq 0x18(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x56625
movq %rax, %rdi
callq 0x29f9b
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x567ba
jmp 0x56637
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3cdb0
movq %rbx, %rdi
callq 0x18ba0
nop
| _ZNK5minja12BinaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push r15
push r14
push r12
push rbx
sub rsp, 0E8h
mov r15, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz loc_56599
cmp qword ptr [r15+30h], 0
jz loc_565B7
mov r14, rdx
mov rbx, rdi
lea r12, [rsp+108h+var_D0]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov qword ptr [rsp+108h+var_100], r15
mov qword ptr [rsp+108h+var_100+8], r14
cmp qword ptr [r12+30h], 0
jz loc_564E5
lea rdi, [rsp+108h+var_80]; this
lea rsi, [rsp+108h+var_D0]; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
movups xmm0, [rsp+108h+var_100]
lea rsi, [rsp+108h+var_80]
movups xmmword ptr [rsi+50h], xmm0
lea rdi, [rsp+108h+var_F0]
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEEC2IZNKS0_12BinaryOpExpr11do_evaluateES6_EUlS6_S8_E_vEEOT_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::function<minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1},void>(minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1} &&)
lea rsi, [rsp+108h+var_F0]
mov rdi, rbx
call _ZN5minja5Value8callableERKSt8functionIFS0_RKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueEEE; minja::Value::callable(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)> const&)
mov rax, [rsp+108h+var_E0]
test rax, rax
jz short loc_56475
lea rdi, [rsp+108h+var_F0]
mov rsi, rdi
mov edx, 3
call rax
loc_56475:
lea r14, [rsp+108h+var_40]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_5649D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5649D:
mov rdi, [rsp+108h+var_58]
test rdi, rdi
jz short loc_564AF
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_564AF:
mov rdi, [rsp+108h+var_68]
test rdi, rdi
jz short loc_564C1
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_564C1:
mov rdi, [rsp+108h+var_78]
test rdi, rdi
jz short loc_5650E
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_564F9
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_56503
loc_564E5:
lea rsi, [rsp+108h+var_100]
lea rdx, [rsp+108h+var_D0]
mov rdi, rbx; this
call _ZZNK5minja12BinaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEEENKUlRKNS_5ValueEE_clES8_; minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value const&)#1}::operator()(minja::Value const&)
jmp short loc_5650E
loc_564F9:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_56503:
cmp eax, 1
jnz short loc_5650E
mov rax, [rdi]
call qword ptr [rax+18h]
loc_5650E:
lea r14, [rsp+108h+var_90]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_56533
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_56533:
mov rdi, [rsp+108h+var_A8]
test rdi, rdi
jz short loc_56542
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_56542:
mov rdi, [rsp+108h+var_B8]
test rdi, rdi
jz short loc_56551
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_56551:
mov rdi, [rsp+108h+var_C8]
test rdi, rdi
jz short loc_56587
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_56572
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_5657C
loc_56572:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_5657C:
cmp eax, 1
jnz short loc_56587
mov rax, [rdi]
call qword ptr [rax+18h]
loc_56587:
mov rax, rbx
add rsp, 0E8h
pop rbx
pop r12
pop r14
pop r15
retn
loc_56599:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aBinaryopexprLe; "BinaryOpExpr.left is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_565D3
loc_565B7:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aBinaryopexprRi; "BinaryOpExpr.right is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_565D3:
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_56634
jmp short loc_5661A
jmp short $+2
loc_565EF:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_56641
mov rbx, rax
mov rax, [rsp+108h+var_E0]
test rax, rax
jz short loc_56625
lea rdi, [rsp+108h+var_F0]
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_56625
loc_5661A:
mov rdi, rax
call __clang_call_terminate
mov rbx, rax
loc_56625:
lea rdi, [rsp+108h+var_80]
call _ZZNK5minja12BinaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEEENUlS5_RNS_14ArgumentsValueEE_D2Ev; minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1}::~ArgumentsValue()
jmp short loc_56637
loc_56634:
mov rbx, rax
loc_56637:
lea rdi, [rsp+108h+var_D0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_56641:
mov rdi, rbx
call __Unwind_Resume
| minja::Value * minja::BinaryOpExpr::do_evaluate(minja::Value *this, long long a2, long long a3)
{
void (***v4)(void); // rsi
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
long long v11; // rdi
signed __int32 v12; // eax
long long v13; // rdi
signed __int32 v14; // eax
std::runtime_error *exception; // r14
__int128 v17; // [rsp+8h] [rbp-100h]
_BYTE v18[16]; // [rsp+18h] [rbp-F0h] BYREF
void ( *v19)(_BYTE *, _BYTE *, long long); // [rsp+28h] [rbp-E0h]
_BYTE v20[8]; // [rsp+38h] [rbp-D0h] BYREF
long long v21; // [rsp+40h] [rbp-C8h]
volatile signed __int32 *v22; // [rsp+50h] [rbp-B8h]
volatile signed __int32 *v23; // [rsp+60h] [rbp-A8h]
long long v24; // [rsp+68h] [rbp-A0h]
volatile signed __int32 *v25; // [rsp+70h] [rbp-98h]
void **v26[2]; // [rsp+78h] [rbp-90h] BYREF
_BYTE v27[8]; // [rsp+88h] [rbp-80h] BYREF
long long v28; // [rsp+90h] [rbp-78h]
volatile signed __int32 *v29; // [rsp+A0h] [rbp-68h]
volatile signed __int32 *v30; // [rsp+B0h] [rbp-58h]
volatile signed __int32 *v31; // [rsp+C0h] [rbp-48h]
void **v32[2]; // [rsp+C8h] [rbp-40h] BYREF
__int128 v33; // [rsp+D8h] [rbp-30h]
v4 = *(void (****)(void))(a2 + 32);
if ( !v4 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "BinaryOpExpr.left is null");
goto LABEL_34;
}
if ( !*(_QWORD *)(a2 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "BinaryOpExpr.right is null");
LABEL_34:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v20, v4);
*(_QWORD *)&v17 = a2;
*((_QWORD *)&v17 + 1) = a3;
if ( v24 )
{
minja::Value::Value((minja::Value *)v27, (const minja::Value *)v20);
v33 = v17;
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::function<minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1},void>(v18);
minja::Value::callable((_DWORD)this, (unsigned int)v18, v7, v8, v9, v10);
if ( v19 )
v19(v18, v18, 3LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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 *)v32);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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(v32);
if ( v31 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v31);
if ( v30 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v30);
if ( v29 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v29);
v11 = v28;
if ( v28 )
{
if ( _libc_single_threaded )
{
v12 = *(_DWORD *)(v28 + 12);
*(_DWORD *)(v28 + 12) = v12 - 1;
}
else
{
v12 = _InterlockedExchangeAdd((volatile signed __int32 *)(v28 + 12), 0xFFFFFFFF);
}
if ( v12 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v11 + 24LL))(v11, 0LL);
}
}
else
{
minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)const::{lambda(minja::Value const&)#1}::operator()(this);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v26);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v26);
if ( v25 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v25);
if ( v23 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v23);
if ( v22 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v22);
v13 = v21;
if ( v21 )
{
if ( _libc_single_threaded )
{
v14 = *(_DWORD *)(v21 + 12);
*(_DWORD *)(v21 + 12) = v14 - 1;
}
else
{
v14 = _InterlockedExchangeAdd((volatile signed __int32 *)(v21 + 12), 0xFFFFFFFF);
}
if ( v14 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v13 + 24LL))(v13, 0LL);
}
return this;
}
| do_evaluate:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV R15,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x00156599
CMP qword ptr [R15 + 0x30],0x0
JZ 0x001565b7
MOV R14,RDX
MOV RBX,RDI
LEA R12,[RSP + 0x38]
MOV RDI,R12
CALL 0x0013cabe
MOV qword ptr [RSP + 0x8],R15
MOV qword ptr [RSP + 0x10],R14
CMP qword ptr [R12 + 0x30],0x0
JZ 0x001564e5
LAB_00156422:
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x38]
CALL 0x0014e20c
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x88]
MOVUPS xmmword ptr [RSI + 0x50],XMM0
LAB_00156445:
LEA RDI,[RSP + 0x18]
CALL 0x0015675c
LAB_0015644f:
LEA RSI,[RSP + 0x18]
MOV RDI,RBX
CALL 0x001566f0
MOV RAX,qword ptr [RSP + 0x28]
TEST RAX,RAX
JZ 0x00156475
LAB_00156466:
LEA RDI,[RSP + 0x18]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_00156475:
LEA R14,[RSP + 0xc8]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013ce3c
MOV RDI,R14
CALL 0x00149a2a
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x0015649d
CALL 0x0012ef66
LAB_0015649d:
MOV RDI,qword ptr [RSP + 0xb0]
TEST RDI,RDI
JZ 0x001564af
CALL 0x0012ef66
LAB_001564af:
MOV RDI,qword ptr [RSP + 0xa0]
TEST RDI,RDI
JZ 0x001564c1
CALL 0x0012ef66
LAB_001564c1:
MOV RDI,qword ptr [RSP + 0x90]
TEST RDI,RDI
JZ 0x0015650e
MOV RAX,qword ptr [0x001dbf98]
CMP byte ptr [RAX],0x0
JZ 0x001564f9
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00156503
LAB_001564e5:
LEA RSI,[RSP + 0x8]
LEA RDX,[RSP + 0x38]
MOV RDI,RBX
CALL 0x00156846
LAB_001564f7:
JMP 0x0015650e
LAB_001564f9:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00156503:
CMP EAX,0x1
JNZ 0x0015650e
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0015650e:
LEA R14,[RSP + 0x78]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013ce3c
MOV RDI,R14
CALL 0x00149a2a
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x00156533
CALL 0x0012ef66
LAB_00156533:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x00156542
CALL 0x0012ef66
LAB_00156542:
MOV RDI,qword ptr [RSP + 0x50]
TEST RDI,RDI
JZ 0x00156551
CALL 0x0012ef66
LAB_00156551:
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x00156587
MOV RAX,qword ptr [0x001dbf98]
CMP byte ptr [RAX],0x0
JZ 0x00156572
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0015657c
LAB_00156572:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0015657c:
CMP EAX,0x1
JNZ 0x00156587
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00156587:
MOV RAX,RBX
ADD RSP,0xe8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00156599:
MOV EDI,0x10
CALL 0x00118350
MOV R14,RAX
LAB_001565a6:
LEA RSI,[0x1ab513]
MOV RDI,RAX
CALL 0x00118260
LAB_001565b5:
JMP 0x001565d3
LAB_001565b7:
MOV EDI,0x10
CALL 0x00118350
MOV R14,RAX
LAB_001565c4:
LEA RSI,[0x1ab52d]
MOV RDI,RAX
CALL 0x00118260
LAB_001565d3:
MOV RSI,qword ptr [0x001dbff0]
MOV RDX,qword ptr [0x001dbf70]
MOV RDI,R14
CALL 0x00118b30
|
/* minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
shared_ptr * minja::BinaryOpExpr::do_evaluate(shared_ptr *param_1)
{
int *piVar1;
int iVar2;
runtime_error *this;
int8 in_RDX;
long in_RSI;
long local_100;
int8 uStack_f8;
_lambda_std__shared_ptr<minja::Context>_const__minja__ArgumentsValue___1_ local_f0 [16];
code *local_e0;
Expression local_d0 [8];
long *local_c8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_b8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_a8;
long local_a0;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_98;
data local_90 [16];
Value local_80 [8];
long *local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
data local_40 [16];
long local_30;
int8 uStack_28;
if (*(shared_ptr **)(in_RSI + 0x20) == (shared_ptr *)0x0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001565a6 to 001565b4 has its CatchHandler @ 001565ef */
std::runtime_error::runtime_error(this,"BinaryOpExpr.left is null");
}
else {
if (*(long *)(in_RSI + 0x30) != 0) {
Expression::evaluate(local_d0,*(shared_ptr **)(in_RSI + 0x20));
if (local_a0 == 0) {
/* try { // try from 001564e5 to 001564f6 has its CatchHandler @ 001565e9 */
const::{lambda(minja::Value_const&)#1}::operator()
((_lambda_minja__Value_const___1_ *)param_1,(Value *)&local_100);
}
else {
/* try { // try from 00156422 to 00156433 has its CatchHandler @ 00156634 */
local_100 = in_RSI;
uStack_f8 = in_RDX;
Value::Value(local_80,(Value *)local_d0);
local_30 = local_100;
uStack_28 = uStack_f8;
/* try { // try from 00156445 to 0015644e has its CatchHandler @ 00156622 */
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>::
function<minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context>const&)const::_lambda(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)_1_,void>
(local_f0);
/* try { // try from 0015644f to 0015645b has its CatchHandler @ 001565fc */
Value::callable((Value *)param_1,local_f0);
if (local_e0 != (code *)0x0) {
/* try { // try from 00156466 to 00156474 has its CatchHandler @ 001565eb */
(*local_e0)(local_f0,local_f0,3);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_001dbf98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_90,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_90);
if (local_98 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_98);
}
if (local_a8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_a8);
}
if (local_b8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_b8);
}
if (local_c8 != (long *)0x0) {
if (*PTR___libc_single_threaded_001dbf98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_c8 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_c8 + 0xc);
*(int *)((long)local_c8 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_c8 + 0x18))();
}
}
return param_1;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001565c4 to 001565d2 has its CatchHandler @ 001565ed */
std::runtime_error::runtime_error(this,"BinaryOpExpr.right is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001dbff0,PTR__runtime_error_001dbf70);
}
| |
26,015 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(int) | llama.cpp/common/json.hpp | inline cached_power get_cached_power_for_binary_exponent(int e)
{
// Now
//
// alpha <= e_c + e + q <= gamma (1)
// ==> f_c * 2^alpha <= c * 2^e * 2^q
//
// and since the c's are normalized, 2^(q-1) <= f_c,
//
// ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
// ==> 2^(alpha - e - 1) <= c
//
// If c were an exact power of ten, i.e. c = 10^k, one may determine k as
//
// k = ceil( log_10( 2^(alpha - e - 1) ) )
// = ceil( (alpha - e - 1) * log_10(2) )
//
// From the paper:
// "In theory the result of the procedure could be wrong since c is rounded,
// and the computation itself is approximated [...]. In practice, however,
// this simple function is sufficient."
//
// For IEEE double precision floating-point numbers converted into
// normalized diyfp's w = f * 2^e, with q = 64,
//
// e >= -1022 (min IEEE exponent)
// -52 (p - 1)
// -52 (p - 1, possibly normalize denormal IEEE numbers)
// -11 (normalize the diyfp)
// = -1137
//
// and
//
// e <= +1023 (max IEEE exponent)
// -52 (p - 1)
// -11 (normalize the diyfp)
// = 960
//
// This binary exponent range [-1137,960] results in a decimal exponent
// range [-307,324]. One does not need to store a cached power for each
// k in this range. For each such k it suffices to find a cached power
// such that the exponent of the product lies in [alpha,gamma].
// This implies that the difference of the decimal exponents of adjacent
// table entries must be less than or equal to
//
// floor( (gamma - alpha) * log_10(2) ) = 8.
//
// (A smaller distance gamma-alpha would require a larger table.)
// NB:
// Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
constexpr int kCachedPowersMinDecExp = -300;
constexpr int kCachedPowersDecStep = 8;
static constexpr std::array<cached_power, 79> kCachedPowers =
{
{
{ 0xAB70FE17C79AC6CA, -1060, -300 },
{ 0xFF77B1FCBEBCDC4F, -1034, -292 },
{ 0xBE5691EF416BD60C, -1007, -284 },
{ 0x8DD01FAD907FFC3C, -980, -276 },
{ 0xD3515C2831559A83, -954, -268 },
{ 0x9D71AC8FADA6C9B5, -927, -260 },
{ 0xEA9C227723EE8BCB, -901, -252 },
{ 0xAECC49914078536D, -874, -244 },
{ 0x823C12795DB6CE57, -847, -236 },
{ 0xC21094364DFB5637, -821, -228 },
{ 0x9096EA6F3848984F, -794, -220 },
{ 0xD77485CB25823AC7, -768, -212 },
{ 0xA086CFCD97BF97F4, -741, -204 },
{ 0xEF340A98172AACE5, -715, -196 },
{ 0xB23867FB2A35B28E, -688, -188 },
{ 0x84C8D4DFD2C63F3B, -661, -180 },
{ 0xC5DD44271AD3CDBA, -635, -172 },
{ 0x936B9FCEBB25C996, -608, -164 },
{ 0xDBAC6C247D62A584, -582, -156 },
{ 0xA3AB66580D5FDAF6, -555, -148 },
{ 0xF3E2F893DEC3F126, -529, -140 },
{ 0xB5B5ADA8AAFF80B8, -502, -132 },
{ 0x87625F056C7C4A8B, -475, -124 },
{ 0xC9BCFF6034C13053, -449, -116 },
{ 0x964E858C91BA2655, -422, -108 },
{ 0xDFF9772470297EBD, -396, -100 },
{ 0xA6DFBD9FB8E5B88F, -369, -92 },
{ 0xF8A95FCF88747D94, -343, -84 },
{ 0xB94470938FA89BCF, -316, -76 },
{ 0x8A08F0F8BF0F156B, -289, -68 },
{ 0xCDB02555653131B6, -263, -60 },
{ 0x993FE2C6D07B7FAC, -236, -52 },
{ 0xE45C10C42A2B3B06, -210, -44 },
{ 0xAA242499697392D3, -183, -36 },
{ 0xFD87B5F28300CA0E, -157, -28 },
{ 0xBCE5086492111AEB, -130, -20 },
{ 0x8CBCCC096F5088CC, -103, -12 },
{ 0xD1B71758E219652C, -77, -4 },
{ 0x9C40000000000000, -50, 4 },
{ 0xE8D4A51000000000, -24, 12 },
{ 0xAD78EBC5AC620000, 3, 20 },
{ 0x813F3978F8940984, 30, 28 },
{ 0xC097CE7BC90715B3, 56, 36 },
{ 0x8F7E32CE7BEA5C70, 83, 44 },
{ 0xD5D238A4ABE98068, 109, 52 },
{ 0x9F4F2726179A2245, 136, 60 },
{ 0xED63A231D4C4FB27, 162, 68 },
{ 0xB0DE65388CC8ADA8, 189, 76 },
{ 0x83C7088E1AAB65DB, 216, 84 },
{ 0xC45D1DF942711D9A, 242, 92 },
{ 0x924D692CA61BE758, 269, 100 },
{ 0xDA01EE641A708DEA, 295, 108 },
{ 0xA26DA3999AEF774A, 322, 116 },
{ 0xF209787BB47D6B85, 348, 124 },
{ 0xB454E4A179DD1877, 375, 132 },
{ 0x865B86925B9BC5C2, 402, 140 },
{ 0xC83553C5C8965D3D, 428, 148 },
{ 0x952AB45CFA97A0B3, 455, 156 },
{ 0xDE469FBD99A05FE3, 481, 164 },
{ 0xA59BC234DB398C25, 508, 172 },
{ 0xF6C69A72A3989F5C, 534, 180 },
{ 0xB7DCBF5354E9BECE, 561, 188 },
{ 0x88FCF317F22241E2, 588, 196 },
{ 0xCC20CE9BD35C78A5, 614, 204 },
{ 0x98165AF37B2153DF, 641, 212 },
{ 0xE2A0B5DC971F303A, 667, 220 },
{ 0xA8D9D1535CE3B396, 694, 228 },
{ 0xFB9B7CD9A4A7443C, 720, 236 },
{ 0xBB764C4CA7A44410, 747, 244 },
{ 0x8BAB8EEFB6409C1A, 774, 252 },
{ 0xD01FEF10A657842C, 800, 260 },
{ 0x9B10A4E5E9913129, 827, 268 },
{ 0xE7109BFBA19C0C9D, 853, 276 },
{ 0xAC2820D9623BF429, 880, 284 },
{ 0x80444B5E7AA7CF85, 907, 292 },
{ 0xBF21E44003ACDD2D, 933, 300 },
{ 0x8E679C2F5E44FF8F, 960, 308 },
{ 0xD433179D9C8CB841, 986, 316 },
{ 0x9E19DB92B4E31BA9, 1013, 324 },
}
};
// This computation gives exactly the same results for k as
// k = ceil((kAlpha - e - 1) * 0.30102999566398114)
// for |e| <= 1500, but doesn't require floating-point operations.
// NB: log_10(2) ~= 78913 / 2^18
JSON_ASSERT(e >= -1500);
JSON_ASSERT(e <= 1500);
const int f = kAlpha - e - 1;
const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
JSON_ASSERT(index >= 0);
JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
JSON_ASSERT(kAlpha <= cached.e + e + 64);
JSON_ASSERT(kGamma >= cached.e + e + 64);
return cached;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(int):
pushq %rax
cmpl $0xfffffa23, %edi # imm = 0xFFFFFA23
jle 0x87174
cmpl $0x5dd, %edi # imm = 0x5DD
jge 0x87193
xorl %eax, %eax
movl %edi, %ecx
subl $-0x3d, %ecx
setl %al
negl %ecx
imull $0x13441, %ecx, %ecx # imm = 0x13441
leal 0x3ffff(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
sarl $0x12, %edx
addl %edx, %eax
cmpl $0xfffffec5, %eax # imm = 0xFFFFFEC5
jle 0x871af
leal 0x133(%rax), %ecx
addl $0x13a, %eax # imm = 0x13A
testw %cx, %cx
cmovnsl %ecx, %eax
cwtl
shrl $0x3, %eax
cmpw $0x4f, %ax
jae 0x871cb
movzwl %ax, %eax
shll $0x4, %eax
leaq 0x41fbb(%rip), %rcx # 0xc9110
movq 0x8(%rcx,%rax), %rdx
addl %edx, %edi
cmpl $-0x7d, %edi
jle 0x871e7
cmpl $-0x5f, %edi
jge 0x87203
movq (%rcx,%rax), %rax
popq %rcx
retq
leaq 0x44ac0(%rip), %rdi # 0xcbc3b
leaq 0x40f0e(%rip), %rdx # 0xc8090
leaq 0x46518(%rip), %rcx # 0xcd6a1
movl $0x43e4, %esi # imm = 0x43E4
jmp 0x8721d
leaq 0x44aa1(%rip), %rdi # 0xcbc3b
leaq 0x40eef(%rip), %rdx # 0xc8090
leaq 0x46504(%rip), %rcx # 0xcd6ac
movl $0x43e5, %esi # imm = 0x43E5
jmp 0x8721d
leaq 0x44a85(%rip), %rdi # 0xcbc3b
leaq 0x40ed3(%rip), %rdx # 0xc8090
leaq 0x464f2(%rip), %rcx # 0xcd6b6
movl $0x43ea, %esi # imm = 0x43EA
jmp 0x8721d
leaq 0x44a69(%rip), %rdi # 0xcbc3b
leaq 0x40eb7(%rip), %rdx # 0xc8090
leaq 0x464e1(%rip), %rcx # 0xcd6c1
movl $0x43eb, %esi # imm = 0x43EB
jmp 0x8721d
leaq 0x44a4d(%rip), %rdi # 0xcbc3b
leaq 0x40e9b(%rip), %rdx # 0xc8090
leaq 0x464fc(%rip), %rcx # 0xcd6f8
movl $0x43ee, %esi # imm = 0x43EE
jmp 0x8721d
leaq 0x44a31(%rip), %rdi # 0xcbc3b
leaq 0x40e7f(%rip), %rdx # 0xc8090
leaq 0x464fc(%rip), %rcx # 0xcd714
movl $0x43ef, %esi # imm = 0x43EF
xorl %eax, %eax
callq 0x1ca40
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl36get_cached_power_for_binary_exponentEi:
push rax
cmp edi, 0FFFFFA23h
jle loc_87174
cmp edi, 5DDh
jge loc_87193
xor eax, eax
mov ecx, edi
sub ecx, 0FFFFFFC3h
setl al
neg ecx
imul ecx, 13441h
lea edx, [rcx+3FFFFh]
test ecx, ecx
cmovns edx, ecx
sar edx, 12h
add eax, edx
cmp eax, 0FFFFFEC5h
jle loc_871AF
lea ecx, [rax+133h]
add eax, 13Ah
test cx, cx
cmovns eax, ecx
cwde
shr eax, 3
cmp ax, 4Fh ; 'O'
jnb loc_871CB
movzx eax, ax
shl eax, 4
lea rcx, _ZZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl36get_cached_power_for_binary_exponentEiE13kCachedPowers; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(int)::kCachedPowers
mov rdx, [rcx+rax+8]
add edi, edx
cmp edi, 0FFFFFF83h
jle loc_871E7
cmp edi, 0FFFFFFA1h
jge loc_87203
mov rax, [rcx+rax]
pop rcx
retn
loc_87174:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aE1500; "e >= -1500"
mov esi, 43E4h
jmp loc_8721D
loc_87193:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aE1500_0; "e <= 1500"
mov esi, 43E5h
jmp short loc_8721D
loc_871AF:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aIndex0; "index >= 0"
mov esi, 43EAh
jmp short loc_8721D
loc_871CB:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aStaticCastStdS; "static_cast<std::size_t>(index) < kCach"...
mov esi, 43EBh
jmp short loc_8721D
loc_871E7:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKalphaCachedEE; "kAlpha <= cached.e + e + 64"
mov esi, 43EEh
jmp short loc_8721D
loc_87203:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKgammaCachedEE; "kGamma >= cached.e + e + 64"
mov esi, 43EFh
loc_8721D:
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *this)
{
int v1; // eax
__int16 v2; // cx
__int16 v3; // ax
unsigned int v4; // eax
long long v5; // rax
int v6; // edi
if ( (int)this <= -1501 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17380LL,
"GGML_ASSERT(%s) failed",
"e >= -1500");
}
else if ( (int)this >= 1501 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17381LL,
"GGML_ASSERT(%s) failed",
"e <= 1500");
}
else
{
v1 = -78913 * ((int)this + 61) / 0x40000 + ((int)this < -61);
if ( v1 <= -315 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17386LL,
"GGML_ASSERT(%s) failed",
"index >= 0");
}
else
{
v2 = v1 + 307;
v3 = v1 + 314;
if ( v2 >= 0 )
v3 = v2;
v4 = (unsigned int)v3 >> 3;
if ( (unsigned __int16)v4 >= 0x4Fu )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17387LL,
"GGML_ASSERT(%s) failed",
"static_cast<std::size_t>(index) < kCachedPowers.size()");
}
else
{
v5 = 16 * (unsigned int)(unsigned __int16)v4;
v6 = *(_QWORD *)((char *)&nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(int)::kCachedPowers
+ v5
+ 8)
+ (_DWORD)this;
if ( v6 <= -125 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17390LL,
"GGML_ASSERT(%s) failed",
"kAlpha <= cached.e + e + 64");
}
else
{
if ( v6 < -95 )
return *(_QWORD *)((char *)&nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(int)::kCachedPowers
+ v5);
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17391LL,
"GGML_ASSERT(%s) failed",
"kGamma >= cached.e + e + 64");
}
}
}
}
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub();
}
| get_cached_power_for_binary_exponent:
PUSH RAX
CMP EDI,0xfffffa23
JLE 0x00187174
CMP EDI,0x5dd
JGE 0x00187193
XOR EAX,EAX
MOV ECX,EDI
SUB ECX,-0x3d
SETL AL
NEG ECX
IMUL ECX,ECX,0x13441
LEA EDX,[RCX + 0x3ffff]
TEST ECX,ECX
CMOVNS EDX,ECX
SAR EDX,0x12
ADD EAX,EDX
CMP EAX,0xfffffec5
JLE 0x001871af
LEA ECX,[RAX + 0x133]
ADD EAX,0x13a
TEST CX,CX
CMOVNS EAX,ECX
CWDE
SHR EAX,0x3
CMP AX,0x4f
JNC 0x001871cb
MOVZX EAX,AX
SHL EAX,0x4
LEA RCX,[0x1c9110]
MOV RDX,qword ptr [RCX + RAX*0x1 + 0x8]
ADD EDI,EDX
CMP EDI,-0x7d
JLE 0x001871e7
CMP EDI,-0x5f
JGE 0x00187203
MOV RAX,qword ptr [RCX + RAX*0x1]
POP RCX
RET
LAB_00187174:
LEA RDI,[0x1cbc3b]
LEA RDX,[0x1c8090]
LEA RCX,[0x1cd6a1]
MOV ESI,0x43e4
JMP 0x0018721d
LAB_00187193:
LEA RDI,[0x1cbc3b]
LEA RDX,[0x1c8090]
LEA RCX,[0x1cd6ac]
MOV ESI,0x43e5
JMP 0x0018721d
LAB_001871af:
LEA RDI,[0x1cbc3b]
LEA RDX,[0x1c8090]
LEA RCX,[0x1cd6b6]
MOV ESI,0x43ea
JMP 0x0018721d
LAB_001871cb:
LEA RDI,[0x1cbc3b]
LEA RDX,[0x1c8090]
LEA RCX,[0x1cd6c1]
MOV ESI,0x43eb
JMP 0x0018721d
LAB_001871e7:
LEA RDI,[0x1cbc3b]
LEA RDX,[0x1c8090]
LEA RCX,[0x1cd6f8]
MOV ESI,0x43ee
JMP 0x0018721d
LAB_00187203:
LEA RDI,[0x1cbc3b]
LEA RDX,[0x1c8090]
LEA RCX,[0x1cd714]
MOV ESI,0x43ef
LAB_0018721d:
XOR EAX,EAX
CALL 0x0011ca40
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(int) */
int8
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(int param_1)
{
short sVar1;
int iVar2;
ulong uVar3;
short sVar4;
int iVar5;
char *pcVar6;
int8 uVar7;
if (param_1 < -0x5dc) {
pcVar6 = "e >= -1500";
uVar7 = 0x43e4;
}
else if (param_1 < 0x5dd) {
iVar5 = (param_1 + 0x3d) * -0x13441;
iVar2 = iVar5 + 0x3ffff;
if (-1 < iVar5) {
iVar2 = iVar5;
}
iVar2 = (uint)(param_1 < -0x3d) + (iVar2 >> 0x12);
if (iVar2 < -0x13a) {
pcVar6 = "index >= 0";
uVar7 = 0x43ea;
}
else {
sVar1 = (short)iVar2;
sVar4 = sVar1 + 0x133;
sVar1 = sVar1 + 0x13a;
if (-1 < sVar4) {
sVar1 = sVar4;
}
if ((ushort)((uint)(int)sVar1 >> 3) < 0x4f) {
uVar3 = (ulong)(((uint)(int)sVar1 >> 3 & 0xffff) << 4);
iVar2 = param_1 + (int)*(int8 *)
(get_cached_power_for_binary_exponent(int)::kCachedPowers +
uVar3 + 8);
if (iVar2 < -0x7c) {
pcVar6 = "kAlpha <= cached.e + e + 64";
uVar7 = 0x43ee;
}
else {
if (iVar2 < -0x5f) {
return *(int8 *)(get_cached_power_for_binary_exponent(int)::kCachedPowers + uVar3)
;
}
pcVar6 = "kGamma >= cached.e + e + 64";
uVar7 = 0x43ef;
}
}
else {
pcVar6 = "static_cast<std::size_t>(index) < kCachedPowers.size()";
uVar7 = 0x43eb;
}
}
}
else {
pcVar6 = "e <= 1500";
uVar7 = 0x43e5;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",uVar7,
"GGML_ASSERT(%s) failed",pcVar6);
}
| |
26,016 | my_once_free | eloqsql/mysys/my_once.c | void my_once_free(void)
{
reg1 USED_MEM *next,*old;
DBUG_ENTER("my_once_free");
for (next=my_once_root_block ; next ; )
{
old=next; next= next->next ;
free((uchar*) old);
}
my_once_root_block=0;
DBUG_VOID_RETURN;
} | O0 | c | my_once_free:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3605f1(%rip), %rax # 0x3872d0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x26d0b
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x24350
jmp 0x26ce6
leaq 0x3605be(%rip), %rax # 0x3872d0
movq $0x0, (%rax)
jmp 0x26d1b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| my_once_free:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rax, my_once_root_block
mov rax, [rax]
mov [rbp+var_8], rax
loc_26CE6:
cmp [rbp+var_8], 0
jz short loc_26D0B
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_8], rax
mov rdi, [rbp+var_10]
call _free
jmp short loc_26CE6
loc_26D0B:
lea rax, my_once_root_block
mov qword ptr [rax], 0
jmp short $+2
loc_26D1B:
add rsp, 10h
pop rbp
retn
| _QWORD *my_once_free()
{
_QWORD *result; // rax
_QWORD *v1; // [rsp+0h] [rbp-10h]
_QWORD *v2; // [rsp+8h] [rbp-8h]
v2 = (_QWORD *)my_once_root_block;
while ( v2 )
{
v1 = v2;
v2 = (_QWORD *)*v2;
free(v1);
}
result = &my_once_root_block;
my_once_root_block = 0LL;
return result;
}
| my_once_free:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RAX,[0x4872d0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
LAB_00126ce6:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00126d0b
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00124350
JMP 0x00126ce6
LAB_00126d0b:
LEA RAX,[0x4872d0]
MOV qword ptr [RAX],0x0
JMP 0x00126d1b
LAB_00126d1b:
ADD RSP,0x10
POP RBP
RET
|
void my_once_free(void)
{
int8 *puVar1;
int8 local_10;
local_10 = my_once_root_block;
while (local_10 != (int8 *)0x0) {
puVar1 = (int8 *)*local_10;
free(local_10);
local_10 = puVar1;
}
my_once_root_block = (int8 *)0x0;
return;
}
| |
26,017 | minja::Value::dump(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int, bool) const | monkey531[P]llama/common/minja.hpp | void dump(std::ostringstream & out, int indent = -1, int level = 0, bool to_json = false) const {
auto print_indent = [&](int level) {
if (indent > 0) {
out << "\n";
for (int i = 0, n = level * indent; i < n; ++i) out << ' ';
}
};
auto print_sub_sep = [&]() {
out << ',';
if (indent < 0) out << ' ';
else print_indent(level + 1);
};
auto string_quote = to_json ? '"' : '\'';
if (is_null()) out << "null";
else if (array_) {
out << "[";
print_indent(level + 1);
for (size_t i = 0; i < array_->size(); ++i) {
if (i) print_sub_sep();
(*array_)[i].dump(out, indent, level + 1, to_json);
}
print_indent(level);
out << "]";
} else if (object_) {
out << "{";
print_indent(level + 1);
for (auto begin = object_->begin(), it = begin; it != object_->end(); ++it) {
if (it != begin) print_sub_sep();
if (it->first.is_string()) {
dump_string(it->first, out, string_quote);
} else {
out << string_quote << it->first.dump() << string_quote;
}
out << ": ";
it->second.dump(out, indent, level + 1, to_json);
}
print_indent(level);
out << "}";
} else if (callable_) {
throw std::runtime_error("Cannot dump callable to JSON");
} else if (is_boolean() && !to_json) {
out << (this->to_bool() ? "True" : "False");
} else if (is_string() && !to_json) {
dump_string(primitive_, out, string_quote);
} else {
out << primitive_.dump();
}
} | O2 | cpp | minja::Value::dump(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int, bool) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %r12d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %edx, (%rax)
leaq 0x8(%rsp), %rdx
movl %ecx, (%rdx)
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq %rsi, 0x8(%rcx)
movq %rsi, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movq %rcx, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
xorl %r15d, %r15d
testl %r8d, %r8d
sete %bpl
callq 0x60344
testb %al, %al
je 0x6007c
leaq 0x3d778(%rip), %rsi # 0x9d7ef
jmp 0x602c7
cmpq $0x0, 0x10(%rbx)
je 0x6011f
leaq 0x3a1bb(%rip), %rsi # 0x9a249
movq %r14, %rdi
callq 0x216a0
movl 0x8(%rsp), %esi
incl %esi
leaq 0x18(%rsp), %rdi
callq 0x60364
xorl %r13d, %r13d
movl %r12d, %eax
pushq $0x50
popq %r12
movzbl %al, %ebp
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %rax, %r15
jae 0x60105
testq %r15, %r15
je 0x600e4
leaq 0x48(%rsp), %rdi
callq 0x603b0
movq 0x10(%rbx), %rax
movq (%rax), %rdi
addq %r13, %rdi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
incl %ecx
movq %r14, %rsi
movl %ebp, %r8d
callq 0x60018
incq %r15
addq $0x50, %r13
jmp 0x600b6
movl 0x8(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x60364
leaq 0x3be69(%rip), %rsi # 0x9bf83
jmp 0x602c7
movb %bpl, %r15b
leal (%r15,%r15,4), %ebp
addl $0x22, %ebp
cmpq $0x0, 0x20(%rbx)
je 0x60252
leaq 0x39ed0(%rip), %rsi # 0x9a00b
movq %r14, %rdi
callq 0x216a0
movl 0x8(%rsp), %esi
incl %esi
leaq 0x18(%rsp), %rdi
callq 0x60364
movq 0x20(%rbx), %rax
movq (%rax), %r15
xorl %r13d, %r13d
movsbl %bpl, %ebp
movl %r12d, %ecx
leaq 0x3a0ed(%rip), %r12 # 0x9a258
movzbl %cl, %ecx
movl %ecx, 0x14(%rsp)
movl %ebp, 0x10(%rsp)
cmpq 0x8(%rax), %r15
je 0x6023b
testq %r13, %r13
je 0x6018f
leaq 0x48(%rsp), %rdi
callq 0x603b0
cmpb $0x3, (%r15)
jne 0x601a4
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x603e6
jmp 0x60204
movq %r14, %rdi
movq %r13, %r14
movq %rbx, %r13
movq %rdi, %rbx
movl %ebp, %esi
callq 0x217d0
movq %rax, %rbp
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
pushq $-0x1
popq %rdx
pushq $0x20
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x47264
movq %rbp, %rdi
movl 0x10(%rsp), %ebp
leaq 0x28(%rsp), %rsi
callq 0x21610
movq %rax, %rdi
movl %ebp, %esi
callq 0x217d0
leaq 0x28(%rsp), %rdi
callq 0x21dc8
movq %rbx, %rax
movq %r13, %rbx
movq %r14, %r13
movq %rax, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x216a0
leaq 0x10(%r15), %rdi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
incl %ecx
movq %r14, %rsi
movl 0x14(%rsp), %r8d
callq 0x60018
addq $0x60, %r15
movq 0x20(%rbx), %rax
addq $-0x60, %r13
jmp 0x60176
movl 0x8(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x60364
leaq 0x36fcd(%rip), %rsi # 0x9721d
jmp 0x602c7
cmpq $0x0, 0x30(%rbx)
jne 0x602ef
movb 0x40(%rbx), %al
cmpb $0x4, %al
setne %cl
orb %r12b, %cl
je 0x602ab
addq $0x40, %rbx
cmpb $0x3, %al
setne %al
orb %r12b, %al
je 0x602de
leaq 0x28(%rsp), %r15
pushq $-0x1
popq %rdx
pushq $0x20
popq %rcx
movq %r15, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x47264
movq %r14, %rdi
movq %r15, %rsi
callq 0x21610
leaq 0x28(%rsp), %rdi
callq 0x21dc8
jmp 0x602cf
movq %rbx, %rdi
callq 0x5fc1e
leaq 0x36df7(%rip), %rcx # 0x970b1
leaq 0x3cc7f(%rip), %rsi # 0x9cf40
testb %al, %al
cmovneq %rcx, %rsi
movq %r14, %rdi
callq 0x216a0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsbl %bpl, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x603e6
jmp 0x602cf
pushq $0x10
popq %rdi
callq 0x213a0
movq %rax, %r14
leaq 0x3cc22(%rip), %rsi # 0x9cf23
movq %rax, %rdi
callq 0x21280
movq 0x7bcd8(%rip), %rsi # 0xdbfe8
movq 0x7bc51(%rip), %rdx # 0xdbf68
movq %r14, %rdi
callq 0x21b70
jmp 0x6032e
movq %rax, %rbx
movq %r14, %rdi
callq 0x21530
jmp 0x6033b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x21dc8
movq %rbx, %rdi
callq 0x21be0
nop
| _ZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiib:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12d, r8d
mov r14, rsi
mov rbx, rdi
lea rax, [rsp+98h+var_8C]
mov [rax], edx
lea rdx, [rsp+98h+var_90]
mov [rdx], ecx
lea rcx, [rsp+98h+var_80]
mov [rcx], rax
mov [rcx+8], rsi
mov [rsp+98h+var_50], rsi
mov [rsp+98h+var_48], rax
mov [rsp+98h+var_40], rcx
mov [rsp+98h+var_38], rdx
xor r15d, r15d
test r8d, r8d
setz bpl
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jz short loc_6007C
lea rsi, aOnNull_0+5; "null"
jmp loc_602C7
loc_6007C:
cmp qword ptr [rbx+10h], 0
jz loc_6011F
lea rsi, aBytes+9; "["
mov rdi, r14
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov esi, [rsp+98h+var_90]
inc esi
lea rdi, [rsp+98h+var_80]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
xor r13d, r13d
mov eax, r12d
push 50h ; 'P'
pop r12
movzx ebp, al
xor r15d, r15d
loc_600B6:
mov rax, [rbx+10h]
mov rdi, [rax]
mov rax, [rax+8]
sub rax, rdi
cqo
idiv r12
cmp r15, rax
jnb short loc_60105
test r15, r15
jz short loc_600E4
lea rdi, [rsp+98h+var_50]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUlvE_clEv; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(void)#1}::operator()(void)
mov rax, [rbx+10h]
mov rdi, [rax]
loc_600E4:
add rdi, r13; this
mov edx, [rsp+98h+var_8C]
mov ecx, [rsp+98h+var_90]
inc ecx
mov rsi, r14
mov r8d, ebp
call _ZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiib; minja::Value::dump(std::ostringstream &,int,int,bool)
inc r15
add r13, 50h ; 'P'
jmp short loc_600B6
loc_60105:
mov esi, [rsp+98h+var_90]
lea rdi, [rsp+98h+var_80]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
lea rsi, asc_9BF82+1; "]"
jmp loc_602C7
loc_6011F:
mov r15b, bpl
lea ebp, [r15+r15*4]
add ebp, 22h ; '"'
cmp qword ptr [rbx+20h], 0
jz loc_60252
lea rsi, asc_9A00B; "{"
mov rdi, r14
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov esi, [rsp+98h+var_90]
inc esi
lea rdi, [rsp+98h+var_80]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
mov rax, [rbx+20h]
mov r15, [rax]
xor r13d, r13d
movsx ebp, bpl
mov ecx, r12d
lea r12, aSubtype+9; ": "
movzx ecx, cl
mov [rsp+98h+var_84], ecx
mov [rsp+98h+var_88], ebp
loc_60176:
cmp r15, [rax+8]
jz loc_6023B
test r13, r13
jz short loc_6018F
lea rdi, [rsp+98h+var_50]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUlvE_clEv; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(void)#1}::operator()(void)
loc_6018F:
cmp byte ptr [r15], 3
jnz short loc_601A4
mov rdi, r15
mov rsi, r14
mov edx, ebp
call _ZN5minja5Value11dump_stringERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEERNS6_19basic_ostringstreamIcS9_SA_EEc; minja::Value::dump_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> const&,std::ostringstream &,char)
jmp short loc_60204
loc_601A4:
mov rdi, r14
mov r14, r13
mov r13, rbx
mov rbx, rdi
mov esi, ebp
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
mov rbp, rax
lea rdi, [rsp+98h+var_70]
mov rsi, r15
push 0FFFFFFFFFFFFFFFFh
pop rdx
push 20h ; ' '
pop rcx
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
mov rdi, rbp
mov ebp, [rsp+98h+var_88]
lea rsi, [rsp+98h+var_70]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov rdi, rax
mov esi, ebp
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
lea rdi, [rsp+98h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
mov rbx, r13
mov r13, r14
mov r14, rax
loc_60204:
mov rdi, r14
mov rsi, r12
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
lea rdi, [r15+10h]
mov edx, [rsp+98h+var_8C]
mov ecx, [rsp+98h+var_90]
inc ecx
mov rsi, r14
mov r8d, [rsp+98h+var_84]
call _ZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiib; minja::Value::dump(std::ostringstream &,int,int,bool)
add r15, 60h ; '`'
mov rax, [rbx+20h]
add r13, 0FFFFFFFFFFFFFFA0h
jmp loc_60176
loc_6023B:
mov esi, [rsp+98h+var_90]
lea rdi, [rsp+98h+var_80]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
lea rsi, aPatternAZaZ09+34h; "}"
jmp short loc_602C7
loc_60252:
cmp qword ptr [rbx+30h], 0
jnz loc_602EF
mov al, [rbx+40h]
cmp al, 4
setnz cl
or cl, r12b
jz short loc_602AB
add rbx, 40h ; '@'
cmp al, 3
setnz al
or al, r12b
jz short loc_602DE
lea r15, [rsp+98h+var_70]
push 0FFFFFFFFFFFFFFFFh
pop rdx
push 20h ; ' '
pop rcx
mov rdi, r15
mov rsi, rbx
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
mov rdi, r14
mov rsi, r15
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
lea rdi, [rsp+98h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_602CF
loc_602AB:
mov rdi, rbx; this
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
lea rcx, aTrue_1; "True"
lea rsi, aFalse_1; "False"
test al, al
cmovnz rsi, rcx
loc_602C7:
mov rdi, r14
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
loc_602CF:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_602DE:
movsx edx, bpl
mov rdi, rbx
mov rsi, r14
call _ZN5minja5Value11dump_stringERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEERNS6_19basic_ostringstreamIcS9_SA_EEc; minja::Value::dump_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> const&,std::ostringstream &,char)
jmp short loc_602CF
loc_602EF:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aCannotDumpCall; "Cannot dump callable to JSON"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_6032E
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_6033B
loc_6032E:
mov rbx, rax
lea rdi, [rsp+98h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_6033B:
mov rdi, rbx
call __Unwind_Resume
| void minja::Value::dump(long long a1, long long a2, unsigned int a3, unsigned int a4, int a5)
{
unsigned __int8 v5; // r12
long long v6; // r14
long long v7; // rbx
bool v8; // bp
char *v9; // rsi
long long v10; // r13
unsigned long long i; // r15
long long *v12; // rax
long long v13; // rdi
bool v14; // r15
unsigned int v15; // ebp
_BYTE **v16; // rax
_BYTE *v17; // r15
long long v18; // r13
long long v19; // rdi
long long v20; // r14
long long v21; // r13
long long v22; // rbx
long long v23; // rbp
long long v24; // rdi
long long v25; // rax
long long v26; // rax
char v27; // al
long long v28; // rbx
std::runtime_error *exception; // r14
unsigned int v30; // [rsp+8h] [rbp-90h] BYREF
unsigned int v31; // [rsp+Ch] [rbp-8Ch] BYREF
unsigned int v32; // [rsp+10h] [rbp-88h]
unsigned int v33; // [rsp+14h] [rbp-84h]
_QWORD v34[2]; // [rsp+18h] [rbp-80h] BYREF
_BYTE v35[32]; // [rsp+28h] [rbp-70h] BYREF
_QWORD v36[10]; // [rsp+48h] [rbp-50h] BYREF
v5 = a5;
v6 = a2;
v7 = a1;
v31 = a3;
v30 = a4;
v34[0] = &v31;
v34[1] = a2;
v36[0] = a2;
v36[1] = &v31;
v36[2] = v34;
v36[3] = &v30;
v8 = a5 == 0;
if ( (unsigned __int8)minja::Value::is_null((minja::Value *)a1) )
{
v9 = "null";
LABEL_26:
std::operator<<<std::char_traits<char>>(v6, v9);
return;
}
if ( *(_QWORD *)(a1 + 16) )
{
std::operator<<<std::char_traits<char>>(a2, "[");
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v34, v30 + 1);
v10 = 0LL;
for ( i = 0LL; ; ++i )
{
v12 = *(long long **)(v7 + 16);
v13 = *v12;
if ( i >= (v12[1] - *v12) / 80 )
break;
if ( i )
{
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(void)#1}::operator()(v36);
v13 = **(_QWORD **)(v7 + 16);
}
minja::Value::dump(v10 + v13, a2, v31, v30 + 1, v5);
v10 += 80LL;
}
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v34, v30);
v9 = "]";
goto LABEL_26;
}
v14 = v8;
LOBYTE(v15) = 5 * v8 + 34;
if ( *(_QWORD *)(a1 + 32) )
{
std::operator<<<std::char_traits<char>>(a2, "{");
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v34, v30 + 1);
v16 = *(_BYTE ***)(a1 + 32);
v17 = *v16;
v18 = 0LL;
v15 = (char)v15;
v33 = v5;
v32 = (char)v15;
while ( v17 != v16[1] )
{
if ( v18 )
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(void)#1}::operator()(v36);
if ( *v17 == 3 )
{
minja::Value::dump_string(v17, v6, v15);
}
else
{
v19 = v6;
v20 = v18;
v21 = v7;
v22 = v19;
v23 = std::operator<<<std::char_traits<char>>(v19, 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>::dump(
(long long)v35,
(long long)v17,
-1,
32,
0,
0);
v24 = v23;
v15 = v32;
v25 = std::operator<<<char>(v24, v35);
std::operator<<<std::char_traits<char>>(v25, v15);
std::string::~string(v35);
v26 = v22;
v7 = v21;
v18 = v20;
v6 = v26;
}
std::operator<<<std::char_traits<char>>(v6, ": ");
minja::Value::dump(v17 + 16, v6, v31, v30 + 1, v33);
v17 += 96;
v16 = *(_BYTE ***)(v7 + 32);
v18 -= 96LL;
}
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v34, v30);
v9 = "}";
goto LABEL_26;
}
if ( *(_QWORD *)(a1 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Cannot dump callable to JSON");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v27 = *(_BYTE *)(a1 + 64);
if ( !(v5 | (v27 != 4)) )
{
v9 = "False";
if ( (unsigned __int8)minja::Value::to_bool((minja::Value *)a1) )
v9 = "True";
goto LABEL_26;
}
v28 = a1 + 64;
if ( v5 | (v27 != 3) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::dump(
(long long)v35,
v28,
-1,
32,
0,
0);
std::operator<<<char>(a2, v35);
std::string::~string(v35);
}
else
{
minja::Value::dump_string(v28, a2, (unsigned int)(char)(5 * v14 + 34));
}
}
| dump:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12D,R8D
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RSP + 0xc]
MOV dword ptr [RAX],EDX
LEA RDX,[RSP + 0x8]
MOV dword ptr [RDX],ECX
LEA RCX,[RSP + 0x18]
MOV qword ptr [RCX],RAX
MOV qword ptr [RCX + 0x8],RSI
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RCX
MOV qword ptr [RSP + 0x60],RDX
XOR R15D,R15D
TEST R8D,R8D
SETZ BPL
CALL 0x00160344
TEST AL,AL
JZ 0x0016007c
LEA RSI,[0x19d7ef]
JMP 0x001602c7
LAB_0016007c:
CMP qword ptr [RBX + 0x10],0x0
JZ 0x0016011f
LEA RSI,[0x19a249]
MOV RDI,R14
CALL 0x001216a0
MOV ESI,dword ptr [RSP + 0x8]
INC ESI
LEA RDI,[RSP + 0x18]
CALL 0x00160364
XOR R13D,R13D
MOV EAX,R12D
PUSH 0x50
POP R12
MOVZX EBP,AL
XOR R15D,R15D
LAB_001600b6:
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
SUB RAX,RDI
CQO
IDIV R12
CMP R15,RAX
JNC 0x00160105
TEST R15,R15
JZ 0x001600e4
LEA RDI,[RSP + 0x48]
CALL 0x001603b0
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RAX]
LAB_001600e4:
ADD RDI,R13
MOV EDX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x8]
INC ECX
MOV RSI,R14
MOV R8D,EBP
CALL 0x00160018
INC R15
ADD R13,0x50
JMP 0x001600b6
LAB_00160105:
MOV ESI,dword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x18]
CALL 0x00160364
LEA RSI,[0x19bf83]
JMP 0x001602c7
LAB_0016011f:
MOV R15B,BPL
LEA EBP,[R15 + R15*0x4]
ADD EBP,0x22
CMP qword ptr [RBX + 0x20],0x0
JZ 0x00160252
LEA RSI,[0x19a00b]
MOV RDI,R14
CALL 0x001216a0
MOV ESI,dword ptr [RSP + 0x8]
INC ESI
LEA RDI,[RSP + 0x18]
CALL 0x00160364
MOV RAX,qword ptr [RBX + 0x20]
MOV R15,qword ptr [RAX]
XOR R13D,R13D
MOVSX EBP,BPL
MOV ECX,R12D
LEA R12,[0x19a258]
MOVZX ECX,CL
MOV dword ptr [RSP + 0x14],ECX
MOV dword ptr [RSP + 0x10],EBP
LAB_00160176:
CMP R15,qword ptr [RAX + 0x8]
JZ 0x0016023b
TEST R13,R13
JZ 0x0016018f
LEA RDI,[RSP + 0x48]
CALL 0x001603b0
LAB_0016018f:
CMP byte ptr [R15],0x3
JNZ 0x001601a4
MOV RDI,R15
MOV RSI,R14
MOV EDX,EBP
CALL 0x001603e6
JMP 0x00160204
LAB_001601a4:
MOV RDI,R14
MOV R14,R13
MOV R13,RBX
MOV RBX,RDI
MOV ESI,EBP
CALL 0x001217d0
MOV RBP,RAX
LEA RDI,[RSP + 0x28]
MOV RSI,R15
PUSH -0x1
POP RDX
PUSH 0x20
POP RCX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00147264
LAB_001601d3:
MOV RDI,RBP
MOV EBP,dword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x28]
CALL 0x00121610
MOV RDI,RAX
MOV ESI,EBP
CALL 0x001217d0
LAB_001601ee:
LEA RDI,[RSP + 0x28]
CALL 0x00121dc8
MOV RAX,RBX
MOV RBX,R13
MOV R13,R14
MOV R14,RAX
LAB_00160204:
MOV RDI,R14
MOV RSI,R12
CALL 0x001216a0
LEA RDI,[R15 + 0x10]
MOV EDX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x8]
INC ECX
MOV RSI,R14
MOV R8D,dword ptr [RSP + 0x14]
CALL 0x00160018
ADD R15,0x60
MOV RAX,qword ptr [RBX + 0x20]
ADD R13,-0x60
JMP 0x00160176
LAB_0016023b:
MOV ESI,dword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x18]
CALL 0x00160364
LEA RSI,[0x19721d]
JMP 0x001602c7
LAB_00160252:
CMP qword ptr [RBX + 0x30],0x0
JNZ 0x001602ef
MOV AL,byte ptr [RBX + 0x40]
CMP AL,0x4
SETNZ CL
OR CL,R12B
JZ 0x001602ab
ADD RBX,0x40
CMP AL,0x3
SETNZ AL
OR AL,R12B
JZ 0x001602de
LEA R15,[RSP + 0x28]
PUSH -0x1
POP RDX
PUSH 0x20
POP RCX
MOV RDI,R15
MOV RSI,RBX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00147264
LAB_00160294:
MOV RDI,R14
MOV RSI,R15
CALL 0x00121610
LAB_0016029f:
LEA RDI,[RSP + 0x28]
CALL 0x00121dc8
JMP 0x001602cf
LAB_001602ab:
MOV RDI,RBX
CALL 0x0015fc1e
LEA RCX,[0x1970b1]
LEA RSI,[0x19cf40]
TEST AL,AL
CMOVNZ RSI,RCX
LAB_001602c7:
MOV RDI,R14
CALL 0x001216a0
LAB_001602cf:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001602de:
MOVSX EDX,BPL
MOV RDI,RBX
MOV RSI,R14
CALL 0x001603e6
JMP 0x001602cf
LAB_001602ef:
PUSH 0x10
POP RDI
CALL 0x001213a0
MOV R14,RAX
LAB_001602fa:
LEA RSI,[0x19cf23]
MOV RDI,RAX
CALL 0x00121280
LAB_00160309:
MOV RSI,qword ptr [0x001dbfe8]
MOV RDX,qword ptr [0x001dbf68]
MOV RDI,R14
CALL 0x00121b70
|
/* minja::Value::dump(std::__cxx11::ostringstream&, int, int, bool) const */
void __thiscall
minja::Value::dump(Value *this,ostringstream *param_1,int param_2,int param_3,bool param_4)
{
char cVar1;
int8 *puVar2;
ostream *poVar3;
runtime_error *this_00;
int iVar4;
char *pcVar5;
long lVar6;
int7 in_register_00000081;
long lVar7;
ulong uVar8;
int local_90;
int local_8c;
int local_88;
uint local_84;
int *local_80;
ostringstream *local_78;
string local_70 [32];
ostringstream *local_50;
int *local_48;
int **local_40;
int *local_38;
local_80 = &local_8c;
local_38 = &local_90;
local_40 = &local_80;
local_90 = param_3;
local_8c = param_2;
local_78 = param_1;
local_50 = param_1;
local_48 = local_80;
cVar1 = is_null(this);
if (cVar1 == '\0') {
if (*(long *)(this + 0x10) == 0) {
cVar1 = ((int)CONCAT71(in_register_00000081,param_4) == 0) * '\x05' + '\"';
if (*(long *)(this + 0x20) == 0) {
if (*(long *)(this + 0x30) != 0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001602fa to 00160308 has its CatchHandler @ 00160321 */
std::runtime_error::runtime_error(this_00,"Cannot dump callable to JSON");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001dbfe8,PTR__runtime_error_001dbf68);
}
if (this[0x40] != (Value)0x4 || param_4) {
if (this[0x40] != (Value)0x3 || param_4) {
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::dump(local_70,this + 0x40,0xffffffffffffffff,0x20,0,0);
/* try { // try from 00160294 to 0016029e has its CatchHandler @ 0016031f */
std::operator<<((ostream *)param_1,local_70);
std::__cxx11::string::~string(local_70);
return;
}
dump_string(this + 0x40,param_1,cVar1);
return;
}
cVar1 = to_bool(this);
pcVar5 = "False";
if (cVar1 != '\0') {
pcVar5 = "True";
}
}
else {
std::operator<<((ostream *)param_1,"{");
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_80,local_90 + 1);
puVar2 = *(int8 **)(this + 0x20);
lVar7 = 0;
iVar4 = (int)cVar1;
local_84 = (uint)param_4;
local_88 = iVar4;
for (pcVar5 = (char *)*puVar2; pcVar5 != (char *)puVar2[1]; pcVar5 = pcVar5 + 0x60) {
if (lVar7 != 0) {
const::{lambda()#1}::operator()((_lambda___1_ *)&local_50);
}
if (*pcVar5 == '\x03') {
dump_string(pcVar5,param_1,(char)iVar4);
}
else {
poVar3 = std::operator<<((ostream *)param_1,(char)iVar4);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::dump(local_70,pcVar5,0xffffffffffffffff,0x20,0,0);
iVar4 = local_88;
/* try { // try from 001601d3 to 001601ed has its CatchHandler @ 0016032e */
poVar3 = std::operator<<(poVar3,local_70);
std::operator<<(poVar3,(char)iVar4);
std::__cxx11::string::~string(local_70);
}
std::operator<<((ostream *)param_1,": ");
dump((Value *)(pcVar5 + 0x10),param_1,local_8c,local_90 + 1,SUB41(local_84,0));
puVar2 = *(int8 **)(this + 0x20);
lVar7 = lVar7 + -0x60;
}
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_80,local_90);
pcVar5 = "}";
}
}
else {
std::operator<<((ostream *)param_1,"[");
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_80,local_90 + 1);
lVar7 = 0;
for (uVar8 = 0; lVar6 = **(long **)(this + 0x10),
uVar8 < (ulong)(((*(long **)(this + 0x10))[1] - lVar6) / 0x50); uVar8 = uVar8 + 1) {
if (uVar8 != 0) {
const::{lambda()#1}::operator()((_lambda___1_ *)&local_50);
lVar6 = **(long **)(this + 0x10);
}
dump((Value *)(lVar6 + lVar7),param_1,local_8c,local_90 + 1,param_4);
lVar7 = lVar7 + 0x50;
}
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_80,local_90);
pcVar5 = "]";
}
}
else {
pcVar5 = "null";
}
std::operator<<((ostream *)param_1,pcVar5);
return;
}
| |
26,018 | diag | eloqsql/unittest/mytap/tap.c | void
diag(char const *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
fprintf(tapout, "# ");
vfprintf(tapout, fmt, ap);
emit_endl();
va_end(ap);
} | O3 | c | diag:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq -0xe0(%rbp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x2d1fe
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %r14
movq %rdi, 0x10(%r14)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax # imm = 0x3000000008
movq %rax, (%r14)
movq 0x2e9d76(%rip), %r15 # 0x316f98
movq (%r15), %rdi
leaq 0x4dec1(%rip), %rdx # 0x7b0ed
movl $0x1, %esi
xorl %eax, %eax
callq 0x265e0
movq (%r15), %rdi
movl $0x1, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x260e0
movq (%r15), %rdi
leaq 0x52ad6(%rip), %rdx # 0x7fd2b
movl $0x1, %esi
xorl %eax, %eax
callq 0x265e0
movq (%r15), %rdi
callq 0x263e0
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| diag:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 0C8h
mov rbx, rdi
lea rdi, [rbp+var_E0]
mov [rdi+8], rsi
mov [rdi+10h], rdx
mov [rdi+18h], rcx
mov [rdi+20h], r8
mov [rdi+28h], r9
test al, al
jz short loc_2D1FE
movaps [rbp+var_B0], xmm0
movaps [rbp+var_A0], xmm1
movaps [rbp+var_90], xmm2
movaps [rbp+var_80], xmm3
movaps [rbp+var_70], xmm4
movaps [rbp+var_60], xmm5
movaps [rbp+var_50], xmm6
movaps [rbp+var_40], xmm7
loc_2D1FE:
lea r14, [rbp+var_30]
mov [r14+10h], rdi
lea rax, [rbp+arg_0]
mov [r14+8], rax
mov rax, 3000000008h
mov [r14], rax
mov r15, cs:stdout_ptr
mov rdi, [r15]
lea rdx, asc_7B0ED; "# "
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [r15]
mov esi, 1
mov rdx, rbx
mov rcx, r14
call ___vfprintf_chk
mov rdi, [r15]
lea rdx, asc_7FD28+3; "\n"
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [r15]
call _fflush
add rsp, 0C8h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long diag(
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-E0h] BYREF
long long v17; // [rsp+8h] [rbp-D8h]
long long v18; // [rsp+10h] [rbp-D0h]
long long v19; // [rsp+18h] [rbp-C8h]
long long v20; // [rsp+20h] [rbp-C0h]
long long v21; // [rsp+28h] [rbp-B8h]
__m128 v22; // [rsp+30h] [rbp-B0h]
__m128 v23; // [rsp+40h] [rbp-A0h]
__m128 v24; // [rsp+50h] [rbp-90h]
__m128 v25; // [rsp+60h] [rbp-80h]
__m128 v26; // [rsp+70h] [rbp-70h]
__m128 v27; // [rsp+80h] [rbp-60h]
__m128 v28; // [rsp+90h] [rbp-50h]
__m128 v29; // [rsp+A0h] [rbp-40h]
_QWORD v30[6]; // [rsp+B0h] [rbp-30h] BYREF
v22 = a7;
v23 = a8;
v24 = a9;
v25 = a10;
v26 = a11;
v27 = a12;
v28 = a13;
v29 = a14;
v17 = a2;
v18 = a3;
v19 = a4;
v20 = a5;
v21 = a6;
v30[2] = &v16;
v30[1] = &a15;
v30[0] = 0x3000000008LL;
__fprintf_chk(stdout, 1LL, "# ");
__vfprintf_chk(stdout, 1LL, a1, v30);
__fprintf_chk(stdout, 1LL, "\n");
return fflush(stdout);
}
| diag:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xc8
MOV RBX,RDI
LEA RDI,[RBP + -0xe0]
MOV qword ptr [RDI + 0x8],RSI
MOV qword ptr [RDI + 0x10],RDX
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],R8
MOV qword ptr [RDI + 0x28],R9
TEST AL,AL
JZ 0x0012d1fe
MOVAPS xmmword ptr [RBP + -0xb0],XMM0
MOVAPS xmmword ptr [RBP + -0xa0],XMM1
MOVAPS xmmword ptr [RBP + -0x90],XMM2
MOVAPS xmmword ptr [RBP + -0x80],XMM3
MOVAPS xmmword ptr [RBP + -0x70],XMM4
MOVAPS xmmword ptr [RBP + -0x60],XMM5
MOVAPS xmmword ptr [RBP + -0x50],XMM6
MOVAPS xmmword ptr [RBP + -0x40],XMM7
LAB_0012d1fe:
LEA R14,[RBP + -0x30]
MOV qword ptr [R14 + 0x10],RDI
LEA RAX,[RBP + 0x10]
MOV qword ptr [R14 + 0x8],RAX
MOV RAX,0x3000000008
MOV qword ptr [R14],RAX
MOV R15,qword ptr [0x00416f98]
MOV RDI,qword ptr [R15]
LEA RDX,[0x17b0ed]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x001265e0
MOV RDI,qword ptr [R15]
MOV ESI,0x1
MOV RDX,RBX
MOV RCX,R14
CALL 0x001260e0
MOV RDI,qword ptr [R15]
LEA RDX,[0x17fd2b]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x001265e0
MOV RDI,qword ptr [R15]
CALL 0x001263e0
ADD RSP,0xc8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void diag(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)
{
int *puVar1;
char in_AL;
int1 local_e8 [8];
int8 local_e0;
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int1 *local_30;
int1 *local_28;
puVar1 = PTR_stdout_00416f98;
local_28 = local_e8;
if (in_AL != '\0') {
local_b8 = param_1;
local_a8 = param_2;
local_98 = param_3;
local_88 = param_4;
local_78 = param_5;
local_68 = param_6;
local_58 = param_7;
local_48 = param_8;
}
local_30 = &stack0x00000008;
local_38 = 0x3000000008;
local_e0 = param_10;
local_d8 = param_11;
local_d0 = param_12;
local_c8 = param_13;
local_c0 = param_14;
__fprintf_chk(*(int8 *)PTR_stdout_00416f98,1,&DAT_0017b0ed);
__vfprintf_chk(*(int8 *)puVar1,1,param_9,&local_38);
__fprintf_chk(*(int8 *)puVar1,1,&DAT_0017fd2b);
fflush(*(FILE **)puVar1);
return;
}
| |
26,019 | SettingValue_SliderInt::layout() const | untodesu[P]voxelius/game/client/settings.cc | void SettingValue_SliderInt::layout(void) const
{
auto current_value = value->get_value();
if(ImGui::SliderInt(wid.c_str(), ¤t_value, value->get_min_value(), value->get_max_value())) {
value->set_value(current_value);
}
layout_label();
layout_tooltip();
} | O3 | cpp | SettingValue_SliderInt::layout() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x98(%rdi), %rax
movl 0x8(%rax), %ecx
leaq 0x4(%rsp), %rsi
movl %ecx, (%rsi)
movq 0x78(%rdi), %rdi
movl 0xc(%rax), %edx
movl 0x10(%rax), %ecx
leaq 0x1681b7(%rip), %r8 # 0x1d12f4
xorl %r9d, %r9d
callq 0xd4d40
testb %al, %al
je 0x6922c
movq 0x98(%rbx), %r14
movl 0x4(%rsp), %eax
movl 0x10(%r14), %r15d
cmpl %eax, %r15d
cmovgel %eax, %r15d
movl 0xc(%r14), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %r15d
movl %r15d, 0x8(%r14)
movl %r15d, %ebp
negl %ebp
cmovsl %r15d, %ebp
movl $0x1, %r12d
cmpl $0xa, %ebp
jb 0x691ce
movl $0x4, %r12d
movl $0xd1b71759, %eax # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x691c5
cmpl $0x3e7, %ecx # imm = 0x3E7
jbe 0x691cb
cmpl $0x2710, %ecx # imm = 0x2710
jb 0x691ce
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r12d
cmpl $0x1869f, %ecx # imm = 0x1869F
movl %edx, %ecx
ja 0x69192
addl $-0x3, %r12d
jmp 0x691ce
addl $-0x2, %r12d
jmp 0x691ce
decl %r12d
shrl $0x1f, %r15d
leal (%r12,%r15), %esi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movl $0x2d, %edx
callq 0x26a20
addq (%r13), %r15
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x32df4
addq $0x18, %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x26ad0
movq (%r13), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6922c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x268e0
movss 0x129d58(%rip), %xmm1 # 0x192f8c
xorps %xmm0, %xmm0
callq 0x10cf35
movq 0x30(%rbx), %rdi
xorl %esi, %esi
callq 0xcc66d
movq %rbx, %rdi
callq 0x68b00
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZNK22SettingValue_SliderInt6layoutEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
mov rax, [rdi+98h]
mov ecx, [rax+8]
lea rsi, [rsp+58h+var_54]; char *
mov [rsi], ecx
mov rdi, [rdi+78h]; this
mov edx, [rax+0Ch]; int *
mov ecx, [rax+10h]; int
lea r8, aBufcapacityaD+0Eh; int
xor r9d, r9d; char *
call _ZN5ImGui9SliderIntEPKcPiiiS1_i; ImGui::SliderInt(char const*,int *,int,int,char const*,int)
test al, al
jz loc_6922C
mov r14, [rbx+98h]
mov eax, dword ptr [rsp+58h+var_54]
mov r15d, [r14+10h]
cmp r15d, eax
cmovge r15d, eax
mov ecx, [r14+0Ch]
cmp ecx, eax
cmovg r15d, ecx
mov [r14+8], r15d
mov ebp, r15d
neg ebp
cmovs ebp, r15d
mov r12d, 1
cmp ebp, 0Ah
jb short loc_691CE
mov r12d, 4
mov eax, 0D1B71759h
mov ecx, ebp
loc_69192:
cmp ecx, 63h ; 'c'
jbe short loc_691C5
cmp ecx, 3E7h
jbe short loc_691CB
cmp ecx, 2710h
jb short loc_691CE
mov edx, ecx
imul rdx, rax
shr rdx, 2Dh
add r12d, 4
cmp ecx, 1869Fh
mov ecx, edx
ja short loc_69192
add r12d, 0FFFFFFFDh
jmp short loc_691CE
loc_691C5:
add r12d, 0FFFFFFFEh
jmp short loc_691CE
loc_691CB:
dec r12d
loc_691CE:
shr r15d, 1Fh
lea esi, [r12+r15]
lea rax, [rsp+58h+var_40]
mov [rax-10h], rax
lea r13, [rsp+58h+var_50]
mov rdi, r13
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
add r15, [r13+0]
mov rdi, r15
mov esi, r12d
mov edx, ebp
call _ZNSt8__detail18__to_chars_10_implIjEEvPcjT_; std::__detail::__to_chars_10_impl<uint>(char *,uint,uint)
add r14, 18h
mov rdi, r14
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r13+0]; this
lea rax, [rsp+58h+var_40]
cmp rdi, rax
jz short loc_6922C
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6922C:
movss xmm1, cs:flt_192F8C; float
xorps xmm0, xmm0; float
call _ZN5ImGui8SameLineEff; ImGui::SameLine(float,float)
mov rdi, [rbx+30h]; this
xor esi, esi; char *
call _ZN5ImGui15TextUnformattedEPKcS1_; ImGui::TextUnformatted(char const*,char const*)
mov rdi, rbx; this
call _ZNK12SettingValue14layout_tooltipEv; SettingValue::layout_tooltip(void)
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| void SettingValue_SliderInt::layout(SettingValue_SliderInt *this)
{
_DWORD *v2; // rax
ImGui *v3; // rdi
_DWORD *v4; // r14
int v5; // r15d
unsigned int v6; // ebp
int v7; // r12d
unsigned int v8; // ecx
bool v9; // cc
unsigned int v10; // r15d
double v11; // xmm0_8
const char *v12; // rdx
int v13; // [rsp+0h] [rbp-58h]
char v14[4]; // [rsp+4h] [rbp-54h] BYREF
void *v15[2]; // [rsp+8h] [rbp-50h] BYREF
_QWORD v16[8]; // [rsp+18h] [rbp-40h] BYREF
v2 = (_DWORD *)*((_QWORD *)this + 19);
*(_DWORD *)v14 = v2[2];
v3 = (ImGui *)*((_QWORD *)this + 15);
if ( (unsigned __int8)ImGui::SliderInt(v3, v14, (int *)(unsigned int)v2[3], v2[4], (int)"%d", 0LL, v13) )
{
v4 = (_DWORD *)*((_QWORD *)this + 19);
v5 = v4[4];
if ( v5 >= *(int *)v14 )
v5 = *(_DWORD *)v14;
if ( v4[3] > *(int *)v14 )
v5 = v4[3];
v4[2] = v5;
v6 = -v5;
if ( v5 > 0 )
v6 = v5;
v7 = 1;
if ( v6 >= 0xA )
{
v7 = 4;
v8 = v6;
while ( 1 )
{
if ( v8 <= 0x63 )
{
v7 -= 2;
goto LABEL_17;
}
if ( v8 <= 0x3E7 )
break;
if ( v8 < 0x2710 )
goto LABEL_17;
v7 += 4;
v9 = v8 <= 0x1869F;
v8 /= 0x2710u;
if ( v9 )
{
v7 -= 3;
goto LABEL_17;
}
}
--v7;
}
LABEL_17:
v10 = (unsigned int)v5 >> 31;
v15[0] = v16;
v11 = std::string::_M_construct(v15, v7 + v10, 45LL);
std::__detail::__to_chars_10_impl<unsigned int>((char *)v15[0] + v10, v7, v6);
std::string::operator=(v4 + 6, v15, v11);
v3 = (ImGui *)v15[0];
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
}
ImGui::SameLine(v3, 0.0, -1.0);
ImGui::TextUnformatted(*((ImGui **)this + 6), 0LL, v12);
SettingValue::layout_tooltip((ImGui **)this, 0LL);
}
| layout:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x98]
MOV ECX,dword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x4]
MOV dword ptr [RSI],ECX
MOV RDI,qword ptr [RDI + 0x78]
MOV EDX,dword ptr [RAX + 0xc]
MOV ECX,dword ptr [RAX + 0x10]
LEA R8,[0x2d12f4]
XOR R9D,R9D
CALL 0x001d4d40
TEST AL,AL
JZ 0x0016922c
MOV R14,qword ptr [RBX + 0x98]
MOV EAX,dword ptr [RSP + 0x4]
MOV R15D,dword ptr [R14 + 0x10]
CMP R15D,EAX
CMOVGE R15D,EAX
MOV ECX,dword ptr [R14 + 0xc]
CMP ECX,EAX
CMOVG R15D,ECX
MOV dword ptr [R14 + 0x8],R15D
MOV EBP,R15D
NEG EBP
CMOVS EBP,R15D
MOV R12D,0x1
CMP EBP,0xa
JC 0x001691ce
MOV R12D,0x4
MOV EAX,0xd1b71759
MOV ECX,EBP
LAB_00169192:
CMP ECX,0x63
JBE 0x001691c5
CMP ECX,0x3e7
JBE 0x001691cb
CMP ECX,0x2710
JC 0x001691ce
MOV EDX,ECX
IMUL RDX,RAX
SHR RDX,0x2d
ADD R12D,0x4
CMP ECX,0x1869f
MOV ECX,EDX
JA 0x00169192
ADD R12D,-0x3
JMP 0x001691ce
LAB_001691c5:
ADD R12D,-0x2
JMP 0x001691ce
LAB_001691cb:
DEC R12D
LAB_001691ce:
SHR R15D,0x1f
LEA ESI,[R12 + R15*0x1]
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LEA R13,[RSP + 0x8]
MOV RDI,R13
MOV EDX,0x2d
CALL 0x00126a20
ADD R15,qword ptr [R13]
MOV RDI,R15
MOV ESI,R12D
MOV EDX,EBP
CALL 0x00132df4
ADD R14,0x18
MOV RDI,R14
MOV RSI,R13
CALL 0x00126ad0
MOV RDI,qword ptr [R13]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x0016922c
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001268e0
LAB_0016922c:
MOVSS XMM1,dword ptr [0x00292f8c]
XORPS XMM0,XMM0
CALL 0x0020cf35
MOV RDI,qword ptr [RBX + 0x30]
XOR ESI,ESI
CALL 0x001cc66d
MOV RDI,RBX
CALL 0x00168b00
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* SettingValue_SliderInt::layout() const */
void __thiscall SettingValue_SliderInt::layout(SettingValue_SliderInt *this)
{
long lVar1;
uint uVar2;
uint uVar3;
char cVar4;
uint uVar5;
ulong uVar6;
uint uVar7;
uint uVar8;
uint local_54;
long *local_50 [2];
long local_40 [2];
lVar1 = *(long *)(this + 0x98);
local_54 = *(uint *)(lVar1 + 8);
cVar4 = ImGui::SliderInt(*(char **)(this + 0x78),(int *)&local_54,*(int *)(lVar1 + 0xc),
*(int *)(lVar1 + 0x10),"%d",0);
if (cVar4 != '\0') {
lVar1 = *(long *)(this + 0x98);
uVar8 = *(uint *)(lVar1 + 0x10);
if ((int)local_54 <= (int)*(uint *)(lVar1 + 0x10)) {
uVar8 = local_54;
}
if ((int)local_54 < (int)*(uint *)(lVar1 + 0xc)) {
uVar8 = *(uint *)(lVar1 + 0xc);
}
*(uint *)(lVar1 + 8) = uVar8;
uVar2 = -uVar8;
if (0 < (int)uVar8) {
uVar2 = uVar8;
}
uVar7 = 1;
if (9 < uVar2) {
uVar6 = (ulong)uVar2;
uVar3 = 4;
do {
uVar7 = uVar3;
uVar5 = (uint)uVar6;
if (uVar5 < 100) {
uVar7 = uVar7 - 2;
goto LAB_001691ce;
}
if (uVar5 < 1000) {
uVar7 = uVar7 - 1;
goto LAB_001691ce;
}
if (uVar5 < 10000) goto LAB_001691ce;
uVar6 = uVar6 / 10000;
uVar3 = uVar7 + 4;
} while (99999 < uVar5);
uVar7 = uVar7 + 1;
}
LAB_001691ce:
local_50[0] = local_40;
std::__cxx11::string::_M_construct((ulong)local_50,(char)uVar7 - (char)((int)uVar8 >> 0x1f));
std::__detail::__to_chars_10_impl<unsigned_int>
((char *)((ulong)(uVar8 >> 0x1f) + (long)local_50[0]),uVar7,uVar2);
std::__cxx11::string::operator=((string *)(lVar1 + 0x18),(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
}
ImGui::SameLine(0.0,DAT_00292f8c);
ImGui::TextUnformatted(*(char **)(this + 0x30),(char *)0x0);
SettingValue::layout_tooltip((SettingValue *)this);
return;
}
| |
26,020 | my_wc_mb_euc_kr | eloqsql/strings/ctype-euc_kr.c | static int
my_wc_mb_euc_kr(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((uint) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_ksc5601_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL2;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
} | O3 | c | my_wc_mb_euc_kr:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x53156
cmpl $0x7f, %esi
ja 0x53157
movb %sil, (%rdx)
movl $0x1, %eax
retq
leal -0xa1(%rsi), %eax
cmpl $0xc6, %eax
ja 0x53172
movl %eax, %eax
leaq 0x97df3(%rip), %rsi # 0xeaf60
jmp 0x5326a
leal -0x2c7(%rsi), %eax
cmpl $0x18a, %eax # imm = 0x18A
ja 0x5318d
movl %eax, %eax
leaq 0x97f68(%rip), %rsi # 0xeb0f0
jmp 0x5326a
leal -0x2015(%rsi), %eax
cmpl $0x2fd, %eax # imm = 0x2FD
ja 0x531a8
movl %eax, %eax
leaq 0x9826d(%rip), %rsi # 0xeb410
jmp 0x5326a
leal -0x2460(%rsi), %eax
cmpl $0x20d, %eax # imm = 0x20D
ja 0x531c3
movl %eax, %eax
leaq 0x98852(%rip), %rsi # 0xeba10
jmp 0x5326a
leal -0x3000(%rsi), %eax
cmpl $0x27f, %eax # imm = 0x27F
ja 0x531de
movl %eax, %eax
leaq 0x98c57(%rip), %rsi # 0xebe30
jmp 0x5326a
leal -0x3380(%rsi), %eax
cmpl $0x5d, %eax
ja 0x531f4
movl %eax, %eax
leaq 0x9913e(%rip), %rsi # 0xec330
jmp 0x5326a
leal -0x4e00(%rsi), %eax
cmpl $0x467f, %eax # imm = 0x467F
ja 0x5320c
movl %eax, %eax
leaq 0x991e6(%rip), %rsi # 0xec3f0
jmp 0x5326a
leal -0x9577(%rsi), %eax
cmpl $0xa25, %eax # imm = 0xA25
ja 0x53224
movl %eax, %eax
leaq 0xa1ece(%rip), %rsi # 0xf50f0
jmp 0x5326a
leal -0xac00(%rsi), %eax
cmpl $0x2ba3, %eax # imm = 0x2BA3
ja 0x5323c
movl %eax, %eax
leaq 0xa3306(%rip), %rsi # 0xf6540
jmp 0x5326a
leal -0xf900(%rsi), %eax
cmpl $0x10b, %eax # imm = 0x10B
ja 0x53254
movl %eax, %eax
leaq 0xa8a3e(%rip), %rsi # 0xfbc90
jmp 0x5326a
leal -0xff01(%rsi), %eax
cmpl $0xe5, %eax
ja 0x5329a
movl %eax, %eax
leaq 0xa8c46(%rip), %rsi # 0xfbeb0
leaq (%rsi,%rax,2), %rax
pushq %rbp
movq %rsp, %rbp
movzwl (%rax), %esi
testw %si, %si
je 0x53296
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x53298
rolw $0x8, %si
movw %si, (%rdx)
movl $0x2, %eax
jmp 0x53298
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
| my_wc_mb_euc_kr:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_53156
cmp esi, 7Fh
ja short loc_53157
mov [rdx], sil
mov eax, 1
locret_53156:
retn
loc_53157:
lea eax, [rsi-0A1h]
cmp eax, 0C6h
ja short loc_53172
mov eax, eax
lea rsi, tab_uni_ksc56010
jmp loc_5326A
loc_53172:
lea eax, [rsi-2C7h]
cmp eax, 18Ah
ja short loc_5318D
mov eax, eax
lea rsi, tab_uni_ksc56011
jmp loc_5326A
loc_5318D:
lea eax, [rsi-2015h]
cmp eax, 2FDh
ja short loc_531A8
mov eax, eax
lea rsi, tab_uni_ksc56012
jmp loc_5326A
loc_531A8:
lea eax, [rsi-2460h]
cmp eax, 20Dh
ja short loc_531C3
mov eax, eax
lea rsi, tab_uni_ksc56013
jmp loc_5326A
loc_531C3:
lea eax, [rsi-3000h]
cmp eax, 27Fh
ja short loc_531DE
mov eax, eax
lea rsi, tab_uni_ksc56014
jmp loc_5326A
loc_531DE:
lea eax, [rsi-3380h]
cmp eax, 5Dh ; ']'
ja short loc_531F4
mov eax, eax
lea rsi, tab_uni_ksc56015
jmp short loc_5326A
loc_531F4:
lea eax, [rsi-4E00h]
cmp eax, 467Fh
ja short loc_5320C
mov eax, eax
lea rsi, tab_uni_ksc56016
jmp short loc_5326A
loc_5320C:
lea eax, [rsi-9577h]
cmp eax, 0A25h
ja short loc_53224
mov eax, eax
lea rsi, tab_uni_ksc56017
jmp short loc_5326A
loc_53224:
lea eax, [rsi-0AC00h]
cmp eax, 2BA3h
ja short loc_5323C
mov eax, eax
lea rsi, tab_uni_ksc56018
jmp short loc_5326A
loc_5323C:
lea eax, [rsi-0F900h]
cmp eax, 10Bh
ja short loc_53254
mov eax, eax
lea rsi, tab_uni_ksc56019
jmp short loc_5326A
loc_53254:
lea eax, [rsi-0FF01h]
cmp eax, 0E5h
ja short loc_5329A
mov eax, eax
lea rsi, tab_uni_ksc560110
loc_5326A:
lea rax, [rsi+rax*2]
push rbp
mov rbp, rsp
movzx esi, word ptr [rax]
test si, si
jz short loc_53296
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_53298
rol si, 8
mov [rdx], si
mov eax, 2
jmp short loc_53298
loc_53296:
xor eax, eax
loc_53298:
pop rbp
retn
loc_5329A:
xor eax, eax
retn
| long long my_wc_mb_euc_kr(long long a1, unsigned int a2, _WORD *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rax
_WORD *v6; // rsi
__int16 v7; // si
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
if ( a2 > 0x7F )
{
LODWORD(v5) = a2 - 161;
if ( a2 - 161 > 0xC6 )
{
LODWORD(v5) = a2 - 711;
if ( a2 - 711 > 0x18A )
{
LODWORD(v5) = a2 - 8213;
if ( a2 - 8213 > 0x2FD )
{
LODWORD(v5) = a2 - 9312;
if ( a2 - 9312 > 0x20D )
{
LODWORD(v5) = a2 - 12288;
if ( a2 - 12288 > 0x27F )
{
LODWORD(v5) = a2 - 13184;
if ( a2 - 13184 > 0x5D )
{
LODWORD(v5) = a2 - 19968;
if ( a2 - 19968 > 0x467F )
{
LODWORD(v5) = a2 - 38263;
if ( a2 - 38263 > 0xA25 )
{
LODWORD(v5) = a2 - 44032;
if ( a2 - 44032 > 0x2BA3 )
{
LODWORD(v5) = a2 - 63744;
if ( a2 - 63744 > 0x10B )
{
LODWORD(v5) = a2 - 65281;
if ( a2 - 65281 > 0xE5 )
return 0LL;
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc560110;
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56019;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56018;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56017;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56016;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56015;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56014;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56013;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56012;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56011;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_ksc56010;
}
v7 = v6[v5];
if ( v7 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
*a3 = __ROL2__(v7, 8);
return 2LL;
}
}
else
{
return 0LL;
}
}
else
{
*(_BYTE *)a3 = a2;
return 1LL;
}
}
return result;
}
| my_wc_mb_euc_kr:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x00153156
CMP ESI,0x7f
JA 0x00153157
MOV byte ptr [RDX],SIL
MOV EAX,0x1
LAB_00153156:
RET
LAB_00153157:
LEA EAX,[RSI + -0xa1]
CMP EAX,0xc6
JA 0x00153172
MOV EAX,EAX
LEA RSI,[0x1eaf60]
JMP 0x0015326a
LAB_00153172:
LEA EAX,[RSI + -0x2c7]
CMP EAX,0x18a
JA 0x0015318d
MOV EAX,EAX
LEA RSI,[0x1eb0f0]
JMP 0x0015326a
LAB_0015318d:
LEA EAX,[RSI + -0x2015]
CMP EAX,0x2fd
JA 0x001531a8
MOV EAX,EAX
LEA RSI,[0x1eb410]
JMP 0x0015326a
LAB_001531a8:
LEA EAX,[RSI + -0x2460]
CMP EAX,0x20d
JA 0x001531c3
MOV EAX,EAX
LEA RSI,[0x1eba10]
JMP 0x0015326a
LAB_001531c3:
LEA EAX,[RSI + -0x3000]
CMP EAX,0x27f
JA 0x001531de
MOV EAX,EAX
LEA RSI,[0x1ebe30]
JMP 0x0015326a
LAB_001531de:
LEA EAX,[RSI + -0x3380]
CMP EAX,0x5d
JA 0x001531f4
MOV EAX,EAX
LEA RSI,[0x1ec330]
JMP 0x0015326a
LAB_001531f4:
LEA EAX,[RSI + -0x4e00]
CMP EAX,0x467f
JA 0x0015320c
MOV EAX,EAX
LEA RSI,[0x1ec3f0]
JMP 0x0015326a
LAB_0015320c:
LEA EAX,[RSI + -0x9577]
CMP EAX,0xa25
JA 0x00153224
MOV EAX,EAX
LEA RSI,[0x1f50f0]
JMP 0x0015326a
LAB_00153224:
LEA EAX,[RSI + -0xac00]
CMP EAX,0x2ba3
JA 0x0015323c
MOV EAX,EAX
LEA RSI,[0x1f6540]
JMP 0x0015326a
LAB_0015323c:
LEA EAX,[RSI + -0xf900]
CMP EAX,0x10b
JA 0x00153254
MOV EAX,EAX
LEA RSI,[0x1fbc90]
JMP 0x0015326a
LAB_00153254:
LEA EAX,[RSI + -0xff01]
CMP EAX,0xe5
JA 0x0015329a
MOV EAX,EAX
LEA RSI,[0x1fbeb0]
LAB_0015326a:
LEA RAX,[RSI + RAX*0x2]
PUSH RBP
MOV RBP,RSP
MOVZX ESI,word ptr [RAX]
TEST SI,SI
JZ 0x00153296
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x00153298
ROL SI,0x8
MOV word ptr [RDX],SI
MOV EAX,0x2
JMP 0x00153298
LAB_00153296:
XOR EAX,EAX
LAB_00153298:
POP RBP
RET
LAB_0015329a:
XOR EAX,EAX
RET
|
int8 my_wc_mb_euc_kr(int8 param_1,uint param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
int8 uVar2;
ulong uVar3;
int1 *puVar4;
uVar2 = 0xffffff9b;
if (param_3 < param_4) {
if (0x7f < param_2) {
if (param_2 - 0xa1 < 199) {
uVar3 = (ulong)(param_2 - 0xa1);
puVar4 = tab_uni_ksc56010;
}
else if (param_2 - 0x2c7 < 0x18b) {
uVar3 = (ulong)(param_2 - 0x2c7);
puVar4 = tab_uni_ksc56011;
}
else if (param_2 - 0x2015 < 0x2fe) {
uVar3 = (ulong)(param_2 - 0x2015);
puVar4 = tab_uni_ksc56012;
}
else if (param_2 - 0x2460 < 0x20e) {
uVar3 = (ulong)(param_2 - 0x2460);
puVar4 = tab_uni_ksc56013;
}
else if (param_2 - 0x3000 < 0x280) {
uVar3 = (ulong)(param_2 - 0x3000);
puVar4 = tab_uni_ksc56014;
}
else if (param_2 - 0x3380 < 0x5e) {
uVar3 = (ulong)(param_2 - 0x3380);
puVar4 = tab_uni_ksc56015;
}
else if (param_2 - 0x4e00 < 0x4680) {
uVar3 = (ulong)(param_2 - 0x4e00);
puVar4 = tab_uni_ksc56016;
}
else if (param_2 - 0x9577 < 0xa26) {
uVar3 = (ulong)(param_2 - 0x9577);
puVar4 = tab_uni_ksc56017;
}
else if (param_2 - 0xac00 < 0x2ba4) {
uVar3 = (ulong)(param_2 - 0xac00);
puVar4 = tab_uni_ksc56018;
}
else if (param_2 - 0xf900 < 0x10c) {
uVar3 = (ulong)(param_2 - 0xf900);
puVar4 = tab_uni_ksc56019;
}
else {
uVar3 = (ulong)(param_2 - 0xff01);
if (0xe5 < param_2 - 0xff01) {
return 0;
}
puVar4 = tab_uni_ksc560110;
}
uVar1 = *(ushort *)(puVar4 + uVar3 * 2);
if (uVar1 == 0) {
uVar2 = 0;
}
else {
uVar2 = 0xffffff9a;
if (param_3 + 1 <= param_4) {
*param_3 = uVar1 << 8 | uVar1 >> 8;
uVar2 = 2;
}
}
return uVar2;
}
*(char *)param_3 = (char)param_2;
uVar2 = 1;
}
return uVar2;
}
| |
26,021 | blst_aggregate_in_g2 | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/aggregate.c | BLST_ERROR blst_aggregate_in_g2(POINTonE2 *out, const POINTonE2 *in,
const unsigned char *zwire)
{
POINTonE2 P[1];
BLST_ERROR ret;
ret = POINTonE2_Deserialize_Z((POINTonE2_affine *)P, zwire);
if (ret != BLST_SUCCESS)
return ret;
if (vec_is_zero(P, sizeof(POINTonE2_affine))) {
if (in == NULL)
vec_zero(out, sizeof(*out));
return BLST_SUCCESS;
}
vec_copy(P->Z, BLS12_381_Rx.p, sizeof(P->Z));
if (!POINTonE2_in_G2(P))
return BLST_POINT_NOT_IN_GROUP;
if (in == NULL) {
vec_copy(out, P, sizeof(P));
} else {
POINTonE2_dadd_affine(out, in, (POINTonE2_affine *)P);
}
return BLST_SUCCESS;
} | O0 | c | blst_aggregate_in_g2:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x140(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x26e60
movl %eax, -0x144(%rbp)
cmpl $0x0, -0x144(%rbp)
je 0x2ca84
movl -0x144(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2cb2c
leaq -0x140(%rbp), %rdi
movl $0xc0, %esi
callq 0x23820
cmpq $0x0, %rax
je 0x2cab9
cmpq $0x0, -0x18(%rbp)
jne 0x2cab0
movq -0x10(%rbp), %rdi
movl $0x120, %esi # imm = 0x120
callq 0x23310
movl $0x0, -0x4(%rbp)
jmp 0x2cb2c
leaq -0x140(%rbp), %rdi
addq $0xc0, %rdi
leaq 0x2825a(%rip), %rsi # 0x54d28
movl $0x60, %edx
callq 0x23620
leaq -0x140(%rbp), %rdi
callq 0x29360
cmpq $0x0, %rax
jne 0x2caf3
movl $0x3, -0x4(%rbp)
jmp 0x2cb2c
cmpq $0x0, -0x18(%rbp)
jne 0x2cb11
movq -0x10(%rbp), %rdi
leaq -0x140(%rbp), %rsi
movl $0x120, %edx # imm = 0x120
callq 0x23620
jmp 0x2cb25
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x140(%rbp), %rdx
callq 0x27c90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x150, %rsp # imm = 0x150
popq %rbp
retq
nopl (%rax,%rax)
| blst_aggregate_in_g2:
push rbp
mov rbp, rsp
sub rsp, 150h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
lea rdi, [rbp+var_140]
mov rsi, [rbp+var_20]
call POINTonE2_Deserialize_Z
mov [rbp+var_144], eax
cmp [rbp+var_144], 0
jz short loc_2CA84
mov eax, [rbp+var_144]
mov [rbp+var_4], eax
jmp loc_2CB2C
loc_2CA84:
lea rdi, [rbp+var_140]
mov esi, 0C0h
call vec_is_zero
cmp rax, 0
jz short loc_2CAB9
cmp [rbp+var_18], 0
jnz short loc_2CAB0
mov rdi, [rbp+var_10]
mov esi, 120h
call vec_zero
loc_2CAB0:
mov [rbp+var_4], 0
jmp short loc_2CB2C
loc_2CAB9:
lea rdi, [rbp+var_140]
add rdi, 0C0h
lea rsi, BLS12_381_Rx
mov edx, 60h ; '`'
call vec_copy
lea rdi, [rbp+var_140]
call POINTonE2_in_G2
cmp rax, 0
jnz short loc_2CAF3
mov [rbp+var_4], 3
jmp short loc_2CB2C
loc_2CAF3:
cmp [rbp+var_18], 0
jnz short loc_2CB11
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_140]
mov edx, 120h
call vec_copy
jmp short loc_2CB25
loc_2CB11:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
lea rdx, [rbp+var_140]
call POINTonE2_dadd_affine
loc_2CB25:
mov [rbp+var_4], 0
loc_2CB2C:
mov eax, [rbp+var_4]
add rsp, 150h
pop rbp
retn
| long long blst_aggregate_in_g2(long long a1, long long a2, char *a3)
{
unsigned int v4; // [rsp+Ch] [rbp-144h]
_BYTE v5[192]; // [rsp+10h] [rbp-140h] BYREF
_QWORD v6[13]; // [rsp+D0h] [rbp-80h] BYREF
long long v7; // [rsp+138h] [rbp-18h]
long long v8; // [rsp+140h] [rbp-10h]
v8 = a1;
v7 = a2;
v6[12] = a3;
v4 = POINTonE2_Deserialize_Z((long long)v5, a3);
if ( v4 )
{
return v4;
}
else if ( vec_is_zero((long long)v5, 0xC0uLL) )
{
if ( !v7 )
vec_zero(v8, 0x120uLL);
return 0;
}
else
{
vec_copy((long long)v6, (long long)&BLS12_381_Rx, 0x60uLL);
if ( POINTonE2_in_G2((long long)v5) )
{
if ( v7 )
POINTonE2_dadd_affine(v8, v7, (long long)v5);
else
vec_copy(v8, (long long)v5, 0x120uLL);
return 0;
}
else
{
return 3;
}
}
}
| blst_aggregate_in_g2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x150
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
LEA RDI,[RBP + -0x140]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00126e60
MOV dword ptr [RBP + -0x144],EAX
CMP dword ptr [RBP + -0x144],0x0
JZ 0x0012ca84
MOV EAX,dword ptr [RBP + -0x144]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0012cb2c
LAB_0012ca84:
LEA RDI,[RBP + -0x140]
MOV ESI,0xc0
CALL 0x00123820
CMP RAX,0x0
JZ 0x0012cab9
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x0012cab0
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x120
CALL 0x00123310
LAB_0012cab0:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0012cb2c
LAB_0012cab9:
LEA RDI,[RBP + -0x140]
ADD RDI,0xc0
LEA RSI,[0x154d28]
MOV EDX,0x60
CALL 0x00123620
LEA RDI,[RBP + -0x140]
CALL 0x00129360
CMP RAX,0x0
JNZ 0x0012caf3
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0012cb2c
LAB_0012caf3:
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x0012cb11
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x140]
MOV EDX,0x120
CALL 0x00123620
JMP 0x0012cb25
LAB_0012cb11:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
LEA RDX,[RBP + -0x140]
CALL 0x00127c90
LAB_0012cb25:
MOV dword ptr [RBP + -0x4],0x0
LAB_0012cb2c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x150
POP RBP
RET
|
int blst_aggregate_in_g2(int8 param_1,long param_2,int8 param_3)
{
long lVar1;
int1 local_148 [192];
int1 auStack_88 [96];
int8 local_28;
long local_20;
int8 local_18;
int local_c;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_c = POINTonE2_Deserialize_Z(local_148,param_3);
if (local_c == 0) {
lVar1 = vec_is_zero(local_148,0xc0);
if (lVar1 == 0) {
vec_copy(auStack_88,BLS12_381_Rx,0x60);
lVar1 = POINTonE2_in_G2(local_148);
if (lVar1 == 0) {
local_c = 3;
}
else {
if (local_20 == 0) {
vec_copy(local_18,local_148,0x120);
}
else {
POINTonE2_dadd_affine(local_18,local_20,local_148);
}
local_c = 0;
}
}
else {
if (local_20 == 0) {
vec_zero(local_18,0x120);
}
local_c = 0;
}
}
return local_c;
}
| |
26,022 | ssz_union_selector | corpus-core[P]colibri-stateless/src/util/ssz_builder.c | uint8_t ssz_union_selector(const ssz_def_t* union_types, size_t union_types_len, const char* name, const ssz_def_t** def) {
*def = NULL;
for (int i = 0; i < union_types_len; i++) {
if (union_types[i].name == name || strcmp(union_types[i].name, name) == 0) {
*def = union_types + i;
return i;
}
}
return 0;
} | O0 | c | ssz_union_selector:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xa40d7
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
je 0xa40ac
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x233f0
cmpl $0x0, %eax
jne 0xa40ca
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
movb %al, -0x1(%rbp)
jmp 0xa40db
jmp 0xa40cc
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa406a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ssz_union_selector:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_28]
mov qword ptr [rax], 0
mov [rbp+var_2C], 0
loc_A406A:
movsxd rax, [rbp+var_2C]
cmp rax, [rbp+var_18]
jnb short loc_A40D7
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_2C]
shl rcx, 5
add rax, rcx
mov rax, [rax]
cmp rax, [rbp+var_20]
jz short loc_A40AC
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_2C]
shl rcx, 5
add rax, rcx
mov rdi, [rax]
mov rsi, [rbp+var_20]
call _strcmp
cmp eax, 0
jnz short loc_A40CA
loc_A40AC:
mov rcx, [rbp+var_10]
movsxd rax, [rbp+var_2C]
shl rax, 5
add rcx, rax
mov rax, [rbp+var_28]
mov [rax], rcx
mov eax, [rbp+var_2C]
mov [rbp+var_1], al
jmp short loc_A40DB
loc_A40CA:
jmp short $+2
loc_A40CC:
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp short loc_A406A
loc_A40D7:
mov [rbp+var_1], 0
loc_A40DB:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char ssz_union_selector(long long a1, unsigned long long a2, long long a3, _QWORD *a4)
{
int i; // [rsp+4h] [rbp-2Ch]
*a4 = 0LL;
for ( i = 0; i < a2; ++i )
{
if ( *(_QWORD *)(32LL * i + a1) == a3 || !(unsigned int)strcmp(*(_QWORD *)(32LL * i + a1), a3, a3) )
{
*a4 = 32LL * i + a1;
return i;
}
}
return 0;
}
| ssz_union_selector:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],0x0
MOV dword ptr [RBP + -0x2c],0x0
LAB_001a406a:
MOVSXD RAX,dword ptr [RBP + -0x2c]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x001a40d7
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x2c]
SHL RCX,0x5
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001a40ac
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x2c]
SHL RCX,0x5
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001233f0
CMP EAX,0x0
JNZ 0x001a40ca
LAB_001a40ac:
MOV RCX,qword ptr [RBP + -0x10]
MOVSXD RAX,dword ptr [RBP + -0x2c]
SHL RAX,0x5
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0x2c]
MOV byte ptr [RBP + -0x1],AL
JMP 0x001a40db
LAB_001a40ca:
JMP 0x001a40cc
LAB_001a40cc:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001a406a
LAB_001a40d7:
MOV byte ptr [RBP + -0x1],0x0
LAB_001a40db:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int8 ssz_union_selector(long param_1,ulong param_2,char *param_3,long *param_4)
{
int iVar1;
ulong uVar2;
int4 local_34;
int1 local_9;
*param_4 = 0;
local_34 = 0;
do {
uVar2 = (ulong)(int)local_34;
if (param_2 <= uVar2) {
local_9 = 0;
LAB_001a40db:
return CONCAT71((int7)(uVar2 >> 8),local_9);
}
if (*(char **)(param_1 + (long)(int)local_34 * 0x20) == param_3) {
LAB_001a40ac:
*param_4 = param_1 + (long)(int)local_34 * 0x20;
uVar2 = (ulong)local_34;
local_9 = (int1)local_34;
goto LAB_001a40db;
}
iVar1 = strcmp(*(char **)(param_1 + (long)(int)local_34 * 0x20),param_3);
if (iVar1 == 0) goto LAB_001a40ac;
local_34 = local_34 + 1;
} while( true );
}
| |
26,023 | ssz_union_selector | corpus-core[P]colibri-stateless/src/util/ssz_builder.c | uint8_t ssz_union_selector(const ssz_def_t* union_types, size_t union_types_len, const char* name, const ssz_def_t** def) {
*def = NULL;
for (int i = 0; i < union_types_len; i++) {
if (union_types[i].name == name || strcmp(union_types[i].name, name) == 0) {
*def = union_types + i;
return i;
}
}
return 0;
} | O3 | c | ssz_union_selector:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq $0x0, (%rcx)
testq %rsi, %rsi
je 0x567c3
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
xorl %ebx, %ebx
movq (%r12), %rdi
cmpq %r15, %rdi
je 0x567c7
movq %r15, %rsi
callq 0x223d0
testl %eax, %eax
je 0x567c7
incq %rbx
addq $0x20, %r12
cmpq %rbx, %r13
jne 0x567a2
xorl %ebx, %ebx
jmp 0x567ca
movq %r12, (%r14)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| ssz_union_selector:
push r15
push r14
push r13
push r12
push rbx
mov qword ptr [rcx], 0
test rsi, rsi
jz short loc_567C3
mov r14, rcx
mov r15, rdx
mov r13, rsi
mov r12, rdi
xor ebx, ebx
loc_567A2:
mov rdi, [r12]
cmp rdi, r15
jz short loc_567C7
mov rsi, r15
call _strcmp
test eax, eax
jz short loc_567C7
inc rbx
add r12, 20h ; ' '
cmp r13, rbx
jnz short loc_567A2
loc_567C3:
xor ebx, ebx
jmp short loc_567CA
loc_567C7:
mov [r14], r12
loc_567CA:
mov eax, ebx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long ssz_union_selector(_QWORD *a1, long long a2, long long a3, _QWORD *a4)
{
long long v7; // rbx
*a4 = 0LL;
if ( a2 )
{
v7 = 0LL;
while ( *a1 != a3 && (unsigned int)strcmp(*a1, a3) )
{
++v7;
a1 += 4;
if ( a2 == v7 )
goto LABEL_6;
}
*a4 = a1;
}
else
{
LABEL_6:
LODWORD(v7) = 0;
}
return (unsigned int)v7;
}
| ssz_union_selector:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV qword ptr [RCX],0x0
TEST RSI,RSI
JZ 0x001567c3
MOV R14,RCX
MOV R15,RDX
MOV R13,RSI
MOV R12,RDI
XOR EBX,EBX
LAB_001567a2:
MOV RDI,qword ptr [R12]
CMP RDI,R15
JZ 0x001567c7
MOV RSI,R15
CALL 0x001223d0
TEST EAX,EAX
JZ 0x001567c7
INC RBX
ADD R12,0x20
CMP R13,RBX
JNZ 0x001567a2
LAB_001567c3:
XOR EBX,EBX
JMP 0x001567ca
LAB_001567c7:
MOV qword ptr [R14],R12
LAB_001567ca:
MOV EAX,EBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
ulong ssz_union_selector(int8 *param_1,ulong param_2,char *param_3,int8 *param_4)
{
int iVar1;
ulong uVar2;
*param_4 = 0;
if (param_2 != 0) {
uVar2 = 0;
do {
if ((char *)*param_1 == param_3) {
LAB_001567c7:
*param_4 = param_1;
goto LAB_001567ca;
}
iVar1 = strcmp((char *)*param_1,param_3);
if (iVar1 == 0) goto LAB_001567c7;
uVar2 = uVar2 + 1;
param_1 = param_1 + 4;
} while (param_2 != uVar2);
}
uVar2 = 0;
LAB_001567ca:
return uVar2 & 0xffffffff;
}
| |
26,024 | mi_alloc_rec_buff | eloqsql/storage/myisam/mi_open.c | uchar *mi_alloc_rec_buff(MI_INFO *info, ulong length, uchar **buf)
{
uint extra;
uint32 UNINIT_VAR(old_length);
if (! *buf || length > (old_length=mi_get_rec_buff_len(info, *buf)))
{
uchar *newptr = *buf;
/* to simplify initial init of info->rec_buf in mi_open and mi_extra */
if (length == (ulong) -1)
{
if (info->s->options & HA_OPTION_COMPRESS_RECORD)
length= MY_MAX(info->s->base.pack_reclength, info->s->max_pack_length);
else
length= info->s->base.pack_reclength;
length= MY_MAX(length, info->s->base.max_key_length);
length= MY_MAX(length, info->s->vreclength);
/* Avoid unnecessary realloc */
if (newptr && length == old_length)
return newptr;
}
extra= ((info->s->options & HA_OPTION_PACK_RECORD) ?
ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
MI_REC_BUFF_OFFSET : 0);
if (extra && newptr)
newptr-= MI_REC_BUFF_OFFSET;
if (!(newptr=(uchar*) my_realloc(mi_key_memory_record_buffer,
(uchar*)newptr, length + extra + 8,
MYF(MY_ALLOW_ZERO_PTR))))
return NULL;
*((uint32 *) newptr)= (uint32) length;
*buf= newptr+(extra ? MI_REC_BUFF_OFFSET : 0);
}
return *buf;
} | O3 | c | mi_alloc_rec_buff:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rax
movq (%rdi), %rcx
testq %rax, %rax
je 0x7fb32
movq 0x318(%rcx), %rdx
andl $0x1, %edx
negq %rdx
andq $-0x18, %rdx
movl (%rax,%rdx), %edx
cmpq %r14, %rdx
jb 0x7fb32
jmp 0x7fbe5
movq 0x318(%rcx), %r15
cmpq $-0x1, %r14
je 0x7fb9a
leaq 0x60(%r14), %rdx
xorl %ecx, %ecx
testb $0x1, %r15b
movq $-0x18, %rsi
cmoveq %rcx, %rsi
cmoveq %r14, %rdx
testq %rax, %rax
leaq 0xb7f956(%rip), %rcx # 0xbff4b8
movl (%rcx), %edi
cmoveq %rax, %rsi
addq %rax, %rsi
addq $0x8, %rdx
movl $0x40, %ecx
callq 0x9fe74
movq %rax, %rcx
movl $0x0, %eax
testq %rcx, %rcx
je 0x7fbe5
movl %r14d, (%rcx)
leaq 0x18(%rcx), %rax
testb $0x1, %r15b
cmoveq %rcx, %rax
movq %rax, (%rbx)
jmp 0x7fbe5
movq 0x148(%rcx), %rsi
testb $0x4, %r15b
je 0x7fbb5
movq 0x328(%rcx), %rdi
cmpq %rdi, %rsi
cmovbeq %rdi, %rsi
movl 0x194(%rcx), %r14d
cmpq %r14, %rsi
cmovaq %rsi, %r14
movq 0x340(%rcx), %rcx
cmpq %rcx, %r14
cmovbeq %rcx, %r14
testq %rax, %rax
je 0x7fb3f
movl %edx, %ecx
cmpq %rcx, %r14
jne 0x7fb3f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mi_alloc_rec_buff:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov rax, [rdx]
mov rcx, [rdi]
test rax, rax
jz short loc_7FB32
mov rdx, [rcx+318h]
and edx, 1
neg rdx
and rdx, 0FFFFFFFFFFFFFFE8h
mov edx, [rax+rdx]
cmp rdx, r14
jb short loc_7FB32
jmp loc_7FBE5
loc_7FB32:
mov r15, [rcx+318h]
cmp r14, 0FFFFFFFFFFFFFFFFh
jz short loc_7FB9A
loc_7FB3F:
lea rdx, [r14+60h]
xor ecx, ecx
test r15b, 1
mov rsi, 0FFFFFFFFFFFFFFE8h
cmovz rsi, rcx
cmovz rdx, r14
test rax, rax
lea rcx, mi_key_memory_record_buffer
mov edi, [rcx]
cmovz rsi, rax
add rsi, rax
add rdx, 8
mov ecx, 40h ; '@'
call my_realloc
mov rcx, rax
mov eax, 0
test rcx, rcx
jz short loc_7FBE5
mov [rcx], r14d
lea rax, [rcx+18h]
test r15b, 1
cmovz rax, rcx
mov [rbx], rax
jmp short loc_7FBE5
loc_7FB9A:
mov rsi, [rcx+148h]
test r15b, 4
jz short loc_7FBB5
mov rdi, [rcx+328h]
cmp rsi, rdi
cmovbe rsi, rdi
loc_7FBB5:
mov r14d, [rcx+194h]
cmp rsi, r14
cmova r14, rsi
mov rcx, [rcx+340h]
cmp r14, rcx
cmovbe r14, rcx
test rax, rax
jz loc_7FB3F
mov ecx, edx
cmp r14, rcx
jnz loc_7FB3F
loc_7FBE5:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| _DWORD * mi_alloc_rec_buff(long long *a1, unsigned long long a2, _QWORD *a3, long long a4, long long a5, long long a6)
{
_QWORD *v6; // rbx
unsigned long long v7; // r14
_DWORD *result; // rax
long long v9; // rcx
long long v10; // r15
unsigned long long v11; // rdx
long long v12; // rsi
_DWORD *v13; // rcx
unsigned long long v14; // rsi
unsigned long long v15; // rcx
v6 = a3;
v7 = a2;
result = (_DWORD *)*a3;
v9 = *a1;
if ( !*a3
|| (a3 = (_QWORD *)*(unsigned int *)((char *)result + (-(*(_QWORD *)(v9 + 792) & 1LL) & 0xFFFFFFFFFFFFFFE8LL)),
(unsigned long long)a3 < a2) )
{
v10 = *(_QWORD *)(v9 + 792);
if ( a2 != -1LL )
goto LABEL_4;
v14 = *(_QWORD *)(v9 + 328);
if ( (v10 & 4) != 0 && v14 <= *(_QWORD *)(v9 + 808) )
v14 = *(_QWORD *)(v9 + 808);
v7 = *(unsigned int *)(v9 + 404);
if ( v14 > v7 )
v7 = v14;
v15 = *(_QWORD *)(v9 + 832);
if ( v7 <= v15 )
v7 = v15;
if ( !result || v7 != (unsigned int)a3 )
{
LABEL_4:
v11 = v7 + 96;
v12 = 0x3FFFFFFFFFFFFFFALL;
if ( (v10 & 1) == 0 )
{
v12 = 0LL;
v11 = v7;
}
if ( !result )
v12 = 0LL;
v13 = (_DWORD *)my_realloc(mi_key_memory_record_buffer, &result[v12], v11 + 8, 64LL, a5, a6);
result = 0LL;
if ( v13 )
{
*v13 = v7;
result = v13 + 6;
if ( (v10 & 1) == 0 )
result = v13;
*v6 = result;
}
}
}
return result;
}
| mi_alloc_rec_buff:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV RAX,qword ptr [RDX]
MOV RCX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0017fb32
MOV RDX,qword ptr [RCX + 0x318]
AND EDX,0x1
NEG RDX
AND RDX,-0x18
MOV EDX,dword ptr [RAX + RDX*0x1]
CMP RDX,R14
JC 0x0017fb32
JMP 0x0017fbe5
LAB_0017fb32:
MOV R15,qword ptr [RCX + 0x318]
CMP R14,-0x1
JZ 0x0017fb9a
LAB_0017fb3f:
LEA RDX,[R14 + 0x60]
XOR ECX,ECX
TEST R15B,0x1
MOV RSI,-0x18
CMOVZ RSI,RCX
CMOVZ RDX,R14
TEST RAX,RAX
LEA RCX,[0xcff4b8]
MOV EDI,dword ptr [RCX]
CMOVZ RSI,RAX
ADD RSI,RAX
ADD RDX,0x8
MOV ECX,0x40
CALL 0x0019fe74
MOV RCX,RAX
MOV EAX,0x0
TEST RCX,RCX
JZ 0x0017fbe5
MOV dword ptr [RCX],R14D
LEA RAX,[RCX + 0x18]
TEST R15B,0x1
CMOVZ RAX,RCX
MOV qword ptr [RBX],RAX
JMP 0x0017fbe5
LAB_0017fb9a:
MOV RSI,qword ptr [RCX + 0x148]
TEST R15B,0x4
JZ 0x0017fbb5
MOV RDI,qword ptr [RCX + 0x328]
CMP RSI,RDI
CMOVBE RSI,RDI
LAB_0017fbb5:
MOV R14D,dword ptr [RCX + 0x194]
CMP RSI,R14
CMOVA R14,RSI
MOV RCX,qword ptr [RCX + 0x340]
CMP R14,RCX
CMOVBE R14,RCX
TEST RAX,RAX
JZ 0x0017fb3f
MOV ECX,EDX
CMP R14,RCX
JNZ 0x0017fb3f
LAB_0017fbe5:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 * mi_alloc_rec_buff(long *param_1,long *param_2,long *param_3)
{
ulong uVar1;
int4 *puVar2;
int4 *puVar3;
long *plVar4;
long lVar5;
long *plVar6;
puVar3 = (int4 *)*param_3;
lVar5 = *param_1;
plVar4 = param_3;
if ((puVar3 == (int4 *)0x0) ||
(plVar4 = (long *)(ulong)*(uint *)((long)puVar3 +
(-(ulong)((uint)*(int8 *)(lVar5 + 0x318) & 1) &
0xffffffffffffffe8)), plVar4 < param_2)) {
uVar1 = *(ulong *)(lVar5 + 0x318);
if (param_2 == (long *)0xffffffffffffffff) {
plVar6 = *(long **)(lVar5 + 0x148);
if (((uVar1 & 4) != 0) && (plVar6 <= *(long **)(lVar5 + 0x328))) {
plVar6 = *(long **)(lVar5 + 0x328);
}
param_2 = (long *)(ulong)*(uint *)(lVar5 + 0x194);
if ((long *)(ulong)*(uint *)(lVar5 + 0x194) < plVar6) {
param_2 = plVar6;
}
if (param_2 <= *(long **)(lVar5 + 0x340)) {
param_2 = *(long **)(lVar5 + 0x340);
}
if ((puVar3 != (int4 *)0x0) && (param_2 == (long *)((ulong)plVar4 & 0xffffffff))) {
return puVar3;
}
}
plVar4 = param_2 + 0xc;
lVar5 = -0x18;
if ((uVar1 & 1) == 0) {
plVar4 = param_2;
lVar5 = 0;
}
if (puVar3 == (int4 *)0x0) {
lVar5 = 0;
}
puVar2 = (int4 *)
my_realloc(mi_key_memory_record_buffer,lVar5 + (long)puVar3,plVar4 + 1,0x40);
puVar3 = (int4 *)0x0;
if (puVar2 != (int4 *)0x0) {
*puVar2 = (int)param_2;
puVar3 = puVar2 + 6;
if ((uVar1 & 1) == 0) {
puVar3 = puVar2;
}
*param_3 = (long)puVar3;
}
}
return puVar3;
}
| |
26,025 | rak_number_value_from_cstr | fabiosvm[P]rak/src/value.c | RakValue rak_number_value_from_cstr(int len, const char *cstr, RakError *err)
{
if (len < 0) len = (int) strlen(cstr);
errno = 0;
double data = strtod(cstr, NULL);
if (errno)
{
rak_error_set(err, "invalid number format");
return rak_nil_value();
}
return rak_number_value(data);
} | O3 | c | rak_number_value_from_cstr:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x2050
movq %rax, %r15
movl $0x0, (%rax)
movq %r14, %rdi
xorl %esi, %esi
callq 0x2060
cmpl $0x0, (%r15)
je 0x81b6
leaq 0x27db(%rip), %rsi # 0xa978
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x666c
movabsq $0x100000000, %rax # imm = 0x100000000
jmp 0x81c0
movq %xmm0, %r14
movl $0x2, %eax
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
retq
| rak_number_value_from_cstr:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
call ___errno_location
mov r15, rax
mov dword ptr [rax], 0
mov rdi, r14
xor esi, esi
call _strtod
cmp dword ptr [r15], 0
jz short loc_81B6
lea rsi, aInvalidNumberF; "invalid number format"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call rak_error_set
mov rax, 100000000h
jmp short loc_81C0
loc_81B6:
movq r14, xmm0
mov eax, 2
loc_81C0:
mov rdx, r14
pop rbx
pop r14
pop r15
retn
| long long rak_number_value_from_cstr(long long a1, long long a2, _BYTE *a3)
{
_DWORD *v4; // r15
v4 = (_DWORD *)__errno_location();
*v4 = 0;
strtod(a2, 0LL);
if ( !*v4 )
return 2LL;
rak_error_set(a3, (long long)"invalid number format");
return 0x100000000LL;
}
| rak_number_value_from_cstr:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
CALL 0x00102050
MOV R15,RAX
MOV dword ptr [RAX],0x0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00102060
CMP dword ptr [R15],0x0
JZ 0x001081b6
LEA RSI,[0x10a978]
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0010666c
MOV RAX,0x100000000
JMP 0x001081c0
LAB_001081b6:
MOVQ R14,XMM0
MOV EAX,0x2
LAB_001081c0:
MOV RDX,R14
POP RBX
POP R14
POP R15
RET
|
int1 [16] rak_number_value_from_cstr(int8 param_1,char *param_2,int8 param_3)
{
int *piVar1;
int8 uVar2;
double dVar3;
int1 auVar4 [16];
piVar1 = __errno_location();
*piVar1 = 0;
dVar3 = strtod(param_2,(char **)0x0);
if (*piVar1 == 0) {
uVar2 = 2;
}
else {
dVar3 = 0.0;
rak_error_set(param_3,"invalid number format");
uVar2 = 0x100000000;
}
auVar4._8_8_ = dVar3;
auVar4._0_8_ = uVar2;
return auVar4;
}
| |
26,026 | my_handler_delete_with_symlink | eloqsql/mysys/my_symlink2.c | int my_handler_delete_with_symlink(const char *filename, myf sync_dir)
{
char real[FN_REFLEN];
int res= 0;
DBUG_ENTER("my_handler_delete_with_symlink");
if (my_is_symlink(filename))
{
/*
Delete the symlinked file only if the symlink is not
pointing into datadir.
*/
if (!(my_realpath(real, filename, MYF(0)) ||
mysys_test_invalid_symlink(real)))
res= my_delete(real, MYF(MY_NOSYMLINKS | sync_dir));
}
DBUG_RETURN(my_delete(filename, sync_dir) || res);
} | O3 | c | my_handler_delete_with_symlink:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
callq 0xa3d78
testl %eax, %eax
je 0xa43c2
xorl %r15d, %r15d
leaq -0x220(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xa3db5
testl %eax, %eax
jne 0xa43c5
leaq 0x2e482b(%rip), %rax # 0x388be0
leaq -0x220(%rbp), %rdi
callq *(%rax)
testl %eax, %eax
je 0xa43fb
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa0e20
testl %eax, %eax
setne %al
movq %fs:0x28, %rcx
cmpq -0x20(%rbp), %rcx
jne 0xa4419
orb %r15b, %al
movzbl %al, %eax
andl $0x1, %eax
addq $0x208, %rsp # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rsi
orq $0x200, %rsi # imm = 0x200
leaq -0x220(%rbp), %rdi
callq 0xa0e20
testl %eax, %eax
setne %r15b
jmp 0xa43c5
callq 0x29220
nop
| my_handler_delete_with_symlink:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 208h
mov rbx, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
call my_is_symlink
test eax, eax
jz short loc_A43C2
xor r15d, r15d
lea rdi, [rbp+var_220]
mov rsi, r14
xor edx, edx
call my_realpath
test eax, eax
jnz short loc_A43C5
lea rax, mysys_test_invalid_symlink
lea rdi, [rbp+var_220]
call qword ptr [rax]
test eax, eax
jz short loc_A43FB
loc_A43C2:
xor r15d, r15d
loc_A43C5:
mov rdi, r14
mov rsi, rbx
call my_delete
test eax, eax
setnz al
mov rcx, fs:28h
cmp rcx, [rbp+var_20]
jnz short loc_A4419
or al, r15b
movzx eax, al
and eax, 1
add rsp, 208h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_A43FB:
mov rsi, rbx
or rsi, 200h
lea rdi, [rbp+var_220]
call my_delete
test eax, eax
setnz r15b
jmp short loc_A43C5
loc_A4419:
call ___stack_chk_fail
| long long my_handler_delete_with_symlink(long long a1, long long a2)
{
bool v2; // r15
_BYTE v4[512]; // [rsp+0h] [rbp-220h] BYREF
unsigned long long v5; // [rsp+200h] [rbp-20h]
v5 = __readfsqword(0x28u);
if ( !my_is_symlink(a1) )
{
LABEL_4:
v2 = 0;
return v2 | (unsigned __int8)((unsigned int)my_delete(a1, a2) != 0);
}
v2 = 0;
if ( !(unsigned int)my_realpath((long long)v4, a1, 0) )
{
if ( !(unsigned int)mysys_test_invalid_symlink() )
{
v2 = (unsigned int)my_delete((long long)v4, a2 | 0x200) != 0;
return v2 | (unsigned __int8)((unsigned int)my_delete(a1, a2) != 0);
}
goto LABEL_4;
}
return v2 | (unsigned __int8)((unsigned int)my_delete(a1, a2) != 0);
}
| my_handler_delete_with_symlink:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x208
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
CALL 0x001a3d78
TEST EAX,EAX
JZ 0x001a43c2
XOR R15D,R15D
LEA RDI,[RBP + -0x220]
MOV RSI,R14
XOR EDX,EDX
CALL 0x001a3db5
TEST EAX,EAX
JNZ 0x001a43c5
LEA RAX,[0x488be0]
LEA RDI,[RBP + -0x220]
CALL qword ptr [RAX]
TEST EAX,EAX
JZ 0x001a43fb
LAB_001a43c2:
XOR R15D,R15D
LAB_001a43c5:
MOV RDI,R14
MOV RSI,RBX
CALL 0x001a0e20
TEST EAX,EAX
SETNZ AL
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x20]
JNZ 0x001a4419
OR AL,R15B
MOVZX EAX,AL
AND EAX,0x1
ADD RSP,0x208
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001a43fb:
MOV RSI,RBX
OR RSI,0x200
LEA RDI,[RBP + -0x220]
CALL 0x001a0e20
TEST EAX,EAX
SETNZ R15B
JMP 0x001a43c5
LAB_001a4419:
CALL 0x00129220
|
byte my_handler_delete_with_symlink(int8 param_1,ulong param_2)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
int1 local_228 [512];
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = my_is_symlink();
if (iVar1 != 0) {
bVar2 = false;
iVar1 = my_realpath(local_228,param_1,0);
if (iVar1 != 0) goto LAB_001a43c5;
iVar1 = (*(code *)mysys_test_invalid_symlink)(local_228);
if (iVar1 == 0) {
iVar1 = my_delete(local_228,param_2 | 0x200);
bVar2 = iVar1 != 0;
goto LAB_001a43c5;
}
}
bVar2 = false;
LAB_001a43c5:
iVar1 = my_delete(param_1,param_2);
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return iVar1 != 0 | bVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
26,027 | mariadb_set_conf_option | eloqsql/libmariadb/libmariadb/mariadb_lib.c | my_bool _mariadb_set_conf_option(MYSQL *mysql, const char *config_option, const char *config_value)
{
if (config_option)
{
int i;
char *c;
/* CONC-395: replace underscore "_" by dash "-" */
while ((c= strchr(config_option, '_')))
*c= '-';
for (i=0; mariadb_defaults[i].conf_key; i++)
{
if (!strcmp(mariadb_defaults[i].conf_key, config_option))
{
my_bool val_bool;
int val_int;
size_t val_sizet;
int rc;
void *option_val= NULL;
switch (mariadb_defaults[i].type) {
case MARIADB_OPTION_FUNC:
return mariadb_defaults[i].u.option_func(mysql, config_option, config_value, -1);
break;
case MARIADB_OPTION_BOOL:
val_bool= 0;
if (config_value)
val_bool= atoi(config_value);
option_val= &val_bool;
break;
case MARIADB_OPTION_INT:
val_int= 0;
if (config_value)
val_int= atoi(config_value);
option_val= &val_int;
break;
case MARIADB_OPTION_SIZET:
val_sizet= 0;
if (config_value)
val_sizet= strtol(config_value, NULL, 10);
option_val= &val_sizet;
break;
case MARIADB_OPTION_STR:
option_val= (void*)config_value;
break;
case MARIADB_OPTION_NONE:
break;
}
rc= mysql_optionsv(mysql, mariadb_defaults[i].u.option, option_val);
return(test(rc));
}
}
}
/* unknown key */
return 1;
} | O3 | c | mariadb_set_conf_option:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movb $0x1, %r12b
testq %rsi, %rsi
je 0x19f6c
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %r15, %rdi
movl $0x5f, %esi
callq 0x13180
testq %rax, %rax
je 0x19e75
movb $0x2d, (%rax)
jmp 0x19e5e
leaq 0x33564(%rip), %r13 # 0x4d3e0
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0x19f6c
movq %r15, %rsi
callq 0x13640
testl %eax, %eax
je 0x19eb9
leaq 0x33544(%rip), %r13 # 0x4d3e0
movq 0x28(%r13), %rdi
testq %rdi, %rdi
je 0x19f6c
movq %r15, %rsi
callq 0x13640
addq $0x18, %r13
testl %eax, %eax
jne 0x19e9c
movl 0x8(%r13), %eax
decl %eax
cmpl $0x4, %eax
ja 0x19f52
leaq 0x22dc5(%rip), %rcx # 0x3cc94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x29(%rbp), %r15
movb $0x0, (%r15)
testq %r14, %r14
je 0x19f55
movq %r14, %rdi
callq 0x136f0
movb %al, -0x29(%rbp)
jmp 0x19f55
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq $-0x1, %rcx
callq *(%r13)
movl %eax, %r12d
jmp 0x19f6c
leaq -0x38(%rbp), %r15
movq $0x0, (%r15)
testq %r14, %r14
je 0x19f55
movq %r14, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x13650
movq %rax, -0x38(%rbp)
jmp 0x19f55
movq %r14, %r15
jmp 0x19f55
leaq -0x30(%rbp), %r15
movl $0x0, (%r15)
testq %r14, %r14
je 0x19f55
movq %r14, %rdi
callq 0x136f0
movl %eax, -0x30(%rbp)
jmp 0x19f55
xorl %r15d, %r15d
movl (%r13), %esi
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19f7e
testl %eax, %eax
setne %r12b
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mariadb_set_conf_option:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12b, 1
test rsi, rsi
jz loc_19F6C
mov r14, rdx
mov r15, rsi
mov rbx, rdi
loc_19E5E:
mov rdi, r15
mov esi, 5Fh ; '_'
call _strchr
test rax, rax
jz short loc_19E75
mov byte ptr [rax], 2Dh ; '-'
jmp short loc_19E5E
loc_19E75:
lea r13, mariadb_defaults
mov rdi, [r13+10h]
test rdi, rdi
jz loc_19F6C
mov rsi, r15
call _strcmp
test eax, eax
jz short loc_19EB9
lea r13, mariadb_defaults
loc_19E9C:
mov rdi, [r13+28h]
test rdi, rdi
jz loc_19F6C
mov rsi, r15
call _strcmp
add r13, 18h
test eax, eax
jnz short loc_19E9C
loc_19EB9:
mov eax, [r13+8]
dec eax; switch 5 cases
cmp eax, 4
ja def_19ED6; jumptable 0000000000019ED6 default case
lea rcx, jpt_19ED6
movsxd rax, ds:(jpt_19ED6 - 3CC94h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_19ED8:
lea r15, [rbp+var_29]; jumptable 0000000000019ED6 case 1
mov byte ptr [r15], 0
test r14, r14
jz short loc_19F55
mov rdi, r14
call _atoi
mov [rbp+var_29], al
jmp short loc_19F55
loc_19EF2:
mov rdi, rbx; jumptable 0000000000019ED6 case 5
mov rsi, r15
mov rdx, r14
mov rcx, 0FFFFFFFFFFFFFFFFh
call qword ptr [r13+0]
mov r12d, eax
jmp short loc_19F6C
loc_19F0B:
lea r15, [rbp+var_38]; jumptable 0000000000019ED6 case 3
mov qword ptr [r15], 0
test r14, r14
jz short loc_19F55
mov rdi, r14
xor esi, esi
mov edx, 0Ah
call _strtol
mov [rbp+var_38], rax
jmp short loc_19F55
loc_19F30:
mov r15, r14; jumptable 0000000000019ED6 case 4
jmp short loc_19F55
loc_19F35:
lea r15, [rbp+var_30]; jumptable 0000000000019ED6 case 2
mov dword ptr [r15], 0
test r14, r14
jz short loc_19F55
mov rdi, r14
call _atoi
mov [rbp+var_30], eax
jmp short loc_19F55
def_19ED6:
xor r15d, r15d; jumptable 0000000000019ED6 default case
loc_19F55:
mov esi, [r13+0]
mov rdi, rbx
mov rdx, r15
xor eax, eax
call mysql_optionsv
test eax, eax
setnz r12b
loc_19F6C:
mov eax, r12d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mariadb_set_conf_option(long long a1, long long a2, long long a3)
{
unsigned int v3; // r12d
_BYTE *v6; // rax
_DWORD *v7; // r13
long long v8; // rdi
int v9; // ecx
int v10; // r8d
int v11; // r9d
long long v12; // rdi
long long *v13; // r15
long long v15; // [rsp+8h] [rbp-38h] BYREF
int v16; // [rsp+10h] [rbp-30h] BYREF
char v17; // [rsp+17h] [rbp-29h] BYREF
LOBYTE(v3) = 1;
if ( a2 )
{
while ( 1 )
{
v6 = (_BYTE *)strchr(a2, 95LL);
if ( !v6 )
break;
*v6 = 45;
}
v7 = &mariadb_defaults;
v8 = *((_QWORD *)&mariadb_defaults + 2);
if ( v8 )
{
if ( !(unsigned int)strcmp(v8, a2) )
{
LABEL_9:
switch ( v7[2] )
{
case 1:
v13 = (long long *)&v17;
v17 = 0;
if ( a3 )
v17 = atoi(a3);
goto LABEL_19;
case 2:
v13 = (long long *)&v16;
v16 = 0;
if ( a3 )
v16 = atoi(a3);
goto LABEL_19;
case 3:
v13 = &v15;
v15 = 0LL;
if ( a3 )
v15 = strtol(a3, 0LL, 10LL);
goto LABEL_19;
case 4:
LODWORD(v13) = a3;
goto LABEL_19;
case 5:
return (*(unsigned int ( **)(long long, long long, long long, long long))v7)(a1, a2, a3, -1LL);
default:
LODWORD(v13) = 0;
LABEL_19:
LOBYTE(v3) = (unsigned int)mysql_optionsv(a1, *v7, (_DWORD)v13, v9, v10, v11) != 0;
break;
}
}
else
{
v7 = &mariadb_defaults;
while ( 1 )
{
v12 = *((_QWORD *)v7 + 5);
if ( !v12 )
break;
v7 += 6;
if ( !(unsigned int)strcmp(v12, a2) )
goto LABEL_9;
}
}
}
}
return v3;
}
| _mariadb_set_conf_option:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12B,0x1
TEST RSI,RSI
JZ 0x00119f6c
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LAB_00119e5e:
MOV RDI,R15
MOV ESI,0x5f
CALL 0x00113180
TEST RAX,RAX
JZ 0x00119e75
MOV byte ptr [RAX],0x2d
JMP 0x00119e5e
LAB_00119e75:
LEA R13,[0x14d3e0]
MOV RDI,qword ptr [R13 + 0x10]
TEST RDI,RDI
JZ 0x00119f6c
MOV RSI,R15
CALL 0x00113640
TEST EAX,EAX
JZ 0x00119eb9
LEA R13,[0x14d3e0]
LAB_00119e9c:
MOV RDI,qword ptr [R13 + 0x28]
TEST RDI,RDI
JZ 0x00119f6c
MOV RSI,R15
CALL 0x00113640
ADD R13,0x18
TEST EAX,EAX
JNZ 0x00119e9c
LAB_00119eb9:
MOV EAX,dword ptr [R13 + 0x8]
DEC EAX
CMP EAX,0x4
JA 0x00119f52
LEA RCX,[0x13cc94]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
LEA R15,[RBP + -0x29]
MOV byte ptr [R15],0x0
TEST R14,R14
JZ 0x00119f55
MOV RDI,R14
CALL 0x001136f0
MOV byte ptr [RBP + -0x29],AL
JMP 0x00119f55
caseD_5:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV RCX,-0x1
CALL qword ptr [R13]
MOV R12D,EAX
JMP 0x00119f6c
caseD_3:
LEA R15,[RBP + -0x38]
MOV qword ptr [R15],0x0
TEST R14,R14
JZ 0x00119f55
MOV RDI,R14
XOR ESI,ESI
MOV EDX,0xa
CALL 0x00113650
MOV qword ptr [RBP + -0x38],RAX
JMP 0x00119f55
caseD_4:
MOV R15,R14
JMP 0x00119f55
caseD_2:
LEA R15,[RBP + -0x30]
MOV dword ptr [R15],0x0
TEST R14,R14
JZ 0x00119f55
MOV RDI,R14
CALL 0x001136f0
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00119f55
default:
XOR R15D,R15D
LAB_00119f55:
MOV ESI,dword ptr [R13]
MOV RDI,RBX
MOV RDX,R15
XOR EAX,EAX
CALL 0x00119f7e
TEST EAX,EAX
SETNZ R12B
LAB_00119f6c:
MOV EAX,R12D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong _mariadb_set_conf_option(int8 param_1,char *param_2,long *param_3)
{
int iVar1;
uint uVar2;
char *pcVar3;
int8 unaff_R12;
ulong uVar4;
int1 *puVar6;
long *plVar7;
long local_40;
int local_38;
int1 local_31;
int7 uVar5;
uVar5 = (int7)((ulong)unaff_R12 >> 8);
uVar4 = CONCAT71(uVar5,1);
if (param_2 != (char *)0x0) {
while (pcVar3 = strchr(param_2,0x5f), pcVar3 != (char *)0x0) {
*pcVar3 = '-';
}
puVar6 = mariadb_defaults;
if (mariadb_defaults._16_8_ != 0) {
iVar1 = strcmp((char *)mariadb_defaults._16_8_,param_2);
if (iVar1 != 0) {
puVar6 = mariadb_defaults;
do {
if (*(char **)((long)puVar6 + 0x28) == (char *)0x0) goto LAB_00119f6c;
iVar1 = strcmp(*(char **)((long)puVar6 + 0x28),param_2);
puVar6 = (int1 *)((long)puVar6 + 0x18);
} while (iVar1 != 0);
}
switch(*(int4 *)((long)puVar6 + 8)) {
case 1:
plVar7 = (long *)&local_31;
local_31 = 0;
if (param_3 != (long *)0x0) {
iVar1 = atoi((char *)param_3);
local_31 = (int1)iVar1;
}
break;
case 2:
plVar7 = (long *)&local_38;
local_38 = 0;
if (param_3 != (long *)0x0) {
local_38 = atoi((char *)param_3);
}
break;
case 3:
plVar7 = &local_40;
local_40 = 0;
if (param_3 != (long *)0x0) {
local_40 = strtol((char *)param_3,(char **)0x0,10);
}
break;
case 4:
plVar7 = param_3;
break;
case 5:
uVar2 = (**(code **)puVar6)(param_1,param_2,param_3,0xffffffffffffffff);
uVar4 = (ulong)uVar2;
goto LAB_00119f6c;
default:
plVar7 = (long *)0x0;
}
iVar1 = mysql_optionsv(param_1,*(int4 *)puVar6,plVar7);
uVar4 = CONCAT71(uVar5,iVar1 != 0);
}
}
LAB_00119f6c:
return uVar4 & 0xffffffff;
}
| |
26,028 | OpenSubdiv::v3_6_0::Far::PatchBuilder::IsFaceAPatch(int, int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchBuilder.cpp | bool
PatchBuilder::IsFaceAPatch(int levelIndex, Index faceIndex) const {
Level const & level = _refiner.getLevel(levelIndex);
// Faces tagged as holes are not patches (no limit surface)
if (_refiner.HasHoles() && level.isFaceHole(faceIndex)) return false;
// Base faces are patches unless an irregular face or incident one:
if (levelIndex == 0) {
if (_schemeIsLinear) {
return level.getFaceVertices(faceIndex).size() == _schemeRegFaceSize;
} else {
return !level.getFaceCompositeVTag(faceIndex)._incidIrregFace;
}
}
// Refined faces are patches unless "incomplete", i.e. they exist solely to
// support an adjacent patch (can only use the more commonly used combined
// VTag for all corners for quads -- need a Refinement tag for tris):
if (_schemeRegFaceSize == 4) {
return !level.getFaceCompositeVTag(faceIndex)._incomplete;
} else {
Refinement const & refinement = _refiner.getRefinement(levelIndex - 1);
return !refinement.getChildFaceTag(faceIndex)._incomplete;
}
} | O0 | cpp | OpenSubdiv::v3_6_0::Far::PatchBuilder::IsFaceAPatch(int, int) const:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xd66c0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0xd25c0
testb $0x1, %al
jne 0x135860
jmp 0x13587b
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xc3150
testb $0x1, %al
jne 0x135872
jmp 0x13587b
movb $0x0, -0x1(%rbp)
jmp 0x135968
cmpl $0x0, -0x14(%rbp)
jne 0x1358fa
movq -0x58(%rbp), %rax
testb $0x1, 0x24(%rax)
je 0x1358c9
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xce580
movl %edx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xcc250
movq -0x58(%rbp), %rcx
cmpl 0x20(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x135968
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0xcc9c0
movw %ax, -0x42(%rbp)
movw -0x42(%rbp), %ax
shrw $0xc, %ax
andw $0x1, %ax
cmpw $0x0, %ax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x135968
movq -0x58(%rbp), %rax
cmpl $0x4, 0x20(%rax)
jne 0x135935
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0xcc9c0
movw %ax, -0x44(%rbp)
movw -0x44(%rbp), %ax
shrw $0xb, %ax
andw $0x1, %ax
cmpw $0x0, %ax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x135968
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0xd4c60
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xcbbb0
movb (%rax), %al
andb $0x1, %al
cmpb $0x0, %al
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZNK10OpenSubdiv6v3_6_03Far12PatchBuilder12IsFaceAPatchEii:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov rax, [rbp+var_10]
mov [rbp+var_58], rax
mov rdi, [rax+8]; this
mov esi, [rbp+var_14]; int
call __ZNK10OpenSubdiv6v3_6_03Far15TopologyRefiner8getLevelEi; OpenSubdiv::v3_6_0::Far::TopologyRefiner::getLevel(int)
mov rcx, rax
mov rax, [rbp+var_58]
mov [rbp+var_20], rcx
mov rdi, [rax+8]; this
call __ZNK10OpenSubdiv6v3_6_03Far15TopologyRefiner8HasHolesEv; OpenSubdiv::v3_6_0::Far::TopologyRefiner::HasHoles(void)
test al, 1
jnz short loc_135860
jmp short loc_13587B
loc_135860:
mov rdi, [rbp+var_20]; this
mov esi, [rbp+var_18]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level10isFaceHoleEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::isFaceHole(int)
test al, 1
jnz short loc_135872
jmp short loc_13587B
loc_135872:
mov [rbp+var_1], 0
jmp loc_135968
loc_13587B:
cmp [rbp+var_14], 0
jnz short loc_1358FA
mov rax, [rbp+var_58]
test byte ptr [rax+24h], 1
jz short loc_1358C9
mov rdi, [rbp+var_20]; this
mov esi, [rbp+var_18]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level15getFaceVerticesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(int)
mov [rbp+var_38], edx
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_30], rax
mov eax, [rbp+var_38]
mov [rbp+var_28], eax
lea rdi, [rbp+var_30]
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiE4sizeEv; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::size(void)
mov rcx, [rbp+var_58]
cmp eax, [rcx+20h]
setz al
and al, 1
mov [rbp+var_1], al
jmp loc_135968
loc_1358C9:
mov rdi, [rbp+var_20]; this
mov esi, [rbp+var_18]; int
mov edx, 0FFFFFFFFh; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level20getFaceCompositeVTagEii; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceCompositeVTag(int,int)
mov [rbp+var_42], ax
mov ax, [rbp+var_42]
shr ax, 0Ch
and ax, 1
cmp ax, 0
setnz al
xor al, 0FFh
and al, 1
mov [rbp+var_1], al
jmp short loc_135968
loc_1358FA:
mov rax, [rbp+var_58]
cmp dword ptr [rax+20h], 4
jnz short loc_135935
mov rdi, [rbp+var_20]; this
mov esi, [rbp+var_18]; int
mov edx, 0FFFFFFFFh; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level20getFaceCompositeVTagEii; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceCompositeVTag(int,int)
mov [rbp+var_44], ax
mov ax, [rbp+var_44]
shr ax, 0Bh
and ax, 1
cmp ax, 0
setnz al
xor al, 0FFh
and al, 1
mov [rbp+var_1], al
jmp short loc_135968
loc_135935:
mov rax, [rbp+var_58]
mov rdi, [rax+8]; this
mov esi, [rbp+var_14]
sub esi, 1; int
call __ZNK10OpenSubdiv6v3_6_03Far15TopologyRefiner13getRefinementEi; OpenSubdiv::v3_6_0::Far::TopologyRefiner::getRefinement(int)
mov [rbp+var_50], rax
mov rdi, [rbp+var_50]; this
mov esi, [rbp+var_18]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal10Refinement15getChildFaceTagEi; OpenSubdiv::v3_6_0::Vtr::internal::Refinement::getChildFaceTag(int)
mov al, [rax]
and al, 1
cmp al, 0
setnz al
xor al, 0FFh
and al, 1
mov [rbp+var_1], al
loc_135968:
mov al, [rbp+var_1]
and al, 1
add rsp, 60h
pop rbp
retn
| bool OpenSubdiv::v3_6_0::Far::PatchBuilder::IsFaceAPatch(
OpenSubdiv::v3_6_0::Far::TopologyRefiner **this,
int a2,
int a3)
{
int v3; // edx
OpenSubdiv::v3_6_0::Vtr::internal::Refinement *Refinement; // [rsp+10h] [rbp-50h]
long long FaceVertices; // [rsp+30h] [rbp-30h] BYREF
int v7; // [rsp+38h] [rbp-28h]
OpenSubdiv::v3_6_0::Vtr::internal::Level *Level; // [rsp+40h] [rbp-20h]
int v9; // [rsp+48h] [rbp-18h]
int v10; // [rsp+4Ch] [rbp-14h]
OpenSubdiv::v3_6_0::Far::TopologyRefiner **v11; // [rsp+50h] [rbp-10h]
v11 = this;
v10 = a2;
v9 = a3;
Level = (OpenSubdiv::v3_6_0::Vtr::internal::Level *)OpenSubdiv::v3_6_0::Far::TopologyRefiner::getLevel(this[1], a2);
if ( (OpenSubdiv::v3_6_0::Far::TopologyRefiner::HasHoles(this[1]) & 1) != 0
&& (OpenSubdiv::v3_6_0::Vtr::internal::Level::isFaceHole(Level, v9) & 1) != 0 )
{
return 0;
}
else if ( v10 )
{
if ( *((_DWORD *)this + 8) == 4 )
{
return (((unsigned __int16)OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceCompositeVTag(Level, v9, -1) >> 11) & 1) == 0;
}
else
{
Refinement = (OpenSubdiv::v3_6_0::Vtr::internal::Refinement *)OpenSubdiv::v3_6_0::Far::TopologyRefiner::getRefinement(
this[1],
v10 - 1);
return (*(_BYTE *)OpenSubdiv::v3_6_0::Vtr::internal::Refinement::getChildFaceTag(Refinement, v9) & 1) == 0;
}
}
else if ( (*((_BYTE *)this + 36) & 1) != 0 )
{
FaceVertices = OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(Level, v9);
v7 = v3;
return (unsigned int)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::size(&FaceVertices) == *((_DWORD *)this + 8);
}
else
{
return (((unsigned __int16)OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceCompositeVTag(Level, v9, -1) >> 12) & 1) == 0;
}
}
| |||
26,029 | OpenSubdiv::v3_6_0::Far::PatchBuilder::IsFaceAPatch(int, int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchBuilder.cpp | bool
PatchBuilder::IsFaceAPatch(int levelIndex, Index faceIndex) const {
Level const & level = _refiner.getLevel(levelIndex);
// Faces tagged as holes are not patches (no limit surface)
if (_refiner.HasHoles() && level.isFaceHole(faceIndex)) return false;
// Base faces are patches unless an irregular face or incident one:
if (levelIndex == 0) {
if (_schemeIsLinear) {
return level.getFaceVertices(faceIndex).size() == _schemeRegFaceSize;
} else {
return !level.getFaceCompositeVTag(faceIndex)._incidIrregFace;
}
}
// Refined faces are patches unless "incomplete", i.e. they exist solely to
// support an adjacent patch (can only use the more commonly used combined
// VTag for all corners for quads -- need a Refinement tag for tris):
if (_schemeRegFaceSize == 4) {
return !level.getFaceCompositeVTag(faceIndex)._incomplete;
} else {
Refinement const & refinement = _refiner.getRefinement(levelIndex - 1);
return !refinement.getChildFaceTag(faceIndex)._incomplete;
}
} | O2 | cpp | OpenSubdiv::v3_6_0::Far::PatchBuilder::IsFaceAPatch(int, int) const:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movslq %esi, %rcx
movq 0x30(%rax), %rdi
movq (%rdi,%rcx,8), %rdi
testb $0x2, 0x8(%rax)
movslq %edx, %r8
je 0x786ff
movq 0x60(%rdi), %r9
testb $0x1, (%r9,%r8)
jne 0x7872d
testl %esi, %esi
je 0x7871b
cmpl $0x4, 0x20(%rbx)
jne 0x78731
pushq $-0x1
popq %rax
movl %edx, %esi
movl %eax, %edx
callq 0x52510
btl $0xb, %eax
jmp 0x7875b
cmpb $0x1, 0x24(%rbx)
jne 0x7874b
movl %edx, %esi
callq 0x52db0
cmpl 0x20(%rbx), %edx
jmp 0x78746
xorl %eax, %eax
jmp 0x7875e
movq 0x48(%rax), %rax
movq -0x8(%rax,%rcx,8), %rax
movq 0x150(%rax), %rax
testb $0x1, (%rax,%r8)
sete %al
jmp 0x7875e
pushq $-0x1
popq %rax
movl %edx, %esi
movl %eax, %edx
callq 0x52510
btl $0xc, %eax
setae %al
popq %rbx
retq
| _ZNK10OpenSubdiv6v3_6_03Far12PatchBuilder12IsFaceAPatchEii:
push rbx
mov rbx, rdi
mov rax, [rdi+8]
movsxd rcx, esi
mov rdi, [rax+30h]
mov rdi, [rdi+rcx*8]; this
test byte ptr [rax+8], 2
movsxd r8, edx
jz short loc_786FF
mov r9, [rdi+60h]
test byte ptr [r9+r8], 1
jnz short loc_7872D
loc_786FF:
test esi, esi
jz short loc_7871B
cmp dword ptr [rbx+20h], 4
jnz short loc_78731
push 0FFFFFFFFFFFFFFFFh
pop rax
mov esi, edx; int
mov edx, eax; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level20getFaceCompositeVTagEii; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceCompositeVTag(int,int)
bt eax, 0Bh
jmp short loc_7875B
loc_7871B:
cmp byte ptr [rbx+24h], 1
jnz short loc_7874B
mov esi, edx; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level15getFaceVerticesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(int)
cmp edx, [rbx+20h]
jmp short loc_78746
loc_7872D:
xor eax, eax
jmp short loc_7875E
loc_78731:
mov rax, [rax+48h]
mov rax, [rax+rcx*8-8]
mov rax, [rax+150h]
test byte ptr [rax+r8], 1
loc_78746:
setz al
jmp short loc_7875E
loc_7874B:
push 0FFFFFFFFFFFFFFFFh
pop rax
mov esi, edx; int
mov edx, eax; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level20getFaceCompositeVTagEii; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceCompositeVTag(int,int)
bt eax, 0Ch
loc_7875B:
setnb al
loc_7875E:
pop rbx
retn
| bool OpenSubdiv::v3_6_0::Far::PatchBuilder::IsFaceAPatch(
OpenSubdiv::v3_6_0::Far::PatchBuilder *this,
int a2,
int a3)
{
long long v4; // rax
OpenSubdiv::v3_6_0::Vtr::internal::Level *v5; // rdi
bool v6; // cf
int v7; // edx
v4 = *((_QWORD *)this + 1);
v5 = *(OpenSubdiv::v3_6_0::Vtr::internal::Level **)(*(_QWORD *)(v4 + 48) + 8LL * a2);
if ( (*(_BYTE *)(v4 + 8) & 2) != 0 && (*(_BYTE *)(*((_QWORD *)v5 + 12) + a3) & 1) != 0 )
return 0;
if ( !a2 )
{
if ( *((_BYTE *)this + 36) != 1 )
{
v6 = (OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceCompositeVTag(v5, a3, -1) & 0x1000) != 0;
return !v6;
}
OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(v5, a3);
return v7 == *((_DWORD *)this + 8);
}
if ( *((_DWORD *)this + 8) != 4 )
return (*(_BYTE *)(*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(v4 + 72) + 8LL * a2 - 8) + 336LL) + a3) & 1) == 0;
v6 = (OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceCompositeVTag(v5, a3, -1) & 0x800) != 0;
return !v6;
}
| IsFaceAPatch:
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x8]
MOVSXD RCX,ESI
MOV RDI,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RDI + RCX*0x8]
TEST byte ptr [RAX + 0x8],0x2
MOVSXD R8,EDX
JZ 0x001786ff
MOV R9,qword ptr [RDI + 0x60]
TEST byte ptr [R9 + R8*0x1],0x1
JNZ 0x0017872d
LAB_001786ff:
TEST ESI,ESI
JZ 0x0017871b
CMP dword ptr [RBX + 0x20],0x4
JNZ 0x00178731
PUSH -0x1
POP RAX
MOV ESI,EDX
MOV EDX,EAX
CALL 0x00152510
BT EAX,0xb
JMP 0x0017875b
LAB_0017871b:
CMP byte ptr [RBX + 0x24],0x1
JNZ 0x0017874b
MOV ESI,EDX
CALL 0x00152db0
CMP EDX,dword ptr [RBX + 0x20]
JMP 0x00178746
LAB_0017872d:
XOR EAX,EAX
JMP 0x0017875e
LAB_00178731:
MOV RAX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RAX + RCX*0x8 + -0x8]
MOV RAX,qword ptr [RAX + 0x150]
TEST byte ptr [RAX + R8*0x1],0x1
LAB_00178746:
SETZ AL
JMP 0x0017875e
LAB_0017874b:
PUSH -0x1
POP RAX
MOV ESI,EDX
MOV EDX,EAX
CALL 0x00152510
BT EAX,0xc
LAB_0017875b:
SETNC AL
LAB_0017875e:
POP RBX
RET
|
/* OpenSubdiv::v3_6_0::Far::PatchBuilder::IsFaceAPatch(int, int) const */
bool __thiscall
OpenSubdiv::v3_6_0::Far::PatchBuilder::IsFaceAPatch(PatchBuilder *this,int param_1,int param_2)
{
long lVar1;
Level *this_00;
uint uVar2;
int1 auVar3 [12];
lVar1 = *(long *)(this + 8);
this_00 = *(Level **)(*(long *)(lVar1 + 0x30) + (long)param_1 * 8);
if (((*(byte *)(lVar1 + 8) & 2) != 0) &&
((*(byte *)(*(long *)(this_00 + 0x60) + (long)param_2) & 1) != 0)) {
return false;
}
if (param_1 == 0) {
if (this[0x24] == (PatchBuilder)0x1) {
auVar3 = Vtr::internal::Level::getFaceVertices(this_00,param_2);
return auVar3._8_4_ == *(int *)(this + 0x20);
}
uVar2 = Vtr::internal::Level::getFaceCompositeVTag(this_00,param_2,-1);
uVar2 = uVar2 >> 0xc;
}
else {
if (*(int *)(this + 0x20) != 4) {
return (*(byte *)(*(long *)(*(long *)(*(long *)(lVar1 + 0x48) + -8 + (long)param_1 * 8) +
0x150) + (long)param_2) & 1) == 0;
}
uVar2 = Vtr::internal::Level::getFaceCompositeVTag(this_00,param_2,-1);
uVar2 = uVar2 >> 0xb;
}
return (uVar2 & 1) == 0;
}
| |
26,030 | OpenSubdiv::v3_6_0::Far::PatchBuilder::IsFaceAPatch(int, int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchBuilder.cpp | bool
PatchBuilder::IsFaceAPatch(int levelIndex, Index faceIndex) const {
Level const & level = _refiner.getLevel(levelIndex);
// Faces tagged as holes are not patches (no limit surface)
if (_refiner.HasHoles() && level.isFaceHole(faceIndex)) return false;
// Base faces are patches unless an irregular face or incident one:
if (levelIndex == 0) {
if (_schemeIsLinear) {
return level.getFaceVertices(faceIndex).size() == _schemeRegFaceSize;
} else {
return !level.getFaceCompositeVTag(faceIndex)._incidIrregFace;
}
}
// Refined faces are patches unless "incomplete", i.e. they exist solely to
// support an adjacent patch (can only use the more commonly used combined
// VTag for all corners for quads -- need a Refinement tag for tris):
if (_schemeRegFaceSize == 4) {
return !level.getFaceCompositeVTag(faceIndex)._incomplete;
} else {
Refinement const & refinement = _refiner.getRefinement(levelIndex - 1);
return !refinement.getChildFaceTag(faceIndex)._incomplete;
}
} | O3 | cpp | OpenSubdiv::v3_6_0::Far::PatchBuilder::IsFaceAPatch(int, int) const:
pushq %rax
movq %rdi, %rax
movq 0x8(%rdi), %rcx
movslq %esi, %r8
movq 0x30(%rcx), %rdi
movq (%rdi,%r8,8), %rdi
testb $0x2, 0x8(%rcx)
je 0x66b87
movslq %edx, %r9
movq 0x60(%rdi), %r10
testb $0x1, (%r10,%r9)
jne 0x66bba
testl %esi, %esi
je 0x66ba3
cmpl $0x4, 0x20(%rax)
jne 0x66bbe
movl %edx, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x3a0d0
btl $0xb, %eax
jmp 0x66bea
cmpb $0x1, 0x24(%rax)
jne 0x66bda
addl %edx, %edx
movq 0x18(%rdi), %rcx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
cmpl 0x20(%rax), %ecx
jmp 0x66bd5
xorl %eax, %eax
jmp 0x66bed
movq 0x48(%rcx), %rax
movq -0x8(%rax,%r8,8), %rax
movslq %edx, %rcx
movq 0x150(%rax), %rax
testb $0x1, (%rax,%rcx)
sete %al
jmp 0x66bed
movl %edx, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x3a0d0
btl $0xc, %eax
setae %al
popq %rcx
retq
nop
| _ZNK10OpenSubdiv6v3_6_03Far12PatchBuilder12IsFaceAPatchEii:
push rax
mov rax, rdi
mov rcx, [rdi+8]
movsxd r8, esi
mov rdi, [rcx+30h]
mov rdi, [rdi+r8*8]; this
test byte ptr [rcx+8], 2
jz short loc_66B87
movsxd r9, edx
mov r10, [rdi+60h]
test byte ptr [r10+r9], 1
jnz short loc_66BBA
loc_66B87:
test esi, esi
jz short loc_66BA3
cmp dword ptr [rax+20h], 4
jnz short loc_66BBE
mov esi, edx; int
mov edx, 0FFFFFFFFh; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level20getFaceCompositeVTagEii; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceCompositeVTag(int,int)
bt eax, 0Bh
jmp short loc_66BEA
loc_66BA3:
cmp byte ptr [rax+24h], 1
jnz short loc_66BDA
add edx, edx
mov rcx, [rdi+18h]
movsxd rdx, edx
mov ecx, [rcx+rdx*4]
cmp ecx, [rax+20h]
jmp short loc_66BD5
loc_66BBA:
xor eax, eax
jmp short loc_66BED
loc_66BBE:
mov rax, [rcx+48h]
mov rax, [rax+r8*8-8]
movsxd rcx, edx
mov rax, [rax+150h]
test byte ptr [rax+rcx], 1
loc_66BD5:
setz al
jmp short loc_66BED
loc_66BDA:
mov esi, edx; int
mov edx, 0FFFFFFFFh; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level20getFaceCompositeVTagEii; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceCompositeVTag(int,int)
bt eax, 0Ch
loc_66BEA:
setnb al
loc_66BED:
pop rcx
retn
| bool OpenSubdiv::v3_6_0::Far::PatchBuilder::IsFaceAPatch(
OpenSubdiv::v3_6_0::Far::PatchBuilder *this,
int a2,
int a3)
{
long long v4; // rcx
OpenSubdiv::v3_6_0::Vtr::internal::Level *v5; // rdi
bool v6; // cf
v4 = *((_QWORD *)this + 1);
v5 = *(OpenSubdiv::v3_6_0::Vtr::internal::Level **)(*(_QWORD *)(v4 + 48) + 8LL * a2);
if ( (*(_BYTE *)(v4 + 8) & 2) != 0 && (*(_BYTE *)(*((_QWORD *)v5 + 12) + a3) & 1) != 0 )
return 0;
if ( !a2 )
{
if ( *((_BYTE *)this + 36) != 1 )
{
v6 = (OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceCompositeVTag(v5, a3, -1) & 0x1000) != 0;
return !v6;
}
return *(_DWORD *)(*((_QWORD *)v5 + 3) + 8LL * a3) == *((_DWORD *)this + 8);
}
if ( *((_DWORD *)this + 8) != 4 )
return (*(_BYTE *)(*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(v4 + 72) + 8LL * a2 - 8) + 336LL) + a3) & 1) == 0;
v6 = (OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceCompositeVTag(v5, a3, -1) & 0x800) != 0;
return !v6;
}
| IsFaceAPatch:
PUSH RAX
MOV RAX,RDI
MOV RCX,qword ptr [RDI + 0x8]
MOVSXD R8,ESI
MOV RDI,qword ptr [RCX + 0x30]
MOV RDI,qword ptr [RDI + R8*0x8]
TEST byte ptr [RCX + 0x8],0x2
JZ 0x00166b87
MOVSXD R9,EDX
MOV R10,qword ptr [RDI + 0x60]
TEST byte ptr [R10 + R9*0x1],0x1
JNZ 0x00166bba
LAB_00166b87:
TEST ESI,ESI
JZ 0x00166ba3
CMP dword ptr [RAX + 0x20],0x4
JNZ 0x00166bbe
MOV ESI,EDX
MOV EDX,0xffffffff
CALL 0x0013a0d0
BT EAX,0xb
JMP 0x00166bea
LAB_00166ba3:
CMP byte ptr [RAX + 0x24],0x1
JNZ 0x00166bda
ADD EDX,EDX
MOV RCX,qword ptr [RDI + 0x18]
MOVSXD RDX,EDX
MOV ECX,dword ptr [RCX + RDX*0x4]
CMP ECX,dword ptr [RAX + 0x20]
JMP 0x00166bd5
LAB_00166bba:
XOR EAX,EAX
JMP 0x00166bed
LAB_00166bbe:
MOV RAX,qword ptr [RCX + 0x48]
MOV RAX,qword ptr [RAX + R8*0x8 + -0x8]
MOVSXD RCX,EDX
MOV RAX,qword ptr [RAX + 0x150]
TEST byte ptr [RAX + RCX*0x1],0x1
LAB_00166bd5:
SETZ AL
JMP 0x00166bed
LAB_00166bda:
MOV ESI,EDX
MOV EDX,0xffffffff
CALL 0x0013a0d0
BT EAX,0xc
LAB_00166bea:
SETNC AL
LAB_00166bed:
POP RCX
RET
|
/* OpenSubdiv::v3_6_0::Far::PatchBuilder::IsFaceAPatch(int, int) const */
bool __thiscall
OpenSubdiv::v3_6_0::Far::PatchBuilder::IsFaceAPatch(PatchBuilder *this,int param_1,int param_2)
{
long lVar1;
Level *this_00;
uint uVar2;
bool bVar3;
lVar1 = *(long *)(this + 8);
this_00 = *(Level **)(*(long *)(lVar1 + 0x30) + (long)param_1 * 8);
if (((*(byte *)(lVar1 + 8) & 2) == 0) ||
((*(byte *)(*(long *)(this_00 + 0x60) + (long)param_2) & 1) == 0)) {
if (param_1 == 0) {
if (this[0x24] == (PatchBuilder)0x1) {
return *(int *)(*(long *)(this_00 + 0x18) + (long)(param_2 * 2) * 4) ==
*(int *)(this + 0x20);
}
uVar2 = Vtr::internal::Level::getFaceCompositeVTag(this_00,param_2,-1);
uVar2 = uVar2 >> 0xc;
}
else {
if (*(int *)(this + 0x20) != 4) {
return (*(byte *)(*(long *)(*(long *)(*(long *)(lVar1 + 0x48) + -8 + (long)param_1 * 8) +
0x150) + (long)param_2) & 1) == 0;
}
uVar2 = Vtr::internal::Level::getFaceCompositeVTag(this_00,param_2,-1);
uVar2 = uVar2 >> 0xb;
}
bVar3 = (uVar2 & 1) == 0;
}
else {
bVar3 = false;
}
return bVar3;
}
| |
26,031 | mi_split_page | eloqsql/storage/myisam/mi_write.c | int _mi_split_page(register MI_INFO *info, register MI_KEYDEF *keyinfo,
uchar *key, uchar *buff, uchar *key_buff,
my_bool insert_last_key)
{
uint length,a_length,key_ref_length,t_length,nod_flag,key_length;
uchar *key_pos,*pos, *UNINIT_VAR(after_key);
my_off_t new_pos;
MI_KEY_PARAM s_temp;
DBUG_ENTER("mi_split_page");
DBUG_DUMP("buff",(uchar*) buff,mi_getint(buff));
if (info->s->keyinfo+info->lastinx == keyinfo)
info->page_changed=1; /* Info->buff is used */
info->buff_used=1;
nod_flag=mi_test_if_nod(buff);
key_ref_length=2+nod_flag;
if (insert_last_key)
key_pos=_mi_find_last_pos(keyinfo,buff,key_buff, &key_length, &after_key);
else
key_pos=_mi_find_half_pos(nod_flag,keyinfo,buff,key_buff, &key_length,
&after_key);
if (!key_pos)
DBUG_RETURN(-1);
length=(uint) (key_pos-buff);
a_length=mi_getint(buff);
mi_putint(buff,length,nod_flag);
key_pos=after_key;
if (nod_flag)
{
DBUG_PRINT("test",("Splitting nod"));
pos=key_pos-nod_flag;
memcpy((uchar*) info->buff+2,(uchar*) pos,(size_t) nod_flag);
}
/* Move middle item to key and pointer to new page */
if ((new_pos=_mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR)
DBUG_RETURN(-1);
_mi_kpointer(info,_mi_move_key(keyinfo,key,key_buff),new_pos);
/* Store new page */
if (!(*keyinfo->get_key)(keyinfo,nod_flag,&key_pos,key_buff))
DBUG_RETURN(-1);
t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,(uchar *) 0,
(uchar*) 0, (uchar*) 0,
key_buff, &s_temp);
length=(uint) ((buff+a_length)-key_pos);
memcpy((uchar*) info->buff+key_ref_length+t_length,(uchar*) key_pos,
(size_t) length);
(*keyinfo->store_key)(keyinfo,info->buff+key_ref_length,&s_temp);
mi_putint(info->buff,length+t_length+key_ref_length,nod_flag);
if (_mi_write_keypage(info,keyinfo,new_pos,DFLT_INIT_HITS,info->buff))
DBUG_RETURN(-1);
DBUG_DUMP("key",(uchar*) key,_mi_keylength(keyinfo,key));
DBUG_RETURN(2); /* Middle key up */
} | O0 | c | mi_split_page:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movb %al, -0x31(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0xc796f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x1d4(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
jne 0xc79a0
movq -0x10(%rbp), %rax
movb $0x1, 0x33c(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x33d(%rax)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xc79d1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %eax
movl %eax, -0xc4(%rbp)
jmp 0xc79db
xorl %eax, %eax
movl %eax, -0xc4(%rbp)
jmp 0xc79db
movl -0xc4(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x40(%rbp)
cmpb $0x0, -0x31(%rbp)
je 0xc7a12
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x4c(%rbp), %rcx
leaq -0x68(%rbp), %r8
callq 0xc7cd0
movq %rax, -0x58(%rbp)
jmp 0xc7a32
movl -0x48(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x4c(%rbp), %r8
leaq -0x68(%rbp), %r9
callq 0xc7fa0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0xc7a47
jmp 0xc7a3b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc7cba
movq -0x58(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
andl $0x7fff, %eax # imm = 0x7FFF
movl %eax, -0x3c(%rbp)
movl -0x48(%rbp), %edx
xorl %eax, %eax
movl $0x8000, %ecx # imm = 0x8000
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl -0x38(%rbp), %ecx
movzwl %cx, %ecx
addl %ecx, %eax
movw %ax, -0xb2(%rbp)
movzwl -0xb2(%rbp), %eax
movl %eax, -0xb8(%rbp)
movl -0xb8(%rbp), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xb8(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0xc7b0a
jmp 0xc7ad6
jmp 0xc7ad8
movq -0x58(%rbp), %rax
movl -0x48(%rbp), %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rdi
addq $0x2, %rdi
movq -0x60(%rbp), %rsi
movl -0x48(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x3, %edx
callq 0xbe500
movq %rax, -0x70(%rbp)
cmpq $-0x1, %rax
jne 0xc7b34
jmp 0xc7b28
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc7cba
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc1da0
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
movq -0x70(%rbp), %rdx
callq 0xc0630
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rdi
movl -0x48(%rbp), %esi
movq -0x30(%rbp), %rcx
leaq -0x58(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0xc7b8f
jmp 0xc7b83
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc7cba
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rdi
movl -0x48(%rbp), %esi
movq -0x30(%rbp), %r9
xorl %ecx, %ecx
movl %ecx, %r8d
leaq -0xb0(%rbp), %r10
movq %r8, %rdx
movq %r8, %rcx
movq %r10, (%rsp)
callq *%rax
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %ecx
addq %rcx, %rax
movq -0x58(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rdi
movl -0x40(%rbp), %eax
addq %rax, %rdi
movl -0x44(%rbp), %eax
addq %rax, %rdi
movq -0x58(%rbp), %rsi
movl -0x38(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x100(%rcx), %rsi
movl -0x40(%rbp), %ecx
addq %rcx, %rsi
leaq -0xb0(%rbp), %rdx
callq *%rax
movl -0x48(%rbp), %edx
xorl %eax, %eax
movl $0x8000, %ecx # imm = 0x8000
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl -0x38(%rbp), %ecx
addl -0x44(%rbp), %ecx
addl -0x40(%rbp), %ecx
movzwl %cx, %ecx
addl %ecx, %eax
movw %ax, -0xba(%rbp)
movzwl -0xba(%rbp), %eax
movl %eax, -0xc0(%rbp)
movl -0xc0(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movb %cl, 0x1(%rax)
movl -0xc0(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x100(%rax), %r8
movl $0x3, %ecx
callq 0xbe1d0
cmpl $0x0, %eax
je 0xc7cad
jmp 0xc7ca4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc7cba
jmp 0xc7caf
jmp 0xc7cb1
jmp 0xc7cb3
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _mi_split_page:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov al, r9b
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_31], al
mov rax, [rbp+var_68]
mov [rbp+var_68], rax
jmp short $+2
loc_C796F:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+218h]
mov rcx, [rbp+var_10]
movsxd rcx, dword ptr [rcx+1D4h]
imul rcx, 70h ; 'p'
add rax, rcx
cmp rax, [rbp+var_18]
jnz short loc_C79A0
mov rax, [rbp+var_10]
mov byte ptr [rax+33Ch], 1
loc_C79A0:
mov rax, [rbp+var_10]
mov byte ptr [rax+33Dh], 1
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
and eax, 80h
cmp eax, 0
jz short loc_C79D1
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+17Ch]
mov [rbp+var_C4], eax
jmp short loc_C79DB
loc_C79D1:
xor eax, eax
mov [rbp+var_C4], eax
jmp short $+2
loc_C79DB:
mov eax, [rbp+var_C4]
mov [rbp+var_48], eax
mov eax, [rbp+var_48]
add eax, 2
mov [rbp+var_40], eax
cmp [rbp+var_31], 0
jz short loc_C7A12
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_30]
lea rcx, [rbp+var_4C]
lea r8, [rbp+var_68]
call _mi_find_last_pos
mov [rbp+var_58], rax
jmp short loc_C7A32
loc_C7A12:
mov edi, [rbp+var_48]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
lea r8, [rbp+var_4C]
lea r9, [rbp+var_68]
call _mi_find_half_pos
mov [rbp+var_58], rax
loc_C7A32:
cmp [rbp+var_58], 0
jnz short loc_C7A47
jmp short $+2
loc_C7A3B:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_C7CBA
loc_C7A47:
mov rax, [rbp+var_58]
mov rcx, [rbp+var_28]
sub rax, rcx
mov [rbp+var_38], eax
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_28]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
and eax, 7FFFh
mov [rbp+var_3C], eax
mov edx, [rbp+var_48]
xor eax, eax
mov ecx, 8000h
cmp edx, 0
cmovnz eax, ecx
mov ecx, [rbp+var_38]
movzx ecx, cx
add eax, ecx
mov [rbp+var_B2], ax
movzx eax, [rbp+var_B2]
mov [rbp+var_B8], eax
mov eax, [rbp+var_B8]
mov cl, al
mov rax, [rbp+var_28]
mov [rax+1], cl
mov eax, [rbp+var_B8]
shr eax, 8
mov cl, al
mov rax, [rbp+var_28]
mov [rax], cl
mov rax, [rbp+var_68]
mov [rbp+var_58], rax
cmp [rbp+var_48], 0
jz short loc_C7B0A
jmp short $+2
loc_C7AD6:
jmp short $+2
loc_C7AD8:
mov rax, [rbp+var_58]
mov ecx, [rbp+var_48]
mov edx, ecx
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_60], rax
mov rax, [rbp+var_10]
mov rdi, [rax+100h]
add rdi, 2
mov rsi, [rbp+var_60]
mov eax, [rbp+var_48]
mov edx, eax
call _memcpy
loc_C7B0A:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, 3
call _mi_new
mov [rbp+var_70], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_C7B34
jmp short $+2
loc_C7B28:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_C7CBA
loc_C7B34:
mov rax, [rbp+var_10]
mov [rbp+var_D0], rax
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_30]
call _mi_move_key
mov rdi, [rbp+var_D0]
mov rsi, rax
mov rdx, [rbp+var_70]
call _mi_kpointer
mov rax, [rbp+var_18]
mov rax, [rax+48h]
mov rdi, [rbp+var_18]
mov esi, [rbp+var_48]
mov rcx, [rbp+var_30]
lea rdx, [rbp+var_58]
call rax
cmp eax, 0
jnz short loc_C7B8F
jmp short $+2
loc_C7B83:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_C7CBA
loc_C7B8F:
mov rax, [rbp+var_18]
mov rax, [rax+50h]
mov rdi, [rbp+var_18]
mov esi, [rbp+var_48]
mov r9, [rbp+var_30]
xor ecx, ecx
mov r8d, ecx
lea r10, [rbp+var_B0]
mov rdx, r8
mov rcx, r8
mov [rsp+0E0h+var_E0], r10
call rax
mov [rbp+var_44], eax
mov rax, [rbp+var_28]
mov ecx, [rbp+var_3C]
add rax, rcx
mov rcx, [rbp+var_58]
sub rax, rcx
mov [rbp+var_38], eax
mov rax, [rbp+var_10]
mov rdi, [rax+100h]
mov eax, [rbp+var_40]
add rdi, rax
mov eax, [rbp+var_44]
add rdi, rax
mov rsi, [rbp+var_58]
mov eax, [rbp+var_38]
mov edx, eax
call _memcpy
mov rax, [rbp+var_18]
mov rax, [rax+58h]
mov rdi, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rsi, [rcx+100h]
mov ecx, [rbp+var_40]
add rsi, rcx
lea rdx, [rbp+var_B0]
call rax
mov edx, [rbp+var_48]
xor eax, eax
mov ecx, 8000h
cmp edx, 0
cmovnz eax, ecx
mov ecx, [rbp+var_38]
add ecx, [rbp+var_44]
add ecx, [rbp+var_40]
movzx ecx, cx
add eax, ecx
mov [rbp+var_BA], ax
movzx eax, [rbp+var_BA]
mov [rbp+var_C0], eax
mov eax, [rbp+var_C0]
mov cl, al
mov rax, [rbp+var_10]
mov rax, [rax+100h]
mov [rax+1], cl
mov eax, [rbp+var_C0]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov rax, [rax+100h]
mov [rax], cl
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_70]
mov rax, [rbp+var_10]
mov r8, [rax+100h]
mov ecx, 3
call _mi_write_keypage
cmp eax, 0
jz short loc_C7CAD
jmp short $+2
loc_C7CA4:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_C7CBA
loc_C7CAD:
jmp short $+2
loc_C7CAF:
jmp short $+2
loc_C7CB1:
jmp short $+2
loc_C7CB3:
mov [rbp+var_4], 2
loc_C7CBA:
mov eax, [rbp+var_4]
add rsp, 0E0h
pop rbp
retn
| long long mi_split_page(_QWORD *a1, long long a2, long long a3, long long a4, unsigned __int8 *a5, char a6)
{
__int16 v6; // ax
_BYTE *v7; // rax
__int16 v8; // ax
_QWORD *v10; // [rsp+10h] [rbp-D0h]
unsigned int v11; // [rsp+1Ch] [rbp-C4h]
__int16 v12; // [rsp+26h] [rbp-BAh]
__int16 v13; // [rsp+28h] [rbp-B8h]
_BYTE v14[64]; // [rsp+30h] [rbp-B0h] BYREF
unsigned long long v15; // [rsp+70h] [rbp-70h]
long long v16; // [rsp+78h] [rbp-68h] BYREF
long long v17; // [rsp+80h] [rbp-60h]
long long last_pos; // [rsp+88h] [rbp-58h] BYREF
_BYTE v19[4]; // [rsp+94h] [rbp-4Ch] BYREF
unsigned int v20; // [rsp+98h] [rbp-48h]
unsigned int v21; // [rsp+9Ch] [rbp-44h]
unsigned int v22; // [rsp+A0h] [rbp-40h]
int v23; // [rsp+A4h] [rbp-3Ch]
unsigned int v24; // [rsp+A8h] [rbp-38h]
char v25; // [rsp+AFh] [rbp-31h]
unsigned __int8 *v26; // [rsp+B0h] [rbp-30h]
long long v27; // [rsp+B8h] [rbp-28h]
long long v28; // [rsp+C0h] [rbp-20h]
long long v29; // [rsp+C8h] [rbp-18h]
_QWORD *v30; // [rsp+D0h] [rbp-10h]
v30 = a1;
v29 = a2;
v28 = a3;
v27 = a4;
v26 = a5;
v25 = a6;
if ( 112LL * *((int *)v30 + 117) + *(_QWORD *)(*v30 + 536LL) == a2 )
*((_BYTE *)v30 + 828) = 1;
*((_BYTE *)v30 + 829) = 1;
if ( (*(_BYTE *)v27 & 0x80) != 0 )
v11 = *(_DWORD *)(*v30 + 380LL);
else
v11 = 0;
v20 = v11;
v22 = v11 + 2;
if ( v25 )
last_pos = mi_find_last_pos(v29, v27, v26, v19, &v16);
else
last_pos = mi_find_half_pos(v20, v29, v27, v26, v19, &v16);
if ( last_pos )
{
v24 = last_pos - v27;
v23 = _byteswap_ushort(*(_WORD *)v27) & 0x7FFF;
v6 = 0;
if ( v20 )
v6 = 0x8000;
v13 = v24 + v6;
*(_BYTE *)(v27 + 1) = v24 + v6;
*(_BYTE *)v27 = HIBYTE(v13);
last_pos = v16;
if ( v20 )
{
v17 = last_pos - v20;
memcpy(v30[32] + 2LL, v17, v20);
}
v15 = mi_new(v30, v29, 3);
if ( v15 == -1LL )
{
return (unsigned int)-1;
}
else
{
v10 = v30;
v7 = (_BYTE *)mi_move_key(v29, v28, v26);
mi_kpointer((long long)v10, v7, v15);
if ( (*(unsigned int ( **)(long long, _QWORD, long long *, unsigned __int8 *))(v29 + 72))(
v29,
v20,
&last_pos,
v26) )
{
v21 = (*(long long ( **)(long long, _QWORD, _QWORD, _QWORD, _QWORD, unsigned __int8 *, _BYTE *))(v29 + 80))(
v29,
v20,
0LL,
0LL,
0LL,
v26,
v14);
v24 = v23 + v27 - last_pos;
memcpy(v21 + v22 + v30[32], last_pos, v24);
(*(void ( **)(long long, _QWORD, _BYTE *))(v29 + 88))(v29, v22 + v30[32], v14);
v8 = 0;
if ( v20 )
v8 = 0x8000;
v12 = v22 + v21 + v24 + v8;
*(_BYTE *)(v30[32] + 1LL) = v22 + v21 + v24 + v8;
*(_BYTE *)v30[32] = HIBYTE(v12);
if ( (unsigned int)mi_write_keypage(v30, v29, v15, 3, (unsigned __int16 *)v30[32]) )
return (unsigned int)-1;
else
return 2;
}
else
{
return (unsigned int)-1;
}
}
}
else
{
return (unsigned int)-1;
}
}
| _mi_split_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV AL,R9B
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV byte ptr [RBP + -0x31],AL
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x68],RAX
JMP 0x001c796f
LAB_001c796f:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RCX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RCX + 0x1d4]
IMUL RCX,RCX,0x70
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x001c79a0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33c],0x1
LAB_001c79a0:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33d],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001c79d1
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x17c]
MOV dword ptr [RBP + -0xc4],EAX
JMP 0x001c79db
LAB_001c79d1:
XOR EAX,EAX
MOV dword ptr [RBP + -0xc4],EAX
JMP 0x001c79db
LAB_001c79db:
MOV EAX,dword ptr [RBP + -0xc4]
MOV dword ptr [RBP + -0x48],EAX
MOV EAX,dword ptr [RBP + -0x48]
ADD EAX,0x2
MOV dword ptr [RBP + -0x40],EAX
CMP byte ptr [RBP + -0x31],0x0
JZ 0x001c7a12
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x4c]
LEA R8,[RBP + -0x68]
CALL 0x001c7cd0
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001c7a32
LAB_001c7a12:
MOV EDI,dword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
LEA R8,[RBP + -0x4c]
LEA R9,[RBP + -0x68]
CALL 0x001c7fa0
MOV qword ptr [RBP + -0x58],RAX
LAB_001c7a32:
CMP qword ptr [RBP + -0x58],0x0
JNZ 0x001c7a47
JMP 0x001c7a3b
LAB_001c7a3b:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c7cba
LAB_001c7a47:
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
AND EAX,0x7fff
MOV dword ptr [RBP + -0x3c],EAX
MOV EDX,dword ptr [RBP + -0x48]
XOR EAX,EAX
MOV ECX,0x8000
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV ECX,dword ptr [RBP + -0x38]
MOVZX ECX,CX
ADD EAX,ECX
MOV word ptr [RBP + -0xb2],AX
MOVZX EAX,word ptr [RBP + -0xb2]
MOV dword ptr [RBP + -0xb8],EAX
MOV EAX,dword ptr [RBP + -0xb8]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0xb8]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x58],RAX
CMP dword ptr [RBP + -0x48],0x0
JZ 0x001c7b0a
JMP 0x001c7ad6
LAB_001c7ad6:
JMP 0x001c7ad8
LAB_001c7ad8:
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x48]
MOV EDX,ECX
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x100]
ADD RDI,0x2
MOV RSI,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RBP + -0x48]
MOV EDX,EAX
CALL 0x0012a090
LAB_001c7b0a:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x3
CALL 0x001be500
MOV qword ptr [RBP + -0x70],RAX
CMP RAX,-0x1
JNZ 0x001c7b34
JMP 0x001c7b28
LAB_001c7b28:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c7cba
LAB_001c7b34:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0xd0],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x001c1da0
MOV RDI,qword ptr [RBP + -0xd0]
MOV RSI,RAX
MOV RDX,qword ptr [RBP + -0x70]
CALL 0x001c0630
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x48]
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x30]
LEA RDX,[RBP + -0x58]
CALL RAX
CMP EAX,0x0
JNZ 0x001c7b8f
JMP 0x001c7b83
LAB_001c7b83:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c7cba
LAB_001c7b8f:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x50]
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x30]
XOR ECX,ECX
MOV R8D,ECX
LEA R10,[RBP + -0xb0]
MOV RDX,R8
MOV RCX,R8
MOV qword ptr [RSP],R10
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x3c]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x58]
SUB RAX,RCX
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x100]
MOV EAX,dword ptr [RBP + -0x40]
ADD RDI,RAX
MOV EAX,dword ptr [RBP + -0x44]
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RBP + -0x38]
MOV EDX,EAX
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x58]
MOV RDI,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX + 0x100]
MOV ECX,dword ptr [RBP + -0x40]
ADD RSI,RCX
LEA RDX,[RBP + -0xb0]
CALL RAX
MOV EDX,dword ptr [RBP + -0x48]
XOR EAX,EAX
MOV ECX,0x8000
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV ECX,dword ptr [RBP + -0x38]
ADD ECX,dword ptr [RBP + -0x44]
ADD ECX,dword ptr [RBP + -0x40]
MOVZX ECX,CX
ADD EAX,ECX
MOV word ptr [RBP + -0xba],AX
MOVZX EAX,word ptr [RBP + -0xba]
MOV dword ptr [RBP + -0xc0],EAX
MOV EAX,dword ptr [RBP + -0xc0]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0xc0]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100]
MOV byte ptr [RAX],CL
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x10]
MOV R8,qword ptr [RAX + 0x100]
MOV ECX,0x3
CALL 0x001be1d0
CMP EAX,0x0
JZ 0x001c7cad
JMP 0x001c7ca4
LAB_001c7ca4:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c7cba
LAB_001c7cad:
JMP 0x001c7caf
LAB_001c7caf:
JMP 0x001c7cb1
LAB_001c7cb1:
JMP 0x001c7cb3
LAB_001c7cb3:
MOV dword ptr [RBP + -0x4],0x2
LAB_001c7cba:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0xe0
POP RBP
RET
|
int4
_mi_split_page(long *param_1,long param_2,int8 param_3,byte *param_4,int8 param_5,
char param_6)
{
long *plVar1;
short sVar2;
int iVar3;
int8 uVar4;
uint local_cc;
int1 local_b8 [64];
long local_78;
void *local_70;
void *local_68;
void *local_60;
int1 local_54 [4];
uint local_50;
uint local_4c;
uint local_48;
uint local_44;
uint local_40;
char local_39;
int8 local_38;
byte *local_30;
int8 local_28;
long local_20;
long *local_18;
int4 local_c;
if (*(long *)(*param_1 + 0x218) + (long)*(int *)((long)param_1 + 0x1d4) * 0x70 == param_2) {
*(int1 *)((long)param_1 + 0x33c) = 1;
}
*(int1 *)((long)param_1 + 0x33d) = 1;
if ((*param_4 & 0x80) == 0) {
local_cc = 0;
}
else {
local_cc = *(uint *)(*param_1 + 0x17c);
}
local_50 = local_cc;
local_48 = local_cc + 2;
local_39 = param_6;
local_38 = param_5;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
if (param_6 == '\0') {
local_60 = (void *)_mi_find_half_pos(local_cc,param_2,param_4,param_5,local_54,&local_70);
}
else {
local_60 = (void *)_mi_find_last_pos(param_2,param_4,param_5,local_54,&local_70);
}
if (local_60 == (void *)0x0) {
local_c = 0xffffffff;
}
else {
local_40 = (int)local_60 - (int)local_30;
local_44 = (uint)local_30[1] | (*local_30 & 0x7f) << 8;
sVar2 = 0;
if (local_50 != 0) {
sVar2 = -0x8000;
}
sVar2 = sVar2 + (short)local_40;
local_30[1] = (byte)sVar2;
*local_30 = (byte)((ushort)sVar2 >> 8);
local_60 = local_70;
if (local_50 != 0) {
local_68 = (void *)((long)local_70 - (ulong)local_50);
memcpy((void *)(local_18[0x20] + 2),local_68,(ulong)local_50);
}
local_78 = _mi_new(local_18,local_20,3);
plVar1 = local_18;
if (local_78 == -1) {
local_c = 0xffffffff;
}
else {
uVar4 = _mi_move_key(local_20,local_28,local_38);
_mi_kpointer(plVar1,uVar4,local_78);
iVar3 = (**(code **)(local_20 + 0x48))(local_20,local_50,&local_60,local_38);
if (iVar3 == 0) {
local_c = 0xffffffff;
}
else {
local_4c = (**(code **)(local_20 + 0x50))(local_20,local_50,0,0,0,local_38,local_b8);
local_40 = ((int)local_30 + local_44) - (int)local_60;
memcpy((void *)(local_18[0x20] + (ulong)local_48 + (ulong)local_4c),local_60,(ulong)local_40
);
(**(code **)(local_20 + 0x58))(local_20,local_18[0x20] + (ulong)local_48,local_b8);
sVar2 = 0;
if (local_50 != 0) {
sVar2 = -0x8000;
}
sVar2 = sVar2 + (short)local_40 + (short)local_4c + (short)local_48;
*(char *)(local_18[0x20] + 1) = (char)sVar2;
*(char *)local_18[0x20] = (char)((ushort)sVar2 >> 8);
iVar3 = _mi_write_keypage(local_18,local_20,local_78,3,local_18[0x20]);
if (iVar3 == 0) {
local_c = 2;
}
else {
local_c = 0xffffffff;
}
}
}
}
return local_c;
}
| |
26,032 | js_number_toExponential | bluesky950520[P]quickjs/quickjs.c | static JSValue js_number_toExponential(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue val;
double d;
int f;
val = js_thisNumberValue(ctx, this_val);
if (JS_IsException(val))
return val;
if (JS_ToFloat64Free(ctx, &d, val))
return JS_EXCEPTION;
if (JS_ToInt32Sat(ctx, &f, argv[0]))
return JS_EXCEPTION;
if (!isfinite(d))
return js_dtoa_infinite(ctx, d);
if (!JS_IsUndefined(argv[0])) {
if (f < 0 || f > 100) {
return JS_ThrowRangeError(ctx, "toExponential() argument must be between 0 and 100");
}
f += 1; /* number of significant digits between 1 and 101 */
}
return js_dtoa(ctx, d, f, JS_DTOA_EXPONENTIAL);
} | O0 | c | js_number_toExponential:
subq $0x68, %rsp
movq %rsi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq %r8, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0xd7dd0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xd7679
movq 0x20(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0xd779c
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
leaq 0x18(%rsp), %rsi
callq 0x3e8e0
cmpl $0x0, %eax
je 0xd76ad
movl $0x0, 0x58(%rsp)
movq $0x6, 0x60(%rsp)
jmp 0xd779c
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0x14(%rsp), %rsi
callq 0x3e970
cmpl $0x0, %eax
je 0xd76e3
movl $0x0, 0x58(%rsp)
movq $0x6, 0x60(%rsp)
jmp 0xd779c
movsd 0x18(%rsp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0xd772b
movq 0x40(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0x68650
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
jmp 0xd779c
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x34550
cmpl $0x0, %eax
jne 0xd7779
cmpl $0x0, 0x14(%rsp)
jl 0xd774f
cmpl $0x64, 0x14(%rsp)
jle 0xd776e
movq 0x40(%rsp), %rdi
leaq 0x3fa0e(%rip), %rsi # 0x117169
movb $0x0, %al
callq 0x2f960
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
jmp 0xd779c
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x40(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
movl 0x14(%rsp), %esi
movl $0x1, %edx
callq 0x3f940
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rdx
addq $0x68, %rsp
retq
nopl (%rax,%rax)
| js_number_toExponential:
sub rsp, 68h
mov [rsp+68h+var_20], rsi
mov [rsp+68h+var_18], rdx
mov [rsp+68h+var_28], rdi
mov [rsp+68h+var_2C], ecx
mov [rsp+68h+var_38], r8
mov rdi, [rsp+68h+var_28]
mov rsi, [rsp+68h+var_20]
mov rdx, [rsp+68h+var_18]
call js_thisNumberValue
mov [rsp+68h+var_68], rax
mov [rsp+68h+var_60], rdx
mov rax, [rsp+68h+var_68]
mov [rsp+68h+var_48], rax
mov rax, [rsp+68h+var_60]
mov [rsp+68h+var_40], rax
mov rdi, [rsp+68h+var_48]
mov rsi, [rsp+68h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_D7679
mov rax, [rsp+68h+var_48]
mov [rsp+68h+var_10], rax
mov rax, [rsp+68h+var_40]
mov [rsp+68h+var_8], rax
jmp loc_D779C
loc_D7679:
mov rdi, [rsp+68h+var_28]
mov rdx, [rsp+68h+var_48]
mov rcx, [rsp+68h+var_40]
lea rsi, [rsp+68h+var_50]
call JS_ToFloat64Free
cmp eax, 0
jz short loc_D76AD
mov dword ptr [rsp+68h+var_10], 0
mov [rsp+68h+var_8], 6
jmp loc_D779C
loc_D76AD:
mov rdi, [rsp+68h+var_28]
mov rax, [rsp+68h+var_38]
mov rdx, [rax]
mov rcx, [rax+8]
lea rsi, [rsp+68h+var_54]
call JS_ToInt32Sat
cmp eax, 0
jz short loc_D76E3
mov dword ptr [rsp+68h+var_10], 0
mov [rsp+68h+var_8], 6
jmp loc_D779C
loc_D76E3:
movsd xmm0, [rsp+68h+var_50]
movq rax, xmm0
mov rcx, 7FFFFFFFFFFFFFFFh
and rax, rcx
mov rcx, 7FF0000000000000h
sub rax, rcx
setl al
test al, 1
jnz short loc_D772B
mov rdi, [rsp+68h+var_28]
movsd xmm0, [rsp+68h+var_50]
call js_dtoa_infinite
mov [rsp+68h+var_10], rax
mov [rsp+68h+var_8], rdx
jmp short loc_D779C
loc_D772B:
mov rax, [rsp+68h+var_38]
mov rdi, [rax]
mov rsi, [rax+8]
call JS_IsUndefined_1
cmp eax, 0
jnz short loc_D7779
cmp [rsp+68h+var_54], 0
jl short loc_D774F
cmp [rsp+68h+var_54], 64h ; 'd'
jle short loc_D776E
loc_D774F:
mov rdi, [rsp+68h+var_28]
lea rsi, aToexponentialA; "toExponential() argument must be betwee"...
mov al, 0
call JS_ThrowRangeError
mov [rsp+68h+var_10], rax
mov [rsp+68h+var_8], rdx
jmp short loc_D779C
loc_D776E:
mov eax, [rsp+68h+var_54]
add eax, 1
mov [rsp+68h+var_54], eax
loc_D7779:
mov rdi, [rsp+68h+var_28]
movsd xmm0, [rsp+68h+var_50]
mov esi, [rsp+68h+var_54]
mov edx, 1
call js_dtoa
mov [rsp+68h+var_10], rax
mov [rsp+68h+var_8], rdx
loc_D779C:
mov rax, [rsp+68h+var_10]
mov rdx, [rsp+68h+var_8]
add rsp, 68h
retn
| long long js_number_toExponential(
long long a1,
long long a2,
long long a3,
int a4,
long long *a5,
double a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rdx
__m128 v14; // xmm0
long long v15; // rdx
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
long long v22; // rdx
long long v23; // rdx
long long v25; // [rsp+0h] [rbp-68h]
unsigned int v26; // [rsp+14h] [rbp-54h] BYREF
double v27; // [rsp+18h] [rbp-50h] BYREF
long long v28; // [rsp+20h] [rbp-48h]
long long v29; // [rsp+28h] [rbp-40h]
long long *v30; // [rsp+30h] [rbp-38h]
int v31; // [rsp+3Ch] [rbp-2Ch]
long long v32; // [rsp+40h] [rbp-28h]
long long v33; // [rsp+48h] [rbp-20h]
long long v34; // [rsp+50h] [rbp-18h]
long long v35; // [rsp+58h] [rbp-10h]
long long v36; // [rsp+60h] [rbp-8h]
v33 = a2;
v34 = a3;
v32 = a1;
v31 = a4;
v30 = a5;
v25 = js_thisNumberValue(a1, a2, a3);
v28 = v25;
v29 = v13;
if ( JS_IsException_1(v25, v13) )
{
v35 = v28;
v36 = v29;
}
else if ( (unsigned int)JS_ToFloat64Free(v32, &v27, v28, v29) )
{
LODWORD(v35) = 0;
v36 = 6LL;
}
else if ( (unsigned int)JS_ToInt32Sat(v32, (long long)&v26, (_DWORD *)*v30, v30[1]) )
{
LODWORD(v35) = 0;
v36 = 6LL;
}
else
{
v14 = (__m128)*(unsigned long long *)&v27;
if ( (*(_QWORD *)&v27 & 0x7FFFFFFFFFFFFFFFuLL) < 0x7FF0000000000000LL )
{
if ( !JS_IsUndefined_1(*v30, v30[1]) )
{
if ( v26 > 0x64 )
{
v35 = JS_ThrowRangeError(
v32,
(long long)"toExponential() argument must be between 0 and 100",
v16,
v17,
v18,
v19,
v14,
a7,
a8,
a9,
v20,
v21,
a12,
a13,
v25);
v36 = v22;
return v35;
}
++v26;
}
v35 = js_dtoa(v32, v26, 1, v27);
v36 = v23;
return v35;
}
v35 = js_dtoa_infinite(v32, v27);
v36 = v15;
}
return v35;
}
| js_number_toExponential:
SUB RSP,0x68
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RSP + 0x40],RDI
MOV dword ptr [RSP + 0x3c],ECX
MOV qword ptr [RSP + 0x30],R8
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
CALL 0x001d7dd0
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001d7679
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x60],RAX
JMP 0x001d779c
LAB_001d7679:
MOV RDI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0x18]
CALL 0x0013e8e0
CMP EAX,0x0
JZ 0x001d76ad
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x6
JMP 0x001d779c
LAB_001d76ad:
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x14]
CALL 0x0013e970
CMP EAX,0x0
JZ 0x001d76e3
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x6
JMP 0x001d779c
LAB_001d76e3:
MOVSD XMM0,qword ptr [RSP + 0x18]
MOVQ RAX,XMM0
MOV RCX,0x7fffffffffffffff
AND RAX,RCX
MOV RCX,0x7ff0000000000000
SUB RAX,RCX
SETL AL
TEST AL,0x1
JNZ 0x001d772b
MOV RDI,qword ptr [RSP + 0x40]
MOVSD XMM0,qword ptr [RSP + 0x18]
CALL 0x00168650
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
JMP 0x001d779c
LAB_001d772b:
MOV RAX,qword ptr [RSP + 0x30]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00134550
CMP EAX,0x0
JNZ 0x001d7779
CMP dword ptr [RSP + 0x14],0x0
JL 0x001d774f
CMP dword ptr [RSP + 0x14],0x64
JLE 0x001d776e
LAB_001d774f:
MOV RDI,qword ptr [RSP + 0x40]
LEA RSI,[0x217169]
MOV AL,0x0
CALL 0x0012f960
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
JMP 0x001d779c
LAB_001d776e:
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
LAB_001d7779:
MOV RDI,qword ptr [RSP + 0x40]
MOVSD XMM0,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RSP + 0x14]
MOV EDX,0x1
CALL 0x0013f940
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
LAB_001d779c:
MOV RAX,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
ADD RSP,0x68
RET
|
int1 [16]
js_number_toExponential
(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
int iVar1;
int1 auVar2 [16];
int local_54;
ulong local_50;
int1 local_48 [16];
int8 *local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_48 = js_thisNumberValue(param_1,param_2,param_3);
iVar1 = JS_IsException(local_48._0_8_,local_48._8_8_);
if (iVar1 == 0) {
iVar1 = JS_ToFloat64Free(local_28,&local_50,local_48._0_8_,local_48._8_8_);
if (iVar1 == 0) {
iVar1 = JS_ToInt32Sat(local_28,&local_54,*local_38,local_38[1]);
if (iVar1 == 0) {
if ((local_50 & 0x7fffffffffffffff) < 0x7ff0000000000000) {
iVar1 = JS_IsUndefined(*local_38,local_38[1]);
if (iVar1 == 0) {
if ((local_54 < 0) || (100 < local_54)) {
auVar2 = JS_ThrowRangeError(local_28,
"toExponential() argument must be between 0 and 100");
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
goto LAB_001d779c;
}
local_54 = local_54 + 1;
}
auVar2 = js_dtoa(local_50,local_28,local_54,1);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
else {
auVar2 = js_dtoa_infinite(local_50,local_28);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
}
else {
local_10 = 0;
local_8 = 6;
}
}
else {
local_10 = 0;
local_8 = 6;
}
}
else {
local_10 = local_48._0_4_;
uStack_c = local_48._4_4_;
local_8 = local_48._8_8_;
}
LAB_001d779c:
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
| |
26,033 | end_simple_key_cache | eloqsql/mysys/mf_keycache.c | static
void end_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache, my_bool cleanup)
{
DBUG_ENTER("end_simple_key_cache");
DBUG_PRINT("enter", ("key_cache: %p", keycache));
if (!keycache->key_cache_inited)
DBUG_VOID_RETURN;
if (keycache->disk_blocks > 0)
{
if (keycache->block_mem)
{
my_large_free((uchar*) keycache->block_mem, keycache->allocated_mem_size);
keycache->block_mem= NULL;
my_free(keycache->block_root);
keycache->block_root= NULL;
}
keycache->disk_blocks= -1;
/* Reset blocks_changed to be safe if flush_all_key_blocks is called */
keycache->blocks_changed= 0;
}
DBUG_PRINT("status", ("used: %lu changed: %lu w_requests: %lu "
"writes: %lu r_requests: %lu reads: %lu",
keycache->blocks_used, keycache->global_blocks_changed,
(ulong) keycache->global_cache_w_requests,
(ulong) keycache->global_cache_write,
(ulong) keycache->global_cache_r_requests,
(ulong) keycache->global_cache_read));
/*
Reset these values to be able to detect a disabled key cache.
See Bug#44068 (RESTORE can disable the MyISAM Key Cache).
*/
keycache->blocks_used= 0;
keycache->blocks_unused= 0;
if (cleanup)
{
mysql_mutex_destroy(&keycache->cache_lock);
keycache->key_cache_inited= keycache->can_be_used= 0;
KEYCACHE_DEBUG_CLOSE;
}
DBUG_VOID_RETURN;
} | O0 | c | end_simple_key_cache:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
jmp 0xe6b34
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xe6b44
jmp 0xe6b3f
jmp 0xe6bfe
movq -0x8(%rbp), %rax
cmpl $0x0, 0x48(%rax)
jle 0xe6bb9
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0xe6ba2
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x101f30
movq -0x8(%rbp), %rax
movq $0x0, 0xa8(%rax)
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0xf3be0
movq -0x8(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x48(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x60(%rax)
jmp 0xe6bbb
jmp 0xe6bbd
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
cmpb $0x0, -0x9(%rbp)
je 0xe6bfa
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
callq 0xe7c30
movq -0x8(%rbp), %rax
movb $0x0, 0x3(%rax)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0xe6bfc
jmp 0xe6bfe
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| end_simple_key_cache:
push rbp
mov rbp, rsp
sub rsp, 10h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
jmp short $+2
loc_E6B34:
mov rax, [rbp+var_8]
cmp byte ptr [rax], 0
jnz short loc_E6B44
jmp short $+2
loc_E6B3F:
jmp loc_E6BFE
loc_E6B44:
mov rax, [rbp+var_8]
cmp dword ptr [rax+48h], 0
jle short loc_E6BB9
mov rax, [rbp+var_8]
cmp qword ptr [rax+0A8h], 0
jz short loc_E6BA2
mov rax, [rbp+var_8]
mov rdi, [rax+0A8h]
mov rax, [rbp+var_8]
mov rsi, [rax+10h]
call my_large_free
mov rax, [rbp+var_8]
mov qword ptr [rax+0A8h], 0
mov rax, [rbp+var_8]
mov rdi, [rax+0A0h]
call my_free
mov rax, [rbp+var_8]
mov qword ptr [rax+0A0h], 0
loc_E6BA2:
mov rax, [rbp+var_8]
mov dword ptr [rax+48h], 0FFFFFFFFh
mov rax, [rbp+var_8]
mov qword ptr [rax+60h], 0
loc_E6BB9:
jmp short $+2
loc_E6BBB:
jmp short $+2
loc_E6BBD:
mov rax, [rbp+var_8]
mov qword ptr [rax+50h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+58h], 0
cmp [rbp+var_9], 0
jz short loc_E6BFA
mov rdi, [rbp+var_8]
add rdi, 0C0h
call inline_mysql_mutex_destroy_7
mov rax, [rbp+var_8]
mov byte ptr [rax+3], 0
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
loc_E6BFA:
jmp short $+2
loc_E6BFC:
jmp short $+2
loc_E6BFE:
add rsp, 10h
pop rbp
retn
| long long end_simple_key_cache(long long a1, char a2)
{
long long result; // rax
result = a1;
if ( *(_BYTE *)a1 )
{
if ( *(int *)(a1 + 72) > 0 )
{
if ( *(_QWORD *)(a1 + 168) )
{
my_large_free(*(_QWORD *)(a1 + 168), *(_QWORD *)(a1 + 16));
*(_QWORD *)(a1 + 168) = 0LL;
my_free(*(_QWORD *)(a1 + 160));
*(_QWORD *)(a1 + 160) = 0LL;
}
*(_DWORD *)(a1 + 72) = -1;
*(_QWORD *)(a1 + 96) = 0LL;
}
*(_QWORD *)(a1 + 80) = 0LL;
result = a1;
*(_QWORD *)(a1 + 88) = 0LL;
if ( a2 )
{
inline_mysql_mutex_destroy_7(a1 + 192);
*(_BYTE *)(a1 + 3) = 0;
result = a1;
*(_BYTE *)a1 = 0;
}
}
return result;
}
| end_simple_key_cache:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
JMP 0x001e6b34
LAB_001e6b34:
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX],0x0
JNZ 0x001e6b44
JMP 0x001e6b3f
LAB_001e6b3f:
JMP 0x001e6bfe
LAB_001e6b44:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x48],0x0
JLE 0x001e6bb9
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0xa8],0x0
JZ 0x001e6ba2
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0xa8]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0x10]
CALL 0x00201f30
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0xa0]
CALL 0x001f3be0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa0],0x0
LAB_001e6ba2:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x48],0xffffffff
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x60],0x0
LAB_001e6bb9:
JMP 0x001e6bbb
LAB_001e6bbb:
JMP 0x001e6bbd
LAB_001e6bbd:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x50],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x58],0x0
CMP byte ptr [RBP + -0x9],0x0
JZ 0x001e6bfa
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
CALL 0x001e7c30
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x3],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
LAB_001e6bfa:
JMP 0x001e6bfc
LAB_001e6bfc:
JMP 0x001e6bfe
LAB_001e6bfe:
ADD RSP,0x10
POP RBP
RET
|
void end_simple_key_cache(char *param_1,char param_2)
{
if (*param_1 != '\0') {
if (0 < *(int *)(param_1 + 0x48)) {
if (*(long *)(param_1 + 0xa8) != 0) {
my_large_free(*(int8 *)(param_1 + 0xa8),*(int8 *)(param_1 + 0x10));
param_1[0xa8] = '\0';
param_1[0xa9] = '\0';
param_1[0xaa] = '\0';
param_1[0xab] = '\0';
param_1[0xac] = '\0';
param_1[0xad] = '\0';
param_1[0xae] = '\0';
param_1[0xaf] = '\0';
my_free(*(int8 *)(param_1 + 0xa0));
param_1[0xa0] = '\0';
param_1[0xa1] = '\0';
param_1[0xa2] = '\0';
param_1[0xa3] = '\0';
param_1[0xa4] = '\0';
param_1[0xa5] = '\0';
param_1[0xa6] = '\0';
param_1[0xa7] = '\0';
}
param_1[0x48] = -1;
param_1[0x49] = -1;
param_1[0x4a] = -1;
param_1[0x4b] = -1;
param_1[0x60] = '\0';
param_1[0x61] = '\0';
param_1[0x62] = '\0';
param_1[99] = '\0';
param_1[100] = '\0';
param_1[0x65] = '\0';
param_1[0x66] = '\0';
param_1[0x67] = '\0';
}
param_1[0x50] = '\0';
param_1[0x51] = '\0';
param_1[0x52] = '\0';
param_1[0x53] = '\0';
param_1[0x54] = '\0';
param_1[0x55] = '\0';
param_1[0x56] = '\0';
param_1[0x57] = '\0';
param_1[0x58] = '\0';
param_1[0x59] = '\0';
param_1[0x5a] = '\0';
param_1[0x5b] = '\0';
param_1[0x5c] = '\0';
param_1[0x5d] = '\0';
param_1[0x5e] = '\0';
param_1[0x5f] = '\0';
if (param_2 != '\0') {
inline_mysql_mutex_destroy(param_1 + 0xc0);
param_1[3] = '\0';
*param_1 = '\0';
}
}
return;
}
| |
26,034 | ggml_set_f32_1d | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | void ggml_set_f32_1d(const struct ggml_tensor * tensor, int i, float value) {
if (!ggml_is_contiguous(tensor)) {
int64_t id[4] = { 0, 0, 0, 0 };
ggml_unravel_index(tensor, i, &id[0], &id[1], &id[2], &id[3]);
ggml_set_f32_nd(tensor, id[0], id[1], id[2], id[3], value);
return;
}
switch (tensor->type) {
case GGML_TYPE_I8:
{
GGML_ASSERT(tensor->nb[0] == sizeof(int8_t));
((int8_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_I16:
{
GGML_ASSERT(tensor->nb[0] == sizeof(int16_t));
((int16_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_I32:
{
GGML_ASSERT(tensor->nb[0] == sizeof(int32_t));
((int32_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_F16:
{
GGML_ASSERT(tensor->nb[0] == sizeof(ggml_fp16_t));
((ggml_fp16_t *)(tensor->data))[i] = GGML_FP32_TO_FP16(value);
} break;
case GGML_TYPE_F32:
{
GGML_ASSERT(tensor->nb[0] == sizeof(float));
((float *)(tensor->data))[i] = value;
} break;
default:
{
GGML_ASSERT(false);
} break;
}
} | O1 | c | ggml_set_f32_1d:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
vmovaps %xmm0, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
callq 0x8e334
testb %al, %al
je 0x908d6
vmovaps (%rsp), %xmm0
movl (%rbx), %eax
cmpl $0xf, %eax
jle 0x9091f
cmpl $0x12, %eax
je 0x9094c
cmpl $0x11, %eax
je 0x90966
cmpl $0x10, %eax
jne 0x9099e
cmpq $0x1, 0x30(%rbx)
jne 0x909a8
vcvttss2si %xmm0, %eax
movq 0x118(%rbx), %rcx
movslq %ebp, %rdx
movb %al, (%rcx,%rdx)
jmp 0x90997
movslq %ebp, %rax
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rcx
imulq %rsi, %rcx
movq 0x20(%rbx), %rdi
imulq %rcx, %rdi
cqto
idivq %rdi
movq %rax, %r8
movq %rdx, %rax
cqto
idivq %rcx
movq %rax, %rcx
movq %rdx, %rax
cqto
idivq %rsi
movq %rbx, %rdi
movl %edx, %esi
movl %eax, %edx
vmovaps (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x909bc
testl %eax, %eax
je 0x90981
cmpl $0x1, %eax
jne 0x9099e
cmpq $0x2, 0x30(%rbx)
jne 0x909b7
vcvtps2ph $0x0, %xmm0, %xmm0
movq 0x118(%rbx), %rax
movslq %ebp, %rcx
vpextrw $0x0, %xmm0, (%rax,%rcx,2)
jmp 0x90997
cmpq $0x4, 0x30(%rbx)
jne 0x909a3
vcvttss2si %xmm0, %eax
movq 0x118(%rbx), %rcx
movslq %ebp, %rdx
movl %eax, (%rcx,%rdx,4)
jmp 0x90997
cmpq $0x2, 0x30(%rbx)
jne 0x909ad
vcvttss2si %xmm0, %eax
movq 0x118(%rbx), %rcx
movslq %ebp, %rdx
movw %ax, (%rcx,%rdx,2)
jmp 0x90997
cmpq $0x4, 0x30(%rbx)
jne 0x909b2
movq 0x118(%rbx), %rax
movslq %ebp, %rcx
vmovss %xmm0, (%rax,%rcx,4)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
callq 0xca7f
callq 0xc9b0
callq 0xca3a
callq 0xc9f5
callq 0xc926
callq 0xc96b
| ggml_set_f32_1d:
push rbp
push rbx
sub rsp, 18h
vmovaps [rsp+28h+var_28], xmm0
mov ebp, esi
mov rbx, rdi
call ggml_is_contiguous
test al, al
jz short loc_908D6
vmovaps xmm0, [rsp+28h+var_28]
mov eax, [rbx]
cmp eax, 0Fh
jle loc_9091F
cmp eax, 12h
jz loc_9094C
cmp eax, 11h
jz loc_90966
cmp eax, 10h
jnz loc_9099E
cmp qword ptr [rbx+30h], 1
jnz loc_909A8
vcvttss2si eax, xmm0
mov rcx, [rbx+118h]
movsxd rdx, ebp
mov [rcx+rdx], al
jmp loc_90997
loc_908D6:
movsxd rax, ebp
mov rsi, [rbx+10h]
mov rcx, [rbx+18h]
imul rcx, rsi
mov rdi, [rbx+20h]
imul rdi, rcx
cqo
idiv rdi
mov r8, rax
mov rax, rdx
cqo
idiv rcx
mov rcx, rax
mov rax, rdx
cqo
idiv rsi
mov rdi, rbx
mov esi, edx
mov edx, eax
vmovaps xmm0, [rsp+28h+var_28]
add rsp, 18h
pop rbx
pop rbp
jmp ggml_set_f32_nd
loc_9091F:
test eax, eax
jz short loc_90981
cmp eax, 1
jnz short loc_9099E
cmp qword ptr [rbx+30h], 2
jnz loc_909B7
vcvtps2ph xmm0, xmm0, 0
mov rax, [rbx+118h]
movsxd rcx, ebp
vpextrw word ptr [rax+rcx*2], xmm0, 0
jmp short loc_90997
loc_9094C:
cmp qword ptr [rbx+30h], 4
jnz short loc_909A3
vcvttss2si eax, xmm0
mov rcx, [rbx+118h]
movsxd rdx, ebp
mov [rcx+rdx*4], eax
jmp short loc_90997
loc_90966:
cmp qword ptr [rbx+30h], 2
jnz short loc_909AD
vcvttss2si eax, xmm0
mov rcx, [rbx+118h]
movsxd rdx, ebp
mov [rcx+rdx*2], ax
jmp short loc_90997
loc_90981:
cmp qword ptr [rbx+30h], 4
jnz short loc_909B2
mov rax, [rbx+118h]
movsxd rcx, ebp
vmovss dword ptr [rax+rcx*4], xmm0
loc_90997:
add rsp, 18h
pop rbx
pop rbp
retn
loc_9099E:
call ggml_set_f32_1d_cold_6
loc_909A3:
call ggml_set_f32_1d_cold_3
loc_909A8:
call ggml_set_f32_1d_cold_5
loc_909AD:
call ggml_set_f32_1d_cold_4
loc_909B2:
call ggml_set_f32_1d_cold_1
loc_909B7:
call ggml_set_f32_1d_cold_2
| int ggml_set_f32_1d(_QWORD *a1, int a2, __m128 _XMM0)
{
int v5; // eax
long long v7; // rsi
long long v8; // rcx
__asm { vmovaps [rsp+28h+var_28], xmm0 }
if ( !(unsigned __int8)ggml_is_contiguous(a1) )
{
v7 = a1[2];
v8 = v7 * a1[3];
__asm { vmovaps xmm0, [rsp+28h+var_28] }
LODWORD(_RAX) = ggml_set_f32_nd(
a1,
(unsigned int)(a2 % (v8 * a1[4]) % v8 % v7),
(unsigned int)(a2 % (v8 * a1[4]) % v8 / v7),
a2 % (v8 * a1[4]) / v8,
a2 / (v8 * a1[4]),
*(double *)&_XMM0);
return _RAX;
}
__asm { vmovaps xmm0, [rsp+28h+var_28] }
v5 = *(_DWORD *)a1;
if ( *(int *)a1 <= 15 )
{
if ( v5 )
{
if ( v5 != 1 )
goto LABEL_19;
if ( a1[6] != 2LL )
ggml_set_f32_1d_cold_2(*(double *)&_XMM0);
__asm { vcvtps2ph xmm0, xmm0, 0 }
_RAX = a1[35];
_RCX = a2;
__asm { vpextrw word ptr [rax+rcx*2], xmm0, 0 }
}
else
{
if ( a1[6] != 4LL )
ggml_set_f32_1d_cold_1(*(double *)&_XMM0);
_RAX = a1[35];
_RCX = a2;
__asm { vmovss dword ptr [rax+rcx*4], xmm0 }
}
}
else
{
switch ( v5 )
{
case 18:
if ( a1[6] != 4LL )
ggml_set_f32_1d_cold_3(*(double *)&_XMM0);
__asm { vcvttss2si eax, xmm0 }
*(_DWORD *)(a1[35] + 4LL * a2) = _RAX;
break;
case 17:
if ( a1[6] != 2LL )
ggml_set_f32_1d_cold_4(*(double *)&_XMM0);
__asm { vcvttss2si eax, xmm0 }
*(_WORD *)(a1[35] + 2LL * a2) = _RAX;
break;
case 16:
if ( a1[6] != 1LL )
ggml_set_f32_1d_cold_5(*(double *)&_XMM0);
__asm { vcvttss2si eax, xmm0 }
*(_BYTE *)(a1[35] + a2) = _RAX;
return _RAX;
default:
LABEL_19:
ggml_set_f32_1d_cold_6(*(double *)&_XMM0);
}
}
return _RAX;
}
| |||
26,035 | ggml_set_f32_1d | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | void ggml_set_f32_1d(const struct ggml_tensor * tensor, int i, float value) {
if (!ggml_is_contiguous(tensor)) {
int64_t id[4] = { 0, 0, 0, 0 };
ggml_unravel_index(tensor, i, &id[0], &id[1], &id[2], &id[3]);
ggml_set_f32_nd(tensor, id[0], id[1], id[2], id[3], value);
return;
}
switch (tensor->type) {
case GGML_TYPE_I8:
{
GGML_ASSERT(tensor->nb[0] == sizeof(int8_t));
((int8_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_I16:
{
GGML_ASSERT(tensor->nb[0] == sizeof(int16_t));
((int16_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_I32:
{
GGML_ASSERT(tensor->nb[0] == sizeof(int32_t));
((int32_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_F16:
{
GGML_ASSERT(tensor->nb[0] == sizeof(ggml_fp16_t));
((ggml_fp16_t *)(tensor->data))[i] = GGML_FP32_TO_FP16(value);
} break;
case GGML_TYPE_F32:
{
GGML_ASSERT(tensor->nb[0] == sizeof(float));
((float *)(tensor->data))[i] = value;
} break;
default:
{
GGML_ASSERT(false);
} break;
}
} | O2 | c | ggml_set_f32_1d:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
vmovaps %xmm0, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
callq 0x67db9
testb %al, %al
je 0x69565
vmovaps (%rsp), %xmm0
movl (%rbx), %eax
testl %eax, %eax
je 0x695d8
cmpl $0x1, %eax
je 0x695b8
cmpl $0x12, %eax
je 0x695f4
cmpl $0x11, %eax
je 0x69612
cmpl $0x10, %eax
jne 0x69746
cmpq $0x1, 0x30(%rbx)
jne 0x696a4
vcvttss2si %xmm0, %eax
movq 0x118(%rbx), %rcx
movslq %ebp, %rdx
movb %al, (%rcx,%rdx)
jmp 0x695af
vxorps %xmm0, %xmm0, %xmm0
leaq 0x18(%rsp), %rcx
vmovups %ymm0, -0x8(%rcx)
movslq %ebp, %rsi
leaq 0x20(%rsp), %r8
leaq 0x28(%rsp), %r9
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
vzeroupper
callq 0x68b0d
movl (%r14), %esi
movl 0x8(%r14), %edx
movl 0x10(%r14), %ecx
movl 0x18(%r14), %r8d
movq %rbx, %rdi
vmovaps (%rsp), %xmm0
callq 0x6978a
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpq $0x2, 0x30(%rbx)
jne 0x69634
vcvtps2ph $0x0, %xmm0, %xmm0
movq 0x118(%rbx), %rax
movslq %ebp, %rcx
vpextrw $0x0, %xmm0, (%rax,%rcx,2)
jmp 0x695af
cmpq $0x4, 0x30(%rbx)
jne 0x6966c
movq 0x118(%rbx), %rax
movslq %ebp, %rcx
vmovss %xmm0, (%rax,%rcx,4)
jmp 0x695af
cmpq $0x4, 0x30(%rbx)
jne 0x696dc
vcvttss2si %xmm0, %eax
movq 0x118(%rbx), %rcx
movslq %ebp, %rdx
movl %eax, (%rcx,%rdx,4)
jmp 0x695af
cmpq $0x2, 0x30(%rbx)
jne 0x69711
vcvttss2si %xmm0, %eax
movq 0x118(%rbx), %rcx
movslq %ebp, %rdx
movw %ax, (%rcx,%rdx,2)
jmp 0x695af
movq 0x6c90d(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6c95e(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x30bca(%rip), %rsi # 0x9a21e
leaq 0x38223(%rip), %rdx # 0xa187e
leaq 0x384a4(%rip), %r8 # 0xa1b06
movl $0xb9e, %ecx # imm = 0xB9E
jmp 0x69779
movq 0x6c8d5(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6c926(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x30b92(%rip), %rsi # 0x9a21e
leaq 0x381eb(%rip), %rdx # 0xa187e
leaq 0x31392(%rip), %r8 # 0x9aa2c
movl $0xba3, %ecx # imm = 0xBA3
jmp 0x69779
movq 0x6c89d(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6c8ee(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x30b5a(%rip), %rsi # 0x9a21e
leaq 0x381b3(%rip), %rdx # 0xa187e
leaq 0x383d2(%rip), %r8 # 0xa1aa4
movl $0xb8f, %ecx # imm = 0xB8F
jmp 0x69779
movq 0x6c865(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6c8b6(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x30b22(%rip), %rsi # 0x9a21e
leaq 0x3817b(%rip), %rdx # 0xa187e
leaq 0x383db(%rip), %r8 # 0xa1ae5
movl $0xb99, %ecx # imm = 0xB99
jmp 0x69779
movq 0x6c830(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6c881(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x30aed(%rip), %rsi # 0x9a21e
leaq 0x38146(%rip), %rdx # 0xa187e
leaq 0x38385(%rip), %r8 # 0xa1ac4
movl $0xb94, %ecx # imm = 0xB94
jmp 0x69779
movq 0x6c7fb(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6c84c(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x30ab8(%rip), %rsi # 0x9a21e
leaq 0x38111(%rip), %rdx # 0xa187e
leaq 0x2e8cb(%rip), %r8 # 0x9803f
movl $0xba8, %ecx # imm = 0xBA8
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
| ggml_set_f32_1d:
push rbp
push r14
push rbx
sub rsp, 30h
vmovaps [rsp+48h+var_48], xmm0
mov ebp, esi
mov rbx, rdi
call ggml_is_contiguous
test al, al
jz short loc_69565
vmovaps xmm0, [rsp+48h+var_48]
mov eax, [rbx]
test eax, eax
jz loc_695D8
cmp eax, 1
jz loc_695B8
cmp eax, 12h
jz loc_695F4
cmp eax, 11h
jz loc_69612
cmp eax, 10h
jnz loc_69746
cmp qword ptr [rbx+30h], 1
jnz loc_696A4
vcvttss2si eax, xmm0
mov rcx, [rbx+118h]
movsxd rdx, ebp
mov [rcx+rdx], al
jmp short loc_695AF
loc_69565:
vxorps xmm0, xmm0, xmm0
lea rcx, [rsp+48h+var_30]
vmovups ymmword ptr [rcx-8], ymm0
movsxd rsi, ebp
lea r8, [rsp+48h+var_28]
lea r9, [rsp+48h+var_20]
lea r14, [rsp+48h+var_38]
mov rdi, rbx
mov rdx, r14
vzeroupper
call ggml_unravel_index
mov esi, [r14]
mov edx, [r14+8]
mov ecx, [r14+10h]
mov r8d, [r14+18h]
mov rdi, rbx
vmovaps xmm0, [rsp+48h+var_48]
call ggml_set_f32_nd
loc_695AF:
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_695B8:
cmp qword ptr [rbx+30h], 2
jnz short loc_69634
vcvtps2ph xmm0, xmm0, 0
mov rax, [rbx+118h]
movsxd rcx, ebp
vpextrw word ptr [rax+rcx*2], xmm0, 0
jmp short loc_695AF
loc_695D8:
cmp qword ptr [rbx+30h], 4
jnz loc_6966C
mov rax, [rbx+118h]
movsxd rcx, ebp
vmovss dword ptr [rax+rcx*4], xmm0
jmp short loc_695AF
loc_695F4:
cmp qword ptr [rbx+30h], 4
jnz loc_696DC
vcvttss2si eax, xmm0
mov rcx, [rbx+118h]
movsxd rdx, ebp
mov [rcx+rdx*4], eax
jmp short loc_695AF
loc_69612:
cmp qword ptr [rbx+30h], 2
jnz loc_69711
vcvttss2si eax, xmm0
mov rcx, [rbx+118h]
movsxd rdx, ebp
mov [rcx+rdx*2], ax
jmp loc_695AF
loc_69634:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aTensorNb0Sizeo_0; "tensor->nb[0] == sizeof(ggml_fp16_t)"
mov ecx, 0B9Eh
jmp loc_69779
loc_6966C:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aTensorNb0Sizeo; "tensor->nb[0] == sizeof(float)"
mov ecx, 0BA3h
jmp loc_69779
loc_696A4:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aTensorNb0Sizeo_1; "tensor->nb[0] == sizeof(int8_t)"
mov ecx, 0B8Fh
jmp loc_69779
loc_696DC:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aTensorNb0Sizeo_2; "tensor->nb[0] == sizeof(int32_t)"
mov ecx, 0B99h
jmp short loc_69779
loc_69711:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aTensorNb0Sizeo_3; "tensor->nb[0] == sizeof(int16_t)"
mov ecx, 0B94h
jmp short loc_69779
loc_69746:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aFalse; "false"
mov ecx, 0BA8h
loc_69779:
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
| int ggml_set_f32_1d(_QWORD *a1, int a2, __m128 _XMM0)
{
int v5; // eax
long long v13; // rdi
long long v14; // r9
long long v15; // r9
long long v16; // r9
long long v17; // r9
long long v18; // r9
long long v19; // r9
long long v22; // [rsp+10h] [rbp-38h] BYREF
long long v23; // [rsp+18h] [rbp-30h] BYREF
long long v24; // [rsp+20h] [rbp-28h] BYREF
long long v25[4]; // [rsp+28h] [rbp-20h] BYREF
__asm { vmovaps [rsp+48h+var_48], xmm0 }
if ( !(unsigned __int8)ggml_is_contiguous(a1) )
{
__asm { vxorps xmm0, xmm0, xmm0 }
_RCX = &v23;
__asm
{
vmovups ymmword ptr [rcx-8], ymm0
vzeroupper
}
ggml_unravel_index(a1, a2, &v22, &v23, &v24, v25);
__asm { vmovaps xmm0, [rsp+48h+var_48] }
LODWORD(_RAX) = ggml_set_f32_nd(
a1,
(unsigned int)v22,
(unsigned int)v23,
(unsigned int)v24,
LODWORD(v25[0]),
*(double *)&_XMM0);
return _RAX;
}
__asm { vmovaps xmm0, [rsp+48h+var_48] }
v5 = *(_DWORD *)a1;
if ( !*(_DWORD *)a1 )
{
if ( a1[6] == 4LL )
{
_RAX = a1[35];
_RCX = a2;
__asm { vmovss dword ptr [rax+rcx*4], xmm0 }
return _RAX;
}
fflush(stdout);
v13 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
2979LL,
"tensor->nb[0] == sizeof(float)",
v15,
*(double *)&_XMM0);
goto LABEL_24;
}
switch ( v5 )
{
case 1:
if ( a1[6] == 2LL )
{
__asm { vcvtps2ph xmm0, xmm0, 0 }
_RAX = a1[35];
_RCX = a2;
__asm { vpextrw word ptr [rax+rcx*2], xmm0, 0 }
return _RAX;
}
fflush(stdout);
v13 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
2974LL,
"tensor->nb[0] == sizeof(ggml_fp16_t)",
v14,
*(double *)&_XMM0);
LABEL_24:
ggml_print_backtrace();
abort(v13);
case 18:
if ( a1[6] == 4LL )
{
__asm { vcvttss2si eax, xmm0 }
*(_DWORD *)(a1[35] + 4LL * a2) = _RAX;
return _RAX;
}
fflush(stdout);
v13 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
2969LL,
"tensor->nb[0] == sizeof(int32_t)",
v17,
*(double *)&_XMM0);
goto LABEL_24;
case 17:
if ( a1[6] == 2LL )
{
__asm { vcvttss2si eax, xmm0 }
*(_WORD *)(a1[35] + 2LL * a2) = _RAX;
return _RAX;
}
fflush(stdout);
v13 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
2964LL,
"tensor->nb[0] == sizeof(int16_t)",
v18,
*(double *)&_XMM0);
goto LABEL_24;
}
if ( v5 != 16 )
{
fflush(stdout);
v13 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
2984LL,
"false",
v19,
*(double *)&_XMM0);
goto LABEL_24;
}
if ( a1[6] != 1LL )
{
fflush(stdout);
v13 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
2959LL,
"tensor->nb[0] == sizeof(int8_t)",
v16,
*(double *)&_XMM0);
goto LABEL_24;
}
__asm { vcvttss2si eax, xmm0 }
*(_BYTE *)(a1[35] + a2) = _RAX;
return _RAX;
}
| ggml_set_f32_1d:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
VMOVAPS xmmword ptr [RSP],XMM0
MOV EBP,ESI
MOV RBX,RDI
CALL 0x00167db9
TEST AL,AL
JZ 0x00169565
VMOVAPS XMM0,xmmword ptr [RSP]
MOV EAX,dword ptr [RBX]
TEST EAX,EAX
JZ 0x001695d8
CMP EAX,0x1
JZ 0x001695b8
CMP EAX,0x12
JZ 0x001695f4
CMP EAX,0x11
JZ 0x00169612
CMP EAX,0x10
JNZ 0x00169746
CMP qword ptr [RBX + 0x30],0x1
JNZ 0x001696a4
VCVTTSS2SI EAX,XMM0
MOV RCX,qword ptr [RBX + 0x118]
MOVSXD RDX,EBP
MOV byte ptr [RCX + RDX*0x1],AL
JMP 0x001695af
LAB_00169565:
VXORPS XMM0,XMM0,XMM0
LEA RCX,[RSP + 0x18]
VMOVUPS ymmword ptr [RCX + -0x8],YMM0
MOVSXD RSI,EBP
LEA R8,[RSP + 0x20]
LEA R9,[RSP + 0x28]
LEA R14,[RSP + 0x10]
MOV RDI,RBX
MOV RDX,R14
VZEROUPPER
CALL 0x00168b0d
MOV ESI,dword ptr [R14]
MOV EDX,dword ptr [R14 + 0x8]
MOV ECX,dword ptr [R14 + 0x10]
MOV R8D,dword ptr [R14 + 0x18]
MOV RDI,RBX
VMOVAPS XMM0,xmmword ptr [RSP]
CALL 0x0016978a
LAB_001695af:
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001695b8:
CMP qword ptr [RBX + 0x30],0x2
JNZ 0x00169634
VCVTPS2PH XMM0,XMM0,0x0
MOV RAX,qword ptr [RBX + 0x118]
MOVSXD RCX,EBP
VPEXTRW word ptr [RAX + RCX*0x2],XMM0,0x0
JMP 0x001695af
LAB_001695d8:
CMP qword ptr [RBX + 0x30],0x4
JNZ 0x0016966c
MOV RAX,qword ptr [RBX + 0x118]
MOVSXD RCX,EBP
VMOVSS dword ptr [RAX + RCX*0x4],XMM0
JMP 0x001695af
LAB_001695f4:
CMP qword ptr [RBX + 0x30],0x4
JNZ 0x001696dc
VCVTTSS2SI EAX,XMM0
MOV RCX,qword ptr [RBX + 0x118]
MOVSXD RDX,EBP
MOV dword ptr [RCX + RDX*0x4],EAX
JMP 0x001695af
LAB_00169612:
CMP qword ptr [RBX + 0x30],0x2
JNZ 0x00169711
VCVTTSS2SI EAX,XMM0
MOV RCX,qword ptr [RBX + 0x118]
MOVSXD RDX,EBP
MOV word ptr [RCX + RDX*0x2],AX
JMP 0x001695af
LAB_00169634:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a1b06]
MOV ECX,0xb9e
JMP 0x00169779
LAB_0016966c:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x19aa2c]
MOV ECX,0xba3
JMP 0x00169779
LAB_001696a4:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a1aa4]
MOV ECX,0xb8f
JMP 0x00169779
LAB_001696dc:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a1ae5]
MOV ECX,0xb99
JMP 0x00169779
LAB_00169711:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a1ac4]
MOV ECX,0xb94
JMP 0x00169779
LAB_00169746:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x19803f]
MOV ECX,0xba8
LAB_00169779:
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
void ggml_set_f32_1d(int8 param_1,int *param_2,int param_3)
{
int iVar1;
char cVar2;
int8 uVar3;
FILE *__stream;
char *pcVar4;
float fVar5;
int8 in_XMM0_Qb;
int1 auVar6 [16];
ulong local_38;
ulong uStack_30;
ulong uStack_28;
ulong uStack_20;
cVar2 = ggml_is_contiguous();
if (cVar2 == '\0') {
local_38 = 0;
uStack_30 = 0;
uStack_28 = 0;
uStack_20 = 0;
ggml_unravel_index(param_2,(long)param_3,&local_38,&uStack_30,&uStack_28,&uStack_20);
ggml_set_f32_nd(param_1,param_2,local_38 & 0xffffffff,uStack_30 & 0xffffffff,
uStack_28 & 0xffffffff,uStack_20 & 0xffffffff);
return;
}
auVar6._8_8_ = in_XMM0_Qb;
auVar6._0_8_ = param_1;
iVar1 = *param_2;
fVar5 = (float)param_1;
if (iVar1 == 0) {
if (*(long *)(param_2 + 0xc) == 4) {
*(float *)(*(long *)(param_2 + 0x46) + (long)param_3 * 4) = fVar5;
return;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar4 = "tensor->nb[0] == sizeof(float)";
uVar3 = 0xba3;
}
else if (iVar1 == 1) {
if (*(long *)(param_2 + 0xc) == 2) {
auVar6 = vcvtps2ph_f16c(auVar6,0);
vpextrw_avx(auVar6,0);
return;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar4 = "tensor->nb[0] == sizeof(ggml_fp16_t)";
uVar3 = 0xb9e;
}
else if (iVar1 == 0x12) {
if (*(long *)(param_2 + 0xc) == 4) {
*(int *)(*(long *)(param_2 + 0x46) + (long)param_3 * 4) = (int)fVar5;
return;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar4 = "tensor->nb[0] == sizeof(int32_t)";
uVar3 = 0xb99;
}
else if (iVar1 == 0x11) {
if (*(long *)(param_2 + 0xc) == 2) {
*(short *)(*(long *)(param_2 + 0x46) + (long)param_3 * 2) = (short)(int)fVar5;
return;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar4 = "tensor->nb[0] == sizeof(int16_t)";
uVar3 = 0xb94;
}
else if (iVar1 == 0x10) {
if (*(long *)(param_2 + 0xc) == 1) {
*(char *)(*(long *)(param_2 + 0x46) + (long)param_3) = (char)(int)fVar5;
return;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar4 = "tensor->nb[0] == sizeof(int8_t)";
uVar3 = 0xb8f;
}
else {
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar4 = "false";
uVar3 = 0xba8;
}
fprintf(__stream,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
uVar3,pcVar4);
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
| |
26,036 | ggml_set_f32_1d | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | void ggml_set_f32_1d(const struct ggml_tensor * tensor, int i, float value) {
if (!ggml_is_contiguous(tensor)) {
int64_t id[4] = { 0, 0, 0, 0 };
ggml_unravel_index(tensor, i, &id[0], &id[1], &id[2], &id[3]);
ggml_set_f32_nd(tensor, id[0], id[1], id[2], id[3], value);
return;
}
switch (tensor->type) {
case GGML_TYPE_I8:
{
GGML_ASSERT(tensor->nb[0] == sizeof(int8_t));
((int8_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_I16:
{
GGML_ASSERT(tensor->nb[0] == sizeof(int16_t));
((int16_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_I32:
{
GGML_ASSERT(tensor->nb[0] == sizeof(int32_t));
((int32_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_F16:
{
GGML_ASSERT(tensor->nb[0] == sizeof(ggml_fp16_t));
((ggml_fp16_t *)(tensor->data))[i] = GGML_FP32_TO_FP16(value);
} break;
case GGML_TYPE_F32:
{
GGML_ASSERT(tensor->nb[0] == sizeof(float));
((float *)(tensor->data))[i] = value;
} break;
default:
{
GGML_ASSERT(false);
} break;
}
} | O3 | c | ggml_set_f32_1d:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
vmovaps %xmm0, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
callq 0x8d0a3
testb %al, %al
je 0x8f63c
vmovaps (%rsp), %xmm0
movl (%rbx), %eax
cmpl $0xf, %eax
jle 0x8f685
cmpl $0x12, %eax
je 0x8f6b2
cmpl $0x11, %eax
je 0x8f6cc
cmpl $0x10, %eax
jne 0x8f704
cmpq $0x1, 0x30(%rbx)
jne 0x8f70e
vcvttss2si %xmm0, %eax
movq 0x118(%rbx), %rcx
movslq %ebp, %rdx
movb %al, (%rcx,%rdx)
jmp 0x8f6fd
movslq %ebp, %rax
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rcx
imulq %rsi, %rcx
movq 0x20(%rbx), %rdi
imulq %rcx, %rdi
cqto
idivq %rdi
movq %rax, %r8
movq %rdx, %rax
cqto
idivq %rcx
movq %rax, %rcx
movq %rdx, %rax
cqto
idivq %rsi
movq %rbx, %rdi
movl %edx, %esi
movl %eax, %edx
vmovaps (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x8f722
testl %eax, %eax
je 0x8f6e7
cmpl $0x1, %eax
jne 0x8f704
cmpq $0x2, 0x30(%rbx)
jne 0x8f71d
vcvtps2ph $0x0, %xmm0, %xmm0
movq 0x118(%rbx), %rax
movslq %ebp, %rcx
vpextrw $0x0, %xmm0, (%rax,%rcx,2)
jmp 0x8f6fd
cmpq $0x4, 0x30(%rbx)
jne 0x8f709
vcvttss2si %xmm0, %eax
movq 0x118(%rbx), %rcx
movslq %ebp, %rdx
movl %eax, (%rcx,%rdx,4)
jmp 0x8f6fd
cmpq $0x2, 0x30(%rbx)
jne 0x8f713
vcvttss2si %xmm0, %eax
movq 0x118(%rbx), %rcx
movslq %ebp, %rdx
movw %ax, (%rcx,%rdx,2)
jmp 0x8f6fd
cmpq $0x4, 0x30(%rbx)
jne 0x8f718
movq 0x118(%rbx), %rax
movslq %ebp, %rcx
vmovss %xmm0, (%rax,%rcx,4)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
callq 0xca2a
callq 0xc95b
callq 0xc9e5
callq 0xc9a0
callq 0xc8d1
callq 0xc916
| ggml_set_f32_1d:
push rbp
push rbx
sub rsp, 18h
vmovaps [rsp+28h+var_28], xmm0
mov ebp, esi
mov rbx, rdi
call ggml_is_contiguous
test al, al
jz short loc_8F63C
vmovaps xmm0, [rsp+28h+var_28]
mov eax, [rbx]
cmp eax, 0Fh
jle loc_8F685
cmp eax, 12h
jz loc_8F6B2
cmp eax, 11h
jz loc_8F6CC
cmp eax, 10h
jnz loc_8F704
cmp qword ptr [rbx+30h], 1
jnz loc_8F70E
vcvttss2si eax, xmm0
mov rcx, [rbx+118h]
movsxd rdx, ebp
mov [rcx+rdx], al
jmp loc_8F6FD
loc_8F63C:
movsxd rax, ebp
mov rsi, [rbx+10h]
mov rcx, [rbx+18h]
imul rcx, rsi
mov rdi, [rbx+20h]
imul rdi, rcx
cqo
idiv rdi
mov r8, rax
mov rax, rdx
cqo
idiv rcx
mov rcx, rax
mov rax, rdx
cqo
idiv rsi
mov rdi, rbx
mov esi, edx
mov edx, eax
vmovaps xmm0, [rsp+28h+var_28]
add rsp, 18h
pop rbx
pop rbp
jmp ggml_set_f32_nd
loc_8F685:
test eax, eax
jz short loc_8F6E7
cmp eax, 1
jnz short loc_8F704
cmp qword ptr [rbx+30h], 2
jnz loc_8F71D
vcvtps2ph xmm0, xmm0, 0
mov rax, [rbx+118h]
movsxd rcx, ebp
vpextrw word ptr [rax+rcx*2], xmm0, 0
jmp short loc_8F6FD
loc_8F6B2:
cmp qword ptr [rbx+30h], 4
jnz short loc_8F709
vcvttss2si eax, xmm0
mov rcx, [rbx+118h]
movsxd rdx, ebp
mov [rcx+rdx*4], eax
jmp short loc_8F6FD
loc_8F6CC:
cmp qword ptr [rbx+30h], 2
jnz short loc_8F713
vcvttss2si eax, xmm0
mov rcx, [rbx+118h]
movsxd rdx, ebp
mov [rcx+rdx*2], ax
jmp short loc_8F6FD
loc_8F6E7:
cmp qword ptr [rbx+30h], 4
jnz short loc_8F718
mov rax, [rbx+118h]
movsxd rcx, ebp
vmovss dword ptr [rax+rcx*4], xmm0
loc_8F6FD:
add rsp, 18h
pop rbx
pop rbp
retn
loc_8F704:
call ggml_set_f32_1d_cold_6
loc_8F709:
call ggml_set_f32_1d_cold_3
loc_8F70E:
call ggml_set_f32_1d_cold_5
loc_8F713:
call ggml_set_f32_1d_cold_4
loc_8F718:
call ggml_set_f32_1d_cold_1
loc_8F71D:
call ggml_set_f32_1d_cold_2
| int ggml_set_f32_1d(_QWORD *a1, int a2, __m128 _XMM0)
{
int v5; // eax
long long v7; // rsi
long long v8; // rcx
__asm { vmovaps [rsp+28h+var_28], xmm0 }
if ( !(unsigned __int8)ggml_is_contiguous(a1) )
{
v7 = a1[2];
v8 = v7 * a1[3];
__asm { vmovaps xmm0, [rsp+28h+var_28] }
LODWORD(_RAX) = ggml_set_f32_nd(
a1,
(unsigned int)(a2 % (v8 * a1[4]) % v8 % v7),
(unsigned int)(a2 % (v8 * a1[4]) % v8 / v7),
a2 % (v8 * a1[4]) / v8,
a2 / (v8 * a1[4]),
*(double *)&_XMM0);
return _RAX;
}
__asm { vmovaps xmm0, [rsp+28h+var_28] }
v5 = *(_DWORD *)a1;
if ( *(int *)a1 <= 15 )
{
if ( v5 )
{
if ( v5 != 1 )
goto LABEL_19;
if ( a1[6] != 2LL )
ggml_set_f32_1d_cold_2(*(double *)&_XMM0);
__asm { vcvtps2ph xmm0, xmm0, 0 }
_RAX = a1[35];
_RCX = a2;
__asm { vpextrw word ptr [rax+rcx*2], xmm0, 0 }
}
else
{
if ( a1[6] != 4LL )
ggml_set_f32_1d_cold_1(*(double *)&_XMM0);
_RAX = a1[35];
_RCX = a2;
__asm { vmovss dword ptr [rax+rcx*4], xmm0 }
}
}
else
{
switch ( v5 )
{
case 18:
if ( a1[6] != 4LL )
ggml_set_f32_1d_cold_3(*(double *)&_XMM0);
__asm { vcvttss2si eax, xmm0 }
*(_DWORD *)(a1[35] + 4LL * a2) = _RAX;
break;
case 17:
if ( a1[6] != 2LL )
ggml_set_f32_1d_cold_4(*(double *)&_XMM0);
__asm { vcvttss2si eax, xmm0 }
*(_WORD *)(a1[35] + 2LL * a2) = _RAX;
break;
case 16:
if ( a1[6] != 1LL )
ggml_set_f32_1d_cold_5(*(double *)&_XMM0);
__asm { vcvttss2si eax, xmm0 }
*(_BYTE *)(a1[35] + a2) = _RAX;
return _RAX;
default:
LABEL_19:
ggml_set_f32_1d_cold_6(*(double *)&_XMM0);
}
}
return _RAX;
}
| |||
26,037 | maria_rtree_set_key_mbr | eloqsql/storage/maria/ma_rt_key.c | int maria_rtree_set_key_mbr(MARIA_HA *info, MARIA_KEY *key,
my_off_t child_page)
{
MARIA_PAGE page;
DBUG_ENTER("maria_rtree_set_key_mbr");
if (_ma_fetch_keypage(&page, info, key->keyinfo, child_page,
PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, info->buff, 0))
DBUG_RETURN(-1);
DBUG_RETURN(maria_rtree_page_mbr(key->keyinfo->seg,
&page, key->data, key->data_length));
} | O0 | c | maria_rtree_set_key_mbr:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x378(%rax), %rax
leaq -0x58(%rbp), %rdi
xorl %r8d, %r8d
movl $0x3, %r9d
movq %rax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x9b100
cmpb $0x0, %al
je 0x7eddc
jmp 0x7edd3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7ee07
jmp 0x7edde
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
leaq -0x58(%rbp), %rsi
callq 0x86b20
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
| maria_rtree_set_key_mbr:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rsi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rdx, [rax+8]
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov rax, [rax+378h]
lea rdi, [rbp+var_58]
xor r8d, r8d
mov r9d, 3
mov [rsp+70h+var_70], rax
mov [rsp+70h+var_68], 0
call _ma_fetch_keypage
cmp al, 0
jz short loc_7EDDC
jmp short $+2
loc_7EDD3:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_7EE07
loc_7EDDC:
jmp short $+2
loc_7EDDE:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rdi, [rax+0C0h]
mov rax, [rbp+var_18]
mov rdx, [rax]
mov rax, [rbp+var_18]
mov ecx, [rax+10h]
lea rsi, [rbp+var_58]
call maria_rtree_page_mbr
mov [rbp+var_4], eax
loc_7EE07:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
| long long maria_rtree_set_key_mbr(long long a1, long long a2, long long a3)
{
_BYTE v4[56]; // [rsp+18h] [rbp-58h] BYREF
long long v5; // [rsp+50h] [rbp-20h]
long long v6; // [rsp+58h] [rbp-18h]
long long v7; // [rsp+60h] [rbp-10h]
v7 = a1;
v6 = a2;
v5 = a3;
if ( (unsigned __int8)ma_fetch_keypage((unsigned int)v4, a1, *(_QWORD *)(a2 + 8), a3, 0, 3, *(_QWORD *)(a1 + 888), 0) )
return (unsigned int)-1;
else
return (unsigned int)maria_rtree_page_mbr(
*(_QWORD *)(*(_QWORD *)(v6 + 8) + 192LL),
v4,
*(_QWORD *)v6,
*(unsigned int *)(v6 + 16));
}
| maria_rtree_set_key_mbr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RSI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x378]
LEA RDI,[RBP + -0x58]
XOR R8D,R8D
MOV R9D,0x3
MOV qword ptr [RSP],RAX
MOV dword ptr [RSP + 0x8],0x0
CALL 0x0019b100
CMP AL,0x0
JZ 0x0017eddc
JMP 0x0017edd3
LAB_0017edd3:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0017ee07
LAB_0017eddc:
JMP 0x0017edde
LAB_0017edde:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x10]
LEA RSI,[RBP + -0x58]
CALL 0x00186b20
MOV dword ptr [RBP + -0x4],EAX
LAB_0017ee07:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
int4 maria_rtree_set_key_mbr(long param_1,int8 *param_2,int8 param_3)
{
char cVar1;
int1 local_60 [56];
int8 local_28;
int8 *local_20;
long local_18;
int4 local_c;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
cVar1 = _ma_fetch_keypage(local_60,param_1,param_2[1],param_3,0,3,*(int8 *)(param_1 + 0x378)
,0);
if (cVar1 == '\0') {
local_c = maria_rtree_page_mbr
(*(int8 *)(local_20[1] + 0xc0),local_60,*local_20,
*(int4 *)(local_20 + 2));
}
else {
local_c = 0xffffffff;
}
return local_c;
}
| |
26,038 | google::protobuf::compiler::(anonymous namespace)::IsInstalledProtoPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/command_line_interface.cc | bool IsInstalledProtoPath(const std::string& path) {
// Checking the descriptor.proto file should be good enough.
std::string file_path = path + "/google/protobuf/descriptor.proto";
return access(file_path.c_str(), F_OK) != -1;
} | O3 | cpp | google::protobuf::compiler::(anonymous namespace)::IsInstalledProtoPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rax
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq (%rsi,%rdi), %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2586a
leaq 0x16f0c9(%rip), %rsi # 0x19cbf7
movq %rbx, %rdi
callq 0x1f8e0
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1f7e0
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2db53
callq 0x1f4a0
cmpl $-0x1, %ebx
setne %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2db73
callq 0x1f4a0
movq %rbx, %rdi
callq 0x1f860
| _ZN6google8protobuf8compiler12_GLOBAL__N_120IsInstalledProtoPathERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r14
push rbx
sub rsp, 28h
mov rax, rdi
lea r14, [rsp+38h+var_20]
mov [r14-10h], r14
lea rdx, [rsi+rdi]
lea rbx, [rsp+38h+var_30]
mov rdi, rbx
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rsi, unk_19CBF7
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rdi, [rsp+38h+var_30]
xor esi, esi
call _access
mov ebx, eax
mov rdi, [rsp+38h+var_30]; void *
cmp rdi, r14
jz short loc_2DB53
call __ZdlPv; operator delete(void *)
loc_2DB53:
cmp ebx, 0FFFFFFFFh
setnz al
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r14
jz short loc_2DB73
call __ZdlPv; operator delete(void *)
loc_2DB73:
mov rdi, rbx
call __Unwind_Resume
| bool google::protobuf::compiler::`anonymous namespace'::IsInstalledProtoPath(_BYTE *a1, long long a2)
{
int v2; // ebx
void *v4[2]; // [rsp+8h] [rbp-30h] BYREF
_BYTE v5[32]; // [rsp+18h] [rbp-20h] BYREF
v4[0] = v5;
std::string::_M_construct<char *>((long long)v4, a1, (long long)&a1[a2]);
std::string::append(v4, &unk_19CBF7);
v2 = access(v4[0], 0LL);
if ( v4[0] != v5 )
operator delete(v4[0]);
return v2 != -1;
}
| IsInstalledProtoPath:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RAX,RDI
LEA R14,[RSP + 0x18]
MOV qword ptr [R14 + -0x10],R14
LEA RDX,[RSI + RDI*0x1]
LEA RBX,[RSP + 0x8]
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0012586a
LAB_0012db27:
LEA RSI,[0x29cbf7]
MOV RDI,RBX
CALL 0x0011f8e0
LAB_0012db36:
MOV RDI,qword ptr [RSP + 0x8]
XOR ESI,ESI
CALL 0x0011f7e0
MOV EBX,EAX
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R14
JZ 0x0012db53
CALL 0x0011f4a0
LAB_0012db53:
CMP EBX,-0x1
SETNZ AL
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* google::protobuf::compiler::(anonymous namespace)::IsInstalledProtoPath(std::__cxx11::string
const&) */
bool __thiscall
google::protobuf::compiler::(anonymous_namespace)::IsInstalledProtoPath
(_anonymous_namespace_ *this,string *param_1)
{
int iVar1;
char *local_30 [2];
char local_20 [16];
local_30[0] = local_20;
std::__cxx11::string::_M_construct<char*>(local_30,this,param_1 + (long)this);
/* try { // try from 0012db27 to 0012db35 has its CatchHandler @ 0012db61 */
std::__cxx11::string::append((char *)local_30);
iVar1 = access(local_30[0],0);
if (local_30[0] != local_20) {
operator_delete(local_30[0]);
}
return iVar1 != -1;
}
| |
26,039 | init_state_maps | eloqsql/mysys/charset.c | static my_bool init_state_maps(struct charset_info_st *cs)
{
uint i;
uchar *state_map;
uchar *ident_map;
if (!(cs->state_map= state_map= (uchar*) my_once_alloc(256*2, MYF(MY_WME))))
return 1;
cs->ident_map= ident_map= state_map + 256;
/* Fill state_map with states to get a faster parser */
for (i=0; i < 256 ; i++)
{
if (my_isalpha(cs,i))
state_map[i]=(uchar) MY_LEX_IDENT;
else if (my_isdigit(cs,i))
state_map[i]=(uchar) MY_LEX_NUMBER_IDENT;
else if (is_multi_byte_ident(cs, i))
state_map[i]=(uchar) MY_LEX_IDENT;
else if (my_isspace(cs,i))
state_map[i]=(uchar) MY_LEX_SKIP;
else
state_map[i]=(uchar) MY_LEX_CHAR;
}
state_map[(uchar)'_']=state_map[(uchar)'$']=(uchar) MY_LEX_IDENT;
state_map[(uchar)'\'']=(uchar) MY_LEX_STRING;
state_map[(uchar)'.']=(uchar) MY_LEX_REAL_OR_POINT;
state_map[(uchar)'>']=state_map[(uchar)'=']=state_map[(uchar)'!']= (uchar) MY_LEX_CMP_OP;
state_map[(uchar)'<']= (uchar) MY_LEX_LONG_CMP_OP;
state_map[(uchar)'&']=state_map[(uchar)'|']=(uchar) MY_LEX_BOOL;
state_map[(uchar)'#']=(uchar) MY_LEX_COMMENT;
state_map[(uchar)';']=(uchar) MY_LEX_SEMICOLON;
state_map[(uchar)':']=(uchar) MY_LEX_SET_VAR;
state_map[0]=(uchar) MY_LEX_EOL;
state_map[(uchar)'\\']= (uchar) MY_LEX_ESCAPE;
state_map[(uchar)'/']= (uchar) MY_LEX_LONG_COMMENT;
state_map[(uchar)'*']= (uchar) MY_LEX_END_LONG_COMMENT;
state_map[(uchar)'@']= (uchar) MY_LEX_USER_END;
state_map[(uchar) '`']= (uchar) MY_LEX_USER_VARIABLE_DELIMITER;
state_map[(uchar)'"']= (uchar) MY_LEX_STRING_OR_DELIMITER;
state_map[(uchar)'-']= (uchar) MY_LEX_MINUS_OR_COMMENT;
state_map[(uchar)',']= (uchar) MY_LEX_COMMA;
state_map[(uchar)'?']= (uchar) MY_LEX_PLACEHOLDER;
/*
Create a second map to make it faster to find identifiers
*/
for (i=0; i < 256 ; i++)
{
ident_map[i]= (uchar) (state_map[i] == MY_LEX_IDENT ||
state_map[i] == MY_LEX_NUMBER_IDENT);
}
/* Special handling of hex and binary strings */
state_map[(uchar)'x']= state_map[(uchar)'X']= (uchar) MY_LEX_IDENT_OR_HEX;
state_map[(uchar)'b']= state_map[(uchar)'B']= (uchar) MY_LEX_IDENT_OR_BIN;
state_map[(uchar)'n']= state_map[(uchar)'N']= (uchar) MY_LEX_IDENT_OR_NCHAR;
return 0;
} | O3 | c | init_state_maps:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x200, %edi # imm = 0x200
movl $0x10, %esi
callq 0xa3078
movq %rax, 0x80(%r14)
testq %rax, %rax
je 0x96702
movq %rax, %rbx
movq %rax, %r13
addq $0x100, %r13 # imm = 0x100
movq %r13, 0x88(%r14)
xorl %r15d, %r15d
leaq -0x29(%rbp), %r12
movq 0x40(%r14), %rax
movzbl 0x1(%rax,%r15), %eax
testb $0x3, %al
je 0x9660e
movb $0x2, (%rbx,%r15)
jmp 0x9664d
testb $0x4, %al
jne 0x96648
movb %r15b, -0x29(%rbp)
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
leaq -0x28(%rbp), %rdx
callq *0xc0(%rax)
addl $0x64, %eax
cmpl $-0x6, %eax
jae 0x96607
movq 0x40(%r14), %rax
testb $0x8, 0x1(%rax,%r15)
jne 0x9665b
movb $0x1, (%rbx,%r15)
jmp 0x9664d
movb $0xe, (%rbx,%r15)
incq %r15
cmpq $0x100, %r15 # imm = 0x100
jne 0x965f9
jmp 0x96662
movb $0x1a, (%rbx,%r15)
jmp 0x9664d
movw $0x1b02, 0x5f(%rbx) # imm = 0x1B02
movb $0x8, 0x3e(%rbx)
movb $0x11, 0x7c(%rbx)
movw $0xa11, 0x26(%rbx) # imm = 0xA11
movl $0x8091617, 0x3a(%rbx) # imm = 0x8091617
movb $0x12, (%rbx)
movb $0x13, 0x5c(%rbx)
movb $0x15, 0x2a(%rbx)
movl $0x20b2108, 0x21(%rbx) # imm = 0x20B2108
movl $0x14102224, 0x2c(%rbx) # imm = 0x14102224
movw $0x1823, 0x3f(%rbx) # imm = 0x1823
movq $-0x100, %rax
movdqa 0x4c795(%rip), %xmm0 # 0xe2e40
movdqa 0x4c79d(%rip), %xmm1 # 0xe2e50
movdqa 0x4c7a5(%rip), %xmm2 # 0xe2e60
movdqu (%r13,%rax), %xmm3
movdqa %xmm3, %xmm4
pcmpeqb %xmm0, %xmm4
pcmpeqb %xmm1, %xmm3
por %xmm4, %xmm3
pand %xmm2, %xmm3
movdqu %xmm3, 0x100(%r13,%rax)
addq $0x10, %rax
jne 0x966bb
movb $0x1e, %al
movb %al, 0x58(%rbx)
movb %al, 0x78(%rbx)
movb $0x1f, %al
movb %al, 0x42(%rbx)
movb %al, 0x62(%rbx)
movb $0x20, %al
movb %al, 0x4e(%rbx)
movb %al, 0x6e(%rbx)
xorl %eax, %eax
jmp 0x96704
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| init_state_maps:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdi
mov edi, 200h
mov esi, 10h
call my_once_alloc
mov [r14+80h], rax
test rax, rax
jz loc_96702
mov rbx, rax
mov r13, rax
add r13, 100h
mov [r14+88h], r13
xor r15d, r15d
lea r12, [rbp+var_29]
loc_965F9:
mov rax, [r14+40h]
movzx eax, byte ptr [rax+r15+1]
test al, 3
jz short loc_9660E
loc_96607:
mov byte ptr [rbx+r15], 2
jmp short loc_9664D
loc_9660E:
test al, 4
jnz short loc_96648
mov [rbp+var_29], r15b
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, r12
lea rdx, [rbp+var_28]
call qword ptr [rax+0C0h]
add eax, 64h ; 'd'
cmp eax, 0FFFFFFFAh
jnb short loc_96607
mov rax, [r14+40h]
test byte ptr [rax+r15+1], 8
jnz short loc_9665B
mov byte ptr [rbx+r15], 1
jmp short loc_9664D
loc_96648:
mov byte ptr [rbx+r15], 0Eh
loc_9664D:
inc r15
cmp r15, 100h
jnz short loc_965F9
jmp short loc_96662
loc_9665B:
mov byte ptr [rbx+r15], 1Ah
jmp short loc_9664D
loc_96662:
mov word ptr [rbx+5Fh], 1B02h
mov byte ptr [rbx+3Eh], 8
mov byte ptr [rbx+7Ch], 11h
mov word ptr [rbx+26h], 0A11h
mov dword ptr [rbx+3Ah], 8091617h
mov byte ptr [rbx], 12h
mov byte ptr [rbx+5Ch], 13h
mov byte ptr [rbx+2Ah], 15h
mov dword ptr [rbx+21h], 20B2108h
mov dword ptr [rbx+2Ch], 14102224h
mov word ptr [rbx+3Fh], 1823h
mov rax, 0FFFFFFFFFFFFFF00h
movdqa xmm0, cs:xmmword_E2E40
movdqa xmm1, cs:xmmword_E2E50
movdqa xmm2, cs:xmmword_E2E60
loc_966BB:
movdqu xmm3, xmmword ptr [r13+rax+0]
movdqa xmm4, xmm3
pcmpeqb xmm4, xmm0
pcmpeqb xmm3, xmm1
por xmm3, xmm4
pand xmm3, xmm2
movdqu xmmword ptr [r13+rax+100h], xmm3
add rax, 10h
jnz short loc_966BB
mov al, 1Eh
mov [rbx+58h], al
mov [rbx+78h], al
mov al, 1Fh
mov [rbx+42h], al
mov [rbx+62h], al
mov al, 20h ; ' '
mov [rbx+4Eh], al
mov [rbx+6Eh], al
xor eax, eax
jmp short loc_96704
loc_96702:
mov al, 1
loc_96704:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long init_state_maps(_QWORD *a1)
{
long long v1; // rax
long long v2; // rax
long long v3; // rbx
long long v4; // r13
long long i; // r15
char v6; // al
long long v7; // rax
__m128i si128; // xmm0
__m128i v9; // xmm1
__m128i v10; // xmm2
__m128i v11; // xmm3
char v13; // [rsp+1h] [rbp-29h] BYREF
_BYTE v14[40]; // [rsp+2h] [rbp-28h] BYREF
v13 = HIBYTE(v1);
v2 = my_once_alloc(512LL, 16LL);
a1[16] = v2;
if ( !v2 )
return 1LL;
v3 = v2;
v4 = v2 + 256;
a1[17] = v2 + 256;
for ( i = 0LL; i != 256; ++i )
{
v6 = *(_BYTE *)(a1[8] + i + 1);
if ( (v6 & 3) != 0 )
{
LABEL_4:
*(_BYTE *)(v3 + i) = 2;
continue;
}
if ( (v6 & 4) != 0 )
{
*(_BYTE *)(v3 + i) = 14;
}
else
{
v13 = i;
if ( (*(unsigned int ( **)(_QWORD *, char *, _BYTE *))(a1[23] + 192LL))(a1, &v13, v14) + 100 >= 0xFFFFFFFA )
goto LABEL_4;
if ( (*(_BYTE *)(a1[8] + i + 1) & 8) != 0 )
*(_BYTE *)(v3 + i) = 26;
else
*(_BYTE *)(v3 + i) = 1;
}
}
*(_WORD *)(v3 + 95) = 6914;
*(_BYTE *)(v3 + 62) = 8;
*(_BYTE *)(v3 + 124) = 17;
*(_WORD *)(v3 + 38) = 2577;
*(_DWORD *)(v3 + 58) = 134813207;
*(_BYTE *)v3 = 18;
*(_BYTE *)(v3 + 92) = 19;
*(_BYTE *)(v3 + 42) = 21;
*(_DWORD *)(v3 + 33) = 34283784;
*(_DWORD *)(v3 + 44) = 336601636;
*(_WORD *)(v3 + 63) = 6179;
v7 = -256LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_E2E40);
v9 = _mm_load_si128((const __m128i *)&xmmword_E2E50);
v10 = _mm_load_si128((const __m128i *)&xmmword_E2E60);
do
{
v11 = _mm_loadu_si128((const __m128i *)(v4 + v7));
*(__m128i *)(v4 + v7 + 256) = _mm_and_si128(_mm_or_si128(_mm_cmpeq_epi8(v11, v9), _mm_cmpeq_epi8(v11, si128)), v10);
v7 += 16LL;
}
while ( v7 );
*(_BYTE *)(v3 + 88) = 30;
*(_BYTE *)(v3 + 120) = 30;
*(_BYTE *)(v3 + 66) = 31;
*(_BYTE *)(v3 + 98) = 31;
*(_BYTE *)(v3 + 78) = 32;
*(_BYTE *)(v3 + 110) = 32;
return 0LL;
}
| init_state_maps:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV EDI,0x200
MOV ESI,0x10
CALL 0x001a3078
MOV qword ptr [R14 + 0x80],RAX
TEST RAX,RAX
JZ 0x00196702
MOV RBX,RAX
MOV R13,RAX
ADD R13,0x100
MOV qword ptr [R14 + 0x88],R13
XOR R15D,R15D
LEA R12,[RBP + -0x29]
LAB_001965f9:
MOV RAX,qword ptr [R14 + 0x40]
MOVZX EAX,byte ptr [RAX + R15*0x1 + 0x1]
TEST AL,0x3
JZ 0x0019660e
LAB_00196607:
MOV byte ptr [RBX + R15*0x1],0x2
JMP 0x0019664d
LAB_0019660e:
TEST AL,0x4
JNZ 0x00196648
MOV byte ptr [RBP + -0x29],R15B
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,R12
LEA RDX,[RBP + -0x28]
CALL qword ptr [RAX + 0xc0]
ADD EAX,0x64
CMP EAX,-0x6
JNC 0x00196607
MOV RAX,qword ptr [R14 + 0x40]
TEST byte ptr [RAX + R15*0x1 + 0x1],0x8
JNZ 0x0019665b
MOV byte ptr [RBX + R15*0x1],0x1
JMP 0x0019664d
LAB_00196648:
MOV byte ptr [RBX + R15*0x1],0xe
LAB_0019664d:
INC R15
CMP R15,0x100
JNZ 0x001965f9
JMP 0x00196662
LAB_0019665b:
MOV byte ptr [RBX + R15*0x1],0x1a
JMP 0x0019664d
LAB_00196662:
MOV word ptr [RBX + 0x5f],0x1b02
MOV byte ptr [RBX + 0x3e],0x8
MOV byte ptr [RBX + 0x7c],0x11
MOV word ptr [RBX + 0x26],0xa11
MOV dword ptr [RBX + 0x3a],0x8091617
MOV byte ptr [RBX],0x12
MOV byte ptr [RBX + 0x5c],0x13
MOV byte ptr [RBX + 0x2a],0x15
MOV dword ptr [RBX + 0x21],0x20b2108
MOV dword ptr [RBX + 0x2c],0x14102224
MOV word ptr [RBX + 0x3f],0x1823
MOV RAX,-0x100
MOVDQA XMM0,xmmword ptr [0x001e2e40]
MOVDQA XMM1,xmmword ptr [0x001e2e50]
MOVDQA XMM2,xmmword ptr [0x001e2e60]
LAB_001966bb:
MOVDQU XMM3,xmmword ptr [R13 + RAX*0x1]
MOVDQA XMM4,XMM3
PCMPEQB XMM4,XMM0
PCMPEQB XMM3,XMM1
POR XMM3,XMM4
PAND XMM3,XMM2
MOVDQU xmmword ptr [R13 + RAX*0x1 + 0x100],XMM3
ADD RAX,0x10
JNZ 0x001966bb
MOV AL,0x1e
MOV byte ptr [RBX + 0x58],AL
MOV byte ptr [RBX + 0x78],AL
MOV AL,0x1f
MOV byte ptr [RBX + 0x42],AL
MOV byte ptr [RBX + 0x62],AL
MOV AL,0x20
MOV byte ptr [RBX + 0x4e],AL
MOV byte ptr [RBX + 0x6e],AL
XOR EAX,EAX
JMP 0x00196704
LAB_00196702:
MOV AL,0x1
LAB_00196704:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 init_state_maps(long param_1)
{
char *pcVar1;
byte *pbVar2;
byte bVar3;
char cVar4;
char cVar5;
char cVar6;
char cVar7;
char cVar8;
char cVar9;
char cVar10;
char cVar11;
char cVar12;
char cVar13;
char cVar14;
char cVar15;
char cVar16;
char cVar17;
char cVar18;
char cVar19;
char cVar20;
char cVar21;
char cVar22;
char cVar23;
char cVar24;
char cVar25;
char cVar26;
char cVar27;
char cVar28;
char cVar29;
char cVar30;
char cVar31;
char cVar32;
char cVar33;
char cVar34;
char cVar35;
char cVar36;
char cVar37;
char cVar38;
char cVar39;
char cVar40;
char cVar41;
char cVar42;
char cVar43;
char cVar44;
char cVar45;
char cVar46;
char cVar47;
char cVar48;
char cVar49;
char cVar50;
byte bVar51;
byte bVar52;
byte bVar53;
byte bVar54;
byte bVar55;
byte bVar56;
byte bVar57;
byte bVar58;
byte bVar59;
byte bVar60;
byte bVar61;
byte bVar62;
byte bVar63;
byte bVar64;
byte bVar65;
int iVar66;
int8 in_RAX;
int1 *puVar67;
int8 uVar68;
long lVar69;
int8 uStack_38;
uStack_38 = in_RAX;
puVar67 = (int1 *)my_once_alloc(0x200,0x10);
*(int1 **)(param_1 + 0x80) = puVar67;
if (puVar67 == (int1 *)0x0) {
uVar68 = 1;
}
else {
*(int1 **)(param_1 + 0x88) = puVar67 + 0x100;
lVar69 = 0;
do {
bVar3 = *(byte *)(*(long *)(param_1 + 0x40) + 1 + lVar69);
if ((bVar3 & 3) == 0) {
if ((bVar3 & 4) == 0) {
uStack_38 = CONCAT17((char)lVar69,(int7)uStack_38);
iVar66 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,(long)&uStack_38 + 7,&stack0xffffffffffffffd0);
if (0xfffffff9 < iVar66 + 100U) goto LAB_00196607;
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + lVar69) & 8) == 0) {
puVar67[lVar69] = 1;
}
else {
puVar67[lVar69] = 0x1a;
}
}
else {
puVar67[lVar69] = 0xe;
}
}
else {
LAB_00196607:
puVar67[lVar69] = 2;
}
lVar69 = lVar69 + 1;
} while (lVar69 != 0x100);
*(int2 *)(puVar67 + 0x5f) = 0x1b02;
puVar67[0x3e] = 8;
puVar67[0x7c] = 0x11;
*(int2 *)(puVar67 + 0x26) = 0xa11;
*(int4 *)(puVar67 + 0x3a) = 0x8091617;
*puVar67 = 0x12;
puVar67[0x5c] = 0x13;
puVar67[0x2a] = 0x15;
*(int4 *)(puVar67 + 0x21) = 0x20b2108;
*(int4 *)(puVar67 + 0x2c) = 0x14102224;
*(int2 *)(puVar67 + 0x3f) = 0x1823;
bVar65 = UNK_001e2e6f;
bVar64 = UNK_001e2e6e;
bVar63 = UNK_001e2e6d;
bVar62 = UNK_001e2e6c;
bVar61 = UNK_001e2e6b;
bVar60 = UNK_001e2e6a;
bVar59 = UNK_001e2e69;
bVar58 = UNK_001e2e68;
bVar57 = UNK_001e2e67;
bVar56 = UNK_001e2e66;
bVar55 = UNK_001e2e65;
bVar54 = UNK_001e2e64;
bVar53 = UNK_001e2e63;
bVar52 = UNK_001e2e62;
bVar51 = UNK_001e2e61;
bVar3 = DAT_001e2e60;
cVar50 = UNK_001e2e5f;
cVar49 = UNK_001e2e5e;
cVar48 = UNK_001e2e5d;
cVar47 = UNK_001e2e5c;
cVar46 = UNK_001e2e5b;
cVar45 = UNK_001e2e5a;
cVar44 = UNK_001e2e59;
cVar43 = UNK_001e2e58;
cVar42 = UNK_001e2e57;
cVar41 = UNK_001e2e56;
cVar40 = UNK_001e2e55;
cVar39 = UNK_001e2e54;
cVar38 = UNK_001e2e53;
cVar37 = UNK_001e2e52;
cVar36 = UNK_001e2e51;
cVar35 = DAT_001e2e50;
cVar34 = UNK_001e2e4f;
cVar33 = UNK_001e2e4e;
cVar32 = UNK_001e2e4d;
cVar31 = UNK_001e2e4c;
cVar30 = UNK_001e2e4b;
cVar29 = UNK_001e2e4a;
cVar28 = UNK_001e2e49;
cVar27 = UNK_001e2e48;
cVar26 = UNK_001e2e47;
cVar25 = UNK_001e2e46;
cVar24 = UNK_001e2e45;
cVar23 = UNK_001e2e44;
cVar22 = UNK_001e2e43;
cVar21 = UNK_001e2e42;
cVar20 = UNK_001e2e41;
cVar19 = DAT_001e2e40;
lVar69 = -0x100;
do {
pcVar1 = puVar67 + 0x100 + lVar69;
cVar4 = pcVar1[1];
cVar5 = pcVar1[2];
cVar6 = pcVar1[3];
cVar7 = pcVar1[4];
cVar8 = pcVar1[5];
cVar9 = pcVar1[6];
cVar10 = pcVar1[7];
cVar11 = pcVar1[8];
cVar12 = pcVar1[9];
cVar13 = pcVar1[10];
cVar14 = pcVar1[0xb];
cVar15 = pcVar1[0xc];
cVar16 = pcVar1[0xd];
cVar17 = pcVar1[0xe];
cVar18 = pcVar1[0xf];
pbVar2 = puVar67 + lVar69 + 0x200;
*pbVar2 = (-(*pcVar1 == cVar35) | -(*pcVar1 == cVar19)) & bVar3;
pbVar2[1] = (-(cVar4 == cVar36) | -(cVar4 == cVar20)) & bVar51;
pbVar2[2] = (-(cVar5 == cVar37) | -(cVar5 == cVar21)) & bVar52;
pbVar2[3] = (-(cVar6 == cVar38) | -(cVar6 == cVar22)) & bVar53;
pbVar2[4] = (-(cVar7 == cVar39) | -(cVar7 == cVar23)) & bVar54;
pbVar2[5] = (-(cVar8 == cVar40) | -(cVar8 == cVar24)) & bVar55;
pbVar2[6] = (-(cVar9 == cVar41) | -(cVar9 == cVar25)) & bVar56;
pbVar2[7] = (-(cVar10 == cVar42) | -(cVar10 == cVar26)) & bVar57;
pbVar2[8] = (-(cVar11 == cVar43) | -(cVar11 == cVar27)) & bVar58;
pbVar2[9] = (-(cVar12 == cVar44) | -(cVar12 == cVar28)) & bVar59;
pbVar2[10] = (-(cVar13 == cVar45) | -(cVar13 == cVar29)) & bVar60;
pbVar2[0xb] = (-(cVar14 == cVar46) | -(cVar14 == cVar30)) & bVar61;
pbVar2[0xc] = (-(cVar15 == cVar47) | -(cVar15 == cVar31)) & bVar62;
pbVar2[0xd] = (-(cVar16 == cVar48) | -(cVar16 == cVar32)) & bVar63;
pbVar2[0xe] = (-(cVar17 == cVar49) | -(cVar17 == cVar33)) & bVar64;
pbVar2[0xf] = (-(cVar18 == cVar50) | -(cVar18 == cVar34)) & bVar65;
lVar69 = lVar69 + 0x10;
} while (lVar69 != 0);
puVar67[0x58] = 0x1e;
puVar67[0x78] = 0x1e;
puVar67[0x42] = 0x1f;
puVar67[0x62] = 0x1f;
puVar67[0x4e] = 0x20;
puVar67[0x6e] = 0x20;
uVar68 = 0;
}
return uVar68;
}
| |
26,040 | my_scan_mb2 | eloqsql/strings/ctype-ucs2.c | static size_t
my_scan_mb2(CHARSET_INFO *cs __attribute__((unused)),
const char *str, const char *end, int sequence_type)
{
const char *str0= str;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
int res;
switch (sequence_type)
{
case MY_SEQ_SPACES:
for (res= mb_wc(cs, &wc, (const uchar *) str, (const uchar *) end);
res > 0 && wc == ' ';
str+= res,
res= mb_wc(cs, &wc, (const uchar *) str, (const uchar *) end))
{
}
return (size_t) (str - str0);
case MY_SEQ_NONSPACES:
DBUG_ASSERT(0); /* Not implemented */
/* pass through */
default:
return 0;
}
} | O0 | c | my_scan_mb2:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x48(%rbp)
subl $0x2, %eax
je 0x640f9
jmp 0x640ef
movl -0x48(%rbp), %eax
subl $0x3, %eax
je 0x64170
jmp 0x64176
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x44(%rbp)
movb %al, -0x49(%rbp)
jle 0x64128
cmpq $0x20, -0x38(%rbp)
sete %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x64131
jmp 0x6415f
jmp 0x64133
movl -0x44(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
jmp 0x64112
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x6417e
jmp 0x64172
jmp 0x64174
jmp 0x64176
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_scan_mb2:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov [rbp+var_40], rax
mov eax, [rbp+var_24]
mov [rbp+var_48], eax
sub eax, 2
jz short loc_640F9
jmp short $+2
loc_640EF:
mov eax, [rbp+var_48]
sub eax, 3
jz short loc_64170
jmp short loc_64176
loc_640F9:
mov rax, [rbp+var_40]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
lea rsi, [rbp+var_38]
call rax
mov [rbp+var_44], eax
loc_64112:
xor eax, eax
cmp [rbp+var_44], 0
mov [rbp+var_49], al
jle short loc_64128
cmp [rbp+var_38], 20h ; ' '
setz al
mov [rbp+var_49], al
loc_64128:
mov al, [rbp+var_49]
test al, 1
jnz short loc_64131
jmp short loc_6415F
loc_64131:
jmp short $+2
loc_64133:
mov ecx, [rbp+var_44]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_40]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
lea rsi, [rbp+var_38]
call rax
mov [rbp+var_44], eax
jmp short loc_64112
loc_6415F:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_6417E
loc_64170:
jmp short $+2
loc_64172:
jmp short $+2
loc_64174:
jmp short $+2
loc_64176:
mov [rbp+var_8], 0
loc_6417E:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long my_scan_mb2(long long a1, long long a2, long long a3, int a4)
{
bool v5; // [rsp+7h] [rbp-49h]
int i; // [rsp+Ch] [rbp-44h]
long long ( *v7)(long long, long long *, long long, long long); // [rsp+10h] [rbp-40h]
long long v8; // [rsp+18h] [rbp-38h] BYREF
long long v9; // [rsp+20h] [rbp-30h]
int v10; // [rsp+2Ch] [rbp-24h]
long long v11; // [rsp+30h] [rbp-20h]
long long v12; // [rsp+38h] [rbp-18h]
long long v13; // [rsp+40h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a2;
v7 = *(long long ( **)(long long, long long *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
if ( a4 != 2 )
return 0LL;
for ( i = v7(v13, &v8, v12, v11); ; i = v7(v13, &v8, v12, v11) )
{
v5 = 0;
if ( i > 0 )
v5 = v8 == 32;
if ( !v5 )
break;
v12 += i;
}
return v12 - v9;
}
| my_scan_mb2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x48],EAX
SUB EAX,0x2
JZ 0x001640f9
JMP 0x001640ef
LAB_001640ef:
MOV EAX,dword ptr [RBP + -0x48]
SUB EAX,0x3
JZ 0x00164170
JMP 0x00164176
LAB_001640f9:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x38]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
LAB_00164112:
XOR EAX,EAX
CMP dword ptr [RBP + -0x44],0x0
MOV byte ptr [RBP + -0x49],AL
JLE 0x00164128
CMP qword ptr [RBP + -0x38],0x20
SETZ AL
MOV byte ptr [RBP + -0x49],AL
LAB_00164128:
MOV AL,byte ptr [RBP + -0x49]
TEST AL,0x1
JNZ 0x00164131
JMP 0x0016415f
LAB_00164131:
JMP 0x00164133
LAB_00164133:
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x38]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
JMP 0x00164112
LAB_0016415f:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016417e
LAB_00164170:
JMP 0x00164172
LAB_00164172:
JMP 0x00164174
LAB_00164174:
JMP 0x00164176
LAB_00164176:
MOV qword ptr [RBP + -0x8],0x0
LAB_0016417e:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
long my_scan_mb2(long param_1,long param_2,int8 param_3,int param_4)
{
code *pcVar1;
int local_4c;
long local_40;
long local_38;
int local_2c;
int8 local_28;
long local_20;
long local_18;
long local_10;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
if (param_4 == 2) {
local_38 = param_2;
local_2c = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_4c = (*pcVar1)(param_1,&local_40,param_2,param_3);
while (0 < local_4c && local_40 == 0x20) {
local_20 = local_20 + local_4c;
local_4c = (*pcVar1)(local_18,&local_40,local_20,local_28);
}
local_10 = local_20 - local_38;
}
else {
local_10 = 0;
}
return local_10;
}
| |
26,041 | ma_ft_cmp | eloqsql/storage/maria/ma_ft_update.c | int _ma_ft_cmp(MARIA_HA *info, uint keynr, const uchar *rec1, const uchar *rec2)
{
FT_SEG_ITERATOR ftsi1, ftsi2;
CHARSET_INFO *cs=info->s->keyinfo[keynr].seg->charset;
DBUG_ENTER("_ma_ft_cmp");
_ma_ft_segiterator_init(info, keynr, rec1, &ftsi1);
_ma_ft_segiterator_init(info, keynr, rec2, &ftsi2);
while (_ma_ft_segiterator(&ftsi1) && _ma_ft_segiterator(&ftsi2))
{
if ((ftsi1.pos != ftsi2.pos) &&
(!ftsi1.pos || !ftsi2.pos ||
ha_compare_text(cs, ftsi1.pos,ftsi1.len,
ftsi2.pos,ftsi2.len,0)))
DBUG_RETURN(THOSE_TWO_DAMN_KEYS_ARE_REALLY_DIFFERENT);
}
DBUG_RETURN(GEE_THEY_ARE_ABSOLUTELY_IDENTICAL);
} | O3 | c | ma_ft_cmp:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq (%rdi), %rax
movq 0x570(%rax), %rax
movl %esi, %esi
imulq $0x118, %rsi, %rsi # imm = 0x118
movq 0xc0(%rax,%rsi), %r8
movq (%r8), %rbx
movzwl 0xa0(%rax,%rsi), %eax
leaq -0x60(%rbp), %rdi
movl %eax, (%rdi)
movq %r8, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
xorl %r14d, %r14d
movq %r14, 0x18(%rdi)
movl %r14d, 0x4(%rdi)
movl %eax, -0x40(%rbp)
movq %r8, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
movq %r14, -0x28(%rbp)
movl %r14d, -0x3c(%rbp)
callq 0x5fb87
testl %eax, %eax
je 0x5fe72
leaq -0x40(%rbp), %r15
leaq -0x60(%rbp), %r12
movq %r15, %rdi
callq 0x5fb87
testl %eax, %eax
je 0x5fe6f
movq -0x48(%rbp), %rsi
movq -0x28(%rbp), %rcx
cmpq %rcx, %rsi
je 0x5fe63
movl $0x1, %r14d
testq %rsi, %rsi
je 0x5fe72
testq %rcx, %rcx
je 0x5fe72
movl -0x5c(%rbp), %edx
movl -0x3c(%rbp), %r8d
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x9e8ec
testl %eax, %eax
jne 0x5fe72
movq %r12, %rdi
callq 0x5fb87
testl %eax, %eax
jne 0x5fe24
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _ma_ft_cmp:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov rax, [rdi]
mov rax, [rax+570h]
mov esi, esi
imul rsi, 118h
mov r8, [rax+rsi+0C0h]
mov rbx, [r8]
movzx eax, word ptr [rax+rsi+0A0h]
lea rdi, [rbp+var_60]
mov [rdi], eax
mov [rdi+8], r8
mov [rdi+10h], rdx
xor r14d, r14d
mov [rdi+18h], r14
mov [rdi+4], r14d
mov [rbp+var_40], eax
mov [rbp+var_38], r8
mov [rbp+var_30], rcx
mov [rbp+var_28], r14
mov [rbp+var_3C], r14d
call _ma_ft_segiterator
test eax, eax
jz short loc_5FE72
lea r15, [rbp+var_40]
lea r12, [rbp+var_60]
loc_5FE24:
mov rdi, r15
call _ma_ft_segiterator
test eax, eax
jz short loc_5FE6F
mov rsi, [rbp+var_48]
mov rcx, [rbp+var_28]
cmp rsi, rcx
jz short loc_5FE63
mov r14d, 1
test rsi, rsi
jz short loc_5FE72
test rcx, rcx
jz short loc_5FE72
mov edx, [rbp+var_5C]
mov r8d, [rbp+var_3C]
mov rdi, rbx
xor r9d, r9d
call ha_compare_text
test eax, eax
jnz short loc_5FE72
loc_5FE63:
mov rdi, r12
call _ma_ft_segiterator
test eax, eax
jnz short loc_5FE24
loc_5FE6F:
xor r14d, r14d
loc_5FE72:
mov eax, r14d
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long ma_ft_cmp(long long a1, unsigned int a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // rsi
_QWORD *v6; // r8
long long v7; // rbx
unsigned int v8; // r14d
int v10; // [rsp+0h] [rbp-60h] BYREF
unsigned int v11; // [rsp+4h] [rbp-5Ch]
_QWORD *v12; // [rsp+8h] [rbp-58h]
long long v13; // [rsp+10h] [rbp-50h]
long long v14; // [rsp+18h] [rbp-48h]
int v15; // [rsp+20h] [rbp-40h] BYREF
unsigned int v16; // [rsp+24h] [rbp-3Ch]
_QWORD *v17; // [rsp+28h] [rbp-38h]
long long v18; // [rsp+30h] [rbp-30h]
long long v19; // [rsp+38h] [rbp-28h]
v4 = *(_QWORD *)(*(_QWORD *)a1 + 1392LL);
v5 = 280LL * a2;
v6 = *(_QWORD **)(v4 + v5 + 192);
v7 = *v6;
v10 = *(unsigned __int16 *)(v4 + v5 + 160);
v12 = v6;
v13 = a3;
v8 = 0;
v14 = 0LL;
v11 = 0;
v15 = v10;
v17 = v6;
v18 = a4;
v19 = 0LL;
v16 = 0;
if ( (unsigned int)ma_ft_segiterator((long long)&v10) )
{
do
{
if ( !(unsigned int)ma_ft_segiterator((long long)&v15) )
break;
if ( v14 != v19 )
{
v8 = 1;
if ( !v14 || !v19 || (unsigned int)ha_compare_text(v7, v14, v11, v19, v16, 0LL) )
return v8;
}
}
while ( (unsigned int)ma_ft_segiterator((long long)&v10) );
return 0;
}
return v8;
}
| _ma_ft_cmp:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x570]
MOV ESI,ESI
IMUL RSI,RSI,0x118
MOV R8,qword ptr [RAX + RSI*0x1 + 0xc0]
MOV RBX,qword ptr [R8]
MOVZX EAX,word ptr [RAX + RSI*0x1 + 0xa0]
LEA RDI,[RBP + -0x60]
MOV dword ptr [RDI],EAX
MOV qword ptr [RDI + 0x8],R8
MOV qword ptr [RDI + 0x10],RDX
XOR R14D,R14D
MOV qword ptr [RDI + 0x18],R14
MOV dword ptr [RDI + 0x4],R14D
MOV dword ptr [RBP + -0x40],EAX
MOV qword ptr [RBP + -0x38],R8
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x28],R14
MOV dword ptr [RBP + -0x3c],R14D
CALL 0x0015fb87
TEST EAX,EAX
JZ 0x0015fe72
LEA R15,[RBP + -0x40]
LEA R12,[RBP + -0x60]
LAB_0015fe24:
MOV RDI,R15
CALL 0x0015fb87
TEST EAX,EAX
JZ 0x0015fe6f
MOV RSI,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x28]
CMP RSI,RCX
JZ 0x0015fe63
MOV R14D,0x1
TEST RSI,RSI
JZ 0x0015fe72
TEST RCX,RCX
JZ 0x0015fe72
MOV EDX,dword ptr [RBP + -0x5c]
MOV R8D,dword ptr [RBP + -0x3c]
MOV RDI,RBX
XOR R9D,R9D
CALL 0x0019e8ec
TEST EAX,EAX
JNZ 0x0015fe72
LAB_0015fe63:
MOV RDI,R12
CALL 0x0015fb87
TEST EAX,EAX
JNZ 0x0015fe24
LAB_0015fe6f:
XOR R14D,R14D
LAB_0015fe72:
MOV EAX,R14D
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 _ma_ft_cmp(long *param_1,uint param_2,int8 param_3,int8 param_4)
{
int8 uVar1;
int iVar2;
uint local_68;
int4 local_64;
int8 *local_60;
int8 local_58;
long local_50;
uint local_48;
int4 local_44;
int8 *local_40;
int8 local_38;
long local_30;
local_60 = *(int8 **)(*(long *)(*param_1 + 0x570) + 0xc0 + (ulong)param_2 * 0x118);
uVar1 = *local_60;
local_68 = (uint)*(ushort *)(*(long *)(*param_1 + 0x570) + 0xa0 + (ulong)param_2 * 0x118);
local_50 = 0;
local_64 = 0;
local_30 = 0;
local_44 = 0;
local_58 = param_3;
local_48 = local_68;
local_40 = local_60;
local_38 = param_4;
iVar2 = _ma_ft_segiterator();
if (iVar2 != 0) {
do {
iVar2 = _ma_ft_segiterator(&local_48);
if (iVar2 == 0) {
return 0;
}
if (local_50 != local_30) {
if (local_50 == 0) {
return 1;
}
if (local_30 == 0) {
return 1;
}
iVar2 = ha_compare_text(uVar1,local_50,local_64,local_30,local_44,0);
if (iVar2 != 0) {
return 1;
}
}
iVar2 = _ma_ft_segiterator(&local_68);
} while (iVar2 != 0);
}
return 0;
}
| |
26,042 | get_segment_footer | seiftnesse[P]memoryallocator/src/custom_alloc_util.c | uint32_t *get_segment_footer(segment_t *s) {
if (!s) return 0;
// Calculate the end of the segment's memory block
uintptr_t segment_end = (uintptr_t) (s) + (s->size * BLOCK_SIZE);
// Check for reasonable segment size
if (s->size <= 0 || s->size > MAX_REASONABLE_BLOCKS) {
HEAP_LOG("WARNING: Cannot get footer - segment %p has unreasonable size: %d\n", s, s->size);
return 0;
}
// Subtract the size of the guard value and return the pointer
uintptr_t footer_addr = segment_end - sizeof(uint32_t);
// Check that the footer is within the segment bounds
uintptr_t segment_start = (uintptr_t) (s);
if (footer_addr <= segment_start || footer_addr >= segment_end) {
HEAP_LOG("WARNING: Footer address %p is outside segment bounds [%p-%p]\n",
(void*)footer_addr, s, (void*)segment_end);
return 0;
}
HEAP_LOG("Footer guard address for segment %p: %p\n", s, (void*)footer_addr);
return (uint32_t *) (footer_addr);
} | O0 | c | get_segment_footer:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4259
movq $0x0, -0x8(%rbp)
jmp 0x42cc
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
shll $0xc, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jle 0x4288
movq -0x10(%rbp), %rax
cmpl $0x4000, 0x4(%rax) # imm = 0x4000
jle 0x4292
movq $0x0, -0x8(%rbp)
jmp 0x42cc
movq -0x18(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x42ba
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x42c4
movq $0x0, -0x8(%rbp)
jmp 0x42cc
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| get_segment_footer:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
cmp [rbp+var_10], 0
jnz short loc_4259
mov [rbp+var_8], 0
jmp short loc_42CC
loc_4259:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_10]
mov ecx, [rcx+4]
shl ecx, 0Ch
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jle short loc_4288
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 4000h
jle short loc_4292
loc_4288:
mov [rbp+var_8], 0
jmp short loc_42CC
loc_4292:
mov rax, [rbp+var_18]
sub rax, 4
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jbe short loc_42BA
mov rax, [rbp+var_20]
cmp rax, [rbp+var_18]
jb short loc_42C4
loc_42BA:
mov [rbp+var_8], 0
jmp short loc_42CC
loc_42C4:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_42CC:
mov rax, [rbp+var_8]
pop rbp
retn
| unsigned long long get_segment_footer(unsigned long long a1)
{
unsigned long long v2; // [rsp+10h] [rbp-18h]
if ( !a1 )
return 0LL;
v2 = (int)(*(_DWORD *)(a1 + 4) << 12) + a1;
if ( *(int *)(a1 + 4) <= 0 || *(int *)(a1 + 4) > 0x4000 )
return 0LL;
if ( v2 - 4 > a1 && v2 - 4 < v2 )
return v2 - 4;
return 0LL;
}
| get_segment_footer:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x00104259
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001042cc
LAB_00104259:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x4]
SHL ECX,0xc
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JLE 0x00104288
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x4000
JLE 0x00104292
LAB_00104288:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001042cc
LAB_00104292:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x4
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001042ba
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x18]
JC 0x001042c4
LAB_001042ba:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001042cc
LAB_001042c4:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_001042cc:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
ulong get_segment_footer(ulong param_1)
{
ulong uVar1;
int8 local_10;
if (param_1 == 0) {
local_10 = 0;
}
else {
uVar1 = param_1 + (long)(*(int *)(param_1 + 4) << 0xc);
if ((*(int *)(param_1 + 4) < 1) || (0x4000 < *(int *)(param_1 + 4))) {
local_10 = 0;
}
else {
local_10 = uVar1 - 4;
if ((local_10 <= param_1) || (uVar1 <= local_10)) {
local_10 = 0;
}
}
}
return local_10;
}
| |
26,043 | native_password_auth_client | eloqsql/libmariadb/plugins/auth/my_auth.c | static int native_password_auth_client(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql)
{
int pkt_len;
uchar *pkt;
if (((MCPVIO_EXT *)vio)->mysql_change_user)
{
/*
in mysql_change_user() the client sends the first packet.
we use the old scramble.
*/
pkt= (uchar*)mysql->scramble_buff;
pkt_len= SCRAMBLE_LENGTH + 1;
}
else
{
/* read the scramble */
if ((pkt_len= vio->read_packet(vio, &pkt)) < 0)
return CR_ERROR;
if (pkt_len != SCRAMBLE_LENGTH + 1)
return CR_SERVER_HANDSHAKE_ERR;
/* save it in MYSQL */
memmove(mysql->scramble_buff, pkt, SCRAMBLE_LENGTH);
mysql->scramble_buff[SCRAMBLE_LENGTH] = 0;
}
if (mysql && mysql->passwd[0])
{
char scrambled[SCRAMBLE_LENGTH + 1];
memset(scrambled, 0, SCRAMBLE_LENGTH + 1);
ma_scramble_41((uchar *)scrambled, (char*)pkt, mysql->passwd);
if (vio->write_packet(vio, (uchar*)scrambled, SCRAMBLE_LENGTH))
return CR_ERROR;
}
else
if (vio->write_packet(vio, 0, 0)) /* no password */
return CR_ERROR;
return CR_OK;
} | O3 | c | native_password_auth_client:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
cmpb $0x0, 0x48(%rdi)
je 0x307a0
leaq 0x48e(%r14), %rax
movq %rax, -0x48(%rbp)
testq %r14, %r14
jne 0x307d9
jmp 0x3081b
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq *(%rbx)
testl %eax, %eax
js 0x30816
movl $0x7dc, %r15d # imm = 0x7DC
cmpl $0x15, %eax
jne 0x30832
movq -0x48(%rbp), %rax
movups (%rax), %xmm0
movl 0x10(%rax), %eax
movl %eax, 0x49e(%r14)
movups %xmm0, 0x48e(%r14)
movb $0x0, 0x4a2(%r14)
movq 0x2c0(%r14), %rdx
cmpb $0x0, (%rdx)
je 0x3081b
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0xd(%r14)
movq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x353b6
movq %rbx, %rdi
movq %r14, %rsi
movl $0x14, %edx
callq *0x8(%rbx)
testl %eax, %eax
je 0x3082c
xorl %r15d, %r15d
jmp 0x30832
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *0x8(%rbx)
testl %eax, %eax
jne 0x30832
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x3084f
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| native_password_auth_client:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 38h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
cmp byte ptr [rdi+48h], 0
jz short loc_307A0
lea rax, [r14+48Eh]
mov [rbp+var_48], rax
test r14, r14
jnz short loc_307D9
jmp short loc_3081B
loc_307A0:
lea rsi, [rbp+var_48]
mov rdi, rbx
call qword ptr [rbx]
test eax, eax
js short loc_30816
mov r15d, 7DCh
cmp eax, 15h
jnz short loc_30832
mov rax, [rbp+var_48]
movups xmm0, xmmword ptr [rax]
mov eax, [rax+10h]
mov [r14+49Eh], eax
movups xmmword ptr [r14+48Eh], xmm0
mov byte ptr [r14+4A2h], 0
loc_307D9:
mov rdx, [r14+2C0h]
cmp byte ptr [rdx], 0
jz short loc_3081B
xorps xmm0, xmm0
lea r14, [rbp+var_40]
movaps xmmword ptr [r14], xmm0
mov qword ptr [r14+0Dh], 0
mov rsi, [rbp+var_48]
mov rdi, r14
call ma_scramble_41
mov rdi, rbx
mov rsi, r14
mov edx, 14h
call qword ptr [rbx+8]
test eax, eax
jz short loc_3082C
loc_30816:
xor r15d, r15d
jmp short loc_30832
loc_3081B:
xor r15d, r15d
mov rdi, rbx
xor esi, esi
xor edx, edx
call qword ptr [rbx+8]
test eax, eax
jnz short loc_30832
loc_3082C:
mov r15d, 0FFFFFFFFh
loc_30832:
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_3084F
mov eax, r15d
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_3084F:
call ___stack_chk_fail
| long long native_password_auth_client(long long a1, long long a2)
{
int v2; // eax
unsigned int v3; // r15d
__int128 v4; // xmm0
__int128 *v6; // [rsp+8h] [rbp-48h] BYREF
_BYTE v7[32]; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v8; // [rsp+30h] [rbp-20h]
v8 = __readfsqword(0x28u);
if ( !*(_BYTE *)(a1 + 72) )
{
v2 = (*(long long ( **)(long long, __int128 **))a1)(a1, &v6);
if ( v2 < 0 )
return 0;
v3 = 2012;
if ( v2 != 21 )
return v3;
v4 = *v6;
*(_DWORD *)(a2 + 1182) = *((_DWORD *)v6 + 4);
*(_OWORD *)(a2 + 1166) = v4;
*(_BYTE *)(a2 + 1186) = 0;
LABEL_7:
if ( !**(_BYTE **)(a2 + 704) )
goto LABEL_10;
memset(v7, 0, 21);
ma_scramble_41(v7, v6);
if ( !(*(unsigned int ( **)(long long, _BYTE *, long long))(a1 + 8))(a1, v7, 20LL) )
return (unsigned int)-1;
return 0;
}
v6 = (__int128 *)(a2 + 1166);
if ( a2 )
goto LABEL_7;
LABEL_10:
v3 = 0;
if ( !(*(unsigned int ( **)(long long, _QWORD, _QWORD))(a1 + 8))(a1, 0LL, 0LL) )
return (unsigned int)-1;
return v3;
}
| native_password_auth_client:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
CMP byte ptr [RDI + 0x48],0x0
JZ 0x001307a0
LEA RAX,[R14 + 0x48e]
MOV qword ptr [RBP + -0x48],RAX
TEST R14,R14
JNZ 0x001307d9
JMP 0x0013081b
LAB_001307a0:
LEA RSI,[RBP + -0x48]
MOV RDI,RBX
CALL qword ptr [RBX]
TEST EAX,EAX
JS 0x00130816
MOV R15D,0x7dc
CMP EAX,0x15
JNZ 0x00130832
MOV RAX,qword ptr [RBP + -0x48]
MOVUPS XMM0,xmmword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [R14 + 0x49e],EAX
MOVUPS xmmword ptr [R14 + 0x48e],XMM0
MOV byte ptr [R14 + 0x4a2],0x0
LAB_001307d9:
MOV RDX,qword ptr [R14 + 0x2c0]
CMP byte ptr [RDX],0x0
JZ 0x0013081b
XORPS XMM0,XMM0
LEA R14,[RBP + -0x40]
MOVAPS xmmword ptr [R14],XMM0
MOV qword ptr [R14 + 0xd],0x0
MOV RSI,qword ptr [RBP + -0x48]
MOV RDI,R14
CALL 0x001353b6
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x14
CALL qword ptr [RBX + 0x8]
TEST EAX,EAX
JZ 0x0013082c
LAB_00130816:
XOR R15D,R15D
JMP 0x00130832
LAB_0013081b:
XOR R15D,R15D
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL qword ptr [RBX + 0x8]
TEST EAX,EAX
JNZ 0x00130832
LAB_0013082c:
MOV R15D,0xffffffff
LAB_00130832:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0013084f
MOV EAX,R15D
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0013084f:
CALL 0x00113500
|
int8 native_password_auth_client(int8 *param_1,long param_2)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int iVar5;
int8 uVar6;
long in_FS_OFFSET;
int4 *local_50;
int8 local_48;
int5 uStack_40;
int3 uStack_3b;
int5 uStack_38;
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
if (*(char *)(param_1 + 9) == '\0') {
iVar5 = (*(code *)*param_1)(param_1,&local_50);
if (-1 < iVar5) {
uVar6 = 0x7dc;
if (iVar5 != 0x15) goto LAB_00130832;
uVar1 = *local_50;
uVar2 = local_50[1];
uVar3 = local_50[2];
uVar4 = local_50[3];
*(int4 *)(param_2 + 0x49e) = local_50[4];
*(int4 *)(param_2 + 0x48e) = uVar1;
*(int4 *)(param_2 + 0x492) = uVar2;
*(int4 *)(param_2 + 0x496) = uVar3;
*(int4 *)(param_2 + 0x49a) = uVar4;
*(int1 *)(param_2 + 0x4a2) = 0;
goto LAB_001307d9;
}
LAB_00130816:
uVar6 = 0;
goto LAB_00130832;
}
local_50 = (int4 *)(param_2 + 0x48e);
if (param_2 == 0) {
LAB_0013081b:
uVar6 = 0;
iVar5 = (*(code *)param_1[1])(param_1,0,0);
if (iVar5 != 0) goto LAB_00130832;
}
else {
LAB_001307d9:
if (**(char **)(param_2 + 0x2c0) == '\0') goto LAB_0013081b;
local_48 = 0;
uStack_40 = 0;
uStack_3b = 0;
uStack_38 = 0;
ma_scramble_41(&local_48,local_50);
iVar5 = (*(code *)param_1[1])(param_1,&local_48,0x14);
if (iVar5 != 0) goto LAB_00130816;
}
uVar6 = 0xffffffff;
LAB_00130832:
if (*(long *)(in_FS_OFFSET + 0x28) != local_28) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar6;
}
| |
26,044 | 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;
} | O0 | c | my_dirend:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7fdf2
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x69400
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7c010
movq -0x10(%rbp), %rdi
callq 0x80a40
jmp 0x7fdf4
jmp 0x7fdf6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| my_dirend:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jz short loc_7FDF2
mov rdi, [rbp+var_10]
add rdi, 10h
call delete_dynamic
mov rdi, [rbp+var_10]
add rdi, 38h ; '8'
xor eax, eax
mov esi, eax
call free_root
mov rdi, [rbp+var_10]
call my_free
loc_7FDF2:
jmp short $+2
loc_7FDF4:
jmp short $+2
loc_7FDF6:
add rsp, 10h
pop rbp
retn
| long long my_dirend(long long a1)
{
long long result; // rax
result = a1;
if ( a1 )
{
delete_dynamic(a1 + 16);
free_root(a1 + 56, 0);
return my_free(a1);
}
return result;
}
| my_dirend:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0017fdf2
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10
CALL 0x00169400
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x38
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0017c010
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00180a40
LAB_0017fdf2:
JMP 0x0017fdf4
LAB_0017fdf4:
JMP 0x0017fdf6
LAB_0017fdf6:
ADD RSP,0x10
POP RBP
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;
}
| |
26,045 | minja::Value::operator*(minja::Value const&) const | llama.cpp/common/minja/minja.hpp | Value operator*(const Value& rhs) const {
if (is_string() && rhs.is_number_integer()) {
std::ostringstream out;
for (int64_t i = 0, n = rhs.get<int64_t>(); i < n; ++i) {
out << to_str();
}
return out.str();
}
else if (is_number_integer() && rhs.is_number_integer())
return get<int64_t>() * rhs.get<int64_t>();
else
return get<double>() * rhs.get<double>();
} | O3 | cpp | minja::Value::operator*(minja::Value const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movb 0x40(%rsi), %al
cmpb $0x3, %al
jne 0xa3375
movb 0x40(%r15), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0xa33cc
leaq 0x30(%rsp), %rdi
callq 0x1cb40
movq %r15, %rdi
callq 0x790b6
movq %rax, %r15
testq %rax, %rax
jle 0xa331b
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r12
leaq 0x30(%rsp), %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0x7e39c
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r13, %rdi
callq 0x1cb70
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xa3316
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c110
decq %r15
jne 0xa32e2
leaq 0x38(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1c470
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x729ee
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa3352
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c110
movq 0x5cc07(%rip), %rsi # 0xfff60
leaq 0x30(%rsp), %rdi
callq 0x1c8e0
leaq 0xa0(%rsp), %rdi
callq 0x1c8c0
jmp 0xa3417
addb $-0x5, %al
cmpb $0x1, %al
ja 0xa33cc
movb 0x40(%r15), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0xa33cc
movq %r14, %rdi
callq 0x790b6
movq %rax, %r14
movq %r15, %rdi
callq 0x790b6
imulq %rax, %r14
leaq 0x40(%rbx), %r15
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movupd %xmm0, 0x10(%rbx)
movupd %xmm0, 0x20(%rbx)
movupd %xmm0, 0x30(%rbx)
movupd %xmm0, 0x40(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x32192
movq %r15, %rdi
jmp 0xa340d
movq %r14, %rdi
callq 0x75d7c
movsd %xmm0, 0x28(%rsp)
movq %r15, %rdi
callq 0x75d7c
mulsd 0x28(%rsp), %xmm0
leaq 0x40(%rbx), %r14
xorps %xmm1, %xmm1
movups %xmm1, (%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm1, 0x20(%rbx)
movups %xmm1, 0x30(%rbx)
movups %xmm1, 0x40(%rbx)
movq %r14, %rdi
callq 0x31aea
movq %r14, %rdi
movl $0x1, %esi
callq 0x732fc
movq %rbx, %rax
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xa3455
jmp 0xa3462
jmp 0xa3443
jmp 0xa3443
movq %rax, %rbx
jmp 0xa3462
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xa3462
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c110
movq 0x5caf7(%rip), %rsi # 0xfff60
leaq 0x30(%rsp), %rdi
callq 0x1c8e0
leaq 0xa0(%rsp), %rdi
callq 0x1c8c0
movq %rbx, %rdi
callq 0x1c7d0
| _ZNK5minja5ValuemlERKS0_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1A8h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov al, [rsi+40h]
cmp al, 3
jnz loc_A3375
mov al, [r15+40h]
add al, 0FBh
cmp al, 1
ja loc_A33CC
lea rdi, [rsp+1D8h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rdi, r15
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov r15, rax
test rax, rax
jle short loc_A331B
lea rbp, [rsp+1D8h+var_1C0]
lea r12, [rsp+1D8h+var_1D0]
lea r13, [rsp+1D8h+var_1A8]
loc_A32E2:
mov rdi, r12
mov rsi, r14
call _ZNK5minja5Value6to_strB5cxx11Ev; minja::Value::to_str(void)
mov rsi, [rsp+1D8h+var_1D0]
mov rdx, [rsp+1D8h+var_1C8]
mov rdi, r13
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+1D8h+var_1D0]; void *
cmp rdi, rbp
jz short loc_A3316
mov rsi, [rsp+1D8h+var_1C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A3316:
dec r15
jnz short loc_A32E2
loc_A331B:
lea rsi, [rsp+1D8h+var_1A0]
lea rdi, [rsp+1D8h+var_1D0]
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
lea rsi, [rsp+1D8h+var_1D0]
mov rdi, rbx
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
lea rax, [rsp+1D8h+var_1C0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A3352
mov rsi, [rsp+1D8h+var_1C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A3352:
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1D8h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+1D8h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
jmp loc_A3417
loc_A3375:
add al, 0FBh
cmp al, 1
ja short loc_A33CC
mov al, [r15+40h]
add al, 0FBh
cmp al, 1
ja short loc_A33CC
mov rdi, r14
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov r14, rax
mov rdi, r15
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
imul r14, rax
lea r15, [rbx+40h]
xorpd xmm0, xmm0
movupd xmmword ptr [rbx], xmm0
movupd xmmword ptr [rbx+10h], xmm0
movupd xmmword ptr [rbx+20h], xmm0
movupd xmmword ptr [rbx+30h], xmm0
movupd xmmword ptr [rbx+40h], xmm0
mov rdi, r15
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE5EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_16number_integer_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_integer_t)
mov rdi, r15
jmp short loc_A340D
loc_A33CC:
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+1D8h+var_1B0], xmm0
mov rdi, r15
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
mulsd xmm0, [rsp+1D8h+var_1B0]
lea r14, [rbx+40h]
xorps xmm1, xmm1
movups xmmword ptr [rbx], xmm1
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx+20h], xmm1
movups xmmword ptr [rbx+30h], xmm1
movups xmmword ptr [rbx+40h], xmm1
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE7EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_14number_float_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_float_t)
mov rdi, r14
loc_A340D:
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_A3417:
mov rax, rbx
add rsp, 1A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]
cmp rdi, rax
jnz short loc_A3455
jmp short loc_A3462
jmp short loc_A3443
jmp short $+2
loc_A3443:
mov rbx, rax
jmp short loc_A3462
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, rbp
jz short loc_A3462
loc_A3455:
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A3462:
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_28]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+arg_98]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| long long minja::Value::operator*(long long a1, long long a2, long long a3)
{
char v5; // al
long long v6; // r15
long long v7; // r14
long long v8; // rax
char *v9; // rdi
double v10; // xmm0_8
void *v12[2]; // [rsp+8h] [rbp-1D0h] BYREF
_QWORD v13[2]; // [rsp+18h] [rbp-1C0h] BYREF
double v14; // [rsp+28h] [rbp-1B0h]
_BYTE v15[8]; // [rsp+30h] [rbp-1A8h] BYREF
_BYTE v16[104]; // [rsp+38h] [rbp-1A0h] BYREF
_BYTE v17[312]; // [rsp+A0h] [rbp-138h] BYREF
v5 = *(_BYTE *)(a2 + 64);
if ( v5 != 3 )
{
if ( (unsigned __int8)(v5 - 5) <= 1u && (unsigned __int8)(*(_BYTE *)(a3 + 64) - 5) <= 1u )
{
v7 = minja::Value::get<long>((_QWORD *)a2);
v8 = minja::Value::get<long>((_QWORD *)a3);
*(_OWORD *)a1 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(unsigned __int8 *)(a1 + 64),
v8 * v7);
v9 = (char *)(a1 + 64);
LABEL_14:
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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(v9);
return a1;
}
LABEL_13:
v14 = minja::Value::get<double>((_QWORD *)a2);
v10 = minja::Value::get<double>((_QWORD *)a3) * v14;
*(_OWORD *)a1 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(unsigned __int8 *)(a1 + 64),
v10);
v9 = (char *)(a1 + 64);
goto LABEL_14;
}
if ( (unsigned __int8)(*(_BYTE *)(a3 + 64) - 5) > 1u )
goto LABEL_13;
std::ostringstream::basic_ostringstream(v15);
v6 = minja::Value::get<long>((_QWORD *)a3);
if ( v6 > 0 )
{
do
{
minja::Value::to_str[abi:cxx11](v12, a2);
std::__ostream_insert<char,std::char_traits<char>>(v15, v12[0], v12[1]);
if ( v12[0] != v13 )
operator delete(v12[0], v13[0] + 1LL);
--v6;
}
while ( v6 );
}
std::stringbuf::str(v12, v16);
minja::Value::Value((_OWORD *)a1);
if ( v12[0] != v13 )
operator delete(v12[0], v13[0] + 1LL);
std::ostringstream::~ostringstream(v15, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v17);
return a1;
}
| operator*:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1a8
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV AL,byte ptr [RSI + 0x40]
CMP AL,0x3
JNZ 0x001a3375
MOV AL,byte ptr [R15 + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x001a33cc
LEA RDI,[RSP + 0x30]
CALL 0x0011cb40
LAB_001a32c3:
MOV RDI,R15
CALL 0x001790b6
MOV R15,RAX
TEST RAX,RAX
JLE 0x001a331b
LEA RBP,[RSP + 0x18]
LEA R12,[RSP + 0x8]
LEA R13,[RSP + 0x30]
LAB_001a32e2:
MOV RDI,R12
MOV RSI,R14
CALL 0x0017e39c
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_001a32f7:
MOV RDI,R13
CALL 0x0011cb70
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,RBP
JZ 0x001a3316
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011c110
LAB_001a3316:
DEC R15
JNZ 0x001a32e2
LAB_001a331b:
LEA RSI,[RSP + 0x38]
LAB_001a3320:
LEA RDI,[RSP + 0x8]
CALL 0x0011c470
LAB_001a332a:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x001729ee
LAB_001a3337:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001a3352
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011c110
LAB_001a3352:
MOV RSI,qword ptr [0x001fff60]
LEA RDI,[RSP + 0x30]
CALL 0x0011c8e0
LEA RDI,[RSP + 0xa0]
CALL 0x0011c8c0
JMP 0x001a3417
LAB_001a3375:
ADD AL,0xfb
CMP AL,0x1
JA 0x001a33cc
MOV AL,byte ptr [R15 + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x001a33cc
MOV RDI,R14
CALL 0x001790b6
MOV R14,RAX
MOV RDI,R15
CALL 0x001790b6
IMUL R14,RAX
LEA R15,[RBX + 0x40]
XORPD XMM0,XMM0
MOVUPD xmmword ptr [RBX],XMM0
MOVUPD xmmword ptr [RBX + 0x10],XMM0
MOVUPD xmmword ptr [RBX + 0x20],XMM0
MOVUPD xmmword ptr [RBX + 0x30],XMM0
MOVUPD xmmword ptr [RBX + 0x40],XMM0
MOV RDI,R15
MOV RSI,R14
CALL 0x00132192
MOV RDI,R15
JMP 0x001a340d
LAB_001a33cc:
MOV RDI,R14
CALL 0x00175d7c
MOVSD qword ptr [RSP + 0x28],XMM0
MOV RDI,R15
CALL 0x00175d7c
MULSD XMM0,qword ptr [RSP + 0x28]
LEA R14,[RBX + 0x40]
XORPS XMM1,XMM1
MOVUPS xmmword ptr [RBX],XMM1
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX + 0x20],XMM1
MOVUPS xmmword ptr [RBX + 0x30],XMM1
MOVUPS xmmword ptr [RBX + 0x40],XMM1
MOV RDI,R14
CALL 0x00131aea
MOV RDI,R14
LAB_001a340d:
MOV ESI,0x1
CALL 0x001732fc
LAB_001a3417:
MOV RAX,RBX
ADD RSP,0x1a8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
Value * __thiscall minja::Value::operator*(Value *this,Value *param_1)
{
long lVar1;
long lVar2;
Value *in_RDX;
double dVar3;
long *local_1d0;
long local_1c8;
long local_1c0 [2];
double local_1b0;
ostringstream local_1a8 [112];
ios_base local_138 [264];
if (param_1[0x40] == (Value)0x3) {
if ((byte)((char)in_RDX[0x40] - 5U) < 2) {
std::__cxx11::ostringstream::ostringstream(local_1a8);
/* try { // try from 001a32c3 to 001a32ca has its CatchHandler @ 001a3441 */
lVar1 = get<long>(in_RDX);
if (0 < lVar1) {
do {
/* try { // try from 001a32e2 to 001a32ec has its CatchHandler @ 001a3443 */
to_str_abi_cxx11_();
/* try { // try from 001a32f7 to 001a32fe has its CatchHandler @ 001a3448 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_1a8,(char *)local_1d0,local_1c8);
if (local_1d0 != local_1c0) {
operator_delete(local_1d0,local_1c0[0] + 1);
}
lVar1 = lVar1 + -1;
} while (lVar1 != 0);
}
/* try { // try from 001a3320 to 001a3329 has its CatchHandler @ 001a343f */
std::__cxx11::stringbuf::str();
/* try { // try from 001a332a to 001a3336 has its CatchHandler @ 001a342c */
Value(this,(string *)&local_1d0);
if (local_1d0 != local_1c0) {
operator_delete(local_1d0,local_1c0[0] + 1);
}
std::__cxx11::ostringstream::~ostringstream(local_1a8);
std::ios_base::~ios_base(local_138);
return this;
}
}
else if (((byte)((char)param_1[0x40] - 5U) < 2) && ((byte)((char)in_RDX[0x40] - 5U) < 2)) {
lVar1 = get<long>(param_1);
lVar2 = get<long>(in_RDX);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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 + 0x40,lVar1 * lVar2);
goto LAB_001a340d;
}
local_1b0 = get<double>(param_1);
dVar3 = get<double>(in_RDX);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(dVar3 * local_1b0,this + 0x40);
LAB_001a340d:
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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((bool)((char)this + '@'));
return this;
}
| |
26,046 | 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>>>>>::get() | monkey531[P]llama/common/./json.hpp | char_int_type get()
{
++position.chars_read_total;
++position.chars_read_current_line;
if (next_unget)
{
// just reset the next_unget variable and work with current
next_unget = false;
}
else
{
current = ia.get_character();
}
if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
{
token_string.push_back(char_traits<char_type>::to_char_type(current));
}
if (current == '\n')
{
++position.lines_read;
position.chars_read_current_line = 0;
}
return current;
} | O2 | 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>>>>>::get():
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movdqu 0x20(%rdi), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x20(%rdi)
cmpb $0x1, 0x18(%rdi)
jne 0x417ed
movb $0x0, 0x18(%rbx)
movl 0x14(%rbx), %eax
jmp 0x41802
movq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
je 0x41835
movzbl (%rcx), %eax
incq %rcx
movq %rcx, (%rbx)
movl %eax, 0x14(%rbx)
cmpl $-0x1, %eax
je 0x41831
leaq 0x38(%rbx), %rdi
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
callq 0x375c8
movl 0x14(%rbx), %eax
cmpl $0xa, %eax
jne 0x4182b
incq 0x30(%rbx)
andq $0x0, 0x28(%rbx)
pushq $0xa
popq %rax
addq $0x10, %rsp
popq %rbx
retq
pushq $-0x1
jmp 0x4182a
pushq $-0x1
popq %rax
jmp 0x417ff
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv:
push rbx
sub rsp, 10h
mov rbx, rdi
movdqu xmm0, xmmword ptr [rdi+20h]
pcmpeqd xmm1, xmm1
psubq xmm0, xmm1
movdqu xmmword ptr [rdi+20h], xmm0
cmp byte ptr [rdi+18h], 1
jnz short loc_417ED
mov byte ptr [rbx+18h], 0
mov eax, [rbx+14h]
jmp short loc_41802
loc_417ED:
mov rcx, [rbx]
cmp rcx, [rbx+8]
jz short loc_41835
movzx eax, byte ptr [rcx]
inc rcx
mov [rbx], rcx
loc_417FF:
mov [rbx+14h], eax
loc_41802:
cmp eax, 0FFFFFFFFh
jz short loc_41831
lea rdi, [rbx+38h]
lea rsi, [rsp+18h+var_9]
mov [rsi], al
call _ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
mov eax, [rbx+14h]
cmp eax, 0Ah
jnz short loc_4182B
inc qword ptr [rbx+30h]
and qword ptr [rbx+28h], 0
push 0Ah
loc_4182A:
pop rax
loc_4182B:
add rsp, 10h
pop rbx
retn
loc_41831:
push 0FFFFFFFFFFFFFFFFh
jmp short loc_4182A
loc_41835:
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_417FF
| 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>>>::get(
__m128i *a1)
{
int v1; // eax
unsigned __int8 *v2; // rcx
long long result; // rax
_BYTE v5[9]; // [rsp+Fh] [rbp-9h] BYREF
a1[2] = _mm_sub_epi64(_mm_loadu_si128(a1 + 2), (__m128i)-1LL);
if ( a1[1].m128i_i8[8] == 1 )
{
a1[1].m128i_i8[8] = 0;
v1 = a1[1].m128i_i32[1];
}
else
{
v2 = (unsigned __int8 *)a1->m128i_i64[0];
if ( a1->m128i_i64[0] == a1->m128i_i64[1] )
{
v1 = -1;
}
else
{
v1 = *v2;
a1->m128i_i64[0] = (long long)(v2 + 1);
}
a1[1].m128i_i32[1] = v1;
}
if ( v1 == -1 )
return -1LL;
v5[0] = v1;
std::vector<char>::emplace_back<char>((long long)&a1[3].m128i_i64[1], v5);
result = a1[1].m128i_u32[1];
if ( (_DWORD)result != 10 )
return result;
++a1[3].m128i_i64[0];
a1[2].m128i_i64[1] = 0LL;
return 10LL;
}
| |||
26,047 | 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>>>>>::get() | monkey531[P]llama/common/./json.hpp | char_int_type get()
{
++position.chars_read_total;
++position.chars_read_current_line;
if (next_unget)
{
// just reset the next_unget variable and work with current
next_unget = false;
}
else
{
current = ia.get_character();
}
if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
{
token_string.push_back(char_traits<char_type>::to_char_type(current));
}
if (current == '\n')
{
++position.lines_read;
position.chars_read_current_line = 0;
}
return current;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::get():
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movdqu 0x20(%rdi), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x20(%rdi)
cmpb $0x1, 0x18(%rdi)
jne 0x18d6b
movb $0x0, 0x18(%rbx)
movl 0x14(%rbx), %eax
jmp 0x18d80
movq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
je 0x18db3
movzbl (%rcx), %eax
incq %rcx
movq %rcx, (%rbx)
movl %eax, 0x14(%rbx)
cmpl $-0x1, %eax
je 0x18daf
leaq 0x38(%rbx), %rdi
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
callq 0x392b4
movl 0x14(%rbx), %eax
cmpl $0xa, %eax
jne 0x18da9
incq 0x30(%rbx)
andq $0x0, 0x28(%rbx)
pushq $0xa
popq %rax
addq $0x10, %rsp
popq %rbx
retq
pushq $-0x1
jmp 0x18da8
pushq $-0x1
popq %rax
jmp 0x18d7d
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv:
push rbx
sub rsp, 10h
mov rbx, rdi
movdqu xmm0, xmmword ptr [rdi+20h]
pcmpeqd xmm1, xmm1
psubq xmm0, xmm1
movdqu xmmword ptr [rdi+20h], xmm0
cmp byte ptr [rdi+18h], 1
jnz short loc_18D6B
mov byte ptr [rbx+18h], 0
mov eax, [rbx+14h]
jmp short loc_18D80
loc_18D6B:
mov rcx, [rbx]
cmp rcx, [rbx+8]
jz short loc_18DB3
movzx eax, byte ptr [rcx]
inc rcx
mov [rbx], rcx
loc_18D7D:
mov [rbx+14h], eax
loc_18D80:
cmp eax, 0FFFFFFFFh
jz short loc_18DAF
lea rdi, [rbx+38h]
lea rsi, [rsp+18h+var_9]
mov [rsi], al
call _ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
mov eax, [rbx+14h]
cmp eax, 0Ah
jnz short loc_18DA9
inc qword ptr [rbx+30h]
and qword ptr [rbx+28h], 0
push 0Ah
loc_18DA8:
pop rax
loc_18DA9:
add rsp, 10h
pop rbx
retn
loc_18DAF:
push 0FFFFFFFFFFFFFFFFh
jmp short loc_18DA8
loc_18DB3:
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_18D7D
| 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>>>::get(
__m128i *a1)
{
int v1; // eax
unsigned __int8 *v2; // rcx
long long result; // rax
a1[2] = _mm_sub_epi64(_mm_loadu_si128(a1 + 2), (__m128i)-1LL);
if ( a1[1].m128i_i8[8] == 1 )
{
a1[1].m128i_i8[8] = 0;
v1 = a1[1].m128i_i32[1];
}
else
{
v2 = (unsigned __int8 *)a1->m128i_i64[0];
if ( a1->m128i_i64[0] == a1->m128i_i64[1] )
{
v1 = -1;
}
else
{
v1 = *v2;
a1->m128i_i64[0] = (long long)(v2 + 1);
}
a1[1].m128i_i32[1] = v1;
}
if ( v1 == -1 )
return -1LL;
std::vector<char>::emplace_back<char>(&a1[3].m128i_u64[1]);
result = a1[1].m128i_u32[1];
if ( (_DWORD)result != 10 )
return result;
++a1[3].m128i_i64[0];
a1[2].m128i_i64[1] = 0LL;
return 10LL;
}
| get:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOVDQU XMM0,xmmword ptr [RDI + 0x20]
PCMPEQD XMM1,XMM1
PSUBQ XMM0,XMM1
MOVDQU xmmword ptr [RDI + 0x20],XMM0
CMP byte ptr [RDI + 0x18],0x1
JNZ 0x00118d6b
MOV byte ptr [RBX + 0x18],0x0
MOV EAX,dword ptr [RBX + 0x14]
JMP 0x00118d80
LAB_00118d6b:
MOV RCX,qword ptr [RBX]
CMP RCX,qword ptr [RBX + 0x8]
JZ 0x00118db3
MOVZX EAX,byte ptr [RCX]
INC RCX
MOV qword ptr [RBX],RCX
LAB_00118d7d:
MOV dword ptr [RBX + 0x14],EAX
LAB_00118d80:
CMP EAX,-0x1
JZ 0x00118daf
LEA RDI,[RBX + 0x38]
LEA RSI,[RSP + 0xf]
MOV byte ptr [RSI],AL
CALL 0x001392b4
MOV EAX,dword ptr [RBX + 0x14]
CMP EAX,0xa
JNZ 0x00118da9
INC qword ptr [RBX + 0x30]
AND qword ptr [RBX + 0x28],0x0
PUSH 0xa
LAB_00118da8:
POP RAX
LAB_00118da9:
ADD RSP,0x10
POP RBX
RET
LAB_00118daf:
PUSH -0x1
JMP 0x00118da8
LAB_00118db3:
PUSH -0x1
POP RAX
JMP 0x00118d7d
|
/* 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 > > >::get() */
ulong __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>>>
::get(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)
{
byte *pbVar1;
uint uVar2;
ulong uStack_20;
char local_9;
*(long *)(this + 0x20) = *(long *)(this + 0x20) + 1;
*(long *)(this + 0x28) = *(long *)(this + 0x28) + 1;
if (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>>>
)0x1) {
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;
uVar2 = *(uint *)(this + 0x14);
}
else {
pbVar1 = *(byte **)this;
if (pbVar1 == *(byte **)(this + 8)) {
uVar2 = 0xffffffff;
}
else {
uVar2 = (uint)*pbVar1;
*(byte **)this = pbVar1 + 1;
}
*(uint *)(this + 0x14) = uVar2;
}
if (uVar2 == 0xffffffff) {
uStack_20 = 0xffffffffffffffff;
}
else {
local_9 = (char)uVar2;
std::vector<char,std::allocator<char>>::emplace_back<char>
((vector<char,std::allocator<char>> *)(this + 0x38),&local_9);
uStack_20 = (ulong)*(uint *)(this + 0x14);
if (*(uint *)(this + 0x14) == 10) {
*(long *)(this + 0x30) = *(long *)(this + 0x30) + 1;
*(int8 *)(this + 0x28) = 0;
uStack_20 = 10;
}
}
return uStack_20;
}
| |
26,048 | set_setup_actor_key(PFS_setup_actor_key*, char const*, unsigned int, char const*, unsigned int, char const*, unsigned int) | eloqsql/storage/perfschema/pfs_setup_actor.cc | static void set_setup_actor_key(PFS_setup_actor_key *key,
const char *user, uint user_length,
const char *host, uint host_length,
const char *role, uint role_length)
{
assert(user_length <= USERNAME_LENGTH);
assert(host_length <= HOSTNAME_LENGTH);
char *ptr= &key->m_hash_key[0];
memcpy(ptr, user, user_length);
ptr+= user_length;
ptr[0]= 0;
ptr++;
memcpy(ptr, host, host_length);
ptr+= host_length;
ptr[0]= 0;
ptr++;
memcpy(ptr, role, role_length);
ptr+= role_length;
ptr[0]= 0;
ptr++;
key->m_key_length= (uint)(ptr - &key->m_hash_key[0]);
} | O0 | cpp | set_setup_actor_key(PFS_setup_actor_key*, char const*, unsigned int, char const*, unsigned int, char const*, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x26280
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x26280
movl -0x24(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl 0x10(%rbp), %eax
movl %eax, %edx
callq 0x26280
movl 0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c4(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL19set_setup_actor_keyP19PFS_setup_actor_keyPKcjS2_jS2_j:
push rbp
mov rbp, rsp
sub rsp, 40h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
call _memcpy
mov ecx, [rbp+var_14]
mov rax, [rbp+var_38]
mov ecx, ecx
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_20]
mov eax, [rbp+var_24]
mov edx, eax
call _memcpy
mov ecx, [rbp+var_24]
mov rax, [rbp+var_38]
mov ecx, ecx
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_30]
mov eax, [rbp+arg_0]
mov edx, eax
call _memcpy
mov ecx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov ecx, ecx
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov rcx, [rbp+var_8]
sub rax, rcx
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+2C4h], ecx
add rsp, 40h
pop rbp
retn
| long long set_setup_actor_key(
long long a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
long long a6,
unsigned int a7)
{
long long result; // rax
_BYTE *v8; // [rsp+8h] [rbp-38h]
_BYTE *v9; // [rsp+8h] [rbp-38h]
_BYTE *v10; // [rsp+8h] [rbp-38h]
memcpy(a1, a2, a3);
v8 = (_BYTE *)(a3 + a1);
*v8++ = 0;
memcpy(v8, a4, a5);
v9 = &v8[a5];
*v9++ = 0;
memcpy(v9, a6, a7);
v10 = &v9[a7];
*v10 = 0;
result = a1;
*(_DWORD *)(a1 + 708) = (_DWORD)v10 + 1 - a1;
return result;
}
| set_setup_actor_key:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
CALL 0x00126280
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
CALL 0x00126280
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + 0x10]
MOV EDX,EAX
CALL 0x00126280
MOV ECX,dword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x8]
SUB RAX,RCX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2c4],ECX
ADD RSP,0x40
POP RBP
RET
|
/* set_setup_actor_key(PFS_setup_actor_key*, char const*, unsigned int, char const*, unsigned int,
char const*, unsigned int) */
void set_setup_actor_key(PFS_setup_actor_key *param_1,char *param_2,uint param_3,char *param_4,
uint param_5,char *param_6,uint param_7)
{
PFS_setup_actor_key *pPVar1;
memcpy(param_1,param_2,(ulong)param_3);
pPVar1 = param_1 + param_3;
*pPVar1 = (PFS_setup_actor_key)0x0;
pPVar1 = pPVar1 + 1;
memcpy(pPVar1,param_4,(ulong)param_5);
pPVar1 = pPVar1 + param_5;
*pPVar1 = (PFS_setup_actor_key)0x0;
pPVar1 = pPVar1 + 1;
memcpy(pPVar1,param_6,(ulong)param_7);
pPVar1[param_7] = (PFS_setup_actor_key)0x0;
*(int *)(param_1 + 0x2c4) = ((int)(pPVar1 + param_7) + 1) - (int)param_1;
return;
}
| |
26,049 | remove_end_comment | eloqsql/mysys/my_default.c | static char *remove_end_comment(char *ptr)
{
char quote= 0; /* we are inside quote marks */
char escape= 0; /* symbol is protected by escape chagacter */
for (; *ptr; ptr++)
{
if ((*ptr == '\'' || *ptr == '\"') && !escape)
{
if (!quote)
quote= *ptr;
else if (quote == *ptr)
quote= 0;
}
/* We are not inside a string */
if (!quote && *ptr == '#')
{
*ptr= 0;
return ptr;
}
escape= (quote && *ptr == '\\' && !escape);
}
return ptr;
} | O0 | c | remove_end_comment:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3939d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0x39305
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x39333
cmpb $0x0, -0x12(%rbp)
jne 0x39333
cmpb $0x0, -0x11(%rbp)
jne 0x3931c
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
jmp 0x39331
movsbl -0x11(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x3932f
movb $0x0, -0x11(%rbp)
jmp 0x39331
jmp 0x39333
cmpb $0x0, -0x11(%rbp)
jne 0x39356
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x39356
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x393a5
movsbl -0x11(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x13(%rbp)
je 0x39381
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x5c, %ecx
movb %al, -0x13(%rbp)
jne 0x39381
cmpb $0x0, -0x12(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x392e0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
| remove_end_comment:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_11], 0
mov [rbp+var_12], 0
loc_392E0:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jz loc_3939D
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 27h ; '''
jz short loc_39305
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 22h ; '"'
jnz short loc_39333
loc_39305:
cmp [rbp+var_12], 0
jnz short loc_39333
cmp [rbp+var_11], 0
jnz short loc_3931C
mov rax, [rbp+var_10]
mov al, [rax]
mov [rbp+var_11], al
jmp short loc_39331
loc_3931C:
movsx eax, [rbp+var_11]
mov rcx, [rbp+var_10]
movsx ecx, byte ptr [rcx]
cmp eax, ecx
jnz short loc_3932F
mov [rbp+var_11], 0
loc_3932F:
jmp short $+2
loc_39331:
jmp short $+2
loc_39333:
cmp [rbp+var_11], 0
jnz short loc_39356
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 23h ; '#'
jnz short loc_39356
mov rax, [rbp+var_10]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp short loc_393A5
loc_39356:
movsx ecx, [rbp+var_11]
xor eax, eax
cmp ecx, 0
mov [rbp+var_13], al
jz short loc_39381
mov rax, [rbp+var_10]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 5Ch ; '\'
mov [rbp+var_13], al
jnz short loc_39381
cmp [rbp+var_12], 0
setnz al
xor al, 0FFh
mov [rbp+var_13], al
loc_39381:
mov al, [rbp+var_13]
and al, 1
movzx eax, al
mov [rbp+var_12], al
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp loc_392E0
loc_3939D:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_393A5:
mov rax, [rbp+var_8]
pop rbp
retn
| char * remove_end_comment(char *a1)
{
char v2; // [rsp+1h] [rbp-13h]
char v3; // [rsp+2h] [rbp-12h]
char v4; // [rsp+3h] [rbp-11h]
v4 = 0;
v3 = 0;
while ( *a1 )
{
if ( (*a1 == 39 || *a1 == 34) && !v3 )
{
if ( v4 )
{
if ( v4 == *a1 )
v4 = 0;
}
else
{
v4 = *a1;
}
}
if ( !v4 && *a1 == 35 )
{
*a1 = 0;
return a1;
}
v2 = 0;
if ( v4 )
{
v2 = 0;
if ( *a1 == 92 )
v2 = ~(v3 != 0);
}
v3 = v2 & 1;
++a1;
}
return a1;
}
| remove_end_comment:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],0x0
MOV byte ptr [RBP + -0x12],0x0
LAB_001392e0:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JZ 0x0013939d
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x27
JZ 0x00139305
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x22
JNZ 0x00139333
LAB_00139305:
CMP byte ptr [RBP + -0x12],0x0
JNZ 0x00139333
CMP byte ptr [RBP + -0x11],0x0
JNZ 0x0013931c
MOV RAX,qword ptr [RBP + -0x10]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x11],AL
JMP 0x00139331
LAB_0013931c:
MOVSX EAX,byte ptr [RBP + -0x11]
MOV RCX,qword ptr [RBP + -0x10]
MOVSX ECX,byte ptr [RCX]
CMP EAX,ECX
JNZ 0x0013932f
MOV byte ptr [RBP + -0x11],0x0
LAB_0013932f:
JMP 0x00139331
LAB_00139331:
JMP 0x00139333
LAB_00139333:
CMP byte ptr [RBP + -0x11],0x0
JNZ 0x00139356
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x23
JNZ 0x00139356
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001393a5
LAB_00139356:
MOVSX ECX,byte ptr [RBP + -0x11]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x13],AL
JZ 0x00139381
MOV RAX,qword ptr [RBP + -0x10]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x5c
MOV byte ptr [RBP + -0x13],AL
JNZ 0x00139381
CMP byte ptr [RBP + -0x12],0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x13],AL
LAB_00139381:
MOV AL,byte ptr [RBP + -0x13]
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x12],AL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001392e0
LAB_0013939d:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_001393a5:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
char * remove_end_comment(char *param_1)
{
bool bVar1;
bool bVar2;
char local_19;
char *local_18;
local_19 = '\0';
bVar1 = false;
local_18 = param_1;
while( true ) {
if (*local_18 == '\0') {
return local_18;
}
if (((*local_18 == '\'') || (*local_18 == '\"')) && (!bVar1)) {
if (local_19 == '\0') {
local_19 = *local_18;
}
else if (local_19 == *local_18) {
local_19 = '\0';
}
}
if ((local_19 == '\0') && (*local_18 == '#')) break;
bVar2 = false;
if ((local_19 != '\0') && (bVar2 = false, *local_18 == '\\')) {
bVar2 = (bool)(bVar1 ^ 1);
}
bVar1 = bVar2;
local_18 = local_18 + 1;
}
*local_18 = '\0';
return local_18;
}
| |
26,050 | GetScreenToWorld2D | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c | Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera)
{
Matrix invMatCamera = MatrixInvert(GetCameraMatrix2D(camera));
Vector3 transform = Vector3Transform((Vector3){ position.x, position.y, 0 }, invMatCamera);
return (Vector2){ transform.x, transform.y };
} | O1 | c | GetScreenToWorld2D:
pushq %rbx
subq $0xa0, %rsp
movaps %xmm0, 0x50(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0xb0(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x76b4e
movss (%rbx), %xmm5
movss %xmm5, 0x4c(%rsp)
movss 0x4(%rbx), %xmm1
movss %xmm1, 0x48(%rsp)
movss 0x10(%rbx), %xmm8
movss 0x14(%rbx), %xmm3
movss 0x20(%rbx), %xmm4
movss 0x24(%rbx), %xmm10
movss %xmm10, 0x28(%rsp)
movss 0x30(%rbx), %xmm2
movss 0x34(%rbx), %xmm9
movaps %xmm1, %xmm0
mulss %xmm8, %xmm0
movaps %xmm5, %xmm6
mulss %xmm3, %xmm6
subss %xmm0, %xmm6
movaps %xmm1, %xmm0
mulss %xmm4, %xmm0
movaps %xmm5, %xmm15
mulss %xmm10, %xmm15
subss %xmm0, %xmm15
movaps %xmm1, %xmm0
mulss %xmm2, %xmm0
mulss %xmm9, %xmm5
subss %xmm0, %xmm5
movss %xmm3, 0x3c(%rsp)
movaps %xmm3, %xmm0
mulss %xmm4, %xmm0
movss %xmm4, 0x40(%rsp)
movss %xmm8, 0x44(%rsp)
movaps %xmm8, %xmm14
mulss %xmm10, %xmm14
subss %xmm0, %xmm14
movaps %xmm3, %xmm0
movss %xmm2, 0x2c(%rsp)
mulss %xmm2, %xmm0
mulss %xmm9, %xmm8
subss %xmm0, %xmm8
movaps %xmm10, %xmm0
mulss %xmm2, %xmm0
mulss %xmm9, %xmm4
subss %xmm0, %xmm4
movss 0xc(%rbx), %xmm0
movss 0x18(%rbx), %xmm11
movaps %xmm0, %xmm1
mulss %xmm11, %xmm1
movss 0x8(%rbx), %xmm10
movss 0x1c(%rbx), %xmm3
movaps %xmm10, %xmm2
mulss %xmm3, %xmm2
subss %xmm1, %xmm2
movss %xmm2, 0x34(%rsp)
movss 0x28(%rbx), %xmm12
movaps %xmm0, %xmm1
mulss %xmm12, %xmm1
movss 0x2c(%rbx), %xmm2
movaps %xmm10, %xmm7
mulss %xmm2, %xmm7
subss %xmm1, %xmm7
movss %xmm7, 0x24(%rsp)
movss 0x38(%rbx), %xmm7
mulss %xmm7, %xmm0
movss 0x3c(%rbx), %xmm1
mulss %xmm1, %xmm10
subss %xmm0, %xmm10
movaps %xmm3, %xmm0
mulss %xmm12, %xmm0
movaps %xmm11, %xmm13
mulss %xmm2, %xmm13
subss %xmm0, %xmm13
mulss %xmm7, %xmm3
mulss %xmm1, %xmm11
subss %xmm3, %xmm11
mulss %xmm7, %xmm2
mulss %xmm1, %xmm12
subss %xmm2, %xmm12
mulss %xmm11, %xmm15
mulss %xmm12, %xmm6
subss %xmm15, %xmm6
mulss %xmm13, %xmm5
addss %xmm6, %xmm5
mulss %xmm10, %xmm14
addss %xmm5, %xmm14
mulss 0x24(%rsp), %xmm8
subss %xmm8, %xmm14
movss 0x34(%rsp), %xmm8
mulss %xmm8, %xmm4
addss %xmm14, %xmm4
movss 0x5fe50(%rip), %xmm15 # 0xd9944
divss %xmm4, %xmm15
movaps %xmm11, %xmm0
movaps %xmm11, %xmm5
movss %xmm11, 0x30(%rsp)
movss 0x28(%rsp), %xmm3
mulss %xmm3, %xmm0
movss 0x3c(%rsp), %xmm7
movaps %xmm7, %xmm1
mulss %xmm12, %xmm1
subss %xmm0, %xmm1
movaps %xmm9, %xmm14
mulss %xmm13, %xmm14
addss %xmm1, %xmm14
movaps %xmm10, %xmm0
movss 0x40(%rsp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x38(%rsp)
movaps %xmm9, %xmm6
mulss %xmm8, %xmm9
movss 0x2c(%rsp), %xmm0
movaps %xmm0, %xmm2
movaps %xmm0, %xmm11
mulss %xmm8, %xmm0
movss %xmm0, 0x2c(%rsp)
movaps %xmm3, %xmm0
movaps %xmm3, %xmm4
mulss %xmm8, %xmm0
movss %xmm0, 0x28(%rsp)
movaps %xmm1, %xmm3
mulss %xmm1, %xmm8
mulss %xmm5, %xmm3
mulss %xmm10, %xmm4
movss 0x24(%rsp), %xmm0
movaps %xmm6, %xmm5
mulss %xmm0, %xmm5
mulss %xmm0, %xmm11
movss 0x44(%rsp), %xmm6
movaps %xmm6, %xmm1
mulss %xmm10, %xmm1
mulss %xmm7, %xmm10
mulss %xmm0, %xmm7
mulss %xmm6, %xmm0
movss %xmm0, 0x24(%rsp)
mulss %xmm12, %xmm6
subss %xmm6, %xmm3
mulss %xmm13, %xmm2
subss %xmm2, %xmm3
movss 0x48(%rsp), %xmm6
movaps %xmm6, %xmm2
mulss %xmm12, %xmm2
subss %xmm2, %xmm4
subss %xmm5, %xmm4
movss 0x4c(%rsp), %xmm0
mulss %xmm0, %xmm12
subss 0x38(%rsp), %xmm12
addss %xmm12, %xmm11
movaps %xmm6, %xmm2
movss 0x30(%rsp), %xmm5
mulss %xmm5, %xmm2
subss %xmm10, %xmm2
addss %xmm2, %xmm9
mulss %xmm0, %xmm5
subss %xmm5, %xmm1
subss 0x2c(%rsp), %xmm1
mulss %xmm13, %xmm6
movaps %xmm7, %xmm2
subss %xmm6, %xmm2
subss 0x28(%rsp), %xmm2
movaps %xmm2, %xmm7
mulss %xmm0, %xmm13
subss 0x24(%rsp), %xmm13
addss %xmm13, %xmm8
mulss %xmm15, %xmm14
mulss %xmm15, %xmm3
mulss %xmm15, %xmm4
mulss %xmm15, %xmm11
mulss %xmm15, %xmm9
mulss %xmm15, %xmm1
mulss %xmm15, %xmm7
mulss %xmm15, %xmm8
movaps 0x50(%rsp), %xmm6
movaps %xmm6, %xmm2
shufps $0x55, %xmm6, %xmm2 # xmm2 = xmm2[1,1],xmm6[1,1]
mulss %xmm2, %xmm4
mulss %xmm6, %xmm14
addss %xmm4, %xmm14
xorps %xmm0, %xmm0
mulss %xmm0, %xmm9
addss %xmm14, %xmm9
addss %xmm7, %xmm9
mulss %xmm11, %xmm2
mulss %xmm6, %xmm3
addss %xmm2, %xmm3
mulss %xmm0, %xmm1
addss %xmm3, %xmm1
addss %xmm8, %xmm1
unpcklps %xmm1, %xmm9 # xmm9 = xmm9[0],xmm1[0],xmm9[1],xmm1[1]
movaps %xmm9, %xmm0
addq $0xa0, %rsp
popq %rbx
retq
| GetScreenToWorld2D:
push rbx
sub rsp, 0A0h
movaps [rsp+0A8h+var_58], xmm0
mov rax, [rsp+0A8h+arg_10]
mov [rsp+0A8h+var_98], rax
movaps xmm0, [rsp+0A8h+arg_0]
movups [rsp+0A8h+var_A8], xmm0
lea rbx, [rsp+0A8h+var_48]
mov rdi, rbx
call GetCameraMatrix2D
movss xmm5, dword ptr [rbx]
movss [rsp+0A8h+var_5C], xmm5
movss xmm1, dword ptr [rbx+4]
movss [rsp+0A8h+var_60], xmm1
movss xmm8, dword ptr [rbx+10h]
movss xmm3, dword ptr [rbx+14h]
movss xmm4, dword ptr [rbx+20h]
movss xmm10, dword ptr [rbx+24h]
movss [rsp+0A8h+var_80], xmm10
movss xmm2, dword ptr [rbx+30h]
movss xmm9, dword ptr [rbx+34h]
movaps xmm0, xmm1
mulss xmm0, xmm8
movaps xmm6, xmm5
mulss xmm6, xmm3
subss xmm6, xmm0
movaps xmm0, xmm1
mulss xmm0, xmm4
movaps xmm15, xmm5
mulss xmm15, xmm10
subss xmm15, xmm0
movaps xmm0, xmm1
mulss xmm0, xmm2
mulss xmm5, xmm9
subss xmm5, xmm0
movss [rsp+0A8h+var_6C], xmm3
movaps xmm0, xmm3
mulss xmm0, xmm4
movss [rsp+0A8h+var_68], xmm4
movss [rsp+0A8h+var_64], xmm8
movaps xmm14, xmm8
mulss xmm14, xmm10
subss xmm14, xmm0
movaps xmm0, xmm3
movss [rsp+0A8h+var_7C], xmm2
mulss xmm0, xmm2
mulss xmm8, xmm9
subss xmm8, xmm0
movaps xmm0, xmm10
mulss xmm0, xmm2
mulss xmm4, xmm9
subss xmm4, xmm0
movss xmm0, dword ptr [rbx+0Ch]
movss xmm11, dword ptr [rbx+18h]
movaps xmm1, xmm0
mulss xmm1, xmm11
movss xmm10, dword ptr [rbx+8]
movss xmm3, dword ptr [rbx+1Ch]
movaps xmm2, xmm10
mulss xmm2, xmm3
subss xmm2, xmm1
movss [rsp+0A8h+var_74], xmm2
movss xmm12, dword ptr [rbx+28h]
movaps xmm1, xmm0
mulss xmm1, xmm12
movss xmm2, dword ptr [rbx+2Ch]
movaps xmm7, xmm10
mulss xmm7, xmm2
subss xmm7, xmm1
movss [rsp+0A8h+var_84], xmm7
movss xmm7, dword ptr [rbx+38h]
mulss xmm0, xmm7
movss xmm1, dword ptr [rbx+3Ch]
mulss xmm10, xmm1
subss xmm10, xmm0
movaps xmm0, xmm3
mulss xmm0, xmm12
movaps xmm13, xmm11
mulss xmm13, xmm2
subss xmm13, xmm0
mulss xmm3, xmm7
mulss xmm11, xmm1
subss xmm11, xmm3
mulss xmm2, xmm7
mulss xmm12, xmm1
subss xmm12, xmm2
mulss xmm15, xmm11
mulss xmm6, xmm12
subss xmm6, xmm15
mulss xmm5, xmm13
addss xmm5, xmm6
mulss xmm14, xmm10
addss xmm14, xmm5
mulss xmm8, [rsp+0A8h+var_84]
subss xmm14, xmm8
movss xmm8, [rsp+0A8h+var_74]
mulss xmm4, xmm8
addss xmm4, xmm14
movss xmm15, cs:dword_D9944
divss xmm15, xmm4
movaps xmm0, xmm11
movaps xmm5, xmm11
movss [rsp+0A8h+var_78], xmm11
movss xmm3, [rsp+0A8h+var_80]
mulss xmm0, xmm3
movss xmm7, [rsp+0A8h+var_6C]
movaps xmm1, xmm7
mulss xmm1, xmm12
subss xmm1, xmm0
movaps xmm14, xmm9
mulss xmm14, xmm13
addss xmm14, xmm1
movaps xmm0, xmm10
movss xmm1, [rsp+0A8h+var_68]
mulss xmm0, xmm1
movss [rsp+0A8h+var_70], xmm0
movaps xmm6, xmm9
mulss xmm9, xmm8
movss xmm0, [rsp+0A8h+var_7C]
movaps xmm2, xmm0
movaps xmm11, xmm0
mulss xmm0, xmm8
movss [rsp+0A8h+var_7C], xmm0
movaps xmm0, xmm3
movaps xmm4, xmm3
mulss xmm0, xmm8
movss [rsp+0A8h+var_80], xmm0
movaps xmm3, xmm1
mulss xmm8, xmm1
mulss xmm3, xmm5
mulss xmm4, xmm10
movss xmm0, [rsp+0A8h+var_84]
movaps xmm5, xmm6
mulss xmm5, xmm0
mulss xmm11, xmm0
movss xmm6, [rsp+0A8h+var_64]
movaps xmm1, xmm6
mulss xmm1, xmm10
mulss xmm10, xmm7
mulss xmm7, xmm0
mulss xmm0, xmm6
movss [rsp+0A8h+var_84], xmm0
mulss xmm6, xmm12
subss xmm3, xmm6
mulss xmm2, xmm13
subss xmm3, xmm2
movss xmm6, [rsp+0A8h+var_60]
movaps xmm2, xmm6
mulss xmm2, xmm12
subss xmm4, xmm2
subss xmm4, xmm5
movss xmm0, [rsp+0A8h+var_5C]
mulss xmm12, xmm0
subss xmm12, [rsp+0A8h+var_70]
addss xmm11, xmm12
movaps xmm2, xmm6
movss xmm5, [rsp+0A8h+var_78]
mulss xmm2, xmm5
subss xmm2, xmm10
addss xmm9, xmm2
mulss xmm5, xmm0
subss xmm1, xmm5
subss xmm1, [rsp+0A8h+var_7C]
mulss xmm6, xmm13
movaps xmm2, xmm7
subss xmm2, xmm6
subss xmm2, [rsp+0A8h+var_80]
movaps xmm7, xmm2
mulss xmm13, xmm0
subss xmm13, [rsp+0A8h+var_84]
addss xmm8, xmm13
mulss xmm14, xmm15
mulss xmm3, xmm15
mulss xmm4, xmm15
mulss xmm11, xmm15
mulss xmm9, xmm15
mulss xmm1, xmm15
mulss xmm7, xmm15
mulss xmm8, xmm15
movaps xmm6, [rsp+0A8h+var_58]
movaps xmm2, xmm6
shufps xmm2, xmm6, 55h ; 'U'
mulss xmm4, xmm2
mulss xmm14, xmm6
addss xmm14, xmm4
xorps xmm0, xmm0
mulss xmm9, xmm0
addss xmm9, xmm14
addss xmm9, xmm7
mulss xmm2, xmm11
mulss xmm3, xmm6
addss xmm3, xmm2
mulss xmm1, xmm0
addss xmm1, xmm3
addss xmm1, xmm8
unpcklps xmm9, xmm1
movaps xmm0, xmm9
add rsp, 0A0h
pop rbx
retn
| __m128 GetScreenToWorld2D(
__m128 a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
__int128 a8,
long long a9)
{
__m128 v9; // xmm9
float v10; // xmm10_4
float v11; // xmm13_4
float v12; // xmm11_4
float v13; // xmm12_4
float v14; // xmm15_4
__m128 v15; // xmm1
float v16; // xmm2_4
float v18; // [rsp+24h] [rbp-84h]
float v19; // [rsp+34h] [rbp-74h]
float v20; // [rsp+60h] [rbp-48h] BYREF
float v21; // [rsp+64h] [rbp-44h]
float v22; // [rsp+68h] [rbp-40h]
float v23; // [rsp+6Ch] [rbp-3Ch]
unsigned int v24; // [rsp+70h] [rbp-38h]
float v25; // [rsp+74h] [rbp-34h]
float v26; // [rsp+78h] [rbp-30h]
float v27; // [rsp+7Ch] [rbp-2Ch]
float v28; // [rsp+80h] [rbp-28h]
float v29; // [rsp+84h] [rbp-24h]
float v30; // [rsp+88h] [rbp-20h]
float v31; // [rsp+8Ch] [rbp-1Ch]
float v32; // [rsp+90h] [rbp-18h]
unsigned int v33; // [rsp+94h] [rbp-14h]
float v34; // [rsp+98h] [rbp-10h]
float v35; // [rsp+9Ch] [rbp-Ch]
GetCameraMatrix2D((long long)&v20, a3, a4, a5, a6, a7, a8, *((long long *)&a8 + 1), a9);
v9 = (__m128)v33;
v19 = (float)(v22 * v27) - (float)(v23 * v26);
v18 = (float)(v22 * v31) - (float)(v23 * v30);
v10 = (float)(v22 * v35) - (float)(v23 * v34);
v11 = (float)(v26 * v31) - (float)(v27 * v30);
v12 = (float)(v26 * v35) - (float)(v27 * v34);
v13 = (float)(v30 * v35) - (float)(v31 * v34);
v14 = 1.0
/ (float)((float)((float)((float)(v28 * *(float *)&v33) - (float)(v29 * v32)) * v19)
+ (float)((float)((float)((float)((float)(*(float *)&v24 * v29) - (float)(v25 * v28)) * v10)
+ (float)((float)((float)((float)(v20 * *(float *)&v33) - (float)(v21 * v32)) * v11)
+ (float)((float)((float)((float)(v20 * v25) - (float)(v21 * *(float *)&v24)) * v13)
- (float)((float)((float)(v20 * v29) - (float)(v21 * v28)) * v12))))
- (float)((float)((float)(*(float *)&v24 * *(float *)&v33) - (float)(v25 * v32)) * v18)));
v15 = (__m128)v24;
v16 = _mm_shuffle_ps(a1, a1, 85).m128_f32[0];
v9.m128_f32[0] = (float)((float)((float)((float)((float)(*(float *)&v33 * v19)
+ (float)((float)(v21 * v12) - (float)(v10 * v25)))
* v14)
* 0.0)
+ (float)((float)((float)((float)((float)(*(float *)&v33 * v11)
+ (float)((float)(v25 * v13) - (float)(v12 * v29)))
* v14)
* a1.m128_f32[0])
+ (float)((float)((float)((float)((float)(v29 * v10) - (float)(v21 * v13))
- (float)(*(float *)&v33 * v18))
* v14)
* v16)))
+ (float)((float)((float)((float)(v25 * v18) - (float)(v21 * v11)) - (float)(v29 * v19)) * v14);
v15.m128_f32[0] = (float)((float)((float)((float)((float)((float)(*(float *)&v24 * v10) - (float)(v12 * v20))
- (float)(v32 * v19))
* v14)
* 0.0)
+ (float)((float)((float)((float)((float)((float)(v28 * v12) - (float)(*(float *)&v24 * v13))
- (float)(v32 * v11))
* v14)
* a1.m128_f32[0])
+ (float)(v16
* (float)((float)((float)(v32 * v18)
+ (float)((float)(v13 * v20) - (float)(v10 * v28)))
* v14))))
+ (float)((float)((float)(v19 * v28) + (float)((float)(v11 * v20) - (float)(v18 * *(float *)&v24)))
* v14);
return _mm_unpacklo_ps(v9, v15);
}
| GetScreenToWorld2D:
PUSH RBX
SUB RSP,0xa0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0x10],RAX
MOVAPS XMM0,xmmword ptr [RSP + 0xb0]
MOVUPS xmmword ptr [RSP],XMM0
LEA RBX,[RSP + 0x60]
MOV RDI,RBX
CALL 0x00176b4e
MOVSS XMM5,dword ptr [RBX]
MOVSS dword ptr [RSP + 0x4c],XMM5
MOVSS XMM1,dword ptr [RBX + 0x4]
MOVSS dword ptr [RSP + 0x48],XMM1
MOVSS XMM8,dword ptr [RBX + 0x10]
MOVSS XMM3,dword ptr [RBX + 0x14]
MOVSS XMM4,dword ptr [RBX + 0x20]
MOVSS XMM10,dword ptr [RBX + 0x24]
MOVSS dword ptr [RSP + 0x28],XMM10
MOVSS XMM2,dword ptr [RBX + 0x30]
MOVSS XMM9,dword ptr [RBX + 0x34]
MOVAPS XMM0,XMM1
MULSS XMM0,XMM8
MOVAPS XMM6,XMM5
MULSS XMM6,XMM3
SUBSS XMM6,XMM0
MOVAPS XMM0,XMM1
MULSS XMM0,XMM4
MOVAPS XMM15,XMM5
MULSS XMM15,XMM10
SUBSS XMM15,XMM0
MOVAPS XMM0,XMM1
MULSS XMM0,XMM2
MULSS XMM5,XMM9
SUBSS XMM5,XMM0
MOVSS dword ptr [RSP + 0x3c],XMM3
MOVAPS XMM0,XMM3
MULSS XMM0,XMM4
MOVSS dword ptr [RSP + 0x40],XMM4
MOVSS dword ptr [RSP + 0x44],XMM8
MOVAPS XMM14,XMM8
MULSS XMM14,XMM10
SUBSS XMM14,XMM0
MOVAPS XMM0,XMM3
MOVSS dword ptr [RSP + 0x2c],XMM2
MULSS XMM0,XMM2
MULSS XMM8,XMM9
SUBSS XMM8,XMM0
MOVAPS XMM0,XMM10
MULSS XMM0,XMM2
MULSS XMM4,XMM9
SUBSS XMM4,XMM0
MOVSS XMM0,dword ptr [RBX + 0xc]
MOVSS XMM11,dword ptr [RBX + 0x18]
MOVAPS XMM1,XMM0
MULSS XMM1,XMM11
MOVSS XMM10,dword ptr [RBX + 0x8]
MOVSS XMM3,dword ptr [RBX + 0x1c]
MOVAPS XMM2,XMM10
MULSS XMM2,XMM3
SUBSS XMM2,XMM1
MOVSS dword ptr [RSP + 0x34],XMM2
MOVSS XMM12,dword ptr [RBX + 0x28]
MOVAPS XMM1,XMM0
MULSS XMM1,XMM12
MOVSS XMM2,dword ptr [RBX + 0x2c]
MOVAPS XMM7,XMM10
MULSS XMM7,XMM2
SUBSS XMM7,XMM1
MOVSS dword ptr [RSP + 0x24],XMM7
MOVSS XMM7,dword ptr [RBX + 0x38]
MULSS XMM0,XMM7
MOVSS XMM1,dword ptr [RBX + 0x3c]
MULSS XMM10,XMM1
SUBSS XMM10,XMM0
MOVAPS XMM0,XMM3
MULSS XMM0,XMM12
MOVAPS XMM13,XMM11
MULSS XMM13,XMM2
SUBSS XMM13,XMM0
MULSS XMM3,XMM7
MULSS XMM11,XMM1
SUBSS XMM11,XMM3
MULSS XMM2,XMM7
MULSS XMM12,XMM1
SUBSS XMM12,XMM2
MULSS XMM15,XMM11
MULSS XMM6,XMM12
SUBSS XMM6,XMM15
MULSS XMM5,XMM13
ADDSS XMM5,XMM6
MULSS XMM14,XMM10
ADDSS XMM14,XMM5
MULSS XMM8,dword ptr [RSP + 0x24]
SUBSS XMM14,XMM8
MOVSS XMM8,dword ptr [RSP + 0x34]
MULSS XMM4,XMM8
ADDSS XMM4,XMM14
MOVSS XMM15,dword ptr [0x001d9944]
DIVSS XMM15,XMM4
MOVAPS XMM0,XMM11
MOVAPS XMM5,XMM11
MOVSS dword ptr [RSP + 0x30],XMM11
MOVSS XMM3,dword ptr [RSP + 0x28]
MULSS XMM0,XMM3
MOVSS XMM7,dword ptr [RSP + 0x3c]
MOVAPS XMM1,XMM7
MULSS XMM1,XMM12
SUBSS XMM1,XMM0
MOVAPS XMM14,XMM9
MULSS XMM14,XMM13
ADDSS XMM14,XMM1
MOVAPS XMM0,XMM10
MOVSS XMM1,dword ptr [RSP + 0x40]
MULSS XMM0,XMM1
MOVSS dword ptr [RSP + 0x38],XMM0
MOVAPS XMM6,XMM9
MULSS XMM9,XMM8
MOVSS XMM0,dword ptr [RSP + 0x2c]
MOVAPS XMM2,XMM0
MOVAPS XMM11,XMM0
MULSS XMM0,XMM8
MOVSS dword ptr [RSP + 0x2c],XMM0
MOVAPS XMM0,XMM3
MOVAPS XMM4,XMM3
MULSS XMM0,XMM8
MOVSS dword ptr [RSP + 0x28],XMM0
MOVAPS XMM3,XMM1
MULSS XMM8,XMM1
MULSS XMM3,XMM5
MULSS XMM4,XMM10
MOVSS XMM0,dword ptr [RSP + 0x24]
MOVAPS XMM5,XMM6
MULSS XMM5,XMM0
MULSS XMM11,XMM0
MOVSS XMM6,dword ptr [RSP + 0x44]
MOVAPS XMM1,XMM6
MULSS XMM1,XMM10
MULSS XMM10,XMM7
MULSS XMM7,XMM0
MULSS XMM0,XMM6
MOVSS dword ptr [RSP + 0x24],XMM0
MULSS XMM6,XMM12
SUBSS XMM3,XMM6
MULSS XMM2,XMM13
SUBSS XMM3,XMM2
MOVSS XMM6,dword ptr [RSP + 0x48]
MOVAPS XMM2,XMM6
MULSS XMM2,XMM12
SUBSS XMM4,XMM2
SUBSS XMM4,XMM5
MOVSS XMM0,dword ptr [RSP + 0x4c]
MULSS XMM12,XMM0
SUBSS XMM12,dword ptr [RSP + 0x38]
ADDSS XMM11,XMM12
MOVAPS XMM2,XMM6
MOVSS XMM5,dword ptr [RSP + 0x30]
MULSS XMM2,XMM5
SUBSS XMM2,XMM10
ADDSS XMM9,XMM2
MULSS XMM5,XMM0
SUBSS XMM1,XMM5
SUBSS XMM1,dword ptr [RSP + 0x2c]
MULSS XMM6,XMM13
MOVAPS XMM2,XMM7
SUBSS XMM2,XMM6
SUBSS XMM2,dword ptr [RSP + 0x28]
MOVAPS XMM7,XMM2
MULSS XMM13,XMM0
SUBSS XMM13,dword ptr [RSP + 0x24]
ADDSS XMM8,XMM13
MULSS XMM14,XMM15
MULSS XMM3,XMM15
MULSS XMM4,XMM15
MULSS XMM11,XMM15
MULSS XMM9,XMM15
MULSS XMM1,XMM15
MULSS XMM7,XMM15
MULSS XMM8,XMM15
MOVAPS XMM6,xmmword ptr [RSP + 0x50]
MOVAPS XMM2,XMM6
SHUFPS XMM2,XMM6,0x55
MULSS XMM4,XMM2
MULSS XMM14,XMM6
ADDSS XMM14,XMM4
XORPS XMM0,XMM0
MULSS XMM9,XMM0
ADDSS XMM9,XMM14
ADDSS XMM9,XMM7
MULSS XMM2,XMM11
MULSS XMM3,XMM6
ADDSS XMM3,XMM2
MULSS XMM1,XMM0
ADDSS XMM1,XMM3
ADDSS XMM1,XMM8
UNPCKLPS XMM9,XMM1
MOVAPS XMM0,XMM9
ADD RSP,0xa0
POP RBX
RET
|
int8 GetScreenToWorld2D(int8 param_1)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
float fVar8;
float local_48;
float local_44;
float local_40;
float local_3c;
float local_38;
float local_34;
float local_30;
float local_2c;
float local_28;
float local_24;
float local_20;
float local_1c;
float local_18;
float local_14;
float local_10;
float local_c;
fVar1 = (float)((ulong)param_1 >> 0x20);
GetCameraMatrix2D(&local_48);
fVar2 = local_40 * local_2c - local_3c * local_30;
fVar3 = local_40 * local_1c - local_3c * local_20;
fVar4 = local_40 * local_c - local_3c * local_10;
fVar7 = local_30 * local_1c - local_2c * local_20;
fVar5 = local_30 * local_c - local_2c * local_10;
fVar6 = local_20 * local_c - local_1c * local_10;
fVar8 = DAT_001d9944 /
((local_28 * local_14 - local_24 * local_18) * fVar2 +
(((local_38 * local_24 - local_34 * local_28) * fVar4 +
(local_48 * local_14 - local_44 * local_18) * fVar7 +
((local_48 * local_34 - local_44 * local_38) * fVar6 -
(local_48 * local_24 - local_44 * local_28) * fVar5)) -
(local_38 * local_14 - local_34 * local_18) * fVar3));
return CONCAT44(((local_38 * fVar4 - fVar5 * local_48) - local_18 * fVar2) * fVar8 * 0.0 +
((local_28 * fVar5 - local_38 * fVar6) - local_18 * fVar7) * fVar8 *
(float)param_1 +
fVar1 * (local_18 * fVar3 + (fVar6 * local_48 - fVar4 * local_28)) * fVar8 +
(fVar2 * local_28 + (fVar7 * local_48 - fVar3 * local_38)) * fVar8,
(local_14 * fVar2 + (local_44 * fVar5 - fVar4 * local_34)) * fVar8 * 0.0 +
(local_14 * fVar7 + (local_34 * fVar6 - fVar5 * local_24)) * fVar8 *
(float)param_1 +
((local_24 * fVar4 - local_44 * fVar6) - local_14 * fVar3) * fVar8 * fVar1 +
((local_34 * fVar3 - local_44 * fVar7) - local_24 * fVar2) * fVar8);
}
| |
26,051 | viaRuleCB(LefDefParser::lefrCallbackType_e, LefDefParser::lefiViaRule*, void*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lefdiff/diffLefRW.cpp | int viaRuleCB(lefrCallbackType_e c, lefiViaRule* viaRule, lefiUserData ud) {
int numLayers, numVias, i;
lefiViaRuleLayer* vLayer;
checkType(c);
if (ud != userData) dataError();
fprintf(fout, "VIARULE %s", viaRule->name());
if (viaRule->hasGenerate())
fprintf(fout, " GENERATE");
if (viaRule->hasDefault())
fprintf(fout, " DEFAULT");
fprintf(fout, "\n");
numLayers = viaRule->numLayers();
// if numLayers == 2, it is VIARULE without GENERATE and has via name
// if numLayers == 3, it is VIARULE with GENERATE, and the 3rd layer is cut
for (i = 0; i < numLayers; i++) {
vLayer = viaRule->layer(i);
lefViaRuleLayer(vLayer, viaRule->name());
}
if (numLayers == 2) { // should have vianames
numVias = viaRule->numVias();
if (numVias == 0)
fprintf(fout, "Should have via names in VIARULE.\n");
else {
for (i = 0; i < numVias; i++)
fprintf(fout, "VIARULE %s VIA %s ;\n", viaRule->name(),
viaRule->viaName(i));
}
}
if (viaRule->numProps() > 0) {
for (i = 0; i < viaRule->numProps(); i++) {
fprintf(fout, "VIARULE %s PROP %s ", viaRule->name(),
viaRule->propName(i));
if (viaRule->propValue(i))
fprintf(fout, "%s ", viaRule->propValue(i));
switch (viaRule->propType(i)) {
case 'R': fprintf(fout, "REAL ");
break;
case 'I': fprintf(fout, "INTEGER ");
break;
case 'S': fprintf(fout, "STRING ");
break;
case 'Q': fprintf(fout, "QUOTESTRING ");
break;
case 'N': fprintf(fout, "NUMBER ");
break;
fprintf(fout, "\n");
}
}
}
return 0;
} | O0 | cpp | viaRuleCB(LefDefParser::lefrCallbackType_e, LefDefParser::lefiViaRule*, void*):
subq $0x78, %rsp
movl %edi, 0x74(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl 0x74(%rsp), %edi
callq 0x25a0
movq 0x60(%rsp), %rax
cmpq 0x93719(%rip), %rax # 0xa2560
je 0xee4e
callq 0x2580
movq 0x936fb(%rip), %rax # 0xa2550
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rdi
callq 0x30220
movq 0x40(%rsp), %rdi
movq %rax, %rdx
leaq 0x680f4(%rip), %rsi # 0x76f67
movb $0x0, %al
callq 0x2350
movq 0x68(%rsp), %rdi
callq 0x301a0
cmpl $0x0, %eax
je 0xee9e
movq 0x936c0(%rip), %rdi # 0xa2550
leaq 0x680db(%rip), %rsi # 0x76f72
movb $0x0, %al
callq 0x2350
movq 0x68(%rsp), %rdi
callq 0x301b0
cmpl $0x0, %eax
je 0xeec2
movq 0x9369c(%rip), %rdi # 0xa2550
leaq 0x662dc(%rip), %rsi # 0x75197
movb $0x0, %al
callq 0x2350
movq 0x93687(%rip), %rdi # 0xa2550
leaq 0x6c7f9(%rip), %rsi # 0x7b6c9
movb $0x0, %al
callq 0x2350
movq 0x68(%rsp), %rdi
callq 0x301c0
movl %eax, 0x5c(%rsp)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0x5c(%rsp), %eax
jge 0xef38
movq 0x68(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x301d0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rdi
callq 0x30220
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x3440
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0xeeed
cmpl $0x2, 0x5c(%rsp)
jne 0xefd6
movq 0x68(%rsp), %rdi
callq 0x30360
movl %eax, 0x58(%rsp)
cmpl $0x0, 0x58(%rsp)
jne 0xef6f
movq 0x935f1(%rip), %rdi # 0xa2550
leaq 0x68016(%rip), %rsi # 0x76f7c
movb $0x0, %al
callq 0x2350
jmp 0xefd4
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0x58(%rsp), %eax
jge 0xefd2
movq 0x935c8(%rip), %rax # 0xa2550
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rdi
callq 0x30220
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x30380
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq %rax, %rcx
leaq 0x67fe1(%rip), %rsi # 0x76f9f
movb $0x0, %al
callq 0x2350
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0xef77
jmp 0xefd4
jmp 0xefd6
movq 0x68(%rsp), %rdi
callq 0x303e0
cmpl $0x0, %eax
jle 0xf155
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x68(%rsp), %rdi
callq 0x303e0
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jge 0xf153
movq 0x93538(%rip), %rax # 0xa2550
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
callq 0x30220
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x309b0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
leaq 0x67f67(%rip), %rsi # 0x76fb5
movb $0x0, %al
callq 0x2350
movq 0x68(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x30a70
cmpq $0x0, %rax
je 0xf099
movq 0x934e0(%rip), %rax # 0xa2550
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x30a70
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x668b6(%rip), %rsi # 0x75948
movb $0x0, %al
callq 0x2350
movq 0x68(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x30bf0
movsbl %al, %eax
addl $-0x49, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0xa, %eax
ja 0xf141
movq (%rsp), %rax
leaq 0x66051(%rip), %rcx # 0x75118
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x93479(%rip), %rdi # 0xa2550
leaq 0x67eeb(%rip), %rsi # 0x76fc9
movb $0x0, %al
callq 0x2350
jmp 0xf141
movq 0x93462(%rip), %rdi # 0xa2550
leaq 0x67eda(%rip), %rsi # 0x76fcf
movb $0x0, %al
callq 0x2350
jmp 0xf141
movq 0x9344b(%rip), %rdi # 0xa2550
leaq 0x67ed1(%rip), %rsi # 0x76fdd
movb $0x0, %al
callq 0x2350
jmp 0xf141
movq 0x93434(%rip), %rdi # 0xa2550
leaq 0x67eb5(%rip), %rsi # 0x76fd8
movb $0x0, %al
callq 0x2350
jmp 0xf141
movq 0x9341d(%rip), %rdi # 0xa2550
leaq 0x67eab(%rip), %rsi # 0x76fe5
movb $0x0, %al
callq 0x2350
jmp 0xf143
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0xeff1
jmp 0xf155
xorl %eax, %eax
addq $0x78, %rsp
retq
nopl (%rax)
| _Z9viaRuleCBN12LefDefParser18lefrCallbackType_eEPNS_11lefiViaRuleEPv:
sub rsp, 78h
mov [rsp+78h+var_4], edi
mov [rsp+78h+var_10], rsi
mov [rsp+78h+var_18], rdx
mov edi, [rsp+78h+var_4]
call _Z9checkTypeN12LefDefParser18lefrCallbackType_eE; checkType(LefDefParser::lefrCallbackType_e)
mov rax, [rsp+78h+var_18]
cmp rax, cs:userData
jz short loc_EE4E
call _Z9dataErrorv; dataError(void)
loc_EE4E:
mov rax, cs:fout
mov [rsp+78h+var_38], rax
mov rdi, [rsp+78h+var_10]; this
call _ZNK12LefDefParser11lefiViaRule4nameEv; LefDefParser::lefiViaRule::name(void)
mov rdi, [rsp+78h+var_38]
mov rdx, rax
lea rsi, aViaruleS; "VIARULE %s"
mov al, 0
call _fprintf
mov rdi, [rsp+78h+var_10]; this
call _ZNK12LefDefParser11lefiViaRule11hasGenerateEv; LefDefParser::lefiViaRule::hasGenerate(void)
cmp eax, 0
jz short loc_EE9E
mov rdi, cs:fout
lea rsi, aGenerate; " GENERATE"
mov al, 0
call _fprintf
loc_EE9E:
mov rdi, [rsp+78h+var_10]; this
call _ZNK12LefDefParser11lefiViaRule10hasDefaultEv; LefDefParser::lefiViaRule::hasDefault(void)
cmp eax, 0
jz short loc_EEC2
mov rdi, cs:fout
lea rsi, aDefault; " DEFAULT"
mov al, 0
call _fprintf
loc_EEC2:
mov rdi, cs:fout
lea rsi, aInfoFromFileS+14h; "\n"
mov al, 0
call _fprintf
mov rdi, [rsp+78h+var_10]; this
call _ZNK12LefDefParser11lefiViaRule9numLayersEv; LefDefParser::lefiViaRule::numLayers(void)
mov [rsp+78h+var_1C], eax
mov [rsp+78h+var_24], 0
loc_EEED:
mov eax, [rsp+78h+var_24]
cmp eax, [rsp+78h+var_1C]
jge short loc_EF38
mov rdi, [rsp+78h+var_10]; this
mov esi, [rsp+78h+var_24]; int
call _ZNK12LefDefParser11lefiViaRule5layerEi; LefDefParser::lefiViaRule::layer(int)
mov [rsp+78h+var_30], rax
mov rax, [rsp+78h+var_30]
mov [rsp+78h+var_40], rax
mov rdi, [rsp+78h+var_10]; this
call _ZNK12LefDefParser11lefiViaRule4nameEv; LefDefParser::lefiViaRule::name(void)
mov rdi, [rsp+78h+var_40]; LefDefParser::lefiViaRuleLayer *
mov rsi, rax; char *
call _Z15lefViaRuleLayerPN12LefDefParser16lefiViaRuleLayerEPc; lefViaRuleLayer(LefDefParser::lefiViaRuleLayer *,char *)
mov eax, [rsp+78h+var_24]
add eax, 1
mov [rsp+78h+var_24], eax
jmp short loc_EEED
loc_EF38:
cmp [rsp+78h+var_1C], 2
jnz loc_EFD6
mov rdi, [rsp+78h+var_10]; this
call _ZNK12LefDefParser11lefiViaRule7numViasEv; LefDefParser::lefiViaRule::numVias(void)
mov [rsp+78h+var_20], eax
cmp [rsp+78h+var_20], 0
jnz short loc_EF6F
mov rdi, cs:fout
lea rsi, aShouldHaveViaN; "Should have via names in VIARULE.\n"
mov al, 0
call _fprintf
jmp short loc_EFD4
loc_EF6F:
mov [rsp+78h+var_24], 0
loc_EF77:
mov eax, [rsp+78h+var_24]
cmp eax, [rsp+78h+var_20]
jge short loc_EFD2
mov rax, cs:fout
mov [rsp+78h+var_50], rax
mov rdi, [rsp+78h+var_10]; this
call _ZNK12LefDefParser11lefiViaRule4nameEv; LefDefParser::lefiViaRule::name(void)
mov [rsp+78h+var_48], rax
mov rdi, [rsp+78h+var_10]; this
mov esi, [rsp+78h+var_24]; int
call _ZNK12LefDefParser11lefiViaRule7viaNameEi; LefDefParser::lefiViaRule::viaName(int)
mov rdi, [rsp+78h+var_50]
mov rdx, [rsp+78h+var_48]
mov rcx, rax
lea rsi, aViaruleSViaS; "VIARULE %s VIA %s ;\n"
mov al, 0
call _fprintf
mov eax, [rsp+78h+var_24]
add eax, 1
mov [rsp+78h+var_24], eax
jmp short loc_EF77
loc_EFD2:
jmp short $+2
loc_EFD4:
jmp short $+2
loc_EFD6:
mov rdi, [rsp+78h+var_10]; this
call _ZNK12LefDefParser11lefiViaRule8numPropsEv; LefDefParser::lefiViaRule::numProps(void)
cmp eax, 0
jle loc_F155
mov [rsp+78h+var_24], 0
loc_EFF1:
mov eax, [rsp+78h+var_24]
mov [rsp+78h+var_54], eax
mov rdi, [rsp+78h+var_10]; this
call _ZNK12LefDefParser11lefiViaRule8numPropsEv; LefDefParser::lefiViaRule::numProps(void)
mov ecx, eax
mov eax, [rsp+78h+var_54]
cmp eax, ecx
jge loc_F153
mov rax, cs:fout
mov [rsp+78h+var_68], rax
mov rdi, [rsp+78h+var_10]; this
call _ZNK12LefDefParser11lefiViaRule4nameEv; LefDefParser::lefiViaRule::name(void)
mov [rsp+78h+var_60], rax
mov rdi, [rsp+78h+var_10]; this
mov esi, [rsp+78h+var_24]; int
call _ZNK12LefDefParser11lefiViaRule8propNameEi; LefDefParser::lefiViaRule::propName(int)
mov rdi, [rsp+78h+var_68]
mov rdx, [rsp+78h+var_60]
mov rcx, rax
lea rsi, aViaruleSPropS; "VIARULE %s PROP %s "
mov al, 0
call _fprintf
mov rdi, [rsp+78h+var_10]; this
mov esi, [rsp+78h+var_24]; int
call _ZNK12LefDefParser11lefiViaRule9propValueEi; LefDefParser::lefiViaRule::propValue(int)
cmp rax, 0
jz short loc_F099
mov rax, cs:fout
mov [rsp+78h+var_70], rax
mov rdi, [rsp+78h+var_10]; this
mov esi, [rsp+78h+var_24]; int
call _ZNK12LefDefParser11lefiViaRule9propValueEi; LefDefParser::lefiViaRule::propValue(int)
mov rdi, [rsp+78h+var_70]
mov rdx, rax
lea rsi, aIrdropTableS+0Dh; "%s "
mov al, 0
call _fprintf
loc_F099:
mov rdi, [rsp+78h+var_10]; this
mov esi, [rsp+78h+var_24]; int
call _ZNK12LefDefParser11lefiViaRule8propTypeEi; LefDefParser::lefiViaRule::propType(int)
movsx eax, al
add eax, 0FFFFFFB7h; switch 11 cases
mov ecx, eax
mov [rsp+78h+var_78], rcx
sub eax, 0Ah
ja def_F0CE; jumptable 000000000000F0CE default case, cases 74-77,79,80
mov rax, [rsp+78h+var_78]
lea rcx, jpt_F0CE
movsxd rax, ds:(jpt_F0CE - 75118h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_F0D0:
mov rdi, cs:fout; jumptable 000000000000F0CE case 82
lea rsi, aReal_0; "REAL "
mov al, 0
call _fprintf
jmp short def_F0CE; jumptable 000000000000F0CE default case, cases 74-77,79,80
loc_F0E7:
mov rdi, cs:fout; jumptable 000000000000F0CE case 73
lea rsi, aInteger_0; "INTEGER "
mov al, 0
call _fprintf
jmp short def_F0CE; jumptable 000000000000F0CE default case, cases 74-77,79,80
loc_F0FE:
mov rdi, cs:fout; jumptable 000000000000F0CE case 83
lea rsi, aQuotestring_0+5; "STRING "
mov al, 0
call _fprintf
jmp short def_F0CE; jumptable 000000000000F0CE default case, cases 74-77,79,80
loc_F115:
mov rdi, cs:fout; jumptable 000000000000F0CE case 81
lea rsi, aQuotestring_0; "QUOTESTRING "
mov al, 0
call _fprintf
jmp short def_F0CE; jumptable 000000000000F0CE default case, cases 74-77,79,80
loc_F12C:
mov rdi, cs:fout; jumptable 000000000000F0CE case 78
lea rsi, aNumber_0; "NUMBER "
mov al, 0
call _fprintf
def_F0CE:
jmp short $+2; jumptable 000000000000F0CE default case, cases 74-77,79,80
loc_F143:
mov eax, [rsp+78h+var_24]
add eax, 1
mov [rsp+78h+var_24], eax
jmp loc_EFF1
loc_F153:
jmp short $+2
loc_F155:
xor eax, eax
add rsp, 78h
retn
| long long viaRuleCB(unsigned int a1, LefDefParser::lefiViaRule *a2, long long a3, double a4)
{
const char *v4; // rax
char *v5; // rax
const char *v6; // rax
const char *v7; // rax
const char *v8; // rax
long long v10; // [rsp+8h] [rbp-70h]
long long v11; // [rsp+10h] [rbp-68h]
const char *v12; // [rsp+18h] [rbp-60h]
long long v13; // [rsp+28h] [rbp-50h]
const char *v14; // [rsp+30h] [rbp-48h]
LefDefParser::lefiViaRuleLayer *v15; // [rsp+38h] [rbp-40h]
long long v16; // [rsp+40h] [rbp-38h]
int i; // [rsp+54h] [rbp-24h]
int j; // [rsp+54h] [rbp-24h]
int k; // [rsp+54h] [rbp-24h]
int v20; // [rsp+58h] [rbp-20h]
int v21; // [rsp+5Ch] [rbp-1Ch]
checkType(a1);
if ( a3 != userData )
dataError();
v16 = fout;
v4 = (const char *)LefDefParser::lefiViaRule::name(a2);
fprintf(v16, "VIARULE %s", v4);
if ( (unsigned int)LefDefParser::lefiViaRule::hasGenerate(a2) )
fprintf(fout, " GENERATE");
if ( (unsigned int)LefDefParser::lefiViaRule::hasDefault(a2) )
fprintf(fout, " DEFAULT");
fprintf(fout, "\n");
v21 = LefDefParser::lefiViaRule::numLayers(a2);
for ( i = 0; i < v21; ++i )
{
v15 = (LefDefParser::lefiViaRuleLayer *)LefDefParser::lefiViaRule::layer(a2, i);
v5 = (char *)LefDefParser::lefiViaRule::name(a2);
lefViaRuleLayer(v15, v5, a4);
}
if ( v21 == 2 )
{
v20 = LefDefParser::lefiViaRule::numVias(a2);
if ( v20 )
{
for ( j = 0; j < v20; ++j )
{
v13 = fout;
v14 = (const char *)LefDefParser::lefiViaRule::name(a2);
v6 = (const char *)LefDefParser::lefiViaRule::viaName(a2, j);
fprintf(v13, "VIARULE %s VIA %s ;\n", v14, v6);
}
}
else
{
fprintf(fout, "Should have via names in VIARULE.\n");
}
}
if ( (int)LefDefParser::lefiViaRule::numProps(a2) > 0 )
{
for ( k = 0; k < (int)LefDefParser::lefiViaRule::numProps(a2); ++k )
{
v11 = fout;
v12 = (const char *)LefDefParser::lefiViaRule::name(a2);
v7 = (const char *)LefDefParser::lefiViaRule::propName(a2, k);
fprintf(v11, "VIARULE %s PROP %s ", v12, v7);
if ( LefDefParser::lefiViaRule::propValue(a2, k) )
{
v10 = fout;
v8 = (const char *)LefDefParser::lefiViaRule::propValue(a2, k);
fprintf(v10, "%s ", v8);
}
switch ( (unsigned __int8)LefDefParser::lefiViaRule::propType(a2, k) )
{
case 'I':
fprintf(fout, "INTEGER ");
break;
case 'N':
fprintf(fout, "NUMBER ");
break;
case 'Q':
fprintf(fout, "QUOTESTRING ");
break;
case 'R':
fprintf(fout, "REAL ");
break;
case 'S':
fprintf(fout, "STRING ");
break;
default:
continue;
}
}
}
return 0LL;
}
| viaRuleCB:
SUB RSP,0x78
MOV dword ptr [RSP + 0x74],EDI
MOV qword ptr [RSP + 0x68],RSI
MOV qword ptr [RSP + 0x60],RDX
MOV EDI,dword ptr [RSP + 0x74]
CALL 0x001025a0
MOV RAX,qword ptr [RSP + 0x60]
CMP RAX,qword ptr [0x001a2560]
JZ 0x0010ee4e
CALL 0x00102580
LAB_0010ee4e:
MOV RAX,qword ptr [0x001a2550]
MOV qword ptr [RSP + 0x40],RAX
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00130220
MOV RDI,qword ptr [RSP + 0x40]
MOV RDX,RAX
LEA RSI,[0x176f67]
MOV AL,0x0
CALL 0x00102350
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001301a0
CMP EAX,0x0
JZ 0x0010ee9e
MOV RDI,qword ptr [0x001a2550]
LEA RSI,[0x176f72]
MOV AL,0x0
CALL 0x00102350
LAB_0010ee9e:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001301b0
CMP EAX,0x0
JZ 0x0010eec2
MOV RDI,qword ptr [0x001a2550]
LEA RSI,[0x175197]
MOV AL,0x0
CALL 0x00102350
LAB_0010eec2:
MOV RDI,qword ptr [0x001a2550]
LEA RSI,[0x17b6c9]
MOV AL,0x0
CALL 0x00102350
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001301c0
MOV dword ptr [RSP + 0x5c],EAX
MOV dword ptr [RSP + 0x54],0x0
LAB_0010eeed:
MOV EAX,dword ptr [RSP + 0x54]
CMP EAX,dword ptr [RSP + 0x5c]
JGE 0x0010ef38
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x54]
CALL 0x001301d0
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00130220
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,RAX
CALL 0x00103440
MOV EAX,dword ptr [RSP + 0x54]
ADD EAX,0x1
MOV dword ptr [RSP + 0x54],EAX
JMP 0x0010eeed
LAB_0010ef38:
CMP dword ptr [RSP + 0x5c],0x2
JNZ 0x0010efd6
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00130360
MOV dword ptr [RSP + 0x58],EAX
CMP dword ptr [RSP + 0x58],0x0
JNZ 0x0010ef6f
MOV RDI,qword ptr [0x001a2550]
LEA RSI,[0x176f7c]
MOV AL,0x0
CALL 0x00102350
JMP 0x0010efd4
LAB_0010ef6f:
MOV dword ptr [RSP + 0x54],0x0
LAB_0010ef77:
MOV EAX,dword ptr [RSP + 0x54]
CMP EAX,dword ptr [RSP + 0x58]
JGE 0x0010efd2
MOV RAX,qword ptr [0x001a2550]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00130220
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x54]
CALL 0x00130380
MOV RDI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
MOV RCX,RAX
LEA RSI,[0x176f9f]
MOV AL,0x0
CALL 0x00102350
MOV EAX,dword ptr [RSP + 0x54]
ADD EAX,0x1
MOV dword ptr [RSP + 0x54],EAX
JMP 0x0010ef77
LAB_0010efd2:
JMP 0x0010efd4
LAB_0010efd4:
JMP 0x0010efd6
LAB_0010efd6:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001303e0
CMP EAX,0x0
JLE 0x0010f155
MOV dword ptr [RSP + 0x54],0x0
LAB_0010eff1:
MOV EAX,dword ptr [RSP + 0x54]
MOV dword ptr [RSP + 0x24],EAX
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001303e0
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x24]
CMP EAX,ECX
JGE 0x0010f153
MOV RAX,qword ptr [0x001a2550]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00130220
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x54]
CALL 0x001309b0
MOV RDI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
MOV RCX,RAX
LEA RSI,[0x176fb5]
MOV AL,0x0
CALL 0x00102350
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x54]
CALL 0x00130a70
CMP RAX,0x0
JZ 0x0010f099
MOV RAX,qword ptr [0x001a2550]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x54]
CALL 0x00130a70
MOV RDI,qword ptr [RSP + 0x8]
MOV RDX,RAX
LEA RSI,[0x175948]
MOV AL,0x0
CALL 0x00102350
LAB_0010f099:
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x54]
CALL 0x00130bf0
MOVSX EAX,AL
ADD EAX,-0x49
MOV ECX,EAX
MOV qword ptr [RSP],RCX
SUB EAX,0xa
JA 0x0010f141
MOV RAX,qword ptr [RSP]
LEA RCX,[0x175118]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_52:
MOV RDI,qword ptr [0x001a2550]
LEA RSI,[0x176fc9]
MOV AL,0x0
CALL 0x00102350
JMP 0x0010f141
caseD_49:
MOV RDI,qword ptr [0x001a2550]
LEA RSI,[0x176fcf]
MOV AL,0x0
CALL 0x00102350
JMP 0x0010f141
caseD_53:
MOV RDI,qword ptr [0x001a2550]
LEA RSI,[0x176fdd]
MOV AL,0x0
CALL 0x00102350
JMP 0x0010f141
caseD_51:
MOV RDI,qword ptr [0x001a2550]
LEA RSI,[0x176fd8]
MOV AL,0x0
CALL 0x00102350
JMP 0x0010f141
caseD_4e:
MOV RDI,qword ptr [0x001a2550]
LEA RSI,[0x176fe5]
MOV AL,0x0
CALL 0x00102350
caseD_4a:
JMP 0x0010f143
LAB_0010f143:
MOV EAX,dword ptr [RSP + 0x54]
ADD EAX,0x1
MOV dword ptr [RSP + 0x54],EAX
JMP 0x0010eff1
LAB_0010f153:
JMP 0x0010f155
LAB_0010f155:
XOR EAX,EAX
ADD RSP,0x78
RET
|
/* viaRuleCB(LefDefParser::lefrCallbackType_e, LefDefParser::lefiViaRule*, void*) */
int8 viaRuleCB(int4 param_1,lefiViaRule *param_2,long param_3)
{
FILE *pFVar1;
int1 uVar2;
int iVar3;
int8 uVar4;
lefiViaRuleLayer *plVar5;
char *pcVar6;
int8 uVar7;
long lVar8;
int local_24;
checkType(param_1);
if (param_3 != userData) {
dataError();
}
pFVar1 = fout;
uVar4 = LefDefParser::lefiViaRule::name(param_2);
fprintf(pFVar1,"VIARULE %s",uVar4);
iVar3 = LefDefParser::lefiViaRule::hasGenerate(param_2);
if (iVar3 != 0) {
fprintf(fout," GENERATE");
}
iVar3 = LefDefParser::lefiViaRule::hasDefault(param_2);
if (iVar3 != 0) {
fprintf(fout," DEFAULT");
}
fprintf(fout,"\n");
iVar3 = LefDefParser::lefiViaRule::numLayers(param_2);
for (local_24 = 0; local_24 < iVar3; local_24 = local_24 + 1) {
plVar5 = (lefiViaRuleLayer *)LefDefParser::lefiViaRule::layer(param_2,local_24);
pcVar6 = (char *)LefDefParser::lefiViaRule::name(param_2);
lefViaRuleLayer(plVar5,pcVar6);
}
if (iVar3 == 2) {
iVar3 = LefDefParser::lefiViaRule::numVias(param_2);
if (iVar3 == 0) {
fprintf(fout,"Should have via names in VIARULE.\n");
}
else {
for (local_24 = 0; pFVar1 = fout, local_24 < iVar3; local_24 = local_24 + 1) {
uVar4 = LefDefParser::lefiViaRule::name(param_2);
uVar7 = LefDefParser::lefiViaRule::viaName(param_2,local_24);
fprintf(pFVar1,"VIARULE %s VIA %s ;\n",uVar4,uVar7);
}
}
}
iVar3 = LefDefParser::lefiViaRule::numProps(param_2);
if (0 < iVar3) {
for (local_24 = 0; iVar3 = LefDefParser::lefiViaRule::numProps(param_2), pFVar1 = fout,
local_24 < iVar3; local_24 = local_24 + 1) {
uVar4 = LefDefParser::lefiViaRule::name(param_2);
uVar7 = LefDefParser::lefiViaRule::propName(param_2,local_24);
fprintf(pFVar1,"VIARULE %s PROP %s ",uVar4,uVar7);
lVar8 = LefDefParser::lefiViaRule::propValue(param_2,local_24);
pFVar1 = fout;
if (lVar8 != 0) {
uVar4 = LefDefParser::lefiViaRule::propValue(param_2,local_24);
fprintf(pFVar1,"%s ",uVar4);
}
uVar2 = LefDefParser::lefiViaRule::propType(param_2,local_24);
switch(uVar2) {
case 0x49:
fprintf(fout,"INTEGER ");
break;
case 0x4e:
fprintf(fout,"NUMBER ");
break;
case 0x51:
fprintf(fout,"QUOTESTRING ");
break;
case 0x52:
fprintf(fout,"REAL ");
break;
case 0x53:
fprintf(fout,"STRING ");
}
}
}
return 0;
}
| |
26,052 | madb_get_os_character_set | eloqsql/libmariadb/libmariadb/ma_charset.c | const char *madb_get_os_character_set()
{
unsigned int i= 0;
char *p= NULL;
#ifdef _WIN32
char codepage[FN_REFLEN];
snprintf(codepage, FN_REFLEN, "%u", GetConsoleCP() ? GetConsoleCP() : GetACP());
p= codepage;
#elif defined(HAVE_NL_LANGINFO) && defined(HAVE_SETLOCALE)
if (setlocale(LC_CTYPE, ""))
p= nl_langinfo(CODESET);
#endif
if (!p)
return MADB_DEFAULT_CHARSET_NAME;
while (MADB_OS_CHARSET[i].identifier)
{
if (MADB_OS_CHARSET[i].supported > MADB_CS_UNSUPPORTED &&
strcasecmp(MADB_OS_CHARSET[i].identifier, p) == 0)
return MADB_OS_CHARSET[i].charset;
i++;
}
return MADB_DEFAULT_CHARSET_NAME;
} | O0 | c | madb_get_os_character_set:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
xorl %edi, %edi
leaq 0x36bb2(%rip), %rsi # 0x532f2
callq 0x174f0
cmpq $0x0, %rax
je 0x1c759
movl $0xe, %edi
callq 0x175a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1c770
leaq 0x33af9(%rip), %rax # 0x50260
movq %rax, -0x8(%rbp)
jmp 0x1c801
jmp 0x1c772
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x45b12(%rip), %rax # 0x62290
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x1c7f6
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x45af9(%rip), %rax # 0x62290
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movzbl 0x20(%rax), %eax
cmpl $0x0, %eax
jle 0x1c7e8
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x45add(%rip), %rax # 0x62290
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x17660
cmpl $0x0, %eax
jne 0x1c7e8
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x45ab9(%rip), %rax # 0x62290
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c801
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1c772
leaq 0x33a63(%rip), %rax # 0x50260
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| madb_get_os_character_set:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_C], 0
mov [rbp+var_18], 0
xor edi, edi
lea rsi, asc_532F0+2; ""
call _setlocale
cmp rax, 0
jz short loc_1C759
mov edi, 0Eh
call _nl_langinfo
mov [rbp+var_18], rax
loc_1C759:
cmp [rbp+var_18], 0
jnz short loc_1C770
lea rax, aLatin1; "latin1"
mov [rbp+var_8], rax
jmp loc_1C801
loc_1C770:
jmp short $+2
loc_1C772:
mov eax, [rbp+var_C]
mov ecx, eax
lea rax, MADB_OS_CHARSET
imul rcx, 28h ; '('
add rax, rcx
cmp qword ptr [rax], 0
jz short loc_1C7F6
mov eax, [rbp+var_C]
mov ecx, eax
lea rax, MADB_OS_CHARSET
imul rcx, 28h ; '('
add rax, rcx
movzx eax, byte ptr [rax+20h]
cmp eax, 0
jle short loc_1C7E8
mov eax, [rbp+var_C]
mov ecx, eax
lea rax, MADB_OS_CHARSET
imul rcx, 28h ; '('
add rax, rcx
mov rdi, [rax]
mov rsi, [rbp+var_18]
call _strcasecmp
cmp eax, 0
jnz short loc_1C7E8
mov eax, [rbp+var_C]
mov ecx, eax
lea rax, MADB_OS_CHARSET
imul rcx, 28h ; '('
add rax, rcx
mov rax, [rax+10h]
mov [rbp+var_8], rax
jmp short loc_1C801
loc_1C7E8:
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
jmp loc_1C772
loc_1C7F6:
lea rax, aLatin1; "latin1"
mov [rbp+var_8], rax
loc_1C801:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| const char *madb_get_os_character_set()
{
long long v1; // [rsp+8h] [rbp-18h]
unsigned int v2; // [rsp+14h] [rbp-Ch]
v2 = 0;
v1 = 0LL;
if ( setlocale(0LL, "") )
v1 = nl_langinfo(14LL);
if ( !v1 )
return "latin1";
while ( *(&MADB_OS_CHARSET + 5 * v2) )
{
if ( *((_BYTE *)&MADB_OS_CHARSET + 40 * v2 + 32) && !(unsigned int)strcasecmp(*(&MADB_OS_CHARSET + 5 * v2), v1) )
return (const char *)*(&MADB_OS_CHARSET + 5 * v2 + 2);
++v2;
}
return "latin1";
}
| madb_get_os_character_set:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0xc],0x0
MOV qword ptr [RBP + -0x18],0x0
XOR EDI,EDI
LEA RSI,[0x1532f2]
CALL 0x001174f0
CMP RAX,0x0
JZ 0x0011c759
MOV EDI,0xe
CALL 0x001175a0
MOV qword ptr [RBP + -0x18],RAX
LAB_0011c759:
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x0011c770
LEA RAX,[0x150260]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0011c801
LAB_0011c770:
JMP 0x0011c772
LAB_0011c772:
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
LEA RAX,[0x162290]
IMUL RCX,RCX,0x28
ADD RAX,RCX
CMP qword ptr [RAX],0x0
JZ 0x0011c7f6
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
LEA RAX,[0x162290]
IMUL RCX,RCX,0x28
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX + 0x20]
CMP EAX,0x0
JLE 0x0011c7e8
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
LEA RAX,[0x162290]
IMUL RCX,RCX,0x28
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00117660
CMP EAX,0x0
JNZ 0x0011c7e8
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
LEA RAX,[0x162290]
IMUL RCX,RCX,0x28
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0011c801
LAB_0011c7e8:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x0011c772
LAB_0011c7f6:
LEA RAX,[0x150260]
MOV qword ptr [RBP + -0x8],RAX
LAB_0011c801:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
char * madb_get_os_character_set(void)
{
int iVar1;
char *pcVar2;
char *local_20;
uint local_14;
char *local_10;
local_14 = 0;
local_20 = (char *)0x0;
pcVar2 = setlocale(0,"");
if (pcVar2 != (char *)0x0) {
local_20 = nl_langinfo(0xe);
}
if (local_20 != (char *)0x0) {
while (*(long *)(MADB_OS_CHARSET + (ulong)local_14 * 0x28) != 0) {
if ((MADB_OS_CHARSET[(ulong)local_14 * 0x28 + 0x20] != '\0') &&
(iVar1 = strcasecmp(*(char **)(MADB_OS_CHARSET + (ulong)local_14 * 0x28),local_20),
iVar1 == 0)) {
return *(char **)(MADB_OS_CHARSET + (ulong)local_14 * 0x28 + 0x10);
}
local_14 = local_14 + 1;
}
}
local_10 = "latin1";
return local_10;
}
| |
26,053 | my_hash_sort_utf8mb3 | eloqsql/strings/ctype-utf8.c | static void my_hash_sort_utf8mb3(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
/*
Remove end space. We have to do this to be able to compare
'A ' and 'A' as identical
*/
const uchar *e= skip_trailing_space(s, slen);
my_hash_sort_utf8mb3_nopad(cs, s, e - s, nr1, nr2);
} | O3 | c | my_hash_sort_utf8mb3:
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rdx), %r10
cmpq $0x15, %rdx
jb 0x6ff1f
movq %r10, %r9
andq $-0x4, %r9
cmpq %rsi, %r9
jbe 0x6ff1f
leaq 0x3(%rsi), %rdx
andq $-0x4, %rdx
movq %r10, %rax
movb -0x1(%r10), %r11b
cmpq %r9, %r10
jbe 0x6ff44
leaq -0x1(%rax), %r10
cmpb $0x20, %r11b
je 0x6ff07
jmp 0x6ff22
movq %r10, %rax
movq %rax, %r9
subq %rsi, %r9
movq %r9, %rdx
cmpq %rsi, %rax
jbe 0x6ff3e
cmpb $0x20, -0x1(%rax)
leaq -0x1(%rax), %rax
leaq -0x1(%rdx), %r9
je 0x6ff28
popq %rbp
jmp 0x70129
cmpb $0x20, %r11b
setne %r10b
cmpq %r9, %rdx
setae %r9b
orb %r10b, %r9b
jne 0x6ff22
movq %rax, %r9
movq %r9, %rax
cmpq %rdx, %r9
jbe 0x6ff22
leaq -0x4(%rax), %r9
cmpl $0x20202020, -0x4(%rax) # imm = 0x20202020
je 0x6ff5b
jmp 0x6ff22
| my_hash_sort_utf8mb3:
push rbp
mov rbp, rsp
lea r10, [rsi+rdx]
cmp rdx, 15h
jb short loc_6FF1F
mov r9, r10
and r9, 0FFFFFFFFFFFFFFFCh
cmp r9, rsi
jbe short loc_6FF1F
lea rdx, [rsi+3]
and rdx, 0FFFFFFFFFFFFFFFCh
loc_6FF07:
mov rax, r10
mov r11b, [r10-1]
cmp r10, r9
jbe short loc_6FF44
lea r10, [rax-1]
cmp r11b, 20h ; ' '
jz short loc_6FF07
jmp short loc_6FF22
loc_6FF1F:
mov rax, r10
loc_6FF22:
mov r9, rax
sub r9, rsi
loc_6FF28:
mov rdx, r9
cmp rax, rsi
jbe short loc_6FF3E
cmp byte ptr [rax-1], 20h ; ' '
lea rax, [rax-1]
lea r9, [rdx-1]
jz short loc_6FF28
loc_6FF3E:
pop rbp
jmp my_hash_sort_utf8mb3_nopad
loc_6FF44:
cmp r11b, 20h ; ' '
setnz r10b
cmp rdx, r9
setnb r9b
or r9b, r10b
jnz short loc_6FF22
mov r9, rax
loc_6FF5B:
mov rax, r9
cmp r9, rdx
jbe short loc_6FF22
lea r9, [rax-4]
cmp dword ptr [rax-4], 20202020h
jz short loc_6FF5B
jmp short loc_6FF22
| long long my_hash_sort_utf8mb3(long long a1, unsigned long long a2, unsigned long long a3, long long a4, long long a5)
{
unsigned long long v5; // r10
unsigned long long v6; // r9
unsigned long long v7; // rdx
unsigned long long v8; // rax
char v9; // r11
unsigned long long v10; // r9
unsigned long long v11; // rdx
bool v12; // zf
unsigned long long v14; // r9
v5 = a2 + a3;
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= a2) )
{
v8 = a2 + a3;
}
else
{
v7 = (a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v14 = v5;
do
{
v8 = v14;
if ( v14 <= v7 )
break;
v14 -= 4LL;
}
while ( *(_DWORD *)(v8 - 4) == 538976288 );
}
}
LABEL_8:
v10 = v8 - a2;
do
{
v11 = v10;
if ( v8 <= a2 )
break;
v12 = *(_BYTE *)--v8 == 32;
--v10;
}
while ( v12 );
return my_hash_sort_utf8mb3_nopad(a1, a2, v11, a4, a5, v10);
}
| my_hash_sort_utf8mb3:
PUSH RBP
MOV RBP,RSP
LEA R10,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x0016ff1f
MOV R9,R10
AND R9,-0x4
CMP R9,RSI
JBE 0x0016ff1f
LEA RDX,[RSI + 0x3]
AND RDX,-0x4
LAB_0016ff07:
MOV RAX,R10
MOV R11B,byte ptr [R10 + -0x1]
CMP R10,R9
JBE 0x0016ff44
LEA R10,[RAX + -0x1]
CMP R11B,0x20
JZ 0x0016ff07
JMP 0x0016ff22
LAB_0016ff1f:
MOV RAX,R10
LAB_0016ff22:
MOV R9,RAX
SUB R9,RSI
LAB_0016ff28:
MOV RDX,R9
CMP RAX,RSI
JBE 0x0016ff3e
CMP byte ptr [RAX + -0x1],0x20
LEA RAX,[RAX + -0x1]
LEA R9,[RDX + -0x1]
JZ 0x0016ff28
LAB_0016ff3e:
POP RBP
JMP 0x00170129
LAB_0016ff44:
CMP R11B,0x20
SETNZ R10B
CMP RDX,R9
SETNC R9B
OR R9B,R10B
JNZ 0x0016ff22
MOV R9,RAX
LAB_0016ff5b:
MOV RAX,R9
CMP R9,RDX
JBE 0x0016ff22
LEA R9,[RAX + -0x4]
CMP dword ptr [RAX + -0x4],0x20202020
JZ 0x0016ff5b
JMP 0x0016ff22
|
void my_hash_sort_utf8mb3(int8 param_1,ulong param_2,ulong param_3)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
uVar3 = param_2 + param_3;
if ((0x14 < param_3) && (uVar5 = uVar3 & 0xfffffffffffffffc, param_2 < uVar5)) {
uVar4 = param_2 + 3 & 0xfffffffffffffffc;
uVar2 = uVar3;
do {
uVar3 = uVar2;
if (uVar3 <= uVar5) {
uVar2 = uVar3;
if (uVar4 < uVar5 && *(char *)(uVar3 - 1) == ' ') goto LAB_0016ff5b;
break;
}
uVar2 = uVar3 - 1;
} while (*(char *)(uVar3 - 1) == ' ');
}
goto LAB_0016ff28;
while (uVar2 = uVar3 - 4, *(int *)(uVar3 - 4) == 0x20202020) {
LAB_0016ff5b:
uVar3 = uVar2;
if (uVar3 <= uVar4) break;
}
LAB_0016ff28:
do {
if (uVar3 <= param_2) break;
pcVar1 = (char *)(uVar3 - 1);
uVar3 = uVar3 - 1;
} while (*pcVar1 == ' ');
my_hash_sort_utf8mb3_nopad();
return;
}
| |
26,054 | minja::Expression::evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | Value evaluate(const std::shared_ptr<Context> & context) const {
try {
return do_evaluate(context);
} catch (const std::exception & e) {
std::ostringstream out;
out << e.what();
if (location.source) out << error_location_suffix(*location.source, location.pos);
throw std::runtime_error(out.str());
}
} | O3 | cpp | minja::Expression::evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
callq *(%rax)
movq %rbx, %rax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x85ece
movq %rbx, %rdi
callq 0x1a390
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1abb0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x1a890
movq 0x8(%r14), %rsi
testq %rsi, %rsi
jne 0x85e0d
movl $0x10, %edi
callq 0x1a450
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1ade0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1ae50
xorl %ebp, %ebp
movq 0xa61f2(%rip), %rsi # 0x12bff0
movq 0xa615b(%rip), %rdx # 0x12bf60
movq %r14, %rdi
callq 0x1af40
movq 0x18(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x778f4
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x1aa00
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x85dc9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a8d0
jmp 0x85dc9
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x85ea6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a8d0
jmp 0x85ea6
jmp 0x85ea3
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x85e8f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a8d0
testb %bpl, %bpl
jne 0x85e99
jmp 0x85ea6
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a680
jmp 0x85ea6
movq %rax, %rbx
movq 0xa60cb(%rip), %rsi # 0x12bf78
leaq 0x28(%rsp), %rdi
callq 0x1a4b0
leaq 0x98(%rsp), %rdi
callq 0x1a2c0
jmp 0x85ec9
movq %rax, %rbx
callq 0x1ae80
movq %rbx, %rdi
callq 0x1afc0
movq %rax, %rdi
callq 0x21aaf
| _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r14
push rbx
sub rsp, 1A0h
mov r14, rsi
mov rbx, rdi
mov rax, [rsi]
call qword ptr [rax]
mov rax, rbx
add rsp, 1A0h
pop rbx
pop r14
pop rbp
retn
mov rbx, rax
cmp edx, 1
jnz loc_85ECE
mov rdi, rbx; void *
call ___cxa_begin_catch
mov rbx, rax
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+10h]
lea rdi, [rsp+arg_20]
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rsi, [r14+8]; int
test rsi, rsi
jnz short loc_85E0D
loc_85DC9:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, [rsp+arg_28]
lea rdi, [rsp+arg_0]
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov bpl, 1
lea rsi, [rsp+arg_0]
mov rdi, r14
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, r14; void *
call ___cxa_throw
loc_85E0D:
mov rdx, [r14+18h]; int
lea rdi, [rsp+arg_0]; int
call _ZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; minja::error_location_suffix(std::string const&,ulong)
mov rsi, qword ptr [rsp+arg_0]
mov rdx, [rsp+arg_8]
lea rdi, [rsp+arg_20]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_85DC9
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_85DC9
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_85EA6
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_85EA6
jmp short loc_85EA3
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_85E8F
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_85E8F:
test bpl, bpl
jnz short loc_85E99
jmp short loc_85EA6
mov rbx, rax
loc_85E99:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_85EA6
loc_85EA3:
mov rbx, rax
loc_85EA6:
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+arg_90]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
jmp short loc_85EC9
mov rbx, rax
loc_85EC9:
call ___cxa_end_catch
loc_85ECE:
mov rdi, rbx
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long minja::Expression::evaluate(long long a1, void (***a2)(void))
{
(**a2)();
return a1;
}
| evaluate:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x1a0
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI]
LAB_00185d78:
CALL qword ptr [RAX]
LAB_00185d7a:
MOV RAX,RBX
ADD RSP,0x1a0
POP RBX
POP R14
POP RBP
RET
|
/* minja::Expression::evaluate(std::shared_ptr<minja::Context> const&) const */
Expression * __thiscall minja::Expression::evaluate(Expression *this,shared_ptr *param_1)
{
/* try { // try from 00185d78 to 00185d79 has its CatchHandler @ 00185d89 */
(*(code *)**(int8 **)param_1)();
return this;
}
| |
26,055 | emit_source_loc | bluesky950520[P]quickjs/quickjs.c | static void emit_source_loc(JSParseState *s)
{
JSFunctionDef *fd = s->cur_func;
DynBuf *bc = &fd->byte_code;
dbuf_putc(bc, OP_source_loc);
dbuf_put_u32(bc, s->last_line_num);
dbuf_put_u32(bc, s->last_col_num);
} | O1 | c | emit_source_loc:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x138, %r14d # imm = 0x138
addq 0x90(%rdi), %r14
movq %r14, %rdi
movl $0xc4, %esi
callq 0x1f52c
movl 0x8(%rbx), %eax
movq %rsp, %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %r14, %rdi
callq 0x1f47e
movl 0xc(%rbx), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %r14, %rdi
callq 0x1f47e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| emit_source_loc:
push r14
push rbx
push rax
mov rbx, rdi
mov r14d, 138h
add r14, [rdi+90h]
mov rdi, r14
mov esi, 0C4h
call dbuf_putc
mov eax, [rbx+8]
mov rsi, rsp
mov [rsi], eax
mov edx, 4
mov rdi, r14
call dbuf_put
mov eax, [rbx+0Ch]
lea rsi, [rsp+18h+var_14]
mov [rsi], eax
mov edx, 4
mov rdi, r14
call dbuf_put
add rsp, 8
pop rbx
pop r14
retn
| long long emit_source_loc(long long a1)
{
long long v1; // rax
_QWORD *v2; // r14
_QWORD v4[3]; // [rsp-4h] [rbp-18h] BYREF
v4[0] = v1;
v2 = (_QWORD *)(*(_QWORD *)(a1 + 144) + 312LL);
dbuf_putc(v2, 196);
LODWORD(v4[0]) = *(_DWORD *)(a1 + 8);
dbuf_put(v2, (long long)v4, 4LL);
HIDWORD(v4[0]) = *(_DWORD *)(a1 + 12);
return dbuf_put(v2, (long long)v4 + 4, 4LL);
}
| emit_source_loc:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14D,0x138
ADD R14,qword ptr [RDI + 0x90]
MOV RDI,R14
MOV ESI,0xc4
CALL 0x0011f52c
MOV EAX,dword ptr [RBX + 0x8]
MOV RSI,RSP
MOV dword ptr [RSI],EAX
MOV EDX,0x4
MOV RDI,R14
CALL 0x0011f47e
MOV EAX,dword ptr [RBX + 0xc]
LEA RSI,[RSP + 0x4]
MOV dword ptr [RSI],EAX
MOV EDX,0x4
MOV RDI,R14
CALL 0x0011f47e
ADD RSP,0x8
POP RBX
POP R14
RET
|
void emit_source_loc(long param_1)
{
int8 in_RAX;
long lVar1;
int4 local_18;
int4 local_14;
local_14 = (int4)((ulong)in_RAX >> 0x20);
lVar1 = *(long *)(param_1 + 0x90) + 0x138;
dbuf_putc(lVar1,0xc4);
_local_18 = CONCAT44(local_14,*(int4 *)(param_1 + 8));
dbuf_put(lVar1,&local_18,4);
_local_18 = CONCAT44(*(int4 *)(param_1 + 0xc),local_18);
dbuf_put(lVar1,&local_14,4);
return;
}
| |
26,056 | string_get_milliseconds | bluesky950520[P]quickjs/quickjs.c | static BOOL string_get_milliseconds(const uint8_t *sp, int *pp, int *pval) {
/* parse optional fractional part as milliseconds and truncate. */
/* spec does not indicate which rounding should be used */
int mul = 100, ms = 0, c, p_start, p = *pp;
c = sp[p];
if (c == '.' || c == ',') {
p++;
p_start = p;
while ((c = sp[p]) >= '0' && c <= '9') {
ms += (c - '0') * mul;
mul /= 10;
p++;
if (p - p_start == 9)
break;
}
if (p > p_start) {
/* only consume the separator if digits are present */
*pval = ms;
*pp = p;
}
}
return TRUE;
} | O1 | c | string_get_milliseconds:
movslq (%rsi), %rax
movb (%rdi,%rax), %cl
andb $-0x3, %cl
cmpb $0x2c, %cl
jne 0x5810a
pushq %rbx
leal 0x1(%rax), %ecx
movslq %ecx, %r8
addl $0xa, %eax
addq %r8, %rdi
movl $0x64, %r10d
xorl %r9d, %r9d
xorl %r8d, %r8d
movzbl (%rdi,%r9), %r11d
leal -0x30(%r11), %ebx
cmpb $0x9, %bl
ja 0x580fa
addl $-0x30, %r11d
imull %r10d, %r11d
addl %r11d, %r8d
movslq %r10d, %r10
imulq $0x66666667, %r10, %r10 # imm = 0x66666667
movq %r10, %r11
shrq $0x3f, %r11
sarq $0x22, %r10
addl %r11d, %r10d
incq %r9
cmpl $0x9, %r9d
jne 0x580be
jmp 0x58100
addl %ecx, %r9d
movl %r9d, %eax
cmpl %ecx, %eax
jle 0x58109
movl %r8d, (%rdx)
movl %eax, (%rsi)
popq %rbx
retq
| string_get_milliseconds:
movsxd rax, dword ptr [rsi]
mov cl, [rdi+rax]
and cl, 0FDh
cmp cl, 2Ch ; ','
jnz short locret_5810A
push rbx
lea ecx, [rax+1]
movsxd r8, ecx
add eax, 0Ah
add rdi, r8
mov r10d, 64h ; 'd'
xor r9d, r9d
xor r8d, r8d
loc_580BE:
movzx r11d, byte ptr [rdi+r9]
lea ebx, [r11-30h]
cmp bl, 9
ja short loc_580FA
add r11d, 0FFFFFFD0h
imul r11d, r10d
add r8d, r11d
movsxd r10, r10d
imul r10, 66666667h
mov r11, r10
shr r11, 3Fh
sar r10, 22h
add r10d, r11d
inc r9
cmp r9d, 9
jnz short loc_580BE
jmp short loc_58100
loc_580FA:
add r9d, ecx
mov eax, r9d
loc_58100:
cmp eax, ecx
jle short loc_58109
mov [rdx], r8d
mov [rsi], eax
loc_58109:
pop rbx
locret_5810A:
retn
| long long string_get_milliseconds(long long a1, int *a2, _DWORD *a3)
{
long long result; // rax
int v4; // ecx
long long v5; // rdi
int v6; // r10d
long long v7; // r9
int v8; // r8d
int v9; // r11d
result = *a2;
if ( (*(_BYTE *)(a1 + result) & 0xFD) == 0x2C )
{
v4 = result + 1;
result = (unsigned int)(result + 10);
v5 = v4 + a1;
v6 = 100;
v7 = 0LL;
v8 = 0;
while ( 1 )
{
v9 = *(unsigned __int8 *)(v5 + v7);
if ( (unsigned __int8)(v9 - 48) > 9u )
break;
v8 += v6 * (v9 - 48);
v6 /= 10;
if ( (_DWORD)++v7 == 9 )
goto LABEL_7;
}
result = (unsigned int)(v4 + v7);
LABEL_7:
if ( (int)result > v4 )
{
*a3 = v8;
*a2 = result;
}
}
return result;
}
| string_get_milliseconds:
MOVSXD RAX,dword ptr [RSI]
MOV CL,byte ptr [RDI + RAX*0x1]
AND CL,0xfd
CMP CL,0x2c
JNZ 0x0015810a
PUSH RBX
LEA ECX,[RAX + 0x1]
MOVSXD R8,ECX
ADD EAX,0xa
ADD RDI,R8
MOV R10D,0x64
XOR R9D,R9D
XOR R8D,R8D
LAB_001580be:
MOVZX R11D,byte ptr [RDI + R9*0x1]
LEA EBX,[R11 + -0x30]
CMP BL,0x9
JA 0x001580fa
ADD R11D,-0x30
IMUL R11D,R10D
ADD R8D,R11D
MOVSXD R10,R10D
IMUL R10,R10,0x66666667
MOV R11,R10
SHR R11,0x3f
SAR R10,0x22
ADD R10D,R11D
INC R9
CMP R9D,0x9
JNZ 0x001580be
JMP 0x00158100
LAB_001580fa:
ADD R9D,ECX
MOV EAX,R9D
LAB_00158100:
CMP EAX,ECX
JLE 0x00158109
MOV dword ptr [RDX],R8D
MOV dword ptr [RSI],EAX
LAB_00158109:
POP RBX
LAB_0015810a:
RET
|
void string_get_milliseconds(long param_1,int *param_2,int *param_3)
{
byte bVar1;
int iVar2;
int iVar3;
int iVar4;
long lVar5;
int iVar6;
iVar2 = *param_2;
if ((*(byte *)(param_1 + iVar2) & 0xfd) == 0x2c) {
iVar3 = iVar2 + 1;
iVar2 = iVar2 + 10;
iVar6 = 100;
lVar5 = 0;
iVar4 = 0;
do {
bVar1 = *(byte *)(param_1 + iVar3 + lVar5);
if (9 < (byte)(bVar1 - 0x30)) {
iVar2 = (int)lVar5 + iVar3;
break;
}
iVar4 = iVar4 + (bVar1 - 0x30) * iVar6;
iVar6 = iVar6 / 10;
lVar5 = lVar5 + 1;
} while ((int)lVar5 != 9);
if (iVar3 < iVar2) {
*param_3 = iVar4;
*param_2 = iVar2;
}
}
return;
}
| |
26,057 | string_get_milliseconds | bluesky950520[P]quickjs/quickjs.c | static BOOL string_get_milliseconds(const uint8_t *sp, int *pp, int *pval) {
/* parse optional fractional part as milliseconds and truncate. */
/* spec does not indicate which rounding should be used */
int mul = 100, ms = 0, c, p_start, p = *pp;
c = sp[p];
if (c == '.' || c == ',') {
p++;
p_start = p;
while ((c = sp[p]) >= '0' && c <= '9') {
ms += (c - '0') * mul;
mul /= 10;
p++;
if (p - p_start == 9)
break;
}
if (p > p_start) {
/* only consume the separator if digits are present */
*pval = ms;
*pp = p;
}
}
return TRUE;
} | O2 | c | string_get_milliseconds:
movslq (%rsi), %r8
movb (%rdi,%r8), %al
andb $-0x3, %al
cmpb $0x2c, %al
jne 0x4b4e0
pushq %rbp
pushq %rbx
movq %rdx, %rcx
leal 0x1(%r8), %r9d
movslq %r9d, %rax
addl $0xa, %r8d
addq %rax, %rdi
movl $0x64, %eax
xorl %r11d, %r11d
movl $0xa, %ebx
xorl %r10d, %r10d
movzbl (%rdi,%r11), %edx
leal -0x30(%rdx), %ebp
cmpb $0x9, %bpl
ja 0x4b4cd
addl $-0x30, %edx
imull %eax, %edx
addl %edx, %r10d
cltd
idivl %ebx
incq %r11
cmpl $0x9, %r11d
jne 0x4b4a8
jmp 0x4b4d3
addl %r9d, %r11d
movl %r11d, %r8d
cmpl %r9d, %r8d
jle 0x4b4de
movl %r10d, (%rcx)
movl %r8d, (%rsi)
popq %rbx
popq %rbp
retq
| string_get_milliseconds:
movsxd r8, dword ptr [rsi]
mov al, [rdi+r8]
and al, 0FDh
cmp al, 2Ch ; ','
jnz short locret_4B4E0
push rbp
push rbx
mov rcx, rdx
lea r9d, [r8+1]
movsxd rax, r9d
add r8d, 0Ah
add rdi, rax
mov eax, 64h ; 'd'
xor r11d, r11d
mov ebx, 0Ah
xor r10d, r10d
loc_4B4A8:
movzx edx, byte ptr [rdi+r11]
lea ebp, [rdx-30h]
cmp bpl, 9
ja short loc_4B4CD
add edx, 0FFFFFFD0h
imul edx, eax
add r10d, edx
cdq
idiv ebx
inc r11
cmp r11d, 9
jnz short loc_4B4A8
jmp short loc_4B4D3
loc_4B4CD:
add r11d, r9d
mov r8d, r11d
loc_4B4D3:
cmp r8d, r9d
jle short loc_4B4DE
mov [rcx], r10d
mov [rsi], r8d
loc_4B4DE:
pop rbx
pop rbp
locret_4B4E0:
retn
| char string_get_milliseconds(long long a1, int *a2, _DWORD *a3)
{
long long v3; // r8
int v4; // eax
int v6; // r9d
int v7; // r8d
long long v8; // rdi
long long v9; // r11
int v10; // r10d
int v11; // edx
v3 = *a2;
LOBYTE(v4) = *(_BYTE *)(a1 + v3) & 0xFD;
if ( (_BYTE)v4 == 44 )
{
v6 = v3 + 1;
v7 = v3 + 10;
v8 = v6 + a1;
v4 = 100;
v9 = 0LL;
v10 = 0;
while ( 1 )
{
v11 = *(unsigned __int8 *)(v8 + v9);
if ( (unsigned __int8)(v11 - 48) > 9u )
break;
v10 += v4 * (v11 - 48);
v4 /= 10;
if ( (_DWORD)++v9 == 9 )
goto LABEL_7;
}
v7 = v6 + v9;
LABEL_7:
if ( v7 > v6 )
{
*a3 = v10;
*a2 = v7;
}
}
return v4;
}
| string_get_milliseconds:
MOVSXD R8,dword ptr [RSI]
MOV AL,byte ptr [RDI + R8*0x1]
AND AL,0xfd
CMP AL,0x2c
JNZ 0x0014b4e0
PUSH RBP
PUSH RBX
MOV RCX,RDX
LEA R9D,[R8 + 0x1]
MOVSXD RAX,R9D
ADD R8D,0xa
ADD RDI,RAX
MOV EAX,0x64
XOR R11D,R11D
MOV EBX,0xa
XOR R10D,R10D
LAB_0014b4a8:
MOVZX EDX,byte ptr [RDI + R11*0x1]
LEA EBP,[RDX + -0x30]
CMP BPL,0x9
JA 0x0014b4cd
ADD EDX,-0x30
IMUL EDX,EAX
ADD R10D,EDX
CDQ
IDIV EBX
INC R11
CMP R11D,0x9
JNZ 0x0014b4a8
JMP 0x0014b4d3
LAB_0014b4cd:
ADD R11D,R9D
MOV R8D,R11D
LAB_0014b4d3:
CMP R8D,R9D
JLE 0x0014b4de
MOV dword ptr [RCX],R10D
MOV dword ptr [RSI],R8D
LAB_0014b4de:
POP RBX
POP RBP
LAB_0014b4e0:
RET
|
void string_get_milliseconds(long param_1,int *param_2,int *param_3)
{
byte bVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
long lVar6;
iVar3 = *param_2;
if ((*(byte *)(param_1 + iVar3) & 0xfd) == 0x2c) {
iVar4 = iVar3 + 1;
iVar3 = iVar3 + 10;
iVar2 = 100;
lVar6 = 0;
iVar5 = 0;
do {
bVar1 = *(byte *)(param_1 + iVar4 + lVar6);
if (9 < (byte)(bVar1 - 0x30)) {
iVar3 = (int)lVar6 + iVar4;
break;
}
iVar5 = iVar5 + (bVar1 - 0x30) * iVar2;
iVar2 = iVar2 / 10;
lVar6 = lVar6 + 1;
} while ((int)lVar6 != 9);
if (iVar4 < iVar3) {
*param_3 = iVar5;
*param_2 = iVar3;
}
}
return;
}
| |
26,058 | my_well_formed_char_length_ucs2 | eloqsql/strings/ctype-ucs2.c | static size_t
my_well_formed_char_length_ucs2(CHARSET_INFO *cs __attribute__((unused)),
const char *b, const char *e,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t length= e - b;
if (nchars * 2 <= length)
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= b + (nchars * 2);
return nchars;
}
if (length % 2)
{
status->m_well_formed_error_pos= status->m_source_end_pos= e - 1;
}
else
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= e;
}
return length / 2;
} | O3 | c | my_well_formed_char_length_ucs2:
pushq %rbp
movq %rsp, %rbp
movq %rcx, %rax
movq %rdx, %rcx
subq %rsi, %rcx
leaq (%rax,%rax), %rdi
cmpq %rcx, %rdi
jbe 0xc53e3
movl %ecx, %eax
andl $0x1, %eax
movq %rax, %rsi
negq %rsi
leaq -0x1(%rdx), %rdi
andq %rdi, %rsi
testq %rax, %rax
cmoveq %rdx, %rdi
movq %rsi, 0x8(%r8)
movq %rdi, (%r8)
shrq %rcx
movq %rcx, %rax
jmp 0xc53f1
movq $0x0, 0x8(%r8)
addq %rdi, %rsi
movq %rsi, (%r8)
popq %rbp
retq
| my_well_formed_char_length_ucs2:
push rbp
mov rbp, rsp
mov rax, rcx
mov rcx, rdx
sub rcx, rsi
lea rdi, [rax+rax]
cmp rdi, rcx
jbe short loc_C53E3
mov eax, ecx
and eax, 1
mov rsi, rax
neg rsi
lea rdi, [rdx-1]
and rsi, rdi
test rax, rax
cmovz rdi, rdx
mov [r8+8], rsi
mov [r8], rdi
shr rcx, 1
mov rax, rcx
jmp short loc_C53F1
loc_C53E3:
mov qword ptr [r8+8], 0
add rsi, rdi
mov [r8], rsi
loc_C53F1:
pop rbp
retn
| unsigned long long my_well_formed_char_length_ucs2(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
_QWORD *a5)
{
unsigned long long result; // rax
unsigned long long v6; // rcx
long long v7; // rdi
result = a4;
v6 = a3 - a2;
if ( 2 * result <= a3 - a2 )
{
a5[1] = 0LL;
*a5 = 2 * result + a2;
}
else
{
v7 = a3 - 1;
if ( (v6 & 1) == 0 )
v7 = a3;
a5[1] = (a3 - 1) & -(long long)(v6 & 1);
*a5 = v7;
return v6 >> 1;
}
return result;
}
| my_well_formed_char_length_ucs2:
PUSH RBP
MOV RBP,RSP
MOV RAX,RCX
MOV RCX,RDX
SUB RCX,RSI
LEA RDI,[RAX + RAX*0x1]
CMP RDI,RCX
JBE 0x001c53e3
MOV EAX,ECX
AND EAX,0x1
MOV RSI,RAX
NEG RSI
LEA RDI,[RDX + -0x1]
AND RSI,RDI
TEST RAX,RAX
CMOVZ RDI,RDX
MOV qword ptr [R8 + 0x8],RSI
MOV qword ptr [R8],RDI
SHR RCX,0x1
MOV RAX,RCX
JMP 0x001c53f1
LAB_001c53e3:
MOV qword ptr [R8 + 0x8],0x0
ADD RSI,RDI
MOV qword ptr [R8],RSI
LAB_001c53f1:
POP RBP
RET
|
ulong my_well_formed_char_length_ucs2
(int8 param_1,long param_2,ulong param_3,ulong param_4,ulong *param_5)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
uVar2 = param_3 - param_2;
if (uVar2 < param_4 * 2) {
uVar1 = (ulong)((uint)uVar2 & 1);
uVar3 = param_3 - 1;
if (uVar1 == 0) {
uVar3 = param_3;
}
param_5[1] = -uVar1 & param_3 - 1;
*param_5 = uVar3;
param_4 = uVar2 >> 1;
}
else {
param_5[1] = 0;
*param_5 = param_2 + param_4 * 2;
}
return param_4;
}
| |
26,059 | ma_print_error | eloqsql/storage/maria/ma_info.c | void _ma_print_error(MARIA_HA *info, int error, my_bool write_to_log)
{
DBUG_ENTER("_ma_print_error");
DBUG_PRINT("error", ("error: %d log: %d", error, write_to_log));
if (!info->error_count++ || !maria_in_ha_maria || write_to_log)
{
MARIA_SHARE *share= info->s;
_ma_report_error(error,
(share->index_file_name.length ?
&share->index_file_name :
&share->unique_file_name),
MYF(write_to_log ? ME_ERROR_LOG : 0));
}
DBUG_VOID_RETURN;
} | O3 | c | ma_print_error:
pushq %rbp
movq %rsp, %rbp
movl 0x628(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x628(%rdi)
testb %dl, %dl
jne 0x5ca7b
testl %eax, %eax
je 0x5ca7b
leaq 0x3c8418(%rip), %rax # 0x424e8c
cmpb $0x0, (%rax)
je 0x5ca7b
popq %rbp
retq
xorl %eax, %eax
testb %dl, %dl
setne %al
movq (%rdi), %rcx
xorl %edx, %edx
cmpq $0x0, 0x5d8(%rcx)
setne %dl
shll $0x5, %edx
addq %rdx, %rcx
addq $0x5b0, %rcx # imm = 0x5B0
shll $0x6, %eax
movl %esi, %edi
movq %rcx, %rsi
movq %rax, %rdx
popq %rbp
jmp 0x5c9f4
| _ma_print_error:
push rbp
mov rbp, rsp
mov eax, [rdi+628h]
lea ecx, [rax+1]
mov [rdi+628h], ecx
test dl, dl
jnz short loc_5CA7B
test eax, eax
jz short loc_5CA7B
lea rax, maria_in_ha_maria
cmp byte ptr [rax], 0
jz short loc_5CA7B
pop rbp
retn
loc_5CA7B:
xor eax, eax
test dl, dl
setnz al
mov rcx, [rdi]
xor edx, edx
cmp qword ptr [rcx+5D8h], 0
setnz dl
shl edx, 5
add rcx, rdx
add rcx, 5B0h
shl eax, 6
mov edi, esi
mov rsi, rcx
mov rdx, rax
pop rbp
jmp _ma_report_error
| void * ma_print_error(_DWORD *a1, int a2, char a3, long long a4, long long a5, int a6)
{
int v6; // eax
void *result; // rax
_QWORD *v8; // rcx
v6 = a1[394];
a1[394] = v6 + 1;
if ( a3 || !v6 || (result = &maria_in_ha_maria, !maria_in_ha_maria) )
{
v8 = (_QWORD *)(32 * (unsigned int)(*(_QWORD *)(*(_QWORD *)a1 + 1496LL) != 0LL) + *(_QWORD *)a1 + 1456LL);
return (void *)ma_report_error(a2, v8, (unsigned __int8)(a3 != 0) << 6, (long long)v8, a5, a6);
}
return result;
}
| _ma_print_error:
PUSH RBP
MOV RBP,RSP
MOV EAX,dword ptr [RDI + 0x628]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RDI + 0x628],ECX
TEST DL,DL
JNZ 0x0015ca7b
TEST EAX,EAX
JZ 0x0015ca7b
LEA RAX,[0x524e8c]
CMP byte ptr [RAX],0x0
JZ 0x0015ca7b
POP RBP
RET
LAB_0015ca7b:
XOR EAX,EAX
TEST DL,DL
SETNZ AL
MOV RCX,qword ptr [RDI]
XOR EDX,EDX
CMP qword ptr [RCX + 0x5d8],0x0
SETNZ DL
SHL EDX,0x5
ADD RCX,RDX
ADD RCX,0x5b0
SHL EAX,0x6
MOV EDI,ESI
MOV RSI,RCX
MOV RDX,RAX
POP RBP
JMP 0x0015c9f4
|
void _ma_print_error(long *param_1,int4 param_2,char param_3)
{
long lVar1;
lVar1 = param_1[0xc5];
*(int *)(param_1 + 0xc5) = (int)lVar1 + 1;
if (((param_3 == '\0') && ((int)lVar1 != 0)) && (maria_in_ha_maria != '\0')) {
return;
}
_ma_report_error(param_2,*param_1 + (ulong)(*(long *)(*param_1 + 0x5d8) != 0) * 0x20 + 0x5b0,
(ulong)(param_3 != '\0') << 6);
return;
}
| |
26,060 | ma_fcvt | eloqsql/libmariadb/libmariadb/ma_dtoa.c | size_t ma_fcvt(double x, int precision, char *to, my_bool *error)
{
int decpt, sign, len, i;
char *res, *src, *end, *dst= to;
char buf[DTOA_BUFF_SIZE];
DBUG_ASSERT(precision >= 0 && precision < NOT_FIXED_DEC && to != NULL);
res= dtoa(x, 5, precision, &decpt, &sign, &end, buf, sizeof(buf));
if (decpt == DTOA_OVERFLOW)
{
dtoa_free(res, buf, sizeof(buf));
*to++= '0';
*to= '\0';
if (error != NULL)
*error= TRUE;
return 1;
}
src= res;
len= (int)(end - src);
if (sign)
*dst++= '-';
if (decpt <= 0)
{
*dst++= '0';
*dst++= '.';
for (i= decpt; i < 0; i++)
*dst++= '0';
}
for (i= 1; i <= len; i++)
{
*dst++= *src++;
if (i == decpt && i < len)
*dst++= '.';
}
while (i++ <= decpt)
*dst++= '0';
if (precision > 0)
{
if (len <= decpt)
*dst++= '.';
for (i= precision - MAX(0, (len - decpt)); i > 0; i--)
*dst++= '0';
}
*dst= '\0';
if (error != NULL)
*error= FALSE;
dtoa_free(res, buf, sizeof(buf));
return dst - to;
} | O0 | c | ma_fcvt:
pushq %rbp
movq %rsp, %rbp
subq $0xee0, %rsp # imm = 0xEE0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movsd %xmm0, -0xe80(%rbp)
movl %edi, -0xe84(%rbp)
movq %rsi, -0xe90(%rbp)
movq %rdx, -0xe98(%rbp)
movq -0xe90(%rbp), %rax
movq %rax, -0xec8(%rbp)
movsd -0xe80(%rbp), %xmm0
movl -0xe84(%rbp), %esi
leaq -0xe70(%rbp), %r9
movl $0x5, %edi
leaq -0xe9c(%rbp), %rdx
leaq -0xea0(%rbp), %rcx
leaq -0xec0(%rbp), %r8
movq $0xe60, (%rsp) # imm = 0xE60
callq 0x32390
movq %rax, -0xeb0(%rbp)
cmpl $0x270f, -0xe9c(%rbp) # imm = 0x270F
jne 0x320cf
movq -0xeb0(%rbp), %rdi
leaq -0xe70(%rbp), %rsi
movl $0xe60, %edx # imm = 0xE60
callq 0x339f0
movq -0xe90(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xe90(%rbp)
movb $0x30, (%rax)
movq -0xe90(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0xe98(%rbp)
je 0x320bf
movq -0xe98(%rbp), %rax
movb $0x1, (%rax)
movq $0x1, -0xe78(%rbp)
jmp 0x32356
movq -0xeb0(%rbp), %rax
movq %rax, -0xeb8(%rbp)
movq -0xec0(%rbp), %rax
movq -0xeb8(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0xea4(%rbp)
cmpl $0x0, -0xea0(%rbp)
je 0x32115
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x2d, (%rax)
cmpl $0x0, -0xe9c(%rbp)
jg 0x3218e
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x30, (%rax)
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x2e, (%rax)
movl -0xe9c(%rbp), %eax
movl %eax, -0xea8(%rbp)
cmpl $0x0, -0xea8(%rbp)
jge 0x3218c
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x30, (%rax)
movl -0xea8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xea8(%rbp)
jmp 0x3215a
jmp 0x3218e
movl $0x1, -0xea8(%rbp)
movl -0xea8(%rbp), %eax
cmpl -0xea4(%rbp), %eax
jg 0x3221e
movq -0xeb8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xeb8(%rbp)
movb (%rax), %cl
movq -0xec8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0xec8(%rbp)
movb %cl, (%rax)
movl -0xea8(%rbp), %eax
cmpl -0xe9c(%rbp), %eax
jne 0x32208
movl -0xea8(%rbp), %eax
cmpl -0xea4(%rbp), %eax
jge 0x32208
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x2e, (%rax)
jmp 0x3220a
movl -0xea8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xea8(%rbp)
jmp 0x32198
jmp 0x32220
movl -0xea8(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xea8(%rbp)
cmpl -0xe9c(%rbp), %eax
jg 0x32253
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x30, (%rax)
jmp 0x32220
cmpl $0x0, -0xe84(%rbp)
jle 0x32308
movl -0xea4(%rbp), %eax
cmpl -0xe9c(%rbp), %eax
jg 0x32286
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x2e, (%rax)
movl -0xe84(%rbp), %eax
movl %eax, -0xecc(%rbp)
movl -0xea4(%rbp), %ecx
subl -0xe9c(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x322ae
xorl %eax, %eax
movl %eax, -0xed0(%rbp)
jmp 0x322c0
movl -0xea4(%rbp), %eax
subl -0xe9c(%rbp), %eax
movl %eax, -0xed0(%rbp)
movl -0xecc(%rbp), %eax
movl -0xed0(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0xea8(%rbp)
cmpl $0x0, -0xea8(%rbp)
jle 0x32306
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x30, (%rax)
movl -0xea8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xea8(%rbp)
jmp 0x322d4
jmp 0x32308
movq -0xec8(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0xe98(%rbp)
je 0x32326
movq -0xe98(%rbp), %rax
movb $0x0, (%rax)
movq -0xeb0(%rbp), %rdi
leaq -0xe70(%rbp), %rsi
movl $0xe60, %edx # imm = 0xE60
callq 0x339f0
movq -0xec8(%rbp), %rax
movq -0xe90(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xe78(%rbp)
movq -0xe78(%rbp), %rax
movq %rax, -0xed8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x32386
movq -0xed8(%rbp), %rax
addq $0xee0, %rsp # imm = 0xEE0
popq %rbp
retq
callq 0x134b0
nopl (%rax,%rax)
| ma_fcvt:
push rbp
mov rbp, rsp
sub rsp, 0EE0h
mov rax, fs:28h
mov [rbp+var_8], rax
movsd [rbp+var_E80], xmm0
mov [rbp+var_E84], edi
mov [rbp+var_E90], rsi
mov [rbp+var_E98], rdx
mov rax, [rbp+var_E90]
mov [rbp+var_EC8], rax
movsd xmm0, [rbp+var_E80]
mov esi, [rbp+var_E84]
lea r9, [rbp+var_E70]
mov edi, 5
lea rdx, [rbp+var_E9C]
lea rcx, [rbp+var_EA0]
lea r8, [rbp+var_EC0]
mov [rsp+0EE0h+var_EE0], 0E60h
call dtoa
mov [rbp+var_EB0], rax
cmp [rbp+var_E9C], 270Fh
jnz short loc_320CF
mov rdi, [rbp+var_EB0]
lea rsi, [rbp+var_E70]
mov edx, 0E60h
call dtoa_free
mov rax, [rbp+var_E90]
mov rcx, rax
add rcx, 1
mov [rbp+var_E90], rcx
mov byte ptr [rax], 30h ; '0'
mov rax, [rbp+var_E90]
mov byte ptr [rax], 0
cmp [rbp+var_E98], 0
jz short loc_320BF
mov rax, [rbp+var_E98]
mov byte ptr [rax], 1
loc_320BF:
mov [rbp+var_E78], 1
jmp loc_32356
loc_320CF:
mov rax, [rbp+var_EB0]
mov [rbp+var_EB8], rax
mov rax, [rbp+var_EC0]
mov rcx, [rbp+var_EB8]
sub rax, rcx
mov [rbp+var_EA4], eax
cmp [rbp+var_EA0], 0
jz short loc_32115
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 2Dh ; '-'
loc_32115:
cmp [rbp+var_E9C], 0
jg short loc_3218E
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 30h ; '0'
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 2Eh ; '.'
mov eax, [rbp+var_E9C]
mov [rbp+var_EA8], eax
loc_3215A:
cmp [rbp+var_EA8], 0
jge short loc_3218C
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 30h ; '0'
mov eax, [rbp+var_EA8]
add eax, 1
mov [rbp+var_EA8], eax
jmp short loc_3215A
loc_3218C:
jmp short $+2
loc_3218E:
mov [rbp+var_EA8], 1
loc_32198:
mov eax, [rbp+var_EA8]
cmp eax, [rbp+var_EA4]
jg short loc_3221E
mov rax, [rbp+var_EB8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EB8], rcx
mov cl, [rax]
mov rax, [rbp+var_EC8]
mov rdx, rax
add rdx, 1
mov [rbp+var_EC8], rdx
mov [rax], cl
mov eax, [rbp+var_EA8]
cmp eax, [rbp+var_E9C]
jnz short loc_32208
mov eax, [rbp+var_EA8]
cmp eax, [rbp+var_EA4]
jge short loc_32208
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 2Eh ; '.'
loc_32208:
jmp short $+2
loc_3220A:
mov eax, [rbp+var_EA8]
add eax, 1
mov [rbp+var_EA8], eax
jmp loc_32198
loc_3221E:
jmp short $+2
loc_32220:
mov eax, [rbp+var_EA8]
mov ecx, eax
add ecx, 1
mov [rbp+var_EA8], ecx
cmp eax, [rbp+var_E9C]
jg short loc_32253
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 30h ; '0'
jmp short loc_32220
loc_32253:
cmp [rbp+var_E84], 0
jle loc_32308
mov eax, [rbp+var_EA4]
cmp eax, [rbp+var_E9C]
jg short loc_32286
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 2Eh ; '.'
loc_32286:
mov eax, [rbp+var_E84]
mov [rbp+var_ECC], eax
mov ecx, [rbp+var_EA4]
sub ecx, [rbp+var_E9C]
xor eax, eax
cmp eax, ecx
jle short loc_322AE
xor eax, eax
mov [rbp+var_ED0], eax
jmp short loc_322C0
loc_322AE:
mov eax, [rbp+var_EA4]
sub eax, [rbp+var_E9C]
mov [rbp+var_ED0], eax
loc_322C0:
mov eax, [rbp+var_ECC]
mov ecx, [rbp+var_ED0]
sub eax, ecx
mov [rbp+var_EA8], eax
loc_322D4:
cmp [rbp+var_EA8], 0
jle short loc_32306
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 30h ; '0'
mov eax, [rbp+var_EA8]
add eax, 0FFFFFFFFh
mov [rbp+var_EA8], eax
jmp short loc_322D4
loc_32306:
jmp short $+2
loc_32308:
mov rax, [rbp+var_EC8]
mov byte ptr [rax], 0
cmp [rbp+var_E98], 0
jz short loc_32326
mov rax, [rbp+var_E98]
mov byte ptr [rax], 0
loc_32326:
mov rdi, [rbp+var_EB0]
lea rsi, [rbp+var_E70]
mov edx, 0E60h
call dtoa_free
mov rax, [rbp+var_EC8]
mov rcx, [rbp+var_E90]
sub rax, rcx
mov [rbp+var_E78], rax
loc_32356:
mov rax, [rbp+var_E78]
mov [rbp+var_ED8], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_32386
mov rax, [rbp+var_ED8]
add rsp, 0EE0h
pop rbp
retn
loc_32386:
call ___stack_chk_fail
| long long ma_fcvt(int a1, _BYTE *a2, _BYTE *a3, double a4)
{
_BYTE *v4; // rax
_BYTE *v5; // rax
_BYTE *v6; // rax
char *v7; // rax
char v8; // cl
_BYTE *v9; // rax
_BYTE *v10; // rax
int v11; // eax
_BYTE *v12; // rax
_BYTE *v13; // rax
_BYTE *v14; // rax
int v16; // [rsp+10h] [rbp-ED0h]
_BYTE *v17; // [rsp+18h] [rbp-EC8h]
long long v18; // [rsp+20h] [rbp-EC0h] BYREF
char *v19; // [rsp+28h] [rbp-EB8h]
long long v20; // [rsp+30h] [rbp-EB0h]
int i; // [rsp+38h] [rbp-EA8h]
int v22; // [rsp+3Ch] [rbp-EA4h]
int v23; // [rsp+40h] [rbp-EA0h] BYREF
int v24; // [rsp+44h] [rbp-E9Ch] BYREF
_BYTE *v25; // [rsp+48h] [rbp-E98h]
_BYTE *v26; // [rsp+50h] [rbp-E90h]
int v27; // [rsp+5Ch] [rbp-E84h]
double v28; // [rsp+60h] [rbp-E80h]
_BYTE v30[3688]; // [rsp+70h] [rbp-E70h] BYREF
unsigned long long v31; // [rsp+ED8h] [rbp-8h]
v31 = __readfsqword(0x28u);
v28 = a4;
v27 = a1;
v26 = a2;
v25 = a3;
v17 = a2;
v20 = dtoa(5, a1, (unsigned int)&v24, (unsigned int)&v23, (unsigned int)&v18, (unsigned int)v30, 3680LL);
if ( v24 == 9999 )
{
dtoa_free(v20, v30, 3680LL);
v4 = v26++;
*v4 = 48;
*v26 = 0;
if ( v25 )
*v25 = 1;
return 1LL;
}
else
{
v19 = (char *)v20;
v22 = v18 - v20;
if ( v23 )
{
v17 = a2 + 1;
*a2 = 45;
}
if ( v24 <= 0 )
{
*v17 = 48;
v5 = v17 + 1;
v17 += 2;
*v5 = 46;
for ( i = v24; i < 0; ++i )
{
v6 = v17++;
*v6 = 48;
}
}
for ( i = 1; i <= v22; ++i )
{
v7 = v19++;
v8 = *v7;
v9 = v17++;
*v9 = v8;
if ( i == v24 && i < v22 )
{
v10 = v17++;
*v10 = 46;
}
}
while ( 1 )
{
v11 = i++;
if ( v11 > v24 )
break;
v12 = v17++;
*v12 = 48;
}
if ( v27 > 0 )
{
if ( v22 <= v24 )
{
v13 = v17++;
*v13 = 46;
}
if ( v22 - v24 >= 0 )
v16 = v22 - v24;
else
v16 = 0;
for ( i = v27 - v16; i > 0; --i )
{
v14 = v17++;
*v14 = 48;
}
}
*v17 = 0;
if ( v25 )
*v25 = 0;
dtoa_free(v20, v30, 3680LL);
return v17 - v26;
}
}
| ma_fcvt:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xee0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOVSD qword ptr [RBP + -0xe80],XMM0
MOV dword ptr [RBP + -0xe84],EDI
MOV qword ptr [RBP + -0xe90],RSI
MOV qword ptr [RBP + -0xe98],RDX
MOV RAX,qword ptr [RBP + -0xe90]
MOV qword ptr [RBP + -0xec8],RAX
MOVSD XMM0,qword ptr [RBP + -0xe80]
MOV ESI,dword ptr [RBP + -0xe84]
LEA R9,[RBP + -0xe70]
MOV EDI,0x5
LEA RDX,[RBP + -0xe9c]
LEA RCX,[RBP + -0xea0]
LEA R8,[RBP + -0xec0]
MOV qword ptr [RSP],0xe60
CALL 0x00132390
MOV qword ptr [RBP + -0xeb0],RAX
CMP dword ptr [RBP + -0xe9c],0x270f
JNZ 0x001320cf
MOV RDI,qword ptr [RBP + -0xeb0]
LEA RSI,[RBP + -0xe70]
MOV EDX,0xe60
CALL 0x001339f0
MOV RAX,qword ptr [RBP + -0xe90]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xe90],RCX
MOV byte ptr [RAX],0x30
MOV RAX,qword ptr [RBP + -0xe90]
MOV byte ptr [RAX],0x0
CMP qword ptr [RBP + -0xe98],0x0
JZ 0x001320bf
MOV RAX,qword ptr [RBP + -0xe98]
MOV byte ptr [RAX],0x1
LAB_001320bf:
MOV qword ptr [RBP + -0xe78],0x1
JMP 0x00132356
LAB_001320cf:
MOV RAX,qword ptr [RBP + -0xeb0]
MOV qword ptr [RBP + -0xeb8],RAX
MOV RAX,qword ptr [RBP + -0xec0]
MOV RCX,qword ptr [RBP + -0xeb8]
SUB RAX,RCX
MOV dword ptr [RBP + -0xea4],EAX
CMP dword ptr [RBP + -0xea0],0x0
JZ 0x00132115
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x2d
LAB_00132115:
CMP dword ptr [RBP + -0xe9c],0x0
JG 0x0013218e
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x30
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x2e
MOV EAX,dword ptr [RBP + -0xe9c]
MOV dword ptr [RBP + -0xea8],EAX
LAB_0013215a:
CMP dword ptr [RBP + -0xea8],0x0
JGE 0x0013218c
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x30
MOV EAX,dword ptr [RBP + -0xea8]
ADD EAX,0x1
MOV dword ptr [RBP + -0xea8],EAX
JMP 0x0013215a
LAB_0013218c:
JMP 0x0013218e
LAB_0013218e:
MOV dword ptr [RBP + -0xea8],0x1
LAB_00132198:
MOV EAX,dword ptr [RBP + -0xea8]
CMP EAX,dword ptr [RBP + -0xea4]
JG 0x0013221e
MOV RAX,qword ptr [RBP + -0xeb8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xeb8],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0xec8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0xec8],RDX
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0xea8]
CMP EAX,dword ptr [RBP + -0xe9c]
JNZ 0x00132208
MOV EAX,dword ptr [RBP + -0xea8]
CMP EAX,dword ptr [RBP + -0xea4]
JGE 0x00132208
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x2e
LAB_00132208:
JMP 0x0013220a
LAB_0013220a:
MOV EAX,dword ptr [RBP + -0xea8]
ADD EAX,0x1
MOV dword ptr [RBP + -0xea8],EAX
JMP 0x00132198
LAB_0013221e:
JMP 0x00132220
LAB_00132220:
MOV EAX,dword ptr [RBP + -0xea8]
MOV ECX,EAX
ADD ECX,0x1
MOV dword ptr [RBP + -0xea8],ECX
CMP EAX,dword ptr [RBP + -0xe9c]
JG 0x00132253
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x30
JMP 0x00132220
LAB_00132253:
CMP dword ptr [RBP + -0xe84],0x0
JLE 0x00132308
MOV EAX,dword ptr [RBP + -0xea4]
CMP EAX,dword ptr [RBP + -0xe9c]
JG 0x00132286
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x2e
LAB_00132286:
MOV EAX,dword ptr [RBP + -0xe84]
MOV dword ptr [RBP + -0xecc],EAX
MOV ECX,dword ptr [RBP + -0xea4]
SUB ECX,dword ptr [RBP + -0xe9c]
XOR EAX,EAX
CMP EAX,ECX
JLE 0x001322ae
XOR EAX,EAX
MOV dword ptr [RBP + -0xed0],EAX
JMP 0x001322c0
LAB_001322ae:
MOV EAX,dword ptr [RBP + -0xea4]
SUB EAX,dword ptr [RBP + -0xe9c]
MOV dword ptr [RBP + -0xed0],EAX
LAB_001322c0:
MOV EAX,dword ptr [RBP + -0xecc]
MOV ECX,dword ptr [RBP + -0xed0]
SUB EAX,ECX
MOV dword ptr [RBP + -0xea8],EAX
LAB_001322d4:
CMP dword ptr [RBP + -0xea8],0x0
JLE 0x00132306
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x30
MOV EAX,dword ptr [RBP + -0xea8]
ADD EAX,-0x1
MOV dword ptr [RBP + -0xea8],EAX
JMP 0x001322d4
LAB_00132306:
JMP 0x00132308
LAB_00132308:
MOV RAX,qword ptr [RBP + -0xec8]
MOV byte ptr [RAX],0x0
CMP qword ptr [RBP + -0xe98],0x0
JZ 0x00132326
MOV RAX,qword ptr [RBP + -0xe98]
MOV byte ptr [RAX],0x0
LAB_00132326:
MOV RDI,qword ptr [RBP + -0xeb0]
LEA RSI,[RBP + -0xe70]
MOV EDX,0xe60
CALL 0x001339f0
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,qword ptr [RBP + -0xe90]
SUB RAX,RCX
MOV qword ptr [RBP + -0xe78],RAX
LAB_00132356:
MOV RAX,qword ptr [RBP + -0xe78]
MOV qword ptr [RBP + -0xed8],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00132386
MOV RAX,qword ptr [RBP + -0xed8]
ADD RSP,0xee0
POP RBP
RET
LAB_00132386:
CALL 0x001134b0
|
long ma_fcvt(int8 param_1,int param_2,int1 *param_3,int1 *param_4)
{
int1 *puVar1;
long in_FS_OFFSET;
int local_ed8;
int1 *local_ed0;
int local_ec8 [2];
int1 *local_ec0;
int1 *local_eb8;
int local_eb0;
int local_eac;
int local_ea8;
int local_ea4;
int1 *local_ea0;
int1 *local_e98;
int local_e8c;
int8 local_e88;
long local_e80;
int1 local_e78 [3688];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_ea0 = param_4;
local_e98 = param_3;
local_e8c = param_2;
local_e88 = param_1;
local_eb8 = (int1 *)dtoa(param_1,5,param_2,&local_ea4,&local_ea8,local_ec8,local_e78,0xe60);
if (local_ea4 == 9999) {
dtoa_free(local_eb8,local_e78,0xe60);
*local_e98 = 0x30;
local_e98[1] = 0;
if (local_ea0 != (int1 *)0x0) {
*local_ea0 = 1;
}
local_e80 = 1;
local_e98 = local_e98 + 1;
}
else {
local_eac = local_ec8[0] - (int)local_eb8;
local_ed0 = param_3;
if (local_ea8 != 0) {
local_ed0 = param_3 + 1;
*param_3 = 0x2d;
}
if (local_ea4 < 1) {
*local_ed0 = 0x30;
local_ed0[1] = 0x2e;
local_ed0 = local_ed0 + 2;
for (local_eb0 = local_ea4; local_eb0 < 0; local_eb0 = local_eb0 + 1) {
*local_ed0 = 0x30;
local_ed0 = local_ed0 + 1;
}
}
local_ec0 = local_eb8;
for (local_eb0 = 1; local_eb0 <= local_eac; local_eb0 = local_eb0 + 1) {
puVar1 = local_ed0 + 1;
*local_ed0 = *local_ec0;
if ((local_eb0 == local_ea4) && (local_eb0 < local_eac)) {
*puVar1 = 0x2e;
puVar1 = local_ed0 + 2;
}
local_ed0 = puVar1;
local_ec0 = local_ec0 + 1;
}
while (local_eb0 <= local_ea4) {
*local_ed0 = 0x30;
local_ed0 = local_ed0 + 1;
local_eb0 = local_eb0 + 1;
}
local_eb0 = local_eb0 + 1;
if (0 < local_e8c) {
if (local_eac <= local_ea4) {
*local_ed0 = 0x2e;
local_ed0 = local_ed0 + 1;
}
if (local_eac - local_ea4 < 0) {
local_ed8 = 0;
}
else {
local_ed8 = local_eac - local_ea4;
}
for (local_eb0 = local_e8c - local_ed8; 0 < local_eb0; local_eb0 = local_eb0 + -1) {
*local_ed0 = 0x30;
local_ed0 = local_ed0 + 1;
}
}
*local_ed0 = 0;
if (local_ea0 != (int1 *)0x0) {
*local_ea0 = 0;
}
dtoa_free(local_eb8,local_e78,0xe60);
local_e80 = (long)local_ed0 - (long)local_e98;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_e80;
}
| |
26,061 | testing::MatcherDescriberInterface::MatcherDescriberInterface() | AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h | class GTEST_API_ MatcherDescriberInterface {
public:
virtual ~MatcherDescriberInterface() = default;
// Describes this matcher to an ostream. The function should print
// a verb phrase that describes the property a value matching this
// matcher should have. The subject of the verb phrase is the value
// being matched. For example, the DescribeTo() method of the Gt(7)
// matcher prints "is greater than 7".
virtual void DescribeTo(::std::ostream* os) const = 0;
// Describes the negation of this matcher to an ostream. For
// example, if the description of this matcher is "is greater than
// 7", the negated description could be "is not greater than 7".
// You are not required to override this when implementing
// MatcherInterface, but it is highly advised so that your matcher
// can produce good error messages.
virtual void DescribeNegationTo(::std::ostream* os) const {
*os << "not (";
DescribeTo(os);
*os << ")";
}
} | O0 | c | testing::MatcherDescriberInterface::MatcherDescriberInterface():
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
leaq 0xa175f(%rip), %rcx # 0x1cf690
addq $0x10, %rcx
movq %rcx, (%rax)
retq
nopl (%rax)
| _ZN7testing25MatcherDescriberInterfaceC2Ev:
mov [rsp+var_8], rdi
mov rax, [rsp+var_8]
lea rcx, _ZTVN7testing25MatcherDescriberInterfaceE; `vtable for'testing::MatcherDescriberInterface
add rcx, 10h
mov [rax], rcx
retn
| testing::MatcherDescriberInterface * testing::MatcherDescriberInterface::MatcherDescriberInterface(
testing::MatcherDescriberInterface *this)
{
testing::MatcherDescriberInterface *result; // rax
result = this;
*(_QWORD *)this = &`vtable for'testing::MatcherDescriberInterface + 2;
return result;
}
| _Vector_base:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV RDI,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x8],RDI
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x0012e0b0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x28]
LAB_0012df51:
CALL 0x0012e0e0
LAB_0012df56:
JMP 0x0012df58
LAB_0012df58:
ADD RSP,0x38
RET
|
/* std::_Vector_base<std::mutex, std::allocator<std::mutex> >::_Vector_base(unsigned long,
std::allocator<std::mutex> const&) */
void __thiscall
std::_Vector_base<std::mutex,std::allocator<std::mutex>>::_Vector_base
(_Vector_base<std::mutex,std::allocator<std::mutex>> *this,ulong param_1,
allocator *param_2)
{
_Vector_impl::_Vector_impl((_Vector_impl *)this,param_2);
/* try { // try from 0012df51 to 0012df55 has its CatchHandler @ 0012df5d */
_M_create_storage(this,param_1);
return;
}
| |
26,062 | fct_update_table_derived_flags(PFS_table*) | eloqsql/storage/perfschema/pfs_instr.cc | void fct_update_table_derived_flags(PFS_table *pfs)
{
PFS_table_share *share= sanitize_table_share(pfs->m_share);
if (likely(share != NULL))
{
pfs->m_io_enabled= share->m_enabled &&
flag_global_instrumentation && global_table_io_class.m_enabled;
pfs->m_io_timed= share->m_timed && global_table_io_class.m_timed;
pfs->m_lock_enabled= share->m_enabled &&
flag_global_instrumentation && global_table_lock_class.m_enabled;
pfs->m_lock_timed= share->m_timed && global_table_lock_class.m_timed;
}
else
{
pfs->m_io_enabled= false;
pfs->m_io_timed= false;
pfs->m_lock_enabled= false;
pfs->m_lock_timed= false;
}
} | O0 | cpp | fct_update_table_derived_flags(PFS_table*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x30380
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x3d35a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x4(%rcx)
movb %al, -0x11(%rbp)
je 0x3d2c0
xorl %eax, %eax
leaq 0x3d3cd5(%rip), %rcx # 0x410f80
testb $0x1, (%rcx)
movb %al, -0x11(%rbp)
je 0x3d2c0
leaq 0x391486(%rip), %rax # 0x3ce740
movb 0x4(%rax), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x5(%rcx)
movb %al, -0x12(%rbp)
je 0x3d2e8
leaq 0x39145e(%rip), %rax # 0x3ce740
movb 0x5(%rax), %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x4(%rcx)
movb %al, -0x13(%rbp)
je 0x3d322
xorl %eax, %eax
leaq 0x3d3c73(%rip), %rcx # 0x410f80
testb $0x1, (%rcx)
movb %al, -0x13(%rbp)
je 0x3d322
leaq 0x3914e4(%rip), %rax # 0x3ce800
movb 0x4(%rax), %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x5(%rcx)
movb %al, -0x14(%rbp)
je 0x3d34b
leaq 0x3914bb(%rip), %rax # 0x3ce800
movb 0x5(%rax), %al
movb %al, -0x14(%rbp)
movb -0x14(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x3(%rax)
jmp 0x3d379
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x3(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
| _Z30fct_update_table_derived_flagsP9PFS_table:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rdi, [rax+20h]; PFS_table_share *
call _Z20sanitize_table_shareP15PFS_table_share; sanitize_table_share(PFS_table_share *)
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
jz loc_3D35A
mov rcx, [rbp+var_10]
xor eax, eax
test byte ptr [rcx+4], 1
mov [rbp+var_11], al
jz short loc_3D2C0
xor eax, eax
lea rcx, flag_global_instrumentation
test byte ptr [rcx], 1
mov [rbp+var_11], al
jz short loc_3D2C0
lea rax, global_table_io_class
mov al, [rax+4]
mov [rbp+var_11], al
loc_3D2C0:
mov cl, [rbp+var_11]
mov rax, [rbp+var_8]
and cl, 1
mov [rax], cl
mov rcx, [rbp+var_10]
xor eax, eax
test byte ptr [rcx+5], 1
mov [rbp+var_12], al
jz short loc_3D2E8
lea rax, global_table_io_class
mov al, [rax+5]
mov [rbp+var_12], al
loc_3D2E8:
mov cl, [rbp+var_12]
mov rax, [rbp+var_8]
and cl, 1
mov [rax+2], cl
mov rcx, [rbp+var_10]
xor eax, eax
test byte ptr [rcx+4], 1
mov [rbp+var_13], al
jz short loc_3D322
xor eax, eax
lea rcx, flag_global_instrumentation
test byte ptr [rcx], 1
mov [rbp+var_13], al
jz short loc_3D322
lea rax, global_table_lock_class
mov al, [rax+4]
mov [rbp+var_13], al
loc_3D322:
mov cl, [rbp+var_13]
mov rax, [rbp+var_8]
and cl, 1
mov [rax+1], cl
mov rcx, [rbp+var_10]
xor eax, eax
test byte ptr [rcx+5], 1
mov [rbp+var_14], al
jz short loc_3D34B
lea rax, global_table_lock_class
mov al, [rax+5]
mov [rbp+var_14], al
loc_3D34B:
mov cl, [rbp+var_14]
mov rax, [rbp+var_8]
and cl, 1
mov [rax+3], cl
jmp short loc_3D379
loc_3D35A:
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
mov byte ptr [rax+2], 0
mov rax, [rbp+var_8]
mov byte ptr [rax+1], 0
mov rax, [rbp+var_8]
mov byte ptr [rax+3], 0
loc_3D379:
add rsp, 20h
pop rbp
retn
| PFS_table_share ** fct_update_table_derived_flags(PFS_table_share **a1)
{
PFS_table_share **result; // rax
char v2; // [rsp+Ch] [rbp-14h]
char v3; // [rsp+Dh] [rbp-13h]
char v4; // [rsp+Eh] [rbp-12h]
char v5; // [rsp+Fh] [rbp-11h]
long long v6; // [rsp+10h] [rbp-10h]
v6 = sanitize_table_share(a1[4]);
if ( v6 )
{
v5 = 0;
if ( (*(_BYTE *)(v6 + 4) & 1) != 0 )
{
v5 = 0;
if ( (flag_global_instrumentation & 1) != 0 )
v5 = global_table_io_class[4];
}
*(_BYTE *)a1 = v5 & 1;
v4 = 0;
if ( (*(_BYTE *)(v6 + 5) & 1) != 0 )
v4 = global_table_io_class[5];
*((_BYTE *)a1 + 2) = v4 & 1;
v3 = 0;
if ( (*(_BYTE *)(v6 + 4) & 1) != 0 )
{
v3 = 0;
if ( (flag_global_instrumentation & 1) != 0 )
v3 = global_table_lock_class[4];
}
*((_BYTE *)a1 + 1) = v3 & 1;
v2 = 0;
if ( (*(_BYTE *)(v6 + 5) & 1) != 0 )
v2 = global_table_lock_class[5];
result = a1;
*((_BYTE *)a1 + 3) = v2 & 1;
}
else
{
*(_BYTE *)a1 = 0;
*((_BYTE *)a1 + 2) = 0;
*((_BYTE *)a1 + 1) = 0;
result = a1;
*((_BYTE *)a1 + 3) = 0;
}
return result;
}
| fct_update_table_derived_flags:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x20]
CALL 0x00130380
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0013d35a
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
TEST byte ptr [RCX + 0x4],0x1
MOV byte ptr [RBP + -0x11],AL
JZ 0x0013d2c0
XOR EAX,EAX
LEA RCX,[0x510f80]
TEST byte ptr [RCX],0x1
MOV byte ptr [RBP + -0x11],AL
JZ 0x0013d2c0
LEA RAX,[0x4ce740]
MOV AL,byte ptr [RAX + 0x4]
MOV byte ptr [RBP + -0x11],AL
LAB_0013d2c0:
MOV CL,byte ptr [RBP + -0x11]
MOV RAX,qword ptr [RBP + -0x8]
AND CL,0x1
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
TEST byte ptr [RCX + 0x5],0x1
MOV byte ptr [RBP + -0x12],AL
JZ 0x0013d2e8
LEA RAX,[0x4ce740]
MOV AL,byte ptr [RAX + 0x5]
MOV byte ptr [RBP + -0x12],AL
LAB_0013d2e8:
MOV CL,byte ptr [RBP + -0x12]
MOV RAX,qword ptr [RBP + -0x8]
AND CL,0x1
MOV byte ptr [RAX + 0x2],CL
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
TEST byte ptr [RCX + 0x4],0x1
MOV byte ptr [RBP + -0x13],AL
JZ 0x0013d322
XOR EAX,EAX
LEA RCX,[0x510f80]
TEST byte ptr [RCX],0x1
MOV byte ptr [RBP + -0x13],AL
JZ 0x0013d322
LEA RAX,[0x4ce800]
MOV AL,byte ptr [RAX + 0x4]
MOV byte ptr [RBP + -0x13],AL
LAB_0013d322:
MOV CL,byte ptr [RBP + -0x13]
MOV RAX,qword ptr [RBP + -0x8]
AND CL,0x1
MOV byte ptr [RAX + 0x1],CL
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
TEST byte ptr [RCX + 0x5],0x1
MOV byte ptr [RBP + -0x14],AL
JZ 0x0013d34b
LEA RAX,[0x4ce800]
MOV AL,byte ptr [RAX + 0x5]
MOV byte ptr [RBP + -0x14],AL
LAB_0013d34b:
MOV CL,byte ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x8]
AND CL,0x1
MOV byte ptr [RAX + 0x3],CL
JMP 0x0013d379
LAB_0013d35a:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x2],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x1],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x3],0x0
LAB_0013d379:
ADD RSP,0x20
POP RBP
RET
|
/* fct_update_table_derived_flags(PFS_table*) */
void fct_update_table_derived_flags(PFS_table *param_1)
{
long lVar1;
byte local_1c;
byte local_1b;
byte local_1a;
byte local_19;
lVar1 = sanitize_table_share(*(PFS_table_share **)(param_1 + 0x20));
if (lVar1 == 0) {
*param_1 = (PFS_table)0x0;
param_1[2] = (PFS_table)0x0;
param_1[1] = (PFS_table)0x0;
param_1[3] = (PFS_table)0x0;
}
else {
local_19 = 0;
if (((*(byte *)(lVar1 + 4) & 1) != 0) && (local_19 = 0, (flag_global_instrumentation & 1) != 0))
{
local_19 = global_table_io_class[4];
}
*param_1 = (PFS_table)(local_19 & 1);
local_1a = 0;
if ((*(byte *)(lVar1 + 5) & 1) != 0) {
local_1a = global_table_io_class[5];
}
param_1[2] = (PFS_table)(local_1a & 1);
local_1b = 0;
if (((*(byte *)(lVar1 + 4) & 1) != 0) && (local_1b = 0, (flag_global_instrumentation & 1) != 0))
{
local_1b = global_table_lock_class[4];
}
param_1[1] = (PFS_table)(local_1b & 1);
local_1c = 0;
if ((*(byte *)(lVar1 + 5) & 1) != 0) {
local_1c = global_table_lock_class[5];
}
param_1[3] = (PFS_table)(local_1c & 1);
}
return;
}
| |
26,063 | fct_update_table_derived_flags(PFS_table*) | eloqsql/storage/perfschema/pfs_instr.cc | void fct_update_table_derived_flags(PFS_table *pfs)
{
PFS_table_share *share= sanitize_table_share(pfs->m_share);
if (likely(share != NULL))
{
pfs->m_io_enabled= share->m_enabled &&
flag_global_instrumentation && global_table_io_class.m_enabled;
pfs->m_io_timed= share->m_timed && global_table_io_class.m_timed;
pfs->m_lock_enabled= share->m_enabled &&
flag_global_instrumentation && global_table_lock_class.m_enabled;
pfs->m_lock_timed= share->m_timed && global_table_lock_class.m_timed;
}
else
{
pfs->m_io_enabled= false;
pfs->m_io_timed= false;
pfs->m_lock_enabled= false;
pfs->m_lock_timed= false;
}
} | O3 | cpp | fct_update_table_derived_flags(PFS_table*):
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x3210f
testq %rax, %rax
je 0x394aa
leaq 0x39a7f3(%rip), %rdx # 0x3d3c40
movb (%rdx), %r8b
leaq 0x358369(%rip), %rsi # 0x3917c0
xorl %ecx, %ecx
movl $0x0, %edi
testb %r8b, 0x4(%rax)
je 0x39467
movl 0x4(%rsi), %edi
movb %dil, (%rbx)
movzbl 0x5(%rsi), %esi
cmpb $0x0, 0x5(%rax)
cmovel %ecx, %esi
movb %sil, 0x2(%rbx)
movb (%rdx), %dil
leaq 0x3583fd(%rip), %rdx # 0x391880
movl $0x0, %esi
testb %dil, 0x4(%rax)
je 0x39491
movl 0x4(%rdx), %esi
movb %sil, 0x1(%rbx)
movzbl 0x5(%rdx), %edx
cmpb $0x0, 0x5(%rax)
cmovnel %edx, %ecx
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movw $0x0, (%rbx)
movb $0x0, 0x2(%rbx)
xorl %ecx, %ecx
jmp 0x394a0
| _Z30fct_update_table_derived_flagsP9PFS_table:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+20h]; PFS_table_share *
call _Z20sanitize_table_shareP15PFS_table_share; sanitize_table_share(PFS_table_share *)
test rax, rax
jz short loc_394AA
lea rdx, flag_global_instrumentation
mov r8b, [rdx]
lea rsi, global_table_io_class
xor ecx, ecx
mov edi, 0
test [rax+4], r8b
jz short loc_39467
mov edi, [rsi+4]
loc_39467:
mov [rbx], dil
movzx esi, byte ptr [rsi+5]
cmp byte ptr [rax+5], 0
cmovz esi, ecx
mov [rbx+2], sil
mov dil, [rdx]
lea rdx, global_table_lock_class
mov esi, 0
test [rax+4], dil
jz short loc_39491
mov esi, [rdx+4]
loc_39491:
mov [rbx+1], sil
movzx edx, byte ptr [rdx+5]
cmp byte ptr [rax+5], 0
cmovnz ecx, edx
loc_394A0:
mov [rbx+3], cl
add rsp, 8
pop rbx
pop rbp
retn
loc_394AA:
mov word ptr [rbx], 0
mov byte ptr [rbx+2], 0
xor ecx, ecx
jmp short loc_394A0
| PFS_table_share * fct_update_table_derived_flags(PFS_table_share **a1)
{
PFS_table_share *result; // rax
char v3; // cl
int v4; // edi
char v5; // si
int v6; // esi
result = sanitize_table_share(a1[4]);
if ( result )
{
v3 = 0;
LOBYTE(v4) = 0;
if ( (flag_global_instrumentation[0] & *((_BYTE *)result + 4)) != 0 )
v4 = *(&global_table_io_class + 1);
*(_BYTE *)a1 = v4;
v5 = *((_BYTE *)&global_table_io_class + 5);
if ( !*((_BYTE *)result + 5) )
v5 = 0;
*((_BYTE *)a1 + 2) = v5;
LOBYTE(v6) = 0;
if ( (flag_global_instrumentation[0] & *((_BYTE *)result + 4)) != 0 )
v6 = *(&global_table_lock_class + 1);
*((_BYTE *)a1 + 1) = v6;
if ( *((_BYTE *)result + 5) )
v3 = *((_BYTE *)&global_table_lock_class + 5);
}
else
{
*(_WORD *)a1 = 0;
*((_BYTE *)a1 + 2) = 0;
v3 = 0;
}
*((_BYTE *)a1 + 3) = v3;
return result;
}
| fct_update_table_derived_flags:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x20]
CALL 0x0013210f
TEST RAX,RAX
JZ 0x001394aa
LEA RDX,[0x4d3c40]
MOV R8B,byte ptr [RDX]
LEA RSI,[0x4917c0]
XOR ECX,ECX
MOV EDI,0x0
TEST byte ptr [RAX + 0x4],R8B
JZ 0x00139467
MOV EDI,dword ptr [RSI + 0x4]
LAB_00139467:
MOV byte ptr [RBX],DIL
MOVZX ESI,byte ptr [RSI + 0x5]
CMP byte ptr [RAX + 0x5],0x0
CMOVZ ESI,ECX
MOV byte ptr [RBX + 0x2],SIL
MOV DIL,byte ptr [RDX]
LEA RDX,[0x491880]
MOV ESI,0x0
TEST byte ptr [RAX + 0x4],DIL
JZ 0x00139491
MOV ESI,dword ptr [RDX + 0x4]
LAB_00139491:
MOV byte ptr [RBX + 0x1],SIL
MOVZX EDX,byte ptr [RDX + 0x5]
CMP byte ptr [RAX + 0x5],0x0
CMOVNZ ECX,EDX
LAB_001394a0:
MOV byte ptr [RBX + 0x3],CL
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001394aa:
MOV word ptr [RBX],0x0
MOV byte ptr [RBX + 0x2],0x0
XOR ECX,ECX
JMP 0x001394a0
|
/* fct_update_table_derived_flags(PFS_table*) */
void fct_update_table_derived_flags(PFS_table *param_1)
{
long lVar1;
PFS_table PVar2;
lVar1 = sanitize_table_share(*(PFS_table_share **)(param_1 + 0x20));
if (lVar1 == 0) {
*(int2 *)param_1 = 0;
param_1[2] = (PFS_table)0x0;
PVar2 = (PFS_table)0x0;
}
else {
PVar2 = (PFS_table)0x0;
if ((*(byte *)(lVar1 + 4) & flag_global_instrumentation) != 0) {
PVar2 = SUB41(global_table_io_class._4_4_,0);
}
*param_1 = PVar2;
PVar2 = global_table_io_class[5];
if (*(char *)(lVar1 + 5) == '\0') {
PVar2 = (PFS_table)0x0;
}
param_1[2] = PVar2;
PVar2 = (PFS_table)0x0;
if ((*(byte *)(lVar1 + 4) & flag_global_instrumentation) != 0) {
PVar2 = SUB41(global_table_lock_class._4_4_,0);
}
param_1[1] = PVar2;
PVar2 = (PFS_table)0x0;
if (*(char *)(lVar1 + 5) != '\0') {
PVar2 = global_table_lock_class[5];
}
}
param_1[3] = PVar2;
return;
}
| |
26,064 | mjCModel::mjCModel(mjCModel const&) | aimrt_mujoco_sim/_deps/mujoco-src/src/user/user_model.cc | mjCModel::mjCModel(const mjCModel& other) {
CreateObjectLists();
*this = other;
} | O3 | cpp | mjCModel::mjCModel(mjCModel const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %r12d, %r12d
movq %r12, 0x10(%rdi)
movb %r12b, 0x18(%rdi)
leaq 0x38(%rdi), %rax
movq %rax, 0x28(%rdi)
movq %r12, 0x30(%rdi)
movb %r12b, 0x38(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x170(%rdi)
movq %r12, 0x180(%rdi)
leaq 0x198(%rdi), %rax
movq %rax, 0x188(%rdi)
movq %r12, 0x190(%rdi)
movb %r12b, 0x198(%rdi)
leaq 0x1b8(%rdi), %rax
movq %rax, 0x1a8(%rdi)
movq %r12, 0x1b0(%rdi)
movb %r12b, 0x1b8(%rdi)
leaq 0x1d8(%rdi), %rax
movq %rax, 0x1c8(%rdi)
movq %r12, 0x1d0(%rdi)
movb %r12b, 0x1d8(%rdi)
leaq 0x1f8(%rdi), %rax
movq %rax, 0x1e8(%rdi)
movq %r12, 0x1f0(%rdi)
movb %r12b, 0x1f8(%rdi)
leaq 0x218(%rdi), %rax
movq %rax, 0x208(%rdi)
movq %r12, 0x210(%rdi)
movb %r12b, 0x218(%rdi)
leaq 0x238(%rdi), %rax
movq %rax, 0x228(%rdi)
movq %r12, 0x230(%rdi)
movb %r12b, 0x238(%rdi)
leaq 0x258(%rdi), %rax
movq %rax, 0x248(%rdi)
movq %r12, 0x250(%rdi)
movb %r12b, 0x258(%rdi)
leaq 0x278(%rdi), %rax
movq %rax, 0x268(%rdi)
movq %r12, 0x270(%rdi)
movb %r12b, 0x278(%rdi)
leaq 0x298(%rdi), %rax
movq %rax, 0x288(%rdi)
movq %r12, 0x290(%rdi)
movb %r12b, 0x298(%rdi)
leaq 0x2b8(%rdi), %rax
movq %rax, 0x2a8(%rdi)
movq %r12, 0x2b0(%rdi)
movb %r12b, 0x2b8(%rdi)
leaq 0xc88(%rdi), %r14
movl $0x270, %edx # imm = 0x270
movq %r14, %rdi
xorl %esi, %esi
callq 0x2d300
movl $0xfd0, %eax # imm = 0xFD0
leaq (%rbx,%rax), %rcx
movl $0x0, (%rbx,%rax)
movq %r12, 0x8(%rbx,%rax)
movq %rcx, 0x10(%rbx,%rax)
movq %rcx, 0x18(%rbx,%rax)
movq %r12, 0x20(%rbx,%rax)
addq $0x30, %rax
cmpq $0x14b0, %rax # imm = 0x14B0
jne 0xefa45
leaq 0x14a8(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x10e3f8
movq %rbx, %rdi
callq 0xef642
movq %rbx, %rdi
movq %r15, %rsi
callq 0xefd90
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0x1478, %r12d # imm = 0x1478
leaq (%rbx,%r12), %rdi
callq 0x108314
addq $-0x30, %r12
cmpq $0xf98, %r12 # imm = 0xF98
jne 0xefab0
movq 0xee0(%rbx), %rdi
testq %rdi, %rdi
je 0xefae1
movq 0xef0(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xec8(%rbx), %rdi
testq %rdi, %rdi
je 0xefafc
movq 0xed8(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xeb0(%rbx), %rdi
testq %rdi, %rdi
je 0xefb17
movq 0xec0(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xe98(%rbx), %rdi
testq %rdi, %rdi
je 0xefb32
movq 0xea8(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xe80(%rbx), %rdi
testq %rdi, %rdi
je 0xefb4d
movq 0xe90(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xe68(%rbx), %rdi
testq %rdi, %rdi
je 0xefb68
movq 0xe78(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xe50(%rbx), %rdi
testq %rdi, %rdi
je 0xefb83
movq 0xe60(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xe38(%rbx), %rdi
testq %rdi, %rdi
je 0xefb9e
movq 0xe48(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xe20(%rbx), %rdi
testq %rdi, %rdi
je 0xefbb9
movq 0xe30(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xe08(%rbx), %rdi
testq %rdi, %rdi
je 0xefbd4
movq 0xe18(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xdf0(%rbx), %rdi
testq %rdi, %rdi
je 0xefbef
movq 0xe00(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xdd8(%rbx), %rdi
testq %rdi, %rdi
je 0xefc0a
movq 0xde8(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xdc0(%rbx), %rdi
testq %rdi, %rdi
je 0xefc25
movq 0xdd0(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xda8(%rbx), %rdi
testq %rdi, %rdi
je 0xefc40
movq 0xdb8(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xd90(%rbx), %rdi
testq %rdi, %rdi
je 0xefc5b
movq 0xda0(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xd78(%rbx), %rdi
testq %rdi, %rdi
je 0xefc76
movq 0xd88(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xd60(%rbx), %rdi
testq %rdi, %rdi
je 0xefc91
movq 0xd70(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xd48(%rbx), %rdi
testq %rdi, %rdi
je 0xefcac
movq 0xd58(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xd30(%rbx), %rdi
testq %rdi, %rdi
je 0xefcc7
movq 0xd40(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xd18(%rbx), %rdi
testq %rdi, %rdi
je 0xefce2
movq 0xd28(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xd00(%rbx), %rdi
testq %rdi, %rdi
je 0xefcfd
movq 0xd10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xce8(%rbx), %rdi
testq %rdi, %rdi
je 0xefd18
movq 0xcf8(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xcd0(%rbx), %rdi
testq %rdi, %rdi
je 0xefd33
movq 0xce0(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xcb8(%rbx), %rdi
testq %rdi, %rdi
je 0xefd4e
movq 0xcc8(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq 0xca0(%rbx), %rdi
testq %rdi, %rdi
je 0xefd69
movq 0xcb0(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq (%r14), %rdi
testq %rdi, %rdi
je 0xefd80
movq 0xc98(%rbx), %rsi
subq %rdi, %rsi
callq 0x2ded0
movq %rbx, %rdi
callq 0xef750
movq %r15, %rdi
callq 0x2dee0
| _ZN8mjCModelC2ERKS_:
push r15
push r14
push r12
push rbx
push rax
mov r15, rsi
mov rbx, rdi
lea rax, [rdi+18h]
mov [rdi+8], rax
xor r12d, r12d
mov [rdi+10h], r12
mov [rdi+18h], r12b
lea rax, [rdi+38h]
mov [rdi+28h], rax
mov [rdi+30h], r12
mov [rdi+38h], r12b
vxorps xmm0, xmm0, xmm0
vmovups xmmword ptr [rdi+170h], xmm0
mov [rdi+180h], r12
lea rax, [rdi+198h]
mov [rdi+188h], rax
mov [rdi+190h], r12
mov [rdi+198h], r12b
lea rax, [rdi+1B8h]
mov [rdi+1A8h], rax
mov [rdi+1B0h], r12
mov [rdi+1B8h], r12b
lea rax, [rdi+1D8h]
mov [rdi+1C8h], rax
mov [rdi+1D0h], r12
mov [rdi+1D8h], r12b
lea rax, [rdi+1F8h]
mov [rdi+1E8h], rax
mov [rdi+1F0h], r12
mov [rdi+1F8h], r12b
lea rax, [rdi+218h]
mov [rdi+208h], rax
mov [rdi+210h], r12
mov [rdi+218h], r12b
lea rax, [rdi+238h]
mov [rdi+228h], rax
mov [rdi+230h], r12
mov [rdi+238h], r12b
lea rax, [rdi+258h]
mov [rdi+248h], rax
mov [rdi+250h], r12
mov [rdi+258h], r12b
lea rax, [rdi+278h]
mov [rdi+268h], rax
mov [rdi+270h], r12
mov [rdi+278h], r12b
lea rax, [rdi+298h]
mov [rdi+288h], rax
mov [rdi+290h], r12
mov [rdi+298h], r12b
lea rax, [rdi+2B8h]
mov [rdi+2A8h], rax
mov [rdi+2B0h], r12
mov [rdi+2B8h], r12b
lea r14, [rdi+0C88h]
mov edx, 270h
mov rdi, r14
xor esi, esi
call _memset
mov eax, 0FD0h
loc_EFA45:
lea rcx, [rbx+rax]
mov dword ptr [rbx+rax], 0
mov [rbx+rax+8], r12
mov [rbx+rax+10h], rcx
mov [rbx+rax+18h], rcx
mov [rbx+rax+20h], r12
add rax, 30h ; '0'
cmp rax, 14B0h
jnz short loc_EFA45
lea rdi, [rbx+14A8h]; this
xor esi, esi; mjCBase *
xor edx, edx; char *
xor ecx, ecx; char *
xor r8d, r8d; int
xor r9d, r9d; int
call _ZN8mjCErrorC2EPK7mjCBasePKcS4_ii; mjCError::mjCError(mjCBase const*,char const*,char const*,int,int)
mov rdi, rbx; this
call _ZN8mjCModel17CreateObjectListsEv; mjCModel::CreateObjectLists(void)
mov rdi, rbx
mov rsi, r15
call _ZN8mjCModelaSERKS_; mjCModel::operator=(mjCModel const&)
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov r15, rax
mov r12d, 1478h
loc_EFAB0:
lea rdi, [rbx+r12]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_iESt10_Select1stIS8_ESt4lessIvESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,int>,std::_Select1st<std::pair<std::string const,int>>,std::less<void>,std::allocator<std::pair<std::string const,int>>>::~_Rb_tree()
add r12, 0FFFFFFFFFFFFFFD0h
cmp r12, 0F98h
jnz short loc_EFAB0
mov rdi, [rbx+0EE0h]; void *
test rdi, rdi
jz short loc_EFAE1
mov rsi, [rbx+0EF0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFAE1:
mov rdi, [rbx+0EC8h]; void *
test rdi, rdi
jz short loc_EFAFC
mov rsi, [rbx+0ED8h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFAFC:
mov rdi, [rbx+0EB0h]; void *
test rdi, rdi
jz short loc_EFB17
mov rsi, [rbx+0EC0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFB17:
mov rdi, [rbx+0E98h]; void *
test rdi, rdi
jz short loc_EFB32
mov rsi, [rbx+0EA8h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFB32:
mov rdi, [rbx+0E80h]; void *
test rdi, rdi
jz short loc_EFB4D
mov rsi, [rbx+0E90h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFB4D:
mov rdi, [rbx+0E68h]; void *
test rdi, rdi
jz short loc_EFB68
mov rsi, [rbx+0E78h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFB68:
mov rdi, [rbx+0E50h]; void *
test rdi, rdi
jz short loc_EFB83
mov rsi, [rbx+0E60h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFB83:
mov rdi, [rbx+0E38h]; void *
test rdi, rdi
jz short loc_EFB9E
mov rsi, [rbx+0E48h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFB9E:
mov rdi, [rbx+0E20h]; void *
test rdi, rdi
jz short loc_EFBB9
mov rsi, [rbx+0E30h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFBB9:
mov rdi, [rbx+0E08h]; void *
test rdi, rdi
jz short loc_EFBD4
mov rsi, [rbx+0E18h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFBD4:
mov rdi, [rbx+0DF0h]; void *
test rdi, rdi
jz short loc_EFBEF
mov rsi, [rbx+0E00h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFBEF:
mov rdi, [rbx+0DD8h]; void *
test rdi, rdi
jz short loc_EFC0A
mov rsi, [rbx+0DE8h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFC0A:
mov rdi, [rbx+0DC0h]; void *
test rdi, rdi
jz short loc_EFC25
mov rsi, [rbx+0DD0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFC25:
mov rdi, [rbx+0DA8h]; void *
test rdi, rdi
jz short loc_EFC40
mov rsi, [rbx+0DB8h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFC40:
mov rdi, [rbx+0D90h]; void *
test rdi, rdi
jz short loc_EFC5B
mov rsi, [rbx+0DA0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFC5B:
mov rdi, [rbx+0D78h]; void *
test rdi, rdi
jz short loc_EFC76
mov rsi, [rbx+0D88h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFC76:
mov rdi, [rbx+0D60h]; void *
test rdi, rdi
jz short loc_EFC91
mov rsi, [rbx+0D70h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFC91:
mov rdi, [rbx+0D48h]; void *
test rdi, rdi
jz short loc_EFCAC
mov rsi, [rbx+0D58h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFCAC:
mov rdi, [rbx+0D30h]; void *
test rdi, rdi
jz short loc_EFCC7
mov rsi, [rbx+0D40h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFCC7:
mov rdi, [rbx+0D18h]; void *
test rdi, rdi
jz short loc_EFCE2
mov rsi, [rbx+0D28h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFCE2:
mov rdi, [rbx+0D00h]; void *
test rdi, rdi
jz short loc_EFCFD
mov rsi, [rbx+0D10h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFCFD:
mov rdi, [rbx+0CE8h]; void *
test rdi, rdi
jz short loc_EFD18
mov rsi, [rbx+0CF8h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFD18:
mov rdi, [rbx+0CD0h]; void *
test rdi, rdi
jz short loc_EFD33
mov rsi, [rbx+0CE0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFD33:
mov rdi, [rbx+0CB8h]; void *
test rdi, rdi
jz short loc_EFD4E
mov rsi, [rbx+0CC8h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFD4E:
mov rdi, [rbx+0CA0h]; void *
test rdi, rdi
jz short loc_EFD69
mov rsi, [rbx+0CB0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFD69:
mov rdi, [r14]; void *
test rdi, rdi
jz short loc_EFD80
mov rsi, [rbx+0C98h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EFD80:
mov rdi, rbx; this
call _ZN9mjCModel_D2Ev; mjCModel_::~mjCModel_()
mov rdi, r15
call __Unwind_Resume
| void mjCModel::mjCModel(mjCModel *this, const mjCModel *a2, __m128 _XMM0)
{
long long i; // rax
*((_QWORD *)this + 1) = (char *)this + 24;
*((_QWORD *)this + 2) = 0LL;
*((_BYTE *)this + 24) = 0;
*((_QWORD *)this + 5) = (char *)this + 56;
*((_QWORD *)this + 6) = 0LL;
*((_BYTE *)this + 56) = 0;
__asm
{
vxorps xmm0, xmm0, xmm0
vmovups xmmword ptr [rdi+170h], xmm0
}
*((_QWORD *)this + 48) = 0LL;
*((_QWORD *)this + 49) = (char *)this + 408;
*((_QWORD *)this + 50) = 0LL;
*((_BYTE *)this + 408) = 0;
*((_QWORD *)this + 53) = (char *)this + 440;
*((_QWORD *)this + 54) = 0LL;
*((_BYTE *)this + 440) = 0;
*((_QWORD *)this + 57) = (char *)this + 472;
*((_QWORD *)this + 58) = 0LL;
*((_BYTE *)this + 472) = 0;
*((_QWORD *)this + 61) = (char *)this + 504;
*((_QWORD *)this + 62) = 0LL;
*((_BYTE *)this + 504) = 0;
*((_QWORD *)this + 65) = (char *)this + 536;
*((_QWORD *)this + 66) = 0LL;
*((_BYTE *)this + 536) = 0;
*((_QWORD *)this + 69) = (char *)this + 568;
*((_QWORD *)this + 70) = 0LL;
*((_BYTE *)this + 568) = 0;
*((_QWORD *)this + 73) = (char *)this + 600;
*((_QWORD *)this + 74) = 0LL;
*((_BYTE *)this + 600) = 0;
*((_QWORD *)this + 77) = (char *)this + 632;
*((_QWORD *)this + 78) = 0LL;
*((_BYTE *)this + 632) = 0;
*((_QWORD *)this + 81) = (char *)this + 664;
*((_QWORD *)this + 82) = 0LL;
*((_BYTE *)this + 664) = 0;
*((_QWORD *)this + 85) = (char *)this + 696;
*((_QWORD *)this + 86) = 0LL;
*((_BYTE *)this + 696) = 0;
*(double *)_XMM0.m128_u64 = memset((char *)this + 3208, 0LL, 624LL);
for ( i = 4048LL; i != 5296; i += 48LL )
{
*(_DWORD *)((char *)this + i) = 0;
*(_QWORD *)((char *)this + i + 8) = 0LL;
*(_QWORD *)((char *)this + i + 16) = (char *)this + i;
*(_QWORD *)((char *)this + i + 24) = (char *)this + i;
*(_QWORD *)((char *)this + i + 32) = 0LL;
}
mjCError::mjCError((mjCModel *)((char *)this + 5288), 0LL, 0LL, 0LL, 0, 0);
mjCModel::CreateObjectLists(this, _XMM0);
mjCModel::operator=(this);
}
| mjCModel:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x18]
MOV qword ptr [RDI + 0x8],RAX
XOR R12D,R12D
MOV qword ptr [RDI + 0x10],R12
MOV byte ptr [RDI + 0x18],R12B
LEA RAX,[RDI + 0x38]
MOV qword ptr [RDI + 0x28],RAX
MOV qword ptr [RDI + 0x30],R12
MOV byte ptr [RDI + 0x38],R12B
VXORPS XMM0,XMM0,XMM0
VMOVUPS xmmword ptr [RDI + 0x170],XMM0
MOV qword ptr [RDI + 0x180],R12
LEA RAX,[RDI + 0x198]
MOV qword ptr [RDI + 0x188],RAX
MOV qword ptr [RDI + 0x190],R12
MOV byte ptr [RDI + 0x198],R12B
LEA RAX,[RDI + 0x1b8]
MOV qword ptr [RDI + 0x1a8],RAX
MOV qword ptr [RDI + 0x1b0],R12
MOV byte ptr [RDI + 0x1b8],R12B
LEA RAX,[RDI + 0x1d8]
MOV qword ptr [RDI + 0x1c8],RAX
MOV qword ptr [RDI + 0x1d0],R12
MOV byte ptr [RDI + 0x1d8],R12B
LEA RAX,[RDI + 0x1f8]
MOV qword ptr [RDI + 0x1e8],RAX
MOV qword ptr [RDI + 0x1f0],R12
MOV byte ptr [RDI + 0x1f8],R12B
LEA RAX,[RDI + 0x218]
MOV qword ptr [RDI + 0x208],RAX
MOV qword ptr [RDI + 0x210],R12
MOV byte ptr [RDI + 0x218],R12B
LEA RAX,[RDI + 0x238]
MOV qword ptr [RDI + 0x228],RAX
MOV qword ptr [RDI + 0x230],R12
MOV byte ptr [RDI + 0x238],R12B
LEA RAX,[RDI + 0x258]
MOV qword ptr [RDI + 0x248],RAX
MOV qword ptr [RDI + 0x250],R12
MOV byte ptr [RDI + 0x258],R12B
LEA RAX,[RDI + 0x278]
MOV qword ptr [RDI + 0x268],RAX
MOV qword ptr [RDI + 0x270],R12
MOV byte ptr [RDI + 0x278],R12B
LEA RAX,[RDI + 0x298]
MOV qword ptr [RDI + 0x288],RAX
MOV qword ptr [RDI + 0x290],R12
MOV byte ptr [RDI + 0x298],R12B
LEA RAX,[RDI + 0x2b8]
MOV qword ptr [RDI + 0x2a8],RAX
MOV qword ptr [RDI + 0x2b0],R12
MOV byte ptr [RDI + 0x2b8],R12B
LEA R14,[RDI + 0xc88]
MOV EDX,0x270
MOV RDI,R14
XOR ESI,ESI
CALL 0x0012d300
MOV EAX,0xfd0
LAB_001efa45:
LEA RCX,[RBX + RAX*0x1]
MOV dword ptr [RBX + RAX*0x1],0x0
MOV qword ptr [RBX + RAX*0x1 + 0x8],R12
MOV qword ptr [RBX + RAX*0x1 + 0x10],RCX
MOV qword ptr [RBX + RAX*0x1 + 0x18],RCX
MOV qword ptr [RBX + RAX*0x1 + 0x20],R12
ADD RAX,0x30
CMP RAX,0x14b0
JNZ 0x001efa45
LEA RDI,[RBX + 0x14a8]
LAB_001efa77:
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0020e3f8
MOV RDI,RBX
CALL 0x001ef642
MOV RDI,RBX
MOV RSI,R15
CALL 0x001efd90
LAB_001efa9b:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* mjCModel::mjCModel(mjCModel const&) */
void __thiscall mjCModel::mjCModel(mjCModel *this,mjCModel *param_1)
{
long lVar1;
*(mjCModel **)(this + 8) = this + 0x18;
*(int8 *)(this + 0x10) = 0;
this[0x18] = (mjCModel)0x0;
*(mjCModel **)(this + 0x28) = this + 0x38;
*(int8 *)(this + 0x30) = 0;
this[0x38] = (mjCModel)0x0;
*(int8 *)(this + 0x170) = 0;
*(int8 *)(this + 0x178) = 0;
*(int8 *)(this + 0x180) = 0;
*(mjCModel **)(this + 0x188) = this + 0x198;
*(int8 *)(this + 400) = 0;
this[0x198] = (mjCModel)0x0;
*(mjCModel **)(this + 0x1a8) = this + 0x1b8;
*(int8 *)(this + 0x1b0) = 0;
this[0x1b8] = (mjCModel)0x0;
*(mjCModel **)(this + 0x1c8) = this + 0x1d8;
*(int8 *)(this + 0x1d0) = 0;
this[0x1d8] = (mjCModel)0x0;
*(mjCModel **)(this + 0x1e8) = this + 0x1f8;
*(int8 *)(this + 0x1f0) = 0;
this[0x1f8] = (mjCModel)0x0;
*(mjCModel **)(this + 0x208) = this + 0x218;
*(int8 *)(this + 0x210) = 0;
this[0x218] = (mjCModel)0x0;
*(mjCModel **)(this + 0x228) = this + 0x238;
*(int8 *)(this + 0x230) = 0;
this[0x238] = (mjCModel)0x0;
*(mjCModel **)(this + 0x248) = this + 600;
*(int8 *)(this + 0x250) = 0;
this[600] = (mjCModel)0x0;
*(mjCModel **)(this + 0x268) = this + 0x278;
*(int8 *)(this + 0x270) = 0;
this[0x278] = (mjCModel)0x0;
*(mjCModel **)(this + 0x288) = this + 0x298;
*(int8 *)(this + 0x290) = 0;
this[0x298] = (mjCModel)0x0;
*(mjCModel **)(this + 0x2a8) = this + 0x2b8;
*(int8 *)(this + 0x2b0) = 0;
this[0x2b8] = (mjCModel)0x0;
memset(this + 0xc88,0,0x270);
lVar1 = 0xfd0;
do {
*(int4 *)(this + lVar1) = 0;
*(int8 *)(this + lVar1 + 8) = 0;
*(mjCModel **)(this + lVar1 + 0x10) = this + lVar1;
*(mjCModel **)(this + lVar1 + 0x18) = this + lVar1;
*(int8 *)(this + lVar1 + 0x20) = 0;
lVar1 = lVar1 + 0x30;
} while (lVar1 != 0x14b0);
/* try { // try from 001efa77 to 001efa9a has its CatchHandler @ 001efaa7 */
mjCError::mjCError((mjCError *)(this + 0x14a8),(mjCBase *)0x0,(char *)0x0,(char *)0x0,0,0);
CreateObjectLists(this);
operator=(this,param_1);
return;
}
| |
26,065 | 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[](unsigned long) const | llama.cpp/common/./json.hpp | const_reference operator[](size_type idx) const
{
// const operator[] only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
return m_data.m_value.array->operator[](idx);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsigned long) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0x6568d
movq 0x8(%r14), %rax
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x25790
movq %rax, %rbx
movq %r14, %rdi
callq 0x63928
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10e6cf(%rip), %rsi # 0x173d80
leaq 0x10(%rsp), %rdi
callq 0x658f8
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x65724
xorl %ebp, %ebp
leaq 0x174c04(%rip), %rsi # 0x1da2e0
leaq 0x1eb7f(%rip), %rdx # 0x84262
movq %rbx, %rdi
callq 0x25c00
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65709
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x251b0
testb %bpl, %bpl
jne 0x65713
jmp 0x6571b
movq %rax, %r14
movq %rbx, %rdi
callq 0x26150
movq %r14, %rdi
callq 0x25ca0
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixEm:
push rbp; void *
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 2
jnz short loc_6568D
mov rax, [r14+8]
shl rsi, 4
add rsi, [rax]
mov rax, rsi
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_6568D:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseOpera_0; "cannot use operator[] with a numeric ar"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA52_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(char const(&)[52],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_65709
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_65709:
test bpl, bpl
jnz short loc_65713
jmp short loc_6571B
mov r14, rax
loc_65713:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_6571B:
mov rdi, r14
call __Unwind_Resume
| operator[]:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x2
JNZ 0x0016568d
MOV RAX,qword ptr [R14 + 0x8]
SHL RSI,0x4
ADD RSI,qword ptr [RAX]
MOV RAX,RSI
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0016568d:
MOV EDI,0x20
CALL 0x00125790
MOV RBX,RAX
MOV RDI,R14
CALL 0x00163928
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001656aa:
LEA RSI,[0x273d80]
LEA RDI,[RSP + 0x10]
CALL 0x001658f8
MOV BPL,0x1
LAB_001656be:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x131
MOV RCX,R14
CALL 0x00165724
XOR EBP,EBP
LEA RSI,[0x2da2e0]
LEA RDX,[0x184262]
MOV RDI,RBX
CALL 0x00125c00
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, 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[](unsigned long) const */
long __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[](basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,ulong param_1)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
return param_1 * 0x10 + **(long **)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 001656aa to 001656ba has its CatchHandler @ 00165710 */
detail::concat<std::__cxx11::string,char_const(&)[52],char_const*>
(local_38,"cannot use operator[] with a numeric argument with ",&local_40);
/* try { // try from 001656be to 001656ea has its CatchHandler @ 001656eb */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x131,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
| ||
26,066 | JS_DeleteProperty | bluesky950520[P]quickjs/quickjs.c | int JS_DeleteProperty(JSContext *ctx, JSValue obj, JSAtom prop, int flags)
{
JSValue obj1;
JSObject *p;
int res;
obj1 = JS_ToObject(ctx, obj);
if (JS_IsException(obj1))
return -1;
p = JS_VALUE_GET_OBJ(obj1);
res = delete_property(ctx, p, prop);
JS_FreeValue(ctx, obj1);
if (res != FALSE)
return res;
if ((flags & JS_PROP_THROW) ||
((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
JS_ThrowTypeError(ctx, "could not delete property");
return -1;
}
return FALSE;
} | O1 | c | JS_DeleteProperty:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdi, %rbx
callq 0x26ddd
movq %rdx, %r12
movq %rax, (%rsp)
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpl $0x6, %r12d
je 0x26dcb
movq (%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x26f46
movl %eax, %r14d
movq 0x18(%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1d8c6
testl %r14d, %r14d
jne 0x26dcb
btl $0xe, %ebp
jb 0x26db4
xorl %r14d, %r14d
testw %bp, %bp
jns 0x26dcb
movq 0x18(%rbx), %rax
movq 0x108(%rax), %rax
testq %rax, %rax
je 0x26dcb
cmpl $0x0, 0x40(%rax)
jns 0x26dcb
leaq 0x77f8d(%rip), %rsi # 0x9ed48
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22567
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| JS_DeleteProperty:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, r8d
mov r15d, ecx
mov rbx, rdi
call JS_ToObject
mov r12, rdx
mov [rsp+38h+var_38], rax
mov r14d, 0FFFFFFFFh
cmp r12d, 6
jz short loc_26DCB
mov r13, [rsp+38h+var_38]
mov rdi, rbx
mov rsi, r13
mov edx, r15d
call delete_property
mov r14d, eax
mov rdi, [rbx+18h]
mov rsi, r13
mov rdx, r12
call JS_FreeValueRT
test r14d, r14d
jnz short loc_26DCB
bt ebp, 0Eh
jb short loc_26DB4
xor r14d, r14d
test bp, bp
jns short loc_26DCB
mov rax, [rbx+18h]
mov rax, [rax+108h]
test rax, rax
jz short loc_26DCB
cmp dword ptr [rax+40h], 0
jns short loc_26DCB
loc_26DB4:
lea rsi, aCouldNotDelete; "could not delete property"
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov r14d, 0FFFFFFFFh
loc_26DCB:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long JS_DeleteProperty(
long long a1,
long long a2,
long long a3,
unsigned int a4,
__int16 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v15; // rax
long long v16; // rdx
long long v17; // r12
unsigned int v18; // r14d
long long v19; // rdx
long long v20; // rcx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
long long v25; // rax
_DWORD *v27; // [rsp+0h] [rbp-38h]
v15 = JS_ToObject(a1, a2, a3);
v17 = v16;
v27 = (_DWORD *)v15;
v18 = -1;
if ( (_DWORD)v16 != 6 )
{
v18 = delete_property(a1, v15, a4);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v27, v17);
if ( !v18 )
{
if ( (a5 & 0x4000) != 0
|| (v18 = 0, a5 < 0) && (v25 = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 264LL)) != 0 && *(int *)(v25 + 64) < 0 )
{
JS_ThrowTypeError(
a1,
(long long)"could not delete property",
v19,
v20,
v21,
v22,
a6,
a7,
a8,
a9,
v23,
v24,
a12,
a13,
(char)v27);
return (unsigned int)-1;
}
}
}
return v18;
}
| JS_DeleteProperty:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,R8D
MOV R15D,ECX
MOV RBX,RDI
CALL 0x00126ddd
MOV R12,RDX
MOV qword ptr [RSP],RAX
MOV R14D,0xffffffff
CMP R12D,0x6
JZ 0x00126dcb
MOV R13,qword ptr [RSP]
MOV RDI,RBX
MOV RSI,R13
MOV EDX,R15D
CALL 0x00126f46
MOV R14D,EAX
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R13
MOV RDX,R12
CALL 0x0011d8c6
TEST R14D,R14D
JNZ 0x00126dcb
BT EBP,0xe
JC 0x00126db4
XOR R14D,R14D
TEST BP,BP
JNS 0x00126dcb
MOV RAX,qword ptr [RBX + 0x18]
MOV RAX,qword ptr [RAX + 0x108]
TEST RAX,RAX
JZ 0x00126dcb
CMP dword ptr [RAX + 0x40],0x0
JNS 0x00126dcb
LAB_00126db4:
LEA RSI,[0x19ed48]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00122567
MOV R14D,0xffffffff
LAB_00126dcb:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int JS_DeleteProperty(long param_1,int8 param_2,int8 param_3,int4 param_4,
uint param_5)
{
long lVar1;
int iVar2;
int1 auVar3 [16];
auVar3 = JS_ToObject();
iVar2 = -1;
if (auVar3._8_4_ != 6) {
iVar2 = delete_property(param_1,auVar3._0_8_,param_4);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar3._0_8_,auVar3._8_8_);
if (iVar2 == 0) {
if ((param_5 >> 0xe & 1) == 0) {
if (-1 < (short)param_5) {
return 0;
}
lVar1 = *(long *)(*(long *)(param_1 + 0x18) + 0x108);
if (lVar1 == 0) {
return 0;
}
if (-1 < *(int *)(lVar1 + 0x40)) {
return 0;
}
}
JS_ThrowTypeError(param_1,"could not delete property");
iVar2 = -1;
}
}
return iVar2;
}
| |
26,067 | 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x194d0
movq -0x10(%rbp), %rdi
movl $0x168, %esi # imm = 0x168
callq 0x9730
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN5nglog10NullStreamD0Ev:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
mov [rbp+var_10], rdi
call _ZN5nglog10NullStreamD1Ev; nglog::NullStream::~NullStream()
mov rdi, [rbp+var_10]; void *
mov esi, 168h; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
add rsp, 10h
pop rbp
retn
| void nglog::NullStream::~NullStream(nglog::NullStream *this)
{
nglog::NullStream::~NullStream(this);
operator delete(this, 0x168uLL);
}
| ~NullStream:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RDI
CALL 0x001194d0
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x168
CALL 0x00109730
ADD RSP,0x10
POP RBP
RET
|
/* nglog::NullStream::~NullStream() */
void __thiscall nglog::NullStream::~NullStream(NullStream *this)
{
~NullStream(this);
operator_delete(this,0x168);
return;
}
| |
26,068 | 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 %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
leaq 0x1d4c3(%rip), %rcx # 0x2e8b8
leaq 0x18(%rcx), %rdx
leaq (%rdi,%rax), %rbx
addq $0x60, %rbx
movq %rdx, -0x60(%rbx)
addq $0x40, %rcx
movq %rcx, (%rbx)
movq 0x1db35(%rip), %rcx # 0x2ef48
addq $0x10, %rcx
movq %rcx, -0x58(%rbx)
addq %rax, %rdi
addq $0x40, %rdi
callq 0x7790
movq %rbx, %rdi
popq %rbx
jmp 0x7170
| _ZTv0_n24_N5nglog10NullStreamD1Ev:
push rbx
mov rax, [rdi]
mov rax, [rax-18h]
lea rcx, _ZTCN5nglog10NullStreamE0_NS_10LogMessage9LogStreamE; `construction vtable for'nglog::LogMessage::LogStream-in-nglog::NullStream
lea rdx, [rcx+18h]
lea rbx, [rdi+rax]
add rbx, 60h ; '`'
mov [rbx-60h], rdx
add rcx, 40h ; '@'
mov [rbx], rcx
mov rcx, cs:_ZTVSt15basic_streambufIcSt11char_traitsIcEE_ptr
add rcx, 10h
mov [rbx-58h], rcx
add rdi, rax
add rdi, 40h ; '@'; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rdi, rbx; this
pop rbx
jmp __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
| void `virtual thunk to'nglog::NullStream::~NullStream(nglog::NullStream *this)
{
long long v1; // rax
std::ios_base *v2; // rbx
v1 = *(_QWORD *)(*(_QWORD *)this - 24LL);
v2 = (nglog::NullStream *)((char *)this + v1 + 96);
*((_QWORD *)v2 - 12) = (char *)&`construction vtable for'nglog::LogMessage::LogStream-in-nglog::NullStream + 24;
*(_QWORD *)v2 = (char *)&`construction vtable for'nglog::LogMessage::LogStream-in-nglog::NullStream + 64;
*((_QWORD *)v2 - 11) = (char *)&`vtable for'std::streambuf + 16;
std::locale::~locale((nglog::NullStream *)((char *)this + v1 + 64));
std::ios_base::~ios_base(v2);
}
| ~NullStream:
PUSH RBX
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
LEA RCX,[0x12e8b8]
LEA RDX,[RCX + 0x18]
LEA RBX,[RDI + RAX*0x1]
ADD RBX,0x60
MOV qword ptr [RBX + -0x60],RDX
ADD RCX,0x40
MOV qword ptr [RBX],RCX
MOV RCX,qword ptr [0x0012ef48]
ADD RCX,0x10
MOV qword ptr [RBX + -0x58],RCX
ADD RDI,RAX
ADD RDI,0x40
CALL 0x00107790
MOV RDI,RBX
POP RBX
JMP 0x00107170
|
/* 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 = 0x12e8d0;
*(int8 *)(pNVar1 + 0x60) = 0x12e8f8;
*(int **)(pNVar1 + 8) = PTR_vtable_0012ef48 + 0x10;
std::locale::~locale((locale *)(this + lVar2 + 0x40));
std::ios_base::~ios_base((ios_base *)(pNVar1 + 0x60));
return;
}
| |
26,069 | 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
callq 0xe826
movl $0x168, %esi # imm = 0x168
movq %rbx, %rdi
popq %rbx
jmp 0x75c0
nop
| _ZN5nglog10NullStreamD0Ev:
push rbx
mov rbx, rdi
call _ZN5nglog10NullStreamD1Ev; nglog::NullStream::~NullStream()
mov esi, 168h; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void nglog::NullStream::~NullStream(nglog::NullStream *this)
{
nglog::NullStream::~NullStream(this);
operator delete(this, 0x168uLL);
}
| ~NullStream:
PUSH RBX
MOV RBX,RDI
CALL 0x0010e826
MOV ESI,0x168
MOV RDI,RBX
POP RBX
JMP 0x001075c0
|
/* nglog::NullStream::~NullStream() */
void __thiscall nglog::NullStream::~NullStream(NullStream *this)
{
~NullStream(this);
operator_delete(this,0x168);
return;
}
| |
26,070 | 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 0x1d746(%rip), %rcx # 0x2e8f8
leaq 0x18(%rcx), %rdx
leaq (%rdi,%rax), %r14
addq $0x60, %r14
movq %rdx, -0x60(%r14)
addq $0x40, %rcx
movq %rcx, (%r14)
movq 0x1dd78(%rip), %rcx # 0x2ef48
addq $0x10, %rcx
movq %rcx, -0x58(%r14)
addq %rax, %rdi
addq $0x40, %rdi
callq 0x7790
movq %r14, %rdi
callq 0x7170
movl $0x168, %esi # imm = 0x168
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7540
| _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, 0x168uLL);
}
| ~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,[0x12e8f8]
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 [0x0012ef48]
ADD RCX,0x10
MOV qword ptr [R14 + -0x58],RCX
ADD RDI,RAX
ADD RDI,0x40
CALL 0x00107790
MOV RDI,R14
CALL 0x00107170
MOV ESI,0x168
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00107540
|
/* 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 = 0x12e910;
*(int8 *)(pNVar1 + 0x60) = 0x12e938;
*(int **)(pNVar1 + 8) = PTR_vtable_0012ef48 + 0x10;
std::locale::~locale((locale *)(this + lVar2 + 0x40));
std::ios_base::~ios_base((ios_base *)(pNVar1 + 0x60));
operator_delete(this + lVar2,0x168);
return;
}
| |
26,071 | wait_for_free_space | eloqsql/mysys/errors.c | void wait_for_free_space(const char *filename, int errors)
{
if (errors == 0)
my_error(EE_DISK_FULL,MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
filename,my_errno,MY_WAIT_FOR_USER_TO_FIX_PANIC);
if (!(errors % MY_WAIT_GIVE_USER_A_MESSAGE))
my_printf_error(EE_DISK_FULL,
"Retry in %d secs. Message reprinted in %d secs",
MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
MY_WAIT_FOR_USER_TO_FIX_PANIC,
MY_WAIT_GIVE_USER_A_MESSAGE * MY_WAIT_FOR_USER_TO_FIX_PANIC );
(void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
} | O3 | c | wait_for_free_space:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
je 0xa8b0d
imull $0xcccccccd, %esi, %eax # imm = 0xCCCCCCCD
movl $0x19999998, %ecx # imm = 0x19999998
addl %ecx, %eax
rorl %eax
cmpl %ecx, %eax
ja 0xa8b54
jmp 0xa8b31
movq %rdi, %rbx
callq 0xa1c0e
movl (%rax), %ecx
movl $0x844, %esi # imm = 0x844
movl $0x14, %edi
movq %rbx, %rdx
movl $0x3c, %r8d
xorl %eax, %eax
callq 0x9e11f
leaq 0x34455(%rip), %rsi # 0xdcf8d
movl $0x844, %edx # imm = 0x844
movl $0x14, %edi
movl $0x3c, %ecx
movl $0x258, %r8d # imm = 0x258
xorl %eax, %eax
callq 0x9e239
movl $0x3c, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x298b0
| wait_for_free_space:
push rbp
mov rbp, rsp
push rbx
push rax
test esi, esi
jz short loc_A8B0D
imul eax, esi, 0CCCCCCCDh
mov ecx, 19999998h
add eax, ecx
ror eax, 1
cmp eax, ecx
ja short loc_A8B54
jmp short loc_A8B31
loc_A8B0D:
mov rbx, rdi
call _my_thread_var
mov ecx, [rax]
mov esi, 844h
mov edi, 14h
mov rdx, rbx
mov r8d, 3Ch ; '<'
xor eax, eax
call my_error
loc_A8B31:
lea rsi, aRetryInDSecsMe; "Retry in %d secs. Message reprinted in "...
mov edx, 844h
mov edi, 14h
mov ecx, 3Ch ; '<'
mov r8d, 258h
xor eax, eax
call my_printf_error
loc_A8B54:
mov edi, 3Ch ; '<'
add rsp, 8
pop rbx
pop rbp
jmp _sleep
| long long wait_for_free_space(
long long a1,
int a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
char v14; // al
unsigned int *v15; // rax
char v17; // [rsp-8h] [rbp-10h]
v17 = v14;
if ( !a2 )
{
v15 = (unsigned int *)my_thread_var();
my_error(0x14u, 2116LL, a1, *v15, 60LL);
LABEL_5:
my_printf_error(
20,
(long long)"Retry in %d secs. Message reprinted in %d secs",
2116,
60LL,
600LL,
a14,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
v17);
return sleep(60LL);
}
if ( __ROR4__(-858993459 * a2 + 429496728, 1) <= 0x19999998u )
goto LABEL_5;
return sleep(60LL);
}
| wait_for_free_space:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
TEST ESI,ESI
JZ 0x001a8b0d
IMUL EAX,ESI,-0x33333333
MOV ECX,0x19999998
ADD EAX,ECX
ROR EAX,0x1
CMP EAX,ECX
JA 0x001a8b54
JMP 0x001a8b31
LAB_001a8b0d:
MOV RBX,RDI
CALL 0x001a1c0e
MOV ECX,dword ptr [RAX]
MOV ESI,0x844
MOV EDI,0x14
MOV RDX,RBX
MOV R8D,0x3c
XOR EAX,EAX
CALL 0x0019e11f
LAB_001a8b31:
LEA RSI,[0x1dcf8d]
MOV EDX,0x844
MOV EDI,0x14
MOV ECX,0x3c
MOV R8D,0x258
XOR EAX,EAX
CALL 0x0019e239
LAB_001a8b54:
MOV EDI,0x3c
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001298b0
|
void wait_for_free_space(int8 param_1,int param_2)
{
uint uVar1;
int4 *puVar2;
if (param_2 == 0) {
puVar2 = (int4 *)_my_thread_var();
my_error(0x14,0x844,param_1,*puVar2,0x3c);
}
else {
uVar1 = param_2 * -0x33333333 + 0x19999998;
if (0x19999998 < (uVar1 >> 1 | (uint)((uVar1 & 1) != 0) << 0x1f)) goto LAB_001a8b54;
}
my_printf_error(0x14,"Retry in %d secs. Message reprinted in %d secs",0x844,0x3c,600);
LAB_001a8b54:
sleep(0x3c);
return;
}
| |
26,072 | nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::basic_json(nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>&&) | 7CodeWizard[P]stablediffusion/thirdparty/json.hpp | basic_json(basic_json&& other) noexcept
: m_type(std::move(other.m_type)),
m_value(std::move(other.m_value))
{
// check that passed value is valid
other.assert_invariant(false);
// invalidate payload
other.m_type = value_t::null;
other.m_value = {};
set_parents();
assert_invariant();
} | O0 | cpp | nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::basic_json(nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>&&):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movb (%rcx), %cl
movb %cl, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0xc9070
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
callq 0xcaa90
jmp 0xc9a75
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0xc9070
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x31a30
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEEC2EOSD_:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_20], rax
mov rcx, [rsp+28h+var_10]
mov cl, [rcx]
mov [rax], cl
mov rcx, [rsp+28h+var_10]
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rdi, [rsp+28h+var_10]
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEE16assert_invariantEb; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::assert_invariant(bool)
mov rdi, [rsp+28h+var_20]
mov rax, [rsp+28h+var_10]
mov byte ptr [rax], 0
mov [rsp+28h+var_18], 0
mov rax, [rsp+28h+var_10]
mov rcx, [rsp+28h+var_18]
mov [rax+8], rcx
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEE11set_parentsEv; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::set_parents(void)
jmp short $+2
loc_C9A75:
mov rdi, [rsp+28h+var_20]
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEE16assert_invariantEb; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::assert_invariant(bool)
add rsp, 28h
retn
mov rdi, rax
call __clang_call_terminate
| char nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::basic_json(
long long a1,
long long a2)
{
*(_BYTE *)a1 = *(_BYTE *)a2;
*(_QWORD *)(a1 + 8) = *(_QWORD *)(a2 + 8);
nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::assert_invariant(
a2,
0);
*(_BYTE *)a2 = 0;
*(_QWORD *)(a2 + 8) = 0LL;
nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::set_parents(a1);
return nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::assert_invariant(
a1,
1);
}
| basic_json:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV RCX,qword ptr [RSP + 0x18]
MOV CL,byte ptr [RCX]
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RSP + 0x18]
XOR ESI,ESI
CALL 0x001c9070
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x18]
MOV byte ptr [RAX],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
LAB_001c9a6e:
CALL 0x001caa90
JMP 0x001c9a75
LAB_001c9a75:
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x1
CALL 0x001c9070
ADD RSP,0x28
RET
|
/* nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >
>::basic_json(nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::string,
bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> > >&&) */
void __thiscall
nlohmann::json_abi_v3_11_2::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
::basic_json(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
*this,basic_json *param_1)
{
*this = (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
)*param_1;
*(int8 *)(this + 8) = *(int8 *)(param_1 + 8);
assert_invariant(SUB81(param_1,0));
*param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
/* try { // try from 001c9a6e to 001c9a72 has its CatchHandler @ 001c9a89 */
set_parents();
assert_invariant(SUB81(this,0));
return;
}
| |
26,073 | nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::basic_json(nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>&&) | 7CodeWizard[P]stablediffusion/thirdparty/json.hpp | basic_json(basic_json&& other) noexcept
: m_type(std::move(other.m_type)),
m_value(std::move(other.m_value))
{
// check that passed value is valid
other.assert_invariant(false);
// invalidate payload
other.m_type = value_t::null;
other.m_value = {};
set_parents();
assert_invariant();
} | O2 | cpp | nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::basic_json(nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>&&):
movb (%rsi), %al
movb %al, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movb $0x0, (%rsi)
andq $0x0, 0x8(%rsi)
movq %rsi, %rdi
jmp 0x4a6b0
nop
| _ZSt19__relocate_object_aIN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEEESE_SaISE_EEvPT_PT0_RT1_:
mov al, [rsi]
mov [rdi], al
mov rax, [rsi+8]
mov [rdi+8], rax
mov byte ptr [rsi], 0
and qword ptr [rsi+8], 0
mov rdi, rsi
jmp _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEED2Ev; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::~basic_json()
| long long std::__relocate_object_a<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,std::allocator<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>>>(
long long a1,
long long a2)
{
*(_BYTE *)a1 = *(_BYTE *)a2;
*(_QWORD *)(a1 + 8) = *(_QWORD *)(a2 + 8);
*(_BYTE *)a2 = 0;
*(_QWORD *)(a2 + 8) = 0LL;
return nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::~basic_json(a2);
}
| __relocate_object_a<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,std::allocator<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>>>:
MOV AL,byte ptr [RSI]
MOV byte ptr [RDI],AL
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x8],RAX
MOV byte ptr [RSI],0x0
AND qword ptr [RSI + 0x8],0x0
MOV RDI,RSI
JMP 0x0014a6b0
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__relocate_object_a<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> > >, nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::string,
bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> > >,
std::allocator<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> > > > >(nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::string,
bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> > >*,
nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> > >*,
std::allocator<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> > > >&) */
void std::
__relocate_object_a<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,std::allocator<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>>>
(basic_json *param_1,basic_json *param_2,allocator *param_3)
{
*param_1 = *param_2;
*(int8 *)(param_1 + 8) = *(int8 *)(param_2 + 8);
*param_2 = 0;
*(int8 *)(param_2 + 8) = 0;
nlohmann::json_abi_v3_11_2::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
::~basic_json((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
*)param_2);
return;
}
| |
26,074 | LefDefParser::lefiCalcTime() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiTBExt.cpp | time_t
lefiCalcTime()
{
// Calculate the number for the given date
// The date is 5/1/99
/* Used to calculate the UTC for a time bomb date in libcai.a
** see caiInitWork() function
*/
struct tm ts;
ts.tm_sec = 0;
ts.tm_min = 0;
ts.tm_hour = 0;
ts.tm_mday = 1;
ts.tm_mon = 5;
ts.tm_year = 1999 - 1900;
ts.tm_wday = 0;
ts.tm_yday = 0;
ts.tm_isdst = 0;
/*
printf("May 1, 1999 in UTC is %d\n", mktime(&ts));
ts.tm_mday = 2;
printf("May 2, 1999 in UTC is %d\n", mktime(&ts));
printf("Right now is %d\n", time(0));
*/
return (mktime(&ts));
} | O0 | cpp | LefDefParser::lefiCalcTime():
subq $0x38, %rsp
movl $0x0, (%rsp)
movl $0x0, 0x4(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x1, 0xc(%rsp)
movl $0x5, 0x10(%rsp)
movl $0x63, 0x14(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x20(%rsp)
movq %rsp, %rdi
callq 0x21a0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| _ZN12LefDefParser12lefiCalcTimeEv:
sub rsp, 38h
mov [rsp+38h+var_38], 0
mov [rsp+38h+var_34], 0
mov [rsp+38h+var_30], 0
mov [rsp+38h+var_2C], 1
mov [rsp+38h+var_28], 5
mov [rsp+38h+var_24], 63h ; 'c'
mov [rsp+38h+var_20], 0
mov [rsp+38h+var_1C], 0
mov [rsp+38h+var_18], 0
mov rdi, rsp
call _mktime
add rsp, 38h
retn
| long long LefDefParser::lefiCalcTime(LefDefParser *this)
{
_DWORD v2[14]; // [rsp+0h] [rbp-38h] BYREF
v2[0] = 0;
v2[1] = 0;
v2[2] = 0;
v2[3] = 1;
v2[4] = 5;
v2[5] = 99;
v2[6] = 0;
v2[7] = 0;
v2[8] = 0;
return ((long long ( *)(_DWORD *))mktime)(v2);
}
| lefiCalcTime:
SUB RSP,0x38
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x4],0x0
MOV dword ptr [RSP + 0x8],0x0
MOV dword ptr [RSP + 0xc],0x1
MOV dword ptr [RSP + 0x10],0x5
MOV dword ptr [RSP + 0x14],0x63
MOV dword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x1c],0x0
MOV dword ptr [RSP + 0x20],0x0
MOV RDI,RSP
CALL 0x001021a0
ADD RSP,0x38
RET
|
/* LefDefParser::lefiCalcTime() */
void LefDefParser::lefiCalcTime(void)
{
tm local_38;
local_38.tm_sec = 0;
local_38.tm_min = 0;
local_38.tm_hour = 0;
local_38.tm_mday = 1;
local_38.tm_mon = 5;
local_38.tm_year = 99;
local_38.tm_wday = 0;
local_38.tm_yday = 0;
local_38.tm_isdst = 0;
mktime(&local_38);
return;
}
| |
26,075 | LefDefParser::lefiCalcTime() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiTBExt.cpp | time_t
lefiCalcTime()
{
// Calculate the number for the given date
// The date is 5/1/99
/* Used to calculate the UTC for a time bomb date in libcai.a
** see caiInitWork() function
*/
struct tm ts;
ts.tm_sec = 0;
ts.tm_min = 0;
ts.tm_hour = 0;
ts.tm_mday = 1;
ts.tm_mon = 5;
ts.tm_year = 1999 - 1900;
ts.tm_wday = 0;
ts.tm_yday = 0;
ts.tm_isdst = 0;
/*
printf("May 1, 1999 in UTC is %d\n", mktime(&ts));
ts.tm_mday = 2;
printf("May 2, 1999 in UTC is %d\n", mktime(&ts));
printf("Right now is %d\n", time(0));
*/
return (mktime(&ts));
} | O3 | cpp | LefDefParser::lefiCalcTime():
subq $0x38, %rsp
movaps 0x3da41(%rip), %xmm0 # 0x6aa80
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movsd 0x3da43(%rip), %xmm0 # 0x6aa90
movaps %xmm0, 0x10(%rdi)
movl $0x0, 0x20(%rdi)
callq 0x2150
addq $0x38, %rsp
retq
| _ZN12LefDefParser12lefiCalcTimeEv:
sub rsp, 38h
movaps xmm0, cs:xmmword_6AA80
mov rdi, rsp
movaps xmmword ptr [rdi], xmm0
movsd xmm0, cs:qword_6AA90
movaps xmmword ptr [rdi+10h], xmm0
mov dword ptr [rdi+20h], 0
call _mktime
add rsp, 38h
retn
| long long LefDefParser::lefiCalcTime(LefDefParser *this, long long a2, long long a3, long long a4, long long a5)
{
_OWORD v6[2]; // [rsp+0h] [rbp-38h] BYREF
int v7; // [rsp+20h] [rbp-18h]
v6[0] = xmmword_6AA80;
v6[1] = 0x6300000005uLL;
v7 = 0;
return mktime(v6, a2, a3, a4, a5);
}
| lefiCalcTime:
SUB RSP,0x38
MOVAPS XMM0,xmmword ptr [0x0016aa80]
MOV RDI,RSP
MOVAPS xmmword ptr [RDI],XMM0
MOVSD XMM0,qword ptr [0x0016aa90]
MOVAPS xmmword ptr [RDI + 0x10],XMM0
MOV dword ptr [RDI + 0x20],0x0
CALL 0x00102150
ADD RSP,0x38
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* LefDefParser::lefiCalcTime() */
void LefDefParser::lefiCalcTime(void)
{
tm local_38;
local_38._0_8_ = _DAT_0016aa80;
local_38._8_8_ = _UNK_0016aa88;
local_38._16_8_ = DAT_0016aa90;
local_38.tm_wday = 0;
local_38.tm_yday = 0;
local_38.tm_isdst = 0;
mktime(&local_38);
return;
}
| |
26,076 | ma_zlib_compress | eloqsql/libmariadb/plugins/compress/c_zlib.c | my_bool ma_zlib_compress(ma_compress_ctx *ctx, void *dst,
size_t *dst_len, void *source, size_t source_len)
{
int rc;
if (!ctx)
return 1;
if ((rc= compress2((Bytef *)dst, (uLongf *)dst_len, (Bytef *)source, (uLong)source_len,
ctx->compression_level)) != Z_OK)
return 1;
return 0;
} | O0 | c | ma_zlib_compress:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x194d9
movb $0x1, -0x1(%rbp)
jmp 0x19508
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r8d
callq 0x17310
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x19504
movb $0x1, -0x1(%rbp)
jmp 0x19508
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_zlib_compress:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
cmp [rbp+var_10], 0
jnz short loc_194D9
mov [rbp+var_1], 1
jmp short loc_19508
loc_194D9:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov r8d, [rax+10h]
call _compress2
mov [rbp+var_34], eax
cmp eax, 0
jz short loc_19504
mov [rbp+var_1], 1
jmp short loc_19508
loc_19504:
mov [rbp+var_1], 0
loc_19508:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| bool ma_zlib_compress(long long a1, long long a2, long long a3, long long a4, long long a5)
{
return !a1 || (unsigned int)compress2(a2, a3, a4, a5, *(unsigned int *)(a1 + 16)) != 0;
}
| ma_zlib_compress:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x001194d9
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00119508
LAB_001194d9:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RAX + 0x10]
CALL 0x00117310
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JZ 0x00119504
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00119508
LAB_00119504:
MOV byte ptr [RBP + -0x1],0x0
LAB_00119508:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1
ma_zlib_compress(long param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
int iVar1;
int1 local_9;
if (param_1 == 0) {
local_9 = 1;
}
else {
iVar1 = compress2(param_2,param_3,param_4,param_5,*(int4 *)(param_1 + 0x10));
if (iVar1 == 0) {
local_9 = 0;
}
else {
local_9 = 1;
}
}
return local_9;
}
| |
26,077 | ma_zlib_compress | eloqsql/libmariadb/plugins/compress/c_zlib.c | my_bool ma_zlib_compress(ma_compress_ctx *ctx, void *dst,
size_t *dst_len, void *source, size_t source_len)
{
int rc;
if (!ctx)
return 1;
if ((rc= compress2((Bytef *)dst, (uLongf *)dst_len, (Bytef *)source, (uLong)source_len,
ctx->compression_level)) != Z_OK)
return 1;
return 0;
} | O3 | c | ma_zlib_compress:
testq %rdi, %rdi
je 0x18a77
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rdi), %eax
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movl %eax, %r8d
callq 0x17300
testl %eax, %eax
setne %al
popq %rbp
retq
movb $0x1, %al
retq
| ma_zlib_compress:
test rdi, rdi
jz short loc_18A77
push rbp
mov rbp, rsp
mov eax, [rdi+10h]
mov rdi, rsi
mov rsi, rdx
mov rdx, rcx
mov rcx, r8
mov r8d, eax
call _compress2
test eax, eax
setnz al
pop rbp
retn
loc_18A77:
mov al, 1
retn
| bool ma_zlib_compress(long long a1, long long a2, long long a3, long long a4, long long a5)
{
return !a1 || (unsigned int)compress2(a2, a3, a4, a5, *(unsigned int *)(a1 + 16)) != 0;
}
| ma_zlib_compress:
TEST RDI,RDI
JZ 0x00118a77
PUSH RBP
MOV RBP,RSP
MOV EAX,dword ptr [RDI + 0x10]
MOV RDI,RSI
MOV RSI,RDX
MOV RDX,RCX
MOV RCX,R8
MOV R8D,EAX
CALL 0x00117300
TEST EAX,EAX
SETNZ AL
POP RBP
RET
LAB_00118a77:
MOV AL,0x1
RET
|
bool ma_zlib_compress(long param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
int iVar1;
if (param_1 != 0) {
iVar1 = compress2(param_2,param_3,param_4,param_5,*(int4 *)(param_1 + 0x10));
return iVar1 != 0;
}
return true;
}
| |
26,078 | findPeaks::_local_maxima_1d(std::vector<double, std::allocator<double>> const&) | giladroyz[P]FindPeaks/src/cpp/find_peaks.cpp | std::vector<lmr_peak_index_t> _local_maxima_1d(const std::vector<double> &x) {
std::vector<lmr_peak_index_t> peaks;
if (x.empty())
return peaks;
size_t i_ahead;
size_t i_max = x.size() - 1;
for (size_t i = 1; i < i_max; i++) {
// `i` is the Pointer to current sample, first one can't be maxima
//Test if previous sample is smaller
if (x[i - 1] < x[i]) {
//Index to look ahead of current sample
i_ahead = i + 1;
//Find next sample that is unequal to x[i]
while (i_ahead < i_max && x[i_ahead] == x[i])
i_ahead++;
//Maxima is found if next unequal sample is smaller than x[i]
if (x[i_ahead] < x[i]) {
lmr_peak_index_t peak;
peak.left_edge = i;
peak.right_edge = i_ahead - 1;
peak.mid_point = (peak.left_edge + peak.right_edge) / 2;
peaks.push_back(peak);
//Skip samples that can't be maximum
i = i_ahead;
}
}
}
return peaks;
} | O0 | cpp | findPeaks::_local_maxima_1d(std::vector<double, std::allocator<double>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x6d30
movq -0x10(%rbp), %rdi
callq 0x6d50
testb $0x1, %al
jne 0x3696
jmp 0x36a6
movb $0x1, -0x11(%rbp)
movl $0x1, -0x18(%rbp)
jmp 0x381d
movq -0x10(%rbp), %rdi
callq 0x6b40
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x3812
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
subq $0x1, %rsi
callq 0x6d90
movsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6d90
movsd -0x70(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x37ff
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x71(%rbp)
jae 0x3759
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6d90
movsd (%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6d90
movsd -0x80(%rbp), %xmm0
ucomisd (%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x3762
jmp 0x3770
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3713
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6d90
movsd (%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6d90
movsd -0x88(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x37fd
movq -0x68(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
decq %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
addq %rcx, %rax
shrq %rax
movq %rax, -0x40(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x6db0
jmp 0x37dc
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x37fd
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x6e20
jmp 0x3839
jmp 0x37ff
jmp 0x3801
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x36bf
movb $0x1, -0x11(%rbp)
movl $0x1, -0x18(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x382c
movq -0x68(%rbp), %rdi
callq 0x6e20
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x1140
nopw %cs:(%rax,%rax)
| _ZN9findPeaks16_local_maxima_1dERKSt6vectorIdSaIdEE:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_68], rdi
mov rax, rdi
mov [rbp+var_60], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_11], 0
call _ZNSt6vectorIN9findPeaks16lmr_peak_index_tESaIS1_EEC2Ev; std::vector<findPeaks::lmr_peak_index_t>::vector(void)
mov rdi, [rbp+var_10]
call _ZNKSt6vectorIdSaIdEE5emptyEv; std::vector<double>::empty(void)
test al, 1
jnz short loc_3696
jmp short loc_36A6
loc_3696:
mov [rbp+var_11], 1
mov [rbp+var_18], 1
jmp loc_381D
loc_36A6:
mov rdi, [rbp+var_10]
call _ZNKSt6vectorIdSaIdEE4sizeEv; std::vector<double>::size(void)
sub rax, 1
mov [rbp+var_28], rax
mov [rbp+var_30], 1
loc_36BF:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_28]
jnb loc_3812
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
sub rsi, 1
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, qword ptr [rax]
movsd [rbp+var_70], xmm0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm1, [rbp+var_70]
movsd xmm0, qword ptr [rax]
ucomisd xmm0, xmm1
jbe loc_37FF
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_20], rax
loc_3713:
mov rcx, [rbp+var_20]
xor eax, eax
cmp rcx, [rbp+var_28]
mov [rbp+var_71], al
jnb short loc_3759
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, qword ptr [rax]
movsd [rbp+var_80], xmm0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, [rbp+var_80]
ucomisd xmm0, qword ptr [rax]
setz al
setnp cl
and al, cl
mov [rbp+var_71], al
loc_3759:
mov al, [rbp+var_71]
test al, 1
jnz short loc_3762
jmp short loc_3770
loc_3762:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_3713
loc_3770:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, qword ptr [rax]
movsd [rbp+var_88], xmm0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm1, [rbp+var_88]
movsd xmm0, qword ptr [rax]
ucomisd xmm0, xmm1
jbe short loc_37FD
mov rdi, [rbp+var_68]
mov rax, [rbp+var_30]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
dec rax
mov [rbp+var_38], rax
mov rax, [rbp+var_48]
mov rcx, [rbp+var_38]
add rax, rcx
shr rax, 1
mov [rbp+var_40], rax
lea rsi, [rbp+var_48]
call _ZNSt6vectorIN9findPeaks16lmr_peak_index_tESaIS1_EE9push_backERKS1_; std::vector<findPeaks::lmr_peak_index_t>::push_back(findPeaks::lmr_peak_index_t const&)
jmp short $+2
loc_37DC:
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
jmp short loc_37FD
mov rdi, [rbp+var_68]
mov rcx, rax
mov eax, edx
mov [rbp+var_50], rcx
mov [rbp+var_54], eax
call _ZNSt6vectorIN9findPeaks16lmr_peak_index_tESaIS1_EED2Ev; std::vector<findPeaks::lmr_peak_index_t>::~vector()
jmp short loc_3839
loc_37FD:
jmp short $+2
loc_37FF:
jmp short $+2
loc_3801:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp loc_36BF
loc_3812:
mov [rbp+var_11], 1
mov [rbp+var_18], 1
loc_381D:
test [rbp+var_11], 1
jnz short loc_382C
mov rdi, [rbp+var_68]
call _ZNSt6vectorIN9findPeaks16lmr_peak_index_tESaIS1_EED2Ev; std::vector<findPeaks::lmr_peak_index_t>::~vector()
loc_382C:
mov rax, [rbp+var_60]
add rsp, 90h
pop rbp
retn
loc_3839:
mov rdi, [rbp+var_50]
call __Unwind_Resume
| long long findPeaks::_local_maxima_1d(long long a1, long long a2)
{
double v3; // [rsp+8h] [rbp-88h]
double v4; // [rsp+10h] [rbp-80h]
bool v5; // [rsp+1Fh] [rbp-71h]
double v6; // [rsp+20h] [rbp-70h]
_QWORD v7[3]; // [rsp+48h] [rbp-48h] BYREF
unsigned long long i; // [rsp+60h] [rbp-30h]
unsigned long long v9; // [rsp+68h] [rbp-28h]
unsigned long long j; // [rsp+70h] [rbp-20h]
int v11; // [rsp+78h] [rbp-18h]
char v12; // [rsp+7Fh] [rbp-11h]
long long v13; // [rsp+80h] [rbp-10h]
long long v14; // [rsp+88h] [rbp-8h]
v14 = a1;
v13 = a2;
v12 = 0;
std::vector<findPeaks::lmr_peak_index_t>::vector();
if ( (std::vector<double>::empty(a2) & 1) != 0 )
{
v12 = 1;
v11 = 1;
}
else
{
v9 = std::vector<double>::size(v13) - 1;
for ( i = 1LL; i < v9; ++i )
{
v6 = *(double *)std::vector<double>::operator[](v13, i - 1);
if ( *(double *)std::vector<double>::operator[](v13, i) > v6 )
{
for ( j = i + 1; ; ++j )
{
v5 = 0;
if ( j < v9 )
{
v4 = *(double *)std::vector<double>::operator[](v13, j);
v5 = v4 == *(double *)std::vector<double>::operator[](v13, i);
}
if ( !v5 )
break;
}
v3 = *(double *)std::vector<double>::operator[](v13, j);
if ( *(double *)std::vector<double>::operator[](v13, i) > v3 )
{
v7[0] = i;
v7[2] = j - 1;
v7[1] = (j - 1 + i) >> 1;
std::vector<findPeaks::lmr_peak_index_t>::push_back(a1, v7);
i = j;
}
}
}
v12 = 1;
v11 = 1;
}
return a1;
}
| _local_maxima_1d:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x60],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x11],0x0
CALL 0x00106d30
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00106d50
TEST AL,0x1
JNZ 0x00103696
JMP 0x001036a6
LAB_00103696:
MOV byte ptr [RBP + -0x11],0x1
MOV dword ptr [RBP + -0x18],0x1
JMP 0x0010381d
LAB_001036a6:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00106b40
SUB RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x30],0x1
LAB_001036bf:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x00103812
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
SUB RSI,0x1
CALL 0x00106d90
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x70],XMM0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00106d90
MOVSD XMM1,qword ptr [RBP + -0x70]
MOVSD XMM0,qword ptr [RAX]
UCOMISD XMM0,XMM1
JBE 0x001037ff
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
LAB_00103713:
MOV RCX,qword ptr [RBP + -0x20]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x71],AL
JNC 0x00103759
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00106d90
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x80],XMM0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00106d90
MOVSD XMM0,qword ptr [RBP + -0x80]
UCOMISD XMM0,qword ptr [RAX]
SETZ AL
SETNP CL
AND AL,CL
MOV byte ptr [RBP + -0x71],AL
LAB_00103759:
MOV AL,byte ptr [RBP + -0x71]
TEST AL,0x1
JNZ 0x00103762
JMP 0x00103770
LAB_00103762:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00103713
LAB_00103770:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00106d90
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x88],XMM0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00106d90
MOVSD XMM1,qword ptr [RBP + -0x88]
MOVSD XMM0,qword ptr [RAX]
UCOMISD XMM0,XMM1
JBE 0x001037fd
MOV RDI,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
DEC RAX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x38]
ADD RAX,RCX
SHR RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
LAB_001037d1:
LEA RSI,[RBP + -0x48]
CALL 0x00106db0
LAB_001037da:
JMP 0x001037dc
LAB_001037dc:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001037fd
LAB_001037fd:
JMP 0x001037ff
LAB_001037ff:
JMP 0x00103801
LAB_00103801:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001036bf
LAB_00103812:
MOV byte ptr [RBP + -0x11],0x1
MOV dword ptr [RBP + -0x18],0x1
LAB_0010381d:
TEST byte ptr [RBP + -0x11],0x1
JNZ 0x0010382c
MOV RDI,qword ptr [RBP + -0x68]
CALL 0x00106e20
LAB_0010382c:
MOV RAX,qword ptr [RBP + -0x60]
ADD RSP,0x90
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00103823) */
/* findPeaks::_local_maxima_1d(std::vector<double, std::allocator<double> > const&) */
findPeaks * __thiscall findPeaks::_local_maxima_1d(findPeaks *this,vector *param_1)
{
double dVar1;
bool bVar2;
ulong uVar3;
long lVar4;
double *pdVar5;
ulong local_50;
ulong local_48;
long local_40;
ulong local_38;
ulong local_30;
ulong local_28;
int1 local_19;
vector<double,std::allocator<double>> *local_18;
findPeaks *local_10;
local_19 = 0;
local_18 = (vector<double,std::allocator<double>> *)param_1;
local_10 = this;
std::vector<findPeaks::lmr_peak_index_t,std::allocator<findPeaks::lmr_peak_index_t>>::vector
((vector<findPeaks::lmr_peak_index_t,std::allocator<findPeaks::lmr_peak_index_t>> *)this
);
uVar3 = std::vector<double,std::allocator<double>>::empty(local_18);
if ((uVar3 & 1) == 0) {
lVar4 = std::vector<double,std::allocator<double>>::size(local_18);
local_30 = lVar4 - 1;
for (local_38 = 1; local_38 < local_30; local_38 = local_38 + 1) {
pdVar5 = (double *)
std::vector<double,std::allocator<double>>::operator[](local_18,local_38 - 1);
dVar1 = *pdVar5;
pdVar5 = (double *)std::vector<double,std::allocator<double>>::operator[](local_18,local_38);
uVar3 = local_38;
if (dVar1 < *pdVar5) {
do {
local_28 = uVar3 + 1;
bVar2 = false;
if (local_28 < local_30) {
pdVar5 = (double *)
std::vector<double,std::allocator<double>>::operator[](local_18,local_28);
dVar1 = *pdVar5;
pdVar5 = (double *)
std::vector<double,std::allocator<double>>::operator[](local_18,local_38);
bVar2 = dVar1 == *pdVar5;
}
uVar3 = local_28;
} while (bVar2);
pdVar5 = (double *)std::vector<double,std::allocator<double>>::operator[](local_18,local_28)
;
dVar1 = *pdVar5;
pdVar5 = (double *)std::vector<double,std::allocator<double>>::operator[](local_18,local_38)
;
if (dVar1 < *pdVar5) {
local_50 = local_38;
local_40 = local_28 - 1;
local_48 = local_38 + local_40 >> 1;
/* try { // try from 001037d1 to 001037d9 has its CatchHandler @ 001037e6 */
std::vector<findPeaks::lmr_peak_index_t,std::allocator<findPeaks::lmr_peak_index_t>>::
push_back((vector<findPeaks::lmr_peak_index_t,std::allocator<findPeaks::lmr_peak_index_t>>
*)this,(lmr_peak_index_t *)&local_50);
local_38 = local_28;
}
}
}
}
return this;
}
| |
26,079 | findPeaks::_local_maxima_1d(std::vector<double, std::allocator<double>> const&) | giladroyz[P]FindPeaks/src/cpp/find_peaks.cpp | std::vector<lmr_peak_index_t> _local_maxima_1d(const std::vector<double> &x) {
std::vector<lmr_peak_index_t> peaks;
if (x.empty())
return peaks;
size_t i_ahead;
size_t i_max = x.size() - 1;
for (size_t i = 1; i < i_max; i++) {
// `i` is the Pointer to current sample, first one can't be maxima
//Test if previous sample is smaller
if (x[i - 1] < x[i]) {
//Index to look ahead of current sample
i_ahead = i + 1;
//Find next sample that is unequal to x[i]
while (i_ahead < i_max && x[i_ahead] == x[i])
i_ahead++;
//Maxima is found if next unequal sample is smaller than x[i]
if (x[i_ahead] < x[i]) {
lmr_peak_index_t peak;
peak.left_edge = i;
peak.right_edge = i_ahead - 1;
peak.mid_point = (peak.left_edge + peak.right_edge) / 2;
peaks.push_back(peak);
//Skip samples that can't be maximum
i = i_ahead;
}
}
}
return peaks;
} | O2 | cpp | findPeaks::_local_maxima_1d(std::vector<double, std::allocator<double>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movupd %xmm0, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %r12
cmpq %r12, %rax
je 0x1c0f
movq %rsi, %r14
subq %rax, %r12
sarq $0x3, %r12
leaq -0x1(%r12), %r15
leaq -0x2(%r12), %rbp
pushq $0x1
popq %rax
cmpq %r15, %rax
jae 0x1c0f
movq (%r14), %rcx
movsd (%rcx,%rax,8), %xmm0
ucomisd -0x8(%rcx,%rax,8), %xmm0
jbe 0x1c04
movq %rax, %rdx
leaq 0x1(%rdx), %r13
cmpq %r15, %r13
jae 0x1bd0
movsd 0x8(%rcx,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
movq %r13, %rdx
jne 0x1bca
jnp 0x1bb0
leaq -0x1(%r13), %rcx
jmp 0x1bdd
movsd -0x8(%rcx,%r12,8), %xmm1
movq %rbp, %rcx
movq %r15, %r13
ucomisd %xmm1, %xmm0
jbe 0x1c04
movq %rax, (%rsp)
movq %rcx, 0x10(%rsp)
addq %rax, %rcx
shrq %rcx
movq %rcx, 0x8(%rsp)
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x3130
jmp 0x1c07
movq %rax, %r13
incq %r13
movq %r13, %rax
jmp 0x1b98
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3900
movq %r14, %rdi
callq 0x1120
| _ZN9findPeaks16_local_maxima_1dERKSt6vectorIdSaIdEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
xorpd xmm0, xmm0
and qword ptr [rdi+10h], 0
movupd xmmword ptr [rdi], xmm0
mov rax, [rsi]
mov r12, [rsi+8]
cmp rax, r12
jz loc_1C0F
mov r14, rsi
sub r12, rax
sar r12, 3
lea r15, [r12-1]
lea rbp, [r12-2]
push 1
pop rax
loc_1B98:
cmp rax, r15
jnb short loc_1C0F
mov rcx, [r14]
movsd xmm0, qword ptr [rcx+rax*8]
ucomisd xmm0, qword ptr [rcx+rax*8-8]
jbe short loc_1C04
mov rdx, rax
loc_1BB0:
lea r13, [rdx+1]
cmp r13, r15
jnb short loc_1BD0
movsd xmm1, qword ptr [rcx+rdx*8+8]
ucomisd xmm1, xmm0
mov rdx, r13
jnz short loc_1BCA
jnp short loc_1BB0
loc_1BCA:
lea rcx, [r13-1]
jmp short loc_1BDD
loc_1BD0:
movsd xmm1, qword ptr [rcx+r12*8-8]
mov rcx, rbp
mov r13, r15
loc_1BDD:
ucomisd xmm0, xmm1
jbe short loc_1C04
mov [rsp+48h+var_48], rax
mov [rsp+48h+var_38], rcx
add rcx, rax
shr rcx, 1
mov [rsp+48h+var_40], rcx
mov rdi, rbx
mov rsi, rsp
call _ZNSt6vectorIN9findPeaks16lmr_peak_index_tESaIS1_EE9push_backERKS1_; std::vector<findPeaks::lmr_peak_index_t>::push_back(findPeaks::lmr_peak_index_t const&)
jmp short loc_1C07
loc_1C04:
mov r13, rax
loc_1C07:
inc r13
mov rax, r13
jmp short loc_1B98
loc_1C0F:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, rbx
call _ZNSt12_Vector_baseIN9findPeaks16lmr_peak_index_tESaIS1_EED2Ev; std::_Vector_base<findPeaks::lmr_peak_index_t>::~_Vector_base()
mov rdi, r14
call __Unwind_Resume
| long long findPeaks::_local_maxima_1d(long long a1, long long *a2)
{
long long v2; // r12
long long v3; // r12
unsigned long long v4; // r15
unsigned long long i; // rax
long long v6; // rcx
double v7; // xmm0_8
unsigned long long v8; // rdx
unsigned long long v9; // r13
double v10; // xmm1_8
long long v11; // rcx
_QWORD v13[9]; // [rsp+0h] [rbp-48h] BYREF
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v2 = a2[1];
if ( *a2 != v2 )
{
v3 = (v2 - *a2) >> 3;
v4 = v3 - 1;
for ( i = 1LL; i < v4; i = v9 + 1 )
{
v6 = *a2;
v7 = *(double *)(*a2 + 8 * i);
if ( v7 <= *(double *)(*a2 + 8 * i - 8) )
goto LABEL_12;
v8 = i;
while ( 1 )
{
v9 = v8 + 1;
if ( v8 + 1 >= v4 )
break;
v10 = *(double *)(v6 + 8 * v8++ + 8);
if ( v10 != v7 )
{
v11 = v9 - 1;
goto LABEL_10;
}
}
v10 = *(double *)(v6 + 8 * v3 - 8);
v11 = v3 - 2;
v9 = v3 - 1;
LABEL_10:
if ( v7 <= v10 )
{
LABEL_12:
v9 = i;
}
else
{
v13[0] = i;
v13[2] = v11;
v13[1] = (i + v11) >> 1;
((void ( *)(long long, _QWORD *, unsigned long long))std::vector<findPeaks::lmr_peak_index_t>::push_back)(
a1,
v13,
v8);
}
}
}
return a1;
}
| _local_maxima_1d:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
XORPD XMM0,XMM0
AND qword ptr [RDI + 0x10],0x0
MOVUPD xmmword ptr [RDI],XMM0
MOV RAX,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
CMP RAX,R12
JZ 0x00101c0f
MOV R14,RSI
SUB R12,RAX
SAR R12,0x3
LEA R15,[R12 + -0x1]
LEA RBP,[R12 + -0x2]
PUSH 0x1
POP RAX
LAB_00101b98:
CMP RAX,R15
JNC 0x00101c0f
MOV RCX,qword ptr [R14]
MOVSD XMM0,qword ptr [RCX + RAX*0x8]
UCOMISD XMM0,qword ptr [RCX + RAX*0x8 + -0x8]
JBE 0x00101c04
MOV RDX,RAX
LAB_00101bb0:
LEA R13,[RDX + 0x1]
CMP R13,R15
JNC 0x00101bd0
MOVSD XMM1,qword ptr [RCX + RDX*0x8 + 0x8]
UCOMISD XMM1,XMM0
MOV RDX,R13
JNZ 0x00101bca
JNP 0x00101bb0
LAB_00101bca:
LEA RCX,[R13 + -0x1]
JMP 0x00101bdd
LAB_00101bd0:
MOVSD XMM1,qword ptr [RCX + R12*0x8 + -0x8]
MOV RCX,RBP
MOV R13,R15
LAB_00101bdd:
UCOMISD XMM0,XMM1
JBE 0x00101c04
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x10],RCX
ADD RCX,RAX
SHR RCX,0x1
MOV qword ptr [RSP + 0x8],RCX
LAB_00101bf7:
MOV RDI,RBX
MOV RSI,RSP
CALL 0x00103130
LAB_00101c02:
JMP 0x00101c07
LAB_00101c04:
MOV R13,RAX
LAB_00101c07:
INC R13
MOV RAX,R13
JMP 0x00101b98
LAB_00101c0f:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* findPeaks::_local_maxima_1d(std::vector<double, std::allocator<double> > const&) */
findPeaks * __thiscall findPeaks::_local_maxima_1d(findPeaks *this,vector *param_1)
{
ulong uVar1;
double *pdVar2;
double dVar3;
long lVar4;
long lVar5;
ulong uVar6;
double dVar7;
ulong local_48;
ulong local_40;
ulong local_38;
*(int8 *)(this + 0x10) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
if (*(long *)param_1 != *(long *)(param_1 + 8)) {
lVar5 = *(long *)(param_1 + 8) - *(long *)param_1 >> 3;
uVar1 = lVar5 - 1;
for (local_48 = 1; local_48 < uVar1; local_48 = local_48 + 1) {
lVar4 = *(long *)param_1;
dVar3 = *(double *)(lVar4 + local_48 * 8);
pdVar2 = (double *)(lVar4 + -8 + local_48 * 8);
uVar6 = local_48;
if (*pdVar2 <= dVar3 && dVar3 != *pdVar2) {
while (local_38 = uVar6, uVar6 = local_38 + 1, uVar6 < uVar1) {
dVar7 = *(double *)(lVar4 + 8 + local_38 * 8);
if ((dVar7 != dVar3) || (NAN(dVar7) || NAN(dVar3))) goto LAB_00101bdd;
}
dVar7 = *(double *)(lVar4 + -8 + lVar5 * 8);
local_38 = lVar5 - 2;
uVar6 = uVar1;
LAB_00101bdd:
if (dVar7 < dVar3) {
local_40 = local_38 + local_48 >> 1;
/* try { // try from 00101bf7 to 00101c01 has its CatchHandler @ 00101c21 */
std::vector<findPeaks::lmr_peak_index_t,std::allocator<findPeaks::lmr_peak_index_t>>::
push_back((vector<findPeaks::lmr_peak_index_t,std::allocator<findPeaks::lmr_peak_index_t>>
*)this,(lmr_peak_index_t *)&local_48);
local_48 = uVar6;
}
}
}
}
return this;
}
| |
26,080 | list_builtin_chat_templates[abi:cxx11]() | monkey531[P]llama/common/arg.cpp | static std::string list_builtin_chat_templates() {
std::vector<const char *> supported_tmpl;
int32_t res = llama_chat_builtin_templates(nullptr, 0);
supported_tmpl.resize(res);
res = llama_chat_builtin_templates(supported_tmpl.data(), supported_tmpl.size());
std::ostringstream msg;
for (auto & tmpl : supported_tmpl) {
msg << tmpl << (&tmpl == &supported_tmpl.back() ? "" : ", ");
}
return msg.str();
} | O2 | cpp | list_builtin_chat_templates[abi:cxx11]():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
xorl %edi, %edi
xorl %esi, %esi
callq 0x26290
movslq %eax, %rsi
movq %rsp, %rdi
callq 0x6eb98
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
subq %rdi, %rsi
sarq $0x3, %rsi
callq 0x26290
leaq 0x20(%rsp), %rdi
callq 0x27070
movq (%rsp), %r15
movq 0x8(%rsp), %r12
leaq 0x20(%rsp), %r14
leaq 0x687cc(%rip), %r13 # 0xc5509
leaq 0x73d3c(%rip), %rbp # 0xd0a80
cmpq %r12, %r15
je 0x5cd75
movq (%r15), %rsi
movq %r14, %rdi
callq 0x26c10
movq 0x8(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %r15
movq %rbp, %rsi
cmoveq %r13, %rsi
movq %rax, %rdi
callq 0x26c10
addq $0x8, %r15
jmp 0x5cd44
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x273d0
leaq 0x20(%rsp), %rdi
callq 0x26280
movq %rsp, %rdi
callq 0x6411e
movq %rbx, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5cdb2
jmp 0x5cdad
movq %rax, %rbx
jmp 0x5cdbf
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x26280
movq %rsp, %rdi
callq 0x6411e
movq %rbx, %rdi
callq 0x27660
nop
| _ZL27list_builtin_chat_templatesB5cxx11v:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 198h
mov rbx, rdi
xorps xmm0, xmm0
movaps [rsp+1C8h+var_1C8], xmm0
and [rsp+1C8h+var_1B8], 0
xor edi, edi
xor esi, esi
call _llama_chat_builtin_templates
movsxd rsi, eax
mov rdi, rsp
call _ZNSt6vectorIPKcSaIS1_EE6resizeEm; std::vector<char const*>::resize(ulong)
mov rdi, qword ptr [rsp+1C8h+var_1C8]
mov rsi, qword ptr [rsp+1C8h+var_1C8+8]
sub rsi, rdi
sar rsi, 3
call _llama_chat_builtin_templates
lea rdi, [rsp+1C8h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov r15, qword ptr [rsp+1C8h+var_1C8]
mov r12, qword ptr [rsp+1C8h+var_1C8+8]
lea r14, [rsp+1C8h+var_1A8]
lea r13, aBeginOfTextSta+3Bh; ""
lea rbp, aZuD+6; ", "
loc_5CD44:
cmp r15, r12
jz short loc_5CD75
mov rsi, [r15]
mov rdi, r14
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rcx, qword ptr [rsp+1C8h+var_1C8+8]
add rcx, 0FFFFFFFFFFFFFFF8h
cmp r15, rcx
mov rsi, rbp
cmovz rsi, r13
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
add r15, 8
jmp short loc_5CD44
loc_5CD75:
lea rsi, [rsp+1C8h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
lea rdi, [rsp+1C8h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rdi, rsp
call _ZNSt12_Vector_baseIPKcSaIS1_EED2Ev; std::_Vector_base<char const*>::~_Vector_base()
mov rax, rbx
add rsp, 198h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_5CDB2
jmp short $+2
loc_5CDAD:
mov rbx, rax
jmp short loc_5CDBF
loc_5CDB2:
mov rbx, rax
lea rdi, [rsp+arg_18]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
loc_5CDBF:
mov rdi, rsp
call _ZNSt12_Vector_baseIPKcSaIS1_EED2Ev; std::_Vector_base<char const*>::~_Vector_base()
mov rdi, rbx
call __Unwind_Resume
| long long list_builtin_chat_templates[abi:cxx11](long long a1)
{
int v1; // eax
_QWORD *v2; // r12
_QWORD *i; // r15
long long v4; // rax
char *v5; // rsi
__int128 v7; // [rsp+0h] [rbp-1C8h] BYREF
long long v8; // [rsp+10h] [rbp-1B8h]
_BYTE v9[8]; // [rsp+20h] [rbp-1A8h] BYREF
_BYTE v10[416]; // [rsp+28h] [rbp-1A0h] BYREF
v7 = 0LL;
v8 = 0LL;
v1 = llama_chat_builtin_templates(0LL, 0LL);
std::vector<char const*>::resize(&v7, v1);
llama_chat_builtin_templates(v7, (long long)(*((_QWORD *)&v7 + 1) - v7) >> 3);
std::ostringstream::basic_ostringstream(v9);
v2 = (_QWORD *)*((_QWORD *)&v7 + 1);
for ( i = (_QWORD *)v7; i != v2; ++i )
{
v4 = std::operator<<<std::char_traits<char>>(v9, *i);
v5 = ", ";
if ( i == (_QWORD *)(*((_QWORD *)&v7 + 1) - 8LL) )
v5 = "";
std::operator<<<std::char_traits<char>>(v4, v5);
}
std::stringbuf::str(a1, v10);
std::ostringstream::~ostringstream(v9);
std::_Vector_base<char const*>::~_Vector_base(&v7);
return a1;
}
| list_builtin_chat_templates[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x198
MOV RBX,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
AND qword ptr [RSP + 0x10],0x0
LAB_0015ccf5:
XOR EDI,EDI
XOR ESI,ESI
CALL 0x00126290
MOVSXD RSI,EAX
MOV RDI,RSP
CALL 0x0016eb98
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
SUB RSI,RDI
SAR RSI,0x3
CALL 0x00126290
LAB_0015cd1e:
LEA RDI,[RSP + 0x20]
CALL 0x00127070
MOV R15,qword ptr [RSP]
MOV R12,qword ptr [RSP + 0x8]
LEA R14,[RSP + 0x20]
LEA R13,[0x1c5509]
LEA RBP,[0x1d0a80]
LAB_0015cd44:
CMP R15,R12
JZ 0x0015cd75
MOV RSI,qword ptr [R15]
LAB_0015cd4c:
MOV RDI,R14
CALL 0x00126c10
MOV RCX,qword ptr [RSP + 0x8]
ADD RCX,-0x8
CMP R15,RCX
MOV RSI,RBP
CMOVZ RSI,R13
MOV RDI,RAX
CALL 0x00126c10
ADD R15,0x8
JMP 0x0015cd44
LAB_0015cd75:
LEA RSI,[RSP + 0x28]
LAB_0015cd7a:
MOV RDI,RBX
CALL 0x001273d0
LAB_0015cd82:
LEA RDI,[RSP + 0x20]
CALL 0x00126280
MOV RDI,RSP
CALL 0x0016411e
MOV RAX,RBX
ADD RSP,0x198
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* list_builtin_chat_templates[abi:cxx11]() */
void list_builtin_chat_templates_abi_cxx11_(void)
{
int8 *puVar1;
int iVar2;
ostream *poVar3;
char *pcVar4;
int8 *puVar5;
int8 *local_1c8;
int8 *puStack_1c0;
int8 local_1b8;
ostringstream local_1a8 [376];
local_1c8 = (int8 *)0x0;
puStack_1c0 = (int8 *)0x0;
local_1b8 = 0;
/* try { // try from 0015ccf5 to 0015cd1d has its CatchHandler @ 0015cdad */
iVar2 = llama_chat_builtin_templates(0,0);
std::vector<char_const*,std::allocator<char_const*>>::resize
((vector<char_const*,std::allocator<char_const*>> *)&local_1c8,(long)iVar2);
llama_chat_builtin_templates(local_1c8,(long)puStack_1c0 - (long)local_1c8 >> 3);
/* try { // try from 0015cd1e to 0015cd27 has its CatchHandler @ 0015cdab */
std::__cxx11::ostringstream::ostringstream(local_1a8);
puVar1 = puStack_1c0;
for (puVar5 = local_1c8; puVar5 != puVar1; puVar5 = puVar5 + 1) {
/* try { // try from 0015cd4c to 0015cd6e has its CatchHandler @ 0015cdb2 */
poVar3 = std::operator<<((ostream *)local_1a8,(char *)*puVar5);
pcVar4 = ", ";
if (puVar5 == puStack_1c0 + -1) {
pcVar4 = "";
}
std::operator<<(poVar3,pcVar4);
}
/* try { // try from 0015cd7a to 0015cd81 has its CatchHandler @ 0015cda9 */
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream(local_1a8);
std::_Vector_base<char_const*,std::allocator<char_const*>>::~_Vector_base
((_Vector_base<char_const*,std::allocator<char_const*>> *)&local_1c8);
return;
}
| |
26,081 | my_realpath | eloqsql/mysys/my_symlink.c | int my_realpath(char *to, const char *filename, myf MyFlags)
{
#if defined(HAVE_REALPATH) && !defined(HAVE_BROKEN_REALPATH)
int result=0;
char buff[BUFF_LEN];
char *ptr;
DBUG_ENTER("my_realpath");
DBUG_PRINT("info",("executing realpath"));
if ((ptr=realpath(filename,buff)))
strmake(to, ptr, FN_REFLEN-1);
else
{
/*
Realpath didn't work; Use my_load_path() which is a poor substitute
original name but will at least be able to resolve paths that starts
with '.'.
*/
if (MyFlags)
DBUG_PRINT("error",("realpath failed with errno: %d", errno));
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_REALPATH, MYF(0), filename, my_errno);
my_load_path(to, filename, NullS);
if (my_errno == ENOENT)
result= 1;
else
result= -1;
}
DBUG_RETURN(result);
#elif defined(_WIN32)
int ret= GetFullPathName(filename,FN_REFLEN, to, NULL);
if (ret == 0 || ret > FN_REFLEN)
{
my_errno= (ret > FN_REFLEN) ? ENAMETOOLONG : GetLastError();
if (MyFlags & MY_WME)
my_error(EE_REALPATH, MYF(0), filename, my_errno);
/*
GetFullPathName didn't work : use my_load_path() which is a poor
substitute original name but will at least be able to resolve
paths that starts with '.'.
*/
my_load_path(to, filename, NullS);
return -1;
}
#else
my_load_path(to, filename, NullS);
#endif
return 0;
} | O0 | c | my_realpath:
pushq %rbp
movq %rsp, %rbp
subq $0x1060, %rsp # imm = 0x1060
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x1020(%rbp)
movq %rsi, -0x1028(%rbp)
movq %rdx, -0x1030(%rbp)
movl $0x0, -0x1034(%rbp)
jmp 0xf6b29
movq -0x1028(%rbp), %rdi
leaq -0x1010(%rbp), %rsi
callq 0x29430
movq %rax, -0x1040(%rbp)
cmpq $0x0, %rax
je 0xf6b66
movq -0x1020(%rbp), %rdi
movq -0x1040(%rbp), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14f650
jmp 0xf6c06
cmpq $0x0, -0x1030(%rbp)
je 0xf6b76
jmp 0xf6b72
jmp 0xf6b74
jmp 0xf6b76
callq 0x296d0
movl (%rax), %eax
movl %eax, -0x1044(%rbp)
callq 0xf7b30
movl -0x1044(%rbp), %ecx
movl %ecx, (%rax)
movq -0x1030(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0xf6bcd
movq -0x1028(%rbp), %rax
movq %rax, -0x1050(%rbp)
callq 0xf7b30
movq -0x1050(%rbp), %rdx
movl (%rax), %ecx
movl $0x1a, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0xf14a0
movq -0x1020(%rbp), %rdi
movq -0x1028(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1049b0
callq 0xf7b30
cmpl $0x2, (%rax)
jne 0xf6bfa
movl $0x1, -0x1034(%rbp)
jmp 0xf6c04
movl $0xffffffff, -0x1034(%rbp) # imm = 0xFFFFFFFF
jmp 0xf6c06
jmp 0xf6c08
movl -0x1034(%rbp), %eax
movl %eax, -0x1014(%rbp)
movl -0x1014(%rbp), %eax
movl %eax, -0x1054(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xf6c41
movl -0x1054(%rbp), %eax
addq $0x1060, %rsp # imm = 0x1060
popq %rbp
retq
callq 0x29230
nopw %cs:(%rax,%rax)
| my_realpath:
push rbp
mov rbp, rsp
sub rsp, 1060h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_1020], rdi
mov [rbp+var_1028], rsi
mov [rbp+var_1030], rdx
mov [rbp+var_1034], 0
jmp short $+2
loc_F6B29:
mov rdi, [rbp+var_1028]
lea rsi, [rbp+var_1010]
call _realpath
mov [rbp+var_1040], rax
cmp rax, 0
jz short loc_F6B66
mov rdi, [rbp+var_1020]
mov rsi, [rbp+var_1040]
mov edx, 1FFh
call strmake
jmp loc_F6C06
loc_F6B66:
cmp [rbp+var_1030], 0
jz short loc_F6B76
jmp short $+2
loc_F6B72:
jmp short $+2
loc_F6B74:
jmp short $+2
loc_F6B76:
call ___errno_location
mov eax, [rax]
mov [rbp+var_1044], eax
call _my_thread_var
mov ecx, [rbp+var_1044]
mov [rax], ecx
mov rax, [rbp+var_1030]
and rax, 10h
cmp rax, 0
jz short loc_F6BCD
mov rax, [rbp+var_1028]
mov [rbp+var_1050], rax
call _my_thread_var
mov rdx, [rbp+var_1050]
mov ecx, [rax]
mov edi, 1Ah
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_F6BCD:
mov rdi, [rbp+var_1020]
mov rsi, [rbp+var_1028]
xor eax, eax
mov edx, eax
call my_load_path
call _my_thread_var
cmp dword ptr [rax], 2
jnz short loc_F6BFA
mov [rbp+var_1034], 1
jmp short loc_F6C04
loc_F6BFA:
mov [rbp+var_1034], 0FFFFFFFFh
loc_F6C04:
jmp short $+2
loc_F6C06:
jmp short $+2
loc_F6C08:
mov eax, [rbp+var_1034]
mov [rbp+var_1014], eax
mov eax, [rbp+var_1014]
mov [rbp+var_1054], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_F6C41
mov eax, [rbp+var_1054]
add rsp, 1060h
pop rbp
retn
loc_F6C41:
call ___stack_chk_fail
| long long my_realpath(long long a1, const char *a2, char a3)
{
unsigned int *v3; // rax
long long v5; // [rsp+1Ch] [rbp-1044h]
long long v6; // [rsp+20h] [rbp-1040h]
unsigned int v7; // [rsp+2Ch] [rbp-1034h]
char v9[4104]; // [rsp+50h] [rbp-1010h] BYREF
unsigned long long v10; // [rsp+1058h] [rbp-8h]
v10 = __readfsqword(0x28u);
v7 = 0;
v6 = realpath(a2, v9);
if ( v6 )
{
strmake(a1, v6, 511LL);
}
else
{
v5 = *(unsigned int *)__errno_location();
*(_DWORD *)my_thread_var(a2, v9) = v5;
if ( (a3 & 0x10) != 0 )
{
v3 = (unsigned int *)my_thread_var(a2, v9);
my_error(0x1Au, 0LL, a2, *v3);
}
my_load_path(a1, a2, 0LL);
if ( *(_DWORD *)my_thread_var(a1, a2) == 2 )
return 1;
else
return (unsigned int)-1;
}
return v7;
}
| my_realpath:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1060
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x1020],RDI
MOV qword ptr [RBP + -0x1028],RSI
MOV qword ptr [RBP + -0x1030],RDX
MOV dword ptr [RBP + -0x1034],0x0
JMP 0x001f6b29
LAB_001f6b29:
MOV RDI,qword ptr [RBP + -0x1028]
LEA RSI,[RBP + -0x1010]
CALL 0x00129430
MOV qword ptr [RBP + -0x1040],RAX
CMP RAX,0x0
JZ 0x001f6b66
MOV RDI,qword ptr [RBP + -0x1020]
MOV RSI,qword ptr [RBP + -0x1040]
MOV EDX,0x1ff
CALL 0x0024f650
JMP 0x001f6c06
LAB_001f6b66:
CMP qword ptr [RBP + -0x1030],0x0
JZ 0x001f6b76
JMP 0x001f6b72
LAB_001f6b72:
JMP 0x001f6b74
LAB_001f6b74:
JMP 0x001f6b76
LAB_001f6b76:
CALL 0x001296d0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1044],EAX
CALL 0x001f7b30
MOV ECX,dword ptr [RBP + -0x1044]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x1030]
AND RAX,0x10
CMP RAX,0x0
JZ 0x001f6bcd
MOV RAX,qword ptr [RBP + -0x1028]
MOV qword ptr [RBP + -0x1050],RAX
CALL 0x001f7b30
MOV RDX,qword ptr [RBP + -0x1050]
MOV ECX,dword ptr [RAX]
MOV EDI,0x1a
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x001f14a0
LAB_001f6bcd:
MOV RDI,qword ptr [RBP + -0x1020]
MOV RSI,qword ptr [RBP + -0x1028]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x002049b0
CALL 0x001f7b30
CMP dword ptr [RAX],0x2
JNZ 0x001f6bfa
MOV dword ptr [RBP + -0x1034],0x1
JMP 0x001f6c04
LAB_001f6bfa:
MOV dword ptr [RBP + -0x1034],0xffffffff
LAB_001f6c04:
JMP 0x001f6c06
LAB_001f6c06:
JMP 0x001f6c08
LAB_001f6c08:
MOV EAX,dword ptr [RBP + -0x1034]
MOV dword ptr [RBP + -0x1014],EAX
MOV EAX,dword ptr [RBP + -0x1014]
MOV dword ptr [RBP + -0x1054],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001f6c41
MOV EAX,dword ptr [RBP + -0x1054]
ADD RSP,0x1060
POP RBP
RET
LAB_001f6c41:
CALL 0x00129230
|
int4 my_realpath(int8 param_1,char *param_2,ulong param_3)
{
int iVar1;
char *pcVar2;
int *piVar3;
int4 *puVar4;
long in_FS_OFFSET;
int4 local_103c;
char local_1018 [4104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_103c = 0;
pcVar2 = realpath(param_2,local_1018);
if (pcVar2 == (char *)0x0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((param_3 & 0x10) != 0) {
puVar4 = (int4 *)_my_thread_var();
my_error(0x1a,0,param_2,*puVar4);
}
my_load_path(param_1,param_2,0);
piVar3 = (int *)_my_thread_var();
if (*piVar3 == 2) {
local_103c = 1;
}
else {
local_103c = 0xffffffff;
}
}
else {
strmake(param_1,pcVar2,0x1ff);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_103c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
26,082 | my_coll_lexem_next | eloqsql/strings/ctype-uca.c | static my_coll_lexem_num my_coll_lexem_next(MY_COLL_LEXEM *lexem)
{
const char *beg;
my_coll_lexem_num rc;
for (beg= lexem->beg ; beg < lexem->end ; beg++)
{
switch (*beg)
{
case ' ':
case '\t':
case '\r':
case '\n':
continue;
case '[': /* Bracket expression, e.g. "[optimize [a-z]]" */
{
size_t nbrackets; /* Indicates nested recursion level */
for (beg++, nbrackets= 1 ; beg < lexem->end; beg++)
{
if (*beg == '[') /* Enter nested bracket expression */
nbrackets++;
else if (*beg == ']')
{
if (--nbrackets == 0)
{
rc= MY_COLL_LEXEM_OPTION;
beg++;
goto ex;
}
}
}
rc= MY_COLL_LEXEM_ERROR;
goto ex;
}
case '&':
beg++;
rc= MY_COLL_LEXEM_RESET;
goto ex;
case '=':
beg++;
lexem->diff= 0;
rc= MY_COLL_LEXEM_SHIFT;
goto ex;
case '/':
beg++;
rc= MY_COLL_LEXEM_EXTEND;
goto ex;
case '|':
beg++;
rc= MY_COLL_LEXEM_CONTEXT;
goto ex;
case '<': /* Shift: '<' or '<<' or '<<<' or '<<<<' */
{
/* Scan up to 3 additional '<' characters */
for (beg++, lexem->diff= 1;
(beg < lexem->end) && (*beg == '<') && (lexem->diff <= 3);
beg++, lexem->diff++);
rc= MY_COLL_LEXEM_SHIFT;
goto ex;
}
default:
break;
}
/* Escaped character, e.g. \u1234 */
if ((*beg == '\\') && (beg + 2 < lexem->end) &&
(beg[1] == 'u') && my_isxdigit(&my_charset_utf8mb3_general_ci, beg[2]))
{
int ch;
beg+= 2;
lexem->code= 0;
while ((beg < lexem->end) && ((ch= ch2x(beg[0])) >= 0))
{
lexem->code= (lexem->code << 4) + ch;
beg++;
}
rc= MY_COLL_LEXEM_CHAR;
goto ex;
}
/*
Unescaped single byte character:
allow printable ASCII range except SPACE and
special characters parsed above []<&/|=
*/
if (*beg >= 0x21 && *beg <= 0x7E)
{
lexem->code= *beg++;
rc= MY_COLL_LEXEM_CHAR;
goto ex;
}
if (((uchar) *beg) > 0x7F) /* Unescaped multibyte character */
{
CHARSET_INFO *cs= &my_charset_utf8mb3_general_ci;
my_wc_t wc;
int nbytes= my_ci_mb_wc(cs, &wc, (uchar *) beg, (uchar *) lexem->end);
if (nbytes > 0)
{
rc= MY_COLL_LEXEM_CHAR;
beg+= nbytes;
lexem->code= (int) wc;
goto ex;
}
}
rc= MY_COLL_LEXEM_ERROR;
goto ex;
}
rc= MY_COLL_LEXEM_EOF;
ex:
lexem->prev= lexem->beg;
lexem->beg= beg;
lexem->term= rc;
return rc;
} | O0 | c | my_coll_lexem_next:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x511ab
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x40(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x50e95
jmp 0x50e2e
movl -0x40(%rbp), %eax
subl $0xd, %eax
je 0x50e95
jmp 0x50e38
movl -0x40(%rbp), %eax
subl $0x20, %eax
je 0x50e95
jmp 0x50e42
movl -0x40(%rbp), %eax
subl $0x26, %eax
je 0x50f2c
jmp 0x50e50
movl -0x40(%rbp), %eax
subl $0x2f, %eax
je 0x50f67
jmp 0x50e5e
movl -0x40(%rbp), %eax
subl $0x3c, %eax
je 0x50f97
jmp 0x50e6c
movl -0x40(%rbp), %eax
subl $0x3d, %eax
je 0x50f44
jmp 0x50e7a
movl -0x40(%rbp), %eax
subl $0x5b, %eax
je 0x50e9a
jmp 0x50e84
movl -0x40(%rbp), %eax
subl $0x7c, %eax
je 0x50f7f
jmp 0x51012
jmp 0x5119a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x50f20
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x50ed6
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x50f10
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x50f0e
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x50f0c
movl $0x7, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x511b2
jmp 0x50f0e
jmp 0x50f10
jmp 0x50f12
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x50eae
movl $0x6, -0x14(%rbp)
jmp 0x511b2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl $0x4, -0x14(%rbp)
jmp 0x511b2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movl $0x1, -0x14(%rbp)
jmp 0x511b2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl $0x8, -0x14(%rbp)
jmp 0x511b2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl $0x9, -0x14(%rbp)
jmp 0x511b2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x41(%rbp)
jae 0x50fe0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3c, %ecx
movb %al, -0x41(%rbp)
jne 0x50fe0
movq -0x8(%rbp), %rax
cmpl $0x3, 0x20(%rax)
setle %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x50fe9
jmp 0x51006
jmp 0x50feb
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
jmp 0x50fae
movl $0x1, -0x14(%rbp)
jmp 0x511b2
jmp 0x51014
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x510e6
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x510e6
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x75, %eax
jne 0x510e6
leaq 0x332a1e(%rip), %rax # 0x383a70
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x510e6
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x42(%rbp)
jae 0x510af
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x51200
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
setge %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x510b8
jmp 0x510da
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
shll $0x4, %ecx
addl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x51084
movl $0x5, -0x14(%rbp)
jmp 0x511b2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x21, %eax
jl 0x51123
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jg 0x51123
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movl $0x5, -0x14(%rbp)
jmp 0x511b2
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7f, %eax
jle 0x51191
leaq 0x33293a(%rip), %rax # 0x383a70
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
leaq -0x38(%rbp), %rsi
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jle 0x5118f
movl $0x5, -0x14(%rbp)
movl -0x3c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x511b2
jmp 0x51191
movl $0x6, -0x14(%rbp)
jmp 0x511b2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x50e08
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
| my_coll_lexem_next:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_10], rax
loc_50E08:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
cmp rax, [rcx+10h]
jnb loc_511AB
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
mov [rbp+var_40], eax
add eax, 0FFFFFFF7h
sub eax, 2
jb short loc_50E95
jmp short $+2
loc_50E2E:
mov eax, [rbp+var_40]
sub eax, 0Dh
jz short loc_50E95
jmp short $+2
loc_50E38:
mov eax, [rbp+var_40]
sub eax, 20h ; ' '
jz short loc_50E95
jmp short $+2
loc_50E42:
mov eax, [rbp+var_40]
sub eax, 26h ; '&'
jz loc_50F2C
jmp short $+2
loc_50E50:
mov eax, [rbp+var_40]
sub eax, 2Fh ; '/'
jz loc_50F67
jmp short $+2
loc_50E5E:
mov eax, [rbp+var_40]
sub eax, 3Ch ; '<'
jz loc_50F97
jmp short $+2
loc_50E6C:
mov eax, [rbp+var_40]
sub eax, 3Dh ; '='
jz loc_50F44
jmp short $+2
loc_50E7A:
mov eax, [rbp+var_40]
sub eax, 5Bh ; '['
jz short loc_50E9A
jmp short $+2
loc_50E84:
mov eax, [rbp+var_40]
sub eax, 7Ch ; '|'
jz loc_50F7F
jmp loc_51012
loc_50E95:
jmp loc_5119A
loc_50E9A:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
mov [rbp+var_20], 1
loc_50EAE:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
cmp rax, [rcx+10h]
jnb short loc_50F20
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 5Bh ; '['
jnz short loc_50ED6
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_50F10
loc_50ED6:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 5Dh ; ']'
jnz short loc_50F0E
mov rax, [rbp+var_20]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_50F0C
mov [rbp+var_14], 7
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp loc_511B2
loc_50F0C:
jmp short $+2
loc_50F0E:
jmp short $+2
loc_50F10:
jmp short $+2
loc_50F12:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_50EAE
loc_50F20:
mov [rbp+var_14], 6
jmp loc_511B2
loc_50F2C:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
mov [rbp+var_14], 4
jmp loc_511B2
loc_50F44:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov dword ptr [rax+20h], 0
mov [rbp+var_14], 1
jmp loc_511B2
loc_50F67:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
mov [rbp+var_14], 8
jmp loc_511B2
loc_50F7F:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
mov [rbp+var_14], 9
jmp loc_511B2
loc_50F97:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov dword ptr [rax+20h], 1
loc_50FAE:
mov rcx, [rbp+var_10]
mov rdx, [rbp+var_8]
xor eax, eax
cmp rcx, [rdx+10h]
mov [rbp+var_41], al
jnb short loc_50FE0
mov rax, [rbp+var_10]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 3Ch ; '<'
mov [rbp+var_41], al
jnz short loc_50FE0
mov rax, [rbp+var_8]
cmp dword ptr [rax+20h], 3
setle al
mov [rbp+var_41], al
loc_50FE0:
mov al, [rbp+var_41]
test al, 1
jnz short loc_50FE9
jmp short loc_51006
loc_50FE9:
jmp short $+2
loc_50FEB:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov ecx, [rax+20h]
add ecx, 1
mov [rax+20h], ecx
jmp short loc_50FAE
loc_51006:
mov [rbp+var_14], 1
jmp loc_511B2
loc_51012:
jmp short $+2
loc_51014:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 5Ch ; '\'
jnz loc_510E6
mov rax, [rbp+var_10]
add rax, 2
mov rcx, [rbp+var_8]
cmp rax, [rcx+10h]
jnb loc_510E6
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1]
cmp eax, 75h ; 'u'
jnz loc_510E6
lea rax, my_charset_utf8mb3_general_ci
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx+2]
movzx eax, byte ptr [rax+rcx+1]
and eax, 80h
cmp eax, 0
jz short loc_510E6
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov dword ptr [rax+24h], 0
loc_51084:
mov rcx, [rbp+var_10]
mov rdx, [rbp+var_8]
xor eax, eax
cmp rcx, [rdx+10h]
mov [rbp+var_42], al
jnb short loc_510AF
mov rax, [rbp+var_10]
movsx edi, byte ptr [rax]
call ch2x
mov [rbp+var_24], eax
cmp eax, 0
setnl al
mov [rbp+var_42], al
loc_510AF:
mov al, [rbp+var_42]
test al, 1
jnz short loc_510B8
jmp short loc_510DA
loc_510B8:
mov rax, [rbp+var_8]
mov ecx, [rax+24h]
shl ecx, 4
add ecx, [rbp+var_24]
mov rax, [rbp+var_8]
mov [rax+24h], ecx
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_51084
loc_510DA:
mov [rbp+var_14], 5
jmp loc_511B2
loc_510E6:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 21h ; '!'
jl short loc_51123
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 7Eh ; '~'
jg short loc_51123
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
movsx ecx, byte ptr [rax]
mov rax, [rbp+var_8]
mov [rax+24h], ecx
mov [rbp+var_14], 5
jmp loc_511B2
loc_51123:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
cmp eax, 7Fh
jle short loc_51191
lea rax, my_charset_utf8mb3_general_ci
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov rdi, [rbp+var_30]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_8]
mov rcx, [rcx+10h]
lea rsi, [rbp+var_38]
call rax
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0
jle short loc_5118F
mov [rbp+var_14], 5
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov rax, [rbp+var_38]
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+24h], ecx
jmp short loc_511B2
loc_5118F:
jmp short $+2
loc_51191:
mov [rbp+var_14], 6
jmp short loc_511B2
loc_5119A:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp loc_50E08
loc_511AB:
mov [rbp+var_14], 0
loc_511B2:
mov rax, [rbp+var_8]
mov rcx, [rax+8]
mov rax, [rbp+var_8]
mov [rax+18h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax+8], rcx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_8]
mov [rax], ecx
mov eax, [rbp+var_14]
add rsp, 50h
pop rbp
retn
| long long my_coll_lexem_next(long long a1)
{
char *v1; // rax
bool v3; // [rsp+Eh] [rbp-42h]
bool v4; // [rsp+Fh] [rbp-41h]
int v5; // [rsp+10h] [rbp-40h]
int v6; // [rsp+14h] [rbp-3Ch]
_QWORD v7[2]; // [rsp+18h] [rbp-38h] BYREF
int v8; // [rsp+2Ch] [rbp-24h]
long long v9; // [rsp+30h] [rbp-20h]
unsigned int v10; // [rsp+3Ch] [rbp-14h]
unsigned __int8 *i; // [rsp+40h] [rbp-10h]
long long v12; // [rsp+48h] [rbp-8h]
v12 = a1;
for ( i = *(unsigned __int8 **)(a1 + 8); ; ++i )
{
if ( (unsigned long long)i >= *(_QWORD *)(v12 + 16) )
{
v10 = 0;
goto LABEL_52;
}
v5 = (char)*i;
if ( (unsigned int)(v5 - 9) >= 2 && v5 != 13 && v5 != 32 )
break;
}
switch ( v5 )
{
case '&':
++i;
v10 = 4;
break;
case '/':
++i;
v10 = 8;
break;
case '<':
++i;
for ( *(_DWORD *)(v12 + 32) = 1; ; ++*(_DWORD *)(v12 + 32) )
{
v4 = 0;
if ( (unsigned long long)i < *(_QWORD *)(v12 + 16) )
{
v4 = 0;
if ( *i == 60 )
v4 = *(_DWORD *)(v12 + 32) <= 3;
}
if ( !v4 )
break;
++i;
}
v10 = 1;
break;
case '=':
++i;
*(_DWORD *)(v12 + 32) = 0;
v10 = 1;
break;
case '[':
++i;
v9 = 1LL;
while ( (unsigned long long)i < *(_QWORD *)(v12 + 16) )
{
if ( *i == 91 )
{
++v9;
}
else if ( *i == 93 && !--v9 )
{
v10 = 7;
++i;
goto LABEL_52;
}
++i;
}
v10 = 6;
break;
case '|':
++i;
v10 = 9;
break;
default:
if ( *i == 92
&& (unsigned long long)(i + 2) < *(_QWORD *)(v12 + 16)
&& i[1] == 117
&& (*(_BYTE *)(*(_QWORD *)&my_charset_utf8mb3_general_ci[16] + i[2] + 1LL) & 0x80) != 0 )
{
i += 2;
*(_DWORD *)(v12 + 36) = 0;
while ( 1 )
{
v3 = 0;
if ( (unsigned long long)i < *(_QWORD *)(v12 + 16) )
{
v8 = ch2x((unsigned int)(char)*i);
v3 = v8 >= 0;
}
if ( !v3 )
break;
*(_DWORD *)(v12 + 36) = v8 + 16 * *(_DWORD *)(v12 + 36);
++i;
}
v10 = 5;
}
else if ( (char)*i < 33 || *i == 127 )
{
if ( *i <= 0x7Fu
|| (v7[1] = my_charset_utf8mb3_general_ci,
v6 = (*(long long ( **)(unsigned int *, _QWORD *, unsigned __int8 *, _QWORD))(*(_QWORD *)&my_charset_utf8mb3_general_ci[46]
+ 40LL))(
my_charset_utf8mb3_general_ci,
v7,
i,
*(_QWORD *)(v12 + 16)),
v6 <= 0) )
{
v10 = 6;
}
else
{
v10 = 5;
i += v6;
*(_DWORD *)(v12 + 36) = v7[0];
}
}
else
{
v1 = (char *)i++;
*(_DWORD *)(v12 + 36) = *v1;
v10 = 5;
}
break;
}
LABEL_52:
*(_QWORD *)(v12 + 24) = *(_QWORD *)(v12 + 8);
*(_QWORD *)(v12 + 8) = i;
*(_DWORD *)v12 = v10;
return v10;
}
| my_coll_lexem_next:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x10],RAX
LAB_00150e08:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x10]
JNC 0x001511ab
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x40],EAX
ADD EAX,-0x9
SUB EAX,0x2
JC 0x00150e95
JMP 0x00150e2e
LAB_00150e2e:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0xd
JZ 0x00150e95
JMP 0x00150e38
LAB_00150e38:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x20
JZ 0x00150e95
JMP 0x00150e42
LAB_00150e42:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x26
JZ 0x00150f2c
JMP 0x00150e50
LAB_00150e50:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x2f
JZ 0x00150f67
JMP 0x00150e5e
LAB_00150e5e:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x3c
JZ 0x00150f97
JMP 0x00150e6c
LAB_00150e6c:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x3d
JZ 0x00150f44
JMP 0x00150e7a
LAB_00150e7a:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x5b
JZ 0x00150e9a
JMP 0x00150e84
LAB_00150e84:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x7c
JZ 0x00150f7f
JMP 0x00151012
LAB_00150e95:
JMP 0x0015119a
LAB_00150e9a:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x20],0x1
LAB_00150eae:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x10]
JNC 0x00150f20
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x5b
JNZ 0x00150ed6
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00150f10
LAB_00150ed6:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x5d
JNZ 0x00150f0e
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x00150f0c
MOV dword ptr [RBP + -0x14],0x7
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001511b2
LAB_00150f0c:
JMP 0x00150f0e
LAB_00150f0e:
JMP 0x00150f10
LAB_00150f10:
JMP 0x00150f12
LAB_00150f12:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00150eae
LAB_00150f20:
MOV dword ptr [RBP + -0x14],0x6
JMP 0x001511b2
LAB_00150f2c:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x14],0x4
JMP 0x001511b2
LAB_00150f44:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x20],0x0
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001511b2
LAB_00150f67:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x14],0x8
JMP 0x001511b2
LAB_00150f7f:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x14],0x9
JMP 0x001511b2
LAB_00150f97:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x20],0x1
LAB_00150fae:
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
XOR EAX,EAX
CMP RCX,qword ptr [RDX + 0x10]
MOV byte ptr [RBP + -0x41],AL
JNC 0x00150fe0
MOV RAX,qword ptr [RBP + -0x10]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x3c
MOV byte ptr [RBP + -0x41],AL
JNZ 0x00150fe0
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x20],0x3
SETLE AL
MOV byte ptr [RBP + -0x41],AL
LAB_00150fe0:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x00150fe9
JMP 0x00151006
LAB_00150fe9:
JMP 0x00150feb
LAB_00150feb:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x20]
ADD ECX,0x1
MOV dword ptr [RAX + 0x20],ECX
JMP 0x00150fae
LAB_00151006:
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001511b2
LAB_00151012:
JMP 0x00151014
LAB_00151014:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x5c
JNZ 0x001510e6
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x10]
JNC 0x001510e6
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x75
JNZ 0x001510e6
LEA RAX,[0x483a70]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX + 0x2]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001510e6
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x24],0x0
LAB_00151084:
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
XOR EAX,EAX
CMP RCX,qword ptr [RDX + 0x10]
MOV byte ptr [RBP + -0x42],AL
JNC 0x001510af
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EDI,byte ptr [RAX]
CALL 0x00151200
MOV dword ptr [RBP + -0x24],EAX
CMP EAX,0x0
SETGE AL
MOV byte ptr [RBP + -0x42],AL
LAB_001510af:
MOV AL,byte ptr [RBP + -0x42]
TEST AL,0x1
JNZ 0x001510b8
JMP 0x001510da
LAB_001510b8:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x24]
SHL ECX,0x4
ADD ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x24],ECX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00151084
LAB_001510da:
MOV dword ptr [RBP + -0x14],0x5
JMP 0x001511b2
LAB_001510e6:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x21
JL 0x00151123
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x7e
JG 0x00151123
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOVSX ECX,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x24],ECX
MOV dword ptr [RBP + -0x14],0x5
JMP 0x001511b2
LAB_00151123:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x7f
JLE 0x00151191
LEA RAX,[0x483a70]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x10]
LEA RSI,[RBP + -0x38]
CALL RAX
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0x0
JLE 0x0015118f
MOV dword ptr [RBP + -0x14],0x5
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001511b2
LAB_0015118f:
JMP 0x00151191
LAB_00151191:
MOV dword ptr [RBP + -0x14],0x6
JMP 0x001511b2
LAB_0015119a:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00150e08
LAB_001511ab:
MOV dword ptr [RBP + -0x14],0x0
LAB_001511b2:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RBP + -0x14]
ADD RSP,0x50
POP RBP
RET
|
int4 my_coll_lexem_next(int4 *param_1)
{
byte *pbVar1;
int iVar2;
bool bVar3;
int4 local_40 [2];
int1 *local_38;
int local_2c;
long local_28;
int4 local_1c;
byte *local_18;
int4 *local_10;
local_18 = *(byte **)(param_1 + 2);
while( true ) {
local_10 = param_1;
if (*(byte **)(param_1 + 4) <= local_18) goto LAB_001511ab;
iVar2 = (int)(char)*local_18;
if (((1 < iVar2 - 9U) && (iVar2 != 0xd)) && (iVar2 != 0x20)) break;
local_18 = local_18 + 1;
}
if (iVar2 == 0x26) {
local_18 = local_18 + 1;
local_1c = 4;
goto LAB_001511b2;
}
if (iVar2 == 0x2f) {
local_18 = local_18 + 1;
local_1c = 8;
goto LAB_001511b2;
}
if (iVar2 != 0x3c) {
if (iVar2 == 0x3d) {
local_18 = local_18 + 1;
param_1[8] = 0;
local_1c = 1;
goto LAB_001511b2;
}
if (iVar2 == 0x5b) {
local_28 = 1;
goto LAB_00150eae;
}
if (iVar2 == 0x7c) {
local_18 = local_18 + 1;
local_1c = 9;
goto LAB_001511b2;
}
if ((((*local_18 == 0x5c) && (local_18 + 2 < *(byte **)(param_1 + 4))) && (local_18[1] == 0x75))
&& ((*(byte *)(my_charset_utf8mb3_general_ci._64_8_ + 1 + (ulong)local_18[2]) & 0x80) != 0))
{
local_18 = local_18 + 2;
param_1[9] = 0;
while( true ) {
bVar3 = false;
if (local_18 < *(byte **)(local_10 + 4)) {
local_2c = ch2x((int)(char)*local_18);
bVar3 = -1 < local_2c;
}
if (!bVar3) break;
local_10[9] = local_10[9] * 0x10 + local_2c;
local_18 = local_18 + 1;
}
local_1c = 5;
goto LAB_001511b2;
}
if ((' ' < (char)*local_18) && ((char)*local_18 < '\x7f')) {
param_1[9] = (int)(char)*local_18;
local_1c = 5;
local_18 = local_18 + 1;
goto LAB_001511b2;
}
if (0x7f < *local_18) {
local_38 = my_charset_utf8mb3_general_ci;
iVar2 = (**(code **)(my_charset_utf8mb3_general_ci._184_8_ + 0x28))
(my_charset_utf8mb3_general_ci,local_40,local_18,
*(int8 *)(param_1 + 4));
if (0 < iVar2) {
local_1c = 5;
local_18 = local_18 + iVar2;
local_10[9] = local_40[0];
goto LAB_001511b2;
}
}
local_1c = 6;
goto LAB_001511b2;
}
param_1[8] = 1;
while( true ) {
local_18 = local_18 + 1;
bVar3 = false;
if ((local_18 < *(byte **)(param_1 + 4)) && (bVar3 = false, *local_18 == 0x3c)) {
bVar3 = (int)param_1[8] < 4;
}
if (!bVar3) break;
param_1[8] = param_1[8] + 1;
}
local_1c = 1;
goto LAB_001511b2;
LAB_001511ab:
local_1c = 0;
goto LAB_001511b2;
while ((*local_18 != 0x5d || (local_28 = local_28 + -1, local_28 != 0))) {
LAB_00150eae:
pbVar1 = local_18;
local_18 = pbVar1 + 1;
if (*(byte **)(param_1 + 4) <= local_18) {
local_1c = 6;
goto LAB_001511b2;
}
if (*local_18 == 0x5b) {
local_28 = local_28 + 1;
goto LAB_00150eae;
}
}
local_1c = 7;
local_18 = pbVar1 + 2;
LAB_001511b2:
*(int8 *)(local_10 + 6) = *(int8 *)(local_10 + 2);
*(byte **)(local_10 + 2) = local_18;
*local_10 = local_1c;
return local_1c;
}
| |
26,083 | ftxui::(anonymous namespace)::AnimationListener(std::atomic<bool>*, std::unique_ptr<ftxui::SenderImpl<std::variant<ftxui::Event, std::function<void ()>, ftxui::AnimationTask>>, std::default_delete<ftxui::SenderImpl<std::variant<ftxui::Event, std::function<void ()>, ftxui::AnimationTask>>>>) | Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/component/screen_interactive.cpp | void AnimationListener(std::atomic<bool>* quit, Sender<Task> out) {
// Animation at around 60fps.
const auto time_delta = std::chrono::milliseconds(15);
while (!*quit) {
out->Send(AnimationTask());
std::this_thread::sleep_for(time_delta);
}
} | O0 | cpp | ftxui::(anonymous namespace)::AnimationListener(std::atomic<bool>*, std::unique_ptr<ftxui::SenderImpl<std::variant<ftxui::Event, std::function<void ()>, ftxui::AnimationTask>>, std::default_delete<ftxui::SenderImpl<std::variant<ftxui::Event, std::function<void ()>, ftxui::AnimationTask>>>>):
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x300ea(%rip), %rax # 0x931f8
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6ba50
xorb $-0x1, %al
testb $0x1, %al
jne 0x63123
jmp 0x63187
movq -0x80(%rbp), %rdi
callq 0x695c0
movq %rax, -0x90(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x61(%rbp), %rsi
callq 0x6bce0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x695e0
jmp 0x6315c
leaq -0x60(%rbp), %rdi
callq 0x21650
leaq -0x18(%rbp), %rdi
callq 0x6bd10
jmp 0x63112
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x21650
jmp 0x63190
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0xda90
nopl (%rax)
| _ZN5ftxui12_GLOBAL__N_117AnimationListenerEPSt6atomicIbESt10unique_ptrINS_10SenderImplISt7variantIJNS_5EventESt8functionIFvvEENS_13AnimationTaskEEEEESt14default_deleteISD_EE:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_80], rsi
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, cs:qword_931F8
mov [rbp+var_18], rax
loc_63112:
mov rdi, [rbp+var_8]
call _ZNKSt6atomicIbEcvbEv; std::atomic<bool>::operator bool(void)
xor al, 0FFh
test al, 1
jnz short loc_63123
jmp short loc_63187
loc_63123:
mov rdi, [rbp+var_80]
call _ZNKSt10unique_ptrIN5ftxui10SenderImplISt7variantIJNS0_5EventESt8functionIFvvEENS0_13AnimationTaskEEEEESt14default_deleteIS9_EEptEv; std::unique_ptr<ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>>>::operator->(void)
mov [rbp+var_90], rax
lea rdi, [rbp+var_60]
mov [rbp+var_88], rdi
lea rsi, [rbp+var_61]
call _ZNSt7variantIJN5ftxui5EventESt8functionIFvvEENS0_13AnimationTaskEEEC2IS5_vvS5_vEEOT_; std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::variant<ftxui::AnimationTask,void,void,ftxui::AnimationTask,void>(ftxui::AnimationTask &&)
mov rdi, [rbp+var_90]
mov rsi, [rbp+var_88]
call _ZN5ftxui10SenderImplISt7variantIJNS_5EventESt8functionIFvvEENS_13AnimationTaskEEEE4SendES7_; ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>>::Send(std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>)
jmp short $+2
loc_6315C:
lea rdi, [rbp+var_60]
call _ZNSt7variantIJN5ftxui5EventESt8functionIFvvEENS0_13AnimationTaskEEED2Ev; std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~variant()
lea rdi, [rbp+var_18]
call _ZNSt11this_thread9sleep_forIlSt5ratioILl1ELl1000EEEEvRKNSt6chrono8durationIT_T0_EE; std::this_thread::sleep_for<long,std::ratio<1l,1000l>>(std::chrono::duration<long,std::ratio<1l,1000l>> const&)
jmp short loc_63112
mov rcx, rax
mov eax, edx
mov [rbp+var_70], rcx
mov [rbp+var_74], eax
lea rdi, [rbp+var_60]
call _ZNSt7variantIJN5ftxui5EventESt8functionIFvvEENS0_13AnimationTaskEEED2Ev; std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~variant()
jmp short loc_63190
loc_63187:
add rsp, 90h
pop rbp
retn
loc_63190:
mov rdi, [rbp+var_70]
call __Unwind_Resume
| char ftxui::`anonymous namespace'::AnimationListener(long long a1, long long a2)
{
char result; // al
long long v3; // [rsp+0h] [rbp-90h]
char v4; // [rsp+2Fh] [rbp-61h] BYREF
_BYTE v5[72]; // [rsp+30h] [rbp-60h] BYREF
_QWORD v6[2]; // [rsp+78h] [rbp-18h] BYREF
long long v7; // [rsp+88h] [rbp-8h]
v7 = a1;
v6[1] = a2;
v6[0] = 15LL;
while ( 1 )
{
result = ~(unsigned __int8)std::atomic<bool>::operator bool(v7);
if ( (result & 1) == 0 )
break;
v3 = std::unique_ptr<ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>>>::operator->(a2);
std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::variant<ftxui::AnimationTask,void,void,ftxui::AnimationTask,void>(
v5,
&v4);
ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>>::Send(v3, v5);
std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~variant((long long)v5);
std::this_thread::sleep_for<long,std::ratio<1l,1000l>>(v6);
}
return result;
}
| AnimationListener:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x80],RSI
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [0x001931f8]
MOV qword ptr [RBP + -0x18],RAX
LAB_00163112:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0016ba50
XOR AL,0xff
TEST AL,0x1
JNZ 0x00163123
JMP 0x00163187
LAB_00163123:
MOV RDI,qword ptr [RBP + -0x80]
CALL 0x001695c0
MOV qword ptr [RBP + -0x90],RAX
LEA RDI,[RBP + -0x60]
MOV qword ptr [RBP + -0x88],RDI
LEA RSI,[RBP + -0x61]
CALL 0x0016bce0
MOV RDI,qword ptr [RBP + -0x90]
MOV RSI,qword ptr [RBP + -0x88]
LAB_00163155:
CALL 0x001695e0
LAB_0016315a:
JMP 0x0016315c
LAB_0016315c:
LEA RDI,[RBP + -0x60]
CALL 0x00121650
LEA RDI,[RBP + -0x18]
CALL 0x0016bd10
JMP 0x00163112
LAB_00163187:
ADD RSP,0x90
POP RBP
RET
|
/* ftxui::(anonymous namespace)::AnimationListener(std::atomic<bool>*,
std::unique_ptr<ftxui::SenderImpl<std::variant<ftxui::Event, std::function<void ()>,
ftxui::AnimationTask> >, std::default_delete<ftxui::SenderImpl<std::variant<ftxui::Event,
std::function<void ()>, ftxui::AnimationTask> > > >) */
void ftxui::(anonymous_namespace)::AnimationListener
(atomic *param_1,
unique_ptr<ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>>,std::default_delete<ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>>>>
*param_2)
{
bool bVar1;
SenderImpl<std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>> *pSVar2;
AnimationTask local_69;
variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask> local_68 [72];
int8 local_20;
unique_ptr<ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>>,std::default_delete<ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>>>>
*local_18;
atomic *local_10;
local_20 = DAT_001931f8;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar1 = std::atomic::operator_cast_to_bool(local_10);
if (((bVar1 ^ 0xffU) & 1) == 0) break;
pSVar2 = (SenderImpl<std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>> *)
std::
unique_ptr<ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>>,std::default_delete<ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>>>>
::operator->(param_2);
std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>::
variant<ftxui::AnimationTask,void,void,ftxui::AnimationTask,void>(local_68,&local_69);
/* try { // try from 00163155 to 00163159 has its CatchHandler @ 00163170 */
SenderImpl<std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>>::Send
(pSVar2,local_68);
std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>::~variant(local_68);
std::this_thread::sleep_for<long,std::ratio<1l,1000l>>((duration *)&local_20);
}
return;
}
| |
26,084 | js_operator_typeof | bluesky950520[P]quickjs/quickjs.c | static __exception int js_operator_typeof(JSContext *ctx, JSValue op1)
{
JSAtom atom;
uint32_t tag;
tag = JS_VALUE_GET_NORM_TAG(op1);
switch(tag) {
case JS_TAG_BIG_INT:
atom = JS_ATOM_bigint;
break;
case JS_TAG_INT:
case JS_TAG_FLOAT64:
atom = JS_ATOM_number;
break;
case JS_TAG_UNDEFINED:
atom = JS_ATOM_undefined;
break;
case JS_TAG_BOOL:
atom = JS_ATOM_boolean;
break;
case JS_TAG_STRING:
atom = JS_ATOM_string;
break;
case JS_TAG_OBJECT:
{
JSObject *p;
p = JS_VALUE_GET_OBJ(op1);
if (unlikely(p->is_HTMLDDA))
atom = JS_ATOM_undefined;
else if (JS_IsFunction(ctx, op1))
atom = JS_ATOM_function;
else
goto obj_type;
}
break;
case JS_TAG_NULL:
obj_type:
atom = JS_ATOM_object;
break;
case JS_TAG_SYMBOL:
atom = JS_ATOM_symbol;
break;
default:
atom = JS_ATOM_unknown;
break;
}
return atom;
} | O1 | c | js_operator_typeof:
pushq %rax
movq %rsi, (%rsp)
leal 0x9(%rdx), %eax
cmpl $0x10, %eax
ja 0x41422
leaq 0x5b841(%rip), %rcx # 0x9cc08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x47, %eax
jmp 0x41427
movl $0x49, %eax
jmp 0x41427
movl $0x48, %eax
jmp 0x41427
movl $0x8d, %eax
jmp 0x41427
movl $0x4b, %eax
jmp 0x41427
movq (%rsp), %rax
cmpb $0x0, 0x5(%rax)
js 0x41429
movq (%rsp), %rsi
callq 0x22dbe
testl %eax, %eax
sete %cl
movl $0x1b, %eax
testb %cl, %cl
je 0x41427
movl $0x4a, %eax
jmp 0x41427
movl $0x46, %eax
jmp 0x41427
movl $0x4d, %eax
popq %rcx
retq
movl $0x46, %eax
xorl %ecx, %ecx
jmp 0x41410
| js_operator_typeof:
push rax
mov [rsp+8+var_8], rsi
lea eax, [rdx+9]; switch 17 cases
cmp eax, 10h
ja short def_413CE; jumptable 00000000000413CE default case, cases -6--2,4-6
lea rcx, jpt_413CE
movsxd rax, ds:(jpt_413CE - 9CC08h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_413D0:
mov eax, 47h ; 'G'; jumptable 00000000000413CE cases 0,7
jmp short loc_41427
loc_413D7:
mov eax, 49h ; 'I'; jumptable 00000000000413CE case -7
jmp short loc_41427
loc_413DE:
mov eax, 48h ; 'H'; jumptable 00000000000413CE case 1
jmp short loc_41427
loc_413E5:
mov eax, 8Dh; jumptable 00000000000413CE case -9
jmp short loc_41427
loc_413EC:
mov eax, 4Bh ; 'K'; jumptable 00000000000413CE case -8
jmp short loc_41427
loc_413F3:
mov rax, [rsp+8+var_8]; jumptable 00000000000413CE case -1
cmp byte ptr [rax+5], 0
js short loc_41429
mov rsi, [rsp+8+var_8]
call JS_IsFunction
test eax, eax
setz cl
mov eax, 1Bh
loc_41410:
test cl, cl
jz short loc_41427
loc_41414:
mov eax, 4Ah ; 'J'; jumptable 00000000000413CE case 2
jmp short loc_41427
loc_4141B:
mov eax, 46h ; 'F'; jumptable 00000000000413CE case 3
jmp short loc_41427
def_413CE:
mov eax, 4Dh ; 'M'; jumptable 00000000000413CE default case, cases -6--2,4-6
loc_41427:
pop rcx
retn
loc_41429:
mov eax, 46h ; 'F'
xor ecx, ecx
jmp short loc_41410
| long long js_operator_typeof(long long a1, long long a2, int a3)
{
long long result; // rax
bool v4; // cl
switch ( a3 )
{
case -9:
result = 141LL;
break;
case -8:
result = 75LL;
break;
case -7:
result = 73LL;
break;
case -1:
if ( *(char *)(a2 + 5) < 0 )
{
result = 70LL;
v4 = 0;
}
else
{
v4 = (unsigned int)JS_IsFunction(a1, a2, a3) == 0;
result = 27LL;
}
if ( v4 )
goto LABEL_10;
break;
case 0:
case 7:
result = 71LL;
break;
case 1:
result = 72LL;
break;
case 2:
LABEL_10:
result = 74LL;
break;
case 3:
result = 70LL;
break;
default:
result = 77LL;
break;
}
return result;
}
| js_operator_typeof:
PUSH RAX
MOV qword ptr [RSP],RSI
LEA EAX,[RDX + 0x9]
CMP EAX,0x10
JA 0x00141422
LEA RCX,[0x19cc08]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV EAX,0x47
JMP 0x00141427
caseD_fffffff9:
MOV EAX,0x49
JMP 0x00141427
caseD_1:
MOV EAX,0x48
JMP 0x00141427
caseD_fffffff7:
MOV EAX,0x8d
JMP 0x00141427
caseD_fffffff8:
MOV EAX,0x4b
JMP 0x00141427
caseD_ffffffff:
MOV RAX,qword ptr [RSP]
CMP byte ptr [RAX + 0x5],0x0
JS 0x00141429
MOV RSI,qword ptr [RSP]
CALL 0x00122dbe
TEST EAX,EAX
SETZ CL
MOV EAX,0x1b
LAB_00141410:
TEST CL,CL
JZ 0x00141427
caseD_2:
MOV EAX,0x4a
JMP 0x00141427
caseD_3:
MOV EAX,0x46
JMP 0x00141427
caseD_fffffffa:
MOV EAX,0x4d
LAB_00141427:
POP RCX
RET
LAB_00141429:
MOV EAX,0x46
XOR ECX,ECX
JMP 0x00141410
|
int8 js_operator_typeof(int8 param_1,long param_2,int4 param_3)
{
int iVar1;
int8 uVar2;
bool bVar3;
switch(param_3) {
case 0:
case 7:
uVar2 = 0x47;
break;
case 1:
uVar2 = 0x48;
break;
case 3:
uVar2 = 0x46;
break;
case 0xfffffff7:
uVar2 = 0x8d;
break;
case 0xfffffff8:
uVar2 = 0x4b;
break;
case 0xfffffff9:
uVar2 = 0x49;
break;
default:
uVar2 = 0x4d;
break;
case 0xffffffff:
if (*(char *)(param_2 + 5) < '\0') {
uVar2 = 0x46;
bVar3 = false;
}
else {
iVar1 = JS_IsFunction(param_1,param_2);
bVar3 = iVar1 == 0;
uVar2 = 0x1b;
}
if (!bVar3) {
return uVar2;
}
case 2:
uVar2 = 0x4a;
}
return uVar2;
}
| |
26,085 | js_typed_array_create | bluesky950520[P]quickjs/quickjs.c | static JSValue js_typed_array_create(JSContext *ctx, JSValue ctor,
int argc, JSValue *argv)
{
JSValue ret;
int new_len;
int64_t len;
ret = JS_CallConstructor(ctx, ctor, argc, argv);
if (JS_IsException(ret))
return ret;
/* validate the typed array */
new_len = js_typed_array_get_length_unsafe(ctx, ret);
if (new_len < 0)
goto fail;
if (argc == 1) {
/* ensure that it is large enough */
if (JS_ToLengthFree(ctx, &len, js_dup(argv[0])))
goto fail;
if (new_len < len) {
JS_ThrowTypeError(ctx, "TypedArray length is too small");
fail:
JS_FreeValue(ctx, ret);
return JS_EXCEPTION;
}
}
return ret;
} | O1 | c | js_typed_array_create:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movl %ecx, %r13d
movq %rdi, %r15
movq %rsi, %rcx
movq %rdx, %r8
movl %r13d, %r9d
pushq $0x2
pushq %r12
callq 0x2fa61
addq $0x10, %rsp
movq %rax, %r14
movq %rdx, %rbx
cmpl $0x6, %ebx
je 0x781aa
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x77f2d
testl %eax, %eax
js 0x7818f
cmpl $0x1, %r13d
jne 0x781aa
movl %eax, %ebp
movq (%r12), %r13
movq 0x8(%r12), %r12
movq %r13, 0x8(%rsp)
cmpl $-0x9, %r12d
jb 0x78131
movq 0x8(%rsp), %rax
incl (%rax)
subq $0x8, %rsp
leaq 0x10(%rsp), %rsi
movabsq $0x1fffffffffffff, %r9 # imm = 0x1FFFFFFFFFFFFF
movq %r15, %rdi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
pushq $0x0
callq 0x27858
addq $0x10, %rsp
movl %eax, 0x14(%rsp)
movq 0x18(%r15), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1d8c6
cmpl $0x0, 0x14(%rsp)
jne 0x7818f
movl %ebp, %eax
cmpq %rax, 0x8(%rsp)
jle 0x781aa
leaq 0x29c18(%rip), %rsi # 0xa1d9d
movq %r15, %rdi
xorl %eax, %eax
callq 0x22567
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1d8c6
movl $0x6, %ebx
xorl %r14d, %r14d
xorl %ecx, %ecx
jmp 0x781ba
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r14, %rcx
andq %rax, %rcx
movl %r14d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_typed_array_create:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, r8
mov r13d, ecx
mov r15, rdi
mov rcx, rsi
mov r8, rdx
mov r9d, r13d
push 2
push r12
call JS_CallConstructorInternal
add rsp, 10h
mov r14, rax
mov rbx, rdx
cmp ebx, 6
jz loc_781AA
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call js_typed_array_get_length_unsafe
test eax, eax
js loc_7818F
cmp r13d, 1
jnz loc_781AA
mov ebp, eax
mov r13, [r12]
mov r12, [r12+8]
mov [rsp+48h+var_40], r13
cmp r12d, 0FFFFFFF7h
jb short loc_78131
mov rax, [rsp+48h+var_40]
inc dword ptr [rax]
loc_78131:
sub rsp, 8
lea rsi, [rsp+50h+var_40]
mov r9, 1FFFFFFFFFFFFFh
mov rdi, r15
mov rdx, r13
mov rcx, r12
xor r8d, r8d
push 0
call JS_ToInt64Clamp
add rsp, 10h
mov [rsp+48h+var_34], eax
mov rdi, [r15+18h]
mov rsi, r13
mov rdx, r12
call JS_FreeValueRT
cmp [rsp+48h+var_34], 0
jnz short loc_7818F
mov eax, ebp
cmp [rsp+48h+var_40], rax
jle short loc_781AA
lea rsi, aTypedarrayLeng; "TypedArray length is too small"
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
loc_7818F:
mov rdi, [r15+18h]
mov rsi, r14
mov rdx, rbx
call JS_FreeValueRT
mov ebx, 6
xor r14d, r14d
xor ecx, ecx
jmp short loc_781BA
loc_781AA:
mov rax, 0FFFFFFFF00000000h
mov rcx, r14
and rcx, rax
loc_781BA:
mov eax, r14d
or rax, rcx
mov rdx, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long js_typed_array_create(
long long a1,
unsigned long long a2,
long long a3,
unsigned int a4,
_QWORD *a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13)
{
unsigned long long v15; // rax
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
unsigned long long v22; // r14
long long v23; // rbx
int length_unsafe; // eax
unsigned int v25; // ebp
_DWORD *v26; // r13
long long v27; // r12
long long v28; // rdx
long long v29; // rcx
long long v30; // r8
long long v31; // r9
__m128 v32; // xmm4
__m128 v33; // xmm5
unsigned long long v34; // rcx
char v36; // [rsp+0h] [rbp-48h]
_DWORD *v37; // [rsp+8h] [rbp-40h] BYREF
int v38; // [rsp+14h] [rbp-34h]
v15 = JS_CallConstructorInternal(a1, a2, a3, a2, a3, a4, a6, a7, a8, a9, a10, a11, a12, a13, (long long)a5, 2);
v22 = v15;
v23 = v16;
if ( (_DWORD)v16 == 6 )
goto LABEL_10;
length_unsafe = js_typed_array_get_length_unsafe(a1, v15, v16, v17, v18, v19, a6, a7, a8, a9, v20, v21, a12, a13);
if ( length_unsafe >= 0 )
{
if ( a4 == 1 )
{
v25 = length_unsafe;
v26 = (_DWORD *)*a5;
v27 = a5[1];
v37 = v26;
if ( (unsigned int)v27 >= 0xFFFFFFF7 )
++*v37;
v38 = JS_ToInt64Clamp(a1, (unsigned long long *)&v37, v26, v27, 0LL, 0x1FFFFFFFFFFFFFLL, 0LL);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v26, v27);
if ( v38 )
goto LABEL_9;
if ( (long long)v37 > v25 )
{
JS_ThrowTypeError(
a1,
(long long)"TypedArray length is too small",
v28,
v29,
v30,
v31,
a6,
a7,
a8,
a9,
v32,
v33,
a12,
a13,
v36);
goto LABEL_9;
}
}
LABEL_10:
v34 = v22 & 0xFFFFFFFF00000000LL;
return v34 | (unsigned int)v22;
}
LABEL_9:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v22, v23);
LODWORD(v22) = 0;
v34 = 0LL;
return v34 | (unsigned int)v22;
}
| |||
26,086 | js_typed_array_create | bluesky950520[P]quickjs/quickjs.c | static JSValue js_typed_array_create(JSContext *ctx, JSValue ctor,
int argc, JSValue *argv)
{
JSValue ret;
int new_len;
int64_t len;
ret = JS_CallConstructor(ctx, ctor, argc, argv);
if (JS_IsException(ret))
return ret;
/* validate the typed array */
new_len = js_typed_array_get_length_unsafe(ctx, ret);
if (new_len < 0)
goto fail;
if (argc == 1) {
/* ensure that it is large enough */
if (JS_ToLengthFree(ctx, &len, js_dup(argv[0])))
goto fail;
if (new_len < len) {
JS_ThrowTypeError(ctx, "TypedArray length is too small");
fail:
JS_FreeValue(ctx, ret);
return JS_EXCEPTION;
}
}
return ret;
} | O2 | c | js_typed_array_create:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movl %ecx, %ebp
movq %rdi, %r15
callq 0x283f2
movq %rax, %r14
movq %rdx, %rbx
cmpl $0x6, %ebx
je 0x6500a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x64e60
testl %eax, %eax
js 0x64ff2
cmpl $0x1, %ebp
jne 0x6500a
movl %eax, %r13d
movq (%r12), %rdx
movq 0x8(%r12), %rcx
cmpl $-0x9, %ecx
jb 0x64fc9
incl (%rdx)
movq %rsp, %rsi
movq %r15, %rdi
callq 0x3daf8
testl %eax, %eax
jne 0x64ff2
movl %r13d, %eax
cmpq %rax, (%rsp)
jle 0x6500a
leaq 0x23cef(%rip), %rsi # 0x88cd7
movq %r15, %rdi
xorl %eax, %eax
callq 0x1c64d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1801e
pushq $0x6
popq %rbx
xorl %r14d, %r14d
xorl %ecx, %ecx
jmp 0x6501a
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r14, %rcx
andq %rax, %rcx
movl %r14d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_typed_array_create:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, r8
mov ebp, ecx
mov r15, rdi
call JS_CallConstructor
mov r14, rax
mov rbx, rdx
cmp ebx, 6
jz short loc_6500A
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call js_typed_array_get_length_unsafe
test eax, eax
js short loc_64FF2
cmp ebp, 1
jnz short loc_6500A
mov r13d, eax
mov rdx, [r12]
mov rcx, [r12+8]
cmp ecx, 0FFFFFFF7h
jb short loc_64FC9
inc dword ptr [rdx]
loc_64FC9:
mov rsi, rsp
mov rdi, r15
call JS_ToLengthFree
test eax, eax
jnz short loc_64FF2
mov eax, r13d
cmp [rsp+38h+var_38], rax
jle short loc_6500A
lea rsi, aTypedarrayLeng; "TypedArray length is too small"
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
loc_64FF2:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
push 6
pop rbx
xor r14d, r14d
xor ecx, ecx
jmp short loc_6501A
loc_6500A:
mov rax, 0FFFFFFFF00000000h
mov rcx, r14
and rcx, rax
loc_6501A:
mov eax, r14d
or rax, rcx
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long js_typed_array_create(
long long a1,
unsigned long long a2,
unsigned long long a3,
unsigned int a4,
_QWORD *a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rax
unsigned long long v16; // rax
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
__m128 v21; // xmm4
__m128 v22; // xmm5
long long v23; // r14
long long v24; // rbx
int length_unsafe; // eax
unsigned int v26; // r13d
_DWORD *v27; // rdx
long long v28; // rcx
long long v29; // rdx
long long v30; // rcx
long long v31; // r8
long long v32; // r9
__m128 v33; // xmm4
__m128 v34; // xmm5
unsigned long long v35; // rcx
unsigned long long v37[7]; // [rsp+0h] [rbp-38h] BYREF
v37[0] = v13;
v16 = JS_CallConstructor(a1, a2, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13);
v23 = v16;
v24 = v17;
if ( (_DWORD)v17 == 6 )
goto LABEL_10;
length_unsafe = js_typed_array_get_length_unsafe(a1, v16, v17, v18, v19, v20, a6, a7, a8, a9, v21, v22, a12, a13);
if ( length_unsafe >= 0 )
{
if ( a4 == 1 )
{
v26 = length_unsafe;
v27 = (_DWORD *)*a5;
v28 = a5[1];
if ( (unsigned int)v28 >= 0xFFFFFFF7 )
++*v27;
if ( (unsigned int)JS_ToLengthFree(a1, v37, v27, v28) )
goto LABEL_9;
if ( (long long)v37[0] > v26 )
{
JS_ThrowTypeError(
a1,
(long long)"TypedArray length is too small",
v29,
v30,
v31,
v32,
a6,
a7,
a8,
a9,
v33,
v34,
a12,
a13,
v37[0]);
goto LABEL_9;
}
}
LABEL_10:
v35 = v23 & 0xFFFFFFFF00000000LL;
return v35 | (unsigned int)v23;
}
LABEL_9:
JS_FreeValue(a1, v23, v24);
LODWORD(v23) = 0;
v35 = 0LL;
return v35 | (unsigned int)v23;
}
| js_typed_array_create:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,R8
MOV EBP,ECX
MOV R15,RDI
CALL 0x001283f2
MOV R14,RAX
MOV RBX,RDX
CMP EBX,0x6
JZ 0x0016500a
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00164e60
TEST EAX,EAX
JS 0x00164ff2
CMP EBP,0x1
JNZ 0x0016500a
MOV R13D,EAX
MOV RDX,qword ptr [R12]
MOV RCX,qword ptr [R12 + 0x8]
CMP ECX,-0x9
JC 0x00164fc9
INC dword ptr [RDX]
LAB_00164fc9:
MOV RSI,RSP
MOV RDI,R15
CALL 0x0013daf8
TEST EAX,EAX
JNZ 0x00164ff2
MOV EAX,R13D
CMP qword ptr [RSP],RAX
JLE 0x0016500a
LEA RSI,[0x188cd7]
MOV RDI,R15
XOR EAX,EAX
CALL 0x0011c64d
LAB_00164ff2:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011801e
PUSH 0x6
POP RBX
XOR R14D,R14D
XOR ECX,ECX
JMP 0x0016501a
LAB_0016500a:
MOV RAX,-0x100000000
MOV RCX,R14
AND RCX,RAX
LAB_0016501a:
MOV EAX,R14D
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
js_typed_array_create
(int8 param_1,int8 param_2,int8 param_3,int param_4,int8 *param_5)
{
uint uVar1;
int iVar2;
long in_RAX;
ulong uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
long local_38;
local_38 = in_RAX;
auVar4 = JS_CallConstructor();
uVar3 = auVar4._0_8_;
if (auVar4._8_4_ == 6) {
LAB_0016500a:
uVar3 = uVar3 & 0xffffffff00000000;
}
else {
uVar1 = js_typed_array_get_length_unsafe(param_1,uVar3,auVar4._8_8_);
if (-1 < (int)uVar1) {
if (param_4 != 1) goto LAB_0016500a;
if (0xfffffff6 < (uint)param_5[1]) {
*(int *)*param_5 = *(int *)*param_5 + 1;
}
iVar2 = JS_ToLengthFree(param_1,&local_38);
if (iVar2 == 0) {
if (local_38 <= (long)(ulong)uVar1) goto LAB_0016500a;
JS_ThrowTypeError(param_1,"TypedArray length is too small");
}
}
JS_FreeValue(param_1,uVar3,auVar4._8_8_);
auVar4 = ZEXT816(6) << 0x40;
uVar3 = 0;
}
auVar5._0_8_ = auVar4._0_8_ & 0xffffffff | uVar3;
auVar5._8_8_ = auVar4._8_8_;
return auVar5;
}
| |
26,087 | js_os_waitpid | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_os_waitpid(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int pid, status, options, ret;
JSValue obj;
if (JS_ToInt32(ctx, &pid, argv[0]))
return JS_EXCEPTION;
if (JS_ToInt32(ctx, &options, argv[1]))
return JS_EXCEPTION;
ret = waitpid(pid, &status, options);
if (ret < 0) {
ret = -errno;
status = 0;
}
obj = JS_NewArray(ctx);
if (JS_IsException(obj))
return obj;
JS_DefinePropertyValueUint32(ctx, obj, 0, JS_NewInt32(ctx, ret),
JS_PROP_C_W_E);
JS_DefinePropertyValueUint32(ctx, obj, 1, JS_NewInt32(ctx, status),
JS_PROP_C_W_E);
return obj;
} | O2 | c | js_os_waitpid:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r15
movq %rdi, %rbx
movq (%r8), %rdx
movq 0x8(%r8), %rcx
leaq 0x1c(%rsp), %rsi
callq 0x25187
pushq $0x6
popq %r14
testl %eax, %eax
jne 0x190c0
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x25187
testl %eax, %eax
je 0x190db
xorl %r15d, %r15d
xorl %ecx, %ecx
movl %r15d, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %edx
leaq 0x14(%rsp), %rsi
callq 0xe7e0
movl %eax, %ebp
testl %eax, %eax
jns 0x19101
callq 0xe0b0
xorl %ebp, %ebp
subl (%rax), %ebp
andl $0x0, 0x14(%rsp)
movabsq $-0x100000000, %r12 # imm = 0xFFFFFFFF00000000
movq %rbx, %rdi
callq 0x1ee6b
movq %rax, %r15
movq %rdx, %r14
cmpl $0x6, %r14d
je 0x19157
movl %ebp, %r8d
pushq $0x7
popq %rbp
movl %ebp, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x24522
movl 0x14(%rsp), %r8d
movl %ebp, (%rsp)
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x24522
movq %r15, %rcx
andq %r12, %rcx
jmp 0x190c5
| js_os_waitpid:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov r15, r8
mov rbx, rdi
mov rdx, [r8]
mov rcx, [r8+8]
lea rsi, [rsp+48h+var_2C]
call JS_ToInt32
push 6
pop r14
test eax, eax
jnz short loc_190C0
mov rdx, [r15+10h]
mov rcx, [r15+18h]
lea rsi, [rsp+48h+var_30]
mov rdi, rbx
call JS_ToInt32
test eax, eax
jz short loc_190DB
loc_190C0:
xor r15d, r15d
xor ecx, ecx
loc_190C5:
mov eax, r15d
or rax, rcx
mov rdx, r14
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_190DB:
mov edi, [rsp+48h+var_2C]
mov edx, [rsp+48h+var_30]
lea rsi, [rsp+48h+var_34]
call _waitpid
mov ebp, eax
test eax, eax
jns short loc_19101
call ___errno_location
xor ebp, ebp
sub ebp, [rax]
and [rsp+48h+var_34], 0
loc_19101:
mov r12, 0FFFFFFFF00000000h
mov rdi, rbx
call JS_NewArray
mov r15, rax
mov r14, rdx
cmp r14d, 6
jz short loc_19157
mov r8d, ebp
push 7
pop rbp
mov [rsp+48h+var_48], ebp
mov rdi, rbx
mov rsi, r15
mov rdx, r14
xor ecx, ecx
xor r9d, r9d
call JS_DefinePropertyValueUint32
mov r8d, [rsp+48h+var_34]
mov [rsp+48h+var_48], ebp
push 1
pop rcx
mov rdi, rbx
mov rsi, r15
mov rdx, r14
xor r9d, r9d
call JS_DefinePropertyValueUint32
loc_19157:
mov rcx, r15
and rcx, r12
jmp loc_190C5
| unsigned long long js_os_waitpid(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
long long v7; // r15
unsigned long long v8; // rcx
long long v10; // rdi
int v11; // ebp
long long v12; // rax
int v13; // edx
int v14; // r14d
int v15; // [rsp+14h] [rbp-34h] BYREF
unsigned int v16; // [rsp+18h] [rbp-30h] BYREF
_DWORD v17[11]; // [rsp+1Ch] [rbp-2Ch] BYREF
if ( (unsigned int)JS_ToInt32(a1, v17, *a5, a5[1]) || (unsigned int)JS_ToInt32(a1, &v16, a5[2], a5[3]) )
{
LODWORD(v7) = 0;
v8 = 0LL;
}
else
{
v10 = v17[0];
v11 = waitpid(v17[0], &v15, v16);
if ( v11 < 0 )
{
v11 = -*(_DWORD *)__errno_location(v10);
v15 = 0;
}
v12 = JS_NewArray(a1);
v7 = v12;
v14 = v13;
if ( v13 != 6 )
{
JS_DefinePropertyValueUint32(a1, v12, v13, 0, v11, 0, 7);
JS_DefinePropertyValueUint32(a1, v7, v14, 1, v15, 0, 7);
}
v8 = v7 & 0xFFFFFFFF00000000LL;
}
return v8 | (unsigned int)v7;
}
| js_os_waitpid:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV R15,R8
MOV RBX,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
LEA RSI,[RSP + 0x1c]
CALL 0x00125187
PUSH 0x6
POP R14
TEST EAX,EAX
JNZ 0x001190c0
MOV RDX,qword ptr [R15 + 0x10]
MOV RCX,qword ptr [R15 + 0x18]
LEA RSI,[RSP + 0x18]
MOV RDI,RBX
CALL 0x00125187
TEST EAX,EAX
JZ 0x001190db
LAB_001190c0:
XOR R15D,R15D
XOR ECX,ECX
LAB_001190c5:
MOV EAX,R15D
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001190db:
MOV EDI,dword ptr [RSP + 0x1c]
MOV EDX,dword ptr [RSP + 0x18]
LEA RSI,[RSP + 0x14]
CALL 0x0010e7e0
MOV EBP,EAX
TEST EAX,EAX
JNS 0x00119101
CALL 0x0010e0b0
XOR EBP,EBP
SUB EBP,dword ptr [RAX]
AND dword ptr [RSP + 0x14],0x0
LAB_00119101:
MOV R12,-0x100000000
MOV RDI,RBX
CALL 0x0011ee6b
MOV R15,RAX
MOV R14,RDX
CMP R14D,0x6
JZ 0x00119157
MOV R8D,EBP
PUSH 0x7
POP RBP
MOV dword ptr [RSP],EBP
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
XOR ECX,ECX
XOR R9D,R9D
CALL 0x00124522
MOV R8D,dword ptr [RSP + 0x14]
MOV dword ptr [RSP],EBP
PUSH 0x1
POP RCX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
XOR R9D,R9D
CALL 0x00124522
LAB_00119157:
MOV RCX,R15
AND RCX,R12
JMP 0x001190c5
|
int1 [16] js_os_waitpid(int8 param_1)
{
int iVar1;
int *piVar2;
ulong uVar3;
int8 *in_R8;
int1 auVar4 [16];
int1 auVar5 [16];
int local_34;
int local_30;
__pid_t local_2c;
iVar1 = JS_ToInt32(param_1,&local_2c,*in_R8,in_R8[1]);
if (iVar1 == 0) {
iVar1 = JS_ToInt32(param_1,&local_30,in_R8[2],in_R8[3]);
if (iVar1 == 0) {
iVar1 = waitpid(local_2c,&local_34,local_30);
if (iVar1 < 0) {
piVar2 = __errno_location();
iVar1 = -*piVar2;
local_34 = 0;
}
auVar5 = JS_NewArray(param_1);
uVar3 = auVar5._0_8_;
if (auVar5._8_4_ != 6) {
JS_DefinePropertyValueUint32(param_1,uVar3,auVar5._8_8_,0,iVar1,0,7);
JS_DefinePropertyValueUint32(param_1,uVar3,auVar5._8_8_,1,local_34,0,7);
}
uVar3 = uVar3 & 0xffffffff00000000;
goto LAB_001190c5;
}
}
auVar5 = ZEXT816(6) << 0x40;
uVar3 = 0;
LAB_001190c5:
auVar4._0_8_ = auVar5._0_8_ & 0xffffffff | uVar3;
auVar4._8_8_ = auVar5._8_8_;
return auVar4;
}
| |
26,088 | minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | ArgumentsValue evaluate(const std::shared_ptr<Context> & context) const {
ArgumentsValue vargs;
for (const auto& arg : this->args) {
if (auto un_expr = std::dynamic_pointer_cast<UnaryOpExpr>(arg)) {
if (un_expr->op == UnaryOpExpr::Op::Expansion) {
auto array = un_expr->expr->evaluate(context);
if (!array.is_array()) {
throw std::runtime_error("Expansion operator only supported on arrays");
}
array.for_each([&](Value & value) {
vargs.args.push_back(value);
});
continue;
} else if (un_expr->op == UnaryOpExpr::Op::ExpansionDict) {
auto dict = un_expr->expr->evaluate(context);
if (!dict.is_object()) {
throw std::runtime_error("ExpansionDict operator only supported on objects");
}
dict.for_each([&](const Value & key) {
vargs.kwargs.push_back({key.get<std::string>(), dict.at(key)});
});
continue;
}
}
vargs.args.push_back(arg->evaluate(context));
}
for (const auto& [name, value] : this->kwargs) {
vargs.kwargs.push_back({name, value->evaluate(context)});
}
return vargs;
} | O3 | cpp | minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq %rdi, (%rsp)
movups %xmm0, (%rdi)
movq (%rsi), %rbx
movq %rsi, 0x58(%rsp)
movq 0x8(%rsi), %r12
cmpq %r12, %rbx
je 0x66766
leaq 0xa8(%rsp), %r13
leaq 0x68(%rsp), %rbp
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6669d
leaq 0x88d73(%rip), %rsi # 0xef260
leaq 0x88d7c(%rip), %rdx # 0xef270
xorl %ecx, %ecx
callq 0x198c0
testq %rax, %rax
je 0x6669d
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x66524
movq 0x8aa84(%rip), %rcx # 0xf0f98
cmpb $0x0, (%rcx)
je 0x6651f
incl 0x8(%r15)
jmp 0x66524
lock
incl 0x8(%r15)
movl 0x30(%rax), %ecx
cmpl $0x4, %ecx
je 0x665a2
cmpl $0x3, %ecx
jne 0x66690
movq 0x20(%rax), %rsi
movq %rbp, %rdi
movq %r14, %rdx
callq 0x5061c
cmpq $0x0, 0x78(%rsp)
je 0x66896
movq $0x0, 0x10(%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18fb(%rip), %rax # 0x67e64
movq %rax, 0x20(%rsp)
leaq 0x18f7(%rip), %rax # 0x67e6c
movq %rax, 0x18(%rsp)
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x67912
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x6660c
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x6660c
movq 0x20(%rax), %rsi
movq %rbp, %rdi
movq %r14, %rdx
callq 0x5061c
cmpq $0x0, 0x88(%rsp)
je 0x66862
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rbp, 0x10(%rsp)
leaq 0x18bd(%rip), %rax # 0x67e92
movq %rax, 0x20(%rsp)
leaq 0x18b7(%rip), %rax # 0x67e98
movq %rax, 0x18(%rsp)
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x67912
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x6660c
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0xa8(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x5099a
movq %r13, %rdi
callq 0x5d0d4
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x66638
callq 0x31b9a
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
leaq 0xa8(%rsp), %r13
je 0x66652
callq 0x31b9a
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x66664
callq 0x31b9a
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x6674c
movq 0x8a91f(%rip), %rax # 0xf0f98
cmpb $0x0, (%rax)
je 0x66737
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x66741
testq %r15, %r15
je 0x6669d
movq %r15, %rdi
callq 0x31b9a
movq (%rbx), %rsi
movq %rbp, %rdi
movq %r14, %rdx
callq 0x5061c
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x61abc
movq %r13, %rdi
xorl %esi, %esi
callq 0x5099a
movq %r13, %rdi
callq 0x5d0d4
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x666db
callq 0x31b9a
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x666ed
callq 0x31b9a
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x666ff
callq 0x31b9a
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x66759
movq 0x8a888(%rip), %rax # 0xf0f98
cmpb $0x0, (%rax)
je 0x66720
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x6672a
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x66759
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x66759
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x6674c
movq (%rdi), %rax
callq *0x18(%rax)
testq %r15, %r15
je 0x66759
movq %r15, %rdi
callq 0x31b9a
addq $0x10, %rbx
cmpq %r12, %rbx
jne 0x664da
movq %r14, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq 0x18(%rax), %r15
movq 0x20(%rax), %r14
cmpq %r14, %r15
je 0x6684c
movq (%rsp), %rax
leaq 0x18(%rax), %r12
leaq 0x48(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq 0x68(%rsp), %rbx
movq 0x20(%r15), %rsi
movq %rbp, %rdi
movq 0x60(%rsp), %rdx
callq 0x5061c
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x67d22
movq %r12, %rdi
movq %rbx, %rsi
callq 0x67fe8
movq %rbx, %rdi
callq 0x67dc2
movq %r13, %rdi
xorl %esi, %esi
callq 0x5099a
movq %r13, %rdi
callq 0x5d0d4
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x667eb
callq 0x31b9a
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x667fa
callq 0x31b9a
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x66809
callq 0x31b9a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6683f
movq 0x8a77e(%rip), %rax # 0xf0f98
cmpb $0x0, (%rax)
je 0x6682a
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x66834
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x6683f
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x30, %r15
cmpq %r14, %r15
jne 0x66798
movq (%rsp), %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x193b0
movq %rax, %rbx
leaq 0x5616b(%rip), %rsi # 0xbc9e1
movq %rax, %rdi
callq 0x192a0
movq 0x8a76b(%rip), %rsi # 0xf0ff0
movq 0x8a6e4(%rip), %rdx # 0xf0f70
movq %rbx, %rdi
callq 0x19d60
jmp 0x668c8
movl $0x10, %edi
callq 0x193b0
movq %rax, %rbx
leaq 0x5610b(%rip), %rsi # 0xbc9b5
movq %rax, %rdi
callq 0x192a0
movq 0x8a737(%rip), %rsi # 0xf0ff0
movq 0x8a6b0(%rip), %rdx # 0xf0f70
movq %rbx, %rdi
callq 0x19d60
jmp 0x668cc
jmp 0x668d1
movq %rax, %r14
jmp 0x66920
movq %rax, %r14
movq %rbx, %rdi
callq 0x195a0
jmp 0x66920
jmp 0x6692c
jmp 0x6692c
movq %rax, %r14
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x66920
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x66920
jmp 0x6692c
jmp 0x66934
movq %rax, %r14
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x66920
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x68(%rsp), %rdi
callq 0x5090e
jmp 0x66937
movq %rax, %rdi
callq 0x24406
movq %rax, %r14
testq %r15, %r15
je 0x66973
movq %r15, %rdi
callq 0x31b9a
jmp 0x66973
movq %rax, %r14
leaq 0x68(%rsp), %rdi
jmp 0x6696e
jmp 0x66952
movq %rax, %r14
jmp 0x66973
movq %rax, %r14
jmp 0x66969
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x67dc2
leaq 0x8(%rsp), %rdi
callq 0x5090e
movq (%rsp), %rbx
leaq 0x18(%rbx), %rdi
callq 0x68b5a
movq %rbx, %rdi
callq 0x619ec
movq %r14, %rdi
callq 0x19dc0
| _ZNK5minja19ArgumentsExpression8evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0D8h
mov r14, rdx
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
mov [rsp+108h+var_108], rdi
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
mov [rsp+108h+var_B0], rsi
mov r12, [rsi+8]
cmp rbx, r12
jz loc_66766
lea r13, [rsp+108h+var_60]
lea rbp, [rsp+108h+var_A0]
loc_664DA:
mov rdi, [rbx]; lpsrc
test rdi, rdi
jz loc_6669D
lea rsi, _ZTIN5minja10ExpressionE; lpstype
lea rdx, _ZTIN5minja11UnaryOpExprE; lpdtype
xor ecx, ecx; s2d
call ___dynamic_cast
test rax, rax
jz loc_6669D
mov r15, [rbx+8]
test r15, r15
jz short loc_66524
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_6651F
inc dword ptr [r15+8]
jmp short loc_66524
loc_6651F:
lock inc dword ptr [r15+8]
loc_66524:
mov ecx, [rax+30h]
cmp ecx, 4
jz short loc_665A2
cmp ecx, 3
jnz loc_66690
mov rsi, [rax+20h]
mov rdi, rbp
mov rdx, r14
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
cmp [rsp+108h+var_90], 0
jz loc_66896
mov [rsp+108h+var_F8], 0
mov rax, [rsp+108h+var_108]
mov [rsp+108h+var_100], rax
lea rax, _ZNSt17_Function_handlerIFvRN5minja5ValueEEZNKS0_19ArgumentsExpression8evaluateERKSt10shared_ptrINS0_7ContextEEEUlS2_E_E9_M_invokeERKSt9_Any_dataS2_; std::_Function_handler<void ()(minja::Value &),minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1}>::_M_invoke(std::_Any_data const&,minja::Value &)
mov [rsp+108h+var_E8], rax
lea rax, _ZNSt17_Function_handlerIFvRN5minja5ValueEEZNKS0_19ArgumentsExpression8evaluateERKSt10shared_ptrINS0_7ContextEEEUlS2_E_E10_M_managerERSt9_Any_dataRKSC_St18_Manager_operation; std::_Function_handler<void ()(minja::Value &),minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1}>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsp+108h+var_F0], rax
mov rdi, rbp
lea rsi, [rsp+108h+var_100]
call _ZNK5minja5Value8for_eachERKSt8functionIFvRS0_EE; minja::Value::for_each(std::function<void ()(minja::Value&)> const&)
mov rax, [rsp+108h+var_F0]
test rax, rax
jz short loc_6660C
lea rdi, [rsp+108h+var_100]
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_6660C
loc_665A2:
mov rsi, [rax+20h]
mov rdi, rbp
mov rdx, r14
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
cmp [rsp+108h+var_80], 0
jz loc_66862
mov rax, [rsp+108h+var_108]
mov [rsp+108h+var_100], rax
mov [rsp+108h+var_F8], rbp
lea rax, _ZNSt17_Function_handlerIFvRN5minja5ValueEEZNKS0_19ArgumentsExpression8evaluateERKSt10shared_ptrINS0_7ContextEEEUlRKS1_E_E9_M_invokeERKSt9_Any_dataS2_; std::_Function_handler<void ()(minja::Value &),minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value const&)#1}>::_M_invoke(std::_Any_data const&,minja::Value &)
mov [rsp+108h+var_E8], rax
lea rax, _ZNSt17_Function_handlerIFvRN5minja5ValueEEZNKS0_19ArgumentsExpression8evaluateERKSt10shared_ptrINS0_7ContextEEEUlRKS1_E_E10_M_managerERSt9_Any_dataRKSE_St18_Manager_operation; std::_Function_handler<void ()(minja::Value &),minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value const&)#1}>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsp+108h+var_F0], rax
mov rdi, rbp
lea rsi, [rsp+108h+var_100]
call _ZNK5minja5Value8for_eachERKSt8functionIFvRS0_EE; minja::Value::for_each(std::function<void ()(minja::Value&)> const&)
mov rax, [rsp+108h+var_F0]
test rax, rax
jz short loc_6660C
lea rdi, [rsp+108h+var_100]
mov rsi, rdi
mov edx, 3
call rax
loc_6660C:
lea r13, [rsp+108h+var_60]
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()
mov rdi, [rsp+108h+var_68]
test rdi, rdi
jz short loc_66638
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_66638:
mov rdi, [rsp+108h+var_78]
test rdi, rdi
lea r13, [rsp+108h+var_60]
jz short loc_66652
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_66652:
mov rdi, [rsp+108h+var_88]
test rdi, rdi
jz short loc_66664
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_66664:
mov rdi, [rsp+108h+var_98]
test rdi, rdi
jz loc_6674C
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz loc_66737
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp loc_66741
loc_66690:
test r15, r15
jz short loc_6669D
mov rdi, r15
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_6669D:
mov rsi, [rbx]
mov rdi, rbp
mov rdx, r14
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov rdi, [rsp+108h+var_108]
mov rsi, rbp
call _ZNSt6vectorIN5minja5ValueESaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<minja::Value>::emplace_back<minja::Value>(minja::Value &&)
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()
mov rdi, [rsp+108h+var_68]
test rdi, rdi
jz short loc_666DB
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_666DB:
mov rdi, [rsp+108h+var_78]
test rdi, rdi
jz short loc_666ED
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_666ED:
mov rdi, [rsp+108h+var_88]
test rdi, rdi
jz short loc_666FF
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_666FF:
mov rdi, [rsp+108h+var_98]
test rdi, rdi
jz short loc_66759
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_66720
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_6672A
loc_66720:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_6672A:
cmp eax, 1
jnz short loc_66759
mov rax, [rdi]
call qword ptr [rax+18h]
jmp short loc_66759
loc_66737:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_66741:
cmp eax, 1
jnz short loc_6674C
mov rax, [rdi]
call qword ptr [rax+18h]
loc_6674C:
test r15, r15
jz short loc_66759
mov rdi, r15
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_66759:
add rbx, 10h
cmp rbx, r12
jnz loc_664DA
loc_66766:
mov [rsp+108h+var_A8], r14
mov rax, [rsp+108h+var_B0]
mov r15, [rax+18h]
mov r14, [rax+20h]
cmp r15, r14
jz loc_6684C
mov rax, [rsp+108h+var_108]
lea r12, [rax+18h]
lea r13, [rsp+108h+var_C0]
lea rbp, [rsp+108h+var_100]
lea rbx, [rsp+108h+var_A0]
loc_66798:
mov rsi, [r15+20h]
mov rdi, rbp
mov rdx, [rsp+108h+var_A8]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov rdi, rbx
mov rsi, r15
mov rdx, rbp
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEEC2IS7_TnNSt9enable_ifIXclsr5_PCCPE13_CopyMovePairILb1ES5_T_EEEbE4typeELb1EEERKS5_OSB_
mov rdi, r12
mov rsi, rbx
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EE12emplace_backIJS9_EEERS9_DpOT_; std::vector<std::pair<std::string,minja::Value>>::emplace_back<std::pair<std::string,minja::Value>>(std::pair<std::string,minja::Value> &&)
mov rdi, rbx
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEED2Ev; std::pair<std::string,minja::Value>::~pair()
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()
mov rdi, [rsp+108h+var_C8]
test rdi, rdi
jz short loc_667EB
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_667EB:
mov rdi, [rsp+108h+var_D8]
test rdi, rdi
jz short loc_667FA
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_667FA:
mov rdi, [rsp+108h+var_E8]
test rdi, rdi
jz short loc_66809
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_66809:
mov rdi, [rsp+108h+var_F8]
test rdi, rdi
jz short loc_6683F
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_6682A
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_66834
loc_6682A:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_66834:
cmp eax, 1
jnz short loc_6683F
mov rax, [rdi]
call qword ptr [rax+18h]
loc_6683F:
add r15, 30h ; '0'
cmp r15, r14
jnz loc_66798
loc_6684C:
mov rax, [rsp+108h+var_108]
add rsp, 0D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_66862:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aExpansiondictO; "ExpansionDict operator only supported o"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
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_668C8
loc_66896:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aExpansionOpera_0; "Expansion operator only supported on ar"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
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_668C8:
jmp short loc_668CC
jmp short loc_668D1
loc_668CC:
mov r14, rax
jmp short loc_66920
loc_668D1:
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_66920
jmp short loc_6692C
jmp short loc_6692C
mov r14, rax
mov rax, [rsp+108h+var_F0]
test rax, rax
jz short loc_66920
lea rdi, [rsp+108h+var_100]
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_66920
jmp short loc_6692C
jmp short loc_66934
mov r14, rax
mov rax, [rsp+108h+var_F0]
test rax, rax
jz short loc_66920
lea rdi, [rsp+108h+var_100]
mov rsi, rdi
mov edx, 3
call rax
loc_66920:
lea rdi, [rsp+108h+var_A0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_66937
loc_6692C:
mov rdi, rax
call __clang_call_terminate
loc_66934:
mov r14, rax
loc_66937:
test r15, r15
jz short loc_66973
mov rdi, r15
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_66973
mov r14, rax
lea rdi, [rsp+108h+var_A0]
jmp short loc_6696E
jmp short $+2
loc_66952:
mov r14, rax
jmp short loc_66973
mov r14, rax
jmp short loc_66969
mov r14, rax
lea rdi, [rsp+108h+var_A0]
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEED2Ev; std::pair<std::string,minja::Value>::~pair()
loc_66969:
lea rdi, [rsp+108h+var_100]; this
loc_6696E:
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_66973:
mov rbx, [rsp+108h+var_108]
lea rdi, [rbx+18h]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
mov rdi, rbx
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
mov rdi, r14
call __Unwind_Resume
| _OWORD * minja::ArgumentsExpression::evaluate(_OWORD *a1, _QWORD *a2, long long a3)
{
long long v4; // rbx
long long v5; // r12
void *v6; // rax
volatile signed __int32 *v7; // r15
int v8; // ecx
long long v9; // rdi
signed __int32 v10; // eax
long long v11; // rdi
signed __int32 v12; // eax
long long v13; // r15
long long i; // r14
_BYTE *v15; // rdi
signed __int32 v16; // eax
std::runtime_error *v18; // rbx
std::runtime_error *exception; // rbx
_OWORD *v21; // [rsp+8h] [rbp-100h] BYREF
_BYTE *v22; // [rsp+10h] [rbp-F8h]
long long ( *v23)(); // [rsp+18h] [rbp-F0h]
volatile signed __int32 *v24; // [rsp+20h] [rbp-E8h]
volatile signed __int32 *v25; // [rsp+30h] [rbp-D8h]
volatile signed __int32 *v26; // [rsp+40h] [rbp-C8h]
void **v27[2]; // [rsp+48h] [rbp-C0h] BYREF
_QWORD *v28; // [rsp+58h] [rbp-B0h]
long long v29; // [rsp+60h] [rbp-A8h]
_BYTE v30[8]; // [rsp+68h] [rbp-A0h] BYREF
long long v31; // [rsp+70h] [rbp-98h]
long long v32; // [rsp+78h] [rbp-90h]
volatile signed __int32 *v33; // [rsp+80h] [rbp-88h]
long long v34; // [rsp+88h] [rbp-80h]
volatile signed __int32 *v35; // [rsp+90h] [rbp-78h]
volatile signed __int32 *v36; // [rsp+A0h] [rbp-68h]
void **v37[12]; // [rsp+A8h] [rbp-60h] BYREF
a1[2] = 0LL;
a1[1] = 0LL;
*a1 = 0LL;
v4 = *a2;
v28 = a2;
v5 = a2[1];
if ( v4 != v5 )
{
while ( 1 )
{
if ( !*(_QWORD *)v4 )
goto LABEL_27;
v6 = __dynamic_cast(
*(const void **)v4,
(const struct __class_type_info *)&`typeinfo for'minja::Expression,
(const struct __class_type_info *)&`typeinfo for'minja::UnaryOpExpr,
0LL);
if ( !v6 )
goto LABEL_27;
v7 = *(volatile signed __int32 **)(v4 + 8);
if ( v7 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v7 + 2);
else
_InterlockedIncrement(v7 + 2);
}
v8 = *((_DWORD *)v6 + 12);
if ( v8 == 4 )
break;
if ( v8 != 3 )
{
if ( v7 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v7);
LABEL_27:
minja::Expression::evaluate((long long)v30, *(void (****)(void))v4);
std::vector<minja::Value>::emplace_back<minja::Value>((long long)a1, (long long)v30);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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 *)v37);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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(v37);
if ( v36 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v36);
if ( v35 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v35);
if ( v33 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v33);
v11 = v31;
if ( v31 )
{
if ( _libc_single_threaded )
{
v12 = *(_DWORD *)(v31 + 12);
*(_DWORD *)(v31 + 12) = v12 - 1;
}
else
{
v12 = _InterlockedExchangeAdd((volatile signed __int32 *)(v31 + 12), 0xFFFFFFFF);
}
if ( v12 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v11 + 24LL))(v11, 0LL);
}
goto LABEL_44;
}
minja::Expression::evaluate((long long)v30, *((void (****)(void))v6 + 4));
if ( !v32 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expansion operator only supported on arrays");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v22 = 0LL;
v21 = a1;
v24 = (volatile signed __int32 *)std::_Function_handler<void ()(minja::Value &),minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1}>::_M_invoke;
v23 = std::_Function_handler<void ()(minja::Value &),minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1}>::_M_manager;
minja::Value::for_each(v30, &v21);
if ( v23 )
goto LABEL_15;
LABEL_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 *)v37);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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(v37);
if ( v36 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v36);
if ( v35 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v35);
if ( v33 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v33);
v9 = v31;
if ( v31 )
{
if ( _libc_single_threaded )
{
v10 = *(_DWORD *)(v31 + 12);
*(_DWORD *)(v31 + 12) = v10 - 1;
}
else
{
v10 = _InterlockedExchangeAdd((volatile signed __int32 *)(v31 + 12), 0xFFFFFFFF);
}
if ( v10 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v9 + 24LL))(v9, 0LL);
}
if ( v7 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v7);
LABEL_44:
v4 += 16LL;
if ( v4 == v5 )
goto LABEL_45;
}
minja::Expression::evaluate((long long)v30, *((void (****)(void))v6 + 4));
if ( !v34 )
{
v18 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v18, "ExpansionDict operator only supported on objects");
__cxa_throw(
v18,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v21 = a1;
v22 = v30;
v24 = (volatile signed __int32 *)std::_Function_handler<void ()(minja::Value &),minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value const&)#1}>::_M_invoke;
v23 = std::_Function_handler<void ()(minja::Value &),minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value const&)#1}>::_M_manager;
minja::Value::for_each(v30, &v21);
if ( !v23 )
goto LABEL_16;
LABEL_15:
((void ( *)(_OWORD **, _OWORD **, long long))v23)(&v21, &v21, 3LL);
goto LABEL_16;
}
LABEL_45:
v29 = a3;
v13 = v28[3];
for ( i = v28[4]; v13 != i; v13 += 48LL )
{
minja::Expression::evaluate((long long)&v21, *(void (****)(void))(v13 + 32));
ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEEC2IS7_TnNSt9enable_ifIXclsr5_PCCPE13_CopyMovePairILb1ES5_T_EEEbE4typeELb1EEERKS5_OSB_(
v30,
v13,
&v21);
std::vector<std::pair<std::string,minja::Value>>::emplace_back<std::pair<std::string,minja::Value>>(
(char *)a1 + 24,
v30);
std::pair<std::string,minja::Value>::~pair(v30);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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);
if ( v26 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v26);
if ( v25 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v25);
if ( v24 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v24);
v15 = v22;
if ( v22 )
{
if ( _libc_single_threaded )
{
v16 = *((_DWORD *)v22 + 3);
*((_DWORD *)v22 + 3) = v16 - 1;
}
else
{
v16 = _InterlockedExchangeAdd((volatile signed __int32 *)v22 + 3, 0xFFFFFFFF);
}
if ( v16 == 1 )
(*(void ( **)(_BYTE *, _QWORD))(*(_QWORD *)v15 + 24LL))(v15, 0LL);
}
}
return a1;
}
| evaluate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xd8
MOV R14,RDX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOV qword ptr [RSP],RDI
MOVUPS xmmword ptr [RDI],XMM0
MOV RBX,qword ptr [RSI]
MOV qword ptr [RSP + 0x58],RSI
MOV R12,qword ptr [RSI + 0x8]
CMP RBX,R12
JZ 0x00166766
LEA R13,[RSP + 0xa8]
LEA RBP,[RSP + 0x68]
LAB_001664da:
MOV RDI,qword ptr [RBX]
TEST RDI,RDI
JZ 0x0016669d
LEA RSI,[0x1ef260]
LEA RDX,[0x1ef270]
XOR ECX,ECX
CALL 0x001198c0
TEST RAX,RAX
JZ 0x0016669d
MOV R15,qword ptr [RBX + 0x8]
TEST R15,R15
JZ 0x00166524
MOV RCX,qword ptr [0x001f0f98]
CMP byte ptr [RCX],0x0
JZ 0x0016651f
INC dword ptr [R15 + 0x8]
JMP 0x00166524
LAB_0016651f:
INC.LOCK dword ptr [R15 + 0x8]
LAB_00166524:
MOV ECX,dword ptr [RAX + 0x30]
CMP ECX,0x4
JZ 0x001665a2
CMP ECX,0x3
JNZ 0x00166690
MOV RSI,qword ptr [RAX + 0x20]
LAB_00166539:
MOV RDI,RBP
MOV RDX,R14
CALL 0x0015061c
CMP qword ptr [RSP + 0x78],0x0
JZ 0x00166896
MOV qword ptr [RSP + 0x10],0x0
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RAX
LEA RAX,[0x167e64]
MOV qword ptr [RSP + 0x20],RAX
LEA RAX,[0x167e6c]
MOV qword ptr [RSP + 0x18],RAX
LAB_0016657a:
MOV RDI,RBP
LEA RSI,[RSP + 0x8]
CALL 0x00167912
MOV RAX,qword ptr [RSP + 0x18]
TEST RAX,RAX
JZ 0x0016660c
LAB_00166591:
LEA RDI,[RSP + 0x8]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
JMP 0x0016660c
LAB_001665a2:
MOV RSI,qword ptr [RAX + 0x20]
LAB_001665a6:
MOV RDI,RBP
MOV RDX,R14
CALL 0x0015061c
CMP qword ptr [RSP + 0x88],0x0
JZ 0x00166862
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RBP
LEA RAX,[0x167e92]
MOV qword ptr [RSP + 0x20],RAX
LEA RAX,[0x167e98]
MOV qword ptr [RSP + 0x18],RAX
LAB_001665e6:
MOV RDI,RBP
LEA RSI,[RSP + 0x8]
CALL 0x00167912
MOV RAX,qword ptr [RSP + 0x18]
TEST RAX,RAX
JZ 0x0016660c
LAB_001665fd:
LEA RDI,[RSP + 0x8]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0016660c:
LEA R13,[RSP + 0xa8]
MOV RDI,R13
XOR ESI,ESI
CALL 0x0015099a
MOV RDI,R13
CALL 0x0015d0d4
MOV RDI,qword ptr [RSP + 0xa0]
TEST RDI,RDI
JZ 0x00166638
CALL 0x00131b9a
LAB_00166638:
MOV RDI,qword ptr [RSP + 0x90]
TEST RDI,RDI
LEA R13,[RSP + 0xa8]
JZ 0x00166652
CALL 0x00131b9a
LAB_00166652:
MOV RDI,qword ptr [RSP + 0x80]
TEST RDI,RDI
JZ 0x00166664
CALL 0x00131b9a
LAB_00166664:
MOV RDI,qword ptr [RSP + 0x70]
TEST RDI,RDI
JZ 0x0016674c
MOV RAX,qword ptr [0x001f0f98]
CMP byte ptr [RAX],0x0
JZ 0x00166737
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00166741
LAB_00166690:
TEST R15,R15
JZ 0x0016669d
MOV RDI,R15
CALL 0x00131b9a
LAB_0016669d:
MOV RSI,qword ptr [RBX]
LAB_001666a0:
MOV RDI,RBP
MOV RDX,R14
CALL 0x0015061c
LAB_001666ab:
MOV RDI,qword ptr [RSP]
MOV RSI,RBP
CALL 0x00161abc
LAB_001666b7:
MOV RDI,R13
XOR ESI,ESI
CALL 0x0015099a
MOV RDI,R13
CALL 0x0015d0d4
MOV RDI,qword ptr [RSP + 0xa0]
TEST RDI,RDI
JZ 0x001666db
CALL 0x00131b9a
LAB_001666db:
MOV RDI,qword ptr [RSP + 0x90]
TEST RDI,RDI
JZ 0x001666ed
CALL 0x00131b9a
LAB_001666ed:
MOV RDI,qword ptr [RSP + 0x80]
TEST RDI,RDI
JZ 0x001666ff
CALL 0x00131b9a
LAB_001666ff:
MOV RDI,qword ptr [RSP + 0x70]
TEST RDI,RDI
JZ 0x00166759
MOV RAX,qword ptr [0x001f0f98]
CMP byte ptr [RAX],0x0
JZ 0x00166720
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0016672a
LAB_00166720:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0016672a:
CMP EAX,0x1
JNZ 0x00166759
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
JMP 0x00166759
LAB_00166737:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00166741:
CMP EAX,0x1
JNZ 0x0016674c
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0016674c:
TEST R15,R15
JZ 0x00166759
MOV RDI,R15
CALL 0x00131b9a
LAB_00166759:
ADD RBX,0x10
CMP RBX,R12
JNZ 0x001664da
LAB_00166766:
MOV qword ptr [RSP + 0x60],R14
MOV RAX,qword ptr [RSP + 0x58]
MOV R15,qword ptr [RAX + 0x18]
MOV R14,qword ptr [RAX + 0x20]
CMP R15,R14
JZ 0x0016684c
MOV RAX,qword ptr [RSP]
LEA R12,[RAX + 0x18]
LEA R13,[RSP + 0x48]
LEA RBP,[RSP + 0x8]
LEA RBX,[RSP + 0x68]
LAB_00166798:
MOV RSI,qword ptr [R15 + 0x20]
LAB_0016679c:
MOV RDI,RBP
MOV RDX,qword ptr [RSP + 0x60]
CALL 0x0015061c
LAB_001667a9:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,RBP
CALL 0x00167d22
LAB_001667b7:
MOV RDI,R12
MOV RSI,RBX
CALL 0x00167fe8
LAB_001667c2:
MOV RDI,RBX
CALL 0x00167dc2
MOV RDI,R13
XOR ESI,ESI
CALL 0x0015099a
MOV RDI,R13
CALL 0x0015d0d4
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x001667eb
CALL 0x00131b9a
LAB_001667eb:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x001667fa
CALL 0x00131b9a
LAB_001667fa:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x00166809
CALL 0x00131b9a
LAB_00166809:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0016683f
MOV RAX,qword ptr [0x001f0f98]
CMP byte ptr [RAX],0x0
JZ 0x0016682a
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00166834
LAB_0016682a:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00166834:
CMP EAX,0x1
JNZ 0x0016683f
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0016683f:
ADD R15,0x30
CMP R15,R14
JNZ 0x00166798
LAB_0016684c:
MOV RAX,qword ptr [RSP]
ADD RSP,0xd8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00166862:
MOV EDI,0x10
CALL 0x001193b0
MOV RBX,RAX
LAB_0016686f:
LEA RSI,[0x1bc9e1]
MOV RDI,RAX
CALL 0x001192a0
LAB_0016687e:
MOV RSI,qword ptr [0x001f0ff0]
MOV RDX,qword ptr [0x001f0f70]
MOV RDI,RBX
CALL 0x00119d60
LAB_00166896:
MOV EDI,0x10
CALL 0x001193b0
MOV RBX,RAX
LAB_001668a3:
LEA RSI,[0x1bc9b5]
MOV RDI,RAX
CALL 0x001192a0
LAB_001668b2:
MOV RSI,qword ptr [0x001f0ff0]
MOV RDX,qword ptr [0x001f0f70]
MOV RDI,RBX
CALL 0x00119d60
|
/* minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&) const */
shared_ptr * minja::ArgumentsExpression::evaluate(shared_ptr *param_1)
{
int *piVar1;
Expression *pEVar2;
long *plVar3;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *this;
long lVar4;
int iVar5;
long lVar6;
runtime_error *prVar7;
long *plVar8;
long *in_RSI;
shared_ptr *local_100;
Expression *local_f8;
code *local_f0;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_e8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_d8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_c8;
data local_c0 [16];
long *local_b0;
Expression local_a0 [8];
long *local_98;
long local_90;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_88;
long local_80;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
data local_60 [48];
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
plVar8 = (long *)*in_RSI;
plVar3 = (long *)in_RSI[1];
local_b0 = in_RSI;
if (plVar8 != plVar3) {
do {
if (*plVar8 == 0) {
LAB_0016669d:
/* try { // try from 001666a0 to 001666aa has its CatchHandler @ 00166950 */
Expression::evaluate(local_a0,(shared_ptr *)*plVar8);
/* try { // try from 001666ab to 001666b6 has its CatchHandler @ 00166946 */
std::vector<minja::Value,std::allocator<minja::Value>>::emplace_back<minja::Value>
((vector<minja::Value,std::allocator<minja::Value>> *)param_1,(Value *)local_a0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_60,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_60);
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_78);
}
if (local_88 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_88);
}
if (local_98 != (long *)0x0) {
if (*PTR___libc_single_threaded_001f0f98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_98 + 0xc);
iVar5 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar5 = *(int *)((long)local_98 + 0xc);
*(int *)((long)local_98 + 0xc) = iVar5 + -1;
}
if (iVar5 == 1) {
(**(code **)(*local_98 + 0x18))();
}
}
}
else {
lVar6 = __dynamic_cast(*plVar8,&Expression::typeinfo,&UnaryOpExpr::typeinfo,0);
if (lVar6 == 0) goto LAB_0016669d;
this = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)plVar8[1];
if (this != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_001f0f98 == '\0') {
LOCK();
*(int *)(this + 8) = *(int *)(this + 8) + 1;
UNLOCK();
}
else {
*(int *)(this + 8) = *(int *)(this + 8) + 1;
}
}
if (*(int *)(lVar6 + 0x30) == 4) {
/* try { // try from 001665a6 to 001665b0 has its CatchHandler @ 00166934 */
Expression::evaluate(local_a0,*(shared_ptr **)(lVar6 + 0x20));
if (local_80 == 0) {
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016686f to 0016687d has its CatchHandler @ 001668d1 */
std::runtime_error::runtime_error
(prVar7,"ExpansionDict operator only supported on objects");
/* try { // try from 0016687e to 00166893 has its CatchHandler @ 001668cc */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar7,PTR_typeinfo_001f0ff0,PTR__runtime_error_001f0f70);
}
local_e8 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)
std::
_Function_handler<void(minja::Value&),minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context>const&)const::{lambda(minja::Value_const&)#1}>
::_M_invoke;
local_f0 = std::
_Function_handler<void(minja::Value&),minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context>const&)const::{lambda(minja::Value_const&)#1}>
::_M_manager;
/* try { // try from 001665e6 to 001665f2 has its CatchHandler @ 00166904 */
local_100 = param_1;
local_f8 = local_a0;
Value::for_each((Value *)local_a0,(function *)&local_100);
if (local_f0 != (code *)0x0) {
/* try { // try from 001665fd to 0016660b has its CatchHandler @ 001668de */
(*local_f0)(&local_100,&local_100,3);
}
}
else {
if (*(int *)(lVar6 + 0x30) != 3) {
if (this != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(this);
}
goto LAB_0016669d;
}
/* try { // try from 00166539 to 00166543 has its CatchHandler @ 00166902 */
Expression::evaluate(local_a0,*(shared_ptr **)(lVar6 + 0x20));
if (local_90 == 0) {
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001668a3 to 001668b1 has its CatchHandler @ 001668ca */
std::runtime_error::runtime_error(prVar7,"Expansion operator only supported on arrays");
/* try { // try from 001668b2 to 001668c7 has its CatchHandler @ 001668c8 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar7,PTR_typeinfo_001f0ff0,PTR__runtime_error_001f0f70);
}
local_f8 = (Expression *)0x0;
local_e8 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)
std::
_Function_handler<void(minja::Value&),minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context>const&)const::{lambda(minja::Value&)#1}>
::_M_invoke;
local_f0 = std::
_Function_handler<void(minja::Value&),minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context>const&)const::{lambda(minja::Value&)#1}>
::_M_manager;
/* try { // try from 0016657a to 00166586 has its CatchHandler @ 001668e2 */
local_100 = param_1;
Value::for_each((Value *)local_a0,(function *)&local_100);
if (local_f0 != (code *)0x0) {
/* try { // try from 00166591 to 0016659f has its CatchHandler @ 001668e0 */
(*local_f0)(&local_100,&local_100,3);
}
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_60,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_60);
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_78);
}
if (local_88 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_88);
}
if (local_98 != (long *)0x0) {
if (*PTR___libc_single_threaded_001f0f98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_98 + 0xc);
iVar5 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar5 = *(int *)((long)local_98 + 0xc);
*(int *)((long)local_98 + 0xc) = iVar5 + -1;
}
if (iVar5 == 1) {
(**(code **)(*local_98 + 0x18))();
}
}
if (this != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(this);
}
}
plVar8 = plVar8 + 2;
} while (plVar8 != plVar3);
}
lVar6 = local_b0[3];
lVar4 = local_b0[4];
if (lVar6 != lVar4) {
do {
/* try { // try from 0016679c to 001667a8 has its CatchHandler @ 00166952 */
Expression::evaluate((Expression *)&local_100,*(shared_ptr **)(lVar6 + 0x20));
/* try { // try from 001667a9 to 001667b6 has its CatchHandler @ 00166957 */
_ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEEC2IS7_TnNSt9enable_ifIXclsr5_PCCPE13_CopyMovePairILb1ES5_T_EEEbE4typeELb1EEERKS5_OSB_
((pair<std::__cxx11::string,minja::Value> *)local_a0,lVar6,(Expression *)&local_100)
;
/* try { // try from 001667b7 to 001667c1 has its CatchHandler @ 0016695c */
std::
vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
::emplace_back<std::pair<std::__cxx11::string,minja::Value>>
((vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
*)(param_1 + 0x18),(pair *)local_a0);
std::pair<std::__cxx11::string,minja::Value>::~pair
((pair<std::__cxx11::string,minja::Value> *)local_a0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_c0,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_c0);
if (local_c8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_c8);
}
if (local_d8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_d8);
}
if (local_e8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_e8);
}
if (local_f8 != (Expression *)0x0) {
if (*PTR___libc_single_threaded_001f0f98 == '\0') {
LOCK();
pEVar2 = local_f8 + 0xc;
iVar5 = *(int *)pEVar2;
*(int *)pEVar2 = *(int *)pEVar2 + -1;
UNLOCK();
}
else {
iVar5 = *(int *)(local_f8 + 0xc);
*(int *)(local_f8 + 0xc) = iVar5 + -1;
}
if (iVar5 == 1) {
(**(code **)(*(long *)local_f8 + 0x18))();
}
}
lVar6 = lVar6 + 0x30;
} while (lVar6 != lVar4);
}
return param_1;
}
| |
26,089 | maria_rtree_add_key | eloqsql/storage/maria/ma_rt_key.c | int maria_rtree_add_key(const MARIA_KEY *key, MARIA_PAGE *page,
my_off_t *new_page)
{
MARIA_HA *info= page->info;
MARIA_SHARE *share= info->s;
uint page_size= page->size;
uint nod_flag= page->node;
uchar *key_pos= rt_PAGE_END(page);
uint tot_key_length= key->data_length + key->ref_length + nod_flag;
DBUG_ENTER("maria_rtree_add_key");
if (page_size + tot_key_length <=
(uint)(key->keyinfo->block_length - KEYPAGE_CHECKSUM_SIZE))
{
/* split won't be necessary */
if (nod_flag)
{
DBUG_ASSERT(_ma_kpos(nod_flag, key->data) <
info->state->key_file_length);
/* We don't store reference to row on nod pages for rtree index */
tot_key_length-= key->ref_length;
}
/* save key */
memcpy(key_pos, key->data - nod_flag, tot_key_length);
page->size+= tot_key_length;
page_store_size(share, page);
if (share->now_transactional &&
_ma_log_add(page, (uint)(key_pos - page->buff),
key_pos, tot_key_length, tot_key_length, 0,
KEY_OP_DEBUG_LOG_ADD_1))
DBUG_RETURN(-1);
DBUG_RETURN(0);
}
DBUG_RETURN(maria_rtree_split_page(key, page, new_page) ? -1 : 1);
} | O0 | c | maria_rtree_add_key:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x20(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x14(%rcx), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x34(%rbp), %eax
addl -0x44(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movzwl 0xa6(%rcx), %ecx
subl $0x4, %ecx
cmpl %ecx, %eax
ja 0x919a0
cmpl $0x0, -0x38(%rbp)
je 0x918d1
jmp 0x918c0
jmp 0x918c2
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movl -0x44(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x38(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movl -0x44(%rbp), %eax
movl %eax, %edx
callq 0x2a0b0
movl -0x44(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, -0x1(%rax,%rcx)
movl -0x48(%rbp), %eax
shrl $0x8, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, -0x2(%rax,%rcx)
movq -0x30(%rbp), %rax
movsbl 0x7e7(%rax), %eax
cmpl $0x0, %eax
je 0x91995
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, %esi
movq -0x40(%rbp), %rdx
movl -0x44(%rbp), %ecx
movl -0x44(%rbp), %r8d
xorl %r9d, %r9d
movl $0x6, (%rsp)
callq 0x71f80
movsbl %al, %eax
cmpl $0x0, %eax
je 0x91995
jmp 0x9198c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x919c8
jmp 0x91997
movl $0x0, -0x4(%rbp)
jmp 0x919c8
jmp 0x919a2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9bc60
movl %eax, %edx
movl $0x1, %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| maria_rtree_add_key:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
mov eax, [rax+20h]
mov [rbp+var_34], eax
mov rax, [rbp+var_18]
mov eax, [rax+28h]
mov [rbp+var_38], eax
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov rcx, [rbp+var_18]
mov ecx, [rcx+20h]
add rax, rcx
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
mov eax, [rax+10h]
mov rcx, [rbp+var_10]
add eax, [rcx+14h]
add eax, [rbp+var_38]
mov [rbp+var_44], eax
mov eax, [rbp+var_34]
add eax, [rbp+var_44]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
movzx ecx, word ptr [rcx+0A6h]
sub ecx, 4
cmp eax, ecx
ja loc_919A0
cmp [rbp+var_38], 0
jz short loc_918D1
jmp short $+2
loc_918C0:
jmp short $+2
loc_918C2:
mov rax, [rbp+var_10]
mov ecx, [rax+14h]
mov eax, [rbp+var_44]
sub eax, ecx
mov [rbp+var_44], eax
loc_918D1:
mov rdi, [rbp+var_40]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov eax, [rbp+var_38]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rsi, rax
mov eax, [rbp+var_44]
mov edx, eax
call _memcpy
mov ecx, [rbp+var_44]
mov rax, [rbp+var_18]
add ecx, [rax+20h]
mov [rax+20h], ecx
mov rax, [rbp+var_18]
mov eax, [rax+20h]
mov [rbp+var_48], eax
mov eax, [rbp+var_48]
mov dl, al
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov rcx, [rbp+var_30]
mov ecx, [rcx+744h]
mov [rax+rcx-1], dl
mov eax, [rbp+var_48]
shr eax, 8
mov dl, al
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov rcx, [rbp+var_30]
mov ecx, [rcx+744h]
mov [rax+rcx-2], dl
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+7E7h]
cmp eax, 0
jz short loc_91995
mov rdi, [rbp+var_18]
mov rax, [rbp+var_40]
mov rcx, [rbp+var_18]
mov rcx, [rcx+10h]
sub rax, rcx
mov esi, eax
mov rdx, [rbp+var_40]
mov ecx, [rbp+var_44]
mov r8d, [rbp+var_44]
xor r9d, r9d
mov [rsp+50h+var_50], 6
call _ma_log_add
movsx eax, al
cmp eax, 0
jz short loc_91995
jmp short $+2
loc_9198C:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_919C8
loc_91995:
jmp short $+2
loc_91997:
mov [rbp+var_4], 0
jmp short loc_919C8
loc_919A0:
jmp short $+2
loc_919A2:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call maria_rtree_split_page
mov edx, eax
mov eax, 1
mov ecx, 0FFFFFFFFh
cmp edx, 0
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_919C8:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long maria_rtree_add_key(long long a1, long long **a2, long long a3)
{
int v3; // edx
unsigned int v4; // eax
int v6; // [rsp+8h] [rbp-48h]
unsigned int v7; // [rsp+Ch] [rbp-44h]
long long v8; // [rsp+10h] [rbp-40h]
unsigned int v9; // [rsp+18h] [rbp-38h]
long long v10; // [rsp+20h] [rbp-30h]
v10 = **a2;
v9 = *((_DWORD *)a2 + 10);
v8 = (long long)a2[2] + *((unsigned int *)a2 + 8);
v7 = v9 + *(_DWORD *)(a1 + 20) + *(_DWORD *)(a1 + 16);
if ( v7 + *((_DWORD *)a2 + 8) > (unsigned int)*(unsigned __int16 *)(*(_QWORD *)(a1 + 8) + 166LL) - 4 )
{
v3 = maria_rtree_split_page(a1, a2, a3);
v4 = 1;
if ( v3 )
return (unsigned int)-1;
return v4;
}
else
{
if ( v9 )
v7 -= *(_DWORD *)(a1 + 20);
memcpy(v8, *(_QWORD *)a1 - v9, v7);
*((_DWORD *)a2 + 8) += v7;
v6 = *((_DWORD *)a2 + 8);
*((_BYTE *)a2[2] + *(unsigned int *)(v10 + 1860) - 1) = v6;
*((_BYTE *)a2[2] + *(unsigned int *)(v10 + 1860) - 2) = BYTE1(v6);
if ( *(_BYTE *)(v10 + 2023) && ma_log_add(a2, v8 - *((_DWORD *)a2 + 4), v8, v7, v7, 0) )
return (unsigned int)-1;
else
return 0;
}
}
| maria_rtree_add_key:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x20]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x28]
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x20]
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x14]
ADD EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,dword ptr [RBP + -0x44]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
MOVZX ECX,word ptr [RCX + 0xa6]
SUB ECX,0x4
CMP EAX,ECX
JA 0x001919a0
CMP dword ptr [RBP + -0x38],0x0
JZ 0x001918d1
JMP 0x001918c0
LAB_001918c0:
JMP 0x001918c2
LAB_001918c2:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x14]
MOV EAX,dword ptr [RBP + -0x44]
SUB EAX,ECX
MOV dword ptr [RBP + -0x44],EAX
LAB_001918d1:
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x38]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RSI,RAX
MOV EAX,dword ptr [RBP + -0x44]
MOV EDX,EAX
CALL 0x0012a0b0
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x18]
ADD ECX,dword ptr [RAX + 0x20]
MOV dword ptr [RAX + 0x20],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x20]
MOV dword ptr [RBP + -0x48],EAX
MOV EAX,dword ptr [RBP + -0x48]
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + -0x1],DL
MOV EAX,dword ptr [RBP + -0x48]
SHR EAX,0x8
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + -0x2],DL
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0x7e7]
CMP EAX,0x0
JZ 0x00191995
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x10]
SUB RAX,RCX
MOV ESI,EAX
MOV RDX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x44]
MOV R8D,dword ptr [RBP + -0x44]
XOR R9D,R9D
MOV dword ptr [RSP],0x6
CALL 0x00171f80
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00191995
JMP 0x0019198c
LAB_0019198c:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001919c8
LAB_00191995:
JMP 0x00191997
LAB_00191997:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001919c8
LAB_001919a0:
JMP 0x001919a2
LAB_001919a2:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0019bc60
MOV EDX,EAX
MOV EAX,0x1
MOV ECX,0xffffffff
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_001919c8:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4 maria_rtree_add_key(long *param_1,int8 *param_2,int8 param_3)
{
uint uVar1;
int4 uVar2;
long lVar3;
char cVar4;
int iVar5;
void *__dest;
uint local_4c;
int4 local_c;
lVar3 = *(long *)*param_2;
uVar1 = *(uint *)(param_2 + 5);
__dest = (void *)(param_2[2] + (ulong)*(uint *)(param_2 + 4));
local_4c = (int)param_1[2] + *(int *)((long)param_1 + 0x14) + uVar1;
if (*(ushort *)(param_1[1] + 0xa6) - 4 < *(int *)(param_2 + 4) + local_4c) {
iVar5 = maria_rtree_split_page(param_1,param_2,param_3);
local_c = 1;
if (iVar5 != 0) {
local_c = 0xffffffff;
}
}
else {
if (uVar1 != 0) {
local_4c = local_4c - *(int *)((long)param_1 + 0x14);
}
memcpy(__dest,(void *)(*param_1 - (ulong)uVar1),(ulong)local_4c);
*(uint *)(param_2 + 4) = local_4c + *(int *)(param_2 + 4);
uVar2 = *(int4 *)(param_2 + 4);
*(char *)(param_2[2] + -1 + (ulong)*(uint *)(lVar3 + 0x744)) = (char)uVar2;
*(char *)(param_2[2] + -2 + (ulong)*(uint *)(lVar3 + 0x744)) = (char)((uint)uVar2 >> 8);
if ((*(char *)(lVar3 + 0x7e7) == '\0') ||
(cVar4 = _ma_log_add(param_2,(int)__dest - (int)param_2[2],__dest,local_4c,local_4c,0,6),
cVar4 == '\0')) {
local_c = 0;
}
else {
local_c = 0xffffffff;
}
}
return local_c;
}
| |
26,090 | ma_read_rnd_pack_record | eloqsql/storage/maria/ma_packrec.c | int _ma_read_rnd_pack_record(MARIA_HA *info,
uchar *buf,
register MARIA_RECORD_POS filepos,
my_bool skip_deleted_blocks)
{
File file;
MARIA_BLOCK_INFO block_info;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_read_rnd_pack_record");
if (filepos >= info->state->data_file_length)
{
my_errno= HA_ERR_END_OF_FILE;
goto err;
}
file= info->dfile.file;
if (info->opt_flag & READ_CACHE_USED)
{
if (_ma_read_cache(info, &info->rec_cache, block_info.header,
filepos, share->pack.ref_length,
skip_deleted_blocks ? READING_NEXT : 0))
goto err;
file= -1;
}
if (_ma_pack_get_block_info(info, &info->bit_buff, &block_info,
&info->rec_buff, &info->rec_buff_size,
file, filepos))
goto err; /* Error code is already set */
#ifndef DBUG_OFF
if (block_info.rec_len > share->max_pack_length)
{
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
goto err;
}
#endif
if (info->opt_flag & READ_CACHE_USED)
{
if (_ma_read_cache(info, &info->rec_cache, info->rec_buff,
block_info.filepos, block_info.rec_len,
skip_deleted_blocks ? READING_NEXT : 0))
goto err;
}
else
{
if (mysql_file_read(info->dfile.file, info->rec_buff + block_info.offset,
block_info.rec_len-block_info.offset,
MYF(MY_NABP)))
goto err;
}
info->packed_length= block_info.rec_len;
info->cur_row.lastpos= filepos;
info->cur_row.nextpos= block_info.filepos+block_info.rec_len;
info->update|= HA_STATE_AKTIV | HA_STATE_KEY_CHANGED;
info->rec_buff[block_info.rec_len]= 0; /* Keep valgrind happy */
DBUG_RETURN(_ma_pack_rec_unpack(info, &info->bit_buff, buf,
info->rec_buff, block_info.rec_len));
err:
DBUG_RETURN(my_errno);
} | O0 | c | ma_read_rnd_pack_record:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %cl, %al
movq %fs:0x28, %rcx
movq %rcx, -0x8(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq %rdx, -0x80(%rbp)
movb %al, -0x81(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x80(%rbp), %rax
movq -0x70(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x28(%rcx), %rax
jb 0x4a21c
callq 0xfdd30
movl $0x89, (%rax)
jmp 0x4a407
movq -0x70(%rbp), %rax
movl 0x480(%rax), %eax
movl %eax, -0x88(%rbp)
movq -0x70(%rbp), %rax
movl 0x61c(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4a295
movq -0x70(%rbp), %rdi
movq -0x70(%rbp), %rsi
addq $0x4b8, %rsi # imm = 0x4B8
leaq -0x60(%rbp), %rdx
movq -0x80(%rbp), %rcx
movq -0x90(%rbp), %rax
movl 0x598(%rax), %eax
movl %eax, %r8d
movsbl -0x81(%rbp), %r10d
xorl %r9d, %r9d
movl $0x1, %eax
cmpl $0x0, %r10d
cmovnel %eax, %r9d
callq 0xa5010
cmpb $0x0, %al
je 0x4a28b
jmp 0x4a407
movl $0xffffffff, -0x88(%rbp) # imm = 0xFFFFFFFF
movq -0x70(%rbp), %rdi
movq -0x70(%rbp), %rsi
addq $0x290, %rsi # imm = 0x290
movq -0x70(%rbp), %rcx
addq $0x3a0, %rcx # imm = 0x3A0
movq -0x70(%rbp), %r8
addq $0x460, %r8 # imm = 0x460
movl -0x88(%rbp), %r9d
movq -0x80(%rbp), %rax
leaq -0x60(%rbp), %rdx
movq %rax, (%rsp)
callq 0x49c30
cmpl $0x0, %eax
je 0x4a2dc
jmp 0x4a407
movq -0x70(%rbp), %rax
movl 0x61c(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4a338
movq -0x70(%rbp), %rdi
movq -0x70(%rbp), %rsi
addq $0x4b8, %rsi # imm = 0x4B8
movq -0x70(%rbp), %rax
movq 0x3a0(%rax), %rdx
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %r8
movsbl -0x81(%rbp), %r10d
xorl %r9d, %r9d
movl $0x1, %eax
cmpl $0x0, %r10d
cmovnel %eax, %r9d
callq 0xa5010
cmpb $0x0, %al
je 0x4a336
jmp 0x4a407
jmp 0x4a381
movq -0x70(%rbp), %rax
movl 0x480(%rax), %edx
movq -0x70(%rbp), %rax
movq 0x3a0(%rax), %rcx
movl -0xc(%rbp), %eax
addq %rax, %rcx
movq -0x48(%rbp), %r8
movl -0xc(%rbp), %eax
subq %rax, %r8
leaq 0x10efd9(%rip), %rdi # 0x15933d
movl $0x572, %esi # imm = 0x572
movl $0x4, %r9d
callq 0x49e60
cmpq $0x0, %rax
je 0x4a37f
jmp 0x4a407
jmp 0x4a381
movq -0x48(%rbp), %rcx
movq -0x70(%rbp), %rax
movq %rcx, 0x450(%rax)
movq -0x80(%rbp), %rcx
movq -0x70(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x28(%rbp), %rcx
addq -0x48(%rbp), %rcx
movq -0x70(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x70(%rbp), %rax
movl 0x624(%rax), %ecx
orl $0x82, %ecx
movl %ecx, 0x624(%rax)
movq -0x70(%rbp), %rax
movq 0x3a0(%rax), %rax
movq -0x48(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x70(%rbp), %rdi
movq -0x70(%rbp), %rsi
addq $0x290, %rsi # imm = 0x290
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rax
movq 0x3a0(%rax), %rcx
movq -0x48(%rbp), %r8
callq 0x49fd0
movl %eax, -0x64(%rbp)
jmp 0x4a413
jmp 0x4a409
callq 0xfdd30
movl (%rax), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x94(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x4a43d
movl -0x94(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
callq 0x29230
nopw %cs:(%rax,%rax)
| _ma_read_rnd_pack_record:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov al, cl
mov rcx, fs:28h
mov [rbp+var_8], rcx
mov [rbp+var_70], rdi
mov [rbp+var_78], rsi
mov [rbp+var_80], rdx
mov [rbp+var_81], al
mov rax, [rbp+var_70]
mov rax, [rax]
mov [rbp+var_90], rax
mov rax, [rbp+var_80]
mov rcx, [rbp+var_70]
mov rcx, [rcx+20h]
cmp rax, [rcx+28h]
jb short loc_4A21C
call _my_thread_var
mov dword ptr [rax], 89h
jmp loc_4A407
loc_4A21C:
mov rax, [rbp+var_70]
mov eax, [rax+480h]
mov [rbp+var_88], eax
mov rax, [rbp+var_70]
mov eax, [rax+61Ch]
and eax, 2
cmp eax, 0
jz short loc_4A295
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_70]
add rsi, 4B8h
lea rdx, [rbp+var_60]
mov rcx, [rbp+var_80]
mov rax, [rbp+var_90]
mov eax, [rax+598h]
mov r8d, eax
movsx r10d, [rbp+var_81]
xor r9d, r9d
mov eax, 1
cmp r10d, 0
cmovnz r9d, eax
call _ma_read_cache
cmp al, 0
jz short loc_4A28B
jmp loc_4A407
loc_4A28B:
mov [rbp+var_88], 0FFFFFFFFh
loc_4A295:
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_70]
add rsi, 290h
mov rcx, [rbp+var_70]
add rcx, 3A0h
mov r8, [rbp+var_70]
add r8, 460h
mov r9d, [rbp+var_88]
mov rax, [rbp+var_80]
lea rdx, [rbp+var_60]
mov [rsp+0A0h+var_A0], rax
call _ma_pack_get_block_info
cmp eax, 0
jz short loc_4A2DC
jmp loc_4A407
loc_4A2DC:
mov rax, [rbp+var_70]
mov eax, [rax+61Ch]
and eax, 2
cmp eax, 0
jz short loc_4A338
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_70]
add rsi, 4B8h
mov rax, [rbp+var_70]
mov rdx, [rax+3A0h]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_48]
movsx r10d, [rbp+var_81]
xor r9d, r9d
mov eax, 1
cmp r10d, 0
cmovnz r9d, eax
call _ma_read_cache
cmp al, 0
jz short loc_4A336
jmp loc_4A407
loc_4A336:
jmp short loc_4A381
loc_4A338:
mov rax, [rbp+var_70]
mov edx, [rax+480h]
mov rax, [rbp+var_70]
mov rcx, [rax+3A0h]
mov eax, [rbp+var_C]
add rcx, rax
mov r8, [rbp+var_48]
mov eax, [rbp+var_C]
sub r8, rax
lea rdi, aWorkspaceLlm4b_10; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 572h
mov r9d, 4
call inline_mysql_file_read
cmp rax, 0
jz short loc_4A37F
jmp loc_4A407
loc_4A37F:
jmp short $+2
loc_4A381:
mov rcx, [rbp+var_48]
mov rax, [rbp+var_70]
mov [rax+450h], rcx
mov rcx, [rbp+var_80]
mov rax, [rbp+var_70]
mov [rax+98h], rcx
mov rcx, [rbp+var_28]
add rcx, [rbp+var_48]
mov rax, [rbp+var_70]
mov [rax+0A0h], rcx
mov rax, [rbp+var_70]
mov ecx, [rax+624h]
or ecx, 82h
mov [rax+624h], ecx
mov rax, [rbp+var_70]
mov rax, [rax+3A0h]
mov rcx, [rbp+var_48]
mov byte ptr [rax+rcx], 0
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_70]
add rsi, 290h
mov rdx, [rbp+var_78]
mov rax, [rbp+var_70]
mov rcx, [rax+3A0h]
mov r8, [rbp+var_48]
call _ma_pack_rec_unpack
mov [rbp+var_64], eax
jmp short loc_4A413
loc_4A407:
jmp short $+2
loc_4A409:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_64], eax
loc_4A413:
mov eax, [rbp+var_64]
mov [rbp+var_94], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_4A43D
mov eax, [rbp+var_94]
add rsp, 0A0h
pop rbp
retn
loc_4A43D:
call ___stack_chk_fail
| long long ma_read_rnd_pack_record(char *a1, const char *a2, unsigned long long a3, char a4)
{
int v5; // [rsp+18h] [rbp-88h]
long long v8; // [rsp+28h] [rbp-78h]
char *v9; // [rsp+30h] [rbp-70h]
_BYTE v11[24]; // [rsp+40h] [rbp-60h] BYREF
long long v12; // [rsp+58h] [rbp-48h]
long long v13; // [rsp+78h] [rbp-28h]
unsigned int v14; // [rsp+94h] [rbp-Ch]
unsigned long long v15; // [rsp+98h] [rbp-8h]
v15 = __readfsqword(0x28u);
v9 = a1;
v8 = (long long)a2;
if ( a3 >= *(_QWORD *)(*((_QWORD *)a1 + 4) + 40LL) )
{
*(_DWORD *)my_thread_var(a1, a2) = 137;
return *(unsigned int *)my_thread_var(a1, a2);
}
v5 = *((_DWORD *)a1 + 288);
if ( (*((_DWORD *)a1 + 391) & 2) != 0 )
{
a2 = a1 + 1208;
if ( (unsigned __int8)ma_read_cache(a1, a1 + 1208, v11, a3, *(unsigned int *)(*(_QWORD *)a1 + 1432LL), a4 != 0) )
return *(unsigned int *)my_thread_var(a1, a2);
v5 = -1;
}
a2 = a1 + 656;
if ( (unsigned int)ma_pack_get_block_info(
a1,
(long long)(a1 + 656),
(long long)v11,
(long long *)a1 + 116,
(unsigned long long *)a1 + 140,
v5,
a3) )
return *(unsigned int *)my_thread_var(a1, a2);
if ( (*((_DWORD *)a1 + 391) & 2) != 0 )
{
a2 = a1 + 1208;
if ( (unsigned __int8)ma_read_cache(a1, a1 + 1208, *((_QWORD *)a1 + 116), v13, v12, a4 != 0) )
return *(unsigned int *)my_thread_var(a1, a2);
}
else
{
a1 = "/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_packrec.c";
a2 = (_BYTE *)(&stru_568 + 10);
if ( inline_mysql_file_read(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_packrec.c",
0x572u,
*((_DWORD *)v9 + 288),
v14 + *((_QWORD *)v9 + 116),
v12 - v14,
4LL) )
{
return *(unsigned int *)my_thread_var(a1, a2);
}
}
*((_QWORD *)v9 + 138) = v12;
*((_QWORD *)v9 + 19) = a3;
*((_QWORD *)v9 + 20) = v12 + v13;
*((_DWORD *)v9 + 393) |= 0x82u;
*(_BYTE *)(*((_QWORD *)v9 + 116) + v12) = 0;
return (unsigned int)ma_pack_rec_unpack(v9, (long long)(v9 + 656), v8, *((_QWORD *)v9 + 116), v12);
}
| _ma_read_rnd_pack_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV AL,CL
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RCX
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x78],RSI
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RBP + -0x81],AL
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RCX + 0x20]
CMP RAX,qword ptr [RCX + 0x28]
JC 0x0014a21c
CALL 0x001fdd30
MOV dword ptr [RAX],0x89
JMP 0x0014a407
LAB_0014a21c:
MOV RAX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RAX + 0x480]
MOV dword ptr [RBP + -0x88],EAX
MOV RAX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RAX + 0x61c]
AND EAX,0x2
CMP EAX,0x0
JZ 0x0014a295
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x70]
ADD RSI,0x4b8
LEA RDX,[RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RBP + -0x90]
MOV EAX,dword ptr [RAX + 0x598]
MOV R8D,EAX
MOVSX R10D,byte ptr [RBP + -0x81]
XOR R9D,R9D
MOV EAX,0x1
CMP R10D,0x0
CMOVNZ R9D,EAX
CALL 0x001a5010
CMP AL,0x0
JZ 0x0014a28b
JMP 0x0014a407
LAB_0014a28b:
MOV dword ptr [RBP + -0x88],0xffffffff
LAB_0014a295:
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x70]
ADD RSI,0x290
MOV RCX,qword ptr [RBP + -0x70]
ADD RCX,0x3a0
MOV R8,qword ptr [RBP + -0x70]
ADD R8,0x460
MOV R9D,dword ptr [RBP + -0x88]
MOV RAX,qword ptr [RBP + -0x80]
LEA RDX,[RBP + -0x60]
MOV qword ptr [RSP],RAX
CALL 0x00149c30
CMP EAX,0x0
JZ 0x0014a2dc
JMP 0x0014a407
LAB_0014a2dc:
MOV RAX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RAX + 0x61c]
AND EAX,0x2
CMP EAX,0x0
JZ 0x0014a338
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x70]
ADD RSI,0x4b8
MOV RAX,qword ptr [RBP + -0x70]
MOV RDX,qword ptr [RAX + 0x3a0]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x48]
MOVSX R10D,byte ptr [RBP + -0x81]
XOR R9D,R9D
MOV EAX,0x1
CMP R10D,0x0
CMOVNZ R9D,EAX
CALL 0x001a5010
CMP AL,0x0
JZ 0x0014a336
JMP 0x0014a407
LAB_0014a336:
JMP 0x0014a381
LAB_0014a338:
MOV RAX,qword ptr [RBP + -0x70]
MOV EDX,dword ptr [RAX + 0x480]
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RAX + 0x3a0]
MOV EAX,dword ptr [RBP + -0xc]
ADD RCX,RAX
MOV R8,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RBP + -0xc]
SUB R8,RAX
LEA RDI,[0x25933d]
MOV ESI,0x572
MOV R9D,0x4
CALL 0x00149e60
CMP RAX,0x0
JZ 0x0014a37f
JMP 0x0014a407
LAB_0014a37f:
JMP 0x0014a381
LAB_0014a381:
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX + 0x450],RCX
MOV RCX,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX + 0x98],RCX
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX + 0xa0],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,dword ptr [RAX + 0x624]
OR ECX,0x82
MOV dword ptr [RAX + 0x624],ECX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x3a0]
MOV RCX,qword ptr [RBP + -0x48]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x70]
ADD RSI,0x290
MOV RDX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RAX + 0x3a0]
MOV R8,qword ptr [RBP + -0x48]
CALL 0x00149fd0
MOV dword ptr [RBP + -0x64],EAX
JMP 0x0014a413
LAB_0014a407:
JMP 0x0014a409
LAB_0014a409:
CALL 0x001fdd30
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x64],EAX
LAB_0014a413:
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0x94],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0014a43d
MOV EAX,dword ptr [RBP + -0x94]
ADD RSP,0xa0
POP RBP
RET
LAB_0014a43d:
CALL 0x00129230
|
int4 _ma_read_rnd_pack_record(long *param_1,int8 param_2,ulong param_3,char param_4)
{
char cVar1;
int iVar2;
int4 *puVar3;
long lVar4;
long in_FS_OFFSET;
int4 local_90;
int4 local_6c;
int1 local_68 [24];
long local_50;
long local_30;
uint local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_3 < *(ulong *)(param_1[4] + 0x28)) {
local_90 = (int4)param_1[0x90];
if ((*(uint *)((long)param_1 + 0x61c) & 2) != 0) {
cVar1 = _ma_read_cache(param_1,param_1 + 0x97,local_68,param_3,
*(int4 *)(*param_1 + 0x598),param_4 != '\0');
if (cVar1 != '\0') goto LAB_0014a407;
local_90 = 0xffffffff;
}
iVar2 = _ma_pack_get_block_info
(param_1,param_1 + 0x52,local_68,param_1 + 0x74,param_1 + 0x8c,local_90,
param_3);
if (iVar2 == 0) {
if ((*(uint *)((long)param_1 + 0x61c) & 2) == 0) {
lVar4 = inline_mysql_file_read
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_packrec.c",
0x572,(int)param_1[0x90],param_1[0x74] + (ulong)local_14,
local_50 - (ulong)local_14,4);
if (lVar4 == 0) goto LAB_0014a381;
}
else {
cVar1 = _ma_read_cache(param_1,param_1 + 0x97,param_1[0x74],local_30,local_50,
param_4 != '\0');
if (cVar1 == '\0') {
LAB_0014a381:
param_1[0x8a] = local_50;
param_1[0x13] = param_3;
param_1[0x14] = local_30 + local_50;
*(uint *)((long)param_1 + 0x624) = *(uint *)((long)param_1 + 0x624) | 0x82;
*(int1 *)(param_1[0x74] + local_50) = 0;
local_6c = _ma_pack_rec_unpack(param_1,param_1 + 0x52,param_2,param_1[0x74],local_50);
goto LAB_0014a413;
}
}
}
}
else {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
}
LAB_0014a407:
puVar3 = (int4 *)_my_thread_var();
local_6c = *puVar3;
LAB_0014a413:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_6c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
26,091 | ma_log_add | eloqsql/storage/maria/ma_key_recover.c | my_bool _ma_log_add(MARIA_PAGE *ma_page,
uint org_page_length __attribute__ ((unused)),
uchar *key_pos, uint changed_length, int move_length,
my_bool handle_overflow __attribute__ ((unused)),
enum en_key_debug debug_marker __attribute__((unused)))
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + 2 + 3 + 3 + 3 + 3 + 7 +
3 + 2];
uchar *log_pos;
uchar *buff= ma_page->buff;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 6];
MARIA_HA *info= ma_page->info;
uint offset= (uint) (key_pos - buff);
uint max_page_size= info->s->max_index_block_size;
uint translog_parts, current_size;
pgcache_page_no_t page_pos= ma_page->pos / info->s->block_size;
DBUG_ENTER("_ma_log_add");
DBUG_PRINT("enter", ("page: %lu org_page_length: %u changed_length: %u "
"move_length: %d",
(ulong) page_pos, org_page_length, changed_length,
move_length));
DBUG_ASSERT(info->s->now_transactional);
DBUG_ASSERT(move_length <= (int) changed_length);
DBUG_ASSERT(ma_page->org_size == MY_MIN(org_page_length, max_page_size));
DBUG_ASSERT(ma_page->size == org_page_length + move_length);
DBUG_ASSERT(offset <= ma_page->org_size);
/*
Write REDO entry that contains the logical operations we need
to do the page
*/
log_pos= log_data + FILEID_STORE_SIZE;
page_store(log_pos, page_pos);
current_size= ma_page->org_size;
log_pos+= PAGE_STORE_SIZE;
#ifdef EXTRA_DEBUG_KEY_CHANGES
*log_pos++= KEY_OP_DEBUG;
*log_pos++= debug_marker;
#endif
/* Store keypage_flag */
*log_pos++= KEY_OP_SET_PAGEFLAG;
*log_pos++= _ma_get_keypage_flag(info->s, buff);
/*
Don't overwrite page boundary
It's ok to cut this as we will append the data at end of page
in the next log entry
*/
if (offset + changed_length > max_page_size)
{
DBUG_ASSERT(handle_overflow);
changed_length= max_page_size - offset; /* Update to end of page */
move_length= 0; /* Nothing to move */
/* Extend the page to max length on recovery */
*log_pos++= KEY_OP_MAX_PAGELENGTH;
current_size= max_page_size;
}
/* Check if adding the key made the page overflow */
if (current_size + move_length > max_page_size)
{
/*
Adding the key caused an overflow. Cut away the part of the
page that doesn't fit.
*/
uint diff;
DBUG_ASSERT(handle_overflow);
diff= current_size + move_length - max_page_size;
log_pos[0]= KEY_OP_DEL_SUFFIX;
int2store(log_pos+1, diff);
log_pos+= 3;
current_size= max_page_size - move_length;
}
if (offset == current_size)
{
log_pos[0]= KEY_OP_ADD_SUFFIX;
current_size+= changed_length;
}
else
{
log_pos[0]= KEY_OP_OFFSET;
int2store(log_pos+1, offset);
log_pos+= 3;
if (move_length)
{
if (move_length < 0)
{
DBUG_ASSERT(offset - move_length <= org_page_length);
if (offset - move_length > current_size)
{
/*
Truncate to end of page. We will add data to it from
the page buffer below
*/
move_length= (int) offset - (int) current_size;
}
}
log_pos[0]= KEY_OP_SHIFT;
int2store(log_pos+1, move_length);
log_pos+= 3;
current_size+= move_length;
}
/*
Handle case where page was shortend but 'changed_length' goes over
'current_size'. This can only happen when there was a page overflow
and we will below add back the overflow part
*/
if (offset + changed_length > current_size)
{
DBUG_ASSERT(offset + changed_length <= ma_page->size);
changed_length= current_size - offset;
}
log_pos[0]= KEY_OP_CHANGE;
}
int2store(log_pos+1, changed_length);
log_pos+= 3;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= key_pos;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= changed_length;
translog_parts= TRANSLOG_INTERNAL_PARTS + 2;
/*
If page was originally > block_size before operation and now all data
fits, append the end data that was not part of the previous logged
page to it.
*/
DBUG_ASSERT(current_size <= max_page_size && current_size <= ma_page->size);
if (current_size != ma_page->size && current_size != max_page_size)
{
uint length= MY_MIN(ma_page->size, max_page_size) - current_size;
uchar *data= ma_page->buff + current_size;
log_pos[0]= KEY_OP_ADD_SUFFIX;
int2store(log_pos+1, length);
log_array[translog_parts].str= log_pos;
log_array[translog_parts].length= 3;
log_array[translog_parts+1].str= data;
log_array[translog_parts+1].length= length;
log_pos+= 3;
translog_parts+= 2;
current_size+= length;
changed_length+= length + 3;
}
_ma_log_key_changes(ma_page, log_array + translog_parts,
log_pos, &changed_length, &translog_parts);
/*
Remember new page length for future log entries for same page
Note that this can be different from ma_page->size in case of page
overflow!
*/
ma_page->org_size= current_size;
DBUG_ASSERT(ma_page->org_size == MY_MIN(ma_page->size, max_page_size));
if (translog_write_record(&lsn, LOGREC_REDO_INDEX,
info->trn, info,
(translog_size_t)
log_array[TRANSLOG_INTERNAL_PARTS + 0].length +
changed_length, translog_parts,
log_array, log_data, NULL))
DBUG_RETURN(-1);
DBUG_RETURN(0);
} | O3 | c | ma_log_add:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movl %ecx, %esi
movq %rdx, %r9
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rdi), %rbx
movq (%rdi), %rcx
movq 0x18(%rdi), %rax
movq %rdx, %r11
subq %rbx, %r11
movq (%rcx), %r14
movl 0x7bc(%r14), %r15d
movl 0x7c0(%r14), %r10d
xorl %edx, %edx
divq %r15
movl %eax, -0x4e(%rbp)
shrq $0x20, %rax
movb %al, -0x4a(%rbp)
movl 0x24(%rdi), %eax
movb $0xa, -0x49(%rbp)
movl 0x744(%r14), %edx
addl $-0x3, %edx
movb (%rbx,%rdx), %dl
movb %dl, -0x48(%rbp)
leal (%r11,%rsi), %edx
cmpl %r10d, %edx
jbe 0x40cd3
movl %r10d, %esi
subl %r11d, %esi
leaq -0x46(%rbp), %rdx
movb $0xc, -0x1(%rdx)
movl %r10d, %eax
xorl %r8d, %r8d
jmp 0x40cd7
leaq -0x47(%rbp), %rdx
leal (%r8,%rax), %ebx
subl %r10d, %ebx
jbe 0x40cf1
movb $0x7, (%rdx)
movw %bx, 0x1(%rdx)
addq $0x3, %rdx
movl %r10d, %eax
subl %r8d, %eax
movl %r11d, %ebx
subl %eax, %ebx
jne 0x40d01
movb $0x6, (%rdx)
leal (%rsi,%r11), %eax
jmp 0x40d4c
movb $0x1, (%rdx)
movw %r11w, 0x1(%rdx)
testl %r8d, %r8d
je 0x40d34
movl %r11d, %r14d
subl %r8d, %r14d
cmpl %eax, %r14d
cmovbel %r8d, %ebx
testl %r8d, %r8d
cmovnsl %r8d, %ebx
movb $0x2, 0x3(%rdx)
movw %bx, 0x4(%rdx)
addq $0x6, %rdx
addl %eax, %ebx
movl %ebx, %eax
jmp 0x40d38
addq $0x3, %rdx
leal (%rsi,%r11), %r8d
movl %eax, %ebx
subl %r11d, %ebx
cmpl %eax, %r8d
cmovbel %esi, %ebx
movb $0x3, (%rdx)
movl %ebx, %esi
movw %si, 0x1(%rdx)
leaq 0x3(%rdx), %rbx
leaq -0x50(%rbp), %r11
movq %r11, -0xc0(%rbp)
movl %ebx, %r8d
subl %r11d, %r8d
movq %r8, -0xb8(%rbp)
movq %r9, -0xb0(%rbp)
movl %esi, %r9d
movq %r9, -0xa8(%rbp)
movl 0x20(%rdi), %r14d
cmpl %r14d, %eax
sete %r9b
cmpl %r10d, %eax
sete %r15b
orb %r9b, %r15b
movl $0x4, %r9d
jne 0x40deb
cmpl %r10d, %r14d
cmovbl %r14d, %r10d
movl %r10d, %r8d
subl %eax, %r8d
movl %eax, %eax
addq 0x10(%rdi), %rax
movb $0x6, 0x3(%rdx)
movw %r8w, 0x4(%rdx)
movq %rbx, -0xa0(%rbp)
movq $0x3, -0x98(%rbp)
movq %rax, -0x90(%rbp)
movq %r8, -0x88(%rbp)
leal 0x3(%rsi,%r8), %esi
movl $0x6, %r9d
movq -0xb8(%rbp), %r8
movl %r10d, %eax
movl %eax, 0x24(%rdi)
movq 0x8(%rcx), %rdx
addl %esi, %r8d
subq $0x8, %rsp
leaq -0xe0(%rbp), %rax
leaq -0x58(%rbp), %rdi
movl $0xc, %esi
pushq $0x0
pushq %r11
pushq %rax
callq 0x2aa10
addq $0x20, %rsp
movl %eax, %ecx
xorl %eax, %eax
negb %cl
sbbl %eax, %eax
movq %fs:0x28, %rcx
cmpq -0x20(%rbp), %rcx
jne 0x40e3c
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a240
| _ma_log_add:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 0C8h
mov esi, ecx
mov r9, rdx
mov rax, fs:28h
mov [rbp+var_20], rax
mov rbx, [rdi+10h]
mov rcx, [rdi]
mov rax, [rdi+18h]
mov r11, rdx
sub r11, rbx
mov r14, [rcx]
mov r15d, [r14+7BCh]
mov r10d, [r14+7C0h]
xor edx, edx
div r15
mov [rbp+var_4E], eax
shr rax, 20h
mov [rbp+var_4A], al
mov eax, [rdi+24h]
mov [rbp+var_49], 0Ah
mov edx, [r14+744h]
add edx, 0FFFFFFFDh
mov dl, [rbx+rdx]
mov [rbp+var_48], dl
lea edx, [r11+rsi]
cmp edx, r10d
jbe short loc_40CD3
mov esi, r10d
sub esi, r11d
lea rdx, [rbp+var_46]
mov byte ptr [rdx-1], 0Ch
mov eax, r10d
xor r8d, r8d
jmp short loc_40CD7
loc_40CD3:
lea rdx, [rbp+var_47]
loc_40CD7:
lea ebx, [r8+rax]
sub ebx, r10d
jbe short loc_40CF1
mov byte ptr [rdx], 7
mov [rdx+1], bx
add rdx, 3
mov eax, r10d
sub eax, r8d
loc_40CF1:
mov ebx, r11d
sub ebx, eax
jnz short loc_40D01
mov byte ptr [rdx], 6
lea eax, [rsi+r11]
jmp short loc_40D4C
loc_40D01:
mov byte ptr [rdx], 1
mov [rdx+1], r11w
test r8d, r8d
jz short loc_40D34
mov r14d, r11d
sub r14d, r8d
cmp r14d, eax
cmovbe ebx, r8d
test r8d, r8d
cmovns ebx, r8d
mov byte ptr [rdx+3], 2
mov [rdx+4], bx
add rdx, 6
add ebx, eax
mov eax, ebx
jmp short loc_40D38
loc_40D34:
add rdx, 3
loc_40D38:
lea r8d, [rsi+r11]
mov ebx, eax
sub ebx, r11d
cmp r8d, eax
cmovbe ebx, esi
mov byte ptr [rdx], 3
mov esi, ebx
loc_40D4C:
mov [rdx+1], si
lea rbx, [rdx+3]
lea r11, [rbp+var_50]
mov [rbp+var_C0], r11
mov r8d, ebx
sub r8d, r11d
mov [rbp+var_B8], r8
mov [rbp+var_B0], r9
mov r9d, esi
mov [rbp+var_A8], r9
mov r14d, [rdi+20h]
cmp eax, r14d
setz r9b
cmp eax, r10d
setz r15b
or r15b, r9b
mov r9d, 4
jnz short loc_40DEB
cmp r14d, r10d
cmovb r10d, r14d
mov r8d, r10d
sub r8d, eax
mov eax, eax
add rax, [rdi+10h]
mov byte ptr [rdx+3], 6
mov [rdx+4], r8w
mov [rbp+var_A0], rbx
mov [rbp+var_98], 3
mov [rbp+var_90], rax
mov [rbp+var_88], r8
lea esi, [rsi+r8+3]
mov r9d, 6
mov r8, [rbp+var_B8]
mov eax, r10d
loc_40DEB:
mov [rdi+24h], eax
mov rdx, [rcx+8]
add r8d, esi
sub rsp, 8
lea rax, [rbp+var_E0]
lea rdi, [rbp+var_58]
mov esi, 0Ch
push 0
push r11
push rax
call translog_write_record
add rsp, 20h
mov ecx, eax
xor eax, eax
neg cl
sbb eax, eax
mov rcx, fs:28h
cmp rcx, [rbp+var_20]
jnz short loc_40E3C
add rsp, 0C8h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_40E3C:
call ___stack_chk_fail
| long long ma_log_add(long long a1, long long a2, long long a3, unsigned int a4, int a5)
{
long long v7; // rbx
_QWORD *v8; // rcx
int v9; // r11d
_DWORD *v10; // r14
unsigned int v11; // r10d
unsigned long long v12; // rax
unsigned int v13; // eax
char *v14; // rdx
int v15; // ebx
unsigned int v16; // ebx
unsigned int v17; // r8d
unsigned int v18; // r14d
int v19; // r9d
long long v20; // r8
long long v21; // rax
__int128 v23; // [rsp+0h] [rbp-E0h] BYREF
__int16 *v24; // [rsp+20h] [rbp-C0h]
long long v25; // [rsp+28h] [rbp-B8h]
long long v26; // [rsp+30h] [rbp-B0h]
long long v27; // [rsp+38h] [rbp-A8h]
char *v28; // [rsp+40h] [rbp-A0h]
long long v29; // [rsp+48h] [rbp-98h]
long long v30; // [rsp+50h] [rbp-90h]
long long v31; // [rsp+58h] [rbp-88h]
_BYTE v32[8]; // [rsp+88h] [rbp-58h] BYREF
__int16 v33; // [rsp+90h] [rbp-50h] BYREF
int v34; // [rsp+92h] [rbp-4Eh]
char v35; // [rsp+96h] [rbp-4Ah]
char v36; // [rsp+97h] [rbp-49h]
char v37; // [rsp+98h] [rbp-48h]
char v38; // [rsp+99h] [rbp-47h] BYREF
char v39; // [rsp+9Ah] [rbp-46h] BYREF
unsigned long long v40; // [rsp+C0h] [rbp-20h]
v40 = __readfsqword(0x28u);
v7 = *(_QWORD *)(a1 + 16);
v8 = *(_QWORD **)a1;
v9 = a3 - v7;
v10 = **(_DWORD ***)a1;
v11 = v10[496];
v12 = *(_QWORD *)(a1 + 24) / (unsigned long long)(unsigned int)v10[495];
v34 = v12;
v35 = BYTE4(v12);
v13 = *(_DWORD *)(a1 + 36);
v36 = 10;
v37 = *(_BYTE *)(v7 + (unsigned int)(v10[465] - 3));
if ( (_DWORD)a3 - (_DWORD)v7 + a4 <= v11 )
{
v14 = &v38;
}
else
{
a4 = v11 - v9;
v14 = &v39;
v38 = 12;
v13 = v11;
a5 = 0;
}
if ( a5 + v13 > v11 )
{
*v14 = 7;
*(_WORD *)(v14 + 1) = a5 + v13 - v11;
v14 += 3;
v13 = v11 - a5;
}
v15 = v9 - v13;
if ( v9 == v13 )
{
*v14 = 6;
v13 = a4 + v9;
}
else
{
*v14 = 1;
*(_WORD *)(v14 + 1) = v9;
if ( a5 )
{
if ( v9 - a5 <= v13 )
v15 = a5;
if ( a5 >= 0 )
v15 = a5;
v14[3] = 2;
*((_WORD *)v14 + 2) = v15;
v14 += 6;
v13 += v15;
}
else
{
v14 += 3;
}
v16 = v13 - v9;
if ( a4 + v9 <= v13 )
v16 = a4;
*v14 = 3;
a4 = v16;
}
*(_WORD *)(v14 + 1) = a4;
v24 = &v33;
v17 = (_DWORD)v14 + 3 - (unsigned int)&v33;
v25 = v17;
v26 = a3;
v27 = a4;
v18 = *(_DWORD *)(a1 + 32);
v19 = 4;
if ( v13 != v18 && v13 != v11 )
{
if ( v18 < v11 )
v11 = *(_DWORD *)(a1 + 32);
v20 = v11 - v13;
v21 = *(_QWORD *)(a1 + 16) + v13;
v14[3] = 6;
*((_WORD *)v14 + 2) = v20;
v28 = v14 + 3;
v29 = 3LL;
v30 = v21;
v31 = v20;
a4 += v20 + 3;
v19 = 6;
v17 = v25;
v13 = v11;
}
*(_DWORD *)(a1 + 36) = v13;
return (unsigned int)-((unsigned __int8)translog_write_record(
(unsigned long long)v32,
&byte_9[3],
v8[1],
v8,
a4 + v17,
v19,
&v23,
&v33,
0LL) != 0);
}
| _ma_log_add:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xc8
MOV ESI,ECX
MOV R9,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RBX,qword ptr [RDI + 0x10]
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x18]
MOV R11,RDX
SUB R11,RBX
MOV R14,qword ptr [RCX]
MOV R15D,dword ptr [R14 + 0x7bc]
MOV R10D,dword ptr [R14 + 0x7c0]
XOR EDX,EDX
DIV R15
MOV dword ptr [RBP + -0x4e],EAX
SHR RAX,0x20
MOV byte ptr [RBP + -0x4a],AL
MOV EAX,dword ptr [RDI + 0x24]
MOV byte ptr [RBP + -0x49],0xa
MOV EDX,dword ptr [R14 + 0x744]
ADD EDX,-0x3
MOV DL,byte ptr [RBX + RDX*0x1]
MOV byte ptr [RBP + -0x48],DL
LEA EDX,[R11 + RSI*0x1]
CMP EDX,R10D
JBE 0x00140cd3
MOV ESI,R10D
SUB ESI,R11D
LEA RDX,[RBP + -0x46]
MOV byte ptr [RDX + -0x1],0xc
MOV EAX,R10D
XOR R8D,R8D
JMP 0x00140cd7
LAB_00140cd3:
LEA RDX,[RBP + -0x47]
LAB_00140cd7:
LEA EBX,[R8 + RAX*0x1]
SUB EBX,R10D
JBE 0x00140cf1
MOV byte ptr [RDX],0x7
MOV word ptr [RDX + 0x1],BX
ADD RDX,0x3
MOV EAX,R10D
SUB EAX,R8D
LAB_00140cf1:
MOV EBX,R11D
SUB EBX,EAX
JNZ 0x00140d01
MOV byte ptr [RDX],0x6
LEA EAX,[RSI + R11*0x1]
JMP 0x00140d4c
LAB_00140d01:
MOV byte ptr [RDX],0x1
MOV word ptr [RDX + 0x1],R11W
TEST R8D,R8D
JZ 0x00140d34
MOV R14D,R11D
SUB R14D,R8D
CMP R14D,EAX
CMOVBE EBX,R8D
TEST R8D,R8D
CMOVNS EBX,R8D
MOV byte ptr [RDX + 0x3],0x2
MOV word ptr [RDX + 0x4],BX
ADD RDX,0x6
ADD EBX,EAX
MOV EAX,EBX
JMP 0x00140d38
LAB_00140d34:
ADD RDX,0x3
LAB_00140d38:
LEA R8D,[RSI + R11*0x1]
MOV EBX,EAX
SUB EBX,R11D
CMP R8D,EAX
CMOVBE EBX,ESI
MOV byte ptr [RDX],0x3
MOV ESI,EBX
LAB_00140d4c:
MOV word ptr [RDX + 0x1],SI
LEA RBX,[RDX + 0x3]
LEA R11,[RBP + -0x50]
MOV qword ptr [RBP + -0xc0],R11
MOV R8D,EBX
SUB R8D,R11D
MOV qword ptr [RBP + -0xb8],R8
MOV qword ptr [RBP + -0xb0],R9
MOV R9D,ESI
MOV qword ptr [RBP + -0xa8],R9
MOV R14D,dword ptr [RDI + 0x20]
CMP EAX,R14D
SETZ R9B
CMP EAX,R10D
SETZ R15B
OR R15B,R9B
MOV R9D,0x4
JNZ 0x00140deb
CMP R14D,R10D
CMOVC R10D,R14D
MOV R8D,R10D
SUB R8D,EAX
MOV EAX,EAX
ADD RAX,qword ptr [RDI + 0x10]
MOV byte ptr [RDX + 0x3],0x6
MOV word ptr [RDX + 0x4],R8W
MOV qword ptr [RBP + -0xa0],RBX
MOV qword ptr [RBP + -0x98],0x3
MOV qword ptr [RBP + -0x90],RAX
MOV qword ptr [RBP + -0x88],R8
LEA ESI,[RSI + R8*0x1 + 0x3]
MOV R9D,0x6
MOV R8,qword ptr [RBP + -0xb8]
MOV EAX,R10D
LAB_00140deb:
MOV dword ptr [RDI + 0x24],EAX
MOV RDX,qword ptr [RCX + 0x8]
ADD R8D,ESI
SUB RSP,0x8
LEA RAX,[RBP + -0xe0]
LEA RDI,[RBP + -0x58]
MOV ESI,0xc
PUSH 0x0
PUSH R11
PUSH RAX
CALL 0x0012aa10
ADD RSP,0x20
MOV ECX,EAX
XOR EAX,EAX
NEG CL
SBB EAX,EAX
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x20]
JNZ 0x00140e3c
ADD RSP,0xc8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00140e3c:
CALL 0x0012a240
|
int _ma_log_add(long *param_1,int8 param_2,long param_3,uint param_4,int param_5)
{
long *plVar1;
long lVar2;
int1 auVar3 [16];
char cVar4;
uint uVar5;
uint uVar6;
int1 *puVar7;
int iVar8;
uint uVar9;
int iVar10;
uint uVar11;
uint uVar12;
int8 uVar13;
long lVar14;
long in_FS_OFFSET;
int1 local_e8 [32];
int1 *local_c8;
ulong local_c0;
long local_b8;
ulong local_b0;
int1 *local_a8;
int8 local_a0;
long local_98;
ulong local_90;
int1 local_60 [8];
int1 local_58 [2];
int4 local_56;
int1 local_52;
int1 local_51;
int1 local_50;
int1 local_4f [39];
long local_28;
local_b0 = (ulong)param_4;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
plVar1 = (long *)*param_1;
lVar14 = param_3 - param_1[2];
lVar2 = *plVar1;
uVar12 = *(uint *)(lVar2 + 0x7c0);
auVar3._8_8_ = 0;
auVar3._0_8_ = param_1[3];
auVar3 = auVar3 / ZEXT416(*(uint *)(lVar2 + 0x7bc));
local_56 = auVar3._0_4_;
local_52 = auVar3[4];
uVar5 = *(uint *)((long)param_1 + 0x24);
local_51 = 10;
local_50 = *(int1 *)(param_1[2] + (ulong)(*(int *)(lVar2 + 0x744) - 3));
iVar10 = (int)lVar14;
if (uVar12 < iVar10 + param_4) {
local_b0 = (ulong)(uVar12 - iVar10);
puVar7 = local_4f + 1;
local_4f[0] = 0xc;
param_5 = 0;
uVar5 = uVar12;
}
else {
puVar7 = local_4f;
}
uVar9 = (uint)local_b0;
iVar8 = (param_5 + uVar5) - uVar12;
if (uVar12 <= param_5 + uVar5 && iVar8 != 0) {
*puVar7 = 7;
*(short *)(puVar7 + 1) = (short)iVar8;
puVar7 = puVar7 + 3;
uVar5 = uVar12 - param_5;
}
if (iVar10 - uVar5 == 0) {
*puVar7 = 6;
uVar5 = uVar9 + iVar10;
}
else {
*puVar7 = 1;
*(short *)(puVar7 + 1) = (short)lVar14;
if (param_5 == 0) {
puVar7 = puVar7 + 3;
}
else {
iVar8 = iVar10 - uVar5;
if ((uint)(iVar10 - param_5) <= uVar5) {
iVar8 = param_5;
}
if (-1 < param_5) {
iVar8 = param_5;
}
puVar7[3] = 2;
*(short *)(puVar7 + 4) = (short)iVar8;
puVar7 = puVar7 + 6;
uVar5 = iVar8 + uVar5;
}
uVar6 = uVar5 - iVar10;
if (uVar9 + iVar10 <= uVar5) {
uVar6 = uVar9;
}
*puVar7 = 3;
local_b0 = (ulong)uVar6;
}
*(short *)(puVar7 + 1) = (short)local_b0;
local_c8 = local_58;
uVar11 = (int)(puVar7 + 3) - (int)local_c8;
local_c0 = (ulong)uVar11;
iVar10 = (int)local_b0;
uVar9 = *(uint *)(param_1 + 4);
uVar13 = 4;
uVar6 = uVar5;
if (uVar5 != uVar12 && uVar5 != uVar9) {
uVar6 = uVar12;
if (uVar9 < uVar12) {
uVar6 = uVar9;
}
uVar12 = uVar6 - uVar5;
local_90 = (ulong)uVar12;
local_98 = (ulong)uVar5 + param_1[2];
puVar7[3] = 6;
*(short *)(puVar7 + 4) = (short)uVar12;
local_a0 = 3;
iVar10 = iVar10 + 3 + uVar12;
uVar13 = 6;
local_a8 = puVar7 + 3;
}
*(uint *)((long)param_1 + 0x24) = uVar6;
local_b8 = param_3;
cVar4 = translog_write_record
(local_60,0xc,plVar1[1],plVar1,uVar11 + iVar10,uVar13,local_e8,local_c8,0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return -(uint)(cVar4 != '\0');
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
26,092 | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::end_array() | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | bool end_array()
{
bool keep = true;
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
if (keep)
{
#if JSON_DIAGNOSTIC_POSITIONS
if (m_lexer_ref)
{
// Lexer's position is past the closing bracket, so set that as the end position.
ref_stack.back()->end_position = m_lexer_ref->get_position();
}
#endif
ref_stack.back()->set_parents();
}
else
{
// discard array
*ref_stack.back() = discarded;
#if JSON_DIAGNOSTIC_POSITIONS
// Set start/end positions for discarded array.
handle_diagnostic_positions_for_json_value(*ref_stack.back());
#endif
}
}
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
// remove discarded value
if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->pop_back();
}
return true;
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::end_array():
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movb $0x1, -0x9(%rbp)
addq $0x8, %rdi
callq 0x60240
cmpq $0x0, (%rax)
je 0x7de86
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x80, %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
callq 0x5f6f0
movq -0x28(%rbp), %rdi
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
addq $0x8, %rdi
callq 0x60240
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq (%rax), %rcx
movl $0x3, %edx
callq 0x5d470
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x7de4e
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x60240
movq (%rax), %rdi
callq 0x611a0
jmp 0x7de84
movq -0x28(%rbp), %rsi
addq $0xa8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x5d590
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x60240
movq (%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5c770
leaq -0x20(%rbp), %rdi
callq 0x5fdc0
jmp 0x7de86
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x60af0
xorb $-0x1, %al
testb $0x1, %al
jne 0x7de9b
jmp 0x7de9d
jmp 0x7debc
leaq 0x11e7c(%rip), %rdi # 0x8fd20
leaq 0xf058(%rip), %rsi # 0x8cf03
movl $0x248c, %edx # imm = 0x248C
leaq 0x128d1(%rip), %rcx # 0x90788
callq 0x5d1f0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x60380
xorb $-0x1, %al
testb $0x1, %al
jne 0x7ded1
jmp 0x7ded3
jmp 0x7def2
leaq 0x11bf7(%rip), %rdi # 0x8fad1
leaq 0xf022(%rip), %rsi # 0x8cf03
movl $0x248d, %edx # imm = 0x248D
leaq 0x1289b(%rip), %rcx # 0x90788
callq 0x5d1f0
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x5bff0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x60710
testb $0x1, -0x9(%rbp)
jne 0x7df57
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x60af0
testb $0x1, %al
jne 0x7df57
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x60240
movq (%rax), %rdi
callq 0x5dd70
testb $0x1, %al
jne 0x7df3e
jmp 0x7df57
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x60240
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x61670
movb $0x1, %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE9end_arrayEv:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
mov [rbp+var_28], rdi
mov [rbp+var_9], 1
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
cmp qword ptr [rax], 0
jz loc_7DE86
mov rdi, [rbp+var_28]
mov rax, rdi
add rax, 80h
mov [rbp+var_38], rax
add rdi, 8
call __ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4sizeEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::size(void)
mov rdi, [rbp+var_28]
sub eax, 1
mov [rbp+var_2C], eax
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rbp+var_38]
mov esi, [rbp+var_2C]
mov rcx, [rax]
mov edx, 3
call __ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
and al, 1
mov [rbp+var_9], al
test [rbp+var_9], 1
jz short loc_7DE4E
mov rdi, [rbp+var_28]
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE11set_parentsEv; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::set_parents(void)
jmp short loc_7DE84
loc_7DE4E:
mov rsi, [rbp+var_28]
add rsi, 0A8h
lea rdi, [rbp+var_20]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rdi, [rbp+var_28]
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
lea rsi, [rbp+var_20]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
lea rdi, [rbp+var_20]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_7DE84:
jmp short $+2
loc_7DE86:
mov rdi, [rbp+var_28]
add rdi, 8
call __ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE5emptyEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::empty(void)
xor al, 0FFh
test al, 1
jnz short loc_7DE9B
jmp short loc_7DE9D
loc_7DE9B:
jmp short loc_7DEBC
loc_7DE9D:
lea rdi, aRefStackEmpty; "!ref_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 248Ch
lea rcx, aBoolNlohmannDe_3; "bool nlohmann::detail::json_sax_dom_cal"...
call ___assert_fail
loc_7DEBC:
mov rdi, [rbp+var_28]
add rdi, 20h ; ' '
call __ZNKSt6vectorIbSaIbEE5emptyEv; std::vector<bool>::empty(void)
xor al, 0FFh
test al, 1
jnz short loc_7DED1
jmp short loc_7DED3
loc_7DED1:
jmp short loc_7DEF2
loc_7DED3:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 248Dh
lea rcx, aBoolNlohmannDe_3; "bool nlohmann::detail::json_sax_dom_cal"...
call ___assert_fail
loc_7DEF2:
mov rdi, [rbp+var_28]
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE8pop_backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::pop_back(void)
mov rdi, [rbp+var_28]
add rdi, 20h ; ' '
call __ZNSt6vectorIbSaIbEE8pop_backEv; std::vector<bool>::pop_back(void)
test [rbp+var_9], 1
jnz short loc_7DF57
mov rdi, [rbp+var_28]
add rdi, 8
call __ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE5emptyEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::empty(void)
test al, 1
jnz short loc_7DF57
mov rdi, [rbp+var_28]
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8is_arrayEv; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_array(void)
test al, 1
jnz short loc_7DF3E
jmp short loc_7DF57
loc_7DF3E:
mov rdi, [rbp+var_28]
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rax, [rax]
mov rdi, [rax+8]
call __ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE8pop_backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::pop_back(void)
loc_7DF57:
mov al, 1
and al, 1
add rsp, 40h
pop rbp
retn
| char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,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>>>::end_array(
long long a1)
{
_QWORD *v1; // rax
_QWORD *v2; // rax
_QWORD *v3; // rax
char v4; // al
_QWORD *v5; // rax
long long v6; // rax
unsigned int v8; // [rsp+14h] [rbp-2Ch]
_BYTE v9[23]; // [rsp+20h] [rbp-20h] BYREF
char v10; // [rsp+37h] [rbp-9h]
long long v11; // [rsp+38h] [rbp-8h]
v11 = a1;
v10 = 1;
if ( *(_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 8) )
{
v8 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::size(a1 + 8)
- 1;
v1 = (_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 8);
v10 = std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()(
a1 + 128,
v8,
3LL,
*v1) & 1;
if ( v10 )
{
v2 = (_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 8);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::set_parents(*v2);
}
else
{
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v9,
a1 + 168);
v3 = (_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 8);
nlohmann::json_abi_v3_11_3::basic_json<std::map,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=(
*v3,
v9);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json(v9);
}
}
if ( (std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::empty(a1 + 8) & 1) != 0 )
__assert_fail(
"!ref_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9356LL,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapt"
"er<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::end_array() [BasicJsonType = nlohmann::b"
"asic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *"
", std::basic_string<char>>>]");
v4 = std::vector<bool>::empty(a1 + 32);
if ( (v4 & 1) != 0 )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9357LL,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapt"
"er<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::end_array() [BasicJsonType = nlohmann::b"
"asic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *"
", std::basic_string<char>>>]");
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::pop_back(a1 + 8);
std::vector<bool>::pop_back(a1 + 32);
if ( (v10 & 1) == 0
&& (std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::empty(a1 + 8) & 1) == 0 )
{
v5 = (_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 8);
if ( (nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_array(*v5) & 1) != 0 )
{
v6 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 8);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::pop_back(*(_QWORD *)(*(_QWORD *)v6 + 8LL));
}
}
return 1;
}
| end_array:
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
MOV byte ptr [RBP + -0x9],0x1
ADD RDI,0x8
CALL 0x00160240
CMP qword ptr [RAX],0x0
JZ 0x0017de86
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,RDI
ADD RAX,0x80
MOV qword ptr [RBP + -0x38],RAX
ADD RDI,0x8
CALL 0x0015f6f0
MOV RDI,qword ptr [RBP + -0x28]
SUB EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
ADD RDI,0x8
CALL 0x00160240
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RAX]
MOV EDX,0x3
CALL 0x0015d470
AND AL,0x1
MOV byte ptr [RBP + -0x9],AL
TEST byte ptr [RBP + -0x9],0x1
JZ 0x0017de4e
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
CALL 0x00160240
MOV RDI,qword ptr [RAX]
CALL 0x001611a0
JMP 0x0017de84
LAB_0017de4e:
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0xa8
LEA RDI,[RBP + -0x20]
CALL 0x0015d590
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
CALL 0x00160240
MOV RDI,qword ptr [RAX]
LEA RSI,[RBP + -0x20]
CALL 0x0015c770
LEA RDI,[RBP + -0x20]
CALL 0x0015fdc0
LAB_0017de84:
JMP 0x0017de86
LAB_0017de86:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
CALL 0x00160af0
XOR AL,0xff
TEST AL,0x1
JNZ 0x0017de9b
JMP 0x0017de9d
LAB_0017de9b:
JMP 0x0017debc
LAB_0017de9d:
LEA RDI,[0x18fd20]
LEA RSI,[0x18cf03]
MOV EDX,0x248c
LEA RCX,[0x190788]
CALL 0x0015d1f0
LAB_0017debc:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x20
CALL 0x00160380
XOR AL,0xff
TEST AL,0x1
JNZ 0x0017ded1
JMP 0x0017ded3
LAB_0017ded1:
JMP 0x0017def2
LAB_0017ded3:
LEA RDI,[0x18fad1]
LEA RSI,[0x18cf03]
MOV EDX,0x248d
LEA RCX,[0x190788]
CALL 0x0015d1f0
LAB_0017def2:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
CALL 0x0015bff0
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x20
CALL 0x00160710
TEST byte ptr [RBP + -0x9],0x1
JNZ 0x0017df57
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
CALL 0x00160af0
TEST AL,0x1
JNZ 0x0017df57
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
CALL 0x00160240
MOV RDI,qword ptr [RAX]
CALL 0x0015dd70
TEST AL,0x1
JNZ 0x0017df3e
JMP 0x0017df57
LAB_0017df3e:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
CALL 0x00160240
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00161670
LAB_0017df57:
MOV AL,0x1
AND AL,0x1
ADD RSP,0x40
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, 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 > > >::end_array() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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>>>
::end_array(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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)
{
byte bVar1;
int iVar2;
long *plVar3;
int8 *puVar4;
ulong uVar5;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_28 [23];
byte local_11;
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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_10;
local_11 = 1;
local_10 = this;
plVar3 = (long *)std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
if (*plVar3 != 0) {
iVar2 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::size((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
puVar4 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
local_11 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
*)(this + 0x80),iVar2 + -1,3,*puVar4);
local_11 = local_11 & 1;
if (local_11 == 0) {
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_28,(basic_json *)(this + 0xa8));
puVar4 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar4,local_28);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_28);
}
else {
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
basic_json<std::map,std::vector,std::__cxx11::string,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_parents();
}
}
bVar1 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::empty((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
if (((bVar1 ^ 0xff) & 1) != 0) {
bVar1 = std::vector<bool,std::allocator<bool>>::empty
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if (((bVar1 ^ 0xff) & 1) != 0) {
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::pop_back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
std::vector<bool,std::allocator<bool>>::pop_back
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if (((local_11 & 1) == 0) &&
(uVar5 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::empty((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8)), (uVar5 & 1) == 0)) {
puVar4 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
uVar5 = basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::is_array((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar4);
if ((uVar5 & 1) != 0) {
plVar3 = (long *)std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::pop_back(*(vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(*plVar3 + 8));
}
}
return 1;
}
/* WARNING: Subroutine does not return */
__assert_fail("!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x248d,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::end_array() [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>]"
);
}
/* WARNING: Subroutine does not return */
__assert_fail("!ref_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x248c,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::end_array() [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>]"
);
}
| |
26,093 | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::end_array() | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | bool end_array()
{
bool keep = true;
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
if (keep)
{
#if JSON_DIAGNOSTIC_POSITIONS
if (m_lexer_ref)
{
// Lexer's position is past the closing bracket, so set that as the end position.
ref_stack.back()->end_position = m_lexer_ref->get_position();
}
#endif
ref_stack.back()->set_parents();
}
else
{
// discard array
*ref_stack.back() = discarded;
#if JSON_DIAGNOSTIC_POSITIONS
// Set start/end positions for discarded array.
handle_diagnostic_positions_for_json_value(*ref_stack.back());
#endif
}
}
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
// remove discarded value
if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->pop_back();
}
return true;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::end_array():
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq -0x8(%rsi), %rcx
movb $0x1, %bpl
testq %rcx, %rcx
je 0x2668a
leaq 0x80(%rbx), %rdi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
decl %esi
pushq $0x3
popq %rdx
callq 0x1cbe0
testb %al, %al
jne 0x2668a
leaq 0xa8(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x1cc60
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rdi
movq %r14, %rsi
callq 0x1c7e0
movq %r14, %rdi
callq 0x1d7b0
xorl %ebp, %ebp
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x266e1
movq 0x20(%rbx), %rcx
cmpq 0x30(%rbx), %rcx
jne 0x266a4
cmpl $0x0, 0x38(%rbx)
je 0x26700
leaq 0x30(%rbx), %rdi
addq $-0x8, %rax
movq %rax, 0x10(%rbx)
callq 0x1d1f0
testb %bpl, %bpl
jne 0x266d6
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x266d6
movq -0x8(%rax), %rax
cmpb $0x2, (%rax)
jne 0x266d6
movq 0x8(%rax), %rdi
callq 0x1ddb0
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7976(%rip), %rdi # 0x2e05e
leaq 0x5178(%rip), %rsi # 0x2b867
leaq 0x7bd2(%rip), %rcx # 0x2e2c8
movl $0x248c, %edx # imm = 0x248C
callq 0x1cb30
leaq 0x7708(%rip), %rdi # 0x2de0f
leaq 0x5159(%rip), %rsi # 0x2b867
leaq 0x7bb3(%rip), %rcx # 0x2e2c8
movl $0x248d, %edx # imm = 0x248D
callq 0x1cb30
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE9end_arrayEv:
push rbp
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
mov rsi, [rdi+10h]
mov rcx, [rsi-8]
mov bpl, 1
test rcx, rcx
jz short loc_2668A
lea rdi, [rbx+80h]
sub rsi, [rbx+8]
shr rsi, 3
dec esi
push 3
pop rdx
call __ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
test al, al
jnz short loc_2668A
lea rsi, [rbx+0A8h]
mov r14, rsp
mov rdi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, [rbx+10h]
mov rdi, [rax-8]
mov rsi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
xor ebp, ebp
loc_2668A:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_266E1
mov rcx, [rbx+20h]
cmp rcx, [rbx+30h]
jnz short loc_266A4
cmp dword ptr [rbx+38h], 0
jz short loc_26700
loc_266A4:
lea rdi, [rbx+30h]; this
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+10h], rax
call __ZNSt18_Bit_iterator_base12_M_bump_downEv; std::_Bit_iterator_base::_M_bump_down(void)
test bpl, bpl
jnz short loc_266D6
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_266D6
mov rax, [rax-8]
cmp byte ptr [rax], 2
jnz short loc_266D6
mov rdi, [rax+8]
call __ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE8pop_backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::pop_back(void)
loc_266D6:
mov al, 1
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
loc_266E1:
lea rdi, aRefStackEmpty; "!ref_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolNlohmannDe_3; "bool nlohmann::detail::json_sax_dom_cal"...
mov edx, 248Ch
call ___assert_fail
loc_26700:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolNlohmannDe_3; "bool nlohmann::detail::json_sax_dom_cal"...
mov edx, 248Dh
call ___assert_fail
| char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,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>>>::end_array(
long long a1)
{
long long v1; // rsi
long long v2; // rcx
char v3; // bp
long long v4; // rax
long long v5; // rax
long long v6; // rax
_BYTE v8[40]; // [rsp+0h] [rbp-28h] BYREF
v1 = *(_QWORD *)(a1 + 16);
v2 = *(_QWORD *)(v1 - 8);
v3 = 1;
if ( v2
&& !(unsigned __int8)std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()(
a1 + 128,
(unsigned int)((unsigned long long)(v1 - *(_QWORD *)(a1 + 8)) >> 3) - 1,
3LL,
v2) )
{
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v8,
a1 + 168);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL),
v8);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json(v8);
v3 = 0;
}
v4 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v4 )
__assert_fail(
"!ref_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9356LL,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapt"
"er<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::end_array() [BasicJsonType = nlohmann::b"
"asic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *"
", std::basic_string<char>>>]");
if ( *(_QWORD *)(a1 + 32) == *(_QWORD *)(a1 + 48) && !*(_DWORD *)(a1 + 56) )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9357LL,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapt"
"er<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::end_array() [BasicJsonType = nlohmann::b"
"asic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *"
", std::basic_string<char>>>]");
*(_QWORD *)(a1 + 16) = v4 - 8;
std::_Bit_iterator_base::_M_bump_down((std::_Bit_iterator_base *)(a1 + 48));
if ( !v3 )
{
v5 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) != v5 )
{
v6 = *(_QWORD *)(v5 - 8);
if ( *(_BYTE *)v6 == 2 )
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::pop_back(*(_QWORD *)(v6 + 8));
}
}
return 1;
}
| end_array:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV RSI,qword ptr [RDI + 0x10]
MOV RCX,qword ptr [RSI + -0x8]
MOV BPL,0x1
TEST RCX,RCX
JZ 0x0012668a
LEA RDI,[RBX + 0x80]
SUB RSI,qword ptr [RBX + 0x8]
SHR RSI,0x3
DEC ESI
PUSH 0x3
POP RDX
CALL 0x0011cbe0
TEST AL,AL
JNZ 0x0012668a
LEA RSI,[RBX + 0xa8]
MOV R14,RSP
MOV RDI,R14
CALL 0x0011cc60
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,R14
CALL 0x0011c7e0
MOV RDI,R14
CALL 0x0011d7b0
XOR EBP,EBP
LAB_0012668a:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x001266e1
MOV RCX,qword ptr [RBX + 0x20]
CMP RCX,qword ptr [RBX + 0x30]
JNZ 0x001266a4
CMP dword ptr [RBX + 0x38],0x0
JZ 0x00126700
LAB_001266a4:
LEA RDI,[RBX + 0x30]
ADD RAX,-0x8
MOV qword ptr [RBX + 0x10],RAX
CALL 0x0011d1f0
TEST BPL,BPL
JNZ 0x001266d6
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x001266d6
MOV RAX,qword ptr [RAX + -0x8]
CMP byte ptr [RAX],0x2
JNZ 0x001266d6
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x0011ddb0
LAB_001266d6:
MOV AL,0x1
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
LAB_001266e1:
LEA RDI,[0x12e05e]
LEA RSI,[0x12b867]
LEA RCX,[0x12e2c8]
MOV EDX,0x248c
CALL 0x0011cb30
LAB_00126700:
LEA RDI,[0x12de0f]
LEA RSI,[0x12b867]
LEA RCX,[0x12e2c8]
MOV EDX,0x248d
CALL 0x0011cb30
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, 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 > > >::end_array() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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>>>
::end_array(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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)
{
char *pcVar1;
bool bVar2;
char cVar3;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
abStack_28 [16];
bVar2 = true;
if (*(long *)(*(long *)(this + 0x10) + -8) != 0) {
cVar3 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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()(this + 0x80,
(int)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3) + -1,3);
if (cVar3 == '\0') {
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(abStack_28,(basic_json *)(this + 0xa8));
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(*(long *)(this + 0x10) + -8),abStack_28);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(abStack_28);
bVar2 = false;
}
}
if (*(long *)(this + 8) != *(long *)(this + 0x10)) {
if ((*(long *)(this + 0x20) == *(long *)(this + 0x30)) && (*(int *)(this + 0x38) == 0)) {
/* WARNING: Subroutine does not return */
__assert_fail("!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x248d,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::end_array() [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>]"
);
}
*(long *)(this + 0x10) = *(long *)(this + 0x10) + -8;
std::_Bit_iterator_base::_M_bump_down((_Bit_iterator_base *)(this + 0x30));
if (((!bVar2) && (*(long *)(this + 8) != *(long *)(this + 0x10))) &&
(pcVar1 = *(char **)(*(long *)(this + 0x10) + -8), *pcVar1 == '\x02')) {
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::pop_back(*(vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pcVar1 + 8));
}
return 1;
}
/* WARNING: Subroutine does not return */
__assert_fail("!ref_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x248c,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::end_array() [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>]"
);
}
| |
26,094 | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::end_array() | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | bool end_array()
{
bool keep = true;
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
if (keep)
{
#if JSON_DIAGNOSTIC_POSITIONS
if (m_lexer_ref)
{
// Lexer's position is past the closing bracket, so set that as the end position.
ref_stack.back()->end_position = m_lexer_ref->get_position();
}
#endif
ref_stack.back()->set_parents();
}
else
{
// discard array
*ref_stack.back() = discarded;
#if JSON_DIAGNOSTIC_POSITIONS
// Set start/end positions for discarded array.
handle_diagnostic_positions_for_json_value(*ref_stack.back());
#endif
}
}
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
// remove discarded value
if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->pop_back();
}
return true;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::end_array():
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq -0x8(%rax), %rcx
movb $0x1, %bpl
testq %rcx, %rcx
je 0x1bed1
subq 0x8(%rbx), %rax
shrq $0x3, %rax
decl %eax
movl %eax, 0xc(%rsp)
movb $0x3, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x1bf9a
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
callq *0x98(%rbx)
testb %al, %al
jne 0x1bed1
leaq 0xa8(%rbx), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x116c0
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rdi
movq %r14, %rsi
callq 0x11490
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0x11430
movq %r14, %rdi
callq 0x11e20
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
cmpq %rax, %rcx
je 0x1bf5c
movq 0x30(%rbx), %rdx
movl 0x38(%rbx), %esi
cmpq %rdx, 0x20(%rbx)
sete %dil
testl %esi, %esi
sete %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
je 0x1bf7b
leaq -0x8(%rax), %rdi
movq %rdi, 0x10(%rbx)
subl $0x1, %esi
movl %esi, 0x38(%rbx)
jae 0x1bf1b
movl $0x3f, 0x38(%rbx)
addq $-0x8, %rdx
movq %rdx, 0x30(%rbx)
cmpq %rdi, %rcx
sete %cl
orb %cl, %bpl
jne 0x1bf51
movq -0x10(%rax), %rax
cmpb $0x2, (%rax)
jne 0x1bf51
movq 0x8(%rax), %rax
movq 0x8(%rax), %rbx
addq $-0x10, %rbx
movq %rbx, 0x8(%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x11430
movq %rbx, %rdi
callq 0x11e20
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7d80(%rip), %rdi # 0x23ce3
leaq 0x590d(%rip), %rsi # 0x21877
leaq 0x7fdc(%rip), %rcx # 0x23f4d
movl $0x248c, %edx # imm = 0x248C
callq 0x11610
leaq 0x7b12(%rip), %rdi # 0x23a94
leaq 0x58ee(%rip), %rsi # 0x21877
leaq 0x7fbd(%rip), %rcx # 0x23f4d
movl $0x248d, %edx # imm = 0x248D
callq 0x11610
callq 0x11310
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE9end_arrayEv:
push rbp
push r14
push rbx
sub rsp, 20h
mov rbx, rdi
mov rax, [rdi+10h]
mov rcx, [rax-8]
mov bpl, 1
test rcx, rcx
jz short loc_1BED1
sub rax, [rbx+8]
shr rax, 3
dec eax
mov [rsp+38h+var_2C], eax
mov [rsp+38h+var_2D], 3
cmp qword ptr [rbx+90h], 0
jz loc_1BF9A
lea rdi, [rbx+80h]
lea rsi, [rsp+38h+var_2C]
lea rdx, [rsp+38h+var_2D]
call qword ptr [rbx+98h]
test al, al
jnz short loc_1BED1
lea rsi, [rbx+0A8h]
lea r14, [rsp+38h+var_28]
mov rdi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, [rbx+10h]
mov rdi, [rax-8]
mov rsi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
xor ebp, ebp
mov rdi, r14
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::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_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::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_1BED1:
mov rcx, [rbx+8]
mov rax, [rbx+10h]
cmp rcx, rax
jz short loc_1BF5C
mov rdx, [rbx+30h]
mov esi, [rbx+38h]
cmp [rbx+20h], rdx
setz dil
test esi, esi
setz r8b
and r8b, dil
cmp r8b, 1
jz short loc_1BF7B
lea rdi, [rax-8]
mov [rbx+10h], rdi
sub esi, 1
mov [rbx+38h], esi
jnb short loc_1BF1B
mov dword ptr [rbx+38h], 3Fh ; '?'
add rdx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rdx
loc_1BF1B:
cmp rcx, rdi
setz cl
or bpl, cl
jnz short loc_1BF51
mov rax, [rax-10h]
cmp byte ptr [rax], 2
jnz short loc_1BF51
mov rax, [rax+8]
mov rbx, [rax+8]
add rbx, 0FFFFFFFFFFFFFFF0h
mov [rax+8], rbx
mov rdi, rbx
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::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_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::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_1BF51:
mov al, 1
add rsp, 20h
pop rbx
pop r14
pop rbp
retn
loc_1BF5C:
lea rdi, aRefStackEmpty; "!ref_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolNlohmannDe_3; "bool nlohmann::detail::json_sax_dom_cal"...
mov edx, 248Ch
call ___assert_fail
loc_1BF7B:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolNlohmannDe_3; "bool nlohmann::detail::json_sax_dom_cal"...
mov edx, 248Dh
call ___assert_fail
loc_1BF9A:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
| char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,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>>>::end_array(
long long a1)
{
long long v1; // rax
char v2; // bp
long long v3; // rcx
long long v4; // rax
long long v5; // rdx
int v6; // esi
long long v7; // rax
long long v8; // rax
long long v9; // rbx
char v11; // [rsp+Bh] [rbp-2Dh] BYREF
int v12; // [rsp+Ch] [rbp-2Ch] BYREF
_BYTE v13[40]; // [rsp+10h] [rbp-28h] BYREF
v1 = *(_QWORD *)(a1 + 16);
v2 = 1;
if ( *(_QWORD *)(v1 - 8) )
{
v12 = ((unsigned long long)(v1 - *(_QWORD *)(a1 + 8)) >> 3) - 1;
v11 = 3;
if ( !*(_QWORD *)(a1 + 144) )
std::__throw_bad_function_call();
if ( !(*(unsigned __int8 ( **)(long long, int *, char *))(a1 + 152))(a1 + 128, &v12, &v11) )
{
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v13,
a1 + 168);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL),
v13);
v2 = 0;
nlohmann::json_abi_v3_11_3::basic_json<std::map,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,
0LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,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);
}
}
v3 = *(_QWORD *)(a1 + 8);
v4 = *(_QWORD *)(a1 + 16);
if ( v3 == v4 )
__assert_fail(
"!ref_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9356LL,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapt"
"er<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::end_array() [BasicJsonType = nlohmann::b"
"asic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *"
", std::basic_string<char>>>]");
v5 = *(_QWORD *)(a1 + 48);
v6 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v5 && v6 == 0 )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9357LL,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapt"
"er<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::end_array() [BasicJsonType = nlohmann::b"
"asic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *"
", std::basic_string<char>>>]");
*(_QWORD *)(a1 + 16) = v4 - 8;
*(_DWORD *)(a1 + 56) = v6 - 1;
if ( !v6 )
{
*(_DWORD *)(a1 + 56) = 63;
*(_QWORD *)(a1 + 48) = v5 - 8;
}
if ( !((v3 == v4 - 8) | (unsigned __int8)v2) )
{
v7 = *(_QWORD *)(v4 - 16);
if ( *(_BYTE *)v7 == 2 )
{
v8 = *(_QWORD *)(v7 + 8);
v9 = *(_QWORD *)(v8 + 8) - 16LL;
*(_QWORD *)(v8 + 8) = v9;
nlohmann::json_abi_v3_11_3::basic_json<std::map,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(
v9,
0LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v9);
}
}
return 1;
}
| end_array:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x10]
MOV RCX,qword ptr [RAX + -0x8]
MOV BPL,0x1
TEST RCX,RCX
JZ 0x0011bed1
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
DEC EAX
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x3
CMP qword ptr [RBX + 0x90],0x0
JZ 0x0011bf9a
LEA RDI,[RBX + 0x80]
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JNZ 0x0011bed1
LEA RSI,[RBX + 0xa8]
LEA R14,[RSP + 0x10]
MOV RDI,R14
CALL 0x001116c0
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,R14
CALL 0x00111490
XOR EBP,EBP
MOV RDI,R14
XOR ESI,ESI
CALL 0x00111430
MOV RDI,R14
CALL 0x00111e20
LAB_0011bed1:
MOV RCX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RBX + 0x10]
CMP RCX,RAX
JZ 0x0011bf5c
MOV RDX,qword ptr [RBX + 0x30]
MOV ESI,dword ptr [RBX + 0x38]
CMP qword ptr [RBX + 0x20],RDX
SETZ DIL
TEST ESI,ESI
SETZ R8B
AND R8B,DIL
CMP R8B,0x1
JZ 0x0011bf7b
LEA RDI,[RAX + -0x8]
MOV qword ptr [RBX + 0x10],RDI
SUB ESI,0x1
MOV dword ptr [RBX + 0x38],ESI
JNC 0x0011bf1b
MOV dword ptr [RBX + 0x38],0x3f
ADD RDX,-0x8
MOV qword ptr [RBX + 0x30],RDX
LAB_0011bf1b:
CMP RCX,RDI
SETZ CL
OR BPL,CL
JNZ 0x0011bf51
MOV RAX,qword ptr [RAX + -0x10]
CMP byte ptr [RAX],0x2
JNZ 0x0011bf51
MOV RAX,qword ptr [RAX + 0x8]
MOV RBX,qword ptr [RAX + 0x8]
ADD RBX,-0x10
MOV qword ptr [RAX + 0x8],RBX
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00111430
MOV RDI,RBX
CALL 0x00111e20
LAB_0011bf51:
MOV AL,0x1
ADD RSP,0x20
POP RBX
POP R14
POP RBP
RET
LAB_0011bf5c:
LEA RDI,[0x123ce3]
LEA RSI,[0x121877]
LEA RCX,[0x123f4d]
MOV EDX,0x248c
CALL 0x00111610
LAB_0011bf7b:
LEA RDI,[0x123a94]
LEA RSI,[0x121877]
LEA RCX,[0x123f4d]
MOV EDX,0x248d
CALL 0x00111610
LAB_0011bf9a:
CALL 0x00111310
NOP
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, 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 > > >::end_array() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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>>>
::end_array(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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)
{
int iVar1;
long lVar2;
byte bVar3;
char cVar4;
out_of_range *this_00;
out_of_range *poVar5;
data *this_01;
int1 local_2d;
int local_2c;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_28 [16];
poVar5 = *(out_of_range **)(*(long *)(this + 0x10) + -8);
bVar3 = 1;
if (poVar5 != (out_of_range *)0x0) {
local_2c = (int)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3) + -1;
local_2d = 3;
if (*(long *)(this + 0x90) == 0) {
std::__throw_bad_function_call();
this[0x78] = (json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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>>>
)0x1;
if (this[0xa0] !=
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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>>>
)0x1) {
return 0;
}
this_00 = (out_of_range *)__cxa_allocate_exception(0x20);
out_of_range::out_of_range(this_00,poVar5);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0012bfb0,PTR__exception_0012bf50);
}
cVar4 = (**(code **)(this + 0x98))(this + 0x80,&local_2c,&local_2d);
if (cVar4 == '\0') {
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_28,(basic_json *)(this + 0xa8));
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(*(long *)(this + 0x10) + -8),local_28);
bVar3 = 0;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_28,0));
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_28);
}
}
lVar2 = *(long *)(this + 0x10);
if (*(long *)(this + 8) != lVar2) {
iVar1 = *(int *)(this + 0x38);
if (iVar1 != 0 || *(long *)(this + 0x20) != *(long *)(this + 0x30)) {
*(long *)(this + 0x10) = lVar2 + -8;
*(int *)(this + 0x38) = iVar1 + -1;
if (iVar1 == 0) {
*(int4 *)(this + 0x38) = 0x3f;
*(long *)(this + 0x30) = *(long *)(this + 0x30) + -8;
}
if ((!(bool)(bVar3 | *(long *)(this + 8) == lVar2 + -8)) &&
(**(char **)(lVar2 + -0x10) == '\x02')) {
lVar2 = *(long *)(*(char **)(lVar2 + -0x10) + 8);
this_01 = (data *)(*(long *)(lVar2 + 8) + -0x10);
*(data **)(lVar2 + 8) = this_01;
basic_json<std::map,std::vector,std::__cxx11::string,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(this_01,0));
basic_json<std::map,std::vector,std::__cxx11::string,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(this_01);
}
return 1;
}
/* WARNING: Subroutine does not return */
__assert_fail("!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x248d,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::end_array() [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>]"
);
}
/* WARNING: Subroutine does not return */
__assert_fail("!ref_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x248c,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::end_array() [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>]"
);
}
| |
26,095 | mysql_close_start | eloqsql/libmariadb/libmariadb/mariadb_async.c | MK_ASYNC_CONT_BODY_VOID_RETURN(sock)
}
int STDCALL
mysql_close_start(MYSQL *sock)
{
int res;
/* It is legitimate to have NULL sock argument, which will do nothing. */
if (sock && sock->net.pvio)
{
res= mysql_close_slow_part_start(sock);
/* If we need to block, return now and do the rest in mysql_close_cont(). */
if (res)
return res;
}
mysql_close(sock);
return 0;
} | O3 | c | mysql_close_start:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x29bb2
cmpq $0x0, (%rbx)
je 0x29bb2
movq %rbx, %rdi
callq 0x299d6
testl %eax, %eax
jne 0x29bbc
movq %rbx, %rdi
callq 0x19d7c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_close_start:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
test rdi, rdi
jz short loc_29BB2
cmp qword ptr [rbx], 0
jz short loc_29BB2
mov rdi, rbx
call mysql_close_slow_part_start
test eax, eax
jnz short loc_29BBC
loc_29BB2:
mov rdi, rbx
call mysql_close
xor eax, eax
loc_29BBC:
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_close_start(_QWORD *a1)
{
long long result; // rax
if ( !a1 || !*a1 || (result = mysql_close_slow_part_start((long long)a1), !(_DWORD)result) )
{
mysql_close((long long)a1);
return 0LL;
}
return result;
}
| mysql_close_start:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
TEST RDI,RDI
JZ 0x00129bb2
CMP qword ptr [RBX],0x0
JZ 0x00129bb2
MOV RDI,RBX
CALL 0x001299d6
TEST EAX,EAX
JNZ 0x00129bbc
LAB_00129bb2:
MOV RDI,RBX
CALL 0x00119d7c
XOR EAX,EAX
LAB_00129bbc:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 mysql_close_start(long *param_1)
{
int8 uVar1;
if (((param_1 != (long *)0x0) && (*param_1 != 0)) &&
(uVar1 = mysql_close_slow_part_start(param_1), (int)uVar1 != 0)) {
return uVar1;
}
mysql_close(param_1);
return 0;
}
| |
26,096 | fmt::v10::appender fmt::v10::detail::fill_n<fmt::v10::appender, unsigned long, char>(fmt::v10::appender, unsigned long, char const&) | AlayaLite/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h | FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value)
-> OutputIt {
for (Size i = 0; i < count; ++i) *out++ = value;
return out;
} | O3 | c | fmt::v10::appender fmt::v10::detail::fill_n<fmt::v10::appender, unsigned long, char>(fmt::v10::appender, unsigned long, char const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x435c7
movq %rdx, %rbx
movq %rsi, %r15
movq 0x10(%r14), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%r14)
jae 0x435b5
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq 0x10(%r14), %rax
leaq 0x1(%rax), %rsi
movb (%rbx), %cl
movq 0x8(%r14), %rdx
movq %rsi, 0x10(%r14)
movb %cl, (%rdx,%rax)
decq %r15
jne 0x43597
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| _ZN3fmt3v106detail6fill_nINS0_8appenderEmcEET_S4_T0_RKT1_:
push r15
push r14
push rbx
mov r14, rdi
test rsi, rsi
jz short loc_435C7
mov rbx, rdx
mov r15, rsi
loc_43597:
mov rax, [r14+10h]
lea rsi, [rax+1]
cmp [r14+18h], rsi
jnb short loc_435B5
mov rax, [r14]
mov rdi, r14
call qword ptr [rax]
mov rax, [r14+10h]
lea rsi, [rax+1]
loc_435B5:
mov cl, [rbx]
mov rdx, [r14+8]
mov [r14+10h], rsi
mov [rdx+rax], cl
dec r15
jnz short loc_43597
loc_435C7:
mov rax, r14
pop rbx
pop r14
pop r15
retn
| long long fmt::v10::detail::fill_n<fmt::v10::appender,unsigned long,char>(long long a1, long long a2, char *a3)
{
long long v4; // r15
long long v5; // rax
long long v6; // rsi
char v7; // cl
long long v8; // rdx
if ( a2 )
{
v4 = a2;
do
{
v5 = *(_QWORD *)(a1 + 16);
v6 = v5 + 1;
if ( *(_QWORD *)(a1 + 24) < (unsigned long long)(v5 + 1) )
{
(**(void ( ***)(long long))a1)(a1);
v5 = *(_QWORD *)(a1 + 16);
v6 = v5 + 1;
}
v7 = *a3;
v8 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 16) = v6;
*(_BYTE *)(v8 + v5) = v7;
--v4;
}
while ( v4 );
}
return a1;
}
| fill_n<fmt::v10::appender,unsigned_long,char>:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDI
TEST RSI,RSI
JZ 0x001435c7
MOV RBX,RDX
MOV R15,RSI
LAB_00143597:
MOV RAX,qword ptr [R14 + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [R14 + 0x18],RSI
JNC 0x001435b5
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX]
MOV RAX,qword ptr [R14 + 0x10]
LEA RSI,[RAX + 0x1]
LAB_001435b5:
MOV CL,byte ptr [RBX]
MOV RDX,qword ptr [R14 + 0x8]
MOV qword ptr [R14 + 0x10],RSI
MOV byte ptr [RDX + RAX*0x1],CL
DEC R15
JNZ 0x00143597
LAB_001435c7:
MOV RAX,R14
POP RBX
POP R14
POP R15
RET
|
/* fmt::v10::appender fmt::v10::detail::fill_n<fmt::v10::appender, unsigned long,
char>(fmt::v10::appender, unsigned long, char const&) */
int8 *
fmt::v10::detail::fill_n<fmt::v10::appender,unsigned_long,char>
(int8 *param_1,long param_2,int1 *param_3)
{
int1 uVar1;
long lVar2;
ulong uVar3;
if (param_2 != 0) {
do {
lVar2 = param_1[2];
uVar3 = lVar2 + 1;
if ((ulong)param_1[3] < uVar3) {
(**(code **)*param_1)(param_1);
lVar2 = param_1[2];
uVar3 = lVar2 + 1;
}
uVar1 = *param_3;
param_1[2] = uVar3;
*(int1 *)(param_1[1] + lVar2) = uVar1;
param_2 = param_2 + -1;
} while (param_2 != 0);
}
return param_1;
}
| |
26,097 | bf_integer_from_radix_rec | bluesky950520[P]quickjs/libbf.c | static int bf_integer_from_radix_rec(bf_t *r, const limb_t *tab,
limb_t n, int level, limb_t n0,
limb_t radix, bf_t *pow_tab)
{
int ret;
if (n == 1) {
ret = bf_set_ui(r, tab[0]);
} else {
bf_t T_s, *T = &T_s, *B;
limb_t n1, n2;
n2 = (((n0 * 2) >> (level + 1)) + 1) / 2;
n1 = n - n2;
// printf("level=%d n0=%ld n1=%ld n2=%ld\n", level, n0, n1, n2);
B = &pow_tab[level];
if (B->len == 0) {
ret = bf_pow_ui_ui(B, radix, n2, BF_PREC_INF, BF_RNDZ);
if (ret)
return ret;
}
ret = bf_integer_from_radix_rec(r, tab + n2, n1, level + 1, n0,
radix, pow_tab);
if (ret)
return ret;
ret = bf_mul(r, r, B, BF_PREC_INF, BF_RNDZ);
if (ret)
return ret;
bf_init(r->ctx, T);
ret = bf_integer_from_radix_rec(T, tab, n2, level + 1, n0,
radix, pow_tab);
if (!ret)
ret = bf_add(r, r, T, BF_PREC_INF, BF_RNDZ);
bf_delete(T);
}
return ret;
// bf_print_str(" r=", r);
} | O1 | c | bf_integer_from_radix_rec:
movq %rdi, %r10
cmpq $0x1, %rdx
jne 0x901fc
movq (%rsi), %rsi
movq %r10, %rdi
jmp 0x83ea7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %eax
movq %rdx, %rbp
leaq (%r8,%r8), %r13
leal 0x1(%rax), %r11d
movl %r11d, %ecx
shrq %cl, %r13
movq 0x90(%rsp), %rcx
incq %r13
shrq %r13
cltq
leaq (%rax,%rax,4), %rax
leaq (%rcx,%rax,8), %r15
cmpq $0x0, 0x18(%r15)
movq %r10, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
je 0x90342
movl %r11d, 0x14(%rsp)
subq %r13, %rbp
movq %rsi, %rbx
leaq (%rsi,%r13,8), %rsi
movq %rcx, (%rsp)
movq %r10, %rdi
movq %rbp, %rdx
movl %r11d, %ecx
movq %r8, %r12
movq %r9, %rbp
callq 0x901e8
testl %eax, %eax
jne 0x9038e
movq %rbx, 0x8(%rsp)
movq %r12, 0x28(%rsp)
movabsq $0x3fffffffffffffff, %r12 # imm = 0x3FFFFFFFFFFFFFFF
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0x85afd
testl %eax, %eax
jne 0x9038e
movq (%rbx), %rax
leaq 0x30(%rsp), %rdi
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rsi
movq %r13, %rdx
movl 0x14(%rsp), %ecx
movq 0x28(%rsp), %r8
movq %rbp, %r9
callq 0x901e8
movl %eax, %r14d
testl %eax, %eax
jne 0x90324
leaq -0x9348(%rip), %r9 # 0x86fc0
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r12, %rcx
movl $0x1, %r8d
callq 0x86f26
movl %eax, %r14d
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x90391
movq 0x50(%rsp), %rsi
testq %rsi, %rsi
je 0x90391
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
jmp 0x90391
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
movq %r15, %rdi
movq %rsi, 0x8(%rsp)
movq %r9, %rsi
movq %r13, %rdx
movq %r8, %r12
movl $0x1, %r8d
movq %r9, %r14
movl %r11d, %ebx
callq 0x880da
movq 0x18(%rsp), %rcx
movl %ebx, %r11d
movq 0x8(%rsp), %rsi
movq %r12, %r8
movq 0x20(%rsp), %r10
movq %r14, %r9
testl %eax, %eax
je 0x9024a
movl %eax, %r14d
movl %r14d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| bf_integer_from_radix_rec:
mov r10, rdi
cmp rdx, 1
jnz short loc_901FC
mov rsi, [rsi]
mov rdi, r10
jmp bf_set_ui
loc_901FC:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov eax, ecx
mov rbp, rdx
lea r13, [r8+r8]
lea r11d, [rax+1]
mov ecx, r11d
shr r13, cl
mov rcx, [rsp+88h+arg_0]
inc r13
shr r13, 1
cdqe
lea rax, [rax+rax*4]
lea r15, [rcx+rax*8]
cmp qword ptr [r15+18h], 0
mov [rsp+88h+var_68], r10
mov [rsp+88h+var_70], rcx
jz loc_90342
loc_9024A:
mov [rsp+88h+var_74], r11d
sub rbp, r13
mov rbx, rsi
lea rsi, [rsi+r13*8]
mov [rsp+88h+var_88], rcx
mov rdi, r10
mov rdx, rbp
mov ecx, r11d
mov r12, r8
mov rbp, r9
call bf_integer_from_radix_rec
test eax, eax
jnz loc_9038E
mov [rsp+88h+var_80], rbx
mov [rsp+88h+var_60], r12
mov r12, 3FFFFFFFFFFFFFFFh
mov rbx, [rsp+88h+var_68]
mov rdi, rbx
mov rsi, rbx
mov rdx, r15
mov rcx, r12
mov r8d, 1
call bf_mul
test eax, eax
jnz loc_9038E
mov rax, [rbx]
lea rdi, [rsp+88h+var_58]
mov [rdi], rax
mov dword ptr [rdi+8], 0
mov rax, 8000000000000000h
mov [rdi+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [rdi+18h], xmm0
mov rax, [rsp+88h+var_70]
mov [rsp+88h+var_88], rax
mov rsi, [rsp+88h+var_80]
mov rdx, r13
mov ecx, [rsp+88h+var_74]
mov r8, [rsp+88h+var_60]
mov r9, rbp
call bf_integer_from_radix_rec
mov r14d, eax
test eax, eax
jnz short loc_90324
lea r9, __bf_add
lea rdx, [rsp+88h+var_58]
mov rdi, rbx
mov rsi, rbx
mov rcx, r12
mov r8d, 1
call bf_op2
mov r14d, eax
loc_90324:
mov rax, [rsp+88h+var_58]
test rax, rax
jz short loc_90391
mov rsi, [rsp+88h+var_38]
test rsi, rsi
jz short loc_90391
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
jmp short loc_90391
loc_90342:
mov rcx, 3FFFFFFFFFFFFFFFh
mov rdi, r15
mov [rsp+88h+var_80], rsi
mov rsi, r9
mov rdx, r13
mov r12, r8
mov r8d, 1
mov r14, r9
mov ebx, r11d
call bf_pow_ui_ui
mov rcx, [rsp+88h+var_70]
mov r11d, ebx
mov rsi, [rsp+88h+var_80]
mov r8, r12
mov r10, [rsp+88h+var_68]
mov r9, r14
test eax, eax
jz loc_9024A
loc_9038E:
mov r14d, eax
loc_90391:
mov eax, r14d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long bf_integer_from_radix_rec(
__int128 *a1,
unsigned long long *a2,
long long a3,
int a4,
long long a5,
unsigned long long a6,
long long a7)
{
int v7; // r10d
int v10; // ebp
int v11; // r11d
unsigned long long v12; // r13
long long v13; // rcx
unsigned long long v14; // r13
long long v15; // rax
long long v16; // r15
int v17; // edx
int v18; // r12d
int v19; // ebp
unsigned int v20; // eax
unsigned int v21; // r14d
int v22; // r12d
int v23; // r14d
int v24; // ebx
int v25; // [rsp+14h] [rbp-74h]
__int128 v26; // [rsp+30h] [rbp-58h] BYREF
unsigned long long v27; // [rsp+40h] [rbp-48h]
__int128 v28; // [rsp+48h] [rbp-40h]
v7 = (int)a1;
if ( a3 == 1 )
return bf_set_ui((_QWORD **)a1, *a2);
v10 = a3;
v11 = a4 + 1;
v12 = (unsigned long long)(2 * a5) >> ((unsigned __int8)a4 + 1);
v13 = a7;
v14 = (v12 + 1) >> 1;
v15 = 5LL * a4;
v16 = a7 + 8 * v15;
if ( !*(_QWORD *)(v16 + 24) )
{
v22 = a5;
v23 = a6;
v24 = v11;
v20 = bf_pow_ui_ui((_QWORD **)(a7 + 8 * v15), a6, v14, 0x3FFFFFFFFFFFFFFFLL, 1u);
v13 = a7;
v11 = v24;
LODWORD(a5) = v22;
v7 = (int)a1;
LODWORD(a6) = v23;
if ( v20 )
return v20;
}
v25 = v11;
v17 = v10 - v14;
v18 = a5;
v19 = a6;
v20 = bf_integer_from_radix_rec(v7, (int)a2 + 8 * (int)v14, v17, v11, a5, a6, v13);
if ( v20 )
return v20;
v20 = bf_mul(a1, (long long)a1, v16, 0x3FFFFFFFFFFFFFFFLL, 1u);
if ( v20 )
{
return v20;
}
else
{
*(_QWORD *)&v26 = *(_QWORD *)a1;
DWORD2(v26) = 0;
v27 = 0x8000000000000000LL;
v28 = 0LL;
v21 = bf_integer_from_radix_rec((unsigned int)&v26, (_DWORD)a2, v14, v25, v18, v19, a7);
if ( !v21 )
v21 = bf_op2(a1, a1, &v26, 0x3FFFFFFFFFFFFFFFLL, 1LL, (long long ( *)(__int128 *))_bf_add);
if ( (_QWORD)v26 )
{
if ( *((_QWORD *)&v28 + 1) )
(*(void ( **)(_QWORD, _QWORD, _QWORD))(v26 + 8))(*(_QWORD *)v26, *((_QWORD *)&v28 + 1), 0LL);
}
}
return v21;
}
| bf_integer_from_radix_rec:
MOV R10,RDI
CMP RDX,0x1
JNZ 0x001901fc
MOV RSI,qword ptr [RSI]
MOV RDI,R10
JMP 0x00183ea7
LAB_001901fc:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV EAX,ECX
MOV RBP,RDX
LEA R13,[R8 + R8*0x1]
LEA R11D,[RAX + 0x1]
MOV ECX,R11D
SHR R13,CL
MOV RCX,qword ptr [RSP + 0x90]
INC R13
SHR R13,0x1
CDQE
LEA RAX,[RAX + RAX*0x4]
LEA R15,[RCX + RAX*0x8]
CMP qword ptr [R15 + 0x18],0x0
MOV qword ptr [RSP + 0x20],R10
MOV qword ptr [RSP + 0x18],RCX
JZ 0x00190342
LAB_0019024a:
MOV dword ptr [RSP + 0x14],R11D
SUB RBP,R13
MOV RBX,RSI
LEA RSI,[RSI + R13*0x8]
MOV qword ptr [RSP],RCX
MOV RDI,R10
MOV RDX,RBP
MOV ECX,R11D
MOV R12,R8
MOV RBP,R9
CALL 0x001901e8
TEST EAX,EAX
JNZ 0x0019038e
MOV qword ptr [RSP + 0x8],RBX
MOV qword ptr [RSP + 0x28],R12
MOV R12,0x3fffffffffffffff
MOV RBX,qword ptr [RSP + 0x20]
MOV RDI,RBX
MOV RSI,RBX
MOV RDX,R15
MOV RCX,R12
MOV R8D,0x1
CALL 0x00185afd
TEST EAX,EAX
JNZ 0x0019038e
MOV RAX,qword ptr [RBX]
LEA RDI,[RSP + 0x30]
MOV qword ptr [RDI],RAX
MOV dword ptr [RDI + 0x8],0x0
MOV RAX,-0x8000000000000000
MOV qword ptr [RDI + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x18],XMM0
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP],RAX
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R13
MOV ECX,dword ptr [RSP + 0x14]
MOV R8,qword ptr [RSP + 0x28]
MOV R9,RBP
CALL 0x001901e8
MOV R14D,EAX
TEST EAX,EAX
JNZ 0x00190324
LEA R9,[0x186fc0]
LEA RDX,[RSP + 0x30]
MOV RDI,RBX
MOV RSI,RBX
MOV RCX,R12
MOV R8D,0x1
CALL 0x00186f26
MOV R14D,EAX
LAB_00190324:
MOV RAX,qword ptr [RSP + 0x30]
TEST RAX,RAX
JZ 0x00190391
MOV RSI,qword ptr [RSP + 0x50]
TEST RSI,RSI
JZ 0x00190391
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
JMP 0x00190391
LAB_00190342:
MOV RCX,0x3fffffffffffffff
MOV RDI,R15
MOV qword ptr [RSP + 0x8],RSI
MOV RSI,R9
MOV RDX,R13
MOV R12,R8
MOV R8D,0x1
MOV R14,R9
MOV EBX,R11D
CALL 0x001880da
MOV RCX,qword ptr [RSP + 0x18]
MOV R11D,EBX
MOV RSI,qword ptr [RSP + 0x8]
MOV R8,R12
MOV R10,qword ptr [RSP + 0x20]
MOV R9,R14
TEST EAX,EAX
JZ 0x0019024a
LAB_0019038e:
MOV R14D,EAX
LAB_00190391:
MOV EAX,R14D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong bf_integer_from_radix_rec
(int8 *param_1,int8 *param_2,long param_3,int param_4,long param_5,
int8 param_6,long param_7)
{
long lVar1;
uint uVar2;
ulong uVar3;
int iVar4;
int8 *local_58;
int4 local_50;
int8 local_48;
int8 local_40;
long lStack_38;
if (param_3 == 1) {
uVar3 = bf_set_ui(param_1,*param_2);
return uVar3;
}
iVar4 = param_4 + 1;
uVar3 = ((ulong)(param_5 * 2) >> ((byte)iVar4 & 0x3f)) + 1 >> 1;
lVar1 = param_7 + (long)param_4 * 0x28;
if ((((*(long *)(lVar1 + 0x18) != 0) ||
(uVar2 = bf_pow_ui_ui(lVar1,param_6,uVar3,0x3fffffffffffffff,1), uVar2 == 0)) &&
(uVar2 = bf_integer_from_radix_rec
(param_1,param_2 + uVar3,param_3 - uVar3,iVar4,param_5,param_6,param_7),
uVar2 == 0)) && (uVar2 = bf_mul(param_1,param_1,lVar1,0x3fffffffffffffff,1), uVar2 == 0)) {
local_58 = (int8 *)*param_1;
local_50 = 0;
local_48 = 0x8000000000000000;
local_40 = 0;
lStack_38 = 0;
uVar2 = bf_integer_from_radix_rec(&local_58,param_2,uVar3,iVar4,param_5,param_6,param_7);
if (uVar2 == 0) {
uVar2 = bf_op2(param_1,param_1,&local_58,0x3fffffffffffffff,1,__bf_add);
}
uVar3 = (ulong)uVar2;
if (local_58 == (int8 *)0x0) {
return uVar3;
}
if (lStack_38 == 0) {
return uVar3;
}
(*(code *)local_58[1])(*local_58,lStack_38,0);
return uVar3;
}
return (ulong)uVar2;
}
| |
26,098 | bf_integer_from_radix_rec | bluesky950520[P]quickjs/libbf.c | static int bf_integer_from_radix_rec(bf_t *r, const limb_t *tab,
limb_t n, int level, limb_t n0,
limb_t radix, bf_t *pow_tab)
{
int ret;
if (n == 1) {
ret = bf_set_ui(r, tab[0]);
} else {
bf_t T_s, *T = &T_s, *B;
limb_t n1, n2;
n2 = (((n0 * 2) >> (level + 1)) + 1) / 2;
n1 = n - n2;
// printf("level=%d n0=%ld n1=%ld n2=%ld\n", level, n0, n1, n2);
B = &pow_tab[level];
if (B->len == 0) {
ret = bf_pow_ui_ui(B, radix, n2, BF_PREC_INF, BF_RNDZ);
if (ret)
return ret;
}
ret = bf_integer_from_radix_rec(r, tab + n2, n1, level + 1, n0,
radix, pow_tab);
if (ret)
return ret;
ret = bf_mul(r, r, B, BF_PREC_INF, BF_RNDZ);
if (ret)
return ret;
bf_init(r->ctx, T);
ret = bf_integer_from_radix_rec(T, tab, n2, level + 1, n0,
radix, pow_tab);
if (!ret)
ret = bf_add(r, r, T, BF_PREC_INF, BF_RNDZ);
bf_delete(T);
}
return ret;
// bf_print_str(" r=", r);
} | O3 | c | bf_integer_from_radix_rec:
movq %rdi, %r10
cmpq $0x1, %rdx
jne 0x92c67
movq (%rsi), %rsi
movq %r10, %rdi
jmp 0x868c8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %eax
movq %rdx, %rbp
leaq (%r8,%r8), %r13
leal 0x1(%rax), %r11d
movl %r11d, %ecx
shrq %cl, %r13
movq 0x90(%rsp), %rcx
incq %r13
shrq %r13
cltq
leaq (%rax,%rax,4), %rax
leaq (%rcx,%rax,8), %r15
cmpq $0x0, 0x18(%r15)
movq %r10, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
je 0x92dad
movl %r11d, 0x14(%rsp)
subq %r13, %rbp
movq %rsi, %rbx
leaq (%rsi,%r13,8), %rsi
movq %rcx, (%rsp)
movq %r10, %rdi
movq %rbp, %rdx
movl %r11d, %ecx
movq %r8, %r12
movq %r9, %rbp
callq 0x92c53
testl %eax, %eax
jne 0x92df9
movq %rbx, 0x8(%rsp)
movq %r12, 0x28(%rsp)
movabsq $0x3fffffffffffffff, %r12 # imm = 0x3FFFFFFFFFFFFFFF
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0x8853c
testl %eax, %eax
jne 0x92df9
movq (%rbx), %rax
leaq 0x30(%rsp), %rdi
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rsi
movq %r13, %rdx
movl 0x14(%rsp), %ecx
movq 0x28(%rsp), %r8
movq %rbp, %r9
callq 0x92c53
movl %eax, %r14d
testl %eax, %eax
jne 0x92d8f
leaq -0x92dc(%rip), %r9 # 0x89a97
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r12, %rcx
movl $0x1, %r8d
callq 0x899fd
movl %eax, %r14d
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x92dfc
movq 0x50(%rsp), %rsi
testq %rsi, %rsi
je 0x92dfc
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
jmp 0x92dfc
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
movq %r15, %rdi
movq %rsi, 0x8(%rsp)
movq %r9, %rsi
movq %r13, %rdx
movq %r8, %r12
movl $0x1, %r8d
movq %r9, %r14
movl %r11d, %ebx
callq 0x8ac50
movq 0x18(%rsp), %rcx
movl %ebx, %r11d
movq 0x8(%rsp), %rsi
movq %r12, %r8
movq 0x20(%rsp), %r10
movq %r14, %r9
testl %eax, %eax
je 0x92cb5
movl %eax, %r14d
movl %r14d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| bf_integer_from_radix_rec:
mov r10, rdi
cmp rdx, 1
jnz short loc_92C67
mov rsi, [rsi]
mov rdi, r10
jmp bf_set_ui
loc_92C67:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov eax, ecx
mov rbp, rdx
lea r13, [r8+r8]
lea r11d, [rax+1]
mov ecx, r11d
shr r13, cl
mov rcx, [rsp+88h+arg_0]
inc r13
shr r13, 1
cdqe
lea rax, [rax+rax*4]
lea r15, [rcx+rax*8]
cmp qword ptr [r15+18h], 0
mov [rsp+88h+var_68], r10
mov [rsp+88h+var_70], rcx
jz loc_92DAD
loc_92CB5:
mov [rsp+88h+var_74], r11d
sub rbp, r13
mov rbx, rsi
lea rsi, [rsi+r13*8]
mov [rsp+88h+var_88], rcx
mov rdi, r10
mov rdx, rbp
mov ecx, r11d
mov r12, r8
mov rbp, r9
call bf_integer_from_radix_rec
test eax, eax
jnz loc_92DF9
mov [rsp+88h+var_80], rbx
mov [rsp+88h+var_60], r12
mov r12, 3FFFFFFFFFFFFFFFh
mov rbx, [rsp+88h+var_68]
mov rdi, rbx
mov rsi, rbx
mov rdx, r15
mov rcx, r12
mov r8d, 1
call bf_mul
test eax, eax
jnz loc_92DF9
mov rax, [rbx]
lea rdi, [rsp+88h+var_58]
mov [rdi], rax
mov dword ptr [rdi+8], 0
mov rax, 8000000000000000h
mov [rdi+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [rdi+18h], xmm0
mov rax, [rsp+88h+var_70]
mov [rsp+88h+var_88], rax
mov rsi, [rsp+88h+var_80]
mov rdx, r13
mov ecx, [rsp+88h+var_74]
mov r8, [rsp+88h+var_60]
mov r9, rbp
call bf_integer_from_radix_rec
mov r14d, eax
test eax, eax
jnz short loc_92D8F
lea r9, __bf_add
lea rdx, [rsp+88h+var_58]
mov rdi, rbx
mov rsi, rbx
mov rcx, r12
mov r8d, 1
call bf_op2
mov r14d, eax
loc_92D8F:
mov rax, [rsp+88h+var_58]
test rax, rax
jz short loc_92DFC
mov rsi, [rsp+88h+var_38]
test rsi, rsi
jz short loc_92DFC
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
jmp short loc_92DFC
loc_92DAD:
mov rcx, 3FFFFFFFFFFFFFFFh
mov rdi, r15
mov [rsp+88h+var_80], rsi
mov rsi, r9
mov rdx, r13
mov r12, r8
mov r8d, 1
mov r14, r9
mov ebx, r11d
call bf_pow_ui_ui
mov rcx, [rsp+88h+var_70]
mov r11d, ebx
mov rsi, [rsp+88h+var_80]
mov r8, r12
mov r10, [rsp+88h+var_68]
mov r9, r14
test eax, eax
jz loc_92CB5
loc_92DF9:
mov r14d, eax
loc_92DFC:
mov eax, r14d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long bf_integer_from_radix_rec(
__int128 *a1,
unsigned long long *a2,
long long a3,
int a4,
long long a5,
unsigned long long a6,
long long a7)
{
int v7; // r10d
int v10; // ebp
int v11; // r11d
unsigned long long v12; // r13
long long v13; // rcx
unsigned long long v14; // r13
long long v15; // rax
long long v16; // r15
int v17; // edx
int v18; // r12d
int v19; // ebp
unsigned int v20; // eax
unsigned int v21; // r14d
int v22; // r12d
int v23; // r14d
int v24; // ebx
int v25; // [rsp+14h] [rbp-74h]
__int128 v26; // [rsp+30h] [rbp-58h] BYREF
unsigned long long v27; // [rsp+40h] [rbp-48h]
__int128 v28; // [rsp+48h] [rbp-40h]
v7 = (int)a1;
if ( a3 == 1 )
return bf_set_ui((_QWORD **)a1, *a2);
v10 = a3;
v11 = a4 + 1;
v12 = (unsigned long long)(2 * a5) >> ((unsigned __int8)a4 + 1);
v13 = a7;
v14 = (v12 + 1) >> 1;
v15 = 5LL * a4;
v16 = a7 + 8 * v15;
if ( !*(_QWORD *)(v16 + 24) )
{
v22 = a5;
v23 = a6;
v24 = v11;
v20 = bf_pow_ui_ui((_QWORD **)(a7 + 8 * v15), a6, v14, 0x3FFFFFFFFFFFFFFFLL, 1u);
v13 = a7;
v11 = v24;
LODWORD(a5) = v22;
v7 = (int)a1;
LODWORD(a6) = v23;
if ( v20 )
return v20;
}
v25 = v11;
v17 = v10 - v14;
v18 = a5;
v19 = a6;
v20 = bf_integer_from_radix_rec(v7, (int)a2 + 8 * (int)v14, v17, v11, a5, a6, v13);
if ( v20 )
return v20;
v20 = bf_mul(a1, (long long)a1, v16, 0x3FFFFFFFFFFFFFFFLL, 1u);
if ( v20 )
{
return v20;
}
else
{
*(_QWORD *)&v26 = *(_QWORD *)a1;
DWORD2(v26) = 0;
v27 = 0x8000000000000000LL;
v28 = 0LL;
v21 = bf_integer_from_radix_rec((unsigned int)&v26, (_DWORD)a2, v14, v25, v18, v19, a7);
if ( !v21 )
v21 = bf_op2(a1, a1, &v26, 0x3FFFFFFFFFFFFFFFLL, 1LL, (long long ( *)(__int128 *))_bf_add);
if ( (_QWORD)v26 )
{
if ( *((_QWORD *)&v28 + 1) )
(*(void ( **)(_QWORD, _QWORD, _QWORD))(v26 + 8))(*(_QWORD *)v26, *((_QWORD *)&v28 + 1), 0LL);
}
}
return v21;
}
| bf_integer_from_radix_rec:
MOV R10,RDI
CMP RDX,0x1
JNZ 0x00192c67
MOV RSI,qword ptr [RSI]
MOV RDI,R10
JMP 0x001868c8
LAB_00192c67:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV EAX,ECX
MOV RBP,RDX
LEA R13,[R8 + R8*0x1]
LEA R11D,[RAX + 0x1]
MOV ECX,R11D
SHR R13,CL
MOV RCX,qword ptr [RSP + 0x90]
INC R13
SHR R13,0x1
CDQE
LEA RAX,[RAX + RAX*0x4]
LEA R15,[RCX + RAX*0x8]
CMP qword ptr [R15 + 0x18],0x0
MOV qword ptr [RSP + 0x20],R10
MOV qword ptr [RSP + 0x18],RCX
JZ 0x00192dad
LAB_00192cb5:
MOV dword ptr [RSP + 0x14],R11D
SUB RBP,R13
MOV RBX,RSI
LEA RSI,[RSI + R13*0x8]
MOV qword ptr [RSP],RCX
MOV RDI,R10
MOV RDX,RBP
MOV ECX,R11D
MOV R12,R8
MOV RBP,R9
CALL 0x00192c53
TEST EAX,EAX
JNZ 0x00192df9
MOV qword ptr [RSP + 0x8],RBX
MOV qword ptr [RSP + 0x28],R12
MOV R12,0x3fffffffffffffff
MOV RBX,qword ptr [RSP + 0x20]
MOV RDI,RBX
MOV RSI,RBX
MOV RDX,R15
MOV RCX,R12
MOV R8D,0x1
CALL 0x0018853c
TEST EAX,EAX
JNZ 0x00192df9
MOV RAX,qword ptr [RBX]
LEA RDI,[RSP + 0x30]
MOV qword ptr [RDI],RAX
MOV dword ptr [RDI + 0x8],0x0
MOV RAX,-0x8000000000000000
MOV qword ptr [RDI + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x18],XMM0
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP],RAX
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R13
MOV ECX,dword ptr [RSP + 0x14]
MOV R8,qword ptr [RSP + 0x28]
MOV R9,RBP
CALL 0x00192c53
MOV R14D,EAX
TEST EAX,EAX
JNZ 0x00192d8f
LEA R9,[0x189a97]
LEA RDX,[RSP + 0x30]
MOV RDI,RBX
MOV RSI,RBX
MOV RCX,R12
MOV R8D,0x1
CALL 0x001899fd
MOV R14D,EAX
LAB_00192d8f:
MOV RAX,qword ptr [RSP + 0x30]
TEST RAX,RAX
JZ 0x00192dfc
MOV RSI,qword ptr [RSP + 0x50]
TEST RSI,RSI
JZ 0x00192dfc
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
JMP 0x00192dfc
LAB_00192dad:
MOV RCX,0x3fffffffffffffff
MOV RDI,R15
MOV qword ptr [RSP + 0x8],RSI
MOV RSI,R9
MOV RDX,R13
MOV R12,R8
MOV R8D,0x1
MOV R14,R9
MOV EBX,R11D
CALL 0x0018ac50
MOV RCX,qword ptr [RSP + 0x18]
MOV R11D,EBX
MOV RSI,qword ptr [RSP + 0x8]
MOV R8,R12
MOV R10,qword ptr [RSP + 0x20]
MOV R9,R14
TEST EAX,EAX
JZ 0x00192cb5
LAB_00192df9:
MOV R14D,EAX
LAB_00192dfc:
MOV EAX,R14D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong bf_integer_from_radix_rec
(int8 *param_1,int8 *param_2,long param_3,int param_4,long param_5,
int8 param_6,long param_7)
{
long lVar1;
uint uVar2;
ulong uVar3;
int iVar4;
int8 *local_58;
int4 local_50;
int8 local_48;
int8 local_40;
long lStack_38;
if (param_3 == 1) {
uVar3 = bf_set_ui(param_1,*param_2);
return uVar3;
}
iVar4 = param_4 + 1;
uVar3 = ((ulong)(param_5 * 2) >> ((byte)iVar4 & 0x3f)) + 1 >> 1;
lVar1 = param_7 + (long)param_4 * 0x28;
if ((((*(long *)(lVar1 + 0x18) != 0) ||
(uVar2 = bf_pow_ui_ui(lVar1,param_6,uVar3,0x3fffffffffffffff,1), uVar2 == 0)) &&
(uVar2 = bf_integer_from_radix_rec
(param_1,param_2 + uVar3,param_3 - uVar3,iVar4,param_5,param_6,param_7),
uVar2 == 0)) && (uVar2 = bf_mul(param_1,param_1,lVar1,0x3fffffffffffffff,1), uVar2 == 0)) {
local_58 = (int8 *)*param_1;
local_50 = 0;
local_48 = 0x8000000000000000;
local_40 = 0;
lStack_38 = 0;
uVar2 = bf_integer_from_radix_rec(&local_58,param_2,uVar3,iVar4,param_5,param_6,param_7);
if (uVar2 == 0) {
uVar2 = bf_op2(param_1,param_1,&local_58,0x3fffffffffffffff,1,__bf_add);
}
uVar3 = (ulong)uVar2;
if (local_58 == (int8 *)0x0) {
return uVar3;
}
if (lStack_38 == 0) {
return uVar3;
}
(*(code *)local_58[1])(*local_58,lStack_38,0);
return uVar3;
}
return (ulong)uVar2;
}
| |
26,099 | mthd_my_skip_result | eloqsql/libmariadb/libmariadb/mariadb_lib.c | void mthd_my_skip_result(MYSQL *mysql)
{
ulong pkt_len;
do {
pkt_len= ma_net_safe_read(mysql);
if (pkt_len == packet_error)
break;
} while (pkt_len > 8 || mysql->net.read_pos[0] != 254);
return;
} | O3 | c | mthd_my_skip_result:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x152fb
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpq %r14, %rax
je 0x15fb1
cmpq $0x8, %rax
ja 0x15fa7
movq 0x20(%rbx), %rax
cmpb $-0x2, (%rax)
je 0x15fb1
movq %rbx, %rdi
callq 0x152fb
jmp 0x15f93
popq %rbx
popq %r14
popq %rbp
retq
| mthd_my_skip_result:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
call ma_net_safe_read
mov r14d, 0FFFFFFFFh
loc_15F93:
cmp rax, r14
jz short loc_15FB1
cmp rax, 8
ja short loc_15FA7
mov rax, [rbx+20h]
cmp byte ptr [rax], 0FEh
jz short loc_15FB1
loc_15FA7:
mov rdi, rbx
call ma_net_safe_read
jmp short loc_15F93
loc_15FB1:
pop rbx
pop r14
pop rbp
retn
| _BYTE * mthd_my_skip_result(long long a1, long long a2, long long a3, long long a4, unsigned long long a5, int a6)
{
_BYTE *result; // rax
while ( 1 )
{
result = (_BYTE *)ma_net_safe_read(a1, a2, a3, a4, a5, a6);
if ( result == (_BYTE *)0xFFFFFFFFLL )
break;
if ( (unsigned long long)result <= 8 )
{
result = *(_BYTE **)(a1 + 32);
if ( *result == 0xFE )
break;
}
}
return result;
}
| mthd_my_skip_result:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
CALL 0x001152fb
MOV R14D,0xffffffff
LAB_00115f93:
CMP RAX,R14
JZ 0x00115fb1
CMP RAX,0x8
JA 0x00115fa7
MOV RAX,qword ptr [RBX + 0x20]
CMP byte ptr [RAX],0xfe
JZ 0x00115fb1
LAB_00115fa7:
MOV RDI,RBX
CALL 0x001152fb
JMP 0x00115f93
LAB_00115fb1:
POP RBX
POP R14
POP RBP
RET
|
void mthd_my_skip_result(long param_1)
{
ulong uVar1;
uVar1 = ma_net_safe_read();
while ((uVar1 != 0xffffffff && ((8 < uVar1 || (**(char **)(param_1 + 0x20) != -2))))) {
uVar1 = ma_net_safe_read(param_1);
}
return;
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.