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,300 | make_type | eloqsql/mysys/typelib.c | void make_type(register char * to, register uint nr,
register TYPELIB *typelib)
{
DBUG_ENTER("make_type");
if (!nr)
to[0]=0;
else
(void) strmov(to,get_type(typelib,nr-1));
DBUG_VOID_RETURN;
} | O3 | c | make_type:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
je 0xaff1f
decl %esi
leaq 0x37bd9(%rip), %rax # 0xe7adc
cmpl %esi, (%rdx)
jbe 0xaff16
movq 0x10(%rdx), %rcx
testq %rcx, %rcx
je 0xaff16
movl %esi, %eax
movq (%rcx,%rax,8), %rax
movq %rax, %rsi
popq %rbp
jmp 0x2a340
movb $0x0, (%rdi)
popq %rbp
retq
| make_type:
push rbp
mov rbp, rsp
test esi, esi
jz short loc_AFF1F
dec esi
lea rax, asc_E7ADC; "?"
cmp [rdx], esi
jbe short loc_AFF16
mov rcx, [rdx+10h]
test rcx, rcx
jz short loc_AFF16
mov eax, esi
mov rax, [rcx+rax*8]
loc_AFF16:
mov rsi, rax
pop rbp
jmp _strcpy
loc_AFF1F:
mov byte ptr [rdi], 0
pop rbp
retn
| void make_type(_BYTE *a1, int a2, long long a3)
{
unsigned int v3; // esi
const char *v4; // rax
long long v5; // rcx
if ( a2 )
{
v3 = a2 - 1;
v4 = "?";
if ( *(_DWORD *)a3 > v3 )
{
v5 = *(_QWORD *)(a3 + 16);
if ( v5 )
v4 = *(const char **)(v5 + 8LL * v3);
}
strcpy(a1, v4);
}
else
{
*a1 = 0;
}
}
| make_type:
PUSH RBP
MOV RBP,RSP
TEST ESI,ESI
JZ 0x001aff1f
DEC ESI
LEA RAX,[0x1e7adc]
CMP dword ptr [RDX],ESI
JBE 0x001aff16
MOV RCX,qword ptr [RDX + 0x10]
TEST RCX,RCX
JZ 0x001aff16
MOV EAX,ESI
MOV RAX,qword ptr [RCX + RAX*0x8]
LAB_001aff16:
MOV RSI,RAX
POP RBP
JMP 0x0012a340
LAB_001aff1f:
MOV byte ptr [RDI],0x0
POP RBP
RET
|
void make_type(char *param_1,int param_2,uint *param_3)
{
char *__src;
if (param_2 != 0) {
__src = "?";
if ((param_2 - 1U < *param_3) && (*(long *)(param_3 + 4) != 0)) {
__src = *(char **)(*(long *)(param_3 + 4) + (ulong)(param_2 - 1U) * 8);
}
strcpy(param_1,__src);
return;
}
*param_1 = '\0';
return;
}
| |
26,301 | evmone::instr::core::codecopy(evmone::StackTop, long, evmone::ExecutionState&) | corpus-core[P]colibri-stateless/build_O3/_deps/evmone_external-src/lib/evmone/instructions.hpp | inline Result codecopy(StackTop stack, int64_t gas_left, ExecutionState& state) noexcept
{
// TODO: Similar to calldatacopy().
const auto& mem_index = stack.pop();
const auto& input_index = stack.pop();
const auto& size = stack.pop();
if (!check_memory(gas_left, state.memory, mem_index, size))
return {EVMC_OUT_OF_GAS, gas_left};
const auto code_size = state.original_code.size();
const auto dst = static_cast<size_t>(mem_index);
const auto src = code_size < input_index ? code_size : static_cast<size_t>(input_index);
const auto s = static_cast<size_t>(size);
const auto copy_size = std::min(s, code_size - src);
if (const auto cost = copy_cost(s); (gas_left -= cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
// TODO: Add unit tests for each combination of conditions.
if (copy_size > 0)
std::memcpy(&state.memory[dst], &state.original_code[src], copy_size);
if (s - copy_size > 0)
std::memset(&state.memory[dst + copy_size], 0, s - copy_size);
return {EVMC_SUCCESS, gas_left};
} | O3 | cpp | evmone::instr::core::codecopy(evmone::StackTop, long, evmone::ExecutionState&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r8
movq %rdi, %r12
movdqu -0x40(%rdi), %xmm0
movdqu -0x30(%rdi), %xmm1
por %xmm0, %xmm1
leaq 0x8(%rdx), %r9
ptest %xmm1, %xmm1
je 0x3ff21
movq -0x30(%r12), %rax
orq -0x28(%r12), %rax
movl $0x3, %ebp
orq -0x38(%r12), %rax
jne 0x3ffd0
movq -0x40(%r12), %rax
movq %rax, %rcx
shrq $0x20, %rcx
jne 0x3ffd0
movq 0x10(%r12), %rcx
orq 0x18(%r12), %rcx
orq 0x8(%r12), %rcx
jne 0x3ffd0
movq (%r12), %rdx
movq %rdx, %rcx
shrq $0x20, %rcx
jne 0x3ffd0
addq %rax, %rdx
cmpq 0x10(%r15), %rdx
jbe 0x3ff18
movq %r8, %rdi
movq %r9, %rsi
movq %r9, %rbx
callq 0x3fbe5
movq %rbx, %r9
movq %rax, %r8
testq %r8, %r8
js 0x3ffd0
movq -0x10(%r12), %rax
movq -0x8(%r12), %rcx
xorl %edx, %edx
movq %rcx, %rsi
orq %rax, %rsi
movq -0x20(%r12), %rsi
cmoveq %rsi, %rax
cmoveq -0x18(%r12), %rcx
movq 0x68(%r15), %rbx
movl $0x0, %edi
cmoveq %rbx, %rdi
cmpq %rax, %rdi
sbbq %rcx, %rdx
movq -0x40(%r12), %r13
cmovbq %rbx, %rsi
subq %rsi, %rbx
cmpq %r13, %rbx
movq %r13, %r14
cmovbq %rbx, %r14
leaq 0x1f(%r13), %rax
shrq $0x5, %rax
leaq (%rax,%rax,2), %rax
subq %rax, %r8
js 0x3ffcb
movq (%r12), %r12
testq %r14, %r14
je 0x3ffa4
movq 0x8(%r15), %rdi
addq %r12, %rdi
addq 0x70(%r15), %rsi
movq %r14, %rdx
movq %r8, %r15
movq %r9, %rbp
callq 0x211a0
movq %rbp, %r9
movq %r15, %r8
xorl %ebp, %ebp
cmpq %rbx, %r13
jbe 0x3ffd0
addq (%r9), %r12
addq %r14, %r12
subq %r14, %r13
xorl %ebp, %ebp
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r8, %rbx
callq 0x21120
movq %rbx, %r8
jmp 0x3ffd0
movl $0x3, %ebp
movl %ebp, %eax
movq %r8, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN6evmone5instr4core8codecopyENS_8StackTopElRNS_14ExecutionStateE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov r8, rsi
mov r12, rdi
movdqu xmm0, xmmword ptr [rdi-40h]
movdqu xmm1, xmmword ptr [rdi-30h]
por xmm1, xmm0
lea r9, [rdx+8]
ptest xmm1, xmm1
jz short loc_3FF21
mov rax, [r12-30h]
or rax, [r12-28h]
mov ebp, 3
or rax, [r12-38h]
jnz loc_3FFD0
mov rax, [r12-40h]
mov rcx, rax
shr rcx, 20h
jnz loc_3FFD0
mov rcx, [r12+10h]
or rcx, [r12+18h]
or rcx, [r12+8]
jnz loc_3FFD0
mov rdx, [r12]
mov rcx, rdx
shr rcx, 20h; unsigned __int64
jnz loc_3FFD0
add rdx, rax; evmone::Memory *
cmp rdx, [r15+10h]
jbe short loc_3FF18
mov rdi, r8; this
mov rsi, r9; __int64
mov rbx, r9
call _ZN6evmone11grow_memoryElRNS_6MemoryEm; evmone::grow_memory(long,evmone::Memory &,ulong)
mov r9, rbx
mov r8, rax
loc_3FF18:
test r8, r8
js loc_3FFD0
loc_3FF21:
mov rax, [r12-10h]
mov rcx, [r12-8]
xor edx, edx
mov rsi, rcx
or rsi, rax
mov rsi, [r12-20h]
cmovz rax, rsi
cmovz rcx, [r12-18h]
mov rbx, [r15+68h]
mov edi, 0
cmovz rdi, rbx
cmp rdi, rax
sbb rdx, rcx
mov r13, [r12-40h]
cmovb rsi, rbx
sub rbx, rsi
cmp rbx, r13
mov r14, r13
cmovb r14, rbx
lea rax, [r13+1Fh]
shr rax, 5
lea rax, [rax+rax*2]
sub r8, rax
js short loc_3FFCB
mov r12, [r12]
test r14, r14
jz short loc_3FFA4
mov rdi, [r15+8]
add rdi, r12
add rsi, [r15+70h]
mov rdx, r14
mov r15, r8
mov rbp, r9
call _memcpy
mov r9, rbp
mov r8, r15
loc_3FFA4:
xor ebp, ebp
cmp r13, rbx
jbe short loc_3FFD0
add r12, [r9]
add r12, r14
sub r13, r14
xor ebp, ebp
mov rdi, r12
xor esi, esi
mov rdx, r13
mov rbx, r8
call _memset
mov r8, rbx
jmp short loc_3FFD0
loc_3FFCB:
mov ebp, 3
loc_3FFD0:
mov eax, ebp
mov rdx, r8
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long evmone::instr::core::codecopy(const __m128i *a1, evmone *a2, _QWORD *a3)
{
long long v4; // r8
__m128i v6; // xmm1
evmone::Memory *v7; // r9
unsigned int v8; // ebp
evmone::Memory *v9; // rdx
evmone::Memory *v10; // rbx
char *v11; // rax
long long v12; // rax
long long v13; // rcx
long long v14; // rsi
unsigned long long v15; // rdi
unsigned long long v16; // r13
unsigned long long v17; // rbx
long long v18; // r14
long long v19; // r12
evmone::Memory *v20; // rbp
v4 = (long long)a2;
v6 = _mm_or_si128(_mm_loadu_si128(a1 - 3), _mm_loadu_si128(a1 - 4));
v7 = (evmone::Memory *)(a3 + 1);
if ( _mm_testz_si128(v6, v6) )
goto LABEL_9;
v8 = 3;
if ( !(a1[-4].m128i_i64[1] | a1[-3].m128i_i64[1] | a1[-3].m128i_i64[0])
&& !HIDWORD(a1[-4].m128i_i64[0])
&& !(a1->m128i_i64[1] | a1[1].m128i_i64[1] | a1[1].m128i_i64[0])
&& !HIDWORD(a1->m128i_i64[0]) )
{
v9 = (evmone::Memory *)(a1[-4].m128i_i64[0] + a1->m128i_i64[0]);
if ( (unsigned long long)v9 > a3[2] )
{
v10 = v7;
v11 = evmone::grow_memory(a2, v7, v9);
v7 = v10;
v4 = (long long)v11;
}
if ( v4 >= 0 )
{
LABEL_9:
v12 = a1[-1].m128i_i64[0];
v13 = a1[-1].m128i_i64[1];
v14 = a1[-2].m128i_i64[0];
if ( *(_OWORD *)&a1[-1] == 0LL )
{
v12 = a1[-2].m128i_i64[0];
v13 = a1[-2].m128i_i64[1];
}
v15 = 0LL;
if ( *(_OWORD *)&a1[-1] == 0LL )
v15 = a3[13];
v16 = a1[-4].m128i_u64[0];
if ( v15 < __PAIR128__(v13, v12) )
v14 = a3[13];
v17 = a3[13] - v14;
v18 = a1[-4].m128i_i64[0];
if ( v17 < v16 )
v18 = a3[13] - v14;
if ( (long long)(v4 - 3 * ((v16 + 31) >> 5)) < 0 )
{
return 3;
}
else
{
v19 = a1->m128i_i64[0];
if ( v18 )
{
v20 = v7;
memcpy(v19 + a3[1]);
v7 = v20;
}
v8 = 0;
if ( v16 > v17 )
{
v8 = 0;
memset(v18 + *(_QWORD *)v7 + v19, 0LL, v16 - v18);
}
}
}
}
return v8;
}
| codecopy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R8,RSI
MOV R12,RDI
MOVDQU XMM0,xmmword ptr [RDI + -0x40]
MOVDQU XMM1,xmmword ptr [RDI + -0x30]
POR XMM1,XMM0
LEA R9,[RDX + 0x8]
PTEST XMM1,XMM1
JZ 0x0013ff21
MOV RAX,qword ptr [R12 + -0x30]
OR RAX,qword ptr [R12 + -0x28]
MOV EBP,0x3
OR RAX,qword ptr [R12 + -0x38]
JNZ 0x0013ffd0
MOV RAX,qword ptr [R12 + -0x40]
MOV RCX,RAX
SHR RCX,0x20
JNZ 0x0013ffd0
MOV RCX,qword ptr [R12 + 0x10]
OR RCX,qword ptr [R12 + 0x18]
OR RCX,qword ptr [R12 + 0x8]
JNZ 0x0013ffd0
MOV RDX,qword ptr [R12]
MOV RCX,RDX
SHR RCX,0x20
JNZ 0x0013ffd0
ADD RDX,RAX
CMP RDX,qword ptr [R15 + 0x10]
JBE 0x0013ff18
MOV RDI,R8
MOV RSI,R9
MOV RBX,R9
CALL 0x0013fbe5
MOV R9,RBX
MOV R8,RAX
LAB_0013ff18:
TEST R8,R8
JS 0x0013ffd0
LAB_0013ff21:
MOV RAX,qword ptr [R12 + -0x10]
MOV RCX,qword ptr [R12 + -0x8]
XOR EDX,EDX
MOV RSI,RCX
OR RSI,RAX
MOV RSI,qword ptr [R12 + -0x20]
CMOVZ RAX,RSI
CMOVZ RCX,qword ptr [R12 + -0x18]
MOV RBX,qword ptr [R15 + 0x68]
MOV EDI,0x0
CMOVZ RDI,RBX
CMP RDI,RAX
SBB RDX,RCX
MOV R13,qword ptr [R12 + -0x40]
CMOVC RSI,RBX
SUB RBX,RSI
CMP RBX,R13
MOV R14,R13
CMOVC R14,RBX
LEA RAX,[R13 + 0x1f]
SHR RAX,0x5
LEA RAX,[RAX + RAX*0x2]
SUB R8,RAX
JS 0x0013ffcb
MOV R12,qword ptr [R12]
TEST R14,R14
JZ 0x0013ffa4
MOV RDI,qword ptr [R15 + 0x8]
ADD RDI,R12
ADD RSI,qword ptr [R15 + 0x70]
MOV RDX,R14
MOV R15,R8
MOV RBP,R9
CALL 0x001211a0
MOV R9,RBP
MOV R8,R15
LAB_0013ffa4:
XOR EBP,EBP
CMP R13,RBX
JBE 0x0013ffd0
ADD R12,qword ptr [R9]
ADD R12,R14
SUB R13,R14
XOR EBP,EBP
MOV RDI,R12
XOR ESI,ESI
MOV RDX,R13
MOV RBX,R8
CALL 0x00121120
MOV R8,RBX
JMP 0x0013ffd0
LAB_0013ffcb:
MOV EBP,0x3
LAB_0013ffd0:
MOV EAX,EBP
MOV RDX,R8
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* evmone::instr::core::codecopy(evmone::StackTop, long, evmone::ExecutionState&) */
int1 [16] evmone::instr::core::codecopy(ulong *param_1,long param_2,long param_3)
{
ulong uVar1;
bool bVar2;
bool bVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
int8 uVar7;
ulong uVar8;
ulong uVar9;
int1 auVar10 [16];
if (*(int1 (*) [16])(param_1 + -6) != (int1 [16])0x0 ||
*(int1 (*) [16])(param_1 + -8) != (int1 [16])0x0) {
uVar7 = 3;
if (((((param_1[-6] != 0 || param_1[-5] != 0) || param_1[-7] != 0) || (param_1[-8] >> 0x20 != 0)
) || ((param_1[2] != 0 || param_1[3] != 0) || param_1[1] != 0)) || (*param_1 >> 0x20 != 0))
goto LAB_0013ffd0;
uVar5 = *param_1 + param_1[-8];
if (*(ulong *)(param_3 + 0x10) < uVar5) {
param_2 = grow_memory(param_2,(Memory *)(param_3 + 8),uVar5);
}
if (param_2 < 0) goto LAB_0013ffd0;
}
bVar2 = param_1[-1] == 0;
bVar3 = param_1[-2] == 0;
uVar5 = param_1[-2];
if (bVar2 && bVar3) {
uVar5 = param_1[-4];
}
uVar4 = param_1[-1];
if (bVar2 && bVar3) {
uVar4 = param_1[-3];
}
uVar6 = *(ulong *)(param_3 + 0x68);
uVar9 = 0;
if (bVar2 && bVar3) {
uVar9 = uVar6;
}
uVar1 = param_1[-8];
uVar8 = param_1[-4];
if (uVar4 != 0 || -uVar4 < (ulong)(uVar9 < uVar5)) {
uVar8 = uVar6;
}
uVar6 = uVar6 - uVar8;
uVar5 = uVar1;
if (uVar6 < uVar1) {
uVar5 = uVar6;
}
param_2 = param_2 + (uVar1 + 0x1f >> 5) * -3;
if (param_2 < 0) {
uVar7 = 3;
}
else {
uVar4 = *param_1;
if (uVar5 != 0) {
memcpy((void *)(*(long *)(param_3 + 8) + uVar4),(void *)(uVar8 + *(long *)(param_3 + 0x70)),
uVar5);
}
uVar7 = 0;
if (uVar6 < uVar1) {
uVar7 = 0;
memset((void *)(uVar4 + *(long *)(param_3 + 8) + uVar5),0,uVar1 - uVar5);
}
}
LAB_0013ffd0:
auVar10._8_8_ = param_2;
auVar10._0_8_ = uVar7;
return auVar10;
}
| |
26,302 | my_mb_wc_big5 | eloqsql/strings/ctype-big5.c | static int
my_mb_wc_big5(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc,const uchar *s,const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80)
{
pwc[0]=hi;
return 1;
}
if (s+2>e)
return MY_CS_TOOSMALL2;
if (!IS_MB2_CHAR(hi, s[1]))
return MY_CS_ILSEQ;
if (!(pwc[0]=func_big5_uni_onechar((hi<<8)+s[1])))
return -2;
return 2;
} | O0 | c | my_mb_wc_big5:
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 -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x3a25e
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x3a337
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x80, %eax
jge 0x3a286
movslq -0x2c(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3a337
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x3a2a0
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x3a337
movl -0x2c(%rbp), %eax
movzbl %al, %ecx
movl $0xa1, %eax
cmpl %ecx, %eax
jg 0x3a2fa
movl -0x2c(%rbp), %eax
movzbl %al, %eax
cmpl $0xf9, %eax
jg 0x3a2fa
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x40, %eax
cmpl %ecx, %eax
jg 0x3a2da
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x7e, %eax
jle 0x3a303
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0xa1, %eax
cmpl %ecx, %eax
jg 0x3a2fa
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xfe, %eax
jle 0x3a303
movl $0x0, -0x4(%rbp)
jmp 0x3a337
movl -0x2c(%rbp), %edi
shll $0x8, %edi
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %edi
callq 0x3a670
cltq
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x3a330
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x3a337
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
| my_mb_wc_big5:
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_20]
cmp rax, [rbp+var_28]
jb short loc_3A25E
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_3A337
loc_3A25E:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
cmp eax, 80h
jge short loc_3A286
movsxd rcx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_3A337
loc_3A286:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_3A2A0
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_3A337
loc_3A2A0:
mov eax, [rbp+var_2C]
movzx ecx, al
mov eax, 0A1h
cmp eax, ecx
jg short loc_3A2FA
mov eax, [rbp+var_2C]
movzx eax, al
cmp eax, 0F9h
jg short loc_3A2FA
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov eax, 40h ; '@'
cmp eax, ecx
jg short loc_3A2DA
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 7Eh ; '~'
jle short loc_3A303
loc_3A2DA:
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov eax, 0A1h
cmp eax, ecx
jg short loc_3A2FA
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0FEh
jle short loc_3A303
loc_3A2FA:
mov [rbp+var_4], 0
jmp short loc_3A337
loc_3A303:
mov edi, [rbp+var_2C]
shl edi, 8
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
add edi, eax
call func_big5_uni_onechar
cdqe
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jnz short loc_3A330
mov [rbp+var_4], 0FFFFFFFEh
jmp short loc_3A337
loc_3A330:
mov [rbp+var_4], 2
loc_3A337:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_mb_wc_big5(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
int v4; // eax
unsigned int v6; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
v6 = *a3;
if ( v6 >= 0x80 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
if ( (unsigned __int8)v6 < 0xA1u
|| (unsigned __int8)v6 > 0xF9u
|| (a3[1] < 0x40u || a3[1] > 0x7Eu) && (a3[1] < 0xA1u || a3[1] == 255) )
{
return 0;
}
else
{
v4 = func_big5_uni_onechar(a3[1] + (v6 << 8));
*a2 = v4;
if ( v4 )
return 2;
else
return (unsigned int)-2;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
*a2 = *a3;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_mb_wc_big5:
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 + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0013a25e
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0013a337
LAB_0013a25e:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x80
JGE 0x0013a286
MOVSXD RCX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013a337
LAB_0013a286:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0013a2a0
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0013a337
LAB_0013a2a0:
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX ECX,AL
MOV EAX,0xa1
CMP EAX,ECX
JG 0x0013a2fa
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX EAX,AL
CMP EAX,0xf9
JG 0x0013a2fa
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x40
CMP EAX,ECX
JG 0x0013a2da
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x7e
JLE 0x0013a303
LAB_0013a2da:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0xa1
CMP EAX,ECX
JG 0x0013a2fa
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xfe
JLE 0x0013a303
LAB_0013a2fa:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013a337
LAB_0013a303:
MOV EDI,dword ptr [RBP + -0x2c]
SHL EDI,0x8
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
ADD EDI,EAX
CALL 0x0013a670
CDQE
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x0013a330
MOV dword ptr [RBP + -0x4],0xfffffffe
JMP 0x0013a337
LAB_0013a330:
MOV dword ptr [RBP + -0x4],0x2
LAB_0013a337:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_mb_wc_big5(int8 param_1,long *param_2,byte *param_3,byte *param_4)
{
uint uVar1;
int iVar2;
int4 local_c;
if (param_3 < param_4) {
uVar1 = (uint)*param_3;
if (uVar1 < 0x80) {
*param_2 = (long)(int)uVar1;
local_c = 1;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else if (((uVar1 < 0xa1) || (0xf9 < uVar1)) ||
(((param_3[1] < 0x40 || (0x7e < param_3[1])) &&
((param_3[1] < 0xa1 || (param_3[1] == 0xff)))))) {
local_c = 0;
}
else {
iVar2 = func_big5_uni_onechar(uVar1 * 0x100 + (uint)param_3[1]);
*param_2 = (long)iVar2;
if ((long)iVar2 == 0) {
local_c = 0xfffffffe;
}
else {
local_c = 2;
}
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
26,303 | LefDefParser::lefwLayerRoutineEndSpacingtable() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwLayerRoutineEndSpacingtable()
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_LAYERROUTINGWIDTH)
return LEFW_BAD_ORDER;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " ;\n");
else
fprintf(lefwFile, " ;\n");
lefwLines++;
lefwState = LEFW_LAYERROUTING;
return LEFW_OK;
} | O3 | cpp | LefDefParser::lefwLayerRoutineEndSpacingtable():
pushq %rbx
leaq 0x780e3(%rip), %rax # 0x8d0f0
movq (%rax), %rcx
testq %rcx, %rcx
je 0x15042
leaq 0x78324(%rip), %rbx # 0x8d340
movl $0x2, %eax
cmpl $0x20, (%rbx)
jne 0x15070
cmpb $0x1, 0x783af(%rip) # 0x8d3dc
jne 0x15049
leaq 0x457ca(%rip), %rsi # 0x5a800
movq %rcx, %rdi
xorl %eax, %eax
callq 0x55afd
jmp 0x1505f
movl $0x1, %eax
jmp 0x15070
leaq 0x457b0(%rip), %rdi # 0x5a800
movl $0x3, %esi
movl $0x1, %edx
callq 0x23d0
leaq 0x782d6(%rip), %rax # 0x8d33c
incl (%rax)
movl $0x1f, (%rbx)
xorl %eax, %eax
popq %rbx
retq
| _ZN12LefDefParser31lefwLayerRoutineEndSpacingtableEv:
push rbx
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rcx, [rax]
test rcx, rcx
jz short loc_15042
lea rbx, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov eax, 2
cmp dword ptr [rbx], 20h ; ' '
jnz short loc_15070
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_15049
lea rsi, aDividercharS+10h; " ;\n"
mov rdi, rcx
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_1505F
loc_15042:
mov eax, 1
jmp short loc_15070
loc_15049:
lea rdi, aDividercharS+10h; " ;\n"
mov esi, 3
mov edx, 1
call _fwrite
loc_1505F:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
mov dword ptr [rbx], 1Fh
xor eax, eax
loc_15070:
pop rbx
retn
| long long LefDefParser::lefwLayerRoutineEndSpacingtable(
LefDefParser *this,
long long a2,
int a3,
long long a4,
int a5,
int a6)
{
long long result; // rax
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
result = 2LL;
if ( LefDefParser::lefwState == 32 )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" ;\n", a3, LefDefParser::lefwFile, a5, a6);
else
fwrite(" ;\n", 3LL, 1LL, *(_QWORD *)&LefDefParser::lefwFile);
++LefDefParser::lefwLines;
LefDefParser::lefwState = 31;
return 0LL;
}
return result;
}
| lefwLayerRoutineEndSpacingtable:
PUSH RBX
LEA RAX,[0x18d0f0]
MOV RCX,qword ptr [RAX]
TEST RCX,RCX
JZ 0x00115042
LEA RBX,[0x18d340]
MOV EAX,0x2
CMP dword ptr [RBX],0x20
JNZ 0x00115070
CMP byte ptr [0x0018d3dc],0x1
JNZ 0x00115049
LEA RSI,[0x15a800]
MOV RDI,RCX
XOR EAX,EAX
CALL 0x00155afd
JMP 0x0011505f
LAB_00115042:
MOV EAX,0x1
JMP 0x00115070
LAB_00115049:
LEA RDI,[0x15a800]
MOV ESI,0x3
MOV EDX,0x1
CALL 0x001023d0
LAB_0011505f:
LEA RAX,[0x18d33c]
INC dword ptr [RAX]
MOV dword ptr [RBX],0x1f
XOR EAX,EAX
LAB_00115070:
POP RBX
RET
|
/* LefDefParser::lefwLayerRoutineEndSpacingtable() */
int8 LefDefParser::lefwLayerRoutineEndSpacingtable(void)
{
int8 uVar1;
if (lefwFile == (_IO_FILE *)0x0) {
uVar1 = 1;
}
else {
uVar1 = 2;
if (lefwState == 0x20) {
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile," ;\n");
}
else {
fwrite(" ;\n",3,1,lefwFile);
}
lefwLines = lefwLines + 1;
lefwState = 0x1f;
uVar1 = 0;
}
}
return uVar1;
}
| |
26,304 | strmake | eloqsql/strings/strmake.c | char *strmake(register char *dst, register const char *src, size_t length)
{
while (length--)
{
if (! (*dst++ = *src++))
{
#ifdef EXTRA_DEBUG
/*
'length' is the maximum length of the string; the buffer needs
to be one character larger to accommodate the terminating
'\0'. This is easy to get wrong, so we make sure we write to
the entire length of the buffer to identify incorrect
buffer-sizes. We only initialism the "unused" part of the
buffer here, a) for efficiency, and b) because dst==src is
allowed, so initializing the entire buffer would overwrite the
source-string. Also, we write a character rather than '\0' as
this makes spotting these problems in the results easier.
If we are using purify/valgrind, we only set one character at
end to be able to detect also wrong accesses after the end of
dst.
*/
if (length)
{
#ifdef HAVE_valgrind
dst[length-1]= 'Z';
#else
bfill(dst, length-1, (int) 'Z');
#endif /* HAVE_valgrind */
}
#endif /* EXTRA_DEBUG */
return dst-1;
}
}
*dst=0;
return dst;
} | O3 | c | strmake:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorl %edi, %edi
movq %rdi, %rcx
cmpq %rdi, %rdx
je 0x5f590
movb (%rsi,%rcx), %r8b
movb %r8b, (%rax,%rcx)
leaq 0x1(%rcx), %rdi
testb %r8b, %r8b
jne 0x5f575
jmp 0x5f594
movb $0x0, (%rax,%rcx)
addq %rcx, %rax
popq %rbp
retq
nopl (%rax)
| strmake:
push rbp
mov rbp, rsp
mov rax, rdi
xor edi, edi
loc_5F575:
mov rcx, rdi
cmp rdx, rdi
jz short loc_5F590
mov r8b, [rsi+rcx]
mov [rax+rcx], r8b
lea rdi, [rcx+1]
test r8b, r8b
jnz short loc_5F575
jmp short loc_5F594
loc_5F590:
mov byte ptr [rax+rcx], 0
loc_5F594:
add rax, rcx
pop rbp
retn
| long long strmake(long long a1, long long a2, long long a3)
{
long long v4; // rdi
long long v5; // rcx
char v6; // r8
v4 = 0LL;
while ( 1 )
{
v5 = v4;
if ( a3 == v4 )
break;
v6 = *(_BYTE *)(a2 + v4);
*(_BYTE *)(a1 + v4++) = v6;
if ( !v6 )
return v5 + a1;
}
*(_BYTE *)(a1 + v4) = 0;
return v5 + a1;
}
| strmake:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDI
XOR EDI,EDI
LAB_0015f575:
MOV RCX,RDI
CMP RDX,RDI
JZ 0x0015f590
MOV R8B,byte ptr [RSI + RCX*0x1]
MOV byte ptr [RAX + RCX*0x1],R8B
LEA RDI,[RCX + 0x1]
TEST R8B,R8B
JNZ 0x0015f575
JMP 0x0015f594
LAB_0015f590:
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_0015f594:
ADD RAX,RCX
POP RBP
RET
|
long strmake(long param_1,long param_2,long param_3)
{
char cVar1;
long lVar2;
long lVar3;
lVar2 = 0;
do {
lVar3 = lVar2;
if (param_3 == lVar3) {
*(int1 *)(param_1 + lVar3) = 0;
break;
}
cVar1 = *(char *)(param_2 + lVar3);
*(char *)(param_1 + lVar3) = cVar1;
lVar2 = lVar3 + 1;
} while (cVar1 != '\0');
return param_1 + lVar3;
}
| |
26,305 | pow5mult | eloqsql/strings/dtoa.c | static Bigint *pow5mult(Bigint *b, int k, Stack_alloc *alloc)
{
Bigint *b1, *p5, *p51=NULL;
int i;
static int p05[3]= { 5, 25, 125 };
my_bool overflow= FALSE;
if ((i= k & 3))
b= multadd(b, p05[i-1], 0, alloc);
if (!(k>>= 2))
return b;
p5= p5_a;
for (;;)
{
if (k & 1)
{
b1= mult(b, p5, alloc);
Bfree(b, alloc);
b= b1;
}
if (!(k>>= 1))
break;
/* Calculate next power of 5 */
if (overflow)
{
p51= mult(p5, p5, alloc);
Bfree(p5, alloc);
p5= p51;
}
else if (p5 < p5_a + P5A_MAX)
++p5;
else if (p5 == p5_a + P5A_MAX)
{
p5= mult(p5, p5, alloc);
overflow= TRUE;
}
}
if (p51)
Bfree(p51, alloc);
return b;
} | O0 | c | pow5mult:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x3d(%rbp)
movl -0x14(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x74003
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x31340f(%rip), %rax # 0x387400
movl (%rax,%rcx,4), %esi
movq -0x20(%rbp), %rcx
xorl %edx, %edx
callq 0x74950
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x7401e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x74114
leaq 0x3133eb(%rip), %rax # 0x387410
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7405e
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x74120
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x74370
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x74070
jmp 0x740f8
cmpb $0x0, -0x3d(%rbp)
je 0x740a2
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x74120
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x74370
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x740f3
leaq 0x313367(%rip), %rax # 0x387410
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jae 0x740c3
movq -0x30(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
jmp 0x740f1
leaq 0x313346(%rip), %rax # 0x387410
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jne 0x740ef
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x74120
movq %rax, -0x30(%rbp)
movb $0x1, -0x3d(%rbp)
jmp 0x740f1
jmp 0x740f3
jmp 0x74029
cmpq $0x0, -0x38(%rbp)
je 0x7410c
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x74370
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| pow5mult:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_38], 0
mov [rbp+var_3D], 0
mov eax, [rbp+var_14]
and eax, 3
mov [rbp+var_3C], eax
cmp eax, 0
jz short loc_74003
mov rdi, [rbp+var_10]
mov eax, [rbp+var_3C]
sub eax, 1
movsxd rcx, eax
lea rax, pow5mult_p05
mov esi, [rax+rcx*4]
mov rcx, [rbp+var_20]
xor edx, edx
call multadd
mov [rbp+var_10], rax
loc_74003:
mov eax, [rbp+var_14]
sar eax, 2
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_7401E
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_74114
loc_7401E:
lea rax, p5_a
mov [rbp+var_30], rax
loc_74029:
mov eax, [rbp+var_14]
and eax, 1
cmp eax, 0
jz short loc_7405E
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
loc_7405E:
mov eax, [rbp+var_14]
sar eax, 1
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_74070
jmp loc_740F8
loc_74070:
cmp [rbp+var_3D], 0
jz short loc_740A2
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_38], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_38]
mov [rbp+var_30], rax
jmp short loc_740F3
loc_740A2:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnb short loc_740C3
mov rax, [rbp+var_30]
add rax, 18h
mov [rbp+var_30], rax
jmp short loc_740F1
loc_740C3:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnz short loc_740EF
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_30], rax
mov [rbp+var_3D], 1
loc_740EF:
jmp short $+2
loc_740F1:
jmp short $+2
loc_740F3:
jmp loc_74029
loc_740F8:
cmp [rbp+var_38], 0
jz short loc_7410C
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_20]
call Bfree
loc_7410C:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_74114:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long pow5mult(long long a1, int a2, long long a3)
{
char v4; // [rsp+3h] [rbp-3Dh]
_BYTE v5[12]; // [rsp+4h] [rbp-3Ch]
_UNKNOWN **v6; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+18h] [rbp-28h]
int v9; // [rsp+2Ch] [rbp-14h]
long long v10; // [rsp+30h] [rbp-10h]
v10 = a1;
*(_DWORD *)&v5[8] = 0;
v4 = 0;
*(_QWORD *)v5 = a2 & 3;
if ( (a2 & 3) != 0 )
v10 = multadd(a1, pow5mult_p05[*(_DWORD *)v5 - 1], 0LL, a3);
v9 = a2 >> 2;
if ( !(a2 >> 2) )
return v10;
v6 = &p5_a;
while ( 1 )
{
if ( (v9 & 1) != 0 )
{
v7 = mult(v10, v6, a3);
Bfree(v10, a3);
v10 = v7;
}
v9 >>= 1;
if ( !v9 )
break;
if ( v4 )
{
*(_QWORD *)&v5[4] = mult(v6, v6, a3);
Bfree(v6, a3);
v6 = *(_UNKNOWN ***)&v5[4];
}
else if ( v6 >= &p5_a + 18 )
{
if ( v6 == &p5_a + 18 )
{
v6 = (_UNKNOWN **)mult(v6, v6, a3);
v4 = 1;
}
}
else
{
v6 += 3;
}
}
if ( *(_QWORD *)&v5[4] )
Bfree(*(_QWORD *)&v5[4], a3);
return v10;
}
| pow5mult:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x38],0x0
MOV byte ptr [RBP + -0x3d],0x0
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x3
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JZ 0x00174003
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x1
MOVSXD RCX,EAX
LEA RAX,[0x487400]
MOV ESI,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RBP + -0x20]
XOR EDX,EDX
CALL 0x00174950
MOV qword ptr [RBP + -0x10],RAX
LAB_00174003:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x2
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x0017401e
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00174114
LAB_0017401e:
LEA RAX,[0x487410]
MOV qword ptr [RBP + -0x30],RAX
LAB_00174029:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0017405e
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00174120
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00174370
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
LAB_0017405e:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x00174070
JMP 0x001740f8
LAB_00174070:
CMP byte ptr [RBP + -0x3d],0x0
JZ 0x001740a2
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00174120
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00174370
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001740f3
LAB_001740a2:
LEA RAX,[0x487410]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNC 0x001740c3
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x18
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001740f1
LAB_001740c3:
LEA RAX,[0x487410]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNZ 0x001740ef
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00174120
MOV qword ptr [RBP + -0x30],RAX
MOV byte ptr [RBP + -0x3d],0x1
LAB_001740ef:
JMP 0x001740f1
LAB_001740f1:
JMP 0x001740f3
LAB_001740f3:
JMP 0x00174029
LAB_001740f8:
CMP qword ptr [RBP + -0x38],0x0
JZ 0x0017410c
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00174370
LAB_0017410c:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_00174114:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8 pow5mult(int8 param_1,uint param_2,int8 param_3)
{
bool bVar1;
int8 uVar2;
int1 *local_40;
int1 *local_38;
uint local_1c;
int8 local_18;
int8 local_10;
local_40 = (int1 *)0x0;
bVar1 = false;
local_18 = param_1;
if ((param_2 & 3) != 0) {
local_18 = multadd(param_1,*(int4 *)(pow5mult_p05 + (long)(int)((param_2 & 3) - 1) * 4),0,
param_3);
}
local_1c = (int)param_2 >> 2;
if (local_1c == 0) {
local_10 = local_18;
}
else {
local_38 = p5_a;
while( true ) {
if ((local_1c & 1) != 0) {
uVar2 = mult(local_18,local_38,param_3);
Bfree(local_18,param_3);
local_18 = uVar2;
}
local_1c = (int)local_1c >> 1;
if (local_1c == 0) break;
if (bVar1) {
local_40 = (int1 *)mult(local_38,local_38,param_3);
Bfree(local_38,param_3);
local_38 = local_40;
}
else if (local_38 < (int1 *)0x4874a0) {
local_38 = local_38 + 0x18;
}
else if (local_38 == (int1 *)0x4874a0) {
local_38 = (int1 *)mult(0x4874a0,0x4874a0,param_3);
bVar1 = true;
}
}
if (local_40 != (int1 *)0x0) {
Bfree(local_40,param_3);
}
local_10 = local_18;
}
return local_10;
}
| |
26,306 | get_proxy_method | bluesky950520[P]quickjs/quickjs.c | static JSProxyData *get_proxy_method(JSContext *ctx, JSValue *pmethod,
JSValue obj, JSAtom name)
{
JSProxyData *s = JS_GetOpaque(obj, JS_CLASS_PROXY);
JSValue method;
/* safer to test recursion in all proxy methods */
if (js_check_stack_overflow(ctx->rt, 0)) {
JS_ThrowStackOverflow(ctx);
return NULL;
}
/* 's' should never be NULL */
if (s->is_revoked) {
JS_ThrowTypeErrorRevokedProxy(ctx);
return NULL;
}
method = JS_GetProperty(ctx, s->handler, name);
if (JS_IsException(method))
return NULL;
if (JS_IsNull(method))
method = JS_UNDEFINED;
*pmethod = method;
return s;
} | O0 | c | get_proxy_method:
subq $0x88, %rsp
movq %rdx, 0x70(%rsp)
movq %rcx, 0x78(%rsp)
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl %r8d, 0x5c(%rsp)
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movl $0x30, %edx
callq 0x38350
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4dce0
cmpl $0x0, %eax
je 0x600e5
movq 0x68(%rsp), %rdi
callq 0x601e0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq $0x0, 0x80(%rsp)
jmp 0x601ca
movq 0x50(%rsp), %rax
cmpb $0x0, 0x21(%rax)
je 0x60115
movq 0x68(%rsp), %rdi
callq 0x60220
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq $0x0, 0x80(%rsp)
jmp 0x601ca
movq 0x68(%rsp), %rdi
movq 0x50(%rsp), %rax
movl 0x5c(%rsp), %ecx
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x29d80
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x60170
movq $0x0, 0x80(%rsp)
jmp 0x601ca
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2e240
cmpl $0x0, %eax
je 0x601a7
movl $0x0, (%rsp)
movq $0x3, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, (%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
nopw (%rax,%rax)
| get_proxy_method:
sub rsp, 88h
mov [rsp+88h+var_18], rdx
mov [rsp+88h+var_10], rcx
mov [rsp+88h+var_20], rdi
mov [rsp+88h+var_28], rsi
mov [rsp+88h+var_2C], r8d
mov rdi, [rsp+88h+var_18]
mov rsi, [rsp+88h+var_10]
mov edx, 30h ; '0'
call JS_GetOpaque
mov [rsp+88h+var_38], rax
mov rax, [rsp+88h+var_20]
mov rdi, [rax+18h]
xor eax, eax
mov esi, eax
call js_check_stack_overflow
cmp eax, 0
jz short loc_600E5
mov rdi, [rsp+88h+var_20]
call JS_ThrowStackOverflow
mov [rsp+88h+var_58], rax
mov [rsp+88h+var_50], rdx
mov [rsp+88h+var_8], 0
jmp loc_601CA
loc_600E5:
mov rax, [rsp+88h+var_38]
cmp byte ptr [rax+21h], 0
jz short loc_60115
mov rdi, [rsp+88h+var_20]
call JS_ThrowTypeErrorRevokedProxy
mov [rsp+88h+var_68], rax
mov [rsp+88h+var_60], rdx
mov [rsp+88h+var_8], 0
jmp loc_601CA
loc_60115:
mov rdi, [rsp+88h+var_20]
mov rax, [rsp+88h+var_38]
mov ecx, [rsp+88h+var_2C]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
call JS_GetProperty
mov [rsp+88h+var_78], rax
mov [rsp+88h+var_70], rdx
mov rax, [rsp+88h+var_78]
mov [rsp+88h+var_48], rax
mov rax, [rsp+88h+var_70]
mov [rsp+88h+var_40], rax
mov rdi, [rsp+88h+var_48]
mov rsi, [rsp+88h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_60170
mov [rsp+88h+var_8], 0
jmp short loc_601CA
loc_60170:
mov rdi, [rsp+88h+var_48]
mov rsi, [rsp+88h+var_40]
call JS_IsNull_0
cmp eax, 0
jz short loc_601A7
mov dword ptr [rsp+88h+var_88], 0
mov [rsp+88h+var_80], 3
mov rax, [rsp+88h+var_88]
mov [rsp+88h+var_48], rax
mov rax, [rsp+88h+var_80]
mov [rsp+88h+var_40], rax
loc_601A7:
mov rax, [rsp+88h+var_28]
mov rcx, [rsp+88h+var_48]
mov [rax], rcx
mov rcx, [rsp+88h+var_40]
mov [rax+8], rcx
mov rax, [rsp+88h+var_38]
mov [rsp+88h+var_8], rax
loc_601CA:
mov rax, [rsp+88h+var_8]
add rsp, 88h
retn
| long long get_proxy_method(long long a1, long long *a2, long long a3, int a4, int a5)
{
long long v5; // rdx
long long v7; // [rsp+0h] [rbp-88h]
long long Property; // [rsp+10h] [rbp-78h]
long long v9; // [rsp+40h] [rbp-48h]
long long v10; // [rsp+48h] [rbp-40h]
long long Opaque; // [rsp+50h] [rbp-38h]
Opaque = JS_GetOpaque(a3, a4, 48);
if ( js_check_stack_overflow(*(_QWORD *)(a1 + 24), 0LL) )
{
JS_ThrowStackOverflow(a1);
return 0LL;
}
else if ( *(_BYTE *)(Opaque + 33) )
{
JS_ThrowTypeErrorRevokedProxy(a1);
return 0LL;
}
else
{
Property = JS_GetProperty(a1, *(_QWORD *)(Opaque + 16), *(_QWORD *)(Opaque + 24), a5);
v9 = Property;
v10 = v5;
if ( JS_IsException_1(Property, v5) )
{
return 0LL;
}
else
{
if ( JS_IsNull_0(Property, v10) )
{
LODWORD(v7) = 0;
v9 = v7;
v10 = 3LL;
}
*a2 = v9;
a2[1] = v10;
return Opaque;
}
}
}
| get_proxy_method:
SUB RSP,0x88
MOV qword ptr [RSP + 0x70],RDX
MOV qword ptr [RSP + 0x78],RCX
MOV qword ptr [RSP + 0x68],RDI
MOV qword ptr [RSP + 0x60],RSI
MOV dword ptr [RSP + 0x5c],R8D
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x78]
MOV EDX,0x30
CALL 0x00138350
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RAX + 0x18]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0014dce0
CMP EAX,0x0
JZ 0x001600e5
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001601e0
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x80],0x0
JMP 0x001601ca
LAB_001600e5:
MOV RAX,qword ptr [RSP + 0x50]
CMP byte ptr [RAX + 0x21],0x0
JZ 0x00160115
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00160220
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV qword ptr [RSP + 0x80],0x0
JMP 0x001601ca
LAB_00160115:
MOV RDI,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RSP + 0x50]
MOV ECX,dword ptr [RSP + 0x5c]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x00129d80
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x00160170
MOV qword ptr [RSP + 0x80],0x0
JMP 0x001601ca
LAB_00160170:
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x0012e240
CMP EAX,0x0
JZ 0x001601a7
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x3
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x48],RAX
LAB_001601a7:
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x80],RAX
LAB_001601ca:
MOV RAX,qword ptr [RSP + 0x80]
ADD RSP,0x88
RET
|
long get_proxy_method(long param_1,int1 (*param_2) [16],int8 param_3,int8 param_4,
int4 param_5)
{
int iVar1;
int1 auVar2 [16];
uint uStack_84;
long local_8;
local_8 = JS_GetOpaque(param_3,param_4,0x30);
iVar1 = js_check_stack_overflow(*(int8 *)(param_1 + 0x18),0);
if (iVar1 == 0) {
if (*(char *)(local_8 + 0x21) == '\0') {
auVar2 = JS_GetProperty(param_1,*(int8 *)(local_8 + 0x10),
*(int8 *)(local_8 + 0x18),param_5);
iVar1 = JS_IsException(auVar2._0_8_,auVar2._8_8_);
if (iVar1 == 0) {
iVar1 = JS_IsNull(auVar2._0_8_,auVar2._8_8_);
if (iVar1 != 0) {
auVar2._8_8_ = 3;
auVar2._0_8_ = (ulong)uStack_84 << 0x20;
}
*param_2 = auVar2;
}
else {
local_8 = 0;
}
}
else {
JS_ThrowTypeErrorRevokedProxy(param_1);
local_8 = 0;
}
}
else {
JS_ThrowStackOverflow(param_1);
local_8 = 0;
}
return local_8;
}
| |
26,307 | get_proxy_method | bluesky950520[P]quickjs/quickjs.c | static JSProxyData *get_proxy_method(JSContext *ctx, JSValue *pmethod,
JSValue obj, JSAtom name)
{
JSProxyData *s = JS_GetOpaque(obj, JS_CLASS_PROXY);
JSValue method;
/* safer to test recursion in all proxy methods */
if (js_check_stack_overflow(ctx->rt, 0)) {
JS_ThrowStackOverflow(ctx);
return NULL;
}
/* 's' should never be NULL */
if (s->is_revoked) {
JS_ThrowTypeErrorRevokedProxy(ctx);
return NULL;
}
method = JS_GetProperty(ctx, s->handler, name);
if (JS_IsException(method))
return NULL;
if (JS_IsNull(method))
method = JS_UNDEFINED;
*pmethod = method;
return s;
} | O1 | c | get_proxy_method:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdx, -0x18(%rbp)
cmpl $-0x1, %ecx
jne 0x3d408
movq -0x18(%rbp), %rax
cmpw $0x30, 0x6(%rax)
jne 0x3d408
movq 0x30(%rax), %rbx
jmp 0x3d40a
xorl %ebx, %ebx
movq 0x18(%rdi), %rax
cmpq %rbp, 0xe8(%rax)
jbe 0x3d429
leaq 0x61bb8(%rip), %rsi # 0x9efd6
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x20add
jmp 0x3d49a
cmpb $0x0, 0x21(%rbx)
je 0x3d441
leaq 0x61bc1(%rip), %rsi # 0x9eff7
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22567
jmp 0x3d49a
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movl %r8d, %ecx
movq %rsi, %r8
movq %rdx, %r9
pushq $0x0
pushq $0x0
callq 0x22fa3
addq $0x10, %rsp
movl %edx, %ecx
cmpq $0x6, %rcx
jne 0x3d46b
xorl %ebx, %ebx
jmp 0x3d49a
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
andq %rax, %rsi
cmpl $0x2, %ecx
movl $0x3, %edi
cmoveq %rdi, %rdx
xorl %edi, %edi
cmpq $0x2, %rcx
movl %eax, %eax
cmovneq %rax, %rdi
orq %rsi, %rdi
movq %rdi, (%r14)
movq %rdx, 0x8(%r14)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| get_proxy_method:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov r14, rsi
mov [rbp+var_18], rdx
cmp ecx, 0FFFFFFFFh
jnz short loc_3D408
mov rax, [rbp+var_18]
cmp word ptr [rax+6], 30h ; '0'
jnz short loc_3D408
mov rbx, [rax+30h]
jmp short loc_3D40A
loc_3D408:
xor ebx, ebx
loc_3D40A:
mov rax, [rdi+18h]
cmp [rax+0E8h], rbp
jbe short loc_3D429
lea rsi, aMaximumCallSta; "Maximum call stack size exceeded"
xor ebx, ebx
xor eax, eax
call JS_ThrowRangeError
jmp short loc_3D49A
loc_3D429:
cmp byte ptr [rbx+21h], 0
jz short loc_3D441
lea rsi, aRevokedProxy; "revoked proxy"
xor ebx, ebx
xor eax, eax
call JS_ThrowTypeError
jmp short loc_3D49A
loc_3D441:
mov rsi, [rbx+10h]
mov rdx, [rbx+18h]
mov ecx, r8d
mov r8, rsi
mov r9, rdx
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov ecx, edx
cmp rcx, 6
jnz short loc_3D46B
xor ebx, ebx
jmp short loc_3D49A
loc_3D46B:
mov rsi, 0FFFFFFFF00000000h
and rsi, rax
cmp ecx, 2
mov edi, 3
cmovz rdx, rdi
xor edi, edi
cmp rcx, 2
mov eax, eax
cmovnz rdi, rax
or rdi, rsi
mov [r14], rdi
mov [r14+8], rdx
loc_3D49A:
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| long long get_proxy_method(
long long a1,
unsigned long long *a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // rbx
unsigned long long PropertyInternal2; // rax
long long v16; // rdx
long long v17; // rcx
long long v18; // rdi
char v20; // [rsp+0h] [rbp-20h]
long long savedregs; // [rsp+20h] [rbp+0h] BYREF
if ( (_DWORD)a4 == -1 && *(_WORD *)(a3 + 6) == 48 )
v14 = *(_QWORD *)(a3 + 48);
else
v14 = 0LL;
if ( *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) <= (unsigned long long)&savedregs )
{
if ( *(_BYTE *)(v14 + 33) )
{
v14 = 0LL;
JS_ThrowTypeError(a1, (long long)"revoked proxy", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v20);
}
else
{
PropertyInternal2 = JS_GetPropertyInternal2(
a1,
*(_QWORD *)(v14 + 16),
*(_QWORD *)(v14 + 24),
a5,
*(_QWORD *)(v14 + 16),
*(_QWORD *)(v14 + 24),
0LL,
0);
v17 = (unsigned int)v16;
if ( (unsigned int)v16 == 6LL )
{
return 0LL;
}
else
{
if ( (_DWORD)v16 == 2 )
v16 = 3LL;
v18 = 0LL;
if ( v17 != 2 )
v18 = (unsigned int)PropertyInternal2;
*a2 = PropertyInternal2 & 0xFFFFFFFF00000000LL | v18;
a2[1] = v16;
}
}
}
else
{
v14 = 0LL;
JS_ThrowRangeError(
a1,
(long long)"Maximum call stack size exceeded",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v20);
}
return v14;
}
| get_proxy_method:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV qword ptr [RBP + -0x18],RDX
CMP ECX,-0x1
JNZ 0x0013d408
MOV RAX,qword ptr [RBP + -0x18]
CMP word ptr [RAX + 0x6],0x30
JNZ 0x0013d408
MOV RBX,qword ptr [RAX + 0x30]
JMP 0x0013d40a
LAB_0013d408:
XOR EBX,EBX
LAB_0013d40a:
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RAX + 0xe8],RBP
JBE 0x0013d429
LEA RSI,[0x19efd6]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x00120add
JMP 0x0013d49a
LAB_0013d429:
CMP byte ptr [RBX + 0x21],0x0
JZ 0x0013d441
LEA RSI,[0x19eff7]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x00122567
JMP 0x0013d49a
LAB_0013d441:
MOV RSI,qword ptr [RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x18]
MOV ECX,R8D
MOV R8,RSI
MOV R9,RDX
PUSH 0x0
PUSH 0x0
CALL 0x00122fa3
ADD RSP,0x10
MOV ECX,EDX
CMP RCX,0x6
JNZ 0x0013d46b
XOR EBX,EBX
JMP 0x0013d49a
LAB_0013d46b:
MOV RSI,-0x100000000
AND RSI,RAX
CMP ECX,0x2
MOV EDI,0x3
CMOVZ RDX,RDI
XOR EDI,EDI
CMP RCX,0x2
MOV EAX,EAX
CMOVNZ RDI,RAX
OR RDI,RSI
MOV qword ptr [R14],RDI
MOV qword ptr [R14 + 0x8],RDX
LAB_0013d49a:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
long get_proxy_method(long param_1,ulong *param_2,long param_3,int param_4)
{
ulong uVar1;
ulong uVar2;
long lVar3;
ulong uVar4;
int1 auVar5 [16];
if ((param_4 == -1) && (*(short *)(param_3 + 6) == 0x30)) {
lVar3 = *(long *)(param_3 + 0x30);
}
else {
lVar3 = 0;
}
if (&stack0xfffffffffffffff8 < *(int1 **)(*(long *)(param_1 + 0x18) + 0xe8)) {
lVar3 = 0;
JS_ThrowRangeError(param_1,"Maximum call stack size exceeded");
}
else if (*(char *)(lVar3 + 0x21) == '\0') {
auVar5 = JS_GetPropertyInternal2();
uVar2 = auVar5._8_8_;
uVar1 = uVar2 & 0xffffffff;
if (uVar1 == 6) {
lVar3 = 0;
}
else {
if (auVar5._8_4_ == 2) {
uVar2 = 3;
}
uVar4 = 0;
if (uVar1 != 2) {
uVar4 = auVar5._0_8_ & 0xffffffff;
}
*param_2 = uVar4 | auVar5._0_8_ & 0xffffffff00000000;
param_2[1] = uVar2;
}
}
else {
lVar3 = 0;
JS_ThrowTypeError(param_1,"revoked proxy");
}
return lVar3;
}
| |
26,308 | get_proxy_method | bluesky950520[P]quickjs/quickjs.c | static JSProxyData *get_proxy_method(JSContext *ctx, JSValue *pmethod,
JSValue obj, JSAtom name)
{
JSProxyData *s = JS_GetOpaque(obj, JS_CLASS_PROXY);
JSValue method;
/* safer to test recursion in all proxy methods */
if (js_check_stack_overflow(ctx->rt, 0)) {
JS_ThrowStackOverflow(ctx);
return NULL;
}
/* 's' should never be NULL */
if (s->is_revoked) {
JS_ThrowTypeErrorRevokedProxy(ctx);
return NULL;
}
method = JS_GetProperty(ctx, s->handler, name);
if (JS_IsException(method))
return NULL;
if (JS_IsNull(method))
method = JS_UNDEFINED;
*pmethod = method;
return s;
} | O2 | c | get_proxy_method:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
cmpl $-0x1, %ecx
jne 0x35d1d
cmpw $0x30, 0x6(%rdx)
jne 0x35d1d
movq 0x30(%rdx), %rbx
jmp 0x35d1f
xorl %ebx, %ebx
movq 0x18(%rdi), %rax
cmpq %rbp, 0xe8(%rax)
jbe 0x35d33
callq 0x35d91
jmp 0x35d58
cmpb $0x0, 0x21(%rbx)
je 0x35d40
callq 0x35d9f
jmp 0x35d58
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movl %r8d, %ecx
callq 0x1b043
movl %edx, %ecx
cmpq $0x6, %rcx
jne 0x35d62
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
andq %rax, %rsi
cmpl $0x2, %ecx
pushq $0x3
popq %rdi
cmoveq %rdi, %rdx
xorl %edi, %edi
cmpq $0x2, %rcx
movl %eax, %eax
cmovneq %rax, %rdi
orq %rsi, %rdi
movq %rdi, (%r14)
movq %rdx, 0x8(%r14)
jmp 0x35d5a
| get_proxy_method:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rsi
cmp ecx, 0FFFFFFFFh
jnz short loc_35D1D
cmp word ptr [rdx+6], 30h ; '0'
jnz short loc_35D1D
mov rbx, [rdx+30h]
jmp short loc_35D1F
loc_35D1D:
xor ebx, ebx
loc_35D1F:
mov rax, [rdi+18h]
cmp [rax+0E8h], rbp
jbe short loc_35D33
call JS_ThrowStackOverflow
jmp short loc_35D58
loc_35D33:
cmp byte ptr [rbx+21h], 0
jz short loc_35D40
call JS_ThrowTypeErrorRevokedProxy
jmp short loc_35D58
loc_35D40:
mov rsi, [rbx+10h]
mov rdx, [rbx+18h]
mov ecx, r8d
call JS_GetProperty
mov ecx, edx
cmp rcx, 6
jnz short loc_35D62
loc_35D58:
xor ebx, ebx
loc_35D5A:
mov rax, rbx
pop rbx
pop r14
pop rbp
retn
loc_35D62:
mov rsi, 0FFFFFFFF00000000h
and rsi, rax
cmp ecx, 2
push 3
pop rdi
cmovz rdx, rdi
xor edi, edi
cmp rcx, 2
mov eax, eax
cmovnz rdi, rax
or rdi, rsi
mov [r14], rdi
mov [r14+8], rdx
jmp short loc_35D5A
| long long get_proxy_method(long long a1, unsigned long long *a2, long long a3, int a4, int a5)
{
long long v5; // rbx
long long Property; // rax
long long v7; // rdx
long long v8; // rcx
long long v10; // rdi
long long savedregs; // [rsp+10h] [rbp+0h] BYREF
if ( a4 == -1 && *(_WORD *)(a3 + 6) == 48 )
v5 = *(_QWORD *)(a3 + 48);
else
v5 = 0LL;
if ( *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) > (unsigned long long)&savedregs )
{
JS_ThrowStackOverflow(a1);
return 0LL;
}
if ( *(_BYTE *)(v5 + 33) )
{
JS_ThrowTypeErrorRevokedProxy();
return 0LL;
}
Property = JS_GetProperty(a1, *(_QWORD *)(v5 + 16), *(_QWORD *)(v5 + 24), a5);
v8 = (unsigned int)v7;
if ( (unsigned int)v7 == 6LL )
return 0LL;
if ( (_DWORD)v7 == 2 )
v7 = 3LL;
v10 = 0LL;
if ( v8 != 2 )
v10 = (unsigned int)Property;
*a2 = Property & 0xFFFFFFFF00000000LL | v10;
a2[1] = v7;
return v5;
}
| get_proxy_method:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RSI
CMP ECX,-0x1
JNZ 0x00135d1d
CMP word ptr [RDX + 0x6],0x30
JNZ 0x00135d1d
MOV RBX,qword ptr [RDX + 0x30]
JMP 0x00135d1f
LAB_00135d1d:
XOR EBX,EBX
LAB_00135d1f:
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RAX + 0xe8],RBP
JBE 0x00135d33
CALL 0x00135d91
JMP 0x00135d58
LAB_00135d33:
CMP byte ptr [RBX + 0x21],0x0
JZ 0x00135d40
CALL 0x00135d9f
JMP 0x00135d58
LAB_00135d40:
MOV RSI,qword ptr [RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x18]
MOV ECX,R8D
CALL 0x0011b043
MOV ECX,EDX
CMP RCX,0x6
JNZ 0x00135d62
LAB_00135d58:
XOR EBX,EBX
LAB_00135d5a:
MOV RAX,RBX
POP RBX
POP R14
POP RBP
RET
LAB_00135d62:
MOV RSI,-0x100000000
AND RSI,RAX
CMP ECX,0x2
PUSH 0x3
POP RDI
CMOVZ RDX,RDI
XOR EDI,EDI
CMP RCX,0x2
MOV EAX,EAX
CMOVNZ RDI,RAX
OR RDI,RSI
MOV qword ptr [R14],RDI
MOV qword ptr [R14 + 0x8],RDX
JMP 0x00135d5a
|
long get_proxy_method(long param_1,ulong *param_2,long param_3,int param_4,int4 param_5)
{
ulong uVar1;
ulong uVar2;
long lVar3;
ulong uVar4;
int1 auVar5 [16];
if ((param_4 == -1) && (*(short *)(param_3 + 6) == 0x30)) {
lVar3 = *(long *)(param_3 + 0x30);
}
else {
lVar3 = 0;
}
if (&stack0xfffffffffffffff8 < *(int1 **)(*(long *)(param_1 + 0x18) + 0xe8)) {
JS_ThrowStackOverflow();
}
else if (*(char *)(lVar3 + 0x21) == '\0') {
auVar5 = JS_GetProperty(param_1,*(int8 *)(lVar3 + 0x10),*(int8 *)(lVar3 + 0x18),
param_5);
uVar1 = auVar5._8_8_ & 0xffffffff;
if (uVar1 != 6) {
uVar2 = auVar5._8_8_;
if (auVar5._8_4_ == 2) {
uVar2 = 3;
}
uVar4 = 0;
if (uVar1 != 2) {
uVar4 = auVar5._0_8_ & 0xffffffff;
}
*param_2 = uVar4 | auVar5._0_8_ & 0xffffffff00000000;
param_2[1] = uVar2;
return lVar3;
}
}
else {
JS_ThrowTypeErrorRevokedProxy();
}
return 0;
}
| |
26,309 | js_class_has_bytecode | bluesky950520[P]quickjs/quickjs.c | static BOOL js_class_has_bytecode(JSClassID class_id)
{
return (class_id == JS_CLASS_BYTECODE_FUNCTION ||
class_id == JS_CLASS_GENERATOR_FUNCTION ||
class_id == JS_CLASS_ASYNC_FUNCTION ||
class_id == JS_CLASS_ASYNC_GENERATOR_FUNCTION);
} | O0 | c | js_class_has_bytecode:
movl %edi, -0x4(%rsp)
movb $0x1, %al
cmpl $0xd, -0x4(%rsp)
movb %al, -0x5(%rsp)
je 0x4a277
movb $0x1, %al
cmpl $0x10, -0x4(%rsp)
movb %al, -0x5(%rsp)
je 0x4a277
movb $0x1, %al
cmpl $0x34, -0x4(%rsp)
movb %al, -0x5(%rsp)
je 0x4a277
cmpl $0x38, -0x4(%rsp)
sete %al
movb %al, -0x5(%rsp)
movb -0x5(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
retq
nopw %cs:(%rax,%rax)
| js_class_has_bytecode:
mov [rsp+var_4], edi
mov al, 1
cmp [rsp+var_4], 0Dh
mov [rsp+var_5], al
jz short loc_4A277
mov al, 1
cmp [rsp+var_4], 10h
mov [rsp+var_5], al
jz short loc_4A277
mov al, 1
cmp [rsp+var_4], 34h ; '4'
mov [rsp+var_5], al
jz short loc_4A277
cmp [rsp+var_4], 38h ; '8'
setz al
mov [rsp+var_5], al
loc_4A277:
mov al, [rsp+var_5]
and al, 1
movzx eax, al
retn
| _BOOL8 js_class_has_bytecode(int a1)
{
bool v2; // [rsp+1h] [rbp-5h]
v2 = 1;
if ( a1 != 13 )
{
v2 = 1;
if ( a1 != 16 )
{
v2 = 1;
if ( a1 != 52 )
return a1 == 56;
}
}
return v2;
}
| js_class_has_bytecode:
MOV dword ptr [RSP + -0x4],EDI
MOV AL,0x1
CMP dword ptr [RSP + -0x4],0xd
MOV byte ptr [RSP + -0x5],AL
JZ 0x0014a277
MOV AL,0x1
CMP dword ptr [RSP + -0x4],0x10
MOV byte ptr [RSP + -0x5],AL
JZ 0x0014a277
MOV AL,0x1
CMP dword ptr [RSP + -0x4],0x34
MOV byte ptr [RSP + -0x5],AL
JZ 0x0014a277
CMP dword ptr [RSP + -0x4],0x38
SETZ AL
MOV byte ptr [RSP + -0x5],AL
LAB_0014a277:
MOV AL,byte ptr [RSP + -0x5]
AND AL,0x1
MOVZX EAX,AL
RET
|
bool js_class_has_bytecode(int param_1)
{
int1 local_5;
local_5 = true;
if (((param_1 != 0xd) && (local_5 = true, param_1 != 0x10)) && (local_5 = true, param_1 != 0x34))
{
local_5 = param_1 == 0x38;
}
return local_5;
}
| |
26,310 | void spdlog::logger::log_<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>(spdlog::source_loc, spdlog::level::level_enum, fmt::v10::basic_string_view<char>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, int&&) | AlayaLite/build_O3/_deps/spdlog-src/include/spdlog/logger.h | void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args) {
bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled();
if (!log_enabled && !traceback_enabled) {
return;
}
SPDLOG_TRY {
memory_buf_t buf;
#ifdef SPDLOG_USE_STD_FORMAT
fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(args...));
#else
fmt::vformat_to(fmt::appender(buf), fmt, fmt::make_format_args(args...));
#endif
details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));
log_it_(log_msg, log_enabled, traceback_enabled);
} | O3 | c | void spdlog::logger::log_<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>(spdlog::source_loc, spdlog::level::level_enum, fmt::v10::basic_string_view<char>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, int&&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %r9, %r13
movq %r8, %rbx
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %esi, %ebp
movl 0x40(%rdi), %r15d
cmpl %esi, %r15d
setg %r12b
movq %rdi, 0x18(%rsp)
addq $0x68, %rdi
callq 0x2c4fa
movl %eax, %r14d
xorb $0x1, %al
testb %al, %r12b
jne 0x22b14
movq 0x210(%rsp), %rax
movq 0x208(%rsp), %rcx
leaq 0x1f0(%rsp), %r12
leaq 0xb0(%rsp), %rsi
movq $0x0, -0x10(%rsi)
leaq 0x8d69d(%rip), %rdx # 0xb00e8
addq $0x10, %rdx
movq %rdx, -0x20(%rsi)
movq %rsi, -0x18(%rsi)
movq $0xfa, -0x8(%rsi)
movups (%rbx), %xmm0
movl (%r13), %edx
movq (%rcx), %rcx
movq (%rax), %rax
leaq 0x30(%rsp), %r8
movaps %xmm0, (%r8)
movq %rdx, 0x10(%r8)
movq %rcx, 0x20(%r8)
movq %rax, 0x30(%r8)
leaq 0x90(%rsp), %rdi
movl $0x441d, %ecx # imm = 0x441D
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x1a07d
movq 0x18(%rsp), %rbx
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x98(%rsp), %r8
movq 0xa0(%rsp), %r9
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
leaq 0x30(%rsp), %rdi
movl %ebp, %ecx
callq 0x2c872
xorl %edx, %edx
cmpl %ebp, %r15d
setle %dl
movzbl %r14b, %ecx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x2e6f2
movq 0x98(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0x22b14
movq 0xa8(%rsp), %rsi
callq 0x11120
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x22b28
movq %rdx, %r14
movq %rax, %rbx
movq 0x98(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0x22b50
movq 0xa8(%rsp), %rsi
callq 0x11120
movq %rbx, %rdi
callq 0x11070
cmpl $0x2, %r14d
jne 0x22c26
movq (%r12), %rbx
testq %rbx, %rbx
je 0x22bcb
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movl 0x8(%r12), %ecx
leaq 0x90(%rsp), %r8
movq %rax, (%r8)
movq %rbx, 0x10(%r8)
movq %rcx, 0x20(%r8)
leaq 0x5cb4b(%rip), %rsi # 0x7f6de
leaq 0x30(%rsp), %rdi
movl $0xb, %edx
movl $0x1cc, %ecx # imm = 0x1CC
callq 0x40725
leaq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x2e940
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22c1c
movq 0x40(%rsp), %rsi
jmp 0x22c14
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rax, %rsi
callq 0x16c9c
leaq 0x90(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x2e940
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22c1c
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x11120
callq 0x11920
jmp 0x22b14
leaq 0xa0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x5ca7e(%rip), %rsi # 0x7f6b7
leaq 0x5ca9d(%rip), %rdx # 0x7f6dd
leaq 0x90(%rsp), %rdi
callq 0x19014
leaq 0x90(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x2e940
movq 0x90(%rsp), %rdi
cmpq %r14, %rdi
je 0x22c7c
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x11120
callq 0x11990
jmp 0x22cc5
movq %rax, %rbx
movq 0x90(%rsp), %rdi
cmpq %r14, %rdi
je 0x22cc8
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x11120
jmp 0x22cc8
movq %rax, %rbx
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22cf2
movq 0xa0(%rsp), %rsi
jmp 0x22ce5
jmp 0x22cef
movq %rax, %rbx
callq 0x11920
jmp 0x22cf7
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22cf2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x11120
jmp 0x22cf2
movq %rax, %rbx
callq 0x11920
movq %rbx, %rdi
callq 0x11760
movq %rax, %rdi
callq 0x18a8f
| _ZN6spdlog6logger4log_IJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiRmS8_EEEvNS_10source_locENS_5level10level_enumEN3fmt3v1017basic_string_viewIcEEDpOT_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1B8h
mov r13, r9
mov rbx, r8
mov [rsp+1E8h+var_1C0], rcx
mov [rsp+1E8h+var_1C8], rdx
mov ebp, esi
mov r15d, [rdi+40h]
cmp r15d, esi
setnle r12b
mov [rsp+1E8h+var_1D0], rdi
add rdi, 68h ; 'h'; this
call _ZNK6spdlog7details10backtracer7enabledEv; spdlog::details::backtracer::enabled(void)
mov r14d, eax
xor al, 1
test r12b, al
jnz loc_22B14
mov rax, [rsp+1E8h+arg_20]
mov rcx, [rsp+1E8h+arg_18]
lea r12, [rsp+1E8h+arg_0]
lea rsi, [rsp+1E8h+var_138]
mov qword ptr [rsi-10h], 0
lea rdx, _ZTVN3fmt3v1019basic_memory_bufferIcLm250ESaIcEEE; `vtable for'fmt::v10::basic_memory_buffer<char,250ul,std::allocator<char>>
add rdx, 10h
mov [rsi-20h], rdx
mov [rsi-18h], rsi
mov qword ptr [rsi-8], 0FAh
movups xmm0, xmmword ptr [rbx]
mov edx, [r13+0]
mov rcx, [rcx]
mov rax, [rax]
lea r8, [rsp+1E8h+var_1B8]
movaps xmmword ptr [r8], xmm0
mov [r8+10h], rdx
mov [r8+20h], rcx
mov [r8+30h], rax
lea rdi, [rsp+1E8h+var_158]
mov ecx, 441Dh
mov rsi, [rsp+1E8h+var_1C8]
mov rdx, [rsp+1E8h+var_1C0]
call _ZN3fmt3v1010vformat_toINS0_8appenderETnNSt9enable_ifIXsr6detail18is_output_iteratorIT_cEE5valueEiE4typeELi0EEES4_S4_NS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextIS2_cEEEE
mov rbx, [rsp+1E8h+var_1D0]
mov rsi, [rbx+8]
mov rdx, [rbx+10h]
mov r8, [rsp+1E8h+var_150]
mov r9, [rsp+1E8h+var_148]
mov rax, [r12+10h]
mov [rsp+1E8h+var_1D8], rax
movups xmm0, xmmword ptr [r12]
movups [rsp+1E8h+var_1E8], xmm0
lea rdi, [rsp+1E8h+var_1B8]
mov ecx, ebp
call _ZN6spdlog7details7log_msgC2ENS_10source_locEN3fmt3v1017basic_string_viewIcEENS_5level10level_enumES6_; spdlog::details::log_msg::log_msg(spdlog::source_loc,fmt::v10::basic_string_view<char>,spdlog::level::level_enum,fmt::v10::basic_string_view<char>)
xor edx, edx
cmp r15d, ebp
setle dl
movzx ecx, r14b
lea rsi, [rsp+1E8h+var_1B8]
mov rdi, rbx
call _ZN6spdlog6logger7log_it_ERKNS_7details7log_msgEbb; spdlog::logger::log_it_(spdlog::details::log_msg const&,bool,bool)
mov rdi, [rsp+1E8h+var_150]; void *
lea rax, [rsp+1E8h+var_138]
cmp rdi, rax
jz short loc_22B14
mov rsi, [rsp+1E8h+var_140]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_22B14:
add rsp, 1B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_22B28:
mov r14, rdx
mov rbx, rax
mov rdi, [rsp+1E8h+var_150]; void *
lea rax, [rsp+1E8h+var_138]
cmp rdi, rax
jz short loc_22B50
mov rsi, [rsp+1E8h+var_140]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_22B50:
mov rdi, rbx; void *
call ___cxa_begin_catch
cmp r14d, 2
jnz loc_22C26
mov rbx, [r12]
test rbx, rbx
jz short loc_22BCB
mov rcx, [rax]
mov rdi, rax
call qword ptr [rcx+10h]
mov ecx, [r12+8]
lea r8, [rsp+1E8h+var_158]; int
mov [r8], rax
mov [r8+10h], rbx
mov [r8+20h], rcx
lea rsi, asc_7F6DE; "{} [{}({})]"
lea rdi, [rsp+1E8h+var_1B8]; int
mov edx, 0Bh; int
mov ecx, 1CCh; int
call _ZN3fmt3v107vformatB5cxx11ENS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEEE; fmt::v10::vformat(fmt::v10::basic_string_view<char>,fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>>)
lea rsi, [rsp+1E8h+var_1B8]
mov rdi, [rsp+1E8h+var_1D0]
call _ZN6spdlog6logger12err_handler_ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; spdlog::logger::err_handler_(std::string const&)
lea rax, [rsp+1E8h+var_1A8]
mov rdi, [rax-10h]
cmp rdi, rax
jz short loc_22C1C
mov rsi, [rsp+1E8h+var_1A8]
jmp short loc_22C14
loc_22BCB:
mov rcx, [rax]
mov rdi, rax
call qword ptr [rcx+10h]
lea rdi, [rsp+1E8h+var_158]
lea rdx, [rsp+1E8h+var_1B8]
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, [rsp+1E8h+var_158]
mov rdi, [rsp+1E8h+var_1D0]
call _ZN6spdlog6logger12err_handler_ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; spdlog::logger::err_handler_(std::string const&)
lea rax, [rsp+1E8h+var_148]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_22C1C
mov rsi, [rsp+1E8h+var_148]
loc_22C14:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_22C1C:
call ___cxa_end_catch
jmp loc_22B14
loc_22C26:
lea r14, [rsp+1E8h+var_148]
mov [r14-10h], r14
lea rsi, aRethrowingUnkn; "Rethrowing unknown exception in logger"
lea rdx, aRethrowingUnkn+26h; ""
lea rdi, [rsp+1E8h+var_158]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, [rsp+1E8h+var_158]
mov rdi, [rsp+1E8h+var_1D0]
call _ZN6spdlog6logger12err_handler_ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; spdlog::logger::err_handler_(std::string const&)
mov rdi, [rsp+1E8h+var_158]; void *
cmp rdi, r14
jz short loc_22C7C
mov rsi, [rsp+1E8h+var_148]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_22C7C:
call ___cxa_rethrow
jmp short loc_22CC5
mov rbx, rax
mov rdi, [rsp+1E8h+var_158]; void *
cmp rdi, r14
jz short loc_22CC8
mov rsi, [rsp+1E8h+var_148]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_22CC8
mov rbx, rax
lea rax, [rsp+1E8h+var_148]
mov rdi, [rax-10h]
cmp rdi, rax
jz short loc_22CF2
mov rsi, [rsp+1E8h+var_148]
jmp short loc_22CE5
jmp short loc_22CEF
loc_22CC5:
mov rbx, rax
loc_22CC8:
call ___cxa_end_catch
jmp short loc_22CF7
mov rbx, rax
lea rax, [rsp+1E8h+var_1A8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_22CF2
mov rsi, [rsp+1E8h+var_1A8]
loc_22CE5:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_22CF2
loc_22CEF:
mov rbx, rax
loc_22CF2:
call ___cxa_end_catch
loc_22CF7:
mov rdi, rbx
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| void spdlog::logger::log_<std::string,int,unsigned long &,unsigned long &>(
long long a1,
int a2,
long long a3,
long long a4,
__int128 *a5,
unsigned int *a6,
long long a7,
long long a8,
long long a9,
long long *a10,
long long *a11)
{
int v13; // r15d
unsigned __int8 v14; // r14
long long v15; // rdx
long long v16; // rcx
long long v17; // rax
__int128 v18; // [rsp+30h] [rbp-1B8h] BYREF
long long v19; // [rsp+40h] [rbp-1A8h]
long long v20; // [rsp+50h] [rbp-198h]
long long v21; // [rsp+60h] [rbp-188h]
void *v22; // [rsp+90h] [rbp-158h] BYREF
void *v23; // [rsp+98h] [rbp-150h]
long long v24; // [rsp+A0h] [rbp-148h]
unsigned long long v25; // [rsp+A8h] [rbp-140h]
_BYTE v26[312]; // [rsp+B0h] [rbp-138h] BYREF
v13 = *(_DWORD *)(a1 + 64);
v14 = spdlog::details::backtracer::enabled((spdlog::details::backtracer *)(a1 + 104));
if ( ((v14 ^ 1) & (v13 > a2)) == 0 )
{
v24 = 0LL;
v22 = &`vtable for'fmt::v10::basic_memory_buffer<char,250ul,std::allocator<char>> + 2;
v23 = v26;
v25 = 250LL;
v15 = *a6;
v16 = *a10;
v17 = *a11;
v18 = *a5;
v19 = v15;
v20 = v16;
v21 = v17;
ZN3fmt3v1010vformat_toINS0_8appenderETnNSt9enable_ifIXsr6detail18is_output_iteratorIT_cEE5valueEiE4typeELi0EEES4_S4_NS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextIS2_cEEEE((long long)&v22);
spdlog::details::log_msg::log_msg(
(unsigned int)&v18,
*(_QWORD *)(a1 + 8),
*(_QWORD *)(a1 + 16),
a2,
(_DWORD)v23,
v24,
a7,
a8,
a9);
spdlog::logger::log_it_(a1, &v18, v13 <= a2, v14);
if ( v23 != v26 )
operator delete(v23, v25);
}
}
| log_<std::__cxx11::string,int,unsigned_long&,unsigned_long&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1b8
MOV R13,R9
MOV RBX,R8
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RSP + 0x20],RDX
MOV EBP,ESI
MOV R15D,dword ptr [RDI + 0x40]
CMP R15D,ESI
SETG R12B
MOV qword ptr [RSP + 0x18],RDI
ADD RDI,0x68
CALL 0x0012c4fa
MOV R14D,EAX
XOR AL,0x1
TEST R12B,AL
JNZ 0x00122b14
MOV RAX,qword ptr [RSP + 0x210]
MOV RCX,qword ptr [RSP + 0x208]
LEA R12,[RSP + 0x1f0]
LEA RSI,[RSP + 0xb0]
MOV qword ptr [RSI + -0x10],0x0
LEA RDX,[0x1b00e8]
ADD RDX,0x10
MOV qword ptr [RSI + -0x20],RDX
MOV qword ptr [RSI + -0x18],RSI
MOV qword ptr [RSI + -0x8],0xfa
MOVUPS XMM0,xmmword ptr [RBX]
MOV EDX,dword ptr [R13]
MOV RCX,qword ptr [RCX]
MOV RAX,qword ptr [RAX]
LEA R8,[RSP + 0x30]
MOVAPS xmmword ptr [R8],XMM0
MOV qword ptr [R8 + 0x10],RDX
MOV qword ptr [R8 + 0x20],RCX
MOV qword ptr [R8 + 0x30],RAX
LAB_00122a81:
LEA RDI,[RSP + 0x90]
MOV ECX,0x441d
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x0011a07d
MOV RBX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RBX + 0x8]
MOV RDX,qword ptr [RBX + 0x10]
MOV R8,qword ptr [RSP + 0x98]
MOV R9,qword ptr [RSP + 0xa0]
LAB_00122aba:
MOV RAX,qword ptr [R12 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0x30]
MOV ECX,EBP
CALL 0x0012c872
XOR EDX,EDX
CMP R15D,EBP
SETLE DL
MOVZX ECX,R14B
LEA RSI,[RSP + 0x30]
MOV RDI,RBX
CALL 0x0012e6f2
LAB_00122af2:
MOV RDI,qword ptr [RSP + 0x98]
LEA RAX,[RSP + 0xb0]
CMP RDI,RAX
JZ 0x00122b14
MOV RSI,qword ptr [RSP + 0xa8]
CALL 0x00111120
LAB_00122b14:
ADD RSP,0x1b8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* void spdlog::logger::log_<std::__cxx11::string, int, unsigned long&, unsigned
long&>(spdlog::source_loc, spdlog::level::level_enum, fmt::v10::basic_string_view<char>,
std::__cxx11::string&&, int&&, unsigned long&, unsigned long&) */
void spdlog::logger::log_<std::__cxx11::string,int,unsigned_long&,unsigned_long&>
(logger *param_1,int param_2,int8 param_3,int8 param_4,
int4 *param_5,uint *param_6,int4 param_7,int4 param_8,
int8 param_9,int8 *param_10,int8 *param_11)
{
int iVar1;
bool bVar2;
int4 local_1b8;
int4 uStack_1b4;
int4 uStack_1b0;
int4 uStack_1ac;
ulong local_1a8;
int8 local_198;
int8 local_188;
int **local_158;
int1 *local_150;
int8 local_148;
ulong local_140;
int1 local_138 [264];
iVar1 = *(int *)(param_1 + 0x40);
bVar2 = (bool)details::backtracer::enabled((backtracer *)(param_1 + 0x68));
if ((param_2 < iVar1 & (bVar2 ^ 1U)) == 0) {
local_150 = local_138;
local_148 = 0;
local_158 = &PTR_grow_001b00f8;
local_140 = 0xfa;
local_1b8 = *param_5;
uStack_1b4 = param_5[1];
uStack_1b0 = param_5[2];
uStack_1ac = param_5[3];
local_1a8 = (ulong)*param_6;
local_198 = *param_10;
local_188 = *param_11;
/* try { // try from 00122a81 to 00122a9c has its CatchHandler @ 00122b26 */
_ZN3fmt3v1010vformat_toINS0_8appenderETnNSt9enable_ifIXsr6detail18is_output_iteratorIT_cEE5valueEiE4typeELi0EEES4_S4_NS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextIS2_cEEEE
(&local_158,param_3,param_4,0x441d);
/* try { // try from 00122aba to 00122af1 has its CatchHandler @ 00122b28 */
details::log_msg::log_msg
((log_msg *)&local_1b8,*(int8 *)(param_1 + 8),*(int8 *)(param_1 + 0x10),
param_2,local_150,local_148,param_7,param_8,param_9);
log_it_(param_1,(log_msg *)&local_1b8,iVar1 <= param_2,bVar2);
if (local_150 != local_138) {
operator_delete(local_150,local_140);
}
}
return;
}
| |
26,311 | testing::TestSuite::TestSuite(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void (*)(), void (*)()) | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc | TestSuite::TestSuite(const std::string& a_name, const char* a_type_param,
internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc)
: name_(a_name),
type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
set_up_tc_(set_up_tc),
tear_down_tc_(tear_down_tc),
should_run_(false),
start_timestamp_(0),
elapsed_time_(0) {} | O1 | cpp | testing::TestSuite::TestSuite(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void (*)(), void (*)()):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r14
leaq 0x367d4(%rip), %rax # 0x58048
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x39594
testq %r13, %r13
je 0x218cf
movl $0x20, %edi
callq 0x84b0
movq %rax, %rbp
addq $0x10, %rax
movq %rax, (%rbp)
movq %r13, %rdi
callq 0x8200
leaq (%rax,%r13), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x39504
jmp 0x218d1
xorl %ebp, %ebp
leaq 0x28(%r14), %r13
movq %rbp, 0x28(%r14)
leaq 0x30(%r14), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x50(%r14)
movq %r12, 0x60(%r14)
movq %r15, 0x68(%r14)
movb $0x0, 0x70(%r14)
leaq 0x88(%r14), %rdi
movups %xmm0, 0x78(%r14)
callq 0x33e3c
xorps %xmm0, %xmm0
movups %xmm0, 0xe0(%r14)
movups %xmm0, 0xd0(%r14)
movups %xmm0, 0xc0(%r14)
movl $0x0, 0xf0(%r14)
movups %xmm0, 0xf8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x20, %esi
movq %rbp, %rdi
callq 0x84e0
jmp 0x21987
movq %rax, %r15
jmp 0x21987
movq %rax, %r15
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x21979
movq 0x58(%r14), %rsi
subq %rdi, %rsi
callq 0x84e0
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x8c7f
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x2199f
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x84e0
movq %r15, %rdi
callq 0x8990
nop
| _ZN7testing9TestSuiteC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKcPFvvESC_:
push rbp; Alternative name is 'testing::TestSuite::TestSuite(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void (*)(void), void (*)(void))'
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, r8
mov r12, rcx
mov r13, rdx
mov r14, rdi
lea rax, off_58048
mov [rdi], rax
lea rbx, [rdi+8]
lea rax, [rdi+18h]
mov [rsp+38h+var_38], rax
mov [rdi+8], rax
mov rax, [rsi]
mov rdx, [rsi+8]
add rdx, rax
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)
test r13, r13
jz short loc_218CF
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
mov rbp, rax
add rax, 10h
mov [rbp+0], rax
mov rdi, r13
call _strlen
lea rdx, [rax+r13]
mov rdi, rbp
mov rsi, r13
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
jmp short loc_218D1
loc_218CF:
xor ebp, ebp
loc_218D1:
lea r13, [r14+28h]
mov [r14+28h], rbp
lea rbp, [r14+30h]
xorps xmm0, xmm0
movups xmmword ptr [r14+30h], xmm0
movups xmmword ptr [r14+40h], xmm0
movups xmmword ptr [r14+50h], xmm0
mov [r14+60h], r12
mov [r14+68h], r15
mov byte ptr [r14+70h], 0
lea rdi, [r14+88h]; this
movups xmmword ptr [r14+78h], xmm0
call _ZN7testing8internal5MutexC2Ev; testing::internal::Mutex::Mutex(void)
xorps xmm0, xmm0
movups xmmword ptr [r14+0E0h], xmm0
movups xmmword ptr [r14+0D0h], xmm0
movups xmmword ptr [r14+0C0h], xmm0
mov dword ptr [r14+0F0h], 0
movups xmmword ptr [r14+0F8h], xmm0
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r15, rax
mov esi, 20h ; ' '; unsigned __int64
mov rdi, rbp; void *
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_21987
mov r15, rax
jmp short loc_21987
mov r15, rax
mov rdi, [r14+48h]; void *
test rdi, rdi
jz short loc_21979
mov rsi, [r14+58h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_21979:
mov rdi, rbp
mov rsi, r13
mov rdx, r14
call _ZN7testing9TestSuiteC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKcPFvvESC__cold_1; testing::TestSuite::TestSuite(std::string const&,char const*,void (*)(void),void (*)(void)) [clone]
loc_21987:
mov rdi, [rbx]; void *
cmp rdi, [rsp+0]
jz short loc_2199F
mov rax, [rsp+0]
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2199F:
mov rdi, r15
call __Unwind_Resume
| long long testing::TestSuite::TestSuite(long long a1, _QWORD *a2, long long a3, long long a4, long long a5)
{
_QWORD *v8; // rbp
long long v9; // rax
long long result; // rax
*(_QWORD *)a1 = off_58048;
*(_QWORD *)(a1 + 8) = a1 + 24;
std::string::_M_construct<char *>(a1 + 8, *a2, *a2 + a2[1]);
if ( a3 )
{
v8 = (_QWORD *)operator new(0x20uLL);
*v8 = v8 + 2;
v9 = strlen(a3);
std::string::_M_construct<char const*>(v8, a3, v9 + a3);
}
else
{
v8 = 0LL;
}
*(_QWORD *)(a1 + 40) = v8;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 80) = 0LL;
*(_QWORD *)(a1 + 96) = a4;
*(_QWORD *)(a1 + 104) = a5;
*(_BYTE *)(a1 + 112) = 0;
*(_OWORD *)(a1 + 120) = 0LL;
result = testing::internal::Mutex::Mutex((testing::internal::Mutex *)(a1 + 136));
*(_OWORD *)(a1 + 224) = 0LL;
*(_OWORD *)(a1 + 208) = 0LL;
*(_OWORD *)(a1 + 192) = 0LL;
*(_DWORD *)(a1 + 240) = 0;
*(_OWORD *)(a1 + 248) = 0LL;
return result;
}
| TestSuite:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,R8
MOV R12,RCX
MOV R13,RDX
MOV R14,RDI
LEA RAX,[0x158048]
MOV qword ptr [RDI],RAX
LEA RBX,[RDI + 0x8]
LEA RAX,[RDI + 0x18]
MOV qword ptr [RSP],RAX
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
ADD RDX,RAX
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00139594
TEST R13,R13
JZ 0x001218cf
LAB_001218a1:
MOV EDI,0x20
CALL 0x001084b0
MOV RBP,RAX
ADD RAX,0x10
MOV qword ptr [RBP],RAX
MOV RDI,R13
CALL 0x00108200
LEA RDX,[RAX + R13*0x1]
LAB_001218c2:
MOV RDI,RBP
MOV RSI,R13
CALL 0x00139504
JMP 0x001218d1
LAB_001218cf:
XOR EBP,EBP
LAB_001218d1:
LEA R13,[R14 + 0x28]
MOV qword ptr [R14 + 0x28],RBP
LEA RBP,[R14 + 0x30]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x30],XMM0
MOVUPS xmmword ptr [R14 + 0x40],XMM0
MOVUPS xmmword ptr [R14 + 0x50],XMM0
MOV qword ptr [R14 + 0x60],R12
MOV qword ptr [R14 + 0x68],R15
MOV byte ptr [R14 + 0x70],0x0
LEA RDI,[R14 + 0x88]
MOVUPS xmmword ptr [R14 + 0x78],XMM0
LAB_00121908:
CALL 0x00133e3c
LAB_0012190d:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0xe0],XMM0
MOVUPS xmmword ptr [R14 + 0xd0],XMM0
MOVUPS xmmword ptr [R14 + 0xc0],XMM0
MOV dword ptr [R14 + 0xf0],0x0
MOVUPS xmmword ptr [R14 + 0xf8],XMM0
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* testing::TestSuite::TestSuite(std::__cxx11::string const&, char const*, void (*)(), void (*)())
*/
void __thiscall
testing::TestSuite::TestSuite
(TestSuite *this,string *param_1,char *param_2,_func_void *param_3,_func_void *param_4)
{
long *plVar1;
size_t sVar2;
*(int ***)this = &PTR__TestSuite_00158048;
*(TestSuite **)(this + 8) = this + 0x18;
std::__cxx11::string::_M_construct<char*>
(this + 8,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
if (param_2 == (char *)0x0) {
plVar1 = (long *)0x0;
}
else {
/* try { // try from 001218a1 to 001218aa has its CatchHandler @ 0012195c */
plVar1 = (long *)operator_new(0x20);
*plVar1 = (long)(plVar1 + 2);
sVar2 = strlen(param_2);
/* try { // try from 001218c2 to 001218cc has its CatchHandler @ 0012194a */
std::__cxx11::string::_M_construct<char_const*>(plVar1,param_2,param_2 + sVar2);
}
*(long **)(this + 0x28) = plVar1;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
*(_func_void **)(this + 0x60) = param_3;
*(_func_void **)(this + 0x68) = param_4;
this[0x70] = (TestSuite)0x0;
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
/* try { // try from 00121908 to 0012190c has its CatchHandler @ 00121961 */
internal::Mutex::Mutex((Mutex *)(this + 0x88));
*(int8 *)(this + 0xe0) = 0;
*(int8 *)(this + 0xe8) = 0;
*(int8 *)(this + 0xd0) = 0;
*(int8 *)(this + 0xd8) = 0;
*(int8 *)(this + 0xc0) = 0;
*(int8 *)(this + 200) = 0;
*(int4 *)(this + 0xf0) = 0;
*(int8 *)(this + 0xf8) = 0;
*(int8 *)(this + 0x100) = 0;
return;
}
| |
26,312 | ma_stmt_execute_generate_simple_request | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | unsigned char* ma_stmt_execute_generate_simple_request(MYSQL_STMT *stmt, size_t *request_len)
{
/* execute packet has the following format:
Offset Length Description
-----------------------------------------
0 4 Statement id
4 1 Flags (cursor type)
5 4 Iteration count
-----------------------------------------
if (stmt->param_count):
6 (paramcount+7)/8 null bitmap
------------------------------------------
if (stmt->send_types_to_server):
param_count*2 parameter types
1st byte: parameter type
2nd byte flag:
unsigned flag (32768)
indicator variable exists (16384)
------------------------------------------
n data from bind_buffer
*/
size_t length= 1024;
size_t free_bytes= 0;
size_t null_byte_offset= 0;
uint i;
uchar *start= NULL, *p;
/* preallocate length bytes */
/* check: gr */
if (!(start= p= (uchar *)malloc(length)))
goto mem_error;
int4store(p, stmt->stmt_id);
p += STMT_ID_LENGTH;
/* flags is 4 bytes, we store just 1 */
int1store(p, (unsigned char) stmt->flags);
p++;
int4store(p, 1);
p+= 4;
if (stmt->param_count)
{
size_t null_count= (stmt->param_count + 7) / 8;
free_bytes= length - (p - start);
if (null_count + 20 > free_bytes)
{
size_t offset= p - start;
length+= offset + null_count + 20;
if (!(start= (uchar *)realloc(start, length)))
goto mem_error;
p= start + offset;
}
null_byte_offset= p - start;
memset(p, 0, null_count);
p += null_count;
int1store(p, stmt->send_types_to_server);
p++;
free_bytes= length - (p - start);
/* Store type information:
2 bytes per type
*/
if (stmt->send_types_to_server)
{
if (free_bytes < stmt->param_count * 2 + 20)
{
size_t offset= p - start;
length= offset + stmt->param_count * 2 + 20;
if (!(start= (uchar *)realloc(start, length)))
goto mem_error;
p= start + offset;
}
for (i = 0; i < stmt->param_count; i++)
{
/* this differs from mysqlnd, c api supports unsigned !! */
uint buffer_type= stmt->params[i].buffer_type | (stmt->params[i].is_unsigned ? 32768 : 0);
/* check if parameter requires indicator variable */
int2store(p, buffer_type);
p+= 2;
}
}
/* calculate data size */
for (i=0; i < stmt->param_count; i++)
{
size_t size= 0;
my_bool has_data= TRUE;
if (stmt->params[i].long_data_used)
{
has_data= FALSE;
stmt->params[i].long_data_used= 0;
}
if (has_data)
{
switch (stmt->params[i].buffer_type) {
case MYSQL_TYPE_NULL:
has_data= FALSE;
break;
case MYSQL_TYPE_TINY_BLOB:
case MYSQL_TYPE_MEDIUM_BLOB:
case MYSQL_TYPE_LONG_BLOB:
case MYSQL_TYPE_BLOB:
case MYSQL_TYPE_VARCHAR:
case MYSQL_TYPE_VAR_STRING:
case MYSQL_TYPE_STRING:
case MYSQL_TYPE_JSON:
case MYSQL_TYPE_DECIMAL:
case MYSQL_TYPE_NEWDECIMAL:
case MYSQL_TYPE_GEOMETRY:
case MYSQL_TYPE_NEWDATE:
case MYSQL_TYPE_ENUM:
case MYSQL_TYPE_BIT:
case MYSQL_TYPE_SET:
size+= 9; /* max 8 bytes for size */
size+= (size_t)ma_get_length(stmt, i, 0);
break;
case MYSQL_TYPE_TIME:
size+= MAX_TIME_STR_LEN;
break;
case MYSQL_TYPE_DATE:
size+= MAX_DATE_STR_LEN;
break;
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
size+= MAX_DATETIME_STR_LEN;
break;
default:
size+= mysql_ps_fetch_functions[stmt->params[i].buffer_type].pack_len;
break;
}
}
free_bytes= length - (p - start);
if (free_bytes < size + 20)
{
size_t offset= p - start;
length= MAX(2 * length, offset + size + 20);
if (!(start= (uchar *)realloc(start, length)))
goto mem_error;
p= start + offset;
}
if (((stmt->params[i].is_null && *stmt->params[i].is_null) ||
stmt->params[i].buffer_type == MYSQL_TYPE_NULL ||
!stmt->params[i].buffer))
{
has_data= FALSE;
(start + null_byte_offset)[i/8] |= (unsigned char) (1 << (i & 7));
}
if (has_data)
{
store_param(stmt, i, &p, 0);
}
}
}
stmt->send_types_to_server= 0;
*request_len = (size_t)(p - start);
return start;
mem_error:
SET_CLIENT_STMT_ERROR(stmt, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
free(start);
*request_len= 0;
return NULL;
} | O3 | c | ma_stmt_execute_generate_simple_request:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x30(%rbp)
movl $0x400, %edi # imm = 0x400
callq 0x13610
testq %rax, %rax
je 0x2227f
movq %rax, %r15
movq -0x30(%rbp), %rdi
movl 0x40(%rdi), %eax
movl %eax, (%r15)
movb 0x48(%rdi), %al
movb %al, 0x4(%r15)
movl $0x1, 0x5(%r15)
movq %r15, %rbx
addq $0x9, %rbx
movl 0x64(%rdi), %eax
testl %eax, %eax
je 0x2211c
movq %rax, -0x40(%rbp)
addl $0x7, %eax
movl %eax, %r13d
shrl $0x3, %r13d
movl $0x400, %r12d # imm = 0x400
cmpl $0x1f20, %eax # imm = 0x1F20
jb 0x22059
leaq 0x41d(%r13), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x13740
testq %rax, %rax
je 0x2227f
movq %rax, %r15
movq %rax, %rbx
addq $0x9, %rbx
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %rbx, %r14
callq 0x13260
movq %rbx, %r9
movq -0x30(%rbp), %rdi
movb 0x68(%rdi), %al
addq %r13, %rbx
incq %rbx
movb %al, -0x1(%rbx)
movq %rbx, -0x38(%rbp)
testb %al, %al
je 0x22124
movq %rbx, %r13
subq %r15, %r13
movq %r12, %rax
subq %r13, %rax
movq -0x40(%rbp), %rdx
leal 0x14(,%rdx,2), %ecx
movq %r15, %r10
cmpq %rcx, %rax
jae 0x220d7
addl %edx, %edx
movl %edx, %eax
leaq (%rax,%r13), %r12
addq $0x14, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x13740
testq %rax, %rax
je 0x2227f
movq %rax, %r10
addq %rax, %r13
movq %r13, %rbx
movq -0x30(%rbp), %rdi
movq %r14, %r9
movl $0x30, %eax
xorl %ecx, %ecx
movq 0x70(%rdi), %rsi
movl (%rsi,%rax,2), %r8d
xorl %edx, %edx
cmpb $0x0, 0x5(%rsi,%rax,2)
setne %dl
shll $0xf, %edx
orl %r8d, %edx
movb %r8b, (%rbx)
movb %dh, 0x1(%rbx)
addq $0x2, %rbx
incq %rcx
movl 0x64(%rdi), %edx
addq $0x38, %rax
cmpq %rdx, %rcx
jb 0x220de
movq %rbx, -0x38(%rbp)
testl %edx, %edx
jne 0x22127
jmp 0x22276
movq %r15, %r10
jmp 0x22276
movq %r15, %r10
subq %r15, %r9
xorl %r15d, %r15d
xorl %ebx, %ebx
movq %r9, -0x40(%rbp)
movq 0x70(%rdi), %rax
cmpb $0x0, 0x66(%rax,%r15)
je 0x2214c
movb $0x0, 0x66(%rax,%r15)
movb $0x1, %r13b
xorl %eax, %eax
jmp 0x221b4
movl 0x60(%rax,%r15), %ecx
leal -0xf5(%rcx), %edx
cmpl $0xb, %edx
jb 0x22173
cmpl $0x10, %ecx
ja 0x221a1
movl %ecx, %edx
leaq 0x19dbe(%rip), %rsi # 0x3bf28
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movq (%rax,%r15), %rax
testq %rax, %rax
je 0x22185
movq (%rax), %rax
addq $0x9, %rax
jmp 0x221b1
movl $0x9, %eax
jmp 0x221b1
movl $0xc, %eax
jmp 0x221b1
movl $0x5, %eax
jmp 0x221b1
movl $0xd, %eax
jmp 0x221b1
leaq (%rcx,%rcx,2), %rax
leaq 0x2c114(%rip), %rcx # 0x4e2c0
movslq 0x8(%rcx,%rax,8), %rax
xorl %r13d, %r13d
movq -0x38(%rbp), %r14
subq %r10, %r14
movq %r12, %rcx
subq %r14, %rcx
addq $0x14, %rax
cmpq %rax, %rcx
jae 0x22203
movq %r12, %rcx
addq %r12, %rcx
addq %r14, %rax
cmpq %rax, %rcx
movq %rax, %r12
cmovaq %rcx, %r12
movq %r10, %rdi
movq %r12, %rsi
callq 0x13740
testq %rax, %rax
je 0x2227f
movq %rax, %r10
addq %rax, %r14
movq %r14, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %r9
movq 0x70(%rdi), %rax
movq 0x8(%rax,%r15), %rcx
testq %rcx, %rcx
je 0x22216
cmpb $0x0, (%rcx)
jne 0x22248
cmpl $0x6, 0x60(%rax,%r15)
je 0x22248
cmpq $0x0, 0x10(%rax,%r15)
je 0x22248
testb %r13b, %r13b
jne 0x2225f
movl %ebx, %esi
leaq -0x38(%rbp), %rdx
xorl %ecx, %ecx
movq %r10, %r14
callq 0x21b15
movq %r14, %r10
movq -0x40(%rbp), %r9
movq -0x30(%rbp), %rdi
jmp 0x2225f
movl %ebx, %ecx
andb $0x7, %cl
movb $0x1, %al
shlb %cl, %al
leaq (%r10,%r9), %rcx
movq %rbx, %rdx
shrq $0x3, %rdx
orb %al, (%rdx,%rcx)
incq %rbx
movl 0x64(%rdi), %eax
addq $0x70, %r15
cmpq %rax, %rbx
jb 0x22133
movq -0x38(%rbp), %rbx
movb $0x0, 0x68(%rdi)
subq %r10, %rbx
jmp 0x222d8
movq -0x30(%rbp), %r14
movl $0x7d8, 0x108(%r14) # imm = 0x7D8
leaq 0x30d(%r14), %rdi
leaq 0x2bae4(%rip), %rax # 0x4dd80
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %ebx, %ebx
movb %bl, 0x312(%r14)
leaq 0x10c(%r14), %rdi
leaq 0x2bad0(%rip), %rax # 0x4dd90
movq 0x40(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movb %bl, 0x30b(%r14)
xorl %r10d, %r10d
movq -0x48(%rbp), %rax
movq %rbx, (%rax)
movq %r10, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_stmt_execute_generate_simple_request:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_48], rsi
mov [rbp+var_30], rdi
mov edi, 400h
call _malloc
test rax, rax
jz loc_2227F
mov r15, rax
mov rdi, [rbp+var_30]
mov eax, [rdi+40h]
mov [r15], eax
mov al, [rdi+48h]
mov [r15+4], al
mov dword ptr [r15+5], 1
mov rbx, r15
add rbx, 9
mov eax, [rdi+64h]
test eax, eax
jz loc_2211C
mov [rbp+var_40], rax
add eax, 7
mov r13d, eax
shr r13d, 3
mov r12d, 400h
cmp eax, 1F20h
jb short loc_22059
lea r12, [r13+41Dh]
mov rdi, r15
mov rsi, r12
call _realloc
test rax, rax
jz loc_2227F
mov r15, rax
mov rbx, rax
add rbx, 9
loc_22059:
mov rdi, rbx
xor esi, esi
mov rdx, r13
mov r14, rbx
call _memset
mov r9, rbx
mov rdi, [rbp+var_30]
mov al, [rdi+68h]
add rbx, r13
inc rbx
mov [rbx-1], al
mov [rbp+var_38], rbx
test al, al
jz loc_22124
mov r13, rbx
sub r13, r15
mov rax, r12
sub rax, r13
mov rdx, [rbp+var_40]
lea ecx, ds:14h[rdx*2]
mov r10, r15
cmp rax, rcx
jnb short loc_220D7
add edx, edx
mov eax, edx
lea r12, [rax+r13]
add r12, 14h
mov rdi, r15
mov rsi, r12
call _realloc
test rax, rax
jz loc_2227F
mov r10, rax
add r13, rax
mov rbx, r13
mov rdi, [rbp+var_30]
mov r9, r14
loc_220D7:
mov eax, 30h ; '0'
xor ecx, ecx
loc_220DE:
mov rsi, [rdi+70h]
mov r8d, [rsi+rax*2]
xor edx, edx
cmp byte ptr [rsi+rax*2+5], 0
setnz dl
shl edx, 0Fh
or edx, r8d
mov [rbx], r8b
mov [rbx+1], dh
add rbx, 2
inc rcx
mov edx, [rdi+64h]
add rax, 38h ; '8'
cmp rcx, rdx
jb short loc_220DE
mov [rbp+var_38], rbx
test edx, edx
jnz short loc_22127
jmp loc_22276
loc_2211C:
mov r10, r15
jmp loc_22276
loc_22124:
mov r10, r15
loc_22127:
sub r9, r15
xor r15d, r15d
xor ebx, ebx
mov [rbp+var_40], r9
loc_22133:
mov rax, [rdi+70h]
cmp byte ptr [rax+r15+66h], 0
jz short loc_2214C
mov byte ptr [rax+r15+66h], 0
loc_22145:
mov r13b, 1; jumptable 0000000000022171 case 6
xor eax, eax
jmp short loc_221B4
loc_2214C:
mov ecx, [rax+r15+60h]
lea edx, [rcx-0F5h]
cmp edx, 0Bh
jb short loc_22173; jumptable 0000000000022171 cases 0,14-16
cmp ecx, 10h; switch 17 cases
ja short def_22171; jumptable 0000000000022171 default case, cases 1-5,8,9,13
mov edx, ecx
lea rsi, jpt_22171
movsxd rdx, ds:(jpt_22171 - 3BF28h)[rsi+rdx*4]
add rdx, rsi
jmp rdx; switch jump
loc_22173:
mov rax, [rax+r15]; jumptable 0000000000022171 cases 0,14-16
test rax, rax
jz short loc_22185
mov rax, [rax]
add rax, 9
jmp short loc_221B1
loc_22185:
mov eax, 9
jmp short loc_221B1
loc_2218C:
mov eax, 0Ch; jumptable 0000000000022171 cases 7,12
jmp short loc_221B1
loc_22193:
mov eax, 5; jumptable 0000000000022171 case 10
jmp short loc_221B1
loc_2219A:
mov eax, 0Dh; jumptable 0000000000022171 case 11
jmp short loc_221B1
def_22171:
lea rax, [rcx+rcx*2]; jumptable 0000000000022171 default case, cases 1-5,8,9,13
lea rcx, mysql_ps_fetch_functions
movsxd rax, dword ptr [rcx+rax*8+8]
loc_221B1:
xor r13d, r13d
loc_221B4:
mov r14, [rbp+var_38]
sub r14, r10
mov rcx, r12
sub rcx, r14
add rax, 14h
cmp rcx, rax
jnb short loc_22203
mov rcx, r12
add rcx, r12
add rax, r14
cmp rcx, rax
mov r12, rax
cmova r12, rcx
mov rdi, r10
mov rsi, r12
call _realloc
test rax, rax
jz loc_2227F
mov r10, rax
add r14, rax
mov [rbp+var_38], r14
mov rdi, [rbp+var_30]
mov r9, [rbp+var_40]
loc_22203:
mov rax, [rdi+70h]
mov rcx, [rax+r15+8]
test rcx, rcx
jz short loc_22216
cmp byte ptr [rcx], 0
jnz short loc_22248
loc_22216:
cmp dword ptr [rax+r15+60h], 6
jz short loc_22248
cmp qword ptr [rax+r15+10h], 0
jz short loc_22248
test r13b, r13b
jnz short loc_2225F
mov esi, ebx
lea rdx, [rbp+var_38]
xor ecx, ecx
mov r14, r10
call store_param
mov r10, r14
mov r9, [rbp+var_40]
mov rdi, [rbp+var_30]
jmp short loc_2225F
loc_22248:
mov ecx, ebx
and cl, 7
mov al, 1
shl al, cl
lea rcx, [r10+r9]
mov rdx, rbx
shr rdx, 3
or [rdx+rcx], al
loc_2225F:
inc rbx
mov eax, [rdi+64h]
add r15, 70h ; 'p'
cmp rbx, rax
jb loc_22133
mov rbx, [rbp+var_38]
loc_22276:
mov byte ptr [rdi+68h], 0
sub rbx, r10
jmp short loc_222D8
loc_2227F:
mov r14, [rbp+var_30]
mov dword ptr [r14+108h], 7D8h
lea rdi, [r14+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor ebx, ebx
mov [r14+312h], bl
lea rdi, [r14+10Ch]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 200h
call _strncpy
mov [r14+30Bh], bl
xor r10d, r10d
loc_222D8:
mov rax, [rbp+var_48]
mov [rax], rbx
mov rax, r10
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_stmt_execute_generate_simple_request(long long a1, _QWORD *a2)
{
long long v2; // rax
long long v3; // r15
long long v4; // rdi
_BYTE *v5; // rbx
int v6; // eax
unsigned int v7; // eax
long long v8; // r13
long long v9; // r12
long long v10; // rax
_BYTE *v11; // r14
_BYTE *v12; // r9
char v13; // al
_BYTE *v14; // r13
long long v15; // r10
long long v16; // rax
long long v17; // rax
unsigned long long v18; // rcx
long long v19; // rsi
int v20; // r8d
char v21; // dh
unsigned long long v22; // rdx
_BYTE *v23; // r9
long long v24; // r15
unsigned long long v25; // rbx
long long v26; // rax
char v27; // r13
long long v28; // rax
long long v29; // rcx
_QWORD *v30; // rax
_BYTE *v31; // r14
unsigned long long v32; // rax
long long v33; // rcx
unsigned long long v34; // rax
bool v35; // cc
long long v36; // rax
long long v37; // rax
_BYTE *v38; // rcx
long long v39; // r14
_BYTE *v40; // rbx
long long v41; // r14
int v44; // [rsp+10h] [rbp-40h]
_BYTE *v45; // [rsp+10h] [rbp-40h]
_BYTE *v46; // [rsp+18h] [rbp-38h] BYREF
long long v47; // [rsp+20h] [rbp-30h]
v47 = a1;
v2 = malloc(1024LL);
if ( !v2 )
goto LABEL_45;
v3 = v2;
v4 = v47;
*(_DWORD *)v2 = *(_DWORD *)(v47 + 64);
*(_BYTE *)(v2 + 4) = *(_BYTE *)(v4 + 72);
*(_DWORD *)(v2 + 5) = 1;
v5 = (_BYTE *)(v2 + 9);
v6 = *(_DWORD *)(v4 + 100);
if ( v6 )
{
v44 = *(_DWORD *)(v4 + 100);
v7 = v6 + 7;
v8 = v7 >> 3;
v9 = 1024LL;
if ( v7 >= 0x1F20 )
{
v9 = v8 + 1053;
v10 = realloc(v3, v8 + 1053);
if ( !v10 )
goto LABEL_45;
v3 = v10;
v5 = (_BYTE *)(v10 + 9);
}
v11 = v5;
memset(v5, 0LL, v8);
v12 = v5;
v4 = v47;
v13 = *(_BYTE *)(v47 + 104);
v5 += v8 + 1;
*(v5 - 1) = v13;
v46 = v5;
if ( !v13 )
{
v15 = v3;
goto LABEL_16;
}
v14 = &v5[-v3];
v15 = v3;
if ( v9 - (long long)&v5[-v3] >= (unsigned long long)(unsigned int)(2 * v44 + 20) )
{
LABEL_10:
v17 = 48LL;
v18 = 0LL;
do
{
v19 = *(_QWORD *)(v4 + 112);
v20 = *(_DWORD *)(v19 + 2 * v17);
v21 = BYTE1(v20) | ((*(_BYTE *)(v19 + 2 * v17 + 5) != 0) << 7);
*v5 = v20;
v5[1] = v21;
v5 += 2;
++v18;
v22 = *(unsigned int *)(v4 + 100);
v17 += 56LL;
}
while ( v18 < v22 );
v46 = v5;
if ( !(_DWORD)v22 )
goto LABEL_44;
LABEL_16:
v23 = &v12[-v3];
v24 = 0LL;
v25 = 0LL;
v45 = v23;
do
{
v26 = *(_QWORD *)(v4 + 112);
if ( *(_BYTE *)(v26 + v24 + 102) )
{
*(_BYTE *)(v26 + v24 + 102) = 0;
LABEL_19:
v27 = 1;
v28 = 0LL;
}
else
{
v29 = *(unsigned int *)(v26 + v24 + 96);
if ( (unsigned int)(v29 - 245) >= 0xB )
{
switch ( (int)v29 )
{
case 0:
case 14:
case 15:
case 16:
break;
case 6:
goto LABEL_19;
case 7:
case 12:
v28 = 12LL;
goto LABEL_29;
case 10:
v28 = 5LL;
goto LABEL_29;
case 11:
v28 = 13LL;
goto LABEL_29;
default:
v28 = mysql_ps_fetch_functions[6 * v29 + 2];
goto LABEL_29;
}
}
v30 = *(_QWORD **)(v26 + v24);
if ( v30 )
v28 = *v30 + 9LL;
else
v28 = 9LL;
LABEL_29:
v27 = 0;
}
v31 = &v46[-v15];
v32 = v28 + 20;
if ( v9 - (long long)&v46[-v15] < v32 )
{
v33 = 2 * v9;
v34 = (unsigned long long)&v31[v32];
v35 = 2 * v9 <= v34;
v9 = v34;
if ( !v35 )
v9 = v33;
v36 = realloc(v15, v9);
if ( !v36 )
goto LABEL_45;
v15 = v36;
v46 = &v31[v36];
v4 = v47;
v23 = v45;
}
v37 = *(_QWORD *)(v4 + 112);
v38 = *(_BYTE **)(v37 + v24 + 8);
if ( v38 && *v38 || *(_DWORD *)(v37 + v24 + 96) == 6 || !*(_QWORD *)(v37 + v24 + 16) )
{
v23[v15 + (v25 >> 3)] |= 1 << (v25 & 7);
}
else if ( !v27 )
{
v39 = v15;
store_param(v4, v25, &v46, 0LL);
v15 = v39;
v23 = v45;
v4 = v47;
}
++v25;
v24 += 112LL;
}
while ( v25 < *(unsigned int *)(v4 + 100) );
v5 = v46;
goto LABEL_44;
}
v9 = (long long)&v14[2 * v44 + 20];
v16 = realloc(v3, v9);
if ( v16 )
{
v15 = v16;
v5 = &v14[v16];
v4 = v47;
v12 = v11;
goto LABEL_10;
}
LABEL_45:
v41 = v47;
*(_DWORD *)(v47 + 264) = 2008;
strncpy(v41 + 781, SQLSTATE_UNKNOWN, 5LL);
v40 = 0LL;
*(_BYTE *)(v41 + 786) = 0;
strncpy(v41 + 268, client_errors[8], 512LL);
*(_BYTE *)(v41 + 779) = 0;
v15 = 0LL;
goto LABEL_46;
}
v15 = v3;
LABEL_44:
*(_BYTE *)(v4 + 104) = 0;
v40 = &v5[-v15];
LABEL_46:
*a2 = v40;
return v15;
}
| ma_stmt_execute_generate_simple_request:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x48],RSI
MOV qword ptr [RBP + -0x30],RDI
MOV EDI,0x400
CALL 0x00113610
TEST RAX,RAX
JZ 0x0012227f
MOV R15,RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RDI + 0x40]
MOV dword ptr [R15],EAX
MOV AL,byte ptr [RDI + 0x48]
MOV byte ptr [R15 + 0x4],AL
MOV dword ptr [R15 + 0x5],0x1
MOV RBX,R15
ADD RBX,0x9
MOV EAX,dword ptr [RDI + 0x64]
TEST EAX,EAX
JZ 0x0012211c
MOV qword ptr [RBP + -0x40],RAX
ADD EAX,0x7
MOV R13D,EAX
SHR R13D,0x3
MOV R12D,0x400
CMP EAX,0x1f20
JC 0x00122059
LEA R12,[R13 + 0x41d]
MOV RDI,R15
MOV RSI,R12
CALL 0x00113740
TEST RAX,RAX
JZ 0x0012227f
MOV R15,RAX
MOV RBX,RAX
ADD RBX,0x9
LAB_00122059:
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,R13
MOV R14,RBX
CALL 0x00113260
MOV R9,RBX
MOV RDI,qword ptr [RBP + -0x30]
MOV AL,byte ptr [RDI + 0x68]
ADD RBX,R13
INC RBX
MOV byte ptr [RBX + -0x1],AL
MOV qword ptr [RBP + -0x38],RBX
TEST AL,AL
JZ 0x00122124
MOV R13,RBX
SUB R13,R15
MOV RAX,R12
SUB RAX,R13
MOV RDX,qword ptr [RBP + -0x40]
LEA ECX,[0x14 + RDX*0x2]
MOV R10,R15
CMP RAX,RCX
JNC 0x001220d7
ADD EDX,EDX
MOV EAX,EDX
LEA R12,[RAX + R13*0x1]
ADD R12,0x14
MOV RDI,R15
MOV RSI,R12
CALL 0x00113740
TEST RAX,RAX
JZ 0x0012227f
MOV R10,RAX
ADD R13,RAX
MOV RBX,R13
MOV RDI,qword ptr [RBP + -0x30]
MOV R9,R14
LAB_001220d7:
MOV EAX,0x30
XOR ECX,ECX
LAB_001220de:
MOV RSI,qword ptr [RDI + 0x70]
MOV R8D,dword ptr [RSI + RAX*0x2]
XOR EDX,EDX
CMP byte ptr [RSI + RAX*0x2 + 0x5],0x0
SETNZ DL
SHL EDX,0xf
OR EDX,R8D
MOV byte ptr [RBX],R8B
MOV byte ptr [RBX + 0x1],DH
ADD RBX,0x2
INC RCX
MOV EDX,dword ptr [RDI + 0x64]
ADD RAX,0x38
CMP RCX,RDX
JC 0x001220de
MOV qword ptr [RBP + -0x38],RBX
TEST EDX,EDX
JNZ 0x00122127
JMP 0x00122276
LAB_0012211c:
MOV R10,R15
JMP 0x00122276
LAB_00122124:
MOV R10,R15
LAB_00122127:
SUB R9,R15
XOR R15D,R15D
XOR EBX,EBX
MOV qword ptr [RBP + -0x40],R9
LAB_00122133:
MOV RAX,qword ptr [RDI + 0x70]
CMP byte ptr [RAX + R15*0x1 + 0x66],0x0
JZ 0x0012214c
MOV byte ptr [RAX + R15*0x1 + 0x66],0x0
caseD_6:
MOV R13B,0x1
XOR EAX,EAX
JMP 0x001221b4
LAB_0012214c:
MOV ECX,dword ptr [RAX + R15*0x1 + 0x60]
LEA EDX,[RCX + -0xf5]
CMP EDX,0xb
JC 0x00122173
CMP ECX,0x10
JA 0x001221a1
MOV EDX,ECX
LEA RSI,[0x13bf28]
MOVSXD RDX,dword ptr [RSI + RDX*0x4]
ADD RDX,RSI
switchD:
JMP RDX
caseD_0:
MOV RAX,qword ptr [RAX + R15*0x1]
TEST RAX,RAX
JZ 0x00122185
MOV RAX,qword ptr [RAX]
ADD RAX,0x9
JMP 0x001221b1
LAB_00122185:
MOV EAX,0x9
JMP 0x001221b1
caseD_7:
MOV EAX,0xc
JMP 0x001221b1
caseD_a:
MOV EAX,0x5
JMP 0x001221b1
caseD_b:
MOV EAX,0xd
JMP 0x001221b1
caseD_1:
LEA RAX,[RCX + RCX*0x2]
LEA RCX,[0x14e2c0]
MOVSXD RAX,dword ptr [RCX + RAX*0x8 + 0x8]
LAB_001221b1:
XOR R13D,R13D
LAB_001221b4:
MOV R14,qword ptr [RBP + -0x38]
SUB R14,R10
MOV RCX,R12
SUB RCX,R14
ADD RAX,0x14
CMP RCX,RAX
JNC 0x00122203
MOV RCX,R12
ADD RCX,R12
ADD RAX,R14
CMP RCX,RAX
MOV R12,RAX
CMOVA R12,RCX
MOV RDI,R10
MOV RSI,R12
CALL 0x00113740
TEST RAX,RAX
JZ 0x0012227f
MOV R10,RAX
ADD R14,RAX
MOV qword ptr [RBP + -0x38],R14
MOV RDI,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x40]
LAB_00122203:
MOV RAX,qword ptr [RDI + 0x70]
MOV RCX,qword ptr [RAX + R15*0x1 + 0x8]
TEST RCX,RCX
JZ 0x00122216
CMP byte ptr [RCX],0x0
JNZ 0x00122248
LAB_00122216:
CMP dword ptr [RAX + R15*0x1 + 0x60],0x6
JZ 0x00122248
CMP qword ptr [RAX + R15*0x1 + 0x10],0x0
JZ 0x00122248
TEST R13B,R13B
JNZ 0x0012225f
MOV ESI,EBX
LEA RDX,[RBP + -0x38]
XOR ECX,ECX
MOV R14,R10
CALL 0x00121b15
MOV R10,R14
MOV R9,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x0012225f
LAB_00122248:
MOV ECX,EBX
AND CL,0x7
MOV AL,0x1
SHL AL,CL
LEA RCX,[R10 + R9*0x1]
MOV RDX,RBX
SHR RDX,0x3
OR byte ptr [RDX + RCX*0x1],AL
LAB_0012225f:
INC RBX
MOV EAX,dword ptr [RDI + 0x64]
ADD R15,0x70
CMP RBX,RAX
JC 0x00122133
MOV RBX,qword ptr [RBP + -0x38]
LAB_00122276:
MOV byte ptr [RDI + 0x68],0x0
SUB RBX,R10
JMP 0x001222d8
LAB_0012227f:
MOV R14,qword ptr [RBP + -0x30]
MOV dword ptr [R14 + 0x108],0x7d8
LEA RDI,[R14 + 0x30d]
LEA RAX,[0x14dd80]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR EBX,EBX
MOV byte ptr [R14 + 0x312],BL
LEA RDI,[R14 + 0x10c]
LEA RAX,[0x14dd90]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x200
CALL 0x00113220
MOV byte ptr [R14 + 0x30b],BL
XOR R10D,R10D
LAB_001222d8:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX],RBX
MOV RAX,R10
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4 * ma_stmt_execute_generate_simple_request(long param_1,long *param_2)
{
char cVar1;
int iVar2;
int4 uVar3;
uint uVar4;
ulong uVar5;
bool bVar6;
int4 *__ptr;
int4 *__ptr_00;
long lVar7;
ulong uVar8;
char *__s;
char *pcVar9;
long lVar10;
size_t __size;
long lVar11;
long lVar12;
char *local_40;
long local_38;
local_38 = param_1;
__ptr = (int4 *)malloc(0x400);
if (__ptr == (int4 *)0x0) {
LAB_0012227f:
lVar11 = local_38;
*(int4 *)(local_38 + 0x108) = 0x7d8;
strncpy((char *)(local_38 + 0x30d),SQLSTATE_UNKNOWN,5);
lVar10 = 0;
*(int1 *)(lVar11 + 0x312) = 0;
strncpy((char *)(lVar11 + 0x10c),PTR_s_Client_run_out_of_memory_0014ddd0,0x200);
*(int1 *)(lVar11 + 0x30b) = 0;
__ptr = (int4 *)0x0;
goto LAB_001222d8;
}
*__ptr = *(int4 *)(local_38 + 0x40);
*(int1 *)(__ptr + 1) = *(int1 *)(local_38 + 0x48);
*(int4 *)((long)__ptr + 5) = 1;
__s = (char *)((long)__ptr + 9);
iVar2 = *(int *)(local_38 + 100);
pcVar9 = __s;
lVar11 = local_38;
if (iVar2 != 0) {
uVar8 = (ulong)(iVar2 + 7U >> 3);
__size = 0x400;
__ptr_00 = __ptr;
if (0x1f1f < iVar2 + 7U) {
__size = uVar8 + 0x41d;
__ptr_00 = (int4 *)realloc(__ptr,__size);
if (__ptr_00 == (int4 *)0x0) goto LAB_0012227f;
__s = (char *)((long)__ptr_00 + 9);
}
memset(__s,0,uVar8);
cVar1 = *(char *)(local_38 + 0x68);
local_40 = __s + uVar8 + 1;
__s[uVar8] = cVar1;
__ptr = __ptr_00;
if (cVar1 != '\0') {
lVar11 = (long)local_40 - (long)__ptr_00;
if (__size - lVar11 < (ulong)(iVar2 * 2 + 0x14)) {
__size = (ulong)(uint)(iVar2 * 2) + lVar11 + 0x14;
__ptr = (int4 *)realloc(__ptr_00,__size);
if (__ptr == (int4 *)0x0) goto LAB_0012227f;
local_40 = (char *)(lVar11 + (long)__ptr);
}
lVar11 = 0x30;
uVar8 = 0;
do {
uVar3 = *(int4 *)(*(long *)(local_38 + 0x70) + lVar11 * 2);
cVar1 = *(char *)(*(long *)(local_38 + 0x70) + 5 + lVar11 * 2);
*local_40 = (char)uVar3;
local_40[1] = (byte)(((uint)(cVar1 != '\0') << 0xf) >> 8) | (byte)((uint)uVar3 >> 8);
local_40 = local_40 + 2;
uVar8 = uVar8 + 1;
lVar11 = lVar11 + 0x38;
} while (uVar8 < *(uint *)(local_38 + 100));
pcVar9 = local_40;
lVar11 = local_38;
if (*(uint *)(local_38 + 100) == 0) goto LAB_00122276;
}
lVar10 = 0;
uVar8 = 0;
lVar11 = local_38;
do {
lVar7 = *(long *)(lVar11 + 0x70);
if (*(char *)(lVar7 + 0x66 + lVar10) == '\0') {
uVar4 = *(uint *)(lVar7 + 0x60 + lVar10);
if (uVar4 - 0xf5 < 0xb) {
switchD_00122171_caseD_0:
if (*(long **)(lVar7 + lVar10) == (long *)0x0) {
lVar7 = 9;
}
else {
lVar7 = **(long **)(lVar7 + lVar10) + 9;
}
}
else {
switch(uVar4) {
case 0:
case 0xe:
case 0xf:
case 0x10:
goto switchD_00122171_caseD_0;
default:
lVar7 = (long)(int)(&DAT_0014e2c8)[(ulong)uVar4 * 6];
break;
case 6:
goto switchD_00122171_caseD_6;
case 7:
case 0xc:
lVar7 = 0xc;
break;
case 10:
lVar7 = 5;
break;
case 0xb:
lVar7 = 0xd;
}
}
bVar6 = false;
}
else {
*(int1 *)(lVar7 + 0x66 + lVar10) = 0;
switchD_00122171_caseD_6:
bVar6 = true;
lVar7 = 0;
}
lVar12 = (long)local_40 - (long)__ptr;
if (__size - lVar12 < lVar7 + 0x14U) {
uVar5 = __size * 2;
__size = lVar7 + 0x14U + lVar12;
if (__size < uVar5) {
__size = uVar5;
}
__ptr = (int4 *)realloc(__ptr,__size);
if (__ptr == (int4 *)0x0) goto LAB_0012227f;
local_40 = (char *)(lVar12 + (long)__ptr);
lVar11 = local_38;
}
lVar7 = *(long *)(lVar11 + 0x70);
pcVar9 = *(char **)(lVar7 + 8 + lVar10);
if ((((pcVar9 == (char *)0x0) || (*pcVar9 == '\0')) && (*(int *)(lVar7 + 0x60 + lVar10) != 6))
&& (*(long *)(lVar7 + 0x10 + lVar10) != 0)) {
if (!bVar6) {
store_param(lVar11,uVar8 & 0xffffffff,&local_40,0);
lVar11 = local_38;
}
}
else {
*(byte *)((long)__ptr + (long)(__s + ((uVar8 >> 3) - (long)__ptr_00))) =
*(byte *)((long)__ptr + (long)(__s + ((uVar8 >> 3) - (long)__ptr_00))) |
'\x01' << ((byte)uVar8 & 7);
}
uVar8 = uVar8 + 1;
lVar10 = lVar10 + 0x70;
pcVar9 = local_40;
} while (uVar8 < *(uint *)(lVar11 + 100));
}
LAB_00122276:
*(int1 *)(lVar11 + 0x68) = 0;
lVar10 = (long)pcVar9 - (long)__ptr;
LAB_001222d8:
*param_2 = lVar10;
return __ptr;
}
| |
26,313 | del | eloqsql/storage/myisam/mi_delete.c | static int del(register MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *key,
uchar *anc_buff, my_off_t leaf_page, uchar *leaf_buff,
uchar *keypos, /* Pos to where deleted key was */
my_off_t next_block,
uchar *ret_key) /* key before keypos in anc_buff */
{
int ret_value,length;
uint a_length,nod_flag,tmp;
my_off_t next_page;
uchar keybuff[HA_MAX_KEY_BUFF],*endpos,*next_buff,*key_start, *prev_key;
MYISAM_SHARE *share=info->s;
MI_KEY_PARAM s_temp;
DBUG_ENTER("del");
DBUG_PRINT("enter",("leaf_page: %lld keypos: %p", leaf_page,
keypos));
DBUG_DUMP("leaf_buff",(uchar*) leaf_buff,mi_getint(leaf_buff));
endpos=leaf_buff+mi_getint(leaf_buff);
if (!(key_start=_mi_get_last_key(info,keyinfo,leaf_buff,keybuff,endpos,
&tmp)))
DBUG_RETURN(-1);
if ((nod_flag=mi_test_if_nod(leaf_buff)))
{
next_page= _mi_kpos(nod_flag,endpos);
if (!(next_buff= (uchar*) my_alloca((uint) keyinfo->block_length+
HA_MAX_KEY_BUFF*2)))
DBUG_RETURN(-1);
if (!_mi_fetch_keypage(info,keyinfo,next_page,DFLT_INIT_HITS,next_buff,0))
ret_value= -1;
else
{
DBUG_DUMP("next_page",(uchar*) next_buff,mi_getint(next_buff));
if ((ret_value=del(info,keyinfo,key,anc_buff,next_page,next_buff,
keypos,next_block,ret_key)) >0)
{
endpos=leaf_buff+mi_getint(leaf_buff);
if (ret_value == 1)
{
ret_value=underflow(info,keyinfo,leaf_buff,next_page,
next_buff,endpos);
if (ret_value == 0 && mi_getint(leaf_buff) > keyinfo->block_length)
{
ret_value=_mi_split_page(info,keyinfo,key,leaf_buff,ret_key,0) | 2;
}
}
else
{
DBUG_PRINT("test",("Inserting of key when deleting"));
if (!_mi_get_last_key(info,keyinfo,leaf_buff,keybuff,endpos,
&tmp))
goto err;
ret_value=_mi_insert(info,keyinfo,key,leaf_buff,endpos,keybuff,
(uchar*) 0,(uchar*) 0,(my_off_t) 0,0);
}
}
if (_mi_write_keypage(info,keyinfo,leaf_page,DFLT_INIT_HITS,leaf_buff))
goto err;
}
my_afree((uchar*) next_buff);
DBUG_RETURN(ret_value);
}
/* Remove last key from leaf page */
mi_putint(leaf_buff,key_start-leaf_buff,nod_flag);
if (_mi_write_keypage(info,keyinfo,leaf_page,DFLT_INIT_HITS,leaf_buff))
goto err;
/* Place last key in ancestor page on deleted key position */
a_length=mi_getint(anc_buff);
endpos=anc_buff+a_length;
if (keypos != anc_buff+2+share->base.key_reflength &&
!_mi_get_last_key(info,keyinfo,anc_buff,ret_key,keypos,&tmp))
goto err;
prev_key=(keypos == anc_buff+2+share->base.key_reflength ?
0 : ret_key);
length=(*keyinfo->pack_key)(keyinfo,share->base.key_reflength,
keypos == endpos ? (uchar*) 0 : keypos,
prev_key, prev_key,
keybuff,&s_temp);
if (length > 0)
bmove_upp((uchar*) endpos+length,(uchar*) endpos,(uint) (endpos-keypos));
else
bmove(keypos,keypos-length, (int) (endpos-keypos)+length);
(*keyinfo->store_key)(keyinfo,keypos,&s_temp);
/* Save pointer to next leaf */
if (!(*keyinfo->get_key)(keyinfo,share->base.key_reflength,&keypos,ret_key))
goto err;
_mi_kpointer(info,keypos - share->base.key_reflength,next_block);
mi_putint(anc_buff,a_length+length,share->base.key_reflength);
DBUG_RETURN( mi_getint(leaf_buff) <=
(info->quick_mode ? MI_MIN_KEYBLOCK_LENGTH :
(uint) keyinfo->underflow_block_length));
err:
DBUG_RETURN(-1);
} | O3 | c | del:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x538, %rsp # imm = 0x538
movq %r9, %r14
movq %r8, -0x518(%rbp)
movq %rcx, -0x510(%rbp)
movq %rdx, -0x520(%rbp)
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rbp), %rax
movq %rax, -0x500(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq %rax, -0x4f8(%rbp)
movzbl 0x1(%r9), %eax
movzbl (%r9), %r12d
andl $0x7f, %r12d
shll $0x8, %r12d
orq %rax, %r12
addq %r9, %r12
leaq -0x4f0(%rbp), %rcx
leaq -0x504(%rbp), %r9
movq %r14, %rdx
movq %r12, %r8
callq 0x85472
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x75312
cmpb $0x0, (%r14)
js 0x75337
subl %r14d, %eax
rolw $0x8, %ax
movw %ax, (%r14)
movq %r15, %rdi
movq %rbx, %rsi
movq -0x518(%rbp), %rdx
movl $0x3, %ecx
movq %r14, %r8
callq 0x836b4
testl %eax, %eax
je 0x75454
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x7569e
movl %r13d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rcx
movl 0x17c(%rcx), %edi
testl %edi, %edi
je 0x752df
movq %r12, %rsi
callq 0x83f82
movq %rax, %rdx
movzwl 0xe(%rbx), %eax
movq %rsp, %r12
addl $0x97f, %eax # imm = 0x97F
andl $-0x10, %eax
subq %rax, %r12
movq %r12, %rsp
movq %r15, %rdi
movq %rbx, %rsi
movq %rdx, -0x4f8(%rbp)
movl $0x3, %ecx
movq %r12, %r8
xorl %r9d, %r9d
callq 0x83608
testq %rax, %rax
je 0x75312
subq $0x8, %rsp
movq %r15, %rdi
movq %rbx, %rsi
movq -0x520(%rbp), %rdx
movq -0x510(%rbp), %rcx
movq -0x4f8(%rbp), %r8
movq %r12, %r9
pushq 0x20(%rbp)
pushq 0x18(%rbp)
pushq -0x500(%rbp)
callq 0x7524a
addq $0x20, %rsp
movl %eax, %r13d
testl %eax, %eax
jle 0x75677
movzbl 0x1(%r14), %eax
movzbl (%r14), %r10d
andl $0x7f, %r10d
shll $0x8, %r10d
orq %rax, %r10
addq %r14, %r10
cmpl $0x1, %r13d
jne 0x7560a
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq -0x4f8(%rbp), %rcx
movq %r12, %r8
movq %r10, %r9
callq 0x756a3
testl %eax, %eax
jne 0x75674
movzbl 0x1(%r14), %eax
movzbl (%r14), %ecx
andl $0x7f, %ecx
shll $0x8, %ecx
orl %eax, %ecx
movzwl 0xe(%rbx), %eax
xorl %r13d, %r13d
cmpl %eax, %ecx
jbe 0x75677
movq %r15, %rdi
movq %rbx, %rsi
movq -0x520(%rbp), %rdx
movq %r14, %rcx
movq 0x20(%rbp), %r8
xorl %r9d, %r9d
callq 0x88b42
movl %eax, %r13d
orl $0x2, %r13d
jmp 0x75677
movq -0x510(%rbp), %rcx
movzbl 0x1(%rcx), %r12d
movzbl (%rcx), %edi
movq -0x4f8(%rbp), %rax
movl 0x17c(%rax), %esi
leaq (%rcx,%rsi), %rax
addq $0x2, %rax
movq -0x500(%rbp), %r8
cmpq %r8, %rax
je 0x754c7
movq %rdi, %r13
leaq -0x504(%rbp), %r9
movq %r15, %rdi
movq %rbx, %rsi
movq %rcx, %rdx
movq 0x20(%rbp), %rcx
callq 0x85472
testq %rax, %rax
je 0x7530c
movq -0x4f8(%rbp), %rax
movl 0x17c(%rax), %esi
movq -0x510(%rbp), %rcx
movq -0x500(%rbp), %r8
movq %r13, %rdi
andl $0x7f, %edi
shll $0x8, %edi
orl %r12d, %edi
leaq 0x2(%rcx), %rax
addq %rsi, %rax
xorl %edx, %edx
cmpq %r8, %rax
movq %rcx, %rax
movq 0x20(%rbp), %rcx
cmoveq %rdx, %rcx
movq %rdi, -0x518(%rbp)
leaq (%rax,%rdi), %r12
cmpq %r8, %r12
cmovneq %r8, %rdx
subq $0x8, %rsp
leaq -0x560(%rbp), %rax
leaq -0x4f0(%rbp), %r9
movq %rbx, %rdi
movq %rcx, %r8
pushq %rax
callq *0x50(%rbx)
addq $0x10, %rsp
movl %eax, %r13d
testl %eax, %eax
jle 0x75539
movl %r13d, %edi
addq %r12, %rdi
movl %r12d, %edx
subl -0x500(%rbp), %edx
movq %r12, %rsi
callq 0xaa530
jmp 0x75557
movslq %r13d, %rax
movq -0x500(%rbp), %rdi
movq %rdi, %rsi
subq %rax, %rsi
subl %edi, %r12d
addl %r13d, %r12d
movslq %r12d, %rdx
callq 0x29120
leaq -0x560(%rbp), %rdx
movq %rbx, %rdi
movq -0x500(%rbp), %rsi
callq *0x58(%rbx)
movq -0x4f8(%rbp), %rax
movl 0x17c(%rax), %esi
leaq 0x10(%rbp), %rdx
movq %rbx, %rdi
movq 0x20(%rbp), %rcx
callq *0x48(%rbx)
testl %eax, %eax
je 0x7530c
movq 0x10(%rbp), %rsi
movq -0x4f8(%rbp), %r12
movl 0x17c(%r12), %eax
subq %rax, %rsi
movq %r15, %rdi
movq 0x18(%rbp), %rdx
callq 0x84aed
xorl %eax, %eax
cmpl $0x0, 0x17c(%r12)
setne %al
shll $0xf, %eax
addl -0x518(%rbp), %r13d
addl %r13d, %eax
movq -0x510(%rbp), %rcx
movb %r13b, 0x1(%rcx)
movb %ah, (%rcx)
movzbl 0x1(%r14), %ecx
movzbl (%r14), %eax
andl $0x7f, %eax
shll $0x8, %eax
orl %ecx, %eax
movl $0x32, %ecx
cmpb $0x0, 0x33b(%r15)
jne 0x755fc
movzwl 0x10(%rbx), %ecx
xorl %r13d, %r13d
cmpl %ecx, %eax
setbe %r13b
jmp 0x75312
leaq -0x4f0(%rbp), %rcx
leaq -0x504(%rbp), %r9
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r10, %r12
movq %r10, %r8
callq 0x85472
testq %rax, %rax
je 0x7530c
subq $0x20, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movl $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
leaq -0x4f0(%rbp), %r9
movq %r15, %rdi
movq %rbx, %rsi
movq -0x520(%rbp), %rdx
movq %r14, %rcx
movq %r12, %r8
callq 0x881fb
addq $0x20, %rsp
movl %eax, %r13d
movq %r15, %rdi
movq %rbx, %rsi
movq -0x518(%rbp), %rdx
movl $0x3, %ecx
movq %r14, %r8
callq 0x836b4
testl %eax, %eax
jne 0x7530c
jmp 0x75312
callq 0x29260
| del_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 538h
mov r14, r9
mov [rbp+var_518], r8
mov [rbp+var_510], rcx
mov [rbp+var_520], rdx
mov rbx, rsi
mov r15, rdi
mov rax, [rbp+arg_0]
mov [rbp+var_500], rax
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov [rbp+var_4F8], rax
movzx eax, byte ptr [r9+1]
movzx r12d, byte ptr [r9]
and r12d, 7Fh
shl r12d, 8
or r12, rax
add r12, r9
lea rcx, [rbp+var_4F0]
lea r9, [rbp+var_504]
mov rdx, r14
mov r8, r12
call _mi_get_last_key
mov r13d, 0FFFFFFFFh
test rax, rax
jz short loc_75312
cmp byte ptr [r14], 0
js short loc_75337
loc_752DF:
sub eax, r14d
rol ax, 8
mov [r14], ax
mov rdi, r15
mov rsi, rbx
mov rdx, [rbp+var_518]
mov ecx, 3
mov r8, r14
call _mi_write_keypage
test eax, eax
jz loc_75454
loc_7530C:
mov r13d, 0FFFFFFFFh
loc_75312:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_7569E
mov eax, r13d
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_75337:
mov rcx, [r15]
mov edi, [rcx+17Ch]
test edi, edi
jz short loc_752DF
mov rsi, r12
call _mi_kpos
mov rdx, rax
movzx eax, word ptr [rbx+0Eh]
mov r12, rsp
add eax, 97Fh
and eax, 0FFFFFFF0h
sub r12, rax
mov rsp, r12
mov rdi, r15
mov rsi, rbx
mov [rbp+var_4F8], rdx
mov ecx, 3
mov r8, r12
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz short loc_75312
sub rsp, 8
mov rdi, r15
mov rsi, rbx
mov rdx, [rbp+var_520]
mov rcx, [rbp+var_510]
mov r8, [rbp+var_4F8]
mov r9, r12
push [rbp+arg_10]
push [rbp+arg_8]
push [rbp+var_500]
call del_0
add rsp, 20h
mov r13d, eax
test eax, eax
jle loc_75677
movzx eax, byte ptr [r14+1]
movzx r10d, byte ptr [r14]
and r10d, 7Fh
shl r10d, 8
or r10, rax
add r10, r14
cmp r13d, 1
jnz loc_7560A
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov rcx, [rbp+var_4F8]
mov r8, r12
mov r9, r10
call underflow_0
test eax, eax
jnz loc_75674
movzx eax, byte ptr [r14+1]
movzx ecx, byte ptr [r14]
and ecx, 7Fh
shl ecx, 8
or ecx, eax
movzx eax, word ptr [rbx+0Eh]
xor r13d, r13d
cmp ecx, eax
jbe loc_75677
mov rdi, r15
mov rsi, rbx
mov rdx, [rbp+var_520]
mov rcx, r14
mov r8, [rbp+arg_10]
xor r9d, r9d
call _mi_split_page
mov r13d, eax
or r13d, 2
jmp loc_75677
loc_75454:
mov rcx, [rbp+var_510]
movzx r12d, byte ptr [rcx+1]
movzx edi, byte ptr [rcx]
mov rax, [rbp+var_4F8]
mov esi, [rax+17Ch]
lea rax, [rcx+rsi]
add rax, 2
mov r8, [rbp+var_500]
cmp rax, r8
jz short loc_754C7
mov r13, rdi
lea r9, [rbp+var_504]
mov rdi, r15
mov rsi, rbx
mov rdx, rcx
mov rcx, [rbp+arg_10]
call _mi_get_last_key
test rax, rax
jz loc_7530C
mov rax, [rbp+var_4F8]
mov esi, [rax+17Ch]
mov rcx, [rbp+var_510]
mov r8, [rbp+var_500]
mov rdi, r13
loc_754C7:
and edi, 7Fh
shl edi, 8
or edi, r12d
lea rax, [rcx+2]
add rax, rsi
xor edx, edx
cmp rax, r8
mov rax, rcx
mov rcx, [rbp+arg_10]
cmovz rcx, rdx
mov [rbp+var_518], rdi
lea r12, [rax+rdi]
cmp r12, r8
cmovnz rdx, r8
sub rsp, 8
lea rax, [rbp+var_560]
lea r9, [rbp+var_4F0]
mov rdi, rbx
mov r8, rcx
push rax
call qword ptr [rbx+50h]
add rsp, 10h
mov r13d, eax
test eax, eax
jle short loc_75539
mov edi, r13d
add rdi, r12
mov edx, r12d
sub edx, dword ptr [rbp+var_500]
mov rsi, r12
call bmove_upp
jmp short loc_75557
loc_75539:
movsxd rax, r13d
mov rdi, [rbp+var_500]
mov rsi, rdi
sub rsi, rax
sub r12d, edi
add r12d, r13d
movsxd rdx, r12d
call _memmove
loc_75557:
lea rdx, [rbp+var_560]
mov rdi, rbx
mov rsi, [rbp+var_500]
call qword ptr [rbx+58h]
mov rax, [rbp+var_4F8]
mov esi, [rax+17Ch]
lea rdx, [rbp+arg_0]
mov rdi, rbx
mov rcx, [rbp+arg_10]
call qword ptr [rbx+48h]
test eax, eax
jz loc_7530C
mov rsi, [rbp+arg_0]
mov r12, [rbp+var_4F8]
mov eax, [r12+17Ch]
sub rsi, rax
mov rdi, r15
mov rdx, [rbp+arg_8]
call _mi_kpointer
xor eax, eax
cmp dword ptr [r12+17Ch], 0
setnz al
shl eax, 0Fh
add r13d, dword ptr [rbp+var_518]
add eax, r13d
mov rcx, [rbp+var_510]
mov [rcx+1], r13b
mov [rcx], ah
movzx ecx, byte ptr [r14+1]
movzx eax, byte ptr [r14]
and eax, 7Fh
shl eax, 8
or eax, ecx
mov ecx, 32h ; '2'
cmp byte ptr [r15+33Bh], 0
jnz short loc_755FC
movzx ecx, word ptr [rbx+10h]
loc_755FC:
xor r13d, r13d
cmp eax, ecx
setbe r13b
jmp loc_75312
loc_7560A:
lea rcx, [rbp+var_4F0]
lea r9, [rbp+var_504]
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov r12, r10
mov r8, r10
call _mi_get_last_key
test rax, rax
jz loc_7530C
sub rsp, 20h
xorps xmm0, xmm0
movups [rsp+580h+var_580], xmm0
mov [rsp+580h+var_568], 0
mov [rsp+580h+var_570], 0
lea r9, [rbp+var_4F0]
mov rdi, r15
mov rsi, rbx
mov rdx, [rbp+var_520]
mov rcx, r14
mov r8, r12
call _mi_insert
add rsp, 20h
loc_75674:
mov r13d, eax
loc_75677:
mov rdi, r15
mov rsi, rbx
mov rdx, [rbp+var_518]
mov ecx, 3
mov r8, r14
call _mi_write_keypage
test eax, eax
jnz loc_7530C
jmp loc_75312
loc_7569E:
call ___stack_chk_fail
| long long del_0(
_BYTE *a1,
long long a2,
long long a3,
_BYTE *a4,
long long a5,
char *a6,
_BYTE *a7,
long long a8,
long long a9)
{
char *v12; // r12
long long last_key; // rax
unsigned int v14; // r13d
long long v16; // rdi
long long v17; // rax
_BYTE *v18; // r12
long long v19; // rax
unsigned int v20; // eax
_BYTE *v21; // rcx
int v22; // r12d
char v23; // di
long long v24; // rsi
long long v25; // r8
char v26; // r13
long long v27; // rdi
long long v28; // rdx
bool v29; // zf
_BYTE *v30; // rax
long long v31; // rcx
_BYTE *v32; // r12
int v33; // eax
__int16 v34; // r13
long long v35; // r12
bool v36; // al
__int16 v37; // r13
_BYTE *v38; // rcx
unsigned int v39; // ecx
int v40; // r12d
_BYTE v41[64]; // [rsp+20h] [rbp-560h] BYREF
long long v42; // [rsp+60h] [rbp-520h]
long long v43; // [rsp+68h] [rbp-518h]
_BYTE *v44; // [rsp+70h] [rbp-510h]
_BYTE v45[4]; // [rsp+7Ch] [rbp-504h] BYREF
_BYTE *v46; // [rsp+80h] [rbp-500h]
long long v47; // [rsp+88h] [rbp-4F8h]
_BYTE v48[1216]; // [rsp+90h] [rbp-4F0h] BYREF
unsigned long long v49; // [rsp+550h] [rbp-30h]
v43 = a5;
v44 = a4;
v42 = a3;
v46 = a7;
v49 = __readfsqword(0x28u);
v47 = *(_QWORD *)a1;
v12 = &a6[(unsigned __int8)a6[1] | (unsigned long long)((unsigned __int8)(*a6 & 0x7F) << 8)];
last_key = mi_get_last_key(a1, a2, a6, v48, v12, v45);
v14 = -1;
if ( last_key )
{
if ( *a6 < 0 )
{
v16 = *(unsigned int *)(*(_QWORD *)a1 + 380LL);
if ( (_DWORD)v16 )
{
v17 = mi_kpos(v16, v12);
v18 = &v41[-((*(unsigned __int16 *)(a2 + 14) + 2431) & 0xFFFFFFF0)];
v47 = v17;
if ( !mi_fetch_keypage(a1, a2, v17, 3LL, v18, 0LL) )
return v14;
v14 = del_0((_DWORD)a1, a2, v42, (_DWORD)v44, v47, (_DWORD)v18, (long long)v46, a8, a9);
if ( (int)v14 <= 0 )
goto LABEL_30;
v19 = (unsigned __int8)a6[1];
if ( v14 == 1 )
{
v20 = underflow_0(a1, a2, a6, v47, v18, &a6[v19 | ((unsigned __int8)(*a6 & 0x7F) << 8)]);
if ( !v20 )
{
v14 = 0;
if ( ((unsigned __int8)a6[1] | ((unsigned __int8)(*a6 & 0x7F) << 8)) > (unsigned int)*(unsigned __int16 *)(a2 + 14) )
v14 = mi_split_page(a1, a2, v42, a6, a9, 0LL) | 2;
LABEL_30:
if ( !(unsigned int)mi_write_keypage(a1, a2, v43, 3LL, a6) )
return v14;
return (unsigned int)-1;
}
LABEL_29:
v14 = v20;
goto LABEL_30;
}
v40 = (_DWORD)a6 + (v19 | ((*a6 & 0x7F) << 8));
if ( mi_get_last_key(a1, a2, a6, v48, &a6[v19 | ((unsigned __int8)(*a6 & 0x7F) << 8)], v45) )
{
v20 = mi_insert((_DWORD)a1, a2, v42, (_DWORD)a6, v40, (unsigned int)v48, 0LL, 0LL, 0LL, 0);
goto LABEL_29;
}
return (unsigned int)-1;
}
}
*(_WORD *)a6 = __ROL2__(last_key - (_WORD)a6, 8);
if ( (unsigned int)mi_write_keypage(a1, a2, v43, 3LL, a6) )
return (unsigned int)-1;
v21 = v44;
v22 = (unsigned __int8)v44[1];
v23 = *v44;
v24 = *(unsigned int *)(v47 + 380);
v25 = (long long)v46;
if ( &v44[v24 + 2] != v46 )
{
v26 = *v44;
if ( !mi_get_last_key(a1, a2, v44, a9, v46, v45) )
return (unsigned int)-1;
v24 = *(unsigned int *)(v47 + 380);
v21 = v44;
v25 = (long long)v46;
v23 = v26;
}
v27 = v22 | ((unsigned __int8)(v23 & 0x7F) << 8);
v28 = 0LL;
v29 = &v21[v24 + 2] == (_BYTE *)v25;
v30 = v21;
v31 = a9;
if ( v29 )
v31 = 0LL;
v43 = v27;
v32 = &v30[v27];
if ( &v30[v27] != (_BYTE *)v25 )
v28 = v25;
v33 = (*(long long ( **)(long long, long long, long long, long long, long long, _BYTE *, _BYTE *))(a2 + 80))(
a2,
v24,
v28,
v31,
v31,
v48,
v41);
v34 = v33;
if ( v33 <= 0 )
memmove(v46, &v46[-v33], v33 + (int)v32 - (int)v46);
else
bmove_upp(&v32[v33], v32);
(*(void ( **)(long long, _BYTE *, _BYTE *))(a2 + 88))(a2, v46, v41);
if ( !(*(unsigned int ( **)(long long, _QWORD, _BYTE **, long long))(a2 + 72))(
a2,
*(unsigned int *)(v47 + 380),
&a7,
a9) )
return (unsigned int)-1;
v35 = v47;
mi_kpointer(a1, &a7[-*(unsigned int *)(v47 + 380)], a8);
v36 = *(_DWORD *)(v35 + 380) != 0;
v37 = v43 + v34;
v38 = v44;
v44[1] = v37;
*v38 = (unsigned __int16)(v37 + (v36 << 15)) >> 8;
v39 = 50;
if ( !a1[827] )
v39 = *(unsigned __int16 *)(a2 + 16);
return ((unsigned __int8)a6[1] | ((unsigned __int8)(*a6 & 0x7F) << 8)) <= v39;
}
return v14;
}
| del:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x538
MOV R14,R9
MOV qword ptr [RBP + -0x518],R8
MOV qword ptr [RBP + -0x510],RCX
MOV qword ptr [RBP + -0x520],RDX
MOV RBX,RSI
MOV R15,RDI
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x500],RAX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [RBP + -0x4f8],RAX
MOVZX EAX,byte ptr [R9 + 0x1]
MOVZX R12D,byte ptr [R9]
AND R12D,0x7f
SHL R12D,0x8
OR R12,RAX
ADD R12,R9
LEA RCX,[RBP + -0x4f0]
LEA R9,[RBP + -0x504]
MOV RDX,R14
MOV R8,R12
CALL 0x00185472
MOV R13D,0xffffffff
TEST RAX,RAX
JZ 0x00175312
CMP byte ptr [R14],0x0
JS 0x00175337
LAB_001752df:
SUB EAX,R14D
ROL AX,0x8
MOV word ptr [R14],AX
MOV RDI,R15
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x518]
MOV ECX,0x3
MOV R8,R14
CALL 0x001836b4
TEST EAX,EAX
JZ 0x00175454
LAB_0017530c:
MOV R13D,0xffffffff
LAB_00175312:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0017569e
MOV EAX,R13D
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00175337:
MOV RCX,qword ptr [R15]
MOV EDI,dword ptr [RCX + 0x17c]
TEST EDI,EDI
JZ 0x001752df
MOV RSI,R12
CALL 0x00183f82
MOV RDX,RAX
MOVZX EAX,word ptr [RBX + 0xe]
MOV R12,RSP
ADD EAX,0x97f
AND EAX,0xfffffff0
SUB R12,RAX
MOV RSP,R12
MOV RDI,R15
MOV RSI,RBX
MOV qword ptr [RBP + -0x4f8],RDX
MOV ECX,0x3
MOV R8,R12
XOR R9D,R9D
CALL 0x00183608
TEST RAX,RAX
JZ 0x00175312
SUB RSP,0x8
MOV RDI,R15
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x520]
MOV RCX,qword ptr [RBP + -0x510]
MOV R8,qword ptr [RBP + -0x4f8]
MOV R9,R12
PUSH qword ptr [RBP + 0x20]
PUSH qword ptr [RBP + 0x18]
PUSH qword ptr [RBP + -0x500]
CALL 0x0017524a
ADD RSP,0x20
MOV R13D,EAX
TEST EAX,EAX
JLE 0x00175677
MOVZX EAX,byte ptr [R14 + 0x1]
MOVZX R10D,byte ptr [R14]
AND R10D,0x7f
SHL R10D,0x8
OR R10,RAX
ADD R10,R14
CMP R13D,0x1
JNZ 0x0017560a
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV RCX,qword ptr [RBP + -0x4f8]
MOV R8,R12
MOV R9,R10
CALL 0x001756a3
TEST EAX,EAX
JNZ 0x00175674
MOVZX EAX,byte ptr [R14 + 0x1]
MOVZX ECX,byte ptr [R14]
AND ECX,0x7f
SHL ECX,0x8
OR ECX,EAX
MOVZX EAX,word ptr [RBX + 0xe]
XOR R13D,R13D
CMP ECX,EAX
JBE 0x00175677
MOV RDI,R15
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x520]
MOV RCX,R14
MOV R8,qword ptr [RBP + 0x20]
XOR R9D,R9D
CALL 0x00188b42
MOV R13D,EAX
OR R13D,0x2
JMP 0x00175677
LAB_00175454:
MOV RCX,qword ptr [RBP + -0x510]
MOVZX R12D,byte ptr [RCX + 0x1]
MOVZX EDI,byte ptr [RCX]
MOV RAX,qword ptr [RBP + -0x4f8]
MOV ESI,dword ptr [RAX + 0x17c]
LEA RAX,[RCX + RSI*0x1]
ADD RAX,0x2
MOV R8,qword ptr [RBP + -0x500]
CMP RAX,R8
JZ 0x001754c7
MOV R13,RDI
LEA R9,[RBP + -0x504]
MOV RDI,R15
MOV RSI,RBX
MOV RDX,RCX
MOV RCX,qword ptr [RBP + 0x20]
CALL 0x00185472
TEST RAX,RAX
JZ 0x0017530c
MOV RAX,qword ptr [RBP + -0x4f8]
MOV ESI,dword ptr [RAX + 0x17c]
MOV RCX,qword ptr [RBP + -0x510]
MOV R8,qword ptr [RBP + -0x500]
MOV RDI,R13
LAB_001754c7:
AND EDI,0x7f
SHL EDI,0x8
OR EDI,R12D
LEA RAX,[RCX + 0x2]
ADD RAX,RSI
XOR EDX,EDX
CMP RAX,R8
MOV RAX,RCX
MOV RCX,qword ptr [RBP + 0x20]
CMOVZ RCX,RDX
MOV qword ptr [RBP + -0x518],RDI
LEA R12,[RAX + RDI*0x1]
CMP R12,R8
CMOVNZ RDX,R8
SUB RSP,0x8
LEA RAX,[RBP + -0x560]
LEA R9,[RBP + -0x4f0]
MOV RDI,RBX
MOV R8,RCX
PUSH RAX
CALL qword ptr [RBX + 0x50]
ADD RSP,0x10
MOV R13D,EAX
TEST EAX,EAX
JLE 0x00175539
MOV EDI,R13D
ADD RDI,R12
MOV EDX,R12D
SUB EDX,dword ptr [RBP + -0x500]
MOV RSI,R12
CALL 0x001aa530
JMP 0x00175557
LAB_00175539:
MOVSXD RAX,R13D
MOV RDI,qword ptr [RBP + -0x500]
MOV RSI,RDI
SUB RSI,RAX
SUB R12D,EDI
ADD R12D,R13D
MOVSXD RDX,R12D
CALL 0x00129120
LAB_00175557:
LEA RDX,[RBP + -0x560]
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x500]
CALL qword ptr [RBX + 0x58]
MOV RAX,qword ptr [RBP + -0x4f8]
MOV ESI,dword ptr [RAX + 0x17c]
LEA RDX,[RBP + 0x10]
MOV RDI,RBX
MOV RCX,qword ptr [RBP + 0x20]
CALL qword ptr [RBX + 0x48]
TEST EAX,EAX
JZ 0x0017530c
MOV RSI,qword ptr [RBP + 0x10]
MOV R12,qword ptr [RBP + -0x4f8]
MOV EAX,dword ptr [R12 + 0x17c]
SUB RSI,RAX
MOV RDI,R15
MOV RDX,qword ptr [RBP + 0x18]
CALL 0x00184aed
XOR EAX,EAX
CMP dword ptr [R12 + 0x17c],0x0
SETNZ AL
SHL EAX,0xf
ADD R13D,dword ptr [RBP + -0x518]
ADD EAX,R13D
MOV RCX,qword ptr [RBP + -0x510]
MOV byte ptr [RCX + 0x1],R13B
MOV byte ptr [RCX],AH
MOVZX ECX,byte ptr [R14 + 0x1]
MOVZX EAX,byte ptr [R14]
AND EAX,0x7f
SHL EAX,0x8
OR EAX,ECX
MOV ECX,0x32
CMP byte ptr [R15 + 0x33b],0x0
JNZ 0x001755fc
MOVZX ECX,word ptr [RBX + 0x10]
LAB_001755fc:
XOR R13D,R13D
CMP EAX,ECX
SETBE R13B
JMP 0x00175312
LAB_0017560a:
LEA RCX,[RBP + -0x4f0]
LEA R9,[RBP + -0x504]
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV R12,R10
MOV R8,R10
CALL 0x00185472
TEST RAX,RAX
JZ 0x0017530c
SUB RSP,0x20
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP],XMM0
MOV dword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x10],0x0
LEA R9,[RBP + -0x4f0]
MOV RDI,R15
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x520]
MOV RCX,R14
MOV R8,R12
CALL 0x001881fb
ADD RSP,0x20
LAB_00175674:
MOV R13D,EAX
LAB_00175677:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x518]
MOV ECX,0x3
MOV R8,R14
CALL 0x001836b4
TEST EAX,EAX
JNZ 0x0017530c
JMP 0x00175312
LAB_0017569e:
CALL 0x00129260
|
uint del(long *param_1,long param_2,int8 param_3,byte *param_4,ulong param_5,ushort *param_6,
byte *param_7,int8 param_8,byte *param_9)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
int8 uVar4;
ushort uVar5;
int iVar6;
uint uVar7;
long lVar8;
long lVar9;
long lVar10;
byte *pbVar11;
int1 *puVar12;
ulong uVar13;
byte *pbVar14;
long in_FS_OFFSET;
int1 *apuStack_590 [4];
int8 uStack_570;
int1 local_568 [64];
int8 local_528;
ulong local_520;
byte *local_518;
int1 local_50c [4];
byte *local_508;
long local_500;
int1 local_4f8 [1216];
long local_38;
local_508 = param_7;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_500 = *param_1;
pbVar14 = (byte *)(((ulong)(((byte)*param_6 & 0x7f) << 8) | (ulong)*(byte *)((long)param_6 + 1)) +
(long)param_6);
uStack_570 = 0x1752ce;
local_528 = param_3;
local_520 = param_5;
local_518 = param_4;
lVar8 = _mi_get_last_key(param_1,param_2,param_6,local_4f8,pbVar14,local_50c);
uVar7 = 0xffffffff;
puVar12 = local_568;
if (lVar8 == 0) goto LAB_00175312;
if (((char)(byte)*param_6 < '\0') && (*(int *)(*param_1 + 0x17c) != 0)) {
uStack_570 = 0x17534c;
lVar9 = _mi_kpos(*(int *)(*param_1 + 0x17c),pbVar14);
lVar8 = -(ulong)(*(ushort *)(param_2 + 0xe) + 0x97f & 0xfffffff0);
puVar12 = local_568 + lVar8;
local_500 = lVar9;
*(int8 *)(local_568 + lVar8 + -8) = 0x175381;
lVar10 = _mi_fetch_keypage(param_1,param_2,lVar9,3,puVar12,0);
lVar9 = local_500;
pbVar14 = local_518;
uVar4 = local_528;
if (lVar10 == 0) goto LAB_00175312;
*(byte **)((long)apuStack_590 + lVar8 + 0x18) = param_9;
*(int8 *)((long)apuStack_590 + lVar8 + 0x10) = param_8;
*(byte **)((long)apuStack_590 + lVar8 + 8) = local_508;
*(int8 *)((long)apuStack_590 + lVar8) = 0x1753b9;
uVar7 = del(param_1,param_2,uVar4,pbVar14,lVar9,puVar12);
lVar9 = local_500;
if (0 < (int)uVar7) {
pbVar14 = (byte *)(((ulong)(((byte)*param_6 & 0x7f) << 8) |
(ulong)*(byte *)((long)param_6 + 1)) + (long)param_6);
if (uVar7 == 1) {
*(int8 *)(local_568 + lVar8 + -8) = 0x175404;
uVar7 = underflow(param_1,param_2,param_6,lVar9,puVar12,pbVar14);
uVar4 = local_528;
if ((uVar7 == 0) &&
(uVar7 = 0,
(uint)*(ushort *)(param_2 + 0xe) <
(((byte)*param_6 & 0x7f) << 8 | (uint)*(byte *)((long)param_6 + 1)))) {
*(int8 *)(local_568 + lVar8 + -8) = 0x175448;
uVar7 = _mi_split_page(param_1,param_2,uVar4,param_6,param_9,0);
uVar7 = uVar7 | 2;
}
}
else {
*(int8 *)(local_568 + lVar8 + -8) = 0x17562c;
lVar9 = _mi_get_last_key(param_1,param_2,param_6,local_4f8,pbVar14,local_50c);
if (lVar9 == 0) goto LAB_0017530c;
*(int8 *)((long)apuStack_590 + lVar8 + 8) = 0;
*(int8 *)((long)apuStack_590 + lVar8 + 0x10) = 0;
*(int4 *)(local_568 + lVar8 + -8) = 0;
*(int8 *)((long)apuStack_590 + lVar8 + 0x18) = 0;
uVar4 = local_528;
*(int8 *)((long)apuStack_590 + lVar8) = 0x175670;
uVar7 = _mi_insert(param_1,param_2,uVar4,param_6,pbVar14,local_4f8);
}
}
uVar13 = local_520;
*(int8 *)(local_568 + lVar8 + -8) = 0x175691;
iVar6 = _mi_write_keypage(param_1,param_2,uVar13,3,param_6);
if (iVar6 == 0) goto LAB_00175312;
}
else {
uVar5 = (short)lVar8 - (short)param_6;
*param_6 = uVar5 * 0x100 | uVar5 >> 8;
uStack_570 = 0x175304;
iVar6 = _mi_write_keypage(param_1,param_2,local_520,3,param_6);
puVar12 = local_568;
if (iVar6 == 0) {
bVar2 = local_518[1];
bVar3 = *local_518;
uVar13 = (ulong)*(uint *)(local_500 + 0x17c);
if (local_518 + uVar13 + 2 != local_508) {
uStack_570 = 0x1754a0;
lVar8 = _mi_get_last_key(param_1,param_2,local_518,param_9,local_508,local_50c);
puVar12 = local_568;
if (lVar8 == 0) goto LAB_0017530c;
uVar13 = (ulong)*(uint *)(local_500 + 0x17c);
}
local_520 = (ulong)((bVar3 & 0x7f) << 8 | (uint)bVar2);
pbVar14 = param_9;
if (local_518 + uVar13 + 2 == local_508) {
pbVar14 = (byte *)0x0;
}
pbVar1 = local_518 + local_520;
pbVar11 = (byte *)0x0;
if (pbVar1 != local_508) {
pbVar11 = local_508;
}
apuStack_590[3] = local_568;
apuStack_590[2] = (int1 *)0x175515;
uVar7 = (**(code **)(param_2 + 0x50))(param_2,uVar13,pbVar11,pbVar14,pbVar14,local_4f8);
if ((int)uVar7 < 1) {
uStack_570 = 0x175557;
memmove(local_508,local_508 + -(long)(int)uVar7,
(long)(int)(((int)pbVar1 - (int)local_508) + uVar7));
}
else {
uStack_570 = 0x175537;
bmove_upp(pbVar1 + uVar7,pbVar1,(int)pbVar1 - (int)local_508);
}
uStack_570 = 0x17556b;
(**(code **)(param_2 + 0x58))(param_2,local_508,local_568);
uStack_570 = 0x175586;
iVar6 = (**(code **)(param_2 + 0x48))
(param_2,*(int4 *)(local_500 + 0x17c),¶m_7,param_9);
lVar8 = local_500;
puVar12 = local_568;
if (iVar6 != 0) {
uStack_570 = 0x1755b0;
_mi_kpointer(param_1,(long)param_7 - (ulong)*(uint *)(local_500 + 0x17c),param_8);
iVar6 = *(int *)(lVar8 + 0x17c);
local_518[1] = (byte)(uVar7 + (int)local_520);
*local_518 = (byte)((uint)(iVar6 != 0) * 0x8000 + uVar7 + (int)local_520 >> 8);
uVar7 = 0x32;
if (*(char *)((long)param_1 + 0x33b) == '\0') {
uVar7 = (uint)*(ushort *)(param_2 + 0x10);
}
uVar7 = (uint)((((byte)*param_6 & 0x7f) << 8 | (uint)*(byte *)((long)param_6 + 1)) <= uVar7)
;
puVar12 = local_568;
goto LAB_00175312;
}
}
}
LAB_0017530c:
uVar7 = 0xffffffff;
LAB_00175312:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)(puVar12 + -8) = underflow;
__stack_chk_fail();
}
return uVar7;
}
| |
26,314 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::parse<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)>, bool, bool) | monkey531[P]llama/common/json.hpp | JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json parse(InputType&& i,
const parser_callback_t cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false)
{
basic_json result;
parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
return result;
} | O0 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::parse<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)>, bool, bool):
subq $0x158, %rsp # imm = 0x158
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x18(%rsp)
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
andb $0x1, %cl
movb %cl, 0x13f(%rsp)
andb $0x1, %al
movb %al, 0x13e(%rsp)
movb $0x0, 0x13d(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xa6930
movq 0x148(%rsp), %rdi
callq 0xa6a50
movq %rdx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
jmp 0xa67a1
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq %rax, 0x68(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xa6a80
jmp 0xa67c6
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movzbl 0x13e(%rsp), %r9d
movzbl 0x13f(%rsp), %r8d
andl $0x1, %r8d
andl $0x1, %r9d
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rcx
callq 0xa6970
jmp 0xa67fb
movq 0x10(%rsp), %rdx
leaq 0x70(%rsp), %rdi
movl $0x1, %esi
callq 0xa6b30
jmp 0xa6811
leaq 0x70(%rsp), %rdi
callq 0xa7210
leaq 0x30(%rsp), %rdi
callq 0xa6920
movb $0x1, 0x13d(%rsp)
testb $0x1, 0x13d(%rsp)
jne 0xa6887
jmp 0xa687d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xa6894
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xa6871
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xa7210
leaq 0x30(%rsp), %rdi
callq 0xa6920
jmp 0xa6894
movq 0x10(%rsp), %rdi
callq 0xa68f0
movq 0x18(%rsp), %rax
addq $0x158, %rsp # imm = 0x158
retq
movq 0x10(%rsp), %rdi
callq 0xa68f0
movq 0x58(%rsp), %rdi
callq 0x5bd10
nopl (%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5parseIRKS9_EESD_OT_St8functionIFbiNS0_6detail13parse_event_tERSD_EEbb:
sub rsp, 158h
mov [rsp+158h+var_150], rdx
mov [rsp+158h+var_148], rdi
mov al, r8b
mov r8, rdi
mov [rsp+158h+var_140], r8
mov [rsp+158h+var_8], rdi
mov [rsp+158h+var_10], rsi
mov [rsp+158h+var_18], rdx
and cl, 1
mov [rsp+158h+var_19], cl
and al, 1
mov [rsp+158h+var_1A], al
mov [rsp+158h+var_1B], 0
xor eax, eax
mov esi, eax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(decltype(nullptr))
mov rdi, [rsp+158h+var_10]
call _ZN8nlohmann16json_abi_v3_11_36detail13input_adapterINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS1_36container_input_adapter_factory_impl31container_input_adapter_factoryIT_vE12adapter_typeERKSB_; nlohmann::json_abi_v3_11_3::detail::input_adapter<std::string>(std::string const&)
mov [rsp+158h+var_138], rdx
mov [rsp+158h+var_130], rax
jmp short $+2
loc_A67A1:
mov rsi, [rsp+158h+var_150]
mov rax, [rsp+158h+var_138]
mov rcx, [rsp+158h+var_130]
mov [rsp+158h+var_F8], rcx
mov [rsp+158h+var_F0], rax
lea rdi, [rsp+158h+var_128]
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEC2ERKSJ_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::function(std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)> const&)
jmp short $+2
loc_A67C6:
mov rsi, [rsp+158h+var_F8]
mov rdx, [rsp+158h+var_F0]
movzx r9d, [rsp+158h+var_1A]
movzx r8d, [rsp+158h+var_19]
and r8d, 1
and r9d, 1
lea rdi, [rsp+158h+var_E8]
lea rcx, [rsp+158h+var_128]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6parserINS0_6detail22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcS9_EEEEEENSF_6parserISD_T_EESO_St8functionIFbiNSF_13parse_event_tERSD_EEbb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)>,bool,bool)
jmp short $+2
loc_A67FB:
mov rdx, [rsp+158h+var_148]
lea rdi, [rsp+158h+var_E8]
mov esi, 1
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5parseEbRSF_; nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::parse(bool,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)
jmp short $+2
loc_A6811:
lea rdi, [rsp+158h+var_E8]
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~parser()
lea rdi, [rsp+158h+var_128]
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEED2Ev; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::~function()
mov [rsp+158h+var_1B], 1
test [rsp+158h+var_1B], 1
jnz short loc_A6887
jmp short loc_A687D
mov rcx, rax
mov eax, edx
mov [rsp+arg_50], rcx
mov [rsp+arg_4C], eax
jmp short loc_A6894
mov rcx, rax
mov eax, edx
mov [rsp+arg_50], rcx
mov [rsp+arg_4C], eax
jmp short loc_A6871
mov rcx, rax
mov eax, edx
mov [rsp+arg_50], rcx
mov [rsp+arg_4C], eax
lea rdi, [rsp+arg_68]
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~parser()
loc_A6871:
lea rdi, [rsp+arg_28]
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEED2Ev; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::~function()
jmp short loc_A6894
loc_A687D:
mov rdi, [rsp+158h+var_148]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_A6887:
mov rax, [rsp+158h+var_140]
add rsp, 158h
retn
loc_A6894:
mov rdi, [rsp+arg_8]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rdi, [rsp+arg_50]
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parse<std::string const&>(
long long a1,
long long a2,
long long a3,
char a4,
char a5)
{
long long v5; // rdx
int v6; // r8d
int v7; // r9d
int v9; // [rsp+8h] [rbp-150h]
_BYTE v10[48]; // [rsp+30h] [rbp-128h] BYREF
long long v11; // [rsp+60h] [rbp-F8h]
long long v12; // [rsp+68h] [rbp-F0h]
_BYTE v13[206]; // [rsp+70h] [rbp-E8h] BYREF
char v14; // [rsp+13Eh] [rbp-1Ah]
char v15; // [rsp+13Fh] [rbp-19h]
long long v16; // [rsp+140h] [rbp-18h]
long long v17; // [rsp+148h] [rbp-10h]
long long v18; // [rsp+150h] [rbp-8h]
v9 = a3;
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4 & 1;
v14 = a5 & 1;
v13[205] = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
a1,
0LL);
v11 = nlohmann::json_abi_v3_11_3::detail::input_adapter<std::string>(a2);
v12 = v5;
std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::function(
(unsigned int)v10,
v9,
v5,
v11,
v6,
v7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>(
(unsigned int)v13,
v11,
v12,
(unsigned int)v10,
v15 & 1,
v14 & 1);
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::parse(
v13,
1LL,
a1);
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~parser(v13);
std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::~function(v10);
return a1;
}
| parse<std::__cxx11::string_const&>:
SUB RSP,0x158
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP + 0x10],RDI
MOV AL,R8B
MOV R8,RDI
MOV qword ptr [RSP + 0x18],R8
MOV qword ptr [RSP + 0x150],RDI
MOV qword ptr [RSP + 0x148],RSI
MOV qword ptr [RSP + 0x140],RDX
AND CL,0x1
MOV byte ptr [RSP + 0x13f],CL
AND AL,0x1
MOV byte ptr [RSP + 0x13e],AL
MOV byte ptr [RSP + 0x13d],0x0
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001a6930
MOV RDI,qword ptr [RSP + 0x148]
LAB_001a6790:
CALL 0x001a6a50
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x28],RAX
JMP 0x001a67a1
LAB_001a67a1:
MOV RSI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x60],RCX
MOV qword ptr [RSP + 0x68],RAX
LEA RDI,[RSP + 0x30]
CALL 0x001a6a80
JMP 0x001a67c6
LAB_001a67c6:
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
MOVZX R9D,byte ptr [RSP + 0x13e]
MOVZX R8D,byte ptr [RSP + 0x13f]
LAB_001a67e2:
AND R8D,0x1
AND R9D,0x1
LEA RDI,[RSP + 0x70]
LEA RCX,[RSP + 0x30]
CALL 0x001a6970
JMP 0x001a67fb
LAB_001a67fb:
MOV RDX,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x70]
MOV ESI,0x1
CALL 0x001a6b30
LAB_001a680f:
JMP 0x001a6811
LAB_001a6811:
LEA RDI,[RSP + 0x70]
CALL 0x001a7210
LEA RDI,[RSP + 0x30]
CALL 0x001a6920
MOV byte ptr [RSP + 0x13d],0x1
TEST byte ptr [RSP + 0x13d],0x1
JNZ 0x001a6887
JMP 0x001a687d
LAB_001a687d:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001a68f0
LAB_001a6887:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x158
RET
|
/* WARNING: Removing unreachable block (ram,0x001a6837) */
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::parse<std::__cxx11::string const&>(std::__cxx11::string const&,
std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&)>, bool, bool) */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
* __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::parse<std::__cxx11::string_const&>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,string *param_1,function *param_3,byte param_4,byte param_5)
{
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
local_128 [48];
int1 local_f8 [16];
parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
local_e8 [205];
int1 local_1b;
byte local_1a;
byte local_19;
function *local_18;
string *local_10;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*local_8;
local_19 = param_4 & 1;
local_1a = param_5 & 1;
local_1b = 0;
local_18 = param_3;
local_10 = param_1;
local_8 = this;
basic_json((_func_decltype_nullptr *)this);
/* try { // try from 001a6790 to 001a67c3 has its CatchHandler @ 001a6839 */
local_f8 = detail::input_adapter<std::__cxx11::string>(local_10);
std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::function(local_128,param_3);
/* try { // try from 001a67e2 to 001a67f8 has its CatchHandler @ 001a6849 */
parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
(local_e8,local_f8._0_8_,local_f8._8_8_,local_128,local_19 & 1,local_1a & 1);
/* try { // try from 001a67fb to 001a680e has its CatchHandler @ 001a6859 */
detail::
parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::parse(local_e8,true,this);
detail::
parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::~parser(local_e8);
std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::~function(local_128);
return this;
}
| |
26,315 | minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling) | monkey531[P]llama/common/minja.hpp | std::string consumeToken(const std::string & token, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
if (std::distance(it, end) >= (int64_t) token.size() && std::string(it, it + token.size()) == token) {
it += token.size();
return token;
}
it = start;
return "";
} | O2 | cpp | minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %r13
movq %rsi, %rdi
movl %ecx, %esi
callq 0x62d24
movq 0x18(%r15), %rax
movq 0x20(%r15), %rsi
subq %rsi, %rax
movq 0x8(%r14), %rdx
cmpq %rdx, %rax
jl 0x624a7
addq %rsi, %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x53f60
movq %r12, %rdi
movq %r14, %rsi
callq 0x3c1ae
movl %eax, %ebp
movq %r12, %rdi
callq 0x242a8
testb %bpl, %bpl
je 0x624a7
movq 0x8(%r14), %rax
addq %rax, 0x20(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23c60
jmp 0x624bf
movq %r13, 0x20(%r15)
leaq 0x49121(%rip), %rsi # 0xab5d3
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x28b3c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov r13, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
mov rax, [r15+18h]
mov rsi, [r15+20h]
sub rax, rsi
mov rdx, [r14+8]
cmp rax, rdx
jl short loc_624A7
add rdx, rsi
lea rax, [rsp+58h+var_40]
mov [rax-10h], rax
lea r12, [rsp+58h+var_50]
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
mov rdi, r12
mov rsi, r14
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
mov ebp, eax
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jz short loc_624A7
mov rax, [r14+8]
add [r15+20h], rax
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
jmp short loc_624BF
loc_624A7:
mov [r15+20h], r13
lea rsi, aInfillMode+1Ch; ""
lea rdx, [rsp+58h+var_50]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
loc_624BF:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _QWORD * minja::Parser::consumeToken(_QWORD *a1, long long a2, _QWORD *a3, unsigned int a4)
{
long long v6; // r13
_BYTE *v7; // rsi
long long v8; // rdx
bool v9; // bp
_QWORD v11[2]; // [rsp+8h] [rbp-50h] BYREF
char v12; // [rsp+18h] [rbp-40h] BYREF
v6 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v7 = *(_BYTE **)(a2 + 32);
v8 = a3[1];
if ( *(_QWORD *)(a2 + 24) - (_QWORD)v7 >= v8
&& (v11[0] = &v12,
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(
(long long)v11,
v7,
(long long)&v7[v8]),
v9 = std::operator==<char>(v11, a3),
std::string::~string(v11),
v9) )
{
*(_QWORD *)(a2 + 32) += a3[1];
std::string::basic_string(a1, a3);
}
else
{
*(_QWORD *)(a2 + 32) = v6;
std::string::basic_string<std::allocator<char>>(a1, (long long)"");
}
return a1;
}
| consumeToken:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV R13,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x00162d24
MOV RAX,qword ptr [R15 + 0x18]
MOV RSI,qword ptr [R15 + 0x20]
SUB RAX,RSI
MOV RDX,qword ptr [R14 + 0x8]
CMP RAX,RDX
JL 0x001624a7
ADD RDX,RSI
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x00153f60
MOV RDI,R12
MOV RSI,R14
CALL 0x0013c1ae
MOV EBP,EAX
MOV RDI,R12
CALL 0x001242a8
TEST BPL,BPL
JZ 0x001624a7
MOV RAX,qword ptr [R14 + 0x8]
ADD qword ptr [R15 + 0x20],RAX
MOV RDI,RBX
MOV RSI,R14
CALL 0x00123c60
JMP 0x001624bf
LAB_001624a7:
MOV qword ptr [R15 + 0x20],R13
LEA RSI,[0x1ab5d3]
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00128b3c
LAB_001624bf:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::Parser::consumeToken(std::__cxx11::string const&, minja::SpaceHandling) */
string * minja::Parser::consumeToken
(string *param_1,Parser *param_2,string *param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
char cVar3;
int1 *local_50 [2];
int1 local_40 [16];
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
lVar2 = *(long *)(param_2 + 0x20);
if (*(long *)(param_3 + 8) <= *(long *)(param_2 + 0x18) - lVar2) {
local_50[0] = local_40;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
((string *)local_50,lVar2,*(long *)(param_3 + 8) + lVar2);
cVar3 = std::operator==((string *)local_50,param_3);
std::__cxx11::string::~string((string *)local_50);
if (cVar3 != '\0') {
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + *(long *)(param_3 + 8);
std::__cxx11::string::string(param_1,param_3);
return param_1;
}
}
*(int8 *)(param_2 + 0x20) = uVar1;
std::__cxx11::string::string<std::allocator<char>>(param_1,"",(allocator *)local_50);
return param_1;
}
| |
26,316 | Catch::BinaryExpr<unsigned long, int>::streamReconstructedExpression(std::ostream&) const | 11AgReS1SoR11[P]Graph/build_O1/_deps/catch2-src/src/catch2/../catch2/internal/catch_decomposer.hpp | void streamReconstructedExpression( std::ostream &os ) const override {
formatReconstructedExpression
( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
} | O1 | cpp | Catch::BinaryExpr<unsigned long, int>::streamReconstructedExpression(std::ostream&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %rax
movzwl (%rax), %eax
leaq 0x8(%rsp), %rsi
movw %ax, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x1667e
movq 0x18(%r12), %r14
movq 0x20(%r12), %r15
movq 0x28(%r12), %rax
movzwl (%rax), %eax
leaq 0x6(%rsp), %rsi
movw %ax, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x1667e
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2a994
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16759
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x114e0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16774
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x114e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x167a3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x114e0
jmp 0x167a3
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x167be
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x114e0
movq %rbx, %rdi
callq 0x11900
| _ZNK5Catch10BinaryExprIR11line_type_eS2_E29streamReconstructedExpressionERSo:
push r15
push r14
push r12
push rbx
sub rsp, 48h
mov rbx, rsi
mov r12, rdi
mov rax, [rdi+10h]
movzx eax, word ptr [rax]
lea rsi, [rsp+68h+var_60]
mov [rsi], ax
lea rdi, [rsp+68h+var_40]
call _ZN5Catch11StringMakerIsvE7convertIsEENSt9enable_ifIXgssr5Catch6Detail18IsStreamInsertableIT_EE5valueENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE4typeERKS4_
mov r14, [r12+18h]
mov r15, [r12+20h]
mov rax, [r12+28h]
movzx eax, word ptr [rax]
lea rsi, [rsp+68h+var_62]
mov [rsi], ax
lea rdi, [rsp+68h+var_60]
call _ZN5Catch11StringMakerIsvE7convertIsEENSt9enable_ifIXgssr5Catch6Detail18IsStreamInsertableIT_EE5valueENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE4typeERKS4_
lea rsi, [rsp+68h+var_40]
lea r8, [rsp+68h+var_60]
mov rdi, rbx
mov rdx, r14
mov rcx, r15
call _ZN5Catch29formatReconstructedExpressionERSoRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_9StringRefES8_; Catch::formatReconstructedExpression(std::ostream &,std::string const&,Catch::StringRef,std::string const&)
lea rax, [rsp+68h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_16759
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_16759:
lea rax, [rsp+68h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_16774
mov rsi, [rsp+68h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_16774:
add rsp, 48h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_167A3
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_167A3
mov rbx, rax
loc_167A3:
lea rax, [rsp+arg_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_167BE
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_167BE:
mov rdi, rbx
call __Unwind_Resume
| void Catch::BinaryExpr<line_type_e &,line_type_e &>::streamReconstructedExpression(long long a1, long long a2)
{
long long v2; // r14
long long v3; // r15
__int16 v4; // [rsp+6h] [rbp-62h] BYREF
void *v5[2]; // [rsp+8h] [rbp-60h] BYREF
long long v6; // [rsp+18h] [rbp-50h] BYREF
void *v7[2]; // [rsp+28h] [rbp-40h] BYREF
long long v8; // [rsp+38h] [rbp-30h] BYREF
LOWORD(v5[0]) = **(_WORD **)(a1 + 16);
Catch::StringMaker<short,void>::convert<short>((long long)v7, (__int16 *)v5);
v2 = *(_QWORD *)(a1 + 24);
v3 = *(_QWORD *)(a1 + 32);
v4 = **(_WORD **)(a1 + 40);
Catch::StringMaker<short,void>::convert<short>((long long)v5, &v4);
Catch::formatReconstructedExpression(a2, v7, v2, v3, v5);
if ( v5[0] != &v6 )
operator delete(v5[0], v6 + 1);
if ( v7[0] != &v8 )
operator delete(v7[0], v8 + 1);
}
| streamReconstructedExpression:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RSI
MOV R12,RDI
MOV RAX,qword ptr [RDI + 0x10]
MOVZX EAX,word ptr [RAX]
LEA RSI,[RSP + 0x8]
MOV word ptr [RSI],AX
LEA RDI,[RSP + 0x28]
CALL 0x0011667e
MOV R14,qword ptr [R12 + 0x18]
MOV R15,qword ptr [R12 + 0x20]
MOV RAX,qword ptr [R12 + 0x28]
MOVZX EAX,word ptr [RAX]
LEA RSI,[RSP + 0x6]
MOV word ptr [RSI],AX
LAB_0011671c:
LEA RDI,[RSP + 0x8]
CALL 0x0011667e
LAB_00116726:
LEA RSI,[RSP + 0x28]
LEA R8,[RSP + 0x8]
MOV RDI,RBX
MOV RDX,R14
MOV RCX,R15
CALL 0x0012a994
LAB_0011673e:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00116759
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001114e0
LAB_00116759:
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00116774
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001114e0
LAB_00116774:
ADD RSP,0x48
POP RBX
POP R12
POP R14
POP R15
RET
|
/* Catch::BinaryExpr<line_type_e&, line_type_e&>::streamReconstructedExpression(std::ostream&) const
*/
void __thiscall
Catch::BinaryExpr<line_type_e&,line_type_e&>::streamReconstructedExpression
(BinaryExpr<line_type_e&,line_type_e&> *this,ostream *param_1)
{
int8 uVar1;
int8 uVar2;
short local_62;
short local_60;
int6 uStack_5e;
long local_50 [2];
long *local_40 [2];
long local_30 [2];
local_60 = **(short **)(this + 0x10);
StringMaker<short,void>::convert<short>((StringMaker<short,void> *)local_40,&local_60);
uVar1 = *(int8 *)(this + 0x18);
uVar2 = *(int8 *)(this + 0x20);
local_62 = **(short **)(this + 0x28);
/* try { // try from 0011671c to 00116725 has its CatchHandler @ 001167a0 */
StringMaker<short,void>::convert<short>((StringMaker<short,void> *)&local_60,&local_62);
/* try { // try from 00116726 to 0011673d has its CatchHandler @ 00116780 */
formatReconstructedExpression((Catch *)param_1,local_40,uVar1,uVar2,&local_60);
if ((long *)CONCAT62(uStack_5e,local_60) != local_50) {
operator_delete((long *)CONCAT62(uStack_5e,local_60),local_50[0] + 1);
}
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
return;
}
| |
26,317 | mysql_once_init | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static int mysql_once_init()
#else
static void mysql_once_init()
#endif
{
ma_init(); /* Will init threads */
init_client_errs();
get_default_configuration_dirs();
set_default_charset_by_name(MARIADB_DEFAULT_CHARSET, 0);
if (mysql_client_plugin_init())
{
#ifdef _WIN32
return 1;
#else
return;
#endif
}
if (!mysql_port)
{
#if !__has_feature(memory_sanitizer) /* work around MSAN deficiency */
struct servent *serv_ptr;
#endif
char *env;
mysql_port = MARIADB_PORT;
#if !__has_feature(memory_sanitizer) /* work around MSAN deficiency */
if ((serv_ptr = getservbyname("mysql", "tcp")))
mysql_port = (uint)ntohs((ushort)serv_ptr->s_port);
#endif
if ((env = getenv("MYSQL_TCP_PORT")))
mysql_port =(uint)atoi(env);
}
if (!mysql_unix_port)
{
char *env;
#ifdef _WIN32
mysql_unix_port = (char*)MARIADB_NAMEDPIPE;
#else
mysql_unix_port = (char*)MARIADB_UNIX_ADDR;
#endif
if ((env = getenv("MYSQL_UNIX_PORT")) ||
(env = getenv("MARIADB_UNIX_PORT")))
mysql_unix_port = env;
} | O3 | c | mysql_once_init:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x1ef68
callq 0x331dc
xorl %eax, %eax
callq 0x32962
leaq 0x18288(%rip), %rdi # 0x35d52
xorl %esi, %esi
callq 0x328f6
xorl %eax, %eax
callq 0x27f78
testl %eax, %eax
jne 0x1db9e
leaq 0x2d5c9(%rip), %rbx # 0x4b0b0
cmpl $0x0, (%rbx)
jne 0x1db32
movl $0xcea, (%rbx) # imm = 0xCEA
leaq 0x1a98a(%rip), %rdi # 0x38483
leaq 0x1843d(%rip), %rsi # 0x35f3d
callq 0x13080
testq %rax, %rax
je 0x1db17
movzwl 0x10(%rax), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, (%rbx)
leaq 0x18423(%rip), %rdi # 0x35f41
callq 0x13590
testq %rax, %rax
je 0x1db32
movq %rax, %rdi
callq 0x136f0
movl %eax, (%rbx)
leaq 0x2d57f(%rip), %rbx # 0x4b0b8
cmpq $0x0, (%rbx)
jne 0x1db6e
leaq 0x1840a(%rip), %rax # 0x35f50
movq %rax, (%rbx)
leaq 0x18410(%rip), %rdi # 0x35f60
callq 0x13590
testq %rax, %rax
jne 0x1db6b
leaq 0x1840f(%rip), %rdi # 0x35f70
callq 0x13590
testq %rax, %rax
je 0x1db6e
movq %rax, (%rbx)
leaq 0x2d56b(%rip), %rax # 0x4b0e0
cmpb $0x0, (%rax)
jne 0x1db7f
callq 0x24322
xorl %edi, %edi
xorl %esi, %esi
callq 0x28a48
movl $0x1, %esi
movl $0xd, %edi
callq 0x13560
movb $0x1, 0x2d526(%rip) # 0x4b0c4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
| mysql_once_init:
push rbp
mov rbp, rsp
push rbx
push rax
call ma_init
call init_client_errs
xor eax, eax
call get_default_configuration_dirs
lea rdi, aUtf8mb4; "utf8mb4"
xor esi, esi
call set_default_charset_by_name
xor eax, eax
call mysql_client_plugin_init
test eax, eax
jnz loc_1DB9E
lea rbx, mysql_port
cmp dword ptr [rbx], 0
jnz short loc_1DB32
mov dword ptr [rbx], 0CEAh
lea rdi, aEtcMysql+5; "mysql"
lea rsi, aTcp; "tcp"
call _getservbyname
test rax, rax
jz short loc_1DB17
movzx eax, word ptr [rax+10h]
rol ax, 8
movzx eax, ax
mov [rbx], eax
loc_1DB17:
lea rdi, aMysqlTcpPort; "MYSQL_TCP_PORT"
call _getenv
test rax, rax
jz short loc_1DB32
mov rdi, rax
call _atoi
mov [rbx], eax
loc_1DB32:
lea rbx, mysql_unix_port
cmp qword ptr [rbx], 0
jnz short loc_1DB6E
lea rax, aTmpMysqlSock; "/tmp/mysql.sock"
mov [rbx], rax
lea rdi, aMysqlUnixPort; "MYSQL_UNIX_PORT"
call _getenv
test rax, rax
jnz short loc_1DB6B
lea rdi, aMariadbUnixPor; "MARIADB_UNIX_PORT"
call _getenv
test rax, rax
jz short loc_1DB6E
loc_1DB6B:
mov [rbx], rax
loc_1DB6E:
lea rax, mysql_ps_subsystem_initialized
cmp byte ptr [rax], 0
jnz short loc_1DB7F
call mysql_init_ps_subsystem
loc_1DB7F:
xor edi, edi
xor esi, esi
call ma_tls_start
mov esi, 1
mov edi, 0Dh
call _signal
mov cs:mysql_client_init, 1
loc_1DB9E:
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_once_init(long long a1)
{
long long result; // rax
long long v2; // rax
long long v3; // rax
long long v4; // rax
ma_init(a1);
init_client_errs();
get_default_configuration_dirs();
set_default_charset_by_name("utf8mb4", 0LL);
result = mysql_client_plugin_init();
if ( !(_DWORD)result )
{
if ( !mysql_port )
{
mysql_port = 3306;
v2 = getservbyname("mysql", "tcp");
if ( v2 )
mysql_port = (unsigned __int16)__ROL2__(*(_WORD *)(v2 + 16), 8);
v3 = getenv("MYSQL_TCP_PORT");
if ( v3 )
mysql_port = atoi(v3);
}
if ( !mysql_unix_port )
{
mysql_unix_port = "/tmp/mysql.sock";
v4 = getenv("MYSQL_UNIX_PORT");
if ( v4 || (v4 = getenv("MARIADB_UNIX_PORT")) != 0 )
mysql_unix_port = v4;
}
if ( !mysql_ps_subsystem_initialized )
mysql_init_ps_subsystem();
ma_tls_start(0LL, 0LL);
result = signal(13LL, 1LL);
mysql_client_init = 1;
}
return result;
}
| mysql_once_init:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
CALL 0x0011ef68
CALL 0x001331dc
XOR EAX,EAX
CALL 0x00132962
LEA RDI,[0x135d52]
XOR ESI,ESI
CALL 0x001328f6
XOR EAX,EAX
CALL 0x00127f78
TEST EAX,EAX
JNZ 0x0011db9e
LEA RBX,[0x14b0b0]
CMP dword ptr [RBX],0x0
JNZ 0x0011db32
MOV dword ptr [RBX],0xcea
LEA RDI,[0x138483]
LEA RSI,[0x135f3d]
CALL 0x00113080
TEST RAX,RAX
JZ 0x0011db17
MOVZX EAX,word ptr [RAX + 0x10]
ROL AX,0x8
MOVZX EAX,AX
MOV dword ptr [RBX],EAX
LAB_0011db17:
LEA RDI,[0x135f41]
CALL 0x00113590
TEST RAX,RAX
JZ 0x0011db32
MOV RDI,RAX
CALL 0x001136f0
MOV dword ptr [RBX],EAX
LAB_0011db32:
LEA RBX,[0x14b0b8]
CMP qword ptr [RBX],0x0
JNZ 0x0011db6e
LEA RAX,[0x135f50]
MOV qword ptr [RBX],RAX
LEA RDI,[0x135f60]
CALL 0x00113590
TEST RAX,RAX
JNZ 0x0011db6b
LEA RDI,[0x135f70]
CALL 0x00113590
TEST RAX,RAX
JZ 0x0011db6e
LAB_0011db6b:
MOV qword ptr [RBX],RAX
LAB_0011db6e:
LEA RAX,[0x14b0e0]
CMP byte ptr [RAX],0x0
JNZ 0x0011db7f
CALL 0x00124322
LAB_0011db7f:
XOR EDI,EDI
XOR ESI,ESI
CALL 0x00128a48
MOV ESI,0x1
MOV EDI,0xd
CALL 0x00113560
MOV byte ptr [0x0014b0c4],0x1
LAB_0011db9e:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_once_init(void)
{
ushort uVar1;
int iVar2;
servent *psVar3;
char *pcVar4;
ma_init();
init_client_errs();
get_default_configuration_dirs();
set_default_charset_by_name("utf8mb4",0);
iVar2 = mysql_client_plugin_init();
if (iVar2 == 0) {
if (mysql_port == 0) {
mysql_port = 0xcea;
psVar3 = getservbyname("mysql","tcp");
if (psVar3 != (servent *)0x0) {
uVar1 = (ushort)psVar3->s_port;
mysql_port = (uint)(ushort)(uVar1 << 8 | uVar1 >> 8);
}
pcVar4 = getenv("MYSQL_TCP_PORT");
if (pcVar4 != (char *)0x0) {
mysql_port = atoi(pcVar4);
}
}
if (mysql_unix_port == (char *)0x0) {
mysql_unix_port = "/tmp/mysql.sock";
pcVar4 = getenv("MYSQL_UNIX_PORT");
if ((pcVar4 != (char *)0x0) || (pcVar4 = getenv("MARIADB_UNIX_PORT"), pcVar4 != (char *)0x0))
{
mysql_unix_port = pcVar4;
}
}
if (mysql_ps_subsystem_initialized == '\0') {
mysql_init_ps_subsystem();
}
ma_tls_start(0,0);
signal(0xd,(__sighandler_t)0x1);
mysql_client_init = 1;
return;
}
return;
}
| |
26,318 | my_close | eloqsql/mysys/my_open.c | int my_close(File fd, myf MyFlags)
{
int err;
char *name= NULL;
DBUG_ENTER("my_close");
DBUG_PRINT("my",("fd: %d MyFlags: %lu",fd, MyFlags));
if (!(MyFlags & (MY_WME | MY_FAE)))
MyFlags|= my_global_flags;
if ((uint) fd < my_file_limit && my_file_info[fd].type != UNOPEN)
{
name= my_file_info[fd].name;
my_file_info[fd].name= NULL;
my_file_info[fd].type= UNOPEN;
}
#ifndef _WIN32
err= close(fd);
#else
err= my_win_close(fd);
#endif
if (err)
{
DBUG_PRINT("error",("Got error %d on close",err));
my_errno=errno;
if (MyFlags & (MY_FAE | MY_WME))
my_error(EE_BADCLOSE, MYF(ME_BELL | (MyFlags & (ME_NOTE | ME_ERROR_LOG))),
name,errno);
}
if (name)
{
my_free(name);
}
my_atomic_add32_explicit(&my_file_opened, -1, MY_MEMORY_ORDER_RELAXED);
DBUG_RETURN(err);
} | O3 | c | my_close:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
xorl %ebx, %ebx
movl $0x0, %r14d
testb $0x18, %r12b
jne 0xc42ca
leaq 0xb97741(%rip), %rax # 0xc5ba08
movq (%rax), %r14
leaq 0x2f43ef(%rip), %rax # 0x3b86c0
cmpl %edi, (%rax)
jbe 0xc4309
leaq 0x2f43ec(%rip), %rax # 0x3b86c8
movq (%rax), %rdx
movslq %edi, %rcx
shlq $0x4, %rcx
cmpl $0x0, 0x8(%rdx,%rcx)
je 0xc4307
addq %rcx, %rdx
movq (%rdx), %rbx
movq $0x0, (%rdx)
movq (%rax), %rax
movl $0x0, 0x8(%rax,%rcx)
jmp 0xc4309
xorl %ebx, %ebx
callq 0x2b1c0
movl %eax, %r15d
testl %eax, %eax
je 0xc4352
orq %r12, %r14
callq 0x2b950
movq %rax, %r12
movl (%rax), %r13d
callq 0xc5c9a
movl %r13d, (%rax)
testb $0x18, %r14b
je 0xc4352
andl $0x440, %r14d # imm = 0x440
orq $0x4, %r14
movl (%r12), %ecx
movl $0x4, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xbf527
testq %rbx, %rbx
je 0xc435f
movq %rbx, %rdi
callq 0xc3cfa
leaq 0xb976ae(%rip), %rax # 0xc5ba14
lock
decl (%rax)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| my_close:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rsi
xor ebx, ebx
mov r14d, 0
test r12b, 18h
jnz short loc_C42CA
lea rax, my_global_flags
mov r14, [rax]
loc_C42CA:
lea rax, my_file_limit
cmp [rax], edi
jbe short loc_C4309
lea rax, my_file_info
mov rdx, [rax]
movsxd rcx, edi
shl rcx, 4
cmp dword ptr [rdx+rcx+8], 0
jz short loc_C4307
add rdx, rcx
mov rbx, [rdx]
mov qword ptr [rdx], 0
mov rax, [rax]
mov dword ptr [rax+rcx+8], 0
jmp short loc_C4309
loc_C4307:
xor ebx, ebx
loc_C4309:
call _close
mov r15d, eax
test eax, eax
jz short loc_C4352
or r14, r12
call ___errno_location
mov r12, rax
mov r13d, [rax]
call _my_thread_var
mov [rax], r13d
test r14b, 18h
jz short loc_C4352
and r14d, 440h
or r14, 4
mov ecx, [r12]
mov edi, 4
mov rsi, r14
mov rdx, rbx
xor eax, eax
call my_error
loc_C4352:
test rbx, rbx
jz short loc_C435F
mov rdi, rbx
call my_free
loc_C435F:
lea rax, my_file_opened
lock dec dword ptr [rax]
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_close(long long a1, __int16 a2)
{
long long v2; // rbx
__int16 v3; // r14
long long v4; // rcx
unsigned int v5; // r15d
__int16 v6; // r14
unsigned int *v7; // r12
unsigned int v8; // r13d
v2 = 0LL;
v3 = 0;
if ( (a2 & 0x18) == 0 )
v3 = my_global_flags;
if ( my_file_limit > (unsigned int)a1 )
{
v4 = 16LL * (int)a1;
if ( *(_DWORD *)((char *)my_file_info + v4 + 8) )
{
v2 = *(_QWORD *)((char *)my_file_info + v4);
*(_QWORD *)((char *)my_file_info + v4) = 0LL;
*(_DWORD *)((char *)my_file_info + v4 + 8) = 0;
}
else
{
v2 = 0LL;
}
}
v5 = close(a1);
if ( v5 )
{
v6 = a2 | v3;
v7 = (unsigned int *)__errno_location(a1);
v8 = *v7;
*(_DWORD *)my_thread_var(a1) = v8;
if ( (v6 & 0x18) != 0 )
my_error(4u, v6 & 0x440 | 4LL, v2, *v7);
}
if ( v2 )
my_free(v2);
_InterlockedDecrement(my_file_opened);
return v5;
}
| my_close:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RSI
XOR EBX,EBX
MOV R14D,0x0
TEST R12B,0x18
JNZ 0x001c42ca
LEA RAX,[0xd5ba08]
MOV R14,qword ptr [RAX]
LAB_001c42ca:
LEA RAX,[0x4b86c0]
CMP dword ptr [RAX],EDI
JBE 0x001c4309
LEA RAX,[0x4b86c8]
MOV RDX,qword ptr [RAX]
MOVSXD RCX,EDI
SHL RCX,0x4
CMP dword ptr [RDX + RCX*0x1 + 0x8],0x0
JZ 0x001c4307
ADD RDX,RCX
MOV RBX,qword ptr [RDX]
MOV qword ptr [RDX],0x0
MOV RAX,qword ptr [RAX]
MOV dword ptr [RAX + RCX*0x1 + 0x8],0x0
JMP 0x001c4309
LAB_001c4307:
XOR EBX,EBX
LAB_001c4309:
CALL 0x0012b1c0
MOV R15D,EAX
TEST EAX,EAX
JZ 0x001c4352
OR R14,R12
CALL 0x0012b950
MOV R12,RAX
MOV R13D,dword ptr [RAX]
CALL 0x001c5c9a
MOV dword ptr [RAX],R13D
TEST R14B,0x18
JZ 0x001c4352
AND R14D,0x440
OR R14,0x4
MOV ECX,dword ptr [R12]
MOV EDI,0x4
MOV RSI,R14
MOV RDX,RBX
XOR EAX,EAX
CALL 0x001bf527
LAB_001c4352:
TEST RBX,RBX
JZ 0x001c435f
MOV RDI,RBX
CALL 0x001c3cfa
LAB_001c435f:
LEA RAX,[0xd5ba14]
DEC.LOCK dword ptr [RAX]
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int my_close(uint param_1,ulong param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
long lVar5;
long lVar6;
ulong uVar7;
lVar6 = 0;
uVar7 = 0;
if ((param_2 & 0x18) == 0) {
uVar7 = my_global_flags;
}
if (param_1 < my_file_limit) {
lVar5 = (long)(int)param_1 * 0x10;
if (*(int *)(my_file_info + lVar5 + 8) == 0) {
lVar6 = 0;
}
else {
lVar6 = *(long *)(my_file_info + lVar5);
*(long *)(my_file_info + lVar5) = 0;
*(int4 *)(my_file_info + lVar5 + 8) = 0;
}
}
iVar2 = close(param_1);
if (iVar2 != 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if (((uVar7 | param_2) & 0x18) != 0) {
my_error(4,(uint)(uVar7 | param_2) & 0x440 | 4,lVar6,*piVar3);
}
}
if (lVar6 != 0) {
my_free(lVar6);
}
LOCK();
my_file_opened = my_file_opened + -1;
UNLOCK();
return iVar2;
}
| |
26,319 | bf_pow_ui | bluesky950520[P]quickjs/libbf.c | static int bf_pow_ui(bf_t *r, const bf_t *a, limb_t b, limb_t prec,
bf_flags_t flags)
{
int ret, n_bits, i;
assert(r != a);
if (b == 0)
return bf_set_ui(r, 1);
ret = bf_set(r, a);
n_bits = LIMB_BITS - clz(b);
for(i = n_bits - 2; i >= 0; i--) {
ret |= bf_mul(r, r, r, prec, flags);
if ((b >> i) & 1)
ret |= bf_mul(r, r, a, prec, flags);
}
return ret;
} | O1 | c | bf_pow_ui:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
testq %rdx, %rdx
je 0x8c0f9
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %r14, %rdi
callq 0x84c8d
movl %eax, %r13d
bsrq %r12, %rax
xorq $0x3f, %rax
cmpq $0x3f, %rax
jne 0x8c114
movl %r13d, %ebp
jmp 0x8c189
movl $0x1, %esi
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x84abb
movq %rbp, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movl %ebx, 0xc(%rsp)
movl $0x3e, %r12d
subl %eax, %r12d
movl $0x3f, %ebx
subl %eax, %ebx
movq %r15, 0x10(%rsp)
movq %r14, %rdi
movq %r14, %rsi
movq %r14, %rdx
movq %r15, %rcx
movl 0xc(%rsp), %r15d
movl %r15d, %r8d
callq 0x86711
movl %eax, %ebp
orl %r13d, %ebp
movq 0x20(%rsp), %rax
btq %r12, %rax
jae 0x8c17a
movq %r14, %rdi
movq %r14, %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl %r15d, %r8d
callq 0x86711
orl %eax, %ebp
decq %r12
movl %ebp, %r13d
decl %ebx
movq 0x10(%rsp), %r15
jg 0x8c137
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| bf_pow_ui:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdi
test rdx, rdx
jz short loc_8C0F9
mov ebx, r8d
mov r15, rcx
mov r12, rdx
mov rbp, rsi
mov rdi, r14
call bf_set
mov r13d, eax
bsr rax, r12
xor rax, 3Fh
cmp rax, 3Fh ; '?'
jnz short loc_8C114
mov ebp, r13d
jmp loc_8C189
loc_8C0F9:
mov esi, 1
mov rdi, r14
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp bf_set_ui
loc_8C114:
mov [rsp+58h+var_40], rbp
mov [rsp+58h+var_38], r12
mov [rsp+58h+var_4C], ebx
mov r12d, 3Eh ; '>'
sub r12d, eax
mov ebx, 3Fh ; '?'
sub ebx, eax
mov [rsp+58h+var_48], r15
loc_8C137:
mov rdi, r14
mov rsi, r14
mov rdx, r14
mov rcx, r15
mov r15d, [rsp+58h+var_4C]
mov r8d, r15d
call bf_mul
mov ebp, eax
or ebp, r13d
mov rax, [rsp+58h+var_38]
bt rax, r12
jnb short loc_8C17A
mov rdi, r14
mov rsi, r14
mov rdx, [rsp+58h+var_40]
mov rcx, [rsp+58h+var_48]
mov r8d, r15d
call bf_mul
or ebp, eax
loc_8C17A:
dec r12
mov r13d, ebp
dec ebx
mov r15, [rsp+58h+var_48]
jg short loc_8C137
loc_8C189:
mov eax, ebp
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long bf_pow_ui(__int128 *a1, long long a2, unsigned long long a3, long long a4, unsigned int a5)
{
unsigned int v8; // r13d
unsigned long long v9; // rax
unsigned long long v10; // rax
unsigned int v11; // ebp
unsigned long long v13; // r12
int v14; // ebx
unsigned long long v15; // rax
bool v16; // cc
unsigned int v17; // [rsp+Ch] [rbp-4Ch]
long long v18; // [rsp+10h] [rbp-48h]
unsigned long long v19; // [rsp+20h] [rbp-38h]
if ( !a3 )
return bf_set_ui((_QWORD **)a1, 1uLL);
v8 = bf_set(a1, a2);
_BitScanReverse64(&v9, a3);
v10 = v9 ^ 0x3F;
if ( v10 == 63 )
{
return v8;
}
else
{
v19 = a3;
v17 = a5;
v13 = (unsigned int)(62 - v10);
v14 = 63 - v10;
v18 = a4;
do
{
v11 = v8 | bf_mul(a1, (long long)a1, (long long)a1, a4, v17);
v15 = v19;
if ( _bittest64((const long long *)&v15, v13) )
v11 |= bf_mul(a1, (long long)a1, a2, v18, v17);
--v13;
v8 = v11;
v16 = v14-- <= 1;
a4 = v18;
}
while ( !v16 );
}
return v11;
}
| bf_pow_ui:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDI
TEST RDX,RDX
JZ 0x0018c0f9
MOV EBX,R8D
MOV R15,RCX
MOV R12,RDX
MOV RBP,RSI
MOV RDI,R14
CALL 0x00184c8d
MOV R13D,EAX
BSR RAX,R12
XOR RAX,0x3f
CMP RAX,0x3f
JNZ 0x0018c114
MOV EBP,R13D
JMP 0x0018c189
LAB_0018c0f9:
MOV ESI,0x1
MOV RDI,R14
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00184abb
LAB_0018c114:
MOV qword ptr [RSP + 0x18],RBP
MOV qword ptr [RSP + 0x20],R12
MOV dword ptr [RSP + 0xc],EBX
MOV R12D,0x3e
SUB R12D,EAX
MOV EBX,0x3f
SUB EBX,EAX
MOV qword ptr [RSP + 0x10],R15
LAB_0018c137:
MOV RDI,R14
MOV RSI,R14
MOV RDX,R14
MOV RCX,R15
MOV R15D,dword ptr [RSP + 0xc]
MOV R8D,R15D
CALL 0x00186711
MOV EBP,EAX
OR EBP,R13D
MOV RAX,qword ptr [RSP + 0x20]
BT RAX,R12
JNC 0x0018c17a
MOV RDI,R14
MOV RSI,R14
MOV RDX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x10]
MOV R8D,R15D
CALL 0x00186711
OR EBP,EAX
LAB_0018c17a:
DEC R12
MOV R13D,EBP
DEC EBX
MOV R15,qword ptr [RSP + 0x10]
JG 0x0018c137
LAB_0018c189:
MOV EAX,EBP
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong bf_pow_ui(int8 param_1,int8 param_2,ulong param_3,int8 param_4,
int4 param_5)
{
bool bVar1;
uint uVar2;
int iVar3;
uint uVar4;
int iVar5;
ulong uVar6;
ulong uVar7;
if (param_3 == 0) {
uVar7 = bf_set_ui(param_1,1);
return uVar7;
}
uVar2 = bf_set(param_1);
uVar6 = (ulong)uVar2;
uVar7 = 0x3f;
if (param_3 != 0) {
for (; param_3 >> uVar7 == 0; uVar7 = uVar7 - 1) {
}
}
if ((uVar7 ^ 0x3f) != 0x3f) {
iVar3 = (int)(uVar7 ^ 0x3f);
uVar7 = (ulong)(0x3e - iVar3);
iVar3 = 0x3f - iVar3;
do {
uVar2 = bf_mul(param_1,param_1,param_1,param_4,param_5);
uVar2 = uVar2 | (uint)uVar6;
if ((param_3 >> (uVar7 & 0x3f) & 1) != 0) {
uVar4 = bf_mul(param_1,param_1,param_2,param_4,param_5);
uVar2 = uVar2 | uVar4;
}
uVar6 = (ulong)uVar2;
uVar7 = uVar7 - 1;
iVar5 = iVar3 + -1;
bVar1 = 0 < iVar3;
iVar3 = iVar5;
} while (iVar5 != 0 && bVar1);
}
return uVar6;
}
| |
26,320 | JS_NewObjectFromShape | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_NewObjectFromShape(JSContext *ctx, JSShape *sh, JSClassID class_id)
{
JSObject *p;
js_trigger_gc(ctx->rt, sizeof(JSObject));
p = js_malloc(ctx, sizeof(JSObject));
if (unlikely(!p))
goto fail;
p->class_id = class_id;
p->extensible = TRUE;
p->free_mark = 0;
p->is_exotic = 0;
p->fast_array = 0;
p->is_constructor = 0;
p->is_uncatchable_error = 0;
p->tmp_mark = 0;
p->is_HTMLDDA = 0;
p->first_weak_ref = NULL;
p->u.opaque = NULL;
p->shape = sh;
p->prop = js_malloc(ctx, sizeof(JSProperty) * sh->prop_size);
if (unlikely(!p->prop)) {
js_free(ctx, p);
fail:
js_free_shape(ctx->rt, sh);
return JS_EXCEPTION;
}
switch(class_id) {
case JS_CLASS_OBJECT:
break;
case JS_CLASS_ARRAY:
{
JSProperty *pr;
p->is_exotic = 1;
p->fast_array = 1;
p->u.array.u.values = NULL;
p->u.array.count = 0;
p->u.array.u1.size = 0;
/* the length property is always the first one */
if (likely(sh == ctx->array_shape)) {
pr = &p->prop[0];
} else {
/* only used for the first array */
/* cannot fail */
pr = add_property(ctx, p, JS_ATOM_length,
JS_PROP_WRITABLE | JS_PROP_LENGTH);
}
pr->u.value = js_int32(0);
}
break;
case JS_CLASS_C_FUNCTION:
p->prop[0].u.value = JS_UNDEFINED;
break;
case JS_CLASS_ARGUMENTS:
case JS_CLASS_UINT8C_ARRAY:
case JS_CLASS_INT8_ARRAY:
case JS_CLASS_UINT8_ARRAY:
case JS_CLASS_INT16_ARRAY:
case JS_CLASS_UINT16_ARRAY:
case JS_CLASS_INT32_ARRAY:
case JS_CLASS_UINT32_ARRAY:
case JS_CLASS_BIG_INT64_ARRAY:
case JS_CLASS_BIG_UINT64_ARRAY:
case JS_CLASS_FLOAT16_ARRAY:
case JS_CLASS_FLOAT32_ARRAY:
case JS_CLASS_FLOAT64_ARRAY:
p->is_exotic = 1;
p->fast_array = 1;
p->u.array.u.ptr = NULL;
p->u.array.count = 0;
break;
case JS_CLASS_DATAVIEW:
p->u.array.u.ptr = NULL;
p->u.array.count = 0;
break;
case JS_CLASS_NUMBER:
case JS_CLASS_STRING:
case JS_CLASS_BOOLEAN:
case JS_CLASS_SYMBOL:
case JS_CLASS_DATE:
case JS_CLASS_BIG_INT:
p->u.object_data = JS_UNDEFINED;
goto set_exotic;
case JS_CLASS_REGEXP:
p->u.regexp.pattern = NULL;
p->u.regexp.bytecode = NULL;
goto set_exotic;
default:
set_exotic:
if (ctx->rt->class_array[class_id].exotic) {
p->is_exotic = 1;
}
break;
}
p->header.ref_count = 1;
add_gc_object(ctx->rt, &p->header, JS_GC_OBJ_TYPE_JS_OBJECT);
return JS_MKPTR(JS_TAG_OBJECT, p);
} | O0 | c | JS_NewObjectFromShape:
subq $0x78, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rdi
movl $0x48, %esi
callq 0x5ca10
movq 0x60(%rsp), %rdi
movl $0x48, %esi
callq 0x209f0
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x28e3a
jmp 0x28f4c
movl 0x54(%rsp), %eax
movw %ax, %cx
movq 0x48(%rsp), %rax
movw %cx, 0x6(%rax)
movq 0x48(%rsp), %rax
movb 0x5(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x5(%rax)
movq 0x48(%rsp), %rax
movb 0x5(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x5(%rax)
movq 0x48(%rsp), %rax
movb 0x5(%rax), %cl
andb $-0x5, %cl
orb $0x0, %cl
movb %cl, 0x5(%rax)
movq 0x48(%rsp), %rax
movb 0x5(%rax), %cl
andb $-0x9, %cl
orb $0x0, %cl
movb %cl, 0x5(%rax)
movq 0x48(%rsp), %rax
movb 0x5(%rax), %cl
andb $-0x11, %cl
orb $0x0, %cl
movb %cl, 0x5(%rax)
movq 0x48(%rsp), %rax
movb 0x5(%rax), %cl
andb $-0x21, %cl
orb $0x0, %cl
movb %cl, 0x5(%rax)
movq 0x48(%rsp), %rax
movb 0x5(%rax), %cl
andb $-0x41, %cl
orb $0x0, %cl
movb %cl, 0x5(%rax)
movq 0x48(%rsp), %rax
movb 0x5(%rax), %cl
andb $0x7f, %cl
orb $0x0, %cl
movb %cl, 0x5(%rax)
movq 0x48(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x48(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x58(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rax
movslq 0x24(%rax), %rsi
shlq $0x4, %rsi
callq 0x209f0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x48(%rsp), %rax
cmpq $0x0, 0x20(%rax)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x28f75
movq 0x60(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x20af0
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x58(%rsp), %rsi
callq 0x5c3d0
movl $0x0, 0x68(%rsp)
movq $0x6, 0x70(%rsp)
jmp 0x291ae
movl 0x54(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x21, %eax
ja 0x29144
movq 0x8(%rsp), %rax
leaq 0xdfdcd(%rip), %rcx # 0x108d64
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x2917b
movq 0x48(%rsp), %rax
movb 0x5(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0x5(%rax)
movq 0x48(%rsp), %rax
movb 0x5(%rax), %cl
andb $-0x9, %cl
orb $0x8, %cl
movb %cl, 0x5(%rax)
movq 0x48(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x48(%rsp), %rax
movl $0x0, 0x40(%rax)
movq 0x48(%rsp), %rax
movl $0x0, 0x30(%rax)
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rcx
cmpq 0x38(%rcx), %rax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2901e
movq 0x48(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x2903c
movq 0x60(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl $0x32, %edx
movl $0xa, %ecx
callq 0x5ca80
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
xorl %edi, %edi
callq 0x32a00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x2917b
movq 0x48(%rsp), %rax
movq 0x20(%rax), %rax
movl $0x0, 0x20(%rsp)
movq $0x3, 0x28(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x2917b
movq 0x48(%rsp), %rax
movb 0x5(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0x5(%rax)
movq 0x48(%rsp), %rax
movb 0x5(%rax), %cl
andb $-0x9, %cl
orb $0x8, %cl
movb %cl, 0x5(%rax)
movq 0x48(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x48(%rsp), %rax
movl $0x0, 0x40(%rax)
jmp 0x2917b
movq 0x48(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x48(%rsp), %rax
movl $0x0, 0x40(%rax)
jmp 0x2917b
movq 0x48(%rsp), %rax
movl $0x0, 0x10(%rsp)
movq $0x3, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x38(%rax)
jmp 0x29146
movq 0x48(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x48(%rsp), %rax
movq $0x0, 0x38(%rax)
jmp 0x29146
jmp 0x29146
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x80(%rax), %rax
movl 0x54(%rsp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x20(%rax)
je 0x29179
movq 0x48(%rsp), %rax
movb 0x5(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0x5(%rax)
jmp 0x2917b
movq 0x48(%rsp), %rax
movl $0x1, (%rax)
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x48(%rsp), %rsi
xorl %edx, %edx
callq 0x22e10
movq 0x48(%rsp), %rax
movq %rax, 0x68(%rsp)
movq $-0x1, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rdx
addq $0x78, %rsp
retq
nopl (%rax)
| JS_NewObjectFromShape:
sub rsp, 78h
mov [rsp+78h+var_18], rdi
mov [rsp+78h+var_20], rsi
mov [rsp+78h+var_24], edx
mov rax, [rsp+78h+var_18]
mov rdi, [rax+18h]
mov esi, 48h ; 'H'
call js_trigger_gc
mov rdi, [rsp+78h+var_18]
mov esi, 48h ; 'H'
call js_malloc
mov [rsp+78h+var_30], rax
cmp [rsp+78h+var_30], 0
setnz al
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_28E3A
jmp loc_28F4C
loc_28E3A:
mov eax, [rsp+78h+var_24]
mov cx, ax
mov rax, [rsp+78h+var_30]
mov [rax+6], cx
mov rax, [rsp+78h+var_30]
mov cl, [rax+5]
and cl, 0FEh
or cl, 1
mov [rax+5], cl
mov rax, [rsp+78h+var_30]
mov cl, [rax+5]
and cl, 0FDh
or cl, 0
mov [rax+5], cl
mov rax, [rsp+78h+var_30]
mov cl, [rax+5]
and cl, 0FBh
or cl, 0
mov [rax+5], cl
mov rax, [rsp+78h+var_30]
mov cl, [rax+5]
and cl, 0F7h
or cl, 0
mov [rax+5], cl
mov rax, [rsp+78h+var_30]
mov cl, [rax+5]
and cl, 0EFh
or cl, 0
mov [rax+5], cl
mov rax, [rsp+78h+var_30]
mov cl, [rax+5]
and cl, 0DFh
or cl, 0
mov [rax+5], cl
mov rax, [rsp+78h+var_30]
mov cl, [rax+5]
and cl, 0BFh
or cl, 0
mov [rax+5], cl
mov rax, [rsp+78h+var_30]
mov cl, [rax+5]
and cl, 7Fh
or cl, 0
mov [rax+5], cl
mov rax, [rsp+78h+var_30]
mov qword ptr [rax+28h], 0
mov rax, [rsp+78h+var_30]
mov qword ptr [rax+30h], 0
mov rcx, [rsp+78h+var_20]
mov rax, [rsp+78h+var_30]
mov [rax+18h], rcx
mov rdi, [rsp+78h+var_18]
mov rax, [rsp+78h+var_20]
movsxd rsi, dword ptr [rax+24h]
shl rsi, 4
call js_malloc
mov rcx, rax
mov rax, [rsp+78h+var_30]
mov [rax+20h], rcx
mov rax, [rsp+78h+var_30]
cmp qword ptr [rax+20h], 0
setnz al
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_28F75
mov rdi, [rsp+78h+var_18]
mov rsi, [rsp+78h+var_30]
call js_free
loc_28F4C:
mov rax, [rsp+78h+var_18]
mov rdi, [rax+18h]
mov rsi, [rsp+78h+var_20]
call js_free_shape
mov dword ptr [rsp+78h+var_10], 0
mov [rsp+78h+var_8], 6
jmp loc_291AE
loc_28F75:
mov eax, [rsp+78h+var_24]
dec eax; switch 34 cases
mov ecx, eax
mov [rsp+78h+var_70], rcx
sub eax, 21h
ja def_28F9E; jumptable 0000000000028F9E default case, cases 3,9,11,13-17,19,20
mov rax, [rsp+78h+var_70]
lea rcx, jpt_28F9E
movsxd rax, ds:(jpt_28F9E - 108D64h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_28FA0:
jmp loc_2917B; jumptable 0000000000028F9E case 1
loc_28FA5:
mov rax, [rsp+78h+var_30]; jumptable 0000000000028F9E case 2
mov cl, [rax+5]
and cl, 0FBh
or cl, 4
mov [rax+5], cl
mov rax, [rsp+78h+var_30]
mov cl, [rax+5]
and cl, 0F7h
or cl, 8
mov [rax+5], cl
mov rax, [rsp+78h+var_30]
mov qword ptr [rax+38h], 0
mov rax, [rsp+78h+var_30]
mov dword ptr [rax+40h], 0
mov rax, [rsp+78h+var_30]
mov dword ptr [rax+30h], 0
mov rax, [rsp+78h+var_20]
mov rcx, [rsp+78h+var_18]
cmp rax, [rcx+38h]
setz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_2901E
mov rax, [rsp+78h+var_30]
mov rax, [rax+20h]
mov [rsp+78h+var_38], rax
jmp short loc_2903C
loc_2901E:
mov rdi, [rsp+78h+var_18]
mov rsi, [rsp+78h+var_30]
mov edx, 32h ; '2'
mov ecx, 0Ah
call add_property
mov [rsp+78h+var_38], rax
loc_2903C:
mov rax, [rsp+78h+var_38]
mov [rsp+78h+var_78], rax
xor edi, edi
call js_int32
mov rcx, rax
mov rax, [rsp+78h+var_78]
mov [rsp+78h+var_48], rcx
mov [rsp+78h+var_40], rdx
mov rcx, [rsp+78h+var_48]
mov [rax], rcx
mov rcx, [rsp+78h+var_40]
mov [rax+8], rcx
jmp loc_2917B
loc_29073:
mov rax, [rsp+78h+var_30]; jumptable 0000000000028F9E case 12
mov rax, [rax+20h]
mov dword ptr [rsp+78h+var_58], 0
mov [rsp+78h+var_50], 3
mov rcx, [rsp+78h+var_58]
mov [rax], rcx
mov rcx, [rsp+78h+var_50]
mov [rax+8], rcx
jmp loc_2917B
loc_290A3:
mov rax, [rsp+78h+var_30]; jumptable 0000000000028F9E cases 8,21-32
mov cl, [rax+5]
and cl, 0FBh
or cl, 4
mov [rax+5], cl
mov rax, [rsp+78h+var_30]
mov cl, [rax+5]
and cl, 0F7h
or cl, 8
mov [rax+5], cl
mov rax, [rsp+78h+var_30]
mov qword ptr [rax+38h], 0
mov rax, [rsp+78h+var_30]
mov dword ptr [rax+40h], 0
jmp loc_2917B
loc_290E3:
mov rax, [rsp+78h+var_30]; jumptable 0000000000028F9E case 33
mov qword ptr [rax+38h], 0
mov rax, [rsp+78h+var_30]
mov dword ptr [rax+40h], 0
jmp short loc_2917B
loc_290FE:
mov rax, [rsp+78h+var_30]; jumptable 0000000000028F9E cases 4-7,10,34
mov dword ptr [rsp+78h+var_68], 0
mov [rsp+78h+var_60], 3
mov rcx, [rsp+78h+var_68]
mov [rax+30h], rcx
mov rcx, [rsp+78h+var_60]
mov [rax+38h], rcx
jmp short loc_29146
loc_29128:
mov rax, [rsp+78h+var_30]; jumptable 0000000000028F9E case 18
mov qword ptr [rax+30h], 0
mov rax, [rsp+78h+var_30]
mov qword ptr [rax+38h], 0
jmp short loc_29146
def_28F9E:
jmp short $+2; jumptable 0000000000028F9E default case, cases 3,9,11,13-17,19,20
loc_29146:
mov rax, [rsp+78h+var_18]
mov rax, [rax+18h]
mov rax, [rax+80h]
mov ecx, [rsp+78h+var_24]
imul rcx, 28h ; '('
add rax, rcx
cmp qword ptr [rax+20h], 0
jz short loc_29179
mov rax, [rsp+78h+var_30]
mov cl, [rax+5]
and cl, 0FBh
or cl, 4
mov [rax+5], cl
loc_29179:
jmp short $+2
loc_2917B:
mov rax, [rsp+78h+var_30]
mov dword ptr [rax], 1
mov rax, [rsp+78h+var_18]
mov rdi, [rax+18h]
mov rsi, [rsp+78h+var_30]
xor edx, edx
call add_gc_object
mov rax, [rsp+78h+var_30]
mov [rsp+78h+var_10], rax
mov [rsp+78h+var_8], 0FFFFFFFFFFFFFFFFh
loc_291AE:
mov rax, [rsp+78h+var_10]
mov rdx, [rsp+78h+var_8]
add rsp, 78h
retn
| long long JS_NewObjectFromShape(long long a1, long long a2, unsigned int a3)
{
long long v3; // rdx
_QWORD *v4; // rax
long long v6; // [rsp+10h] [rbp-68h]
long long v7; // [rsp+20h] [rbp-58h]
_QWORD *v8; // [rsp+40h] [rbp-38h]
long long v9; // [rsp+48h] [rbp-30h]
long long v11; // [rsp+68h] [rbp-10h]
js_trigger_gc(*(_QWORD *)(a1 + 24), 72LL);
v9 = js_malloc(a1, 72LL);
if ( !v9 )
goto LABEL_4;
*(_WORD *)(v9 + 6) = a3;
*(_BYTE *)(v9 + 5) = *(_BYTE *)(v9 + 5) & 0xFE | 1;
*(_BYTE *)(v9 + 5) &= ~2u;
*(_BYTE *)(v9 + 5) &= ~4u;
*(_BYTE *)(v9 + 5) &= ~8u;
*(_BYTE *)(v9 + 5) &= ~0x10u;
*(_BYTE *)(v9 + 5) &= ~0x20u;
*(_BYTE *)(v9 + 5) &= ~0x40u;
*(_BYTE *)(v9 + 5) &= ~0x80u;
*(_QWORD *)(v9 + 40) = 0LL;
*(_QWORD *)(v9 + 48) = 0LL;
*(_QWORD *)(v9 + 24) = a2;
*(_QWORD *)(v9 + 32) = js_malloc(a1, 16LL * *(int *)(a2 + 36));
if ( !*(_QWORD *)(v9 + 32) )
{
js_free(a1, v9);
LABEL_4:
js_free_shape(*(_QWORD *)(a1 + 24), a2);
LODWORD(v11) = 0;
return v11;
}
switch ( a3 )
{
case 1u:
goto LABEL_17;
case 2u:
*(_BYTE *)(v9 + 5) = *(_BYTE *)(v9 + 5) & 0xFB | 4;
*(_BYTE *)(v9 + 5) = *(_BYTE *)(v9 + 5) & 0xF7 | 8;
*(_QWORD *)(v9 + 56) = 0LL;
*(_DWORD *)(v9 + 64) = 0;
*(_DWORD *)(v9 + 48) = 0;
if ( a2 == *(_QWORD *)(a1 + 56) )
v8 = *(_QWORD **)(v9 + 32);
else
v8 = (_QWORD *)add_property(a1, v9, 50LL, 10LL);
*v8 = js_int32(0LL);
v8[1] = v3;
goto LABEL_17;
case 4u:
case 5u:
case 6u:
case 7u:
case 0xAu:
case 0x22u:
LODWORD(v6) = 0;
*(_QWORD *)(v9 + 48) = v6;
*(_QWORD *)(v9 + 56) = 3LL;
goto LABEL_15;
case 8u:
case 0x15u:
case 0x16u:
case 0x17u:
case 0x18u:
case 0x19u:
case 0x1Au:
case 0x1Bu:
case 0x1Cu:
case 0x1Du:
case 0x1Eu:
case 0x1Fu:
case 0x20u:
*(_BYTE *)(v9 + 5) = *(_BYTE *)(v9 + 5) & 0xFB | 4;
*(_BYTE *)(v9 + 5) = *(_BYTE *)(v9 + 5) & 0xF7 | 8;
*(_QWORD *)(v9 + 56) = 0LL;
*(_DWORD *)(v9 + 64) = 0;
goto LABEL_17;
case 0xCu:
v4 = *(_QWORD **)(v9 + 32);
LODWORD(v7) = 0;
*v4 = v7;
v4[1] = 3LL;
goto LABEL_17;
case 0x12u:
*(_QWORD *)(v9 + 48) = 0LL;
*(_QWORD *)(v9 + 56) = 0LL;
goto LABEL_15;
case 0x21u:
*(_QWORD *)(v9 + 56) = 0LL;
*(_DWORD *)(v9 + 64) = 0;
goto LABEL_17;
default:
LABEL_15:
if ( *(_QWORD *)(40LL * a3 + *(_QWORD *)(*(_QWORD *)(a1 + 24) + 128LL) + 32) )
*(_BYTE *)(v9 + 5) = *(_BYTE *)(v9 + 5) & 0xFB | 4;
LABEL_17:
*(_DWORD *)v9 = 1;
add_gc_object(*(_QWORD *)(a1 + 24), v9, 0);
v11 = v9;
break;
}
return v11;
}
| JS_NewObjectFromShape:
SUB RSP,0x78
MOV qword ptr [RSP + 0x60],RDI
MOV qword ptr [RSP + 0x58],RSI
MOV dword ptr [RSP + 0x54],EDX
MOV RAX,qword ptr [RSP + 0x60]
MOV RDI,qword ptr [RAX + 0x18]
MOV ESI,0x48
CALL 0x0015ca10
MOV RDI,qword ptr [RSP + 0x60]
MOV ESI,0x48
CALL 0x001209f0
MOV qword ptr [RSP + 0x48],RAX
CMP qword ptr [RSP + 0x48],0x0
SETNZ AL
XOR AL,0xff
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00128e3a
JMP 0x00128f4c
LAB_00128e3a:
MOV EAX,dword ptr [RSP + 0x54]
MOV CX,AX
MOV RAX,qword ptr [RSP + 0x48]
MOV word ptr [RAX + 0x6],CX
MOV RAX,qword ptr [RSP + 0x48]
MOV CL,byte ptr [RAX + 0x5]
AND CL,0xfe
OR CL,0x1
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RSP + 0x48]
MOV CL,byte ptr [RAX + 0x5]
AND CL,0xfd
OR CL,0x0
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RSP + 0x48]
MOV CL,byte ptr [RAX + 0x5]
AND CL,0xfb
OR CL,0x0
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RSP + 0x48]
MOV CL,byte ptr [RAX + 0x5]
AND CL,0xf7
OR CL,0x0
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RSP + 0x48]
MOV CL,byte ptr [RAX + 0x5]
AND CL,0xef
OR CL,0x0
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RSP + 0x48]
MOV CL,byte ptr [RAX + 0x5]
AND CL,0xdf
OR CL,0x0
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RSP + 0x48]
MOV CL,byte ptr [RAX + 0x5]
AND CL,0xbf
OR CL,0x0
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RSP + 0x48]
MOV CL,byte ptr [RAX + 0x5]
AND CL,0x7f
OR CL,0x0
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x28],0x0
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x30],0x0
MOV RCX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x18],RCX
MOV RDI,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RSP + 0x58]
MOVSXD RSI,dword ptr [RAX + 0x24]
SHL RSI,0x4
CALL 0x001209f0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RSP + 0x48]
CMP qword ptr [RAX + 0x20],0x0
SETNZ AL
XOR AL,0xff
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00128f75
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00120af0
LAB_00128f4c:
MOV RAX,qword ptr [RSP + 0x60]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x0015c3d0
MOV dword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x6
JMP 0x001291ae
LAB_00128f75:
MOV EAX,dword ptr [RSP + 0x54]
DEC EAX
MOV ECX,EAX
MOV qword ptr [RSP + 0x8],RCX
SUB EAX,0x21
JA 0x00129144
MOV RAX,qword ptr [RSP + 0x8]
LEA RCX,[0x208d64]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
JMP 0x0012917b
caseD_2:
MOV RAX,qword ptr [RSP + 0x48]
MOV CL,byte ptr [RAX + 0x5]
AND CL,0xfb
OR CL,0x4
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RSP + 0x48]
MOV CL,byte ptr [RAX + 0x5]
AND CL,0xf7
OR CL,0x8
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x38],0x0
MOV RAX,qword ptr [RSP + 0x48]
MOV dword ptr [RAX + 0x40],0x0
MOV RAX,qword ptr [RSP + 0x48]
MOV dword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RSP + 0x58]
MOV RCX,qword ptr [RSP + 0x60]
CMP RAX,qword ptr [RCX + 0x38]
SETZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0012901e
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RSP + 0x40],RAX
JMP 0x0012903c
LAB_0012901e:
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x48]
MOV EDX,0x32
MOV ECX,0xa
CALL 0x0015ca80
MOV qword ptr [RSP + 0x40],RAX
LAB_0012903c:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP],RAX
XOR EDI,EDI
CALL 0x00132a00
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x30],RCX
MOV qword ptr [RSP + 0x38],RDX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0012917b
caseD_c:
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x20]
MOV dword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x3
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0012917b
caseD_8:
MOV RAX,qword ptr [RSP + 0x48]
MOV CL,byte ptr [RAX + 0x5]
AND CL,0xfb
OR CL,0x4
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RSP + 0x48]
MOV CL,byte ptr [RAX + 0x5]
AND CL,0xf7
OR CL,0x8
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x38],0x0
MOV RAX,qword ptr [RSP + 0x48]
MOV dword ptr [RAX + 0x40],0x0
JMP 0x0012917b
caseD_21:
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x38],0x0
MOV RAX,qword ptr [RSP + 0x48]
MOV dword ptr [RAX + 0x40],0x0
JMP 0x0012917b
caseD_4:
MOV RAX,qword ptr [RSP + 0x48]
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x3
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x30],RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x38],RCX
JMP 0x00129146
caseD_12:
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x38],0x0
JMP 0x00129146
caseD_3:
JMP 0x00129146
LAB_00129146:
MOV RAX,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x80]
MOV ECX,dword ptr [RSP + 0x54]
IMUL RCX,RCX,0x28
ADD RAX,RCX
CMP qword ptr [RAX + 0x20],0x0
JZ 0x00129179
MOV RAX,qword ptr [RSP + 0x48]
MOV CL,byte ptr [RAX + 0x5]
AND CL,0xfb
OR CL,0x4
MOV byte ptr [RAX + 0x5],CL
LAB_00129179:
JMP 0x0012917b
LAB_0012917b:
MOV RAX,qword ptr [RSP + 0x48]
MOV dword ptr [RAX],0x1
MOV RAX,qword ptr [RSP + 0x60]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RSP + 0x48]
XOR EDX,EDX
CALL 0x00122e10
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],-0x1
LAB_001291ae:
MOV RAX,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
ADD RSP,0x78
RET
|
int1 [16] JS_NewObjectFromShape(long param_1,long param_2,uint param_3)
{
long *plVar1;
int4 *puVar2;
int8 uVar3;
int1 auVar4 [16];
uint uStack_64;
uint uStack_54;
int1 (*local_38) [16];
int4 local_10;
int4 uStack_c;
int8 local_8;
js_trigger_gc(*(int8 *)(param_1 + 0x18),0x48);
puVar2 = (int4 *)js_malloc(param_1,0x48);
if (puVar2 == (int4 *)0x0) {
LAB_00128f4c:
js_free_shape(*(int8 *)(param_1 + 0x18),param_2);
local_10 = 0;
local_8 = 6;
goto LAB_001291ae;
}
*(short *)((long)puVar2 + 6) = (short)param_3;
*(byte *)((long)puVar2 + 5) = *(byte *)((long)puVar2 + 5) & 0xfe | 1;
*(byte *)((long)puVar2 + 5) = *(byte *)((long)puVar2 + 5) & 0xfd;
*(byte *)((long)puVar2 + 5) = *(byte *)((long)puVar2 + 5) & 0xfb;
*(byte *)((long)puVar2 + 5) = *(byte *)((long)puVar2 + 5) & 0xf7;
*(byte *)((long)puVar2 + 5) = *(byte *)((long)puVar2 + 5) & 0xef;
*(byte *)((long)puVar2 + 5) = *(byte *)((long)puVar2 + 5) & 0xdf;
*(byte *)((long)puVar2 + 5) = *(byte *)((long)puVar2 + 5) & 0xbf;
*(byte *)((long)puVar2 + 5) = *(byte *)((long)puVar2 + 5) & 0x7f;
*(int8 *)(puVar2 + 10) = 0;
*(int8 *)(puVar2 + 0xc) = 0;
*(long *)(puVar2 + 6) = param_2;
uVar3 = js_malloc(param_1,(long)*(int *)(param_2 + 0x24) << 4);
*(int8 *)(puVar2 + 8) = uVar3;
if (*(long *)(puVar2 + 8) == 0) {
js_free(param_1,puVar2);
goto LAB_00128f4c;
}
switch(param_3) {
case 1:
break;
case 2:
*(byte *)((long)puVar2 + 5) = *(byte *)((long)puVar2 + 5) & 0xfb | 4;
*(byte *)((long)puVar2 + 5) = *(byte *)((long)puVar2 + 5) & 0xf7 | 8;
*(int8 *)(puVar2 + 0xe) = 0;
puVar2[0x10] = 0;
puVar2[0xc] = 0;
if (param_2 == *(long *)(param_1 + 0x38)) {
local_38 = *(int1 (**) [16])(puVar2 + 8);
}
else {
local_38 = (int1 (*) [16])add_property(param_1,puVar2,0x32,10);
}
auVar4 = js_int32(0);
*local_38 = auVar4;
break;
default:
goto LAB_00129146;
case 4:
case 5:
case 6:
case 7:
case 10:
case 0x22:
*(ulong *)(puVar2 + 0xc) = (ulong)uStack_64 << 0x20;
*(int8 *)(puVar2 + 0xe) = 3;
goto LAB_00129146;
case 8:
case 0x15:
case 0x16:
case 0x17:
case 0x18:
case 0x19:
case 0x1a:
case 0x1b:
case 0x1c:
case 0x1d:
case 0x1e:
case 0x1f:
case 0x20:
*(byte *)((long)puVar2 + 5) = *(byte *)((long)puVar2 + 5) & 0xfb | 4;
*(byte *)((long)puVar2 + 5) = *(byte *)((long)puVar2 + 5) & 0xf7 | 8;
*(int8 *)(puVar2 + 0xe) = 0;
puVar2[0x10] = 0;
break;
case 0xc:
plVar1 = *(long **)(puVar2 + 8);
*plVar1 = (ulong)uStack_54 << 0x20;
plVar1[1] = 3;
break;
case 0x12:
*(int8 *)(puVar2 + 0xc) = 0;
*(int8 *)(puVar2 + 0xe) = 0;
LAB_00129146:
if (*(long *)(*(long *)(*(long *)(param_1 + 0x18) + 0x80) + (ulong)param_3 * 0x28 + 0x20) != 0)
{
*(byte *)((long)puVar2 + 5) = *(byte *)((long)puVar2 + 5) & 0xfb | 4;
}
break;
case 0x21:
*(int8 *)(puVar2 + 0xe) = 0;
puVar2[0x10] = 0;
}
*puVar2 = 1;
add_gc_object(*(int8 *)(param_1 + 0x18),puVar2,0);
local_10 = SUB84(puVar2,0);
uStack_c = (int4)((ulong)puVar2 >> 0x20);
local_8 = 0xffffffffffffffff;
LAB_001291ae:
auVar4._4_4_ = uStack_c;
auVar4._0_4_ = local_10;
auVar4._8_8_ = local_8;
return auVar4;
}
| |
26,321 | minja::IfExpr::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 (!condition) throw std::runtime_error("IfExpr.condition is null");
if (!then_expr) throw std::runtime_error("IfExpr.then_expr is null");
if (condition->evaluate(context).to_bool()) {
return then_expr->evaluate(context);
}
if (else_expr) {
return else_expr->evaluate(context);
}
return nullptr;
} | O2 | cpp | minja::IfExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x726f6
cmpq $0x0, 0x30(%r15)
je 0x72712
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x63f0a
movq %r12, %rdi
callq 0x640e0
movl %eax, %ebp
movq %rsp, %rdi
callq 0x6419a
testb %bpl, %bpl
je 0x726c1
movq 0x30(%r15), %rsi
jmp 0x726ca
movq 0x40(%r15), %rsi
testq %rsi, %rsi
je 0x726e5
movq %rbx, %rdi
movq %r14, %rdx
callq 0x63f0a
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %rsi
andq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x687f2
jmp 0x726d5
pushq $0x10
popq %rdi
callq 0x23470
movq %rax, %r14
leaq 0x43347(%rip), %rsi # 0xb5a4f
movq %rax, %rdi
callq 0x23330
jmp 0x7272c
pushq $0x10
popq %rdi
callq 0x23470
movq %rax, %r14
leaq 0x43344(%rip), %rsi # 0xb5a68
movq %rax, %rdi
callq 0x23330
movq 0x8c8b5(%rip), %rsi # 0xfefe8
movq 0x8c80e(%rip), %rdx # 0xfef48
movq %r14, %rdi
callq 0x23f00
jmp 0x72744
movq %rax, %rbx
movq %r14, %rdi
callq 0x236a0
jmp 0x7275c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6419a
movq %rbx, %rdi
callq 0x23f80
| _ZNK5minja6IfExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 50h
mov r15, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz short loc_726F6
cmp qword ptr [r15+30h], 0
jz short loc_72712
mov r14, rdx
mov rbx, rdi
mov r12, rsp
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov rdi, r12; this
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
mov ebp, eax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
test bpl, bpl
jz short loc_726C1
mov rsi, [r15+30h]
jmp short loc_726CA
loc_726C1:
mov rsi, [r15+40h]
test rsi, rsi
jz short loc_726E5
loc_726CA:
mov rdi, rbx
mov rdx, r14
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
loc_726D5:
mov rax, rbx
add rsp, 50h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_726E5:
mov rsi, rsp
and qword ptr [rsi], 0
mov rdi, rbx
call _ZN5minja5ValueC2ERKDn; minja::Value::Value(decltype(nullptr) const&)
jmp short loc_726D5
loc_726F6:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aIfexprConditio; "IfExpr.condition is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_7272C
loc_72712:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aIfexprThenExpr; "IfExpr.then_expr is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_7272C:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short $+2
loc_72744:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_7275C
mov rbx, rax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_7275C:
mov rdi, rbx
call __Unwind_Resume
| _OWORD * minja::IfExpr::do_evaluate(_OWORD *a1, _QWORD *a2)
{
void (***v3)(void); // rsi
char v4; // bp
void (***v5)(void); // rsi
std::runtime_error *exception; // r14
_QWORD v8[15]; // [rsp+0h] [rbp-78h] BYREF
v3 = (void (***)(void))a2[4];
if ( !v3 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "IfExpr.condition is null");
goto LABEL_11;
}
if ( !a2[6] )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "IfExpr.then_expr is null");
LABEL_11:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v8, v3);
v4 = minja::Value::to_bool((minja::Value *)v8);
minja::Value::~Value((minja::Value *)v8);
if ( v4 )
{
v5 = (void (***)(void))a2[6];
}
else
{
v5 = (void (***)(void))a2[8];
if ( !v5 )
{
v8[0] = 0LL;
minja::Value::Value(a1);
return a1;
}
}
minja::Expression::evaluate((long long)a1, v5);
return a1;
}
| do_evaluate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV R15,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x001726f6
CMP qword ptr [R15 + 0x30],0x0
JZ 0x00172712
MOV R14,RDX
MOV RBX,RDI
MOV R12,RSP
MOV RDI,R12
CALL 0x00163f0a
LAB_001726a4:
MOV RDI,R12
CALL 0x001640e0
LAB_001726ac:
MOV EBP,EAX
MOV RDI,RSP
CALL 0x0016419a
TEST BPL,BPL
JZ 0x001726c1
MOV RSI,qword ptr [R15 + 0x30]
JMP 0x001726ca
LAB_001726c1:
MOV RSI,qword ptr [R15 + 0x40]
TEST RSI,RSI
JZ 0x001726e5
LAB_001726ca:
MOV RDI,RBX
MOV RDX,R14
CALL 0x00163f0a
LAB_001726d5:
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001726e5:
MOV RSI,RSP
AND qword ptr [RSI],0x0
MOV RDI,RBX
CALL 0x001687f2
JMP 0x001726d5
LAB_001726f6:
PUSH 0x10
POP RDI
CALL 0x00123470
MOV R14,RAX
LAB_00172701:
LEA RSI,[0x1b5a4f]
MOV RDI,RAX
CALL 0x00123330
LAB_00172710:
JMP 0x0017272c
LAB_00172712:
PUSH 0x10
POP RDI
CALL 0x00123470
MOV R14,RAX
LAB_0017271d:
LEA RSI,[0x1b5a68]
MOV RDI,RAX
CALL 0x00123330
LAB_0017272c:
MOV RSI,qword ptr [0x001fefe8]
MOV RDX,qword ptr [0x001fef48]
MOV RDI,R14
CALL 0x00123f00
|
/* minja::IfExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
IfExpr * __thiscall minja::IfExpr::do_evaluate(IfExpr *this,shared_ptr *param_1)
{
char cVar1;
runtime_error *this_00;
shared_ptr *psVar2;
_func_decltype_nullptr *local_78 [10];
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00172701 to 0017270f has its CatchHandler @ 00172744 */
std::runtime_error::runtime_error(this_00,"IfExpr.condition is null");
}
else {
if (*(long *)(param_1 + 0x30) != 0) {
Expression::evaluate((Expression *)local_78,*(shared_ptr **)(param_1 + 0x20));
/* try { // try from 001726a4 to 001726ab has its CatchHandler @ 00172751 */
cVar1 = Value::to_bool((Value *)local_78);
Value::~Value((Value *)local_78);
if (cVar1 == '\0') {
psVar2 = *(shared_ptr **)(param_1 + 0x40);
if (psVar2 == (shared_ptr *)0x0) {
local_78[0] = (_func_decltype_nullptr *)0x0;
Value::Value((Value *)this,local_78);
return this;
}
}
else {
psVar2 = *(shared_ptr **)(param_1 + 0x30);
}
Expression::evaluate((Expression *)this,psVar2);
return this;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017271d to 0017272b has its CatchHandler @ 00172742 */
std::runtime_error::runtime_error(this_00,"IfExpr.then_expr is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001fefe8,PTR__runtime_error_001fef48);
}
| |
26,322 | ggml_opt_epoch_callback_progress_bar | monkey531[P]llama/ggml/src/ggml-opt.cpp | void ggml_opt_epoch_callback_progress_bar(
bool train,
ggml_opt_context_t opt_ctx,
ggml_opt_dataset_t dataset,
ggml_opt_result_t result,
int64_t ibatch,
int64_t ibatch_max,
int64_t t_start_us) {
fprintf(stderr, "%s[", train ? "train: " : "val: ");
constexpr int64_t bar_length = 25;
for (int64_t j = 0; j < bar_length; ++j) {
const int64_t ibatch_j = ibatch_max * j/bar_length;
if (ibatch_j < ibatch) {
fprintf(stderr, "=");
} else if (ibatch_max * (j - 1)/bar_length < ibatch) {
fprintf(stderr, ">");
} else {
fprintf(stderr, " ");
}
}
const int64_t batch_size = ggml_opt_inputs(opt_ctx)->ne[1];
const int64_t idata = ibatch*batch_size;
const int64_t idata_max = ibatch_max*batch_size;
double loss;
double loss_unc;
ggml_opt_result_loss(result, &loss, &loss_unc);
double accuracy;
double accuracy_unc;
ggml_opt_result_accuracy(result, &accuracy, &accuracy_unc);
const int64_t t_ibatch_us = ggml_time_us() - t_start_us;
int64_t t_ibatch_s = t_ibatch_us / 1000000;
const int64_t t_ibatch_h = t_ibatch_s / 3600;
t_ibatch_s -= t_ibatch_h * 3600;
const int64_t t_ibatch_m = t_ibatch_s / 60;
t_ibatch_s -= t_ibatch_m * 60;
const int64_t t_eta_us = t_ibatch_us * (ibatch_max - ibatch)/ibatch;
int64_t t_eta_s = t_eta_us / 1000000;
const int64_t t_eta_h = t_eta_s / 3600;
t_eta_s -= t_eta_h * 3600;
const int64_t t_eta_m = t_eta_s / 60;
t_eta_s -= t_eta_m * 60;
fprintf(stderr, "| data=%06" PRId64 "/%06" PRId64 ", loss=%.6lf+-%.6lf, accuracy=%.2lf+-%.2lf%%, "
"t=%02" PRId64 ":%02" PRId64 ":%02" PRId64 ", ETA=%02" PRId64 ":%02" PRId64 ":%02" PRId64 "]\r",
idata, idata_max, loss, loss_unc, 100.0*accuracy, 100.0*accuracy_unc,
t_ibatch_h, t_ibatch_m, t_ibatch_s, t_eta_h, t_eta_m, t_eta_s);
if (ibatch == ibatch_max) {
fprintf(stderr, "\n");
}
fflush(stderr);
GGML_UNUSED(dataset);
} | O1 | cpp | ggml_opt_epoch_callback_progress_bar:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r13
movq %r8, %r14
movq %rcx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x51cbe(%rip), %rax # 0x69fc8
movq (%rax), %rax
leaq 0x35d25(%rip), %rcx # 0x4e039
leaq 0x35d26(%rip), %rdx # 0x4e041
testl %edi, %edi
cmovneq %rcx, %rdx
leaq 0x35d0d(%rip), %rsi # 0x4e035
xorl %r12d, %r12d
movq %rax, %rdi
xorl %eax, %eax
callq 0x17830
movq %r13, %rbx
negq %rbx
pushq $0x19
popq %rbp
movq %rbp, %r15
movq %r12, %rax
cqto
idivq %rbp
cmpq %r14, %rax
jge 0x1835c
movq 0x51c73(%rip), %rax # 0x69fc8
movq (%rax), %rsi
pushq $0x3d
jmp 0x1837a
leaq (%rbx,%r12), %rax
cqto
idivq %rbp
movq 0x51c5c(%rip), %rcx # 0x69fc8
movq (%rcx), %rsi
cmpq %r14, %rax
jge 0x18378
pushq $0x3e
jmp 0x1837a
pushq $0x20
popq %rdi
callq 0x174e0
addq %r13, %r12
decq %r15
jne 0x18341
movq 0x10(%rsp), %rax
movq 0x13d0(%rax), %rax
movq 0x18(%rax), %rbx
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x17b20
movq 0x38(%r15), %rax
movsd 0x358d5(%rip), %xmm0 # 0x4dc90
movapd %xmm0, %xmm2
testq %rax, %rax
js 0x183d2
cvtsi2sd %rax, %xmm2
cvtsi2sdq (%r15), %xmm1
divsd %xmm1, %xmm2
movq %rbx, %r12
imulq %r14, %r12
imulq %r13, %rbx
testq %rax, %rax
movsd %xmm2, 0x10(%rsp)
js 0x1842a
movq (%r15), %rax
cmpq $0x2, %rax
jl 0x1842a
movsd 0x3589f(%rip), %xmm0 # 0x4dc98
subsd %xmm2, %xmm0
mulsd %xmm2, %xmm0
decq %rax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1841d
sqrtsd %xmm0, %xmm0
jmp 0x18422
callq 0x16d20
mulsd 0x35876(%rip), %xmm0 # 0x4dca0
movsd %xmm0, 0x8(%rsp)
callq 0x17de0
movq %rax, %rcx
subq 0x60(%rsp), %rcx
movl $0xf4240, %r10d # imm = 0xF4240
movq %rcx, %rax
cqto
idivq %r10
movq %rax, %rsi
movl $0xd693a400, %r11d # imm = 0xD693A400
movq %rcx, %rax
cqto
idivq %r11
movq %rax, %r8
imulq $-0xe10, %rax, %rdi # imm = 0xF1F0
addq %rsi, %rdi
pushq $0x3c
popq %rbp
movq %rdi, %rax
cqto
idivq %rbp
movq %rax, %r9
imulq $-0x3c, %rax, %r15
addq %rdi, %r15
movq %r13, %rax
subq %r14, %rax
imulq %rcx, %rax
cqto
idivq %r14
movq %rax, %rcx
cqto
idivq %r10
movq %rax, %rsi
movq %rcx, %rax
cqto
idivq %r11
movq %rax, %r10
imulq $-0xe10, %rax, %rcx # imm = 0xF1F0
addq %rsi, %rcx
movq %rcx, %rax
cqto
idivq %rbp
movq %rax, %r11
imulq $-0x3c, %rax, %rbp
addq %rcx, %rbp
movq 0x51b02(%rip), %rax # 0x69fc8
movq (%rax), %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
mulsd 0x357bd(%rip), %xmm2 # 0x4dca0
leaq 0x35b5f(%rip), %rsi # 0x4e049
movq %r12, %rdx
movq %rbx, %rcx
movq %rax, %rbx
movsd 0x8(%rsp), %xmm3
movb $0x4, %al
pushq %rbp
pushq %r11
pushq %r10
pushq %r15
callq 0x17830
addq $0x20, %rsp
cmpq %r14, %r13
jne 0x1851b
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x174e0
movq (%rbx), %rdi
callq 0x17360
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ggml_opt_epoch_callback_progress_bar:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r13, r9
mov r14, r8
mov [rsp+58h+var_50], rcx
mov [rsp+58h+var_48], rsi
mov rax, cs:stderr_ptr
mov rax, [rax]
lea rcx, aTrain; "train: "
lea rdx, aVal; "val: "
test edi, edi
cmovnz rdx, rcx
lea rsi, aS; "%s["
xor r12d, r12d
mov rdi, rax
xor eax, eax
call _fprintf
mov rbx, r13
neg rbx
push 19h
pop rbp
mov r15, rbp
loc_18341:
mov rax, r12
cqo
idiv rbp
cmp rax, r14
jge short loc_1835C
mov rax, cs:stderr_ptr
mov rsi, [rax]
push 3Dh ; '='
jmp short loc_1837A
loc_1835C:
lea rax, [rbx+r12]
cqo
idiv rbp
mov rcx, cs:stderr_ptr
mov rsi, [rcx]
cmp rax, r14
jge short loc_18378
push 3Eh ; '>'
jmp short loc_1837A
loc_18378:
push 20h ; ' '
loc_1837A:
pop rdi
call _fputc
add r12, r13
dec r15
jnz short loc_18341
mov rax, [rsp+58h+var_48]
mov rax, [rax+13D0h]
mov rbx, [rax+18h]
lea rsi, [rsp+58h+var_38]
lea rdx, [rsp+58h+var_40]
mov r15, [rsp+58h+var_50]
mov rdi, r15
call _ggml_opt_result_loss
mov rax, [r15+38h]
movsd xmm0, cs:qword_4DC90
movapd xmm2, xmm0
test rax, rax
js short loc_183D2
cvtsi2sd xmm2, rax
cvtsi2sd xmm1, qword ptr [r15]
divsd xmm2, xmm1
loc_183D2:
mov r12, rbx
imul r12, r14
imul rbx, r13
test rax, rax
movsd [rsp+58h+var_48], xmm2
js short loc_1842A
mov rax, [r15]
cmp rax, 2
jl short loc_1842A
movsd xmm0, cs:qword_4DC98
subsd xmm0, xmm2
mulsd xmm0, xmm2
dec rax
cvtsi2sd xmm1, rax
divsd xmm0, xmm1
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jb short loc_1841D
sqrtsd xmm0, xmm0
jmp short loc_18422
loc_1841D:
call _sqrt
loc_18422:
mulsd xmm0, cs:qword_4DCA0
loc_1842A:
movsd [rsp+58h+var_50], xmm0
call _ggml_time_us
mov rcx, rax
sub rcx, [rsp+58h+arg_0]
mov r10d, 0F4240h
mov rax, rcx
cqo
idiv r10
mov rsi, rax
mov r11d, 0D693A400h
mov rax, rcx
cqo
idiv r11
mov r8, rax
imul rdi, rax, 0FFFFFFFFFFFFF1F0h
add rdi, rsi
push 3Ch ; '<'
pop rbp
mov rax, rdi
cqo
idiv rbp
mov r9, rax
imul r15, rax, -3Ch
add r15, rdi
mov rax, r13
sub rax, r14
imul rax, rcx
cqo
idiv r14
mov rcx, rax
cqo
idiv r10
mov rsi, rax
mov rax, rcx
cqo
idiv r11
mov r10, rax
imul rcx, rax, 0FFFFFFFFFFFFF1F0h
add rcx, rsi
mov rax, rcx
cqo
idiv rbp
mov r11, rax
imul rbp, rax, -3Ch
add rbp, rcx
mov rax, cs:stderr_ptr
mov rdi, [rax]
movsd xmm0, [rsp+58h+var_38]
movsd xmm1, [rsp+58h+var_40]
movsd xmm2, [rsp+58h+var_48]
mulsd xmm2, cs:qword_4DCA0
lea rsi, aData06ld06ldLo; "| data=%06ld/%06ld, loss=%.6lf+-%.6lf, "...
mov rdx, r12
mov rcx, rbx
mov rbx, rax
movsd xmm3, [rsp+58h+var_50]
mov al, 4
push rbp
push r11
push r10
push r15
call _fprintf
add rsp, 20h
cmp r13, r14
jnz short loc_1851B
mov rsi, [rbx]
push 0Ah
pop rdi
call _fputc
loc_1851B:
mov rdi, [rbx]
call _fflush
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ggml_opt_epoch_callback_progress_bar(
int a1,
long long a2,
long long a3,
long long *a4,
long long a5,
long long a6,
long long a7)
{
const char *v9; // rdx
long long v10; // r12
long long v11; // r15
long long v12; // rdx
long long v13; // rbx
long long v14; // rax
double v15; // xmm0_8
double v16; // xmm2_8
long long v17; // r12
long long v18; // rbx
double v19; // xmm0_8
double v20; // xmm0_8
long long v21; // rcx
long long v22; // r8
long long v23; // r9
long long v24; // r15
long long v25; // rcx
long long v26; // rdx
double v29; // [rsp+18h] [rbp-40h] BYREF
double v30[7]; // [rsp+20h] [rbp-38h] BYREF
v9 = "val: ";
if ( a1 )
v9 = "train: ";
v10 = 0LL;
fprintf(stderr, "%s[", v9);
v11 = 25LL;
do
{
if ( v10 / 25 >= a5 )
{
v12 = (v10 - a6) % 25;
if ( (v10 - a6) / 25 >= a5 )
fputc(32LL, stderr, v12);
else
fputc(62LL, stderr, v12);
}
else
{
fputc(61LL, stderr, v10 % 25);
}
v10 += a6;
--v11;
}
while ( v11 );
v13 = *(_QWORD *)(*(_QWORD *)(a2 + 5072) + 24LL);
ggml_opt_result_loss(a4, v30, &v29);
v14 = a4[7];
v15 = NAN;
v16 = NAN;
if ( v14 >= 0 )
v16 = (double)(int)v14 / (double)(int)*a4;
v17 = a5 * v13;
v18 = a6 * v13;
if ( v14 >= 0 && *a4 >= 2 )
{
v19 = (1.0 - v16) * v16 / (double)(int)(*a4 - 1);
if ( v19 < 0.0 )
v20 = sqrt(v19);
else
v20 = sqrt(v19);
v15 = v20 * 100.0;
}
v21 = ggml_time_us() - a7;
v22 = v21 / 3600000000LL;
v23 = (v21 / 1000000 - 3600 * (v21 / 3600000000LL)) / 60;
v24 = (v21 / 1000000 - 3600 * (v21 / 3600000000LL)) % 60;
v25 = v21 * (a6 - a5) / a5;
fprintf(
stderr,
"| data=%06ld/%06ld, loss=%.6lf+-%.6lf, accuracy=%.2lf+-%.2lf%%, t=%02ld:%02ld:%02ld, ETA=%02ld:%02ld:%02ld]\r",
v17,
v18,
v30[0],
v29,
v16 * 100.0,
v15,
v22,
v23,
v24,
v25 / 3600000000LL,
(v25 / 1000000 - 3600 * (v25 / 3600000000LL)) / 60,
(v25 / 1000000 - 3600 * (v25 / 3600000000LL)) % 60);
if ( a6 == a5 )
fputc(10LL, stderr, v26);
return fflush(stderr);
}
| ggml_opt_epoch_callback_progress_bar:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R13,R9
MOV R14,R8
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr [0x00169fc8]
MOV RAX,qword ptr [RAX]
LEA RCX,[0x14e039]
LEA RDX,[0x14e041]
TEST EDI,EDI
CMOVNZ RDX,RCX
LEA RSI,[0x14e035]
XOR R12D,R12D
MOV RDI,RAX
XOR EAX,EAX
CALL 0x00117830
MOV RBX,R13
NEG RBX
PUSH 0x19
POP RBP
MOV R15,RBP
LAB_00118341:
MOV RAX,R12
CQO
IDIV RBP
CMP RAX,R14
JGE 0x0011835c
MOV RAX,qword ptr [0x00169fc8]
MOV RSI,qword ptr [RAX]
PUSH 0x3d
JMP 0x0011837a
LAB_0011835c:
LEA RAX,[RBX + R12*0x1]
CQO
IDIV RBP
MOV RCX,qword ptr [0x00169fc8]
MOV RSI,qword ptr [RCX]
CMP RAX,R14
JGE 0x00118378
PUSH 0x3e
JMP 0x0011837a
LAB_00118378:
PUSH 0x20
LAB_0011837a:
POP RDI
CALL 0x001174e0
ADD R12,R13
DEC R15
JNZ 0x00118341
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x13d0]
MOV RBX,qword ptr [RAX + 0x18]
LEA RSI,[RSP + 0x20]
LEA RDX,[RSP + 0x18]
MOV R15,qword ptr [RSP + 0x8]
MOV RDI,R15
CALL 0x00117b20
MOV RAX,qword ptr [R15 + 0x38]
MOVSD XMM0,qword ptr [0x0014dc90]
MOVAPD XMM2,XMM0
TEST RAX,RAX
JS 0x001183d2
CVTSI2SD XMM2,RAX
CVTSI2SD XMM1,qword ptr [R15]
DIVSD XMM2,XMM1
LAB_001183d2:
MOV R12,RBX
IMUL R12,R14
IMUL RBX,R13
TEST RAX,RAX
MOVSD qword ptr [RSP + 0x10],XMM2
JS 0x0011842a
MOV RAX,qword ptr [R15]
CMP RAX,0x2
JL 0x0011842a
MOVSD XMM0,qword ptr [0x0014dc98]
SUBSD XMM0,XMM2
MULSD XMM0,XMM2
DEC RAX
CVTSI2SD XMM1,RAX
DIVSD XMM0,XMM1
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JC 0x0011841d
SQRTSD XMM0,XMM0
JMP 0x00118422
LAB_0011841d:
CALL 0x00116d20
LAB_00118422:
MULSD XMM0,qword ptr [0x0014dca0]
LAB_0011842a:
MOVSD qword ptr [RSP + 0x8],XMM0
CALL 0x00117de0
MOV RCX,RAX
SUB RCX,qword ptr [RSP + 0x60]
MOV R10D,0xf4240
MOV RAX,RCX
CQO
IDIV R10
MOV RSI,RAX
MOV R11D,0xd693a400
MOV RAX,RCX
CQO
IDIV R11
MOV R8,RAX
IMUL RDI,RAX,-0xe10
ADD RDI,RSI
PUSH 0x3c
POP RBP
MOV RAX,RDI
CQO
IDIV RBP
MOV R9,RAX
IMUL R15,RAX,-0x3c
ADD R15,RDI
MOV RAX,R13
SUB RAX,R14
IMUL RAX,RCX
CQO
IDIV R14
MOV RCX,RAX
CQO
IDIV R10
MOV RSI,RAX
MOV RAX,RCX
CQO
IDIV R11
MOV R10,RAX
IMUL RCX,RAX,-0xe10
ADD RCX,RSI
MOV RAX,RCX
CQO
IDIV RBP
MOV R11,RAX
IMUL RBP,RAX,-0x3c
ADD RBP,RCX
MOV RAX,qword ptr [0x00169fc8]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x20]
MOVSD XMM1,qword ptr [RSP + 0x18]
MOVSD XMM2,qword ptr [RSP + 0x10]
MULSD XMM2,qword ptr [0x0014dca0]
LEA RSI,[0x14e049]
MOV RDX,R12
MOV RCX,RBX
MOV RBX,RAX
MOVSD XMM3,qword ptr [RSP + 0x8]
MOV AL,0x4
PUSH RBP
PUSH R11
PUSH R10
PUSH R15
CALL 0x00117830
ADD RSP,0x20
CMP R13,R14
JNZ 0x0011851b
MOV RSI,qword ptr [RBX]
PUSH 0xa
POP RDI
CALL 0x001174e0
LAB_0011851b:
MOV RDI,qword ptr [RBX]
CALL 0x00117360
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_opt_epoch_callback_progress_bar
(int param_1,long param_2,int8 param_3,long *param_4,long param_5,long param_6,
long param_7)
{
int *puVar1;
long lVar2;
long lVar3;
char *pcVar4;
FILE *__stream;
long lVar5;
long lVar6;
long lVar7;
double dVar8;
double dVar9;
int __c;
int8 local_40;
int8 local_38;
pcVar4 = "val: ";
if (param_1 != 0) {
pcVar4 = "train: ";
}
lVar6 = 0;
fprintf(*(FILE **)PTR_stderr_00169fc8,"%s[",pcVar4);
lVar7 = 0x19;
do {
if (lVar6 / 0x19 < param_5) {
__stream = *(FILE **)PTR_stderr_00169fc8;
__c = 0x3d;
}
else {
__stream = *(FILE **)PTR_stderr_00169fc8;
if ((lVar6 - param_6) / 0x19 < param_5) {
__c = 0x3e;
}
else {
__c = 0x20;
}
}
fputc(__c,__stream);
lVar6 = lVar6 + param_6;
lVar7 = lVar7 + -1;
} while (lVar7 != 0);
lVar7 = *(long *)(*(long *)(param_2 + 0x13d0) + 0x18);
ggml_opt_result_loss(param_4,&local_38,&local_40);
lVar6 = param_4[7];
dVar9 = DAT_0014dc90;
if (-1 < lVar6) {
dVar9 = (double)lVar6 / (double)*param_4;
}
dVar8 = DAT_0014dc90;
if ((-1 < lVar6) && (1 < *param_4)) {
dVar8 = ((DAT_0014dc98 - dVar9) * dVar9) / (double)(*param_4 + -1);
if (dVar8 < 0.0) {
dVar8 = sqrt(dVar8);
}
else {
dVar8 = SQRT(dVar8);
}
dVar8 = dVar8 * _DAT_0014dca0;
}
lVar6 = ggml_time_us();
puVar1 = PTR_stderr_00169fc8;
lVar6 = lVar6 - param_7;
lVar5 = (lVar6 / 3600000000) * -0xe10 + lVar6 / 1000000;
lVar2 = ((param_6 - param_5) * lVar6) / param_5;
lVar3 = lVar2 / 3600000000;
lVar2 = lVar3 * -0xe10 + lVar2 / 1000000;
fprintf(*(FILE **)PTR_stderr_00169fc8,
"| data=%06ld/%06ld, loss=%.6lf+-%.6lf, accuracy=%.2lf+-%.2lf%%, t=%02ld:%02ld:%02ld, ETA=%02ld:%02ld:%02ld]\r"
,local_38,local_40,dVar9 * _DAT_0014dca0,dVar8,lVar7 * param_5,lVar7 * param_6,
lVar6 / 3600000000,lVar5 / 0x3c,lVar5 % 0x3c,lVar3,lVar2 / 0x3c,lVar2 % 0x3c);
if (param_6 == param_5) {
fputc(10,*(FILE **)puVar1);
}
fflush(*(FILE **)puVar1);
return;
}
| |
26,323 | ggml_opt_epoch_callback_progress_bar | monkey531[P]llama/ggml/src/ggml-opt.cpp | void ggml_opt_epoch_callback_progress_bar(
bool train,
ggml_opt_context_t opt_ctx,
ggml_opt_dataset_t dataset,
ggml_opt_result_t result,
int64_t ibatch,
int64_t ibatch_max,
int64_t t_start_us) {
fprintf(stderr, "%s[", train ? "train: " : "val: ");
constexpr int64_t bar_length = 25;
for (int64_t j = 0; j < bar_length; ++j) {
const int64_t ibatch_j = ibatch_max * j/bar_length;
if (ibatch_j < ibatch) {
fprintf(stderr, "=");
} else if (ibatch_max * (j - 1)/bar_length < ibatch) {
fprintf(stderr, ">");
} else {
fprintf(stderr, " ");
}
}
const int64_t batch_size = ggml_opt_inputs(opt_ctx)->ne[1];
const int64_t idata = ibatch*batch_size;
const int64_t idata_max = ibatch_max*batch_size;
double loss;
double loss_unc;
ggml_opt_result_loss(result, &loss, &loss_unc);
double accuracy;
double accuracy_unc;
ggml_opt_result_accuracy(result, &accuracy, &accuracy_unc);
const int64_t t_ibatch_us = ggml_time_us() - t_start_us;
int64_t t_ibatch_s = t_ibatch_us / 1000000;
const int64_t t_ibatch_h = t_ibatch_s / 3600;
t_ibatch_s -= t_ibatch_h * 3600;
const int64_t t_ibatch_m = t_ibatch_s / 60;
t_ibatch_s -= t_ibatch_m * 60;
const int64_t t_eta_us = t_ibatch_us * (ibatch_max - ibatch)/ibatch;
int64_t t_eta_s = t_eta_us / 1000000;
const int64_t t_eta_h = t_eta_s / 3600;
t_eta_s -= t_eta_h * 3600;
const int64_t t_eta_m = t_eta_s / 60;
t_eta_s -= t_eta_m * 60;
fprintf(stderr, "| data=%06" PRId64 "/%06" PRId64 ", loss=%.6lf+-%.6lf, accuracy=%.2lf+-%.2lf%%, "
"t=%02" PRId64 ":%02" PRId64 ":%02" PRId64 ", ETA=%02" PRId64 ":%02" PRId64 ":%02" PRId64 "]\r",
idata, idata_max, loss, loss_unc, 100.0*accuracy, 100.0*accuracy_unc,
t_ibatch_h, t_ibatch_m, t_ibatch_s, t_eta_h, t_eta_m, t_eta_s);
if (ibatch == ibatch_max) {
fprintf(stderr, "\n");
}
fflush(stderr);
GGML_UNUSED(dataset);
} | O3 | cpp | ggml_opt_epoch_callback_progress_bar:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r13
movq %r8, %r14
movq %rcx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x51cde(%rip), %rax # 0x69fc8
movq (%rax), %rax
leaq 0x35d45(%rip), %rcx # 0x4e039
leaq 0x35d46(%rip), %rdx # 0x4e041
testl %edi, %edi
cmovneq %rcx, %rdx
leaq 0x35d2d(%rip), %rsi # 0x4e035
xorl %r12d, %r12d
movq %rax, %rdi
xorl %eax, %eax
callq 0x17820
movq %r13, %rbx
negq %rbx
pushq $0x19
popq %rbp
movq %rbp, %r15
movq %r12, %rax
cqto
idivq %rbp
cmpq %r14, %rax
jge 0x1833c
movq 0x51c93(%rip), %rax # 0x69fc8
movq (%rax), %rsi
pushq $0x3d
jmp 0x1835a
leaq (%rbx,%r12), %rax
cqto
idivq %rbp
movq 0x51c7c(%rip), %rcx # 0x69fc8
movq (%rcx), %rsi
cmpq %r14, %rax
jge 0x18358
pushq $0x3e
jmp 0x1835a
pushq $0x20
popq %rdi
callq 0x174d0
addq %r13, %r12
decq %r15
jne 0x18321
movq 0x8(%rsp), %rax
movq 0x13d0(%rax), %rax
movq 0x18(%rax), %rbx
movq %rbx, %r12
imulq %r14, %r12
imulq %r13, %rbx
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x17b10
movq 0x38(%r15), %rax
movsd 0x358ea(%rip), %xmm1 # 0x4dc90
testq %rax, %rax
js 0x183f4
cvtsi2sd %rax, %xmm2
movq (%r15), %rax
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm2
cmpq $0x2, %rax
movsd %xmm2, 0x10(%rsp)
jl 0x183fa
movsd 0x358c8(%rip), %xmm0 # 0x4dc98
subsd %xmm2, %xmm0
mulsd %xmm2, %xmm0
decq %rax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x18402
sqrtsd %xmm0, %xmm0
jmp 0x18407
movsd %xmm1, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
jmp 0x18415
callq 0x16d20
mulsd 0x35891(%rip), %xmm0 # 0x4dca0
movsd %xmm0, 0x8(%rsp)
callq 0x17dd0
movq %rax, %rcx
subq 0x60(%rsp), %rcx
movl $0xf4240, %r10d # imm = 0xF4240
movq %rcx, %rax
cqto
idivq %r10
movq %rax, %rsi
movl $0xd693a400, %r11d # imm = 0xD693A400
movq %rcx, %rax
cqto
idivq %r11
movq %rax, %r8
imulq $-0xe10, %rax, %rdi # imm = 0xF1F0
addq %rsi, %rdi
pushq $0x3c
popq %rbp
movq %rdi, %rax
cqto
idivq %rbp
movq %rax, %r9
imulq $-0x3c, %rax, %r15
addq %rdi, %r15
movq %r13, %rax
subq %r14, %rax
imulq %rcx, %rax
cqto
idivq %r14
movq %rax, %rcx
cqto
idivq %r10
movq %rax, %rsi
movq %rcx, %rax
cqto
idivq %r11
movq %rax, %r10
imulq $-0xe10, %rax, %rcx # imm = 0xF1F0
addq %rsi, %rcx
movq %rcx, %rax
cqto
idivq %rbp
movq %rax, %r11
imulq $-0x3c, %rax, %rbp
addq %rcx, %rbp
movq 0x51b1d(%rip), %rax # 0x69fc8
movq (%rax), %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
mulsd 0x357d8(%rip), %xmm2 # 0x4dca0
leaq 0x35b7a(%rip), %rsi # 0x4e049
movq %r12, %rdx
movq %rbx, %rcx
movq %rax, %rbx
movsd 0x8(%rsp), %xmm3
movb $0x4, %al
pushq %rbp
pushq %r11
pushq %r10
pushq %r15
callq 0x17820
addq $0x20, %rsp
cmpq %r14, %r13
jne 0x18500
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x174d0
movq (%rbx), %rdi
callq 0x17350
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ggml_opt_epoch_callback_progress_bar:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r13, r9
mov r14, r8
mov [rsp+58h+var_48], rcx
mov [rsp+58h+var_50], rsi
mov rax, cs:stderr_ptr
mov rax, [rax]
lea rcx, aTrain; "train: "
lea rdx, aVal; "val: "
test edi, edi
cmovnz rdx, rcx
lea rsi, aS; "%s["
xor r12d, r12d
mov rdi, rax
xor eax, eax
call _fprintf
mov rbx, r13
neg rbx
push 19h
pop rbp
mov r15, rbp
loc_18321:
mov rax, r12
cqo
idiv rbp
cmp rax, r14
jge short loc_1833C
mov rax, cs:stderr_ptr
mov rsi, [rax]
push 3Dh ; '='
jmp short loc_1835A
loc_1833C:
lea rax, [rbx+r12]
cqo
idiv rbp
mov rcx, cs:stderr_ptr
mov rsi, [rcx]
cmp rax, r14
jge short loc_18358
push 3Eh ; '>'
jmp short loc_1835A
loc_18358:
push 20h ; ' '
loc_1835A:
pop rdi
call _fputc
add r12, r13
dec r15
jnz short loc_18321
mov rax, [rsp+58h+var_50]
mov rax, [rax+13D0h]
mov rbx, [rax+18h]
mov r12, rbx
imul r12, r14
imul rbx, r13
lea rsi, [rsp+58h+var_38]
lea rdx, [rsp+58h+var_40]
mov r15, [rsp+58h+var_48]
mov rdi, r15
call _ggml_opt_result_loss
mov rax, [r15+38h]
movsd xmm1, cs:qword_4DC90
test rax, rax
js short loc_183F4
cvtsi2sd xmm2, rax
mov rax, [r15]
cvtsi2sd xmm0, rax
divsd xmm2, xmm0
cmp rax, 2
movsd [rsp+58h+var_48], xmm2
jl short loc_183FA
movsd xmm0, cs:qword_4DC98
subsd xmm0, xmm2
mulsd xmm0, xmm2
dec rax
cvtsi2sd xmm1, rax
divsd xmm0, xmm1
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jb short loc_18402
sqrtsd xmm0, xmm0
jmp short loc_18407
loc_183F4:
movsd [rsp+58h+var_48], xmm1
loc_183FA:
movsd [rsp+58h+var_50], xmm1
jmp short loc_18415
loc_18402:
call _sqrt
loc_18407:
mulsd xmm0, cs:qword_4DCA0
movsd [rsp+58h+var_50], xmm0
loc_18415:
call _ggml_time_us
mov rcx, rax
sub rcx, [rsp+58h+arg_0]
mov r10d, 0F4240h
mov rax, rcx
cqo
idiv r10
mov rsi, rax
mov r11d, 0D693A400h
mov rax, rcx
cqo
idiv r11
mov r8, rax
imul rdi, rax, 0FFFFFFFFFFFFF1F0h
add rdi, rsi
push 3Ch ; '<'
pop rbp
mov rax, rdi
cqo
idiv rbp
mov r9, rax
imul r15, rax, -3Ch
add r15, rdi
mov rax, r13
sub rax, r14
imul rax, rcx
cqo
idiv r14
mov rcx, rax
cqo
idiv r10
mov rsi, rax
mov rax, rcx
cqo
idiv r11
mov r10, rax
imul rcx, rax, 0FFFFFFFFFFFFF1F0h
add rcx, rsi
mov rax, rcx
cqo
idiv rbp
mov r11, rax
imul rbp, rax, -3Ch
add rbp, rcx
mov rax, cs:stderr_ptr
mov rdi, [rax]
movsd xmm0, [rsp+58h+var_38]
movsd xmm1, [rsp+58h+var_40]
movsd xmm2, [rsp+58h+var_48]
mulsd xmm2, cs:qword_4DCA0
lea rsi, aData06ld06ldLo; "| data=%06ld/%06ld, loss=%.6lf+-%.6lf, "...
mov rdx, r12
mov rcx, rbx
mov rbx, rax
movsd xmm3, [rsp+58h+var_50]
mov al, 4
push rbp
push r11
push r10
push r15
call _fprintf
add rsp, 20h
cmp r13, r14
jnz short loc_18500
mov rsi, [rbx]
push 0Ah
pop rdi
call _fputc
loc_18500:
mov rdi, [rbx]
call _fflush
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ggml_opt_epoch_callback_progress_bar(
int a1,
long long a2,
long long a3,
long long *a4,
long long a5,
long long a6,
long long a7)
{
const char *v9; // rdx
long long v10; // r12
long long v11; // r15
long long v12; // rdx
long long v13; // rax
long long v14; // r12
long long v15; // rbx
long long *v16; // r15
long long v17; // rax
double v18; // xmm2_8
long long v19; // rax
double v20; // xmm2_8
double v21; // xmm0_8
double v22; // xmm0_8
long long v23; // rcx
long long v24; // r8
long long v25; // r9
long long v26; // r15
long long v27; // rcx
long long v28; // rdx
double v30; // [rsp+8h] [rbp-50h]
double v32; // [rsp+10h] [rbp-48h]
double v33; // [rsp+18h] [rbp-40h] BYREF
double v34[7]; // [rsp+20h] [rbp-38h] BYREF
v9 = "val: ";
if ( a1 )
v9 = "train: ";
v10 = 0LL;
fprintf(stderr, "%s[", v9);
v11 = 25LL;
do
{
if ( v10 / 25 >= a5 )
{
v12 = (v10 - a6) % 25;
if ( (v10 - a6) / 25 >= a5 )
fputc(32LL, stderr, v12);
else
fputc(62LL, stderr, v12);
}
else
{
fputc(61LL, stderr, v10 % 25);
}
v10 += a6;
--v11;
}
while ( v11 );
v13 = *(_QWORD *)(a2 + 5072);
v14 = a5 * *(_QWORD *)(v13 + 24);
v15 = a6 * *(_QWORD *)(v13 + 24);
v16 = a4;
ggml_opt_result_loss(a4, v34, &v33);
v17 = a4[7];
if ( v17 < 0 )
{
v32 = NAN;
}
else
{
v18 = (double)(int)v17;
v19 = *a4;
v20 = v18 / (double)(int)*a4;
v32 = v20;
if ( *v16 >= 2 )
{
v21 = (1.0 - v20) * v20 / (double)((int)v19 - 1);
if ( v21 < 0.0 )
v22 = sqrt(v21);
else
v22 = sqrt(v21);
v30 = v22 * 100.0;
goto LABEL_18;
}
}
v30 = NAN;
LABEL_18:
v23 = ggml_time_us() - a7;
v24 = v23 / 3600000000LL;
v25 = (v23 / 1000000 - 3600 * (v23 / 3600000000LL)) / 60;
v26 = (v23 / 1000000 - 3600 * (v23 / 3600000000LL)) % 60;
v27 = v23 * (a6 - a5) / a5;
fprintf(
stderr,
"| data=%06ld/%06ld, loss=%.6lf+-%.6lf, accuracy=%.2lf+-%.2lf%%, t=%02ld:%02ld:%02ld, ETA=%02ld:%02ld:%02ld]\r",
v14,
v15,
v34[0],
v33,
v32 * 100.0,
v30,
v24,
v25,
v26,
v27 / 3600000000LL,
(v27 / 1000000 - 3600 * (v27 / 3600000000LL)) / 60,
(v27 / 1000000 - 3600 * (v27 / 3600000000LL)) % 60);
if ( a6 == a5 )
fputc(10LL, stderr, v28);
return fflush(stderr);
}
| ggml_opt_epoch_callback_progress_bar:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R13,R9
MOV R14,R8
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x8],RSI
MOV RAX,qword ptr [0x00169fc8]
MOV RAX,qword ptr [RAX]
LEA RCX,[0x14e039]
LEA RDX,[0x14e041]
TEST EDI,EDI
CMOVNZ RDX,RCX
LEA RSI,[0x14e035]
XOR R12D,R12D
MOV RDI,RAX
XOR EAX,EAX
CALL 0x00117820
MOV RBX,R13
NEG RBX
PUSH 0x19
POP RBP
MOV R15,RBP
LAB_00118321:
MOV RAX,R12
CQO
IDIV RBP
CMP RAX,R14
JGE 0x0011833c
MOV RAX,qword ptr [0x00169fc8]
MOV RSI,qword ptr [RAX]
PUSH 0x3d
JMP 0x0011835a
LAB_0011833c:
LEA RAX,[RBX + R12*0x1]
CQO
IDIV RBP
MOV RCX,qword ptr [0x00169fc8]
MOV RSI,qword ptr [RCX]
CMP RAX,R14
JGE 0x00118358
PUSH 0x3e
JMP 0x0011835a
LAB_00118358:
PUSH 0x20
LAB_0011835a:
POP RDI
CALL 0x001174d0
ADD R12,R13
DEC R15
JNZ 0x00118321
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x13d0]
MOV RBX,qword ptr [RAX + 0x18]
MOV R12,RBX
IMUL R12,R14
IMUL RBX,R13
LEA RSI,[RSP + 0x20]
LEA RDX,[RSP + 0x18]
MOV R15,qword ptr [RSP + 0x10]
MOV RDI,R15
CALL 0x00117b10
MOV RAX,qword ptr [R15 + 0x38]
MOVSD XMM1,qword ptr [0x0014dc90]
TEST RAX,RAX
JS 0x001183f4
CVTSI2SD XMM2,RAX
MOV RAX,qword ptr [R15]
CVTSI2SD XMM0,RAX
DIVSD XMM2,XMM0
CMP RAX,0x2
MOVSD qword ptr [RSP + 0x10],XMM2
JL 0x001183fa
MOVSD XMM0,qword ptr [0x0014dc98]
SUBSD XMM0,XMM2
MULSD XMM0,XMM2
DEC RAX
CVTSI2SD XMM1,RAX
DIVSD XMM0,XMM1
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JC 0x00118402
SQRTSD XMM0,XMM0
JMP 0x00118407
LAB_001183f4:
MOVSD qword ptr [RSP + 0x10],XMM1
LAB_001183fa:
MOVSD qword ptr [RSP + 0x8],XMM1
JMP 0x00118415
LAB_00118402:
CALL 0x00116d20
LAB_00118407:
MULSD XMM0,qword ptr [0x0014dca0]
MOVSD qword ptr [RSP + 0x8],XMM0
LAB_00118415:
CALL 0x00117dd0
MOV RCX,RAX
SUB RCX,qword ptr [RSP + 0x60]
MOV R10D,0xf4240
MOV RAX,RCX
CQO
IDIV R10
MOV RSI,RAX
MOV R11D,0xd693a400
MOV RAX,RCX
CQO
IDIV R11
MOV R8,RAX
IMUL RDI,RAX,-0xe10
ADD RDI,RSI
PUSH 0x3c
POP RBP
MOV RAX,RDI
CQO
IDIV RBP
MOV R9,RAX
IMUL R15,RAX,-0x3c
ADD R15,RDI
MOV RAX,R13
SUB RAX,R14
IMUL RAX,RCX
CQO
IDIV R14
MOV RCX,RAX
CQO
IDIV R10
MOV RSI,RAX
MOV RAX,RCX
CQO
IDIV R11
MOV R10,RAX
IMUL RCX,RAX,-0xe10
ADD RCX,RSI
MOV RAX,RCX
CQO
IDIV RBP
MOV R11,RAX
IMUL RBP,RAX,-0x3c
ADD RBP,RCX
MOV RAX,qword ptr [0x00169fc8]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x20]
MOVSD XMM1,qword ptr [RSP + 0x18]
MOVSD XMM2,qword ptr [RSP + 0x10]
MULSD XMM2,qword ptr [0x0014dca0]
LEA RSI,[0x14e049]
MOV RDX,R12
MOV RCX,RBX
MOV RBX,RAX
MOVSD XMM3,qword ptr [RSP + 0x8]
MOV AL,0x4
PUSH RBP
PUSH R11
PUSH R10
PUSH R15
CALL 0x00117820
ADD RSP,0x20
CMP R13,R14
JNZ 0x00118500
MOV RSI,qword ptr [RBX]
PUSH 0xa
POP RDI
CALL 0x001174d0
LAB_00118500:
MOV RDI,qword ptr [RBX]
CALL 0x00117350
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_opt_epoch_callback_progress_bar
(int param_1,long param_2,int8 param_3,long *param_4,long param_5,long param_6,
long param_7)
{
int *puVar1;
long lVar2;
long lVar3;
char *pcVar4;
FILE *__stream;
long lVar5;
long lVar6;
long lVar7;
int __c;
double local_50;
double local_48;
int8 local_40;
int8 local_38;
pcVar4 = "val: ";
if (param_1 != 0) {
pcVar4 = "train: ";
}
lVar6 = 0;
fprintf(*(FILE **)PTR_stderr_00169fc8,"%s[",pcVar4);
lVar7 = 0x19;
do {
if (lVar6 / 0x19 < param_5) {
__stream = *(FILE **)PTR_stderr_00169fc8;
__c = 0x3d;
}
else {
__stream = *(FILE **)PTR_stderr_00169fc8;
if ((lVar6 - param_6) / 0x19 < param_5) {
__c = 0x3e;
}
else {
__c = 0x20;
}
}
fputc(__c,__stream);
lVar6 = lVar6 + param_6;
lVar7 = lVar7 + -1;
} while (lVar7 != 0);
lVar7 = *(long *)(*(long *)(param_2 + 0x13d0) + 0x18);
ggml_opt_result_loss(param_4,&local_38,&local_40);
if (param_4[7] < 0) {
local_48 = DAT_0014dc90;
}
else {
lVar6 = *param_4;
local_48 = (double)param_4[7] / (double)lVar6;
if (1 < lVar6) {
local_50 = ((DAT_0014dc98 - local_48) * local_48) / (double)(lVar6 + -1);
if (local_50 < 0.0) {
local_50 = sqrt(local_50);
}
else {
local_50 = SQRT(local_50);
}
local_50 = local_50 * _DAT_0014dca0;
goto LAB_00118415;
}
}
local_50 = DAT_0014dc90;
LAB_00118415:
lVar6 = ggml_time_us();
puVar1 = PTR_stderr_00169fc8;
lVar6 = lVar6 - param_7;
lVar5 = (lVar6 / 3600000000) * -0xe10 + lVar6 / 1000000;
lVar2 = ((param_6 - param_5) * lVar6) / param_5;
lVar3 = lVar2 / 3600000000;
lVar2 = lVar3 * -0xe10 + lVar2 / 1000000;
fprintf(*(FILE **)PTR_stderr_00169fc8,
"| data=%06ld/%06ld, loss=%.6lf+-%.6lf, accuracy=%.2lf+-%.2lf%%, t=%02ld:%02ld:%02ld, ETA=%02ld:%02ld:%02ld]\r"
,local_38,local_40,local_48 * _DAT_0014dca0,local_50,lVar7 * param_5,lVar7 * param_6,
lVar6 / 3600000000,lVar5 / 0x3c,lVar5 % 0x3c,lVar3,lVar2 / 0x3c,lVar2 % 0x3c);
if (param_6 == param_5) {
fputc(10,*(FILE **)puVar1);
}
fflush(*(FILE **)puVar1);
return;
}
| |
26,324 | encryption_crypt(unsigned char const*, unsigned int, unsigned char*, unsigned int*, unsigned char const*, unsigned int, unsigned char const*, unsigned int, int, unsigned int, unsigned int) | eloqsql/include/mysql/service_encryption.h | static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen,
const unsigned char* key, unsigned int klen,
const unsigned char* iv, unsigned int ivlen,
int flags, unsigned int key_id, unsigned int key_version)
{
void *ctx= alloca(encryption_ctx_size(key_id, key_version));
int res1, res2;
unsigned int d1, d2;
if ((res1= encryption_ctx_init(ctx, key, klen, iv, ivlen, flags, key_id, key_version)))
return res1;
res1= encryption_ctx_update(ctx, src, slen, dst, &d1);
res2= encryption_ctx_finish(ctx, dst + d1, &d2);
*dlen= d1 + d2;
return res1 ? res1 : res2;
} | O0 | c | encryption_crypt(unsigned char const*, unsigned int, unsigned char*, unsigned int*, unsigned char const*, unsigned int, unsigned char const*, unsigned int, int, unsigned int, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movl %r9d, -0x3c(%rbp)
leaq 0x1b0e35(%rip), %rax # 0x1da018
movq 0x10(%rax), %rax
movl 0x28(%rbp), %edi
movl 0x30(%rbp), %esi
callq *%rax
movl %eax, %eax
movl %eax, %ecx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x48(%rbp)
leaq 0x1b0e09(%rip), %rax # 0x1da018
movq 0x18(%rax), %rax
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x3c(%rbp), %edx
movq 0x10(%rbp), %rcx
movl 0x18(%rbp), %r8d
movl 0x20(%rbp), %r9d
movl 0x28(%rbp), %r11d
movl 0x30(%rbp), %r10d
subq $0x10, %rsp
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
callq *%rax
addq $0x10, %rsp
movl %eax, -0x4c(%rbp)
cmpl $0x0, %eax
je 0x29255
movl -0x4c(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x292c0
leaq 0x1b0dbc(%rip), %rax # 0x1da018
movq 0x20(%rax), %rax
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
leaq -0x54(%rbp), %r8
callq *%rax
movl %eax, -0x4c(%rbp)
leaq 0x1b0d99(%rip), %rax # 0x1da018
movq 0x28(%rax), %rax
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x54(%rbp), %ecx
addq %rcx, %rsi
leaq -0x58(%rbp), %rdx
callq *%rax
movl %eax, -0x50(%rbp)
movl -0x54(%rbp), %ecx
addl -0x58(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x4c(%rbp)
je 0x292b4
movl -0x4c(%rbp), %eax
movl %eax, -0x5c(%rbp)
jmp 0x292ba
movl -0x50(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x60(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x292e0
movl -0x60(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
callq 0x25480
nopw %cs:(%rax,%rax)
| _ZL16encryption_cryptPKhjPhPjS0_jS0_jijj:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_20]
mov eax, [rbp+arg_18]
mov eax, [rbp+arg_10]
mov eax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_38], r8
mov [rbp+var_3C], r9d
lea rax, encryption_handler
mov rax, [rax+10h]
mov edi, [rbp+arg_18]
mov esi, [rbp+arg_20]
call rax
mov eax, eax
mov ecx, eax
add rcx, 0Fh
and rcx, 0FFFFFFFFFFFFFFF0h
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_48], rax
lea rax, encryption_handler
mov rax, [rax+18h]
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_38]
mov edx, [rbp+var_3C]
mov rcx, [rbp+arg_0]
mov r8d, [rbp+arg_8]
mov r9d, [rbp+arg_10]
mov r11d, [rbp+arg_18]
mov r10d, [rbp+arg_20]
sub rsp, 10h
mov [rsp+10h+var_10], r11d
mov dword ptr [rsp+10h+var_8], r10d
call rax
add rsp, 10h
mov [rbp+var_4C], eax
cmp eax, 0
jz short loc_29255
mov eax, [rbp+var_4C]
mov [rbp+var_C], eax
jmp short loc_292C0
loc_29255:
lea rax, encryption_handler
mov rax, [rax+20h]
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov rcx, [rbp+var_28]
lea r8, [rbp+var_54]
call rax
mov [rbp+var_4C], eax
lea rax, encryption_handler
mov rax, [rax+28h]
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_28]
mov ecx, [rbp+var_54]
add rsi, rcx
lea rdx, [rbp+var_58]
call rax
mov [rbp+var_50], eax
mov ecx, [rbp+var_54]
add ecx, [rbp+var_58]
mov rax, [rbp+var_30]
mov [rax], ecx
cmp [rbp+var_4C], 0
jz short loc_292B4
mov eax, [rbp+var_4C]
mov [rbp+var_5C], eax
jmp short loc_292BA
loc_292B4:
mov eax, [rbp+var_50]
mov [rbp+var_5C], eax
loc_292BA:
mov eax, [rbp+var_5C]
mov [rbp+var_C], eax
loc_292C0:
mov eax, [rbp+var_C]
mov [rbp+var_60], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_292E0
mov eax, [rbp+var_60]
mov rsp, rbp
pop rbp
retn
loc_292E0:
call ___stack_chk_fail
| // bad sp value at call has been detected, the output may be wrong!
long long encryption_crypt(
const unsigned __int8 *a1,
unsigned int a2,
unsigned __int8 *a3,
unsigned int *a4,
const unsigned __int8 *a5,
unsigned int a6,
const unsigned __int8 *a7,
unsigned int a8,
unsigned int a9,
unsigned int a10,
unsigned int a11)
{
long long ( *v11)(char *, const unsigned __int8 *, _QWORD, const unsigned __int8 *, _QWORD, _QWORD, unsigned int, unsigned long long); // rax
int v13; // [rsp+10h] [rbp-60h] BYREF
int v15; // [rsp+18h] [rbp-58h] BYREF
int v16; // [rsp+1Ch] [rbp-54h] BYREF
unsigned int v17; // [rsp+20h] [rbp-50h]
unsigned int v18; // [rsp+24h] [rbp-4Ch]
char *v19; // [rsp+28h] [rbp-48h]
unsigned int v20; // [rsp+34h] [rbp-3Ch]
const unsigned __int8 *v21; // [rsp+38h] [rbp-38h]
unsigned int *v22; // [rsp+40h] [rbp-30h]
unsigned __int8 *v23; // [rsp+48h] [rbp-28h]
unsigned int v24; // [rsp+54h] [rbp-1Ch]
const unsigned __int8 *v25; // [rsp+58h] [rbp-18h]
unsigned long long v27; // [rsp+68h] [rbp-8h]
v27 = __readfsqword(0x28u);
v25 = a1;
v24 = a2;
v23 = a3;
v22 = a4;
v21 = a5;
v20 = a6;
v19 = (char *)&v13
- ((((unsigned int ( *)(_QWORD, _QWORD))*(&encryption_handler + 2))(a10, a11) + 15LL) & 0xFFFFFFFFFFFFFFF0LL);
v11 = (long long ( *)(char *, const unsigned __int8 *, _QWORD, const unsigned __int8 *, _QWORD, _QWORD, unsigned int, unsigned long long))*(&encryption_handler + 3);
LODWORD(v27) = a11;
v18 = v11(v19, v21, v20, a7, a8, a9, a10, v27);
if ( v18 )
{
return v18;
}
else
{
v18 = ((long long ( *)(char *, const unsigned __int8 *, _QWORD, unsigned __int8 *, int *))*(&encryption_handler + 4))(
v19,
v25,
v24,
v23,
&v16);
v17 = ((long long ( *)(char *, unsigned __int8 *, int *))*(&encryption_handler + 5))(v19, &v23[v16], &v15);
*v22 = v15 + v16;
if ( v18 )
return v18;
else
return v17;
}
}
| encryption_crypt:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x30]
MOV EAX,dword ptr [RBP + 0x28]
MOV EAX,dword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x38],R8
MOV dword ptr [RBP + -0x3c],R9D
LEA RAX,[0x2da018]
MOV RAX,qword ptr [RAX + 0x10]
MOV EDI,dword ptr [RBP + 0x28]
MOV ESI,dword ptr [RBP + 0x30]
CALL RAX
MOV EAX,EAX
MOV ECX,EAX
ADD RCX,0xf
AND RCX,-0x10
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x48],RAX
LEA RAX,[0x2da018]
MOV RAX,qword ptr [RAX + 0x18]
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + 0x10]
MOV R8D,dword ptr [RBP + 0x18]
MOV R9D,dword ptr [RBP + 0x20]
MOV R11D,dword ptr [RBP + 0x28]
MOV R10D,dword ptr [RBP + 0x30]
SUB RSP,0x10
MOV dword ptr [RSP],R11D
MOV dword ptr [RSP + 0x8],R10D
CALL RAX
ADD RSP,0x10
MOV dword ptr [RBP + -0x4c],EAX
CMP EAX,0x0
JZ 0x00129255
MOV EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001292c0
LAB_00129255:
LEA RAX,[0x2da018]
MOV RAX,qword ptr [RAX + 0x20]
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x28]
LEA R8,[RBP + -0x54]
CALL RAX
MOV dword ptr [RBP + -0x4c],EAX
LEA RAX,[0x2da018]
MOV RAX,qword ptr [RAX + 0x28]
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x54]
ADD RSI,RCX
LEA RDX,[RBP + -0x58]
CALL RAX
MOV dword ptr [RBP + -0x50],EAX
MOV ECX,dword ptr [RBP + -0x54]
ADD ECX,dword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
CMP dword ptr [RBP + -0x4c],0x0
JZ 0x001292b4
MOV EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0x5c],EAX
JMP 0x001292ba
LAB_001292b4:
MOV EAX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0x5c],EAX
LAB_001292ba:
MOV EAX,dword ptr [RBP + -0x5c]
MOV dword ptr [RBP + -0xc],EAX
LAB_001292c0:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x60],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001292e0
MOV EAX,dword ptr [RBP + -0x60]
MOV RSP,RBP
POP RBP
RET
LAB_001292e0:
CALL 0x00125480
|
/* encryption_crypt(unsigned char const*, unsigned int, unsigned char*, unsigned int*, unsigned char
const*, unsigned int, unsigned char const*, unsigned int, int, unsigned int, unsigned int) */
int encryption_crypt(uchar *param_1,uint param_2,uchar *param_3,uint *param_4,uchar *param_5,
uint param_6,uchar *param_7,uint param_8,int param_9,uint param_10,uint param_11
)
{
long lVar1;
long lVar2;
uint uVar3;
uchar *puVar4;
uint uVar5;
uchar *puVar6;
long in_FS_OFFSET;
int8 uStack_80;
uint auStack_78 [2];
int8 uStack_70;
int local_68;
int local_64;
int local_60;
uint local_5c;
int local_58;
int local_54;
long local_50;
uint local_44;
uchar *local_40;
uint *local_38;
uchar *local_30;
uint local_24;
uchar *local_20;
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uStack_70 = 0x1291ef;
local_44 = param_6;
local_40 = param_5;
local_38 = param_4;
local_30 = param_3;
local_24 = param_2;
local_20 = param_1;
uVar5 = (*(code *)PTR_encryption_ctx_size_func_002da028)(param_10,param_11);
puVar6 = local_40;
uVar3 = local_44;
lVar1 = -((ulong)uVar5 + 0xf & 0xfffffffffffffff0);
local_50 = (long)&local_68 + lVar1;
*(uint *)((long)auStack_78 + lVar1) = param_10;
*(uint *)((long)&uStack_70 + lVar1) = param_11;
*(int8 *)((long)&uStack_80 + lVar1) = 0x129241;
local_54 = (*(code *)PTR_encryption_ctx_init_func_002da030)
((long)&local_68 + lVar1,puVar6,uVar3,param_7,param_8,param_9);
puVar4 = local_20;
uVar3 = local_24;
puVar6 = local_30;
lVar2 = local_50;
local_14 = local_54;
if (local_54 == 0) {
*(int8 *)((long)&uStack_70 + lVar1) = 0x129275;
local_54 = (*(code *)PTR_my_aes_crypt_update_002da038)(lVar2,puVar4,uVar3,puVar6,&local_5c);
lVar2 = local_50;
puVar6 = local_30 + local_5c;
*(int8 *)((long)&uStack_70 + lVar1) = 0x129297;
local_58 = (*(code *)PTR_my_aes_crypt_finish_002da040)(lVar2,puVar6,&local_60);
*local_38 = local_5c + local_60;
local_64 = local_58;
if (local_54 != 0) {
local_64 = local_54;
}
local_14 = local_64;
}
local_68 = local_14;
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
*(int8 *)((long)&uStack_70 + lVar1) = 0x1292e5;
__stack_chk_fail();
}
return local_14;
}
| |
26,325 | write_hook_for_undo_key_delete | eloqsql/storage/maria/ma_key_recover.c | my_bool write_hook_for_undo_key_delete(enum translog_record_type type,
TRN *trn, MARIA_HA *tbl_info,
LSN *lsn, void *hook_arg)
{
struct st_msg_to_write_hook_for_undo_key *msg=
(struct st_msg_to_write_hook_for_undo_key *) hook_arg;
MARIA_SHARE *share= tbl_info->s;
if (msg->auto_increment > 0) /* If auto increment key */
{
/* Restore auto increment if no one has changed it in between */
if (share->last_auto_increment == tbl_info->last_auto_increment &&
tbl_info->last_auto_increment != ~(ulonglong) 0)
share->state.auto_increment= tbl_info->last_auto_increment;
}
return write_hook_for_undo_key(type, trn, tbl_info, lsn, hook_arg);
} | O0 | c | write_hook_for_undo_key_delete:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x706f7
movq -0x38(%rbp), %rax
movq 0x610(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x3e8(%rcx), %rax
jne 0x706f5
movq -0x18(%rbp), %rax
cmpq $-0x1, 0x3e8(%rax)
je 0x706f5
movq -0x18(%rbp), %rax
movq 0x3e8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0xd8(%rax)
jmp 0x706f7
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x70520
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| write_hook_for_undo_key_delete:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
cmp qword ptr [rax+18h], 0
jbe short loc_706F7
mov rax, [rbp+var_38]
mov rax, [rax+610h]
mov rcx, [rbp+var_18]
cmp rax, [rcx+3E8h]
jnz short loc_706F5
mov rax, [rbp+var_18]
cmp qword ptr [rax+3E8h], 0FFFFFFFFFFFFFFFFh
jz short loc_706F5
mov rax, [rbp+var_18]
mov rcx, [rax+3E8h]
mov rax, [rbp+var_38]
mov [rax+0D8h], rcx
loc_706F5:
jmp short $+2
loc_706F7:
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
call write_hook_for_undo_key
add rsp, 40h
pop rbp
retn
| long long write_hook_for_undo_key_delete(unsigned int a1, long long a2, long long *a3, long long a4, long long a5)
{
long long v6; // [rsp+8h] [rbp-38h]
v6 = *a3;
if ( *(_QWORD *)(a5 + 24) && *(_QWORD *)(v6 + 1552) == a3[125] && a3[125] != -1 )
*(_QWORD *)(v6 + 216) = a3[125];
return write_hook_for_undo_key(a1, a2, (long long)a3, a4, a5);
}
| write_hook_for_undo_key_delete:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
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 qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x18],0x0
JBE 0x001706f7
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x610]
MOV RCX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RCX + 0x3e8]
JNZ 0x001706f5
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x3e8],-0x1
JZ 0x001706f5
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x3e8]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0xd8],RCX
LAB_001706f5:
JMP 0x001706f7
LAB_001706f7:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
CALL 0x00170520
ADD RSP,0x40
POP RBP
RET
|
void write_hook_for_undo_key_delete
(int4 param_1,int8 param_2,long *param_3,int8 param_4,long param_5)
{
if (((*(long *)(param_5 + 0x18) != 0) && (*(long *)(*param_3 + 0x610) == param_3[0x7d])) &&
(param_3[0x7d] != -1)) {
*(long *)(*param_3 + 0xd8) = param_3[0x7d];
}
write_hook_for_undo_key(param_1,param_2,param_3,param_4,param_5);
return;
}
| |
26,326 | LefDefParser::defiTrack::setup(char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiRowTrack.cpp | void defiTrack::setup(const char* macro) {
int i;
int len = strlen(macro) + 1;
if (len > macroLength_) {
if (macro_) free(macro_);
macroLength_ = len;
macro_ = (char*)malloc(len);
}
strcpy(macro_, defData->DEFCASE(macro));
if (layers_) {
for (i = 0; i < numLayers_; i++)
if (layers_[i]) {
free(layers_[i]);
layers_[i] = 0;
}
}
numLayers_ = 0;
x_ = 0.0;
xStep_ = 0.0;
xNum_ = 0.0;
firstTrackMask_=0;
samemask_=0;
} | O3 | cpp | LefDefParser::defiTrack::setup(char const*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x60d0
movq %rax, %r12
incl %r12d
movq 0x8(%rbx), %r15
cmpl (%rbx), %r12d
jle 0x1d404
testq %r15, %r15
je 0x1d3f2
movq %r15, %rdi
callq 0x6220
movl %r12d, (%rbx)
movslq %r12d, %rdi
callq 0x6270
movq %rax, %r15
movq %rax, 0x8(%rbx)
movq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0x18aa0
movq %r15, %rdi
movq %rax, %rsi
callq 0x6190
cmpq $0x0, 0x30(%rbx)
je 0x1d458
movl 0x2c(%rbx), %eax
testl %eax, %eax
jle 0x1d458
xorl %r14d, %r14d
movq 0x30(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x1d44d
callq 0x6220
movq 0x30(%rbx), %rax
movq $0x0, (%rax,%r14,8)
movl 0x2c(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x1d42c
movl $0x0, 0x2c(%rbx)
xorl %eax, %eax
movq %rax, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZN12LefDefParser9defiTrack5setupEPKc:
push r15
push r14
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rdi, rsi
call _strlen
mov r12, rax
inc r12d
mov r15, [rbx+8]
cmp r12d, [rbx]
jle short loc_1D404
test r15, r15
jz short loc_1D3F2
mov rdi, r15
call _free
loc_1D3F2:
mov [rbx], r12d
movsxd rdi, r12d
call _malloc
mov r15, rax
mov [rbx+8], rax
loc_1D404:
mov rdi, [rbx+40h]; this
mov rsi, r14; char *
call _ZN12LefDefParser8defrData7DEFCASEEPKc; LefDefParser::defrData::DEFCASE(char const*)
mov rdi, r15
mov rsi, rax
call _strcpy
cmp qword ptr [rbx+30h], 0
jz short loc_1D458
mov eax, [rbx+2Ch]
test eax, eax
jle short loc_1D458
xor r14d, r14d
loc_1D42C:
mov rcx, [rbx+30h]
mov rdi, [rcx+r14*8]
test rdi, rdi
jz short loc_1D44D
call _free
mov rax, [rbx+30h]
mov qword ptr [rax+r14*8], 0
mov eax, [rbx+2Ch]
loc_1D44D:
inc r14
movsxd rcx, eax
cmp r14, rcx
jl short loc_1D42C
loc_1D458:
mov dword ptr [rbx+2Ch], 0
xor eax, eax
mov [rbx+38h], rax
xorps xmm0, xmm0
movups xmmword ptr [rbx+10h], xmm0
mov [rbx+20h], rax
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long LefDefParser::defiTrack::setup(LefDefParser::defiTrack *this, const char *a2)
{
int v3; // r12d
long long v4; // r15
const char *v5; // rax
int v6; // eax
long long i; // r14
long long v8; // rdi
long long result; // rax
v3 = strlen(a2) + 1;
v4 = *((_QWORD *)this + 1);
if ( v3 > *(_DWORD *)this )
{
if ( v4 )
free(*((_QWORD *)this + 1));
*(_DWORD *)this = v3;
v4 = malloc(v3);
*((_QWORD *)this + 1) = v4;
}
v5 = LefDefParser::defrData::DEFCASE(*((LefDefParser::defrData **)this + 8), a2);
strcpy(v4, v5);
if ( *((_QWORD *)this + 6) )
{
v6 = *((_DWORD *)this + 11);
if ( v6 > 0 )
{
for ( i = 0LL; i < v6; ++i )
{
v8 = *(_QWORD *)(*((_QWORD *)this + 6) + 8 * i);
if ( v8 )
{
free(v8);
*(_QWORD *)(*((_QWORD *)this + 6) + 8 * i) = 0LL;
v6 = *((_DWORD *)this + 11);
}
}
}
}
*((_DWORD *)this + 11) = 0;
result = 0LL;
*((_QWORD *)this + 7) = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_QWORD *)this + 4) = 0LL;
return result;
}
| setup:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x001060d0
MOV R12,RAX
INC R12D
MOV R15,qword ptr [RBX + 0x8]
CMP R12D,dword ptr [RBX]
JLE 0x0011d404
TEST R15,R15
JZ 0x0011d3f2
MOV RDI,R15
CALL 0x00106220
LAB_0011d3f2:
MOV dword ptr [RBX],R12D
MOVSXD RDI,R12D
CALL 0x00106270
MOV R15,RAX
MOV qword ptr [RBX + 0x8],RAX
LAB_0011d404:
MOV RDI,qword ptr [RBX + 0x40]
MOV RSI,R14
CALL 0x00118aa0
MOV RDI,R15
MOV RSI,RAX
CALL 0x00106190
CMP qword ptr [RBX + 0x30],0x0
JZ 0x0011d458
MOV EAX,dword ptr [RBX + 0x2c]
TEST EAX,EAX
JLE 0x0011d458
XOR R14D,R14D
LAB_0011d42c:
MOV RCX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RCX + R14*0x8]
TEST RDI,RDI
JZ 0x0011d44d
CALL 0x00106220
MOV RAX,qword ptr [RBX + 0x30]
MOV qword ptr [RAX + R14*0x8],0x0
MOV EAX,dword ptr [RBX + 0x2c]
LAB_0011d44d:
INC R14
MOVSXD RCX,EAX
CMP R14,RCX
JL 0x0011d42c
LAB_0011d458:
MOV dword ptr [RBX + 0x2c],0x0
XOR EAX,EAX
MOV qword ptr [RBX + 0x38],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOV qword ptr [RBX + 0x20],RAX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* LefDefParser::defiTrack::setup(char const*) */
void __thiscall LefDefParser::defiTrack::setup(defiTrack *this,char *param_1)
{
void *__ptr;
size_t sVar1;
char *__dest;
char *__src;
int iVar2;
long lVar3;
sVar1 = strlen(param_1);
iVar2 = (int)sVar1 + 1;
__dest = *(char **)(this + 8);
if (*(int *)this < iVar2) {
if (__dest != (char *)0x0) {
free(__dest);
}
*(int *)this = iVar2;
__dest = (char *)malloc((long)iVar2);
*(char **)(this + 8) = __dest;
}
__src = (char *)defrData::DEFCASE(*(defrData **)(this + 0x40),param_1);
strcpy(__dest,__src);
if (*(long *)(this + 0x30) != 0) {
iVar2 = *(int *)(this + 0x2c);
if (0 < iVar2) {
lVar3 = 0;
do {
__ptr = *(void **)(*(long *)(this + 0x30) + lVar3 * 8);
if (__ptr != (void *)0x0) {
free(__ptr);
*(int8 *)(*(long *)(this + 0x30) + lVar3 * 8) = 0;
iVar2 = *(int *)(this + 0x2c);
}
lVar3 = lVar3 + 1;
} while (lVar3 < iVar2);
}
}
*(int4 *)(this + 0x2c) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
return;
}
| |
26,327 | mi_ft_convert_to_ft2 | eloqsql/storage/myisam/ft_update.c | uint _mi_ft_convert_to_ft2(MI_INFO *info, uint keynr, uchar *key)
{
my_off_t root;
DYNAMIC_ARRAY *da=info->ft1_to_ft2;
MI_KEYDEF *keyinfo=&info->s->ft2_keyinfo;
uchar *key_ptr= (uchar*) dynamic_array_ptr(da, 0), *end;
uint length, key_length;
DBUG_ENTER("_mi_ft_convert_to_ft2");
/* we'll generate one pageful at once, and insert the rest one-by-one */
/* calculating the length of this page ...*/
length=(keyinfo->block_length-2) / keyinfo->keylength;
set_if_smaller(length, da->elements);
length=length * keyinfo->keylength;
get_key_full_length_rdonly(key_length, key);
while (_mi_ck_delete(info, keynr, key, key_length) == 0)
{
/*
nothing to do here.
_mi_ck_delete() will populate info->ft1_to_ft2 with deleted keys
*/
}
/* creating pageful of keys */
mi_putint(info->buff,length+2,0);
memcpy(info->buff+2, key_ptr, length);
info->buff_used=info->page_changed=1; /* info->buff is used */
if ((root= _mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR ||
_mi_write_keypage(info,keyinfo,root,DFLT_INIT_HITS,info->buff))
DBUG_RETURN(-1);
/* inserting the rest of key values */
end= (uchar*) dynamic_array_ptr(da, da->elements);
for (key_ptr+=length; key_ptr < end; key_ptr+=keyinfo->keylength)
if(_mi_ck_real_write_btree(info, keyinfo, key_ptr, 0, &root, SEARCH_SAME))
DBUG_RETURN(-1);
/* now, writing the word key entry */
ft_intXstore(key+key_length, - (int) da->elements);
_mi_dpointer(info, key+key_length+HA_FT_WLEN, root);
DBUG_RETURN(_mi_ck_real_write_btree(info,
info->s->keyinfo+keynr,
key, 0,
&info->s->state.key_root[keynr],
SEARCH_SAME));
} | O3 | c | mi_ft_convert_to_ft2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movq (%rdi), %rcx
movq 0x88(%rdi), %rsi
movzwl 0x1b6(%rcx), %eax
addl $-0x2, %eax
movq %rcx, -0x48(%rbp)
movzwl 0x1ba(%rcx), %ecx
cltd
idivl %ecx
movl 0x8(%rsi), %edx
cmpl %edx, %eax
cmovbl %eax, %edx
movzbl (%rbx), %r12d
cmpl $0xff, %r12d
je 0x4a739
incl %r12d
jmp 0x4a749
movzwl 0x1(%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %r12d
addl $0x3, %r12d
movq -0x48(%rbp), %rax
addq $0x1a8, %rax # imm = 0x1A8
movq %rax, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq (%rsi), %r13
imull %ecx, %edx
movq %rdx, -0x30(%rbp)
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movl %r12d, %ecx
callq 0x2ebcd
testl %eax, %eax
je 0x4a765
movq -0x30(%rbp), %rdx
leal 0x2(%rdx), %eax
movq 0x100(%r14), %rcx
movb %al, 0x1(%rcx)
movq 0x100(%r14), %rcx
movb %ah, (%rcx)
movq 0x100(%r14), %rdi
addq $0x2, %rdi
movl %edx, %edx
movq %r13, %rsi
movq %rdx, -0x30(%rbp)
callq 0x282c0
movw $0x101, 0x33c(%r14) # imm = 0x101
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movl $0x3, %edx
callq 0x3d112
movq %rax, %rcx
movq %rax, -0x50(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq $-0x1, %rcx
je 0x4a8b3
movq 0x100(%r14), %r8
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movq %rcx, -0x58(%rbp)
movq %rcx, %rdx
movl $0x3, %ecx
callq 0x3cf60
testl %eax, %eax
je 0x4a80b
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x4a8b3
movq -0x58(%rbp), %rdx
movq -0x40(%rbp), %rcx
movl 0x8(%rcx), %eax
movl 0x14(%rcx), %esi
imull %eax, %esi
addq (%rcx), %rsi
addq -0x30(%rbp), %r13
movq %rsi, -0x30(%rbp)
cmpq %rsi, %r13
jae 0x4a86a
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movq %r13, %rdx
xorl %ecx, %ecx
leaq -0x50(%rbp), %r8
movl $0x4, %r9d
callq 0x420bb
testl %eax, %eax
jne 0x4a801
movq -0x48(%rbp), %rax
movzwl 0x1ba(%rax), %eax
addq %rax, %r13
cmpq -0x30(%rbp), %r13
jb 0x4a82c
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x50(%rbp), %rdx
negl %eax
movl %r12d, %ecx
bswapl %eax
leaq (%rbx,%rcx), %rsi
addq $0x4, %rsi
movl %eax, -0x4(%rsi)
movq %r14, %rdi
callq 0x3e86f
movq (%r14), %rax
movl %r15d, %r8d
imulq $0x70, %r8, %rsi
addq 0x218(%rax), %rsi
shlq $0x3, %r8
addq 0x98(%rax), %r8
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
movl $0x4, %r9d
callq 0x420bb
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _mi_ft_convert_to_ft2:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, rdx
mov r15d, esi
mov r14, rdi
mov rcx, [rdi]
mov rsi, [rdi+88h]
movzx eax, word ptr [rcx+1B6h]
add eax, 0FFFFFFFEh
mov [rbp+var_48], rcx
movzx ecx, word ptr [rcx+1BAh]
cdq
idiv ecx
mov edx, [rsi+8]
cmp eax, edx
cmovb edx, eax
movzx r12d, byte ptr [rbx]
cmp r12d, 0FFh
jz short loc_4A739
inc r12d
jmp short loc_4A749
loc_4A739:
movzx eax, word ptr [rbx+1]
rol ax, 8
movzx r12d, ax
add r12d, 3
loc_4A749:
mov rax, [rbp+var_48]
add rax, 1A8h
mov [rbp+var_38], rax
mov [rbp+var_40], rsi
mov r13, [rsi]
imul edx, ecx
mov [rbp+var_30], rdx
loc_4A765:
mov rdi, r14
mov esi, r15d
mov rdx, rbx
mov ecx, r12d
call _mi_ck_delete
test eax, eax
jz short loc_4A765
mov rdx, [rbp+var_30]
lea eax, [rdx+2]
mov rcx, [r14+100h]
mov [rcx+1], al
mov rcx, [r14+100h]
mov [rcx], ah
mov rdi, [r14+100h]
add rdi, 2
mov edx, edx
mov rsi, r13
mov [rbp+var_30], rdx
call _memcpy
mov word ptr [r14+33Ch], 101h
mov rdi, r14
mov rsi, [rbp+var_38]
mov edx, 3
call _mi_new
mov rcx, rax
mov [rbp+var_50], rax
mov eax, 0FFFFFFFFh
cmp rcx, 0FFFFFFFFFFFFFFFFh
jz loc_4A8B3
mov r8, [r14+100h]
mov rdi, r14
mov rsi, [rbp+var_38]
mov [rbp+var_58], rcx
mov rdx, rcx
mov ecx, 3
call _mi_write_keypage
test eax, eax
jz short loc_4A80B
loc_4A801:
mov eax, 0FFFFFFFFh
jmp loc_4A8B3
loc_4A80B:
mov rdx, [rbp+var_58]
mov rcx, [rbp+var_40]
mov eax, [rcx+8]
mov esi, [rcx+14h]
imul esi, eax
add rsi, [rcx]
add r13, [rbp+var_30]
mov [rbp+var_30], rsi
cmp r13, rsi
jnb short loc_4A86A
loc_4A82C:
mov rdi, r14
mov rsi, [rbp+var_38]
mov rdx, r13
xor ecx, ecx
lea r8, [rbp+var_50]
mov r9d, 4
call _mi_ck_real_write_btree
test eax, eax
jnz short loc_4A801
mov rax, [rbp+var_48]
movzx eax, word ptr [rax+1BAh]
add r13, rax
cmp r13, [rbp+var_30]
jb short loc_4A82C
mov rax, [rbp+var_40]
mov eax, [rax+8]
mov rdx, [rbp+var_50]
loc_4A86A:
neg eax
mov ecx, r12d
bswap eax
lea rsi, [rbx+rcx]
add rsi, 4
mov [rsi-4], eax
mov rdi, r14
call _mi_dpointer
mov rax, [r14]
mov r8d, r15d
imul rsi, r8, 70h ; 'p'
add rsi, [rax+218h]
shl r8, 3
add r8, [rax+98h]
mov rdi, r14
mov rdx, rbx
xor ecx, ecx
mov r9d, 4
call _mi_ck_real_write_btree
loc_4A8B3:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mi_ft_convert_to_ft2(long long a1, unsigned int a2, unsigned __int8 *a3)
{
long long *v6; // rsi
int v7; // eax
int v8; // ecx
unsigned int v9; // eax
unsigned int v10; // edx
int v11; // r12d
unsigned int v12; // r12d
long long v13; // r13
unsigned int v14; // edx
__int16 v15; // ax
long long v16; // rdi
unsigned long long v17; // rcx
long long result; // rax
unsigned long long v19; // rdx
int v20; // eax
unsigned long long v21; // r13
long long v22; // rsi
unsigned long long v23; // [rsp+8h] [rbp-58h]
unsigned long long v24; // [rsp+10h] [rbp-50h] BYREF
long long v25; // [rsp+18h] [rbp-48h]
long long *v26; // [rsp+20h] [rbp-40h]
long long v27; // [rsp+28h] [rbp-38h]
unsigned long long v28; // [rsp+30h] [rbp-30h]
v6 = *(long long **)(a1 + 136);
v7 = *(unsigned __int16 *)(*(_QWORD *)a1 + 438LL) - 2;
v25 = *(_QWORD *)a1;
v8 = *(unsigned __int16 *)(v25 + 442);
v9 = v7 / v8;
v10 = *((_DWORD *)v6 + 2);
if ( v9 < v10 )
v10 = v9;
v11 = *a3;
if ( v11 == 255 )
v12 = (unsigned __int16)__ROL2__(*(_WORD *)(a3 + 1), 8) + 3;
else
v12 = v11 + 1;
v27 = v25 + 424;
v26 = v6;
v13 = *v6;
v28 = v8 * v10;
while ( !(unsigned int)mi_ck_delete(a1, a2, (long long)a3, v12) )
;
v14 = v28;
v15 = v28 + 2;
*(_BYTE *)(*(_QWORD *)(a1 + 256) + 1LL) = v28 + 2;
**(_BYTE **)(a1 + 256) = HIBYTE(v15);
v16 = *(_QWORD *)(a1 + 256) + 2LL;
v28 = v14;
memcpy(v16, v13, v14);
*(_WORD *)(a1 + 828) = 257;
v17 = mi_new((_QWORD *)a1, v27);
v24 = v17;
result = 0xFFFFFFFFLL;
if ( v17 != -1LL )
{
v23 = v17;
if ( (unsigned int)mi_write_keypage((long long *)a1, v27, v17, 3u, *(_BYTE **)(a1 + 256)) )
return 0xFFFFFFFFLL;
v19 = v23;
v20 = *((_DWORD *)v26 + 2);
v21 = v28 + v13;
v28 = *v26 + (unsigned int)(v20 * *((_DWORD *)v26 + 5));
if ( v21 < v28 )
{
while ( !(unsigned int)mi_ck_real_write_btree(a1, v27, v21, 0, &v24, 4) )
{
v21 += *(unsigned __int16 *)(v25 + 442);
if ( v21 >= v28 )
{
v20 = *((_DWORD *)v26 + 2);
v19 = v24;
goto LABEL_15;
}
}
return 0xFFFFFFFFLL;
}
LABEL_15:
v22 = (long long)&a3[v12 + 4];
*(_DWORD *)(v22 - 4) = _byteswap_ulong(-v20);
mi_dpointer((long long *)a1, v22, v19);
return mi_ck_real_write_btree(
a1,
*(_QWORD *)(*(_QWORD *)a1 + 536LL) + 112LL * a2,
(long long)a3,
0,
(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 152LL) + 8LL * a2),
4);
}
return result;
}
| _mi_ft_convert_to_ft2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDX
MOV R15D,ESI
MOV R14,RDI
MOV RCX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x88]
MOVZX EAX,word ptr [RCX + 0x1b6]
ADD EAX,-0x2
MOV qword ptr [RBP + -0x48],RCX
MOVZX ECX,word ptr [RCX + 0x1ba]
CDQ
IDIV ECX
MOV EDX,dword ptr [RSI + 0x8]
CMP EAX,EDX
CMOVC EDX,EAX
MOVZX R12D,byte ptr [RBX]
CMP R12D,0xff
JZ 0x0014a739
INC R12D
JMP 0x0014a749
LAB_0014a739:
MOVZX EAX,word ptr [RBX + 0x1]
ROL AX,0x8
MOVZX R12D,AX
ADD R12D,0x3
LAB_0014a749:
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1a8
MOV qword ptr [RBP + -0x38],RAX
MOV qword ptr [RBP + -0x40],RSI
MOV R13,qword ptr [RSI]
IMUL EDX,ECX
MOV qword ptr [RBP + -0x30],RDX
LAB_0014a765:
MOV RDI,R14
MOV ESI,R15D
MOV RDX,RBX
MOV ECX,R12D
CALL 0x0012ebcd
TEST EAX,EAX
JZ 0x0014a765
MOV RDX,qword ptr [RBP + -0x30]
LEA EAX,[RDX + 0x2]
MOV RCX,qword ptr [R14 + 0x100]
MOV byte ptr [RCX + 0x1],AL
MOV RCX,qword ptr [R14 + 0x100]
MOV byte ptr [RCX],AH
MOV RDI,qword ptr [R14 + 0x100]
ADD RDI,0x2
MOV EDX,EDX
MOV RSI,R13
MOV qword ptr [RBP + -0x30],RDX
CALL 0x001282c0
MOV word ptr [R14 + 0x33c],0x101
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,0x3
CALL 0x0013d112
MOV RCX,RAX
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,0xffffffff
CMP RCX,-0x1
JZ 0x0014a8b3
MOV R8,qword ptr [R14 + 0x100]
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x58],RCX
MOV RDX,RCX
MOV ECX,0x3
CALL 0x0013cf60
TEST EAX,EAX
JZ 0x0014a80b
LAB_0014a801:
MOV EAX,0xffffffff
JMP 0x0014a8b3
LAB_0014a80b:
MOV RDX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RCX + 0x8]
MOV ESI,dword ptr [RCX + 0x14]
IMUL ESI,EAX
ADD RSI,qword ptr [RCX]
ADD R13,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RSI
CMP R13,RSI
JNC 0x0014a86a
LAB_0014a82c:
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,R13
XOR ECX,ECX
LEA R8,[RBP + -0x50]
MOV R9D,0x4
CALL 0x001420bb
TEST EAX,EAX
JNZ 0x0014a801
MOV RAX,qword ptr [RBP + -0x48]
MOVZX EAX,word ptr [RAX + 0x1ba]
ADD R13,RAX
CMP R13,qword ptr [RBP + -0x30]
JC 0x0014a82c
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x8]
MOV RDX,qword ptr [RBP + -0x50]
LAB_0014a86a:
NEG EAX
MOV ECX,R12D
BSWAP EAX
LEA RSI,[RBX + RCX*0x1]
ADD RSI,0x4
MOV dword ptr [RSI + -0x4],EAX
MOV RDI,R14
CALL 0x0013e86f
MOV RAX,qword ptr [R14]
MOV R8D,R15D
IMUL RSI,R8,0x70
ADD RSI,qword ptr [RAX + 0x218]
SHL R8,0x3
ADD R8,qword ptr [RAX + 0x98]
MOV RDI,R14
MOV RDX,RBX
XOR ECX,ECX
MOV R9D,0x4
CALL 0x001420bb
LAB_0014a8b3:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 _mi_ft_convert_to_ft2(long *param_1,uint param_2,byte *param_3)
{
void *__src;
uint uVar1;
int iVar2;
uint uVar3;
long lVar4;
int8 uVar5;
ulong uVar6;
ulong uVar7;
long local_58;
long local_50;
long *local_48;
long local_40;
ulong local_38;
local_50 = *param_1;
local_48 = (long *)param_1[0x11];
uVar1 = (int)(*(ushort *)(local_50 + 0x1b6) - 2) / (int)(uint)*(ushort *)(local_50 + 0x1ba);
uVar3 = *(uint *)(local_48 + 1);
if (uVar1 < *(uint *)(local_48 + 1)) {
uVar3 = uVar1;
}
if (*param_3 == 0xff) {
uVar1 = (ushort)(*(ushort *)(param_3 + 1) << 8 | *(ushort *)(param_3 + 1) >> 8) + 3;
}
else {
uVar1 = *param_3 + 1;
}
local_40 = local_50 + 0x1a8;
__src = (void *)*local_48;
local_38 = (ulong)(uVar3 * *(ushort *)(local_50 + 0x1ba));
do {
iVar2 = _mi_ck_delete(param_1,param_2,param_3,uVar1);
} while (iVar2 == 0);
iVar2 = (int)local_38 + 2;
*(char *)(param_1[0x20] + 1) = (char)iVar2;
*(char *)param_1[0x20] = (char)((uint)iVar2 >> 8);
local_38 = local_38 & 0xffffffff;
memcpy((void *)(param_1[0x20] + 2),__src,local_38);
*(int2 *)((long)param_1 + 0x33c) = 0x101;
lVar4 = _mi_new(param_1,local_40,3);
uVar5 = 0xffffffff;
if (lVar4 != -1) {
local_58 = lVar4;
iVar2 = _mi_write_keypage(param_1,local_40,lVar4,3,param_1[0x20]);
if (iVar2 == 0) {
iVar2 = (int)local_48[1];
uVar6 = (ulong)(uint)(*(int *)((long)local_48 + 0x14) * iVar2) + *local_48;
uVar7 = (long)__src + local_38;
local_38 = uVar6;
if (uVar7 < uVar6) {
do {
iVar2 = _mi_ck_real_write_btree(param_1,local_40,uVar7,0,&local_58,4);
if (iVar2 != 0) goto LAB_0014a801;
uVar7 = uVar7 + *(ushort *)(local_50 + 0x1ba);
} while (uVar7 < local_38);
iVar2 = (int)local_48[1];
lVar4 = local_58;
}
uVar3 = -iVar2;
*(uint *)(param_3 + uVar1) =
uVar3 >> 0x18 | (uVar3 & 0xff0000) >> 8 | (uVar3 & 0xff00) << 8 | iVar2 * -0x1000000;
_mi_dpointer(param_1,(uint *)((long)(param_3 + uVar1) + 4),lVar4);
uVar5 = _mi_ck_real_write_btree
(param_1,(ulong)param_2 * 0x70 + *(long *)(*param_1 + 0x218),param_3,0,
(ulong)param_2 * 8 + *(long *)(*param_1 + 0x98),4);
}
else {
LAB_0014a801:
uVar5 = 0xffffffff;
}
}
return uVar5;
}
| |
26,328 | unlock_io_cache | eloqsql/mysys/mf_iocache.c | static void unlock_io_cache(IO_CACHE *cache)
{
IO_CACHE_SHARE *cshare= cache->share;
DBUG_ENTER("unlock_io_cache");
DBUG_PRINT("io_cache_share", ("%s: %p pos: %lu running: %u",
(cache == cshare->source_cache) ?
"writer" : "reader",
cache, (ulong) cshare->pos_in_file,
cshare->total_threads));
cshare->running_threads= cshare->total_threads;
mysql_cond_broadcast(&cshare->cond);
mysql_mutex_unlock(&cshare->mutex);
DBUG_VOID_RETURN;
} | O3 | c | unlock_io_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0xdc(%rdi), %eax
movl %eax, 0xd8(%rdi)
leaq 0x48(%rdi), %r14
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
jne 0x9728b
movq %r14, %rdi
callq 0x296f0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
jne 0x9729d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x291e0
leaq 0x2eed7e(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x178(%rax)
jmp 0x9726e
leaq 0x2eed6c(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x9727f
nop
| unlock_io_cache:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
mov eax, [rdi+0DCh]
mov [rdi+0D8h], eax
lea r14, [rdi+48h]
mov rdi, [rdi+78h]
test rdi, rdi
jnz short loc_9728B
loc_9726E:
mov rdi, r14
call _pthread_cond_broadcast
mov rdi, [rbx+40h]
test rdi, rdi
jnz short loc_9729D
loc_9727F:
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp _pthread_mutex_unlock
loc_9728B:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+178h]
jmp short loc_9726E
loc_9729D:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_9727F
| long long unlock_io_cache(long long a1)
{
*(_DWORD *)(a1 + 216) = *(_DWORD *)(a1 + 220);
if ( *(_QWORD *)(a1 + 120) )
PSI_server[47]();
pthread_cond_broadcast(a1 + 72);
if ( *(_QWORD *)(a1 + 64) )
PSI_server[44]();
return pthread_mutex_unlock(a1);
}
| unlock_io_cache:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0xdc]
MOV dword ptr [RDI + 0xd8],EAX
LEA R14,[RDI + 0x48]
MOV RDI,qword ptr [RDI + 0x78]
TEST RDI,RDI
JNZ 0x0019728b
LAB_0019726e:
MOV RDI,R14
CALL 0x001296f0
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JNZ 0x0019729d
LAB_0019727f:
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x001291e0
LAB_0019728b:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x178]
JMP 0x0019726e
LAB_0019729d:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0019727f
|
void unlock_io_cache(pthread_mutex_t *param_1)
{
*(int4 *)((long)param_1 + 0xd8) = *(int4 *)((long)param_1 + 0xdc);
if (param_1[3].__align != 0) {
(**(code **)(PSI_server + 0x178))();
}
pthread_cond_broadcast((pthread_cond_t *)((long)param_1 + 0x48));
if (*(long *)((long)param_1 + 0x40) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(param_1);
return;
}
| |
26,329 | escape_string_for_mysql | eloqsql/mysys/charset.c | size_t escape_string_for_mysql(CHARSET_INFO *charset_info,
char *to, size_t to_length,
const char *from, size_t length,
my_bool *overflow)
{
const char *to_start= to;
const char *end, *to_end=to_start + (to_length ? to_length-1 : 2*length);
*overflow= FALSE;
for (end= from + length; from < end; from++)
{
char escape= 0;
#ifdef USE_MB
int tmp_length= my_ci_charlen(charset_info, (const uchar *) from, (const uchar *) end);
if (tmp_length > 1)
{
if (to + tmp_length > to_end)
{
*overflow= TRUE;
break;
}
while (tmp_length--)
*to++= *from++;
from--;
continue;
}
/*
If the next character appears to begin a multi-byte character, we
escape that first byte of that apparent multi-byte character. (The
character just looks like a multi-byte character -- if it were actually
a multi-byte character, it would have been passed through in the test
above.)
Without this check, we can create a problem by converting an invalid
multi-byte character into a valid one. For example, 0xbf27 is not
a valid GBK character, but 0xbf5c is. (0x27 = ', 0x5c = \)
*/
if (tmp_length < 1) /* Bad byte sequence */
escape= *from;
else
#endif
switch (*from) {
case 0: /* Must be escaped for 'mysql' */
escape= '0';
break;
case '\n': /* Must be escaped for logs */
escape= 'n';
break;
case '\r':
escape= 'r';
break;
case '\\':
escape= '\\';
break;
case '\'':
escape= '\'';
break;
case '"': /* Better safe than sorry */
escape= '"';
break;
case '\032': /* This gives problems on Win32 */
escape= 'Z';
break;
}
if (escape)
{
if (to + 2 > to_end)
{
*overflow= TRUE;
break;
}
*to++= '\\';
*to++= escape;
}
else
{
if (to + 1 > to_end)
{
*overflow= TRUE;
break;
}
*to++= *from;
}
}
*to= 0;
return (size_t) (to - to_start);
} | O0 | c | escape_string_for_mysql:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xde4c5
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0xde4d0
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xde68f
movb $0x0, -0x49(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xde6b0
movl %eax, -0x50(%rbp)
cmpl $0x1, -0x50(%rbp)
jle 0xde582
movq -0x10(%rbp), %rax
movslq -0x50(%rbp), %rcx
addq %rcx, %rax
cmpq -0x48(%rbp), %rax
jbe 0xde53b
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
jmp 0xde68f
jmp 0xde53d
movl -0x50(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x50(%rbp)
cmpl $0x0, %eax
je 0xde571
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0xde53d
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xde67e
cmpl $0x1, -0x50(%rbp)
jge 0xde593
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x49(%rbp)
jmp 0xde609
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x64(%rbp)
testl %eax, %eax
je 0xde5df
jmp 0xde5a3
movl -0x64(%rbp), %eax
subl $0xa, %eax
je 0xde5e5
jmp 0xde5ad
movl -0x64(%rbp), %eax
subl $0xd, %eax
je 0xde5eb
jmp 0xde5b7
movl -0x64(%rbp), %eax
subl $0x1a, %eax
je 0xde603
jmp 0xde5c1
movl -0x64(%rbp), %eax
subl $0x22, %eax
je 0xde5fd
jmp 0xde5cb
movl -0x64(%rbp), %eax
subl $0x27, %eax
je 0xde5f7
jmp 0xde5d5
movl -0x64(%rbp), %eax
subl $0x5c, %eax
je 0xde5f1
jmp 0xde607
movb $0x30, -0x49(%rbp)
jmp 0xde607
movb $0x6e, -0x49(%rbp)
jmp 0xde607
movb $0x72, -0x49(%rbp)
jmp 0xde607
movb $0x5c, -0x49(%rbp)
jmp 0xde607
movb $0x27, -0x49(%rbp)
jmp 0xde607
movb $0x22, -0x49(%rbp)
jmp 0xde607
movb $0x5a, -0x49(%rbp)
jmp 0xde609
cmpb $0x0, -0x49(%rbp)
je 0xde64e
movq -0x10(%rbp), %rax
addq $0x2, %rax
cmpq -0x48(%rbp), %rax
jbe 0xde626
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
jmp 0xde68f
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x5c, (%rax)
movb -0x49(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0xde67c
movq -0x10(%rbp), %rax
addq $0x1, %rax
cmpq -0x48(%rbp), %rax
jbe 0xde665
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
jmp 0xde68f
movq -0x20(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0xde67e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xde4f2
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| escape_string_for_mysql:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_58], rax
cmp [rbp+var_18], 0
jz short loc_DE4C5
mov rax, [rbp+var_18]
sub rax, 1
mov [rbp+var_60], rax
jmp short loc_DE4D0
loc_DE4C5:
mov rax, [rbp+var_28]
shl rax, 1
mov [rbp+var_60], rax
loc_DE4D0:
mov rax, [rbp+var_58]
mov rcx, [rbp+var_60]
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
mov byte ptr [rax], 0
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_40], rax
loc_DE4F2:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_40]
jnb loc_DE68F
mov [rbp+var_49], 0
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_40]
call my_ci_charlen
mov [rbp+var_50], eax
cmp [rbp+var_50], 1
jle short loc_DE582
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_50]
add rax, rcx
cmp rax, [rbp+var_48]
jbe short loc_DE53B
mov rax, [rbp+var_30]
mov byte ptr [rax], 1
jmp loc_DE68F
loc_DE53B:
jmp short $+2
loc_DE53D:
mov eax, [rbp+var_50]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_50], ecx
cmp eax, 0
jz short loc_DE571
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 1
mov [rbp+var_20], rcx
mov cl, [rax]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
jmp short loc_DE53D
loc_DE571:
mov rax, [rbp+var_20]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_20], rax
jmp loc_DE67E
loc_DE582:
cmp [rbp+var_50], 1
jge short loc_DE593
mov rax, [rbp+var_20]
mov al, [rax]
mov [rbp+var_49], al
jmp short loc_DE609
loc_DE593:
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
mov [rbp+var_64], eax
test eax, eax
jz short loc_DE5DF
jmp short $+2
loc_DE5A3:
mov eax, [rbp+var_64]
sub eax, 0Ah
jz short loc_DE5E5
jmp short $+2
loc_DE5AD:
mov eax, [rbp+var_64]
sub eax, 0Dh
jz short loc_DE5EB
jmp short $+2
loc_DE5B7:
mov eax, [rbp+var_64]
sub eax, 1Ah
jz short loc_DE603
jmp short $+2
loc_DE5C1:
mov eax, [rbp+var_64]
sub eax, 22h ; '"'
jz short loc_DE5FD
jmp short $+2
loc_DE5CB:
mov eax, [rbp+var_64]
sub eax, 27h ; '''
jz short loc_DE5F7
jmp short $+2
loc_DE5D5:
mov eax, [rbp+var_64]
sub eax, 5Ch ; '\'
jz short loc_DE5F1
jmp short loc_DE607
loc_DE5DF:
mov [rbp+var_49], 30h ; '0'
jmp short loc_DE607
loc_DE5E5:
mov [rbp+var_49], 6Eh ; 'n'
jmp short loc_DE607
loc_DE5EB:
mov [rbp+var_49], 72h ; 'r'
jmp short loc_DE607
loc_DE5F1:
mov [rbp+var_49], 5Ch ; '\'
jmp short loc_DE607
loc_DE5F7:
mov [rbp+var_49], 27h ; '''
jmp short loc_DE607
loc_DE5FD:
mov [rbp+var_49], 22h ; '"'
jmp short loc_DE607
loc_DE603:
mov [rbp+var_49], 5Ah ; 'Z'
loc_DE607:
jmp short $+2
loc_DE609:
cmp [rbp+var_49], 0
jz short loc_DE64E
mov rax, [rbp+var_10]
add rax, 2
cmp rax, [rbp+var_48]
jbe short loc_DE626
mov rax, [rbp+var_30]
mov byte ptr [rax], 1
jmp short loc_DE68F
loc_DE626:
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 5Ch ; '\'
mov cl, [rbp+var_49]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
jmp short loc_DE67C
loc_DE64E:
mov rax, [rbp+var_10]
add rax, 1
cmp rax, [rbp+var_48]
jbe short loc_DE665
mov rax, [rbp+var_30]
mov byte ptr [rax], 1
jmp short loc_DE68F
loc_DE665:
mov rax, [rbp+var_20]
mov cl, [rax]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
loc_DE67C:
jmp short $+2
loc_DE67E:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp loc_DE4F2
loc_DE68F:
mov rax, [rbp+var_10]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov rcx, [rbp+var_38]
sub rax, rcx
add rsp, 70h
pop rbp
retn
| _BYTE * escape_string_for_mysql(long long a1, char *a2, long long a3, char *a4, long long a5, _BYTE *a6)
{
char *v7; // rax
char v8; // cl
char *v9; // rax
char *v10; // rax
char *v11; // rax
int v13; // [rsp+Ch] [rbp-64h]
long long v14; // [rsp+10h] [rbp-60h]
int v15; // [rsp+20h] [rbp-50h]
char v16; // [rsp+27h] [rbp-49h]
unsigned long long v17; // [rsp+28h] [rbp-48h]
unsigned long long v18; // [rsp+30h] [rbp-40h]
char *v20; // [rsp+50h] [rbp-20h]
char *v21; // [rsp+60h] [rbp-10h]
v21 = a2;
v20 = a4;
if ( a3 )
v14 = a3 - 1;
else
v14 = 2 * a5;
v17 = (unsigned long long)&a2[v14];
*a6 = 0;
v18 = (unsigned long long)&a4[a5];
while ( (unsigned long long)v20 < v18 )
{
v16 = 0;
v15 = my_ci_charlen(a1, v20, v18);
if ( v15 <= 1 )
{
if ( v15 >= 1 )
{
v13 = *v20;
if ( *v20 )
{
switch ( v13 )
{
case 10:
v16 = 110;
break;
case 13:
v16 = 114;
break;
case 26:
v16 = 90;
break;
case 34:
v16 = 34;
break;
case 39:
v16 = 39;
break;
case 92:
v16 = 92;
break;
}
}
else
{
v16 = 48;
}
}
else
{
v16 = *v20;
}
if ( v16 )
{
if ( (unsigned long long)(v21 + 2) > v17 )
{
*a6 = 1;
break;
}
*v21 = 92;
v10 = v21 + 1;
v21 += 2;
*v10 = v16;
}
else
{
if ( (unsigned long long)(v21 + 1) > v17 )
{
*a6 = 1;
break;
}
v11 = v21++;
*v11 = *v20;
}
}
else
{
if ( (unsigned long long)&v21[v15] > v17 )
{
*a6 = 1;
break;
}
while ( v15-- )
{
v7 = v20++;
v8 = *v7;
v9 = v21++;
*v9 = v8;
}
--v20;
}
++v20;
}
*v21 = 0;
return (_BYTE *)(v21 - a2);
}
| escape_string_for_mysql:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x58],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001de4c5
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001de4d0
LAB_001de4c5:
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
LAB_001de4d0:
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x60]
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
LAB_001de4f2:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001de68f
MOV byte ptr [RBP + -0x49],0x0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x001de6b0
MOV dword ptr [RBP + -0x50],EAX
CMP dword ptr [RBP + -0x50],0x1
JLE 0x001de582
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x50]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x48]
JBE 0x001de53b
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],0x1
JMP 0x001de68f
LAB_001de53b:
JMP 0x001de53d
LAB_001de53d:
MOV EAX,dword ptr [RBP + -0x50]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x50],ECX
CMP EAX,0x0
JZ 0x001de571
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x20],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
JMP 0x001de53d
LAB_001de571:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001de67e
LAB_001de582:
CMP dword ptr [RBP + -0x50],0x1
JGE 0x001de593
MOV RAX,qword ptr [RBP + -0x20]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x49],AL
JMP 0x001de609
LAB_001de593:
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x64],EAX
TEST EAX,EAX
JZ 0x001de5df
JMP 0x001de5a3
LAB_001de5a3:
MOV EAX,dword ptr [RBP + -0x64]
SUB EAX,0xa
JZ 0x001de5e5
JMP 0x001de5ad
LAB_001de5ad:
MOV EAX,dword ptr [RBP + -0x64]
SUB EAX,0xd
JZ 0x001de5eb
JMP 0x001de5b7
LAB_001de5b7:
MOV EAX,dword ptr [RBP + -0x64]
SUB EAX,0x1a
JZ 0x001de603
JMP 0x001de5c1
LAB_001de5c1:
MOV EAX,dword ptr [RBP + -0x64]
SUB EAX,0x22
JZ 0x001de5fd
JMP 0x001de5cb
LAB_001de5cb:
MOV EAX,dword ptr [RBP + -0x64]
SUB EAX,0x27
JZ 0x001de5f7
JMP 0x001de5d5
LAB_001de5d5:
MOV EAX,dword ptr [RBP + -0x64]
SUB EAX,0x5c
JZ 0x001de5f1
JMP 0x001de607
LAB_001de5df:
MOV byte ptr [RBP + -0x49],0x30
JMP 0x001de607
LAB_001de5e5:
MOV byte ptr [RBP + -0x49],0x6e
JMP 0x001de607
LAB_001de5eb:
MOV byte ptr [RBP + -0x49],0x72
JMP 0x001de607
LAB_001de5f1:
MOV byte ptr [RBP + -0x49],0x5c
JMP 0x001de607
LAB_001de5f7:
MOV byte ptr [RBP + -0x49],0x27
JMP 0x001de607
LAB_001de5fd:
MOV byte ptr [RBP + -0x49],0x22
JMP 0x001de607
LAB_001de603:
MOV byte ptr [RBP + -0x49],0x5a
LAB_001de607:
JMP 0x001de609
LAB_001de609:
CMP byte ptr [RBP + -0x49],0x0
JZ 0x001de64e
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x48]
JBE 0x001de626
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],0x1
JMP 0x001de68f
LAB_001de626:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x5c
MOV CL,byte ptr [RBP + -0x49]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
JMP 0x001de67c
LAB_001de64e:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x48]
JBE 0x001de665
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],0x1
JMP 0x001de68f
LAB_001de665:
MOV RAX,qword ptr [RBP + -0x20]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
LAB_001de67c:
JMP 0x001de67e
LAB_001de67e:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001de4f2
LAB_001de68f:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
SUB RAX,RCX
ADD RSP,0x70
POP RBP
RET
|
long escape_string_for_mysql
(int8 param_1,char *param_2,long param_3,char *param_4,long param_5,
int1 *param_6)
{
char cVar1;
char *pcVar2;
long local_68;
int local_58;
char local_51;
char *local_28;
char *local_18;
if (param_3 == 0) {
local_68 = param_5 << 1;
}
else {
local_68 = param_3 + -1;
}
pcVar2 = param_2 + local_68;
*param_6 = 0;
local_28 = param_4;
local_18 = param_2;
do {
if (param_4 + param_5 <= local_28) {
LAB_001de68f:
*local_18 = '\0';
return (long)local_18 - (long)param_2;
}
local_51 = '\0';
local_58 = my_ci_charlen(param_1,local_28,param_4 + param_5);
if (local_58 < 2) {
if (local_58 < 1) {
local_51 = *local_28;
}
else {
cVar1 = *local_28;
if (cVar1 == '\0') {
local_51 = '0';
}
else if (cVar1 == '\n') {
local_51 = 'n';
}
else if (cVar1 == '\r') {
local_51 = 'r';
}
else if (cVar1 == '\x1a') {
local_51 = 'Z';
}
else if (cVar1 == '\"') {
local_51 = '\"';
}
else if (cVar1 == '\'') {
local_51 = '\'';
}
else if (cVar1 == '\\') {
local_51 = '\\';
}
}
if (local_51 == '\0') {
if (pcVar2 < local_18 + 1) {
*param_6 = 1;
goto LAB_001de68f;
}
*local_18 = *local_28;
local_18 = local_18 + 1;
}
else {
if (pcVar2 < local_18 + 2) {
*param_6 = 1;
goto LAB_001de68f;
}
*local_18 = '\\';
local_18[1] = local_51;
local_18 = local_18 + 2;
}
}
else {
if (pcVar2 < local_18 + local_58) {
*param_6 = 1;
goto LAB_001de68f;
}
while (local_58 != 0) {
*local_18 = *local_28;
local_58 = local_58 + -1;
local_28 = local_28 + 1;
local_18 = local_18 + 1;
}
local_28 = local_28 + -1;
}
local_28 = local_28 + 1;
} while( true );
}
| |
26,330 | rtree_get_first | eloqsql/storage/myisam/rt_index.c | int rtree_get_first(MI_INFO *info, uint keynr, uint key_length)
{
my_off_t root;
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
if ((root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
info->rtree_recursion_depth = -1;
info->buff_used = 1;
return rtree_get_req(info, keyinfo, key_length, root, 0);
} | O0 | c | rtree_get_first:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, %rax
jne 0xc8cc1
callq 0xf6080
movl $0x89, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc8cf4
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x3c0(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movb $0x1, 0x33d(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
xorl %r8d, %r8d
callq 0xc8d00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| rtree_get_first:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_14]
imul rcx, 70h ; 'p'
add rax, rcx
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+98h]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8]
mov [rbp+var_20], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_C8CC1
call _my_thread_var
mov dword ptr [rax], 89h
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_C8CF4
loc_C8CC1:
mov rax, [rbp+var_10]
mov dword ptr [rax+3C0h], 0FFFFFFFFh
mov rax, [rbp+var_10]
mov byte ptr [rax+33Dh], 1
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov edx, [rbp+var_18]
mov rcx, [rbp+var_20]
xor r8d, r8d
call rtree_get_req
mov [rbp+var_4], eax
loc_C8CF4:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long rtree_get_first(long long a1, const char *a2, unsigned int a3)
{
long long v4; // [rsp+8h] [rbp-28h]
long long v5; // [rsp+10h] [rbp-20h]
v4 = 112LL * (unsigned int)a2 + *(_QWORD *)(*(_QWORD *)a1 + 536LL);
v5 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 152LL) + 8LL * (unsigned int)a2);
if ( v5 == -1 )
{
*(_DWORD *)my_thread_var(a1, a2) = 137;
return (unsigned int)-1;
}
else
{
*(_DWORD *)(a1 + 960) = -1;
*(_BYTE *)(a1 + 829) = 1;
return (unsigned int)rtree_get_req(a1, v4, a3, v5, 0LL);
}
}
| rtree_get_first:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,-0x1
JNZ 0x001c8cc1
CALL 0x001f6080
MOV dword ptr [RAX],0x89
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c8cf4
LAB_001c8cc1:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x3c0],0xffffffff
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33d],0x1
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
XOR R8D,R8D
CALL 0x001c8d00
MOV dword ptr [RBP + -0x4],EAX
LAB_001c8cf4:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 rtree_get_first(long *param_1,uint param_2,int4 param_3)
{
long lVar1;
long lVar2;
int4 *puVar3;
int4 local_c;
lVar1 = *(long *)(*param_1 + 0x218);
lVar2 = *(long *)(*(long *)(*param_1 + 0x98) + (ulong)param_2 * 8);
if (lVar2 == -1) {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
local_c = 0xffffffff;
}
else {
*(int4 *)(param_1 + 0x78) = 0xffffffff;
*(int1 *)((long)param_1 + 0x33d) = 1;
local_c = rtree_get_req(param_1,lVar1 + (ulong)param_2 * 0x70,param_3,lVar2,0);
}
return local_c;
}
| |
26,331 | void nlohmann::json_abi_v3_11_3::detail::from_json<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::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> const&, 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>::string_t&) | monkey531[P]llama/common/./json.hpp | inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
{
if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
{
JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
}
s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
} | O3 | cpp | void nlohmann::json_abi_v3_11_3::detail::from_json<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::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> const&, 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>::string_t&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0x25c38
movq 0x8(%r14), %rax
movq %rsi, %rdi
movq %rax, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x19410
movl $0x20, %edi
callq 0x193b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x25242
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x8b1b9(%rip), %rsi # 0xb0e15
leaq 0x10(%rsp), %rdi
callq 0x25e99
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x25cce
xorl %ebp, %ebp
leaq 0xc0259(%rip), %rsi # 0xe5ee0
leaq -0x1ee6(%rip), %rdx # 0x23da8
movq %rbx, %rdi
callq 0x19da0
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25cb4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x197b0
testb %bpl, %bpl
jne 0x25cbe
jmp 0x25cc6
movq %rax, %r14
movq %rbx, %rdi
callq 0x19570
movq %r14, %rdi
callq 0x19e10
| _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEvRKT_RNSG_8string_tE:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 3
jnz short loc_25C38
mov rax, [r14+8]
mov rdi, rsi
mov rsi, rax
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
loc_25C38:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; 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>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aTypeMustBeStri; "type must be string, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonISt3mapSt6vectorNSt7__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_25CB4
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_25CB4:
test bpl, bpl
jnz short loc_25CBE
jmp short loc_25CC6
mov r14, rax
loc_25CBE:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_25CC6:
mov rdi, r14
call __Unwind_Resume
| from_json<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>>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x3
JNZ 0x00125c38
MOV RAX,qword ptr [R14 + 0x8]
MOV RDI,RSI
MOV RSI,RAX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP 0x00119410
LAB_00125c38:
MOV EDI,0x20
CALL 0x001193b0
MOV RBX,RAX
MOV RDI,R14
CALL 0x00125242
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_00125c55:
LEA RSI,[0x1b0e15]
LEA RDI,[RSP + 0x10]
CALL 0x00125e99
MOV BPL,0x1
LAB_00125c69:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x00125cce
XOR EBP,EBP
LEA RSI,[0x1e5ee0]
LEA RDX,[0x123da8]
MOV RDI,RBX
CALL 0x00119da0
|
/* void
nlohmann::json_abi_v3_11_3::detail::from_json<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::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> const&, 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>::string_t&) */
void nlohmann::json_abi_v3_11_3::detail::
from_json<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>>
(basic_json *param_1,string_t *param_2)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*param_1 == (basic_json)0x3) {
std::__cxx11::string::_M_assign((string *)param_2);
return;
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)basic_json<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>
::type_name((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>
*)param_1);
/* try { // try from 00125c55 to 00125c65 has its CatchHandler @ 00125cbb */
concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be string, but is ",&local_40);
/* try { // try from 00125c69 to 00125c95 has its CatchHandler @ 00125c96 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&type_error::typeinfo,exception::~exception);
}
| ||
26,332 | ColorToInt | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c | int ColorToInt(Color color)
{
int result = 0;
result = (int)(((unsigned int)color.r << 24) |
((unsigned int)color.g << 16) |
((unsigned int)color.b << 8) |
(unsigned int)color.a);
return result;
} | O0 | c | ColorToInt:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movzbl -0x4(%rbp), %eax
shll $0x18, %eax
movzbl -0x3(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movzbl -0x2(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl -0x1(%rbp), %ecx
orl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ColorToInt:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], 0
movzx eax, byte ptr [rbp+var_4]
shl eax, 18h
movzx ecx, byte ptr [rbp+var_4+1]
shl ecx, 10h
or eax, ecx
movzx ecx, byte ptr [rbp+var_4+2]
shl ecx, 8
or eax, ecx
movzx ecx, byte ptr [rbp+var_4+3]
or eax, ecx
mov [rbp+var_8], eax
mov eax, [rbp+var_8]
pop rbp
retn
| long long ColorToInt(unsigned int a1)
{
return _byteswap_ulong(a1);
}
| |||
26,333 | ColorToInt | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c | int ColorToInt(Color color)
{
int result = 0;
result = (int)(((unsigned int)color.r << 24) |
((unsigned int)color.g << 16) |
((unsigned int)color.b << 8) |
(unsigned int)color.a);
return result;
} | O3 | c | ColorToInt:
movl %edi, %eax
bswapl %eax
retq
| ColorToInt:
mov eax, edi
bswap eax
retn
| long long ColorToInt(unsigned int a1)
{
return _byteswap_ulong(a1);
}
| ColorToInt:
MOV EAX,EDI
BSWAP EAX
RET
|
uint ColorToInt(uint param_1)
{
return param_1 >> 0x18 | (param_1 & 0xff0000) >> 8 | (param_1 & 0xff00) << 8 | param_1 << 0x18;
}
| |
26,334 | my_utf8mb3_uni_no_range | eloqsql/strings/ctype-utf8.c | static int my_utf8mb3_uni_no_range(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t * pwc, const uchar *s)
{
uchar c;
c= s[0];
if (c < 0x80)
{
*pwc = c;
return 1;
}
if (c < 0xc2)
return MY_CS_ILSEQ;
if (c < 0xe0)
{
if (!((s[1] ^ 0x80) < 0x40))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
if (c < 0xf0)
{
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
return MY_CS_ILSEQ;
} | O0 | c | my_utf8mb3_uni_no_range:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x80, %eax
jge 0x65bfd
movzbl -0x21(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x65d13
movzbl -0x21(%rbp), %eax
cmpl $0xc2, %eax
jge 0x65c14
movl $0x0, -0x4(%rbp)
jmp 0x65d13
movzbl -0x21(%rbp), %eax
cmpl $0xe0, %eax
jge 0x65c70
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jl 0x65c3d
movl $0x0, -0x4(%rbp)
jmp 0x65d13
movzbl -0x21(%rbp), %eax
andl $0x1f, %eax
movslq %eax, %rcx
shlq $0x6, %rcx
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x65d13
movzbl -0x21(%rbp), %eax
cmpl $0xf0, %eax
jge 0x65d0c
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x65cbd
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x65cbd
movzbl -0x21(%rbp), %eax
cmpl $0xe1, %eax
jge 0x65cc6
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa0, %eax
jge 0x65cc6
movl $0x0, -0x4(%rbp)
jmp 0x65d13
movzbl -0x21(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
shlq $0xc, %rcx
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0x6, %rax
orq %rax, %rcx
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x65d13
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| my_utf8mb3_uni_no_range:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_20]
mov al, [rax]
mov [rbp+var_21], al
movzx eax, [rbp+var_21]
cmp eax, 80h
jge short loc_65BFD
movzx eax, [rbp+var_21]
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_65D13
loc_65BFD:
movzx eax, [rbp+var_21]
cmp eax, 0C2h
jge short loc_65C14
mov [rbp+var_4], 0
jmp loc_65D13
loc_65C14:
movzx eax, [rbp+var_21]
cmp eax, 0E0h
jge short loc_65C70
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jl short loc_65C3D
mov [rbp+var_4], 0
jmp loc_65D13
loc_65C3D:
movzx eax, [rbp+var_21]
and eax, 1Fh
movsxd rcx, eax
shl rcx, 6
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 2
jmp loc_65D13
loc_65C70:
movzx eax, [rbp+var_21]
cmp eax, 0F0h
jge loc_65D0C
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_65CBD
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_65CBD
movzx eax, [rbp+var_21]
cmp eax, 0E1h
jge short loc_65CC6
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0A0h
jge short loc_65CC6
loc_65CBD:
mov [rbp+var_4], 0
jmp short loc_65D13
loc_65CC6:
movzx eax, [rbp+var_21]
and eax, 0Fh
movsxd rcx, eax
shl rcx, 0Ch
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
shl rax, 6
or rcx, rax
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 3
jmp short loc_65D13
loc_65D0C:
mov [rbp+var_4], 0
loc_65D13:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_utf8mb3_uni_no_range(long long a1, unsigned long long *a2, unsigned __int8 *a3)
{
unsigned __int8 v4; // [rsp+1h] [rbp-21h]
v4 = *a3;
if ( *a3 >= 0x80u )
{
if ( v4 >= 0xC2u )
{
if ( v4 >= 0xE0u )
{
if ( v4 >= 0xF0u )
{
return 0;
}
else if ( (a3[1] ^ 0x80) < 64 && (a3[2] ^ 0x80) < 64 && (v4 >= 0xE1u || a3[1] >= 0xA0u) )
{
*a2 = a3[2] ^ 0x80u | ((long long)(a3[1] ^ 0x80u) << 6) | ((unsigned long long)(v4 & 0xF) << 12);
return 3;
}
else
{
return 0;
}
}
else if ( (a3[1] ^ 0x80) < 64 )
{
*a2 = a3[1] ^ 0x80u | ((unsigned long long)(v4 & 0x1F) << 6);
return 2;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
else
{
*a2 = v4;
return 1;
}
}
| my_utf8mb3_uni_no_range:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x20]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x21],AL
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0x80
JGE 0x00165bfd
MOVZX EAX,byte ptr [RBP + -0x21]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00165d13
LAB_00165bfd:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xc2
JGE 0x00165c14
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00165d13
LAB_00165c14:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe0
JGE 0x00165c70
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JL 0x00165c3d
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00165d13
LAB_00165c3d:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0x1f
MOVSXD RCX,EAX
SHL RCX,0x6
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00165d13
LAB_00165c70:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf0
JGE 0x00165d0c
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x00165cbd
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x00165cbd
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe1
JGE 0x00165cc6
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa0
JGE 0x00165cc6
LAB_00165cbd:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00165d13
LAB_00165cc6:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0xf
MOVSXD RCX,EAX
SHL RCX,0xc
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
SHL RAX,0x6
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x3
JMP 0x00165d13
LAB_00165d0c:
MOV dword ptr [RBP + -0x4],0x0
LAB_00165d13:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_utf8mb3_uni_no_range(int8 param_1,ulong *param_2,byte *param_3)
{
byte bVar1;
int4 local_c;
bVar1 = *param_3;
if (bVar1 < 0x80) {
*param_2 = (ulong)bVar1;
local_c = 1;
}
else if (bVar1 < 0xc2) {
local_c = 0;
}
else if (bVar1 < 0xe0) {
if ((param_3[1] ^ 0x80) < 0x40) {
*param_2 = (long)(int)(bVar1 & 0x1f) << 6 | (long)(int)(param_3[1] ^ 0x80);
local_c = 2;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf0) {
if ((((param_3[1] ^ 0x80) < 0x40) && ((param_3[2] ^ 0x80) < 0x40)) &&
((0xe0 < bVar1 || (0x9f < param_3[1])))) {
*param_2 = (long)(int)(bVar1 & 0xf) << 0xc | (long)(int)(param_3[1] ^ 0x80) << 6 |
(long)(int)(param_3[2] ^ 0x80);
local_c = 3;
}
else {
local_c = 0;
}
}
else {
local_c = 0;
}
return local_c;
}
| |
26,335 | ftxui::(anonymous namespace)::InputBase::Text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/component/input.cpp | Element Text(const std::string& input) {
if (!password()) {
return text(input);
}
std::string out;
out.reserve(10 + input.size() * 3 / 2);
for (size_t i = 0; i < input.size(); ++i) {
out += "•";
}
return text(out);
} | O1 | cpp | ftxui::(anonymous namespace)::InputBase::Text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x98(%rsi), %rdi
callq 0x2ce58
cmpb $0x0, (%rax)
je 0x2be7a
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq 0x8(%r14), %rax
leaq (%rax,%rax,2), %rsi
shrq %rsi
addq $0xa, %rsi
leaq 0x8(%rsp), %rdi
callq 0xb6a0
cmpq $0x0, 0x8(%r14)
je 0x2be25
xorl %ebp, %ebp
leaq 0x13a13(%rip), %r15 # 0x3f81f
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xb7f0
incq %rbp
cmpq 0x8(%r14), %rbp
jb 0x2be11
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x11e4e
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x252d4
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x2be69
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb400
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2bebc
movq 0x18(%rsp), %rsi
jmp 0x2beb4
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x11e4e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x252d4
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x2bebc
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb400
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x2bf03
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb400
jmp 0x2bf03
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x2bf1a
movq 0x58(%rsp), %rsi
jmp 0x2bf12
jmp 0x2bf00
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2bf1a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb400
movq %rbx, %rdi
callq 0xb780
| _ZN5ftxui12_GLOBAL__N_19InputBase4TextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, rdx
mov rbx, rdi
lea rdi, [rsi+98h]
call _ZN5ftxui3RefIbE7AddressEv; ftxui::Ref<bool>::Address(void)
cmp byte ptr [rax], 0
jz loc_2BE7A
lea r13, [rsp+98h+var_80]
mov [r13-10h], r13
mov qword ptr [r13-8], 0
mov byte ptr [r13+0], 0
mov rax, [r14+8]
lea rsi, [rax+rax*2]
shr rsi, 1
add rsi, 0Ah
lea rdi, [rsp+98h+var_90]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
cmp qword ptr [r14+8], 0
jz short loc_2BE25
xor ebp, ebp
lea r15, unk_3F81F
lea r12, [rsp+98h+var_90]
loc_2BE11:
mov rdi, r12
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
inc rbp
cmp rbp, [r14+8]
jb short loc_2BE11
loc_2BE25:
lea r14, [rsp+98h+var_60]
mov [r14-10h], r14
mov rsi, [rsp+98h+var_90]
mov rdx, [rsp+98h+var_88]
add rdx, rsi
lea rdi, [rsp+98h+var_70]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rsi, [rsp+98h+var_70]
mov rdi, rbx
call _ZN5ftxui4textENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; ftxui::text(std::string)
mov rdi, [rsp+98h+var_70]; void *
cmp rdi, r14
jz short loc_2BE69
mov rsi, [rsp+98h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2BE69:
mov rdi, [rsp+98h+var_90]
cmp rdi, r13
jz short loc_2BEBC
mov rsi, [rsp+98h+var_80]
jmp short loc_2BEB4
loc_2BE7A:
lea r15, [rsp+98h+var_40]
mov [r15-10h], r15
mov rsi, [r14]
mov rdx, [r14+8]
add rdx, rsi
lea r14, [rsp+98h+var_50]
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rdi, rbx
mov rsi, r14
call _ZN5ftxui4textENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; ftxui::text(std::string)
mov rdi, [rsp+98h+var_50]; void *
cmp rdi, r15
jz short loc_2BEBC
mov rsi, [rsp+98h+var_40]
loc_2BEB4:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2BEBC:
mov rax, rbx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_20]; void *
cmp rdi, r14
jz short loc_2BF03
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2BF03
mov rbx, rax
mov rdi, [rsp+arg_40]
cmp rdi, r15
jz short loc_2BF1A
mov rsi, [rsp+arg_50]
jmp short loc_2BF12
jmp short $+2
loc_2BF00:
mov rbx, rax
loc_2BF03:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r13
jz short loc_2BF1A
mov rsi, [rsp+arg_10]
loc_2BF12:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2BF1A:
mov rdi, rbx
call __Unwind_Resume
| ftxui::Node ** ftxui::`anonymous namespace'::InputBase::Text(ftxui::Node **a1, long long a2, long long a3)
{
unsigned long long v5; // rbp
_BYTE *v6; // rdi
long long v7; // rsi
_BYTE *v9; // [rsp+8h] [rbp-90h] BYREF
long long v10; // [rsp+10h] [rbp-88h]
_QWORD v11[2]; // [rsp+18h] [rbp-80h] BYREF
void *v12[2]; // [rsp+28h] [rbp-70h] BYREF
_QWORD v13[2]; // [rsp+38h] [rbp-60h] BYREF
void *v14[2]; // [rsp+48h] [rbp-50h] BYREF
_QWORD v15[8]; // [rsp+58h] [rbp-40h] BYREF
if ( *(_BYTE *)ftxui::Ref<bool>::Address(a2 + 152) )
{
v9 = v11;
v10 = 0LL;
LOBYTE(v11[0]) = 0;
std::string::reserve(&v9, ((unsigned long long)(3LL * *(_QWORD *)(a3 + 8)) >> 1) + 10);
if ( *(_QWORD *)(a3 + 8) )
{
v5 = 0LL;
do
{
std::string::append(&v9, &unk_3F81F);
++v5;
}
while ( v5 < *(_QWORD *)(a3 + 8) );
}
v12[0] = v13;
std::string::_M_construct<char *>(v12, v9, (long long)&v9[v10]);
ftxui::text(a1, (long long)v12);
if ( v12[0] != v13 )
operator delete(v12[0], v13[0] + 1LL);
v6 = v9;
if ( v9 != (_BYTE *)v11 )
{
v7 = v11[0];
LABEL_11:
operator delete(v6, v7 + 1);
}
}
else
{
v14[0] = v15;
std::string::_M_construct<char *>(v14, *(_BYTE **)a3, *(_QWORD *)a3 + *(_QWORD *)(a3 + 8));
ftxui::text(a1, (long long)v14);
v6 = v14[0];
if ( v14[0] != v15 )
{
v7 = v15[0];
goto LABEL_11;
}
}
return a1;
}
| Text:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RDX
MOV RBX,RDI
LEA RDI,[RSI + 0x98]
CALL 0x0012ce58
CMP byte ptr [RAX],0x0
JZ 0x0012be7a
LEA R13,[RSP + 0x18]
MOV qword ptr [R13 + -0x10],R13
MOV qword ptr [R13 + -0x8],0x0
MOV byte ptr [R13],0x0
MOV RAX,qword ptr [R14 + 0x8]
LEA RSI,[RAX + RAX*0x2]
SHR RSI,0x1
ADD RSI,0xa
LAB_0012bdf2:
LEA RDI,[RSP + 0x8]
CALL 0x0010b6a0
CMP qword ptr [R14 + 0x8],0x0
JZ 0x0012be25
XOR EBP,EBP
LEA R15,[0x13f81f]
LEA R12,[RSP + 0x8]
LAB_0012be11:
MOV RDI,R12
MOV RSI,R15
CALL 0x0010b7f0
INC RBP
CMP RBP,qword ptr [R14 + 0x8]
JC 0x0012be11
LAB_0012be25:
LEA R14,[RSP + 0x38]
MOV qword ptr [R14 + -0x10],R14
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
ADD RDX,RSI
LAB_0012be3b:
LEA RDI,[RSP + 0x28]
CALL 0x00111e4e
LAB_0012be45:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x001252d4
LAB_0012be52:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R14
JZ 0x0012be69
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0010b400
LAB_0012be69:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R13
JZ 0x0012bebc
MOV RSI,qword ptr [RSP + 0x18]
JMP 0x0012beb4
LAB_0012be7a:
LEA R15,[RSP + 0x58]
MOV qword ptr [R15 + -0x10],R15
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
ADD RDX,RSI
LEA R14,[RSP + 0x48]
MOV RDI,R14
CALL 0x00111e4e
LAB_0012be9a:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001252d4
LAB_0012bea5:
MOV RDI,qword ptr [RSP + 0x48]
CMP RDI,R15
JZ 0x0012bebc
MOV RSI,qword ptr [RSP + 0x58]
LAB_0012beb4:
INC RSI
CALL 0x0010b400
LAB_0012bebc:
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ftxui::(anonymous namespace)::InputBase::Text(std::__cxx11::string const&) */
string * ftxui::(anonymous_namespace)::InputBase::Text(string *param_1)
{
char *pcVar1;
long *in_RDX;
ulong uVar2;
long in_RSI;
long *plVar3;
long *local_90;
long local_88;
int1 local_80;
int7 uStack_7f;
long *local_70 [2];
long local_60 [2];
long *local_50 [2];
long local_40 [2];
pcVar1 = (char *)Ref<bool>::Address((Ref<bool> *)(in_RSI + 0x98));
if (*pcVar1 == '\0') {
local_50[0] = local_40;
std::__cxx11::string::_M_construct<char*>(local_50,*in_RDX,in_RDX[1] + *in_RDX);
/* try { // try from 0012be9a to 0012bea4 has its CatchHandler @ 0012beea */
text((ftxui *)param_1,local_50);
plVar3 = local_50[0];
if (local_50[0] == local_40) {
return param_1;
}
}
else {
local_88 = 0;
local_80 = 0;
/* try { // try from 0012bdf2 to 0012bdfb has its CatchHandler @ 0012befe */
local_90 = (long *)&local_80;
std::__cxx11::string::reserve((ulong)&local_90);
if (in_RDX[1] != 0) {
uVar2 = 0;
do {
/* try { // try from 0012be11 to 0012be1b has its CatchHandler @ 0012bf00 */
std::__cxx11::string::append((char *)&local_90);
uVar2 = uVar2 + 1;
} while (uVar2 < (ulong)in_RDX[1]);
}
/* try { // try from 0012be3b to 0012be44 has its CatchHandler @ 0012befe */
local_70[0] = local_60;
std::__cxx11::string::_M_construct<char*>
(local_70,local_90,(int1 *)(local_88 + (long)local_90));
/* try { // try from 0012be45 to 0012be51 has its CatchHandler @ 0012bece */
text((ftxui *)param_1,local_70);
if (local_70[0] != local_60) {
operator_delete(local_70[0],local_60[0] + 1);
}
if (local_90 == (long *)&local_80) {
return param_1;
}
local_40[0] = CONCAT71(uStack_7f,local_80);
plVar3 = local_90;
}
operator_delete(plVar3,local_40[0] + 1);
return param_1;
}
| |
26,336 | json_append_ascii | eloqsql/strings/json_lib.c | int json_append_ascii(CHARSET_INFO *json_cs,
uchar *json, uchar *json_end,
const uchar *ascii, const uchar *ascii_end)
{
const uchar *json_start= json;
while (ascii < ascii_end)
{
int c_len;
if ((c_len= my_ci_wc_mb(json_cs, (my_wc_t) *ascii, json, json_end)) > 0)
{
json+= c_len;
ascii++;
continue;
}
/* Error return. */
return c_len;
}
return (int)(json - json_start);
} | O3 | c | json_append_ascii:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, -0x30(%rbp)
cmpq %r14, %r12
jae 0x27b11
movq 0xb8(%rbx), %rax
movzbl (%r12), %esi
movq %rbx, %rdi
movq %r15, %rdx
movq %r13, %rcx
callq *0x30(%rax)
movl %eax, %ecx
addq %rcx, %r15
incq %r12
testl %eax, %eax
jg 0x27ae6
jmp 0x27b18
subl -0x30(%rbp), %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| json_append_ascii:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r12, rcx
mov r13, rdx
mov r15, rsi
mov rbx, rdi
mov [rbp+var_30], rsi
loc_27AE6:
cmp r12, r14
jnb short loc_27B11
mov rax, [rbx+0B8h]
movzx esi, byte ptr [r12]
mov rdi, rbx
mov rdx, r15
mov rcx, r13
call qword ptr [rax+30h]
mov ecx, eax
add r15, rcx
inc r12
test eax, eax
jg short loc_27AE6
jmp short loc_27B18
loc_27B11:
sub r15d, dword ptr [rbp+var_30]
mov eax, r15d
loc_27B18:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long json_append_ascii(long long a1, long long a2, long long a3, unsigned __int8 *a4, unsigned long long a5)
{
long long v8; // r15
long long result; // rax
v8 = a2;
while ( (unsigned long long)a4 < a5 )
{
result = (*(long long ( **)(long long, _QWORD, long long, long long))(*(_QWORD *)(a1 + 184) + 48LL))(
a1,
*a4,
v8,
a3);
v8 += (unsigned int)result;
++a4;
if ( (int)result <= 0 )
return result;
}
return (unsigned int)(v8 - a2);
}
| json_append_ascii:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R12,RCX
MOV R13,RDX
MOV R15,RSI
MOV RBX,RDI
MOV qword ptr [RBP + -0x30],RSI
LAB_00127ae6:
CMP R12,R14
JNC 0x00127b11
MOV RAX,qword ptr [RBX + 0xb8]
MOVZX ESI,byte ptr [R12]
MOV RDI,RBX
MOV RDX,R15
MOV RCX,R13
CALL qword ptr [RAX + 0x30]
MOV ECX,EAX
ADD R15,RCX
INC R12
TEST EAX,EAX
JG 0x00127ae6
JMP 0x00127b18
LAB_00127b11:
SUB R15D,dword ptr [RBP + -0x30]
MOV EAX,R15D
LAB_00127b18:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong json_append_ascii(long param_1,long param_2,int8 param_3,int1 *param_4,
int1 *param_5)
{
ulong uVar1;
long lVar2;
int local_38;
lVar2 = param_2;
do {
if (param_5 <= param_4) {
local_38 = (int)param_2;
return (ulong)(uint)((int)lVar2 - local_38);
}
uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x30))(param_1,*param_4,lVar2,param_3);
lVar2 = lVar2 + (uVar1 & 0xffffffff);
param_4 = param_4 + 1;
} while (0 < (int)uVar1);
return uVar1;
}
| |
26,337 | bf_isqrt | bluesky950520[P]quickjs/libbf.c | limb_t bf_isqrt(limb_t a)
{
limb_t s, r;
int k;
if (a == 0)
return 0;
k = clz(a) & ~1;
s = mp_sqrtrem1(&r, a << k);
s >>= (k >> 1);
return s;
} | O0 | c | bf_isqrt:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xe824c
movq $0x0, 0x20(%rsp)
jmp 0xe8299
movq 0x18(%rsp), %rdi
callq 0xe4ea0
andl $-0x2, %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rsi
movl 0x4(%rsp), %eax
movl %eax, %ecx
shlq %cl, %rsi
leaq 0x8(%rsp), %rdi
callq 0xe82b0
movq %rax, 0x10(%rsp)
movl 0x4(%rsp), %ecx
sarl %ecx
movq 0x10(%rsp), %rax
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| bf_isqrt:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
cmp [rsp+28h+var_10], 0
jnz short loc_E824C
mov [rsp+28h+var_8], 0
jmp short loc_E8299
loc_E824C:
mov rdi, [rsp+28h+var_10]
call clz
and eax, 0FFFFFFFEh
mov [rsp+28h+var_24], eax
mov rsi, [rsp+28h+var_10]
mov eax, [rsp+28h+var_24]
mov ecx, eax
shl rsi, cl
lea rdi, [rsp+28h+var_20]
call mp_sqrtrem1
mov [rsp+28h+var_18], rax
mov ecx, [rsp+28h+var_24]
sar ecx, 1
mov rax, [rsp+28h+var_18]
mov ecx, ecx
shr rax, cl
mov [rsp+28h+var_18], rax
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_8], rax
loc_E8299:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
| unsigned long long bf_isqrt(long long a1)
{
int v1; // eax
_BYTE v3[8]; // [rsp+8h] [rbp-20h] BYREF
long long v5; // [rsp+18h] [rbp-10h]
v5 = a1;
if ( !a1 )
return 0LL;
v1 = clz(v5);
return (unsigned long long)mp_sqrtrem1(v3, v5 << (v1 & 0xFE)) >> ((int)(v1 & 0xFFFFFFFE) >> 1);
}
| bf_isqrt:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
CMP qword ptr [RSP + 0x18],0x0
JNZ 0x001e824c
MOV qword ptr [RSP + 0x20],0x0
JMP 0x001e8299
LAB_001e824c:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001e4ea0
AND EAX,0xfffffffe
MOV dword ptr [RSP + 0x4],EAX
MOV RSI,qword ptr [RSP + 0x18]
MOV EAX,dword ptr [RSP + 0x4]
MOV ECX,EAX
SHL RSI,CL
LEA RDI,[RSP + 0x8]
CALL 0x001e82b0
MOV qword ptr [RSP + 0x10],RAX
MOV ECX,dword ptr [RSP + 0x4]
SAR ECX,0x1
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,ECX
SHR RAX,CL
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x20],RAX
LAB_001e8299:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
ulong bf_isqrt(long param_1)
{
int iVar1;
int1 local_20 [16];
long local_10;
ulong local_8;
if (param_1 == 0) {
local_8 = 0;
}
else {
local_10 = param_1;
iVar1 = clz(param_1);
local_8 = mp_sqrtrem1(local_20,local_10 << ((byte)iVar1 & 0x3e));
local_8 = local_8 >> ((byte)(iVar1 >> 1) & 0x3f);
}
return local_8;
}
| |
26,338 | bf_isqrt | bluesky950520[P]quickjs/libbf.c | limb_t bf_isqrt(limb_t a)
{
limb_t s, r;
int k;
if (a == 0)
return 0;
k = clz(a) & ~1;
s = mp_sqrtrem1(&r, a << k);
s >>= (k >> 1);
return s;
} | O3 | c | bf_isqrt:
testq %rdi, %rdi
je 0x88f65
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rsi
bsrq %rdi, %rbx
xorq $0x3f, %rbx
movl %ebx, %ecx
andb $0x3e, %cl
shlq %cl, %rsi
leaq 0x8(%rsp), %rdi
callq 0x88f68
shrl %ebx
movl %ebx, %ecx
shrq %cl, %rax
addq $0x10, %rsp
popq %rbx
retq
xorl %eax, %eax
retq
| bf_isqrt:
test rdi, rdi
jz short loc_88F65
push rbx
sub rsp, 10h
mov rsi, rdi
bsr rbx, rdi
xor rbx, 3Fh
mov ecx, ebx
and cl, 3Eh
shl rsi, cl
lea rdi, [rsp+18h+var_10]
call mp_sqrtrem1
shr ebx, 1
mov ecx, ebx
shr rax, cl
add rsp, 10h
pop rbx
retn
loc_88F65:
xor eax, eax
retn
| unsigned long long bf_isqrt(unsigned long long a1)
{
unsigned long long v1; // rbx
_BYTE v3[16]; // [rsp+0h] [rbp-10h] BYREF
if ( !a1 )
return 0LL;
_BitScanReverse64(&v1, a1);
return (unsigned long long)mp_sqrtrem1(v3, a1 << ((v1 ^ 0x3F) & 0x3E)) >> (((unsigned int)v1 ^ 0x3F) >> 1);
}
| bf_isqrt:
TEST RDI,RDI
JZ 0x00188f65
PUSH RBX
SUB RSP,0x10
MOV RSI,RDI
BSR RBX,RDI
XOR RBX,0x3f
MOV ECX,EBX
AND CL,0x3e
SHL RSI,CL
LEA RDI,[RSP + 0x8]
CALL 0x00188f68
SHR EBX,0x1
MOV ECX,EBX
SHR RAX,CL
ADD RSP,0x10
POP RBX
RET
LAB_00188f65:
XOR EAX,EAX
RET
|
ulong bf_isqrt(ulong param_1)
{
ulong uVar1;
ulong uVar2;
int1 auStack_10 [8];
if (param_1 != 0) {
uVar1 = 0x3f;
if (param_1 != 0) {
for (; param_1 >> uVar1 == 0; uVar1 = uVar1 - 1) {
}
}
uVar2 = mp_sqrtrem1(auStack_10,param_1 << ((byte)(uVar1 ^ 0x3f) & 0x3e));
return uVar2 >> ((byte)((uint)(uVar1 ^ 0x3f) >> 1) & 0x3f);
}
return 0;
}
| |
26,339 | set_prealloc_root | eloqsql/mysys/my_alloc.c | void set_prealloc_root(MEM_ROOT *root, char *ptr)
{
USED_MEM *next;
for (next=root->used; next ; next=next->next)
{
if ((char*) next <= ptr && (char*) next + next->size > ptr)
{
root->pre_alloc=next;
return;
}
}
for (next=root->free ; next ; next=next->next)
{
if ((char*) next <= ptr && (char*) next + next->size > ptr)
{
root->pre_alloc=next;
return;
}
}
} | O3 | c | set_prealloc_root:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x37106
cmpq %rsi, %rax
ja 0x37101
movq 0x10(%rax), %rcx
addq %rax, %rcx
cmpq %rsi, %rcx
ja 0x37124
movq (%rax), %rax
jmp 0x370eb
movq (%rdi), %rax
testq %rax, %rax
je 0x37128
cmpq %rsi, %rax
ja 0x3711f
movq 0x10(%rax), %rcx
addq %rax, %rcx
cmpq %rsi, %rcx
ja 0x37124
movq (%rax), %rax
jmp 0x37109
movq %rax, 0x10(%rdi)
popq %rbp
retq
| set_prealloc_root:
push rbp
mov rbp, rsp
mov rax, [rdi+8]
loc_370EB:
test rax, rax
jz short loc_37106
cmp rax, rsi
ja short loc_37101
mov rcx, [rax+10h]
add rcx, rax
cmp rcx, rsi
ja short loc_37124
loc_37101:
mov rax, [rax]
jmp short loc_370EB
loc_37106:
mov rax, [rdi]
loc_37109:
test rax, rax
jz short loc_37128
cmp rax, rsi
ja short loc_3711F
mov rcx, [rax+10h]
add rcx, rax
cmp rcx, rsi
ja short loc_37124
loc_3711F:
mov rax, [rax]
jmp short loc_37109
loc_37124:
mov [rdi+10h], rax
loc_37128:
pop rbp
retn
| _QWORD * set_prealloc_root(_QWORD *a1, unsigned long long a2)
{
_QWORD *result; // rax
for ( result = (_QWORD *)a1[1]; result; result = (_QWORD *)*result )
{
if ( (unsigned long long)result <= a2 && (unsigned long long)result + result[2] > a2 )
{
LABEL_11:
a1[2] = result;
return result;
}
}
for ( result = (_QWORD *)*a1; result; result = (_QWORD *)*result )
{
if ( (unsigned long long)result <= a2 && (unsigned long long)result + result[2] > a2 )
goto LABEL_11;
}
return result;
}
| set_prealloc_root:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI + 0x8]
LAB_001370eb:
TEST RAX,RAX
JZ 0x00137106
CMP RAX,RSI
JA 0x00137101
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,RAX
CMP RCX,RSI
JA 0x00137124
LAB_00137101:
MOV RAX,qword ptr [RAX]
JMP 0x001370eb
LAB_00137106:
MOV RAX,qword ptr [RDI]
LAB_00137109:
TEST RAX,RAX
JZ 0x00137128
CMP RAX,RSI
JA 0x0013711f
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,RAX
CMP RCX,RSI
JA 0x00137124
LAB_0013711f:
MOV RAX,qword ptr [RAX]
JMP 0x00137109
LAB_00137124:
MOV qword ptr [RDI + 0x10],RAX
LAB_00137128:
POP RBP
RET
|
void set_prealloc_root(int8 *param_1,int8 *param_2)
{
int8 *puVar1;
for (puVar1 = (int8 *)param_1[1]; puVar1 != (int8 *)0x0;
puVar1 = (int8 *)*puVar1) {
if ((puVar1 <= param_2) && (param_2 < (int8 *)(puVar1[2] + (long)puVar1)))
goto LAB_00137124;
}
puVar1 = (int8 *)*param_1;
while( true ) {
if (puVar1 == (int8 *)0x0) {
return;
}
if ((puVar1 <= param_2) && (param_2 < (int8 *)(puVar1[2] + (long)puVar1))) break;
puVar1 = (int8 *)*puVar1;
}
LAB_00137124:
param_1[2] = puVar1;
return;
}
| |
26,340 | LefDefParser::defiIOTiming::clear() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiIOTiming.cpp | void defiIOTiming::clear() {
hasVariableRise_ = 0;
hasVariableFall_ = 0;
hasSlewRise_ = 0;
hasSlewFall_ = 0;
hasCapacitance_ = 0;
hasDriveCell_ = 0;
hasFrom_ = 0;
hasTo_ = 0;
hasParallel_ = 0;
variableFallMin_ = 0.0;
variableRiseMin_ = 0.0;
variableFallMax_ = 0.0;
variableRiseMax_ = 0.0;
slewFallMin_ = 0.0;
slewRiseMin_ = 0.0;
slewFallMax_ = 0.0;
slewRiseMax_ = 0.0;
capacitance_ = 0.0;
parallel_ = 0.0;
} | O0 | cpp | LefDefParser::defiIOTiming::clear():
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x0, 0x49(%rax)
movb $0x0, 0x4a(%rax)
movb $0x0, 0x4b(%rax)
movb $0x0, 0x4c(%rax)
movb $0x0, 0x4d(%rax)
movb $0x0, 0x4e(%rax)
movb $0x0, 0x4f(%rax)
movb $0x0, 0x50(%rax)
movb $0x0, 0x51(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x58(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x78(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x80(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x88(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x90(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x98(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xa0(%rax)
retq
nop
| _ZN12LefDefParser12defiIOTiming5clearEv:
mov [rsp+var_8], rdi
mov rax, [rsp+var_8]
mov byte ptr [rax+49h], 0
mov byte ptr [rax+4Ah], 0
mov byte ptr [rax+4Bh], 0
mov byte ptr [rax+4Ch], 0
mov byte ptr [rax+4Dh], 0
mov byte ptr [rax+4Eh], 0
mov byte ptr [rax+4Fh], 0
mov byte ptr [rax+50h], 0
mov byte ptr [rax+51h], 0
xorps xmm0, xmm0
movsd qword ptr [rax+58h], xmm0
xorps xmm0, xmm0
movsd qword ptr [rax+60h], xmm0
xorps xmm0, xmm0
movsd qword ptr [rax+68h], xmm0
xorps xmm0, xmm0
movsd qword ptr [rax+70h], xmm0
xorps xmm0, xmm0
movsd qword ptr [rax+78h], xmm0
xorps xmm0, xmm0
movsd qword ptr [rax+80h], xmm0
xorps xmm0, xmm0
movsd qword ptr [rax+88h], xmm0
xorps xmm0, xmm0
movsd qword ptr [rax+90h], xmm0
xorps xmm0, xmm0
movsd qword ptr [rax+98h], xmm0
xorps xmm0, xmm0
movsd qword ptr [rax+0A0h], xmm0
retn
| LefDefParser::defiIOTiming * LefDefParser::defiIOTiming::clear(LefDefParser::defiIOTiming *this)
{
LefDefParser::defiIOTiming *result; // rax
result = this;
*((_BYTE *)this + 73) = 0;
*((_BYTE *)this + 74) = 0;
*((_BYTE *)this + 75) = 0;
*((_BYTE *)this + 76) = 0;
*((_BYTE *)this + 77) = 0;
*((_BYTE *)this + 78) = 0;
*((_BYTE *)this + 79) = 0;
*((_BYTE *)this + 80) = 0;
*((_BYTE *)this + 81) = 0;
*((_QWORD *)this + 11) = 0LL;
*((_QWORD *)this + 12) = 0LL;
*((_QWORD *)this + 13) = 0LL;
*((_QWORD *)this + 14) = 0LL;
*((_QWORD *)this + 15) = 0LL;
*((_QWORD *)this + 16) = 0LL;
*((_QWORD *)this + 17) = 0LL;
*((_QWORD *)this + 18) = 0LL;
*((_QWORD *)this + 19) = 0LL;
*((_QWORD *)this + 20) = 0LL;
return result;
}
| clear:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
MOV byte ptr [RAX + 0x49],0x0
MOV byte ptr [RAX + 0x4a],0x0
MOV byte ptr [RAX + 0x4b],0x0
MOV byte ptr [RAX + 0x4c],0x0
MOV byte ptr [RAX + 0x4d],0x0
MOV byte ptr [RAX + 0x4e],0x0
MOV byte ptr [RAX + 0x4f],0x0
MOV byte ptr [RAX + 0x50],0x0
MOV byte ptr [RAX + 0x51],0x0
XORPS XMM0,XMM0
MOVSD qword ptr [RAX + 0x58],XMM0
XORPS XMM0,XMM0
MOVSD qword ptr [RAX + 0x60],XMM0
XORPS XMM0,XMM0
MOVSD qword ptr [RAX + 0x68],XMM0
XORPS XMM0,XMM0
MOVSD qword ptr [RAX + 0x70],XMM0
XORPS XMM0,XMM0
MOVSD qword ptr [RAX + 0x78],XMM0
XORPS XMM0,XMM0
MOVSD qword ptr [RAX + 0x80],XMM0
XORPS XMM0,XMM0
MOVSD qword ptr [RAX + 0x88],XMM0
XORPS XMM0,XMM0
MOVSD qword ptr [RAX + 0x90],XMM0
XORPS XMM0,XMM0
MOVSD qword ptr [RAX + 0x98],XMM0
XORPS XMM0,XMM0
MOVSD qword ptr [RAX + 0xa0],XMM0
RET
|
/* LefDefParser::defiIOTiming::clear() */
void __thiscall LefDefParser::defiIOTiming::clear(defiIOTiming *this)
{
this[0x49] = (defiIOTiming)0x0;
this[0x4a] = (defiIOTiming)0x0;
this[0x4b] = (defiIOTiming)0x0;
this[0x4c] = (defiIOTiming)0x0;
this[0x4d] = (defiIOTiming)0x0;
this[0x4e] = (defiIOTiming)0x0;
this[0x4f] = (defiIOTiming)0x0;
this[0x50] = (defiIOTiming)0x0;
this[0x51] = (defiIOTiming)0x0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x70) = 0;
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
*(int8 *)(this + 0x90) = 0;
*(int8 *)(this + 0x98) = 0;
*(int8 *)(this + 0xa0) = 0;
return;
}
| |
26,341 | mysql_autocommit_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_autocommit_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_autocommit,
(parms->mysql, parms->auto_mode),
parms->mysql,
my_bool,
r_my_bool)
} | O0 | c | mysql_autocommit_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %esi
callq 0xaa140
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| mysql_autocommit_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
movsx esi, byte ptr [rax+8]
call mysql_autocommit
mov [rbp+var_11], al
mov cl, [rbp+var_11]
mov rax, [rbp+var_20]
mov [rax+8], cl
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| long long mysql_autocommit_start_internal(long long a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-20h]
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
*(_BYTE *)(v2 + 8) = mysql_autocommit(*(_QWORD *)a1, *(_BYTE *)(a1 + 8));
result = v2;
*(_DWORD *)v2 = 0;
return result;
}
| mysql_autocommit_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOVSX ESI,byte ptr [RAX + 0x8]
CALL 0x001aa140
MOV byte ptr [RBP + -0x11],AL
MOV CL,byte ptr [RBP + -0x11]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x8],CL
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_autocommit_start_internal(long *param_1)
{
int4 *puVar1;
int1 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_autocommit(*param_1,(int)(char)param_1[1]);
*(int1 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
| |
26,342 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<bool&>(bool&, bool) | llama.cpp/common/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O3 | cpp | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<bool&>(bool&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x9942f
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
leaq (%rax,%rcx,8), %rax
leaq 0x3f(%r15), %rcx
andq %rdx, %rcx
xorl %esi, %esi
cmpq %r15, %rcx
setbe %sil
movq -0x8(%rax,%rsi,8), %rax
btq %rdx, %rax
jae 0x992c2
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x92a5c
movq %r14, %rdi
movl $0x1, %esi
callq 0x92a5c
testb %bpl, %bpl
jne 0x9926f
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x99450
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x99403
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x992cc
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x99403
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x99326
cmpl $0x2, %ecx
jne 0x99455
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x96872
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x993ff
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x9941f
leaq 0x10(%rsp), %r14
movups (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x92a5c
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x92a5c
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x94bc8
movq %r15, %rdi
xorl %esi, %esi
callq 0x92a5c
movq %r15, %rdi
callq 0x97176
movq (%rbx), %r14
jmp 0x993ff
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %ecx
cmpq %rax, 0x48(%rbx)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x99463
movl %ecx, %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r15), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r15, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0x99398
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x99403
cmpq $0x0, 0x70(%rbx)
je 0x99484
leaq 0x10(%rsp), %r14
movups (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x92a5c
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x92a5c
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x94bc8
movq %r15, %rdi
xorl %esi, %esi
callq 0x92a5c
movq %r15, %rdi
callq 0x97176
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x99408
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x92a5c
movq %r15, %rdi
callq 0x97176
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8e4e3(%rip), %rdi # 0x127919
leaq 0x8671b(%rip), %rdx # 0x11fb58
leaq 0x8f42b(%rip), %rcx # 0x12886f
movl $0x1c28, %esi # imm = 0x1C28
xorl %eax, %eax
callq 0x21ef0
callq 0x22350
leaq 0x8f427(%rip), %rcx # 0x128883
movl $0x1c4b, %esi # imm = 0x1C4B
jmp 0x9946f
leaq 0x8f457(%rip), %rcx # 0x1288c1
movl $0x1c57, %esi # imm = 0x1C57
leaq 0x8e4a3(%rip), %rdi # 0x127919
leaq 0x866db(%rip), %rdx # 0x11fb58
xorl %eax, %eax
callq 0x21ef0
leaq 0x8e48e(%rip), %rdi # 0x127919
leaq 0x866c6(%rip), %rdx # 0x11fb58
leaq 0x8f440(%rip), %rcx # 0x1288d9
movl $0x1c60, %esi # imm = 0x1C60
xorl %eax, %eax
callq 0x21ef0
jmp 0x994a7
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x92a5c
movq %r14, %rdi
callq 0x97176
movq %rbx, %rdi
callq 0x21b70
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIDnEESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov ebp, edx
mov rax, [rdi+30h]
mov ecx, [rdi+38h]
cmp [rdi+20h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_9942F
mov ecx, ecx
mov r15, 8000000000000000h
lea rdx, [rcx-1]
add rcx, 3Eh ; '>'
test rdx, rdx
cmovns rcx, rdx
sar rcx, 6
lea rax, [rax+rcx*8]
lea rcx, [r15+3Fh]
and rcx, rdx
xor esi, esi
cmp rcx, r15
setbe sil
mov rax, [rax+rsi*8-8]
bt rax, rdx
jnb loc_992C2
mov rbx, rdi
lea r14, [rsp+68h+var_58]
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
test bpl, bpl
jnz short loc_9926F
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+68h+var_5C], eax
mov [rsp+68h+var_5D], 5
cmp qword ptr [rbx+90h], 0
jz loc_99450
lea rdi, [rbx+80h]
lea rsi, [rsp+68h+var_5C]
lea rdx, [rsp+68h+var_5D]
lea rcx, [rsp+68h+var_58]
call qword ptr [rbx+98h]
test al, al
jz loc_99403
loc_9926F:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_992CC
mov rax, [rax-8]
test rax, rax
jz loc_99403
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_99326
cmp ecx, 2
jnz loc_99455
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_993FF
loc_992C2:
xor ebx, ebx
xor r14d, r14d
jmp loc_9941F
loc_992CC:
lea r14, [rsp+68h+var_58]
movups xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_38]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx]
jmp loc_993FF
loc_99326:
mov rax, [rbx+58h]
mov ecx, [rbx+60h]
cmp [rbx+48h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_99463
mov esi, ecx
lea rcx, [rsi-1]
mov rdx, rsi
add rdx, 3Eh ; '>'
test rcx, rcx
cmovns rdx, rcx
sar rdx, 6
lea rdi, [rax+rdx*8]
lea rdx, [r15+3Fh]
and rdx, rcx
xor r8d, r8d
cmp rdx, r15
setbe r8b
mov edx, 1
shl rdx, cl
and rdx, [rdi+r8*8-8]
sub esi, 1
mov [rbx+60h], esi
jnb short loc_99398
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_99398:
test rdx, rdx
jz short loc_99403
cmp qword ptr [rbx+70h], 0
jz loc_99484
lea r14, [rsp+68h+var_58]
movups xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_48]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx+70h]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx+70h]
loc_993FF:
mov bl, 1
jmp short loc_99408
loc_99403:
xor ebx, ebx
xor r14d, r14d
loc_99408:
lea r15, [rsp+68h+var_58]
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_9941F:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_9942F:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1C28h
xor eax, eax
call _ggml_abort
loc_99450:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_99455:
lea rcx, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
mov esi, 1C4Bh
jmp short loc_9946F
loc_99463:
lea rcx, aKeyKeepStackEm; "!key_keep_stack.empty()"
mov esi, 1C57h
loc_9946F:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
xor eax, eax
call _ggml_abort
loc_99484:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aObjectElement; "object_element"
mov esi, 1C60h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_994A7:
mov rbx, rax
lea r14, [rsp+68h+var_58]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::handle_value<decltype(nullptr)>(
long long a1,
long long a2,
char a3)
{
long long v4; // rax
unsigned int v5; // ecx
signed long long v6; // rdx
long long v7; // rcx
long long v8; // rax
unsigned int v9; // ebx
long long v10; // rax
unsigned __int8 *v11; // rax
int v12; // ecx
long long v13; // rax
unsigned int v14; // ecx
long long v15; // rsi
long long v16; // rcx
long long v17; // rdx
long long v18; // rdx
const char *v20; // rcx
long long v21; // rsi
long long v22; // rax
long long v23; // rbx
char v24; // [rsp+Bh] [rbp-5Dh] BYREF
int v25; // [rsp+Ch] [rbp-5Ch] BYREF
__int128 v26; // [rsp+10h] [rbp-58h] BYREF
__int128 v27; // [rsp+20h] [rbp-48h] BYREF
_OWORD v28[3]; // [rsp+30h] [rbp-38h] BYREF
v4 = *(_QWORD *)(a1 + 48);
v5 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v4 && v5 == 0 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7208LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
goto LABEL_28;
}
v6 = v5 - 1LL;
v7 = v5 + 62LL;
if ( v6 >= 0 )
v7 = v6;
v8 = *(_QWORD *)(v4 + 8 * (v7 >> 6) + 8LL * ((v6 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8);
if ( _bittest64(&v8, v6) )
{
v9 = a1;
LOBYTE(v26) = 0;
*((_QWORD *)&v26 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&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>::assert_invariant((char *)&v26);
if ( a3 )
{
LABEL_8:
v10 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v10 )
{
v28[0] = 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>::assert_invariant((char *)&v26);
LOBYTE(v26) = 0;
*((_QWORD *)&v26 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v28);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)a1,
(long long)v28);
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 *)v28);
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(v28);
goto LABEL_23;
}
v11 = *(unsigned __int8 **)(v10 - 8);
if ( v11 )
{
v12 = *v11;
if ( v12 != 1 )
{
if ( v12 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*((_QWORD *)v11 + 1),
(long long)&v26);
LABEL_23:
LOBYTE(v9) = 1;
LABEL_25:
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&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);
return v9;
}
v20 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
v21 = 7243LL;
goto LABEL_31;
}
v13 = *(_QWORD *)(a1 + 88);
v14 = *(_DWORD *)(a1 + 96);
if ( *(_QWORD *)(a1 + 72) == v13 && v14 == 0 )
{
v20 = "!key_keep_stack.empty()";
v21 = 7255LL;
LABEL_31:
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp", v21, "GGML_ASSERT(%s) failed", v20);
goto LABEL_32;
}
v15 = v14;
v16 = v14 - 1LL;
v17 = v15 + 62;
if ( v16 >= 0 )
v17 = v16;
v18 = *(_QWORD *)(v13 + 8 * (v17 >> 6) + 8LL * ((v16 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8) & (1LL << v16);
*(_DWORD *)(a1 + 96) = v15 - 1;
if ( !(_DWORD)v15 )
{
*(_DWORD *)(a1 + 96) = 63;
*(_QWORD *)(a1 + 88) = v13 - 8;
}
if ( v18 )
{
if ( *(_QWORD *)(a1 + 112) )
{
v27 = 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>::assert_invariant((char *)&v26);
LOBYTE(v26) = 0;
*((_QWORD *)&v26 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&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>::operator=(
*(_QWORD *)(a1 + 112),
(long long)&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>::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);
goto LABEL_23;
}
LABEL_32:
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7264LL,
"GGML_ASSERT(%s) failed",
"object_element");
v23 = v22;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&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);
_Unwind_Resume(v23);
}
}
LABEL_24:
v9 = 0;
goto LABEL_25;
}
v25 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v24 = 5;
if ( *(_QWORD *)(a1 + 144) )
{
if ( !(*(unsigned __int8 ( **)(long long, int *, char *, __int128 *))(a1 + 152))(
a1 + 128,
&v25,
&v24,
&v26) )
goto LABEL_24;
goto LABEL_8;
}
LABEL_28:
std::__throw_bad_function_call();
}
return 0;
}
| handle_value<decltype(nullptr)>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV EBP,EDX
MOV RAX,qword ptr [RDI + 0x30]
MOV ECX,dword ptr [RDI + 0x38]
CMP qword ptr [RDI + 0x20],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x0019942f
MOV ECX,ECX
MOV R15,-0x8000000000000000
LEA RDX,[RCX + -0x1]
ADD RCX,0x3e
TEST RDX,RDX
CMOVNS RCX,RDX
SAR RCX,0x6
LEA RAX,[RAX + RCX*0x8]
LEA RCX,[R15 + 0x3f]
AND RCX,RDX
XOR ESI,ESI
CMP RCX,R15
SETBE SIL
MOV RAX,qword ptr [RAX + RSI*0x8 + -0x8]
BT RAX,RDX
JNC 0x001992c2
MOV RBX,RDI
LEA R14,[RSP + 0x10]
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x00192a5c
MOV RDI,R14
MOV ESI,0x1
CALL 0x00192a5c
TEST BPL,BPL
JNZ 0x0019926f
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x5
CMP qword ptr [RBX + 0x90],0x0
JZ 0x00199450
LEA RDI,[RBX + 0x80]
LAB_00199252:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x00199403
LAB_0019926f:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x001992cc
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x00199403
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x00199326
CMP ECX,0x2
JNZ 0x00199455
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x00196872
LAB_001992a9:
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x001993ff
LAB_001992c2:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0019941f
LAB_001992cc:
LEA R14,[RSP + 0x10]
MOVUPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x30]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00192a5c
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00192a5c
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x00194bc8
MOV RDI,R15
XOR ESI,ESI
CALL 0x00192a5c
MOV RDI,R15
CALL 0x00197176
MOV R14,qword ptr [RBX]
JMP 0x001993ff
LAB_00199326:
MOV RAX,qword ptr [RBX + 0x58]
MOV ECX,dword ptr [RBX + 0x60]
CMP qword ptr [RBX + 0x48],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x00199463
MOV ESI,ECX
LEA RCX,[RSI + -0x1]
MOV RDX,RSI
ADD RDX,0x3e
TEST RCX,RCX
CMOVNS RDX,RCX
SAR RDX,0x6
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[R15 + 0x3f]
AND RDX,RCX
XOR R8D,R8D
CMP RDX,R15
SETBE R8B
MOV EDX,0x1
SHL RDX,CL
AND RDX,qword ptr [RDI + R8*0x8 + -0x8]
SUB ESI,0x1
MOV dword ptr [RBX + 0x60],ESI
JNC 0x00199398
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_00199398:
TEST RDX,RDX
JZ 0x00199403
CMP qword ptr [RBX + 0x70],0x0
JZ 0x00199484
LEA R14,[RSP + 0x10]
MOVUPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x20]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00192a5c
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00192a5c
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x00194bc8
MOV RDI,R15
XOR ESI,ESI
CALL 0x00192a5c
MOV RDI,R15
CALL 0x00197176
MOV R14,qword ptr [RBX + 0x70]
LAB_001993ff:
MOV BL,0x1
JMP 0x00199408
LAB_00199403:
XOR EBX,EBX
XOR R14D,R14D
LAB_00199408:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x00192a5c
MOV RDI,R15
CALL 0x00197176
LAB_0019941f:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0019942f:
LEA RDI,[0x227919]
LEA RDX,[0x21fb58]
LEA RCX,[0x22886f]
MOV ESI,0x1c28
XOR EAX,EAX
CALL 0x00121ef0
LAB_00199450:
CALL 0x00122350
LAB_00199455:
LEA RCX,[0x228883]
MOV ESI,0x1c4b
JMP 0x0019946f
LAB_00199463:
LEA RCX,[0x2288c1]
MOV ESI,0x1c57
LAB_0019946f:
LEA RDI,[0x227919]
LEA RDX,[0x21fb58]
XOR EAX,EAX
CALL 0x00121ef0
LAB_00199484:
LEA RDI,[0x227919]
LEA RDX,[0x21fb58]
LEA RCX,[0x2288d9]
MOV ESI,0x1c60
XOR EAX,EAX
CALL 0x00121ef0
|
/* std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*>
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::handle_value<decltype(nullptr)>(decltype(nullptr)&&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::handle_value<decltype(nullptr)>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,_func_decltype_nullptr **param_1,bool param_2)
{
uint uVar1;
char cVar2;
ulong uVar3;
char *pcVar4;
ulong uVar5;
int8 uVar6;
bool bVar7;
long lVar8;
int1 auVar9 [16];
int1 local_5d;
int4 local_5c;
basic_json local_58;
int7 uStack_57;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
int8 uStack_30;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 == 0 && *(long *)(this + 0x20) == *(long *)(this + 0x30)) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x1c28,
"GGML_ASSERT(%s) failed","!keep_stack.empty()");
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
if ((*(ulong *)(*(long *)(this + 0x30) + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar5 & 0x3f) &
1) == 0) {
uVar5 = 0;
lVar8 = 0;
goto LAB_0019941f;
}
local_58 = (basic_json)0x0;
uStack_50 = 0;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
if (param_2) {
LAB_0019926f:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
local_38 = CONCAT71(uStack_57,local_58);
uStack_30 = uStack_50;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = (basic_json)0x0;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_38,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)this,(data *)&local_38);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_38);
lVar8 = *(long *)this;
}
else {
pcVar4 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar4 == (char *)0x0) goto LAB_00199403;
if (*pcVar4 == '\x01') {
lVar8 = *(long *)(this + 0x58);
uVar1 = *(uint *)(this + 0x60);
if (uVar1 == 0 && *(long *)(this + 0x48) == lVar8) {
pcVar4 = "!key_keep_stack.empty()";
uVar6 = 0x1c57;
goto LAB_0019946f;
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
uVar3 = *(ulong *)(lVar8 + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar1 - 1;
if (uVar1 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = lVar8 + -8;
}
if ((1L << ((byte)uVar5 & 0x3f) & uVar3) == 0) goto LAB_00199403;
if (*(long *)(this + 0x70) == 0) {
/* try { // try from 00199484 to 001994a4 has its CatchHandler @ 001994a5 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x1c60,
"GGML_ASSERT(%s) failed","object_element");
}
local_48 = CONCAT71(uStack_57,local_58);
uStack_40 = uStack_50;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = (basic_json)0x0;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_48,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(this + 0x70),(data *)&local_48);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_48);
lVar8 = *(long *)(this + 0x70);
}
else {
if (*pcVar4 != '\x02') {
pcVar4 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
uVar6 = 0x1c4b;
LAB_0019946f:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar4);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pcVar4 + 8),&local_58);
lVar8 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar5 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
local_5c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_5d = 5;
if (*(long *)(this + 0x90) == 0) {
/* WARNING: Subroutine does not return */
/* try { // try from 00199450 to 00199483 has its CatchHandler @ 001994a7 */
std::__throw_bad_function_call();
}
/* try { // try from 00199252 to 001992a8 has its CatchHandler @ 001994a7 */
cVar2 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,&local_58);
if (cVar2 != '\0') goto LAB_0019926f;
LAB_00199403:
uVar5 = 0;
lVar8 = 0;
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)&local_58,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_58);
LAB_0019941f:
auVar9._0_8_ = uVar5 & 0xffffffff;
auVar9._8_8_ = lVar8;
return auVar9;
}
| |
26,343 | my_wc_mb_utf8mb4 | eloqsql/strings/ctype-utf8.c | static int
my_wc_mb_utf8mb4(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *r, uchar *e)
{
int count;
if (r >= e)
return MY_CS_TOOSMALL;
if (wc < 0x80)
count= 1;
else if (wc < 0x800)
count= 2;
else if (wc < 0x10000)
count= 3;
else if (wc < 0x200000)
count= 4;
else return MY_CS_ILUNI;
if (r + count > e)
return MY_CS_TOOSMALLN(count);
switch (count) {
case 4: r[3] = (uchar) (0x80 | (wc & 0x3f)); wc = wc >> 6; wc |= 0x10000;
/* fall through */
case 3: r[2] = (uchar) (0x80 | (wc & 0x3f)); wc = wc >> 6; wc |= 0x800;
/* fall through */
case 2: r[1] = (uchar) (0x80 | (wc & 0x3f)); wc = wc >> 6; wc |= 0xc0;
/* fall through */
case 1: r[0] = (uchar) wc;
}
return count;
} | O3 | c | my_wc_mb_utf8mb4:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xcec28
movl $0x1, %edi
cmpq $0x80, %rsi
jb 0xcebc1
movl $0x2, %edi
cmpq $0x800, %rsi # imm = 0x800
jb 0xcebc1
movl $0x3, %edi
cmpq $0x10000, %rsi # imm = 0x10000
jb 0xcebc1
xorl %eax, %eax
movl $0x4, %edi
cmpq $0x1fffff, %rsi # imm = 0x1FFFFF
ja 0xcec28
movl %edi, %eax
addq %rdx, %rax
cmpq %rcx, %rax
jbe 0xcebd4
movl $0xffffff9c, %eax # imm = 0xFFFFFF9C
subl %edi, %eax
jmp 0xcec28
leal -0x1(%rdi), %eax
leaq 0x28a242(%rip), %rcx # 0x358e20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %esi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x3(%rdx)
shrq $0x6, %rsi
orq $0x10000, %rsi # imm = 0x10000
movl %esi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rdx)
shrq $0x6, %rsi
orq $0x800, %rsi # imm = 0x800
movl %esi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rdx)
shrq $0x6, %rsi
orq $0xc0, %rsi
movb %sil, (%rdx)
movl %edi, %eax
popq %rbp
retq
| my_wc_mb_utf8mb4:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb loc_CEC28
mov edi, 1
cmp rsi, 80h
jb short loc_CEBC1
mov edi, 2
cmp rsi, 800h
jb short loc_CEBC1
mov edi, 3
cmp rsi, offset stru_10000
jb short loc_CEBC1
xor eax, eax
mov edi, 4
cmp rsi, offset unk_1FFFFF
ja short loc_CEC28
loc_CEBC1:
mov eax, edi
add rax, rdx
cmp rax, rcx
jbe short loc_CEBD4
mov eax, 0FFFFFF9Ch
sub eax, edi
jmp short loc_CEC28
loc_CEBD4:
lea eax, [rdi-1]
lea rcx, jpt_CEBE5
movsxd rax, ds:(jpt_CEBE5 - 358E20h)[rcx+rax*4]; switch 4 cases
add rax, rcx
jmp rax; switch jump
loc_CEBE7:
mov eax, esi; jumptable 00000000000CEBE5 case 3
and al, 3Fh
or al, 80h
mov [rdx+3], al
shr rsi, 6
or rsi, 10000h
loc_CEBFB:
mov eax, esi; jumptable 00000000000CEBE5 case 2
and al, 3Fh
or al, 80h
mov [rdx+2], al
shr rsi, 6
or rsi, 800h
loc_CEC0F:
mov eax, esi; jumptable 00000000000CEBE5 case 1
and al, 3Fh
or al, 80h
mov [rdx+1], al
shr rsi, 6
or rsi, 0C0h
loc_CEC23:
mov [rdx], sil; jumptable 00000000000CEBE5 case 0
mov eax, edi
loc_CEC28:
pop rbp
retn
| long long my_wc_mb_utf8mb4(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
unsigned int v5; // edi
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = 1;
if ( a2 < 0x80
|| (v5 = 2, a2 < 0x800)
|| (v5 = 3, a2 < (unsigned long long)&stru_10000)
|| (result = 0LL, v5 = 4, a2 <= (unsigned long long)&unk_1FFFFF) )
{
if ( (unsigned long long)&a3[v5] <= a4 )
{
switch ( v5 )
{
case 1u:
goto LABEL_12;
case 2u:
goto LABEL_11;
case 3u:
goto LABEL_10;
case 4u:
a3[3] = a2 & 0x3F | 0x80;
a2 = (a2 >> 6) | 0x10000;
LABEL_10:
a3[2] = a2 & 0x3F | 0x80;
a2 = (a2 >> 6) | 0x800;
LABEL_11:
a3[1] = a2 & 0x3F | 0x80;
a2 = (a2 >> 6) | 0xC0;
LABEL_12:
*a3 = a2;
result = v5;
break;
}
}
else
{
return -100 - v5;
}
}
}
return result;
}
| my_wc_mb_utf8mb4:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001cec28
MOV EDI,0x1
CMP RSI,0x80
JC 0x001cebc1
MOV EDI,0x2
CMP RSI,0x800
JC 0x001cebc1
MOV EDI,0x3
CMP RSI,0x10000
JC 0x001cebc1
XOR EAX,EAX
MOV EDI,0x4
CMP RSI,0x1fffff
JA 0x001cec28
LAB_001cebc1:
MOV EAX,EDI
ADD RAX,RDX
CMP RAX,RCX
JBE 0x001cebd4
MOV EAX,0xffffff9c
SUB EAX,EDI
JMP 0x001cec28
LAB_001cebd4:
LEA EAX,[RDI + -0x1]
LEA RCX,[0x458e20]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
JMP RAX
LAB_001cec28:
POP RBP
RET
|
ulong my_wc_mb_utf8mb4(int8 param_1,ulong param_2,ulong param_3,ulong param_4)
{
ulong uVar1;
long lVar2;
uVar1 = 0xffffff9b;
if (param_3 < param_4) {
lVar2 = 1;
if ((((0x7f < param_2) && (lVar2 = 2, 0x7ff < param_2)) && (lVar2 = 3, 0xffff < param_2)) &&
(lVar2 = 4, 0x1fffff < param_2)) {
return 0;
}
if (lVar2 + param_3 <= param_4) {
/* WARNING: Could not recover jumptable at 0x001cebe5. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar1 = (*(code *)(&DAT_00458e20 + *(int *)(&DAT_00458e20 + (ulong)((int)lVar2 - 1) * 4)))();
return uVar1;
}
uVar1 = (ulong)(-(int)lVar2 - 100);
}
return uVar1;
}
| |
26,344 | mysql_stmt_prepare | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | int STDCALL mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query, unsigned long length)
{
MYSQL *mysql= stmt->mysql;
int rc= 1;
my_bool is_multi= 0;
if (!stmt->mysql)
{
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (length == (unsigned long) -1)
length= (unsigned long)strlen(query);
/* clear flags */
CLEAR_CLIENT_STMT_ERROR(stmt);
CLEAR_CLIENT_ERROR(stmt->mysql);
stmt->upsert_status.affected_rows= mysql->affected_rows= (unsigned long long) ~0;
/* check if we have to clear results */
if (stmt->state > MYSQL_STMT_INITTED)
{
char stmt_id[STMT_ID_LENGTH];
is_multi= (mysql->net.extension->multi_status > COM_MULTI_OFF);
/* We need to semi-close the prepared statement:
reset stmt and free all buffers and close the statement
on server side. Statement handle will get a new stmt_id */
if (!is_multi)
ma_multi_command(mysql, COM_MULTI_ENABLED);
if (mysql_stmt_internal_reset(stmt, 1))
goto fail;
ma_free_root(&stmt->mem_root, MYF(MY_KEEP_PREALLOC));
ma_free_root(&((MADB_STMT_EXTENSION *)stmt->extension)->fields_ma_alloc_root, MYF(0));
stmt->param_count= 0;
stmt->field_count= 0;
stmt->fields= NULL;
stmt->params= NULL;
int4store(stmt_id, stmt->stmt_id);
if (mysql->methods->db_command(mysql, COM_STMT_CLOSE, stmt_id,
sizeof(stmt_id), 1, stmt))
goto fail;
}
if (mysql->methods->db_command(mysql, COM_STMT_PREPARE, query, length, 1, stmt))
goto fail;
if (!is_multi && mysql->net.extension->multi_status == COM_MULTI_ENABLED)
if (ma_multi_command(mysql, COM_MULTI_END))
goto fail;
if (mysql->net.extension->multi_status > COM_MULTI_OFF ||
mysql->options.extension->skip_read_response)
return 0;
if (mysql->methods->db_read_prepare_response &&
mysql->methods->db_read_prepare_response(stmt))
goto fail;
return(0);
fail:
stmt->state= MYSQL_STMT_INITTED;
UPDATE_STMT_ERROR(stmt);
return(rc);
} | O3 | c | mysql_stmt_prepare:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x38(%rdi), %r14
testq %r14, %r14
je 0x651b0
movq %rdx, %r12
movq %rsi, %r15
cmpq $-0x1, %rdx
jne 0x650a9
movq %r15, %rdi
callq 0x3a4c0
movq %rax, %r12
xorl %eax, %eax
movl %eax, 0x108(%rbx)
movl $0x30303030, %ecx # imm = 0x30303030
movl %ecx, 0x30d(%rbx)
movw $0x30, %dx
movw %dx, 0x311(%rbx)
movb %al, 0x10c(%rbx)
movl %eax, 0x90(%r14)
movq 0x38(%rbx), %rsi
movw %dx, 0x29b(%rsi)
movl %ecx, 0x297(%rsi)
movq 0x38(%rbx), %rcx
movb %al, 0x97(%rcx)
movq 0x38(%rbx), %rax
movq 0x2a0(%rax), %rax
testq %rax, %rax
je 0x65106
movl $0x0, 0x4(%rax)
movq $-0x1, %rax
movq %rax, 0x338(%r14)
movq %rax, 0xf8(%rbx)
cmpl $0x0, 0x50(%rbx)
je 0x651f5
movq 0x2a0(%r14), %rax
cmpl $0x0, (%rax)
sete %r13b
jne 0x65142
movq %r14, %rdi
movl $0x2, %esi
callq 0x5a111
movq %rbx, %rdi
movl $0x1, %esi
callq 0x63db8
testb %al, %al
jne 0x65221
movq %rbx, %rdi
movl $0x1, %esi
callq 0x61f23
movq 0x340(%rbx), %rdi
xorl %esi, %esi
callq 0x61f23
movq $0x0, 0x70(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movl 0x40(%rbx), %eax
leaq -0x34(%rbp), %rdx
movl %eax, (%rdx)
movq 0x4d0(%r14), %rax
movl $0x4, %ecx
movq %r14, %rdi
movl $0x19, %esi
movl $0x1, %r8d
movq %rbx, %r9
callq *0x10(%rax)
testl %eax, %eax
jne 0x65221
jmp 0x651f8
movl $0x7dd, 0x108(%rbx) # imm = 0x7DD
leaq 0x30d(%rbx), %rdi
leaq 0x3088e8(%rip), %rax # 0x36dab0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x3a1a0
movb $0x0, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x3088d6(%rip), %rax # 0x36dac0
movq 0x68(%rax), %rsi
movl $0x200, %edx # imm = 0x200
jmp 0x6526f
movb $0x1, %r13b
movq 0x4d0(%r14), %rax
movq %r14, %rdi
movl $0x16, %esi
movq %r15, %rdx
movq %r12, %rcx
movl $0x1, %r8d
movq %rbx, %r9
callq *0x10(%rax)
testl %eax, %eax
je 0x652a2
leaq 0x30d(%rbx), %rdi
leaq 0x10c(%rbx), %r14
movl $0x0, 0x50(%rbx)
movq 0x38(%rbx), %rsi
movl 0x90(%rsi), %eax
movl %eax, 0x108(%rbx)
addq $0x297, %rsi # imm = 0x297
movl $0x5, %edx
callq 0x3a1a0
movb $0x0, 0x312(%rbx)
movl $0x97, %esi
addq 0x38(%rbx), %rsi
movl $0x200, %edx # imm = 0x200
movq %r14, %rdi
callq 0x3a1a0
movb $0x0, 0x30b(%rbx)
movl $0x1, %r15d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x65309
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb %r13b, %r13b
je 0x652c8
movq 0x2a0(%r14), %rax
cmpl $0x2, (%rax)
jne 0x652c8
movq %r14, %rdi
movl $0x4, %esi
callq 0x5a111
testl %eax, %eax
jne 0x65221
movq 0x2a0(%r14), %rax
xorl %r15d, %r15d
cmpl $0x0, (%rax)
jne 0x65281
movq 0x480(%r14), %rax
cmpb $0x0, 0x148(%rax)
jne 0x65281
movq 0x4d0(%r14), %rax
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x65281
movq %rbx, %rdi
callq *%rax
testb %al, %al
jne 0x65221
jmp 0x65281
callq 0x3a340
| mysql_stmt_prepare:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r14, [rdi+38h]
test r14, r14
jz loc_651B0
mov r12, rdx
mov r15, rsi
cmp rdx, 0FFFFFFFFFFFFFFFFh
jnz short loc_650A9
mov rdi, r15
call _strlen
mov r12, rax
loc_650A9:
xor eax, eax
mov [rbx+108h], eax
mov ecx, 30303030h
mov [rbx+30Dh], ecx
mov dx, 30h ; '0'
mov [rbx+311h], dx
mov [rbx+10Ch], al
mov [r14+90h], eax
mov rsi, [rbx+38h]
mov [rsi+29Bh], dx
mov [rsi+297h], ecx
mov rcx, [rbx+38h]
mov [rcx+97h], al
mov rax, [rbx+38h]
mov rax, [rax+2A0h]
test rax, rax
jz short loc_65106
mov dword ptr [rax+4], 0
loc_65106:
mov rax, 0FFFFFFFFFFFFFFFFh
mov [r14+338h], rax
mov [rbx+0F8h], rax
cmp dword ptr [rbx+50h], 0
jz loc_651F5
mov rax, [r14+2A0h]
cmp dword ptr [rax], 0
setz r13b
jnz short loc_65142
mov rdi, r14
mov esi, 2
call ma_multi_command
loc_65142:
mov rdi, rbx
mov esi, 1
call mysql_stmt_internal_reset
test al, al
jnz loc_65221
mov rdi, rbx
mov esi, 1
call ma_free_root
mov rdi, [rbx+340h]
xor esi, esi
call ma_free_root
mov qword ptr [rbx+70h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx+58h], xmm0
mov eax, [rbx+40h]
lea rdx, [rbp+var_34]
mov [rdx], eax
mov rax, [r14+4D0h]
mov ecx, 4
mov rdi, r14
mov esi, 19h
mov r8d, 1
mov r9, rbx
call qword ptr [rax+10h]
test eax, eax
jnz short loc_65221
jmp short loc_651F8
loc_651B0:
mov dword ptr [rbx+108h], 7DDh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov byte ptr [rbx+312h], 0
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+68h]
mov edx, 200h
jmp short loc_6526F
loc_651F5:
mov r13b, 1
loc_651F8:
mov rax, [r14+4D0h]
mov rdi, r14
mov esi, 16h
mov rdx, r15
mov rcx, r12
mov r8d, 1
mov r9, rbx
call qword ptr [rax+10h]
test eax, eax
jz loc_652A2
loc_65221:
lea rdi, [rbx+30Dh]
lea r14, [rbx+10Ch]
mov dword ptr [rbx+50h], 0
mov rsi, [rbx+38h]
mov eax, [rsi+90h]
mov [rbx+108h], eax
add rsi, 297h
mov edx, 5
call _strncpy
mov byte ptr [rbx+312h], 0
mov esi, 97h
add rsi, [rbx+38h]
mov edx, 200h
mov rdi, r14
loc_6526F:
call _strncpy
mov byte ptr [rbx+30Bh], 0
mov r15d, 1
loc_65281:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_65309
mov eax, r15d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_652A2:
test r13b, r13b
jz short loc_652C8
mov rax, [r14+2A0h]
cmp dword ptr [rax], 2
jnz short loc_652C8
mov rdi, r14
mov esi, 4
call ma_multi_command
test eax, eax
jnz loc_65221
loc_652C8:
mov rax, [r14+2A0h]
xor r15d, r15d
cmp dword ptr [rax], 0
jnz short loc_65281
mov rax, [r14+480h]
cmp byte ptr [rax+148h], 0
jnz short loc_65281
mov rax, [r14+4D0h]
mov rax, [rax+40h]
test rax, rax
jz short loc_65281
mov rdi, rbx
call rax
test al, al
jnz loc_65221
jmp loc_65281
loc_65309:
call ___stack_chk_fail
| long long mysql_stmt_prepare(long long a1, long long a2, long long a3)
{
long long v4; // r14
long long v5; // r12
long long v6; // rax
_DWORD *v7; // rax
bool v8; // r13
long long v9; // rdi
char *v10; // rsi
long long v11; // rsi
unsigned int v12; // r15d
unsigned __int8 ( *v14)(long long); // rax
int v15; // [rsp+Ch] [rbp-34h] BYREF
unsigned long long v16; // [rsp+10h] [rbp-30h]
v16 = __readfsqword(0x28u);
v4 = *(_QWORD *)(a1 + 56);
if ( !v4 )
{
*(_DWORD *)(a1 + 264) = 2013;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v9 = a1 + 268;
v10 = client_errors[13];
LABEL_16:
strncpy(v9, v10, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
v5 = a3;
if ( a3 == -1 )
v5 = strlen(a2);
*(_DWORD *)(a1 + 264) = 0;
strcpy((char *)(a1 + 781), "00000");
*(_BYTE *)(a1 + 268) = 0;
*(_DWORD *)(v4 + 144) = 0;
strcpy((char *)(*(_QWORD *)(a1 + 56) + 663LL), "00000");
*(_BYTE *)(*(_QWORD *)(a1 + 56) + 151LL) = 0;
v6 = *(_QWORD *)(*(_QWORD *)(a1 + 56) + 672LL);
if ( v6 )
*(_DWORD *)(v6 + 4) = 0;
*(_QWORD *)(v4 + 824) = -1LL;
*(_QWORD *)(a1 + 248) = -1LL;
if ( *(_DWORD *)(a1 + 80) )
{
v7 = *(_DWORD **)(v4 + 672);
v8 = *v7 == 0;
if ( !*v7 )
ma_multi_command(v4, 2);
if ( (unsigned __int8)mysql_stmt_internal_reset(a1, 1) )
goto LABEL_15;
ma_free_root(a1, 1);
ma_free_root(*(_QWORD *)(a1 + 832), 0);
*(_QWORD *)(a1 + 112) = 0LL;
*(_OWORD *)(a1 + 88) = 0LL;
v15 = *(_DWORD *)(a1 + 64);
if ( (*(unsigned int ( **)(long long, long long, int *, long long, long long, long long))(*(_QWORD *)(v4 + 1232)
+ 16LL))(
v4,
25LL,
&v15,
4LL,
1LL,
a1) )
{
goto LABEL_15;
}
}
else
{
v8 = 1;
}
if ( (*(unsigned int ( **)(long long, long long, long long, long long, long long, long long))(*(_QWORD *)(v4 + 1232)
+ 16LL))(
v4,
22LL,
a2,
v5,
1LL,
a1)
|| v8 && **(_DWORD **)(v4 + 672) == 2 && (unsigned int)ma_multi_command(v4, 4)
|| (v12 = 0, !**(_DWORD **)(v4 + 672))
&& !*(_BYTE *)(*(_QWORD *)(v4 + 1152) + 328LL)
&& (v14 = *(unsigned __int8 ( **)(long long))(*(_QWORD *)(v4 + 1232) + 64LL)) != 0LL
&& v14(a1) )
{
LABEL_15:
*(_DWORD *)(a1 + 80) = 0;
v11 = *(_QWORD *)(a1 + 56);
*(_DWORD *)(a1 + 264) = *(_DWORD *)(v11 + 144);
strncpy(a1 + 781, v11 + 663, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v10 = (char *)(*(_QWORD *)(a1 + 56) + 151LL);
v9 = a1 + 268;
goto LABEL_16;
}
return v12;
}
| mysql_stmt_prepare:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R14,qword ptr [RDI + 0x38]
TEST R14,R14
JZ 0x001651b0
MOV R12,RDX
MOV R15,RSI
CMP RDX,-0x1
JNZ 0x001650a9
MOV RDI,R15
CALL 0x0013a4c0
MOV R12,RAX
LAB_001650a9:
XOR EAX,EAX
MOV dword ptr [RBX + 0x108],EAX
MOV ECX,0x30303030
MOV dword ptr [RBX + 0x30d],ECX
MOV DX,0x30
MOV word ptr [RBX + 0x311],DX
MOV byte ptr [RBX + 0x10c],AL
MOV dword ptr [R14 + 0x90],EAX
MOV RSI,qword ptr [RBX + 0x38]
MOV word ptr [RSI + 0x29b],DX
MOV dword ptr [RSI + 0x297],ECX
MOV RCX,qword ptr [RBX + 0x38]
MOV byte ptr [RCX + 0x97],AL
MOV RAX,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RAX + 0x2a0]
TEST RAX,RAX
JZ 0x00165106
MOV dword ptr [RAX + 0x4],0x0
LAB_00165106:
MOV RAX,-0x1
MOV qword ptr [R14 + 0x338],RAX
MOV qword ptr [RBX + 0xf8],RAX
CMP dword ptr [RBX + 0x50],0x0
JZ 0x001651f5
MOV RAX,qword ptr [R14 + 0x2a0]
CMP dword ptr [RAX],0x0
SETZ R13B
JNZ 0x00165142
MOV RDI,R14
MOV ESI,0x2
CALL 0x0015a111
LAB_00165142:
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00163db8
TEST AL,AL
JNZ 0x00165221
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00161f23
MOV RDI,qword ptr [RBX + 0x340]
XOR ESI,ESI
CALL 0x00161f23
MOV qword ptr [RBX + 0x70],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x58],XMM0
MOV EAX,dword ptr [RBX + 0x40]
LEA RDX,[RBP + -0x34]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [R14 + 0x4d0]
MOV ECX,0x4
MOV RDI,R14
MOV ESI,0x19
MOV R8D,0x1
MOV R9,RBX
CALL qword ptr [RAX + 0x10]
TEST EAX,EAX
JNZ 0x00165221
JMP 0x001651f8
LAB_001651b0:
MOV dword ptr [RBX + 0x108],0x7dd
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x46dab0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x0013a1a0
MOV byte ptr [RBX + 0x312],0x0
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x46dac0]
MOV RSI,qword ptr [RAX + 0x68]
MOV EDX,0x200
JMP 0x0016526f
LAB_001651f5:
MOV R13B,0x1
LAB_001651f8:
MOV RAX,qword ptr [R14 + 0x4d0]
MOV RDI,R14
MOV ESI,0x16
MOV RDX,R15
MOV RCX,R12
MOV R8D,0x1
MOV R9,RBX
CALL qword ptr [RAX + 0x10]
TEST EAX,EAX
JZ 0x001652a2
LAB_00165221:
LEA RDI,[RBX + 0x30d]
LEA R14,[RBX + 0x10c]
MOV dword ptr [RBX + 0x50],0x0
MOV RSI,qword ptr [RBX + 0x38]
MOV EAX,dword ptr [RSI + 0x90]
MOV dword ptr [RBX + 0x108],EAX
ADD RSI,0x297
MOV EDX,0x5
CALL 0x0013a1a0
MOV byte ptr [RBX + 0x312],0x0
MOV ESI,0x97
ADD RSI,qword ptr [RBX + 0x38]
MOV EDX,0x200
MOV RDI,R14
LAB_0016526f:
CALL 0x0013a1a0
MOV byte ptr [RBX + 0x30b],0x0
MOV R15D,0x1
LAB_00165281:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00165309
MOV EAX,R15D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001652a2:
TEST R13B,R13B
JZ 0x001652c8
MOV RAX,qword ptr [R14 + 0x2a0]
CMP dword ptr [RAX],0x2
JNZ 0x001652c8
MOV RDI,R14
MOV ESI,0x4
CALL 0x0015a111
TEST EAX,EAX
JNZ 0x00165221
LAB_001652c8:
MOV RAX,qword ptr [R14 + 0x2a0]
XOR R15D,R15D
CMP dword ptr [RAX],0x0
JNZ 0x00165281
MOV RAX,qword ptr [R14 + 0x480]
CMP byte ptr [RAX + 0x148],0x0
JNZ 0x00165281
MOV RAX,qword ptr [R14 + 0x4d0]
MOV RAX,qword ptr [RAX + 0x40]
TEST RAX,RAX
JZ 0x00165281
MOV RDI,RBX
CALL RAX
TEST AL,AL
JNZ 0x00165221
JMP 0x00165281
LAB_00165309:
CALL 0x0013a340
|
int8 mysql_stmt_prepare(long param_1,char *param_2,size_t param_3)
{
long lVar1;
long lVar2;
code *pcVar3;
char cVar4;
int iVar5;
char *__src;
int8 uVar6;
long in_FS_OFFSET;
bool bVar7;
int4 local_3c;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = *(long *)(param_1 + 0x38);
if (lVar1 == 0) {
*(int4 *)(param_1 + 0x108) = 0x7dd;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Lost_connection_to_server_during_0046db28;
}
else {
if (param_3 == 0xffffffffffffffff) {
param_3 = strlen(param_2);
}
*(int4 *)(param_1 + 0x108) = 0;
*(int4 *)(param_1 + 0x30d) = 0x30303030;
*(int2 *)(param_1 + 0x311) = 0x30;
*(int1 *)(param_1 + 0x10c) = 0;
*(int4 *)(lVar1 + 0x90) = 0;
lVar2 = *(long *)(param_1 + 0x38);
*(int2 *)(lVar2 + 0x29b) = 0x30;
*(int4 *)(lVar2 + 0x297) = 0x30303030;
*(int1 *)(*(long *)(param_1 + 0x38) + 0x97) = 0;
lVar2 = *(long *)(*(long *)(param_1 + 0x38) + 0x2a0);
if (lVar2 != 0) {
*(int4 *)(lVar2 + 4) = 0;
}
*(int8 *)(lVar1 + 0x338) = 0xffffffffffffffff;
*(int8 *)(param_1 + 0xf8) = 0xffffffffffffffff;
if (*(int *)(param_1 + 0x50) == 0) {
bVar7 = true;
LAB_001651f8:
iVar5 = (**(code **)(*(long *)(lVar1 + 0x4d0) + 0x10))(lVar1,0x16,param_2,param_3,1,param_1);
if ((iVar5 == 0) &&
(((!bVar7 || (**(int **)(lVar1 + 0x2a0) != 2)) ||
(iVar5 = ma_multi_command(lVar1,4), iVar5 == 0)))) {
uVar6 = 0;
if ((((**(int **)(lVar1 + 0x2a0) != 0) ||
(*(char *)(*(long *)(lVar1 + 0x480) + 0x148) != '\0')) ||
(pcVar3 = *(code **)(*(long *)(lVar1 + 0x4d0) + 0x40), pcVar3 == (code *)0x0)) ||
(cVar4 = (*pcVar3)(param_1), uVar6 = 0, cVar4 == '\0')) goto LAB_00165281;
}
}
else {
bVar7 = **(int **)(lVar1 + 0x2a0) == 0;
if (bVar7) {
ma_multi_command(lVar1,2);
}
cVar4 = mysql_stmt_internal_reset(param_1,1);
if (cVar4 == '\0') {
ma_free_root(param_1,1);
ma_free_root(*(int8 *)(param_1 + 0x340),0);
*(int8 *)(param_1 + 0x70) = 0;
*(int8 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x60) = 0;
local_3c = *(int4 *)(param_1 + 0x40);
iVar5 = (**(code **)(*(long *)(lVar1 + 0x4d0) + 0x10))(lVar1,0x19,&local_3c,4,1,param_1);
if (iVar5 == 0) goto LAB_001651f8;
}
}
*(int4 *)(param_1 + 0x50) = 0;
*(int4 *)(param_1 + 0x108) = *(int4 *)(*(long *)(param_1 + 0x38) + 0x90);
strncpy((char *)(param_1 + 0x30d),(char *)(*(long *)(param_1 + 0x38) + 0x297),5);
*(int1 *)(param_1 + 0x312) = 0;
__src = (char *)(*(long *)(param_1 + 0x38) + 0x97);
}
strncpy((char *)(param_1 + 0x10c),__src,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
uVar6 = 1;
LAB_00165281:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar6;
}
| |
26,345 | eth_verify_account_proof_exec | corpus-core[P]colibri-stateless/src/chains/eth/verifier/eth_account.c | INTERNAL bool eth_verify_account_proof_exec(verify_ctx_t* ctx, ssz_ob_t* proof, bytes32_t state_root, eth_account_field_t field, bytes_t values) {
ssz_ob_t account_proof = ssz_get(proof, "accountProof");
ssz_ob_t address = ssz_get(proof, "address");
bytes32_t address_hash = {0};
bytes_t rlp_account = {0};
bytes_t field_value = {0};
bytes32_t storage_hash = {0};
keccak(address.bytes, address_hash);
switch (field) {
case ETH_ACCOUNT_CODE_HASH:
memcpy(values.data, EMPTY_HASH, 32);
break;
case ETH_ACCOUNT_STORAGE_HASH:
memcpy(values.data, EMPTY_ROOT_HASH, 32);
break;
default:
memset(values.data, 0, 32);
break;
}
patricia_result_t result = patricia_verify(state_root, bytes(address_hash, 32), account_proof, &rlp_account);
if (result == PATRICIA_INVALID) RETURN_VERIFY_ERROR(ctx, "invalid account proof on execution layer!");
if (result == PATRICIA_FOUND) { // 2 means not existing account
if (!rlp_account.data) RETURN_VERIFY_ERROR(ctx, "invalid account proof on execution layer!");
if (rlp_decode(&rlp_account, 0, &rlp_account) != RLP_LIST) RETURN_VERIFY_ERROR(ctx, "invalid account proof on execution layer!");
if (rlp_decode(&rlp_account, 2, &field_value) != RLP_ITEM) RETURN_VERIFY_ERROR(ctx, "invalid account proof for storage hash!");
// get the storage hash from the proof
if (field_value.len > 32) RETURN_VERIFY_ERROR(ctx, "invalid account proof for storage hash!");
memcpy(storage_hash, field_value.data, field_value.len);
// get the field value from the proof
if (field) {
if (rlp_decode(&rlp_account, field - 1, &field_value) != RLP_ITEM) RETURN_VERIFY_ERROR(ctx, "invalid account proof on execution layer!");
if (field_value.len > 32) RETURN_VERIFY_ERROR(ctx, "invalid account proof on execution layer!");
memcpy(values.data + 32 - field_value.len, field_value.data, field_value.len);
}
}
if (!verify_storage(ctx, ssz_get(proof, "storageProof"), storage_hash, field == ETH_ACCOUNT_STORAGE_HASH ? values : NULL_BYTES)) RETURN_VERIFY_ERROR(ctx, "invalid storage proof!");
return true;
} | O0 | c | eth_verify_account_proof_exec:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movl %r8d, -0x18(%rbp)
movq %r9, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movq -0x28(%rbp), %rsi
leaq 0x3faf4(%rip), %rdx # 0x52671
leaq -0x50(%rbp), %rdi
callq 0x1c760
movq -0x28(%rbp), %rsi
leaq 0x3faed(%rip), %rdx # 0x5267e
leaq -0x68(%rbp), %rdi
callq 0x1c760
xorps %xmm0, %xmm0
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
movaps %xmm0, -0xb0(%rbp)
movaps %xmm0, -0xc0(%rbp)
movaps %xmm0, -0xd0(%rbp)
movl -0x68(%rbp), %edi
movq -0x60(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x1f4e0
movl -0x34(%rbp), %eax
movl %eax, -0x114(%rbp)
subl $0x3, %eax
je 0x12c1f
jmp 0x12be7
movl -0x114(%rbp), %eax
subl $0x4, %eax
jne 0x12c4a
jmp 0x12bf4
movq -0x10(%rbp), %rax
movq 0x5c601(%rip), %rcx # 0x6f200
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x12c5a
movq -0x10(%rbp), %rax
movq 0x5c5de(%rip), %rcx # 0x6f208
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x12c5a
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x5110
movq -0x30(%rbp), %rdi
movl $0x20, -0xe8(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl -0xe8(%rbp), %esi
movq -0xe0(%rbp), %rdx
leaq -0x50(%rbp), %rax
leaq -0xa0(%rbp), %rcx
movq (%rax), %r8
movq %r8, (%rsp)
movq 0x8(%rax), %r8
movq %r8, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x155e0
movl %eax, -0xd4(%rbp)
cmpl $0x0, -0xd4(%rbp)
jne 0x12ce2
jmp 0x12cbd
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x4073d(%rip), %rsi # 0x53409
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x12f68
cmpl $0x1, -0xd4(%rbp)
jne 0x12e99
cmpq $0x0, -0x98(%rbp)
jne 0x12d20
jmp 0x12cfb
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x406ff(%rip), %rsi # 0x53409
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x12f68
leaq -0xa0(%rbp), %rdx
xorl %esi, %esi
movq %rdx, %rdi
callq 0x15f10
cmpl $0x2, %eax
je 0x12d5d
jmp 0x12d38
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x406c2(%rip), %rsi # 0x53409
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x12f68
leaq -0xa0(%rbp), %rdi
movl $0x2, %esi
leaq -0xb0(%rbp), %rdx
callq 0x15f10
cmpl $0x1, %eax
je 0x12da1
jmp 0x12d7c
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x4092e(%rip), %rsi # 0x536b9
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x12f68
cmpl $0x20, -0xb0(%rbp)
jbe 0x12dd1
jmp 0x12dac
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x408fe(%rip), %rsi # 0x536b9
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x12f68
leaq -0xd0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movl -0xb0(%rbp), %eax
movl %eax, %edx
callq 0x5060
cmpl $0x0, -0x34(%rbp)
je 0x12e97
movl -0x34(%rbp), %esi
subl $0x1, %esi
leaq -0xa0(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
callq 0x15f10
cmpl $0x1, %eax
je 0x12e3b
jmp 0x12e16
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x405e4(%rip), %rsi # 0x53409
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x12f68
cmpl $0x20, -0xb0(%rbp)
jbe 0x12e6b
jmp 0x12e46
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x405b4(%rip), %rsi # 0x53409
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x12f68
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl -0xb0(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq -0xa8(%rbp), %rsi
movl -0xb0(%rbp), %eax
movl %eax, %edx
callq 0x5060
jmp 0x12e99
movq -0x20(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x100(%rbp), %rdi
leaq 0x3f7d0(%rip), %rdx # 0x52686
callq 0x1c760
leaq -0xd0(%rbp), %rax
movq %rax, -0x120(%rbp)
cmpl $0x3, -0x34(%rbp)
jne 0x12ee7
movq -0x18(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x108(%rbp)
jmp 0x12efc
movl $0x0, -0x110(%rbp)
movq $0x0, -0x108(%rbp)
movq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdi
movl -0x110(%rbp), %edx
movq -0x108(%rbp), %rcx
leaq -0x100(%rbp), %rax
movq (%rax), %r8
movq %r8, (%rsp)
movq 0x8(%rax), %r8
movq %r8, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x12f80
testb $0x1, %al
jne 0x12f64
jmp 0x12f42
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x40790(%rip), %rsi # 0x536e1
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x12f68
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x140, %rsp # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
| eth_verify_account_proof_exec:
push rbp
mov rbp, rsp
sub rsp, 140h
mov dword ptr [rbp+var_18], r8d
mov [rbp+var_10], r9
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov [rbp+var_30], rdx
mov [rbp+var_34], ecx
mov rsi, [rbp+var_28]
lea rdx, aAccountproof; "accountProof"
lea rdi, [rbp+var_50]
call ssz_get
mov rsi, [rbp+var_28]
lea rdx, aAddress; "address"
lea rdi, [rbp+var_68]
call ssz_get
xorps xmm0, xmm0
movaps [rbp+var_80], xmm0
movaps [rbp+var_90], xmm0
movaps [rbp+var_A0], xmm0
movaps [rbp+var_B0], xmm0
movaps [rbp+var_C0], xmm0
movaps [rbp+var_D0], xmm0
mov edi, [rbp+var_68]
mov rsi, [rbp+var_60]
lea rdx, [rbp+var_90]
call keccak
mov eax, [rbp+var_34]
mov [rbp+var_114], eax
sub eax, 3
jz short loc_12C1F
jmp short $+2
loc_12BE7:
mov eax, [rbp+var_114]
sub eax, 4
jnz short loc_12C4A
jmp short $+2
loc_12BF4:
mov rax, [rbp+var_10]
mov rcx, cs:EMPTY_HASH
mov rdx, [rcx]
mov [rax], rdx
mov rdx, [rcx+8]
mov [rax+8], rdx
mov rdx, [rcx+10h]
mov [rax+10h], rdx
mov rcx, [rcx+18h]
mov [rax+18h], rcx
jmp short loc_12C5A
loc_12C1F:
mov rax, [rbp+var_10]
mov rcx, cs:EMPTY_ROOT_HASH
mov rdx, [rcx]
mov [rax], rdx
mov rdx, [rcx+8]
mov [rax+8], rdx
mov rdx, [rcx+10h]
mov [rax+10h], rdx
mov rcx, [rcx+18h]
mov [rax+18h], rcx
jmp short loc_12C5A
loc_12C4A:
mov rdi, [rbp+var_10]
xor esi, esi
mov edx, 20h ; ' '
call _memset
loc_12C5A:
mov rdi, [rbp+var_30]
mov [rbp+var_E8], 20h ; ' '
lea rax, [rbp+var_90]
mov [rbp+var_E0], rax
mov esi, [rbp+var_E8]
mov rdx, [rbp+var_E0]
lea rax, [rbp+var_50]
lea rcx, [rbp+var_A0]
mov r8, [rax]
mov [rsp+140h+var_140], r8
mov r8, [rax+8]
mov [rsp+140h+var_138], r8
mov rax, [rax+10h]
mov [rsp+140h+var_130], rax
call patricia_verify
mov [rbp+var_D4], eax
cmp [rbp+var_D4], 0
jnz short loc_12CE2
jmp short $+2
loc_12CBD:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidAccount; "invalid account proof on execution laye"...
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp loc_12F68
loc_12CE2:
cmp [rbp+var_D4], 1
jnz loc_12E99
cmp qword ptr [rbp+var_A0+8], 0
jnz short loc_12D20
jmp short $+2
loc_12CFB:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidAccount; "invalid account proof on execution laye"...
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp loc_12F68
loc_12D20:
lea rdx, [rbp+var_A0]
xor esi, esi
mov rdi, rdx
call rlp_decode
cmp eax, 2
jz short loc_12D5D
jmp short $+2
loc_12D38:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidAccount; "invalid account proof on execution laye"...
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp loc_12F68
loc_12D5D:
lea rdi, [rbp+var_A0]
mov esi, 2
lea rdx, [rbp+var_B0]
call rlp_decode
cmp eax, 1
jz short loc_12DA1
jmp short $+2
loc_12D7C:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidAccount_0; "invalid account proof for storage hash!"
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp loc_12F68
loc_12DA1:
cmp dword ptr [rbp+var_B0], 20h ; ' '
jbe short loc_12DD1
jmp short $+2
loc_12DAC:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidAccount_0; "invalid account proof for storage hash!"
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp loc_12F68
loc_12DD1:
lea rdi, [rbp+var_D0]
mov rsi, qword ptr [rbp+var_B0+8]
mov eax, dword ptr [rbp+var_B0]
mov edx, eax
call _memcpy
cmp [rbp+var_34], 0
jz loc_12E97
mov esi, [rbp+var_34]
sub esi, 1
lea rdi, [rbp+var_A0]
lea rdx, [rbp+var_B0]
call rlp_decode
cmp eax, 1
jz short loc_12E3B
jmp short $+2
loc_12E16:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidAccount; "invalid account proof on execution laye"...
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp loc_12F68
loc_12E3B:
cmp dword ptr [rbp+var_B0], 20h ; ' '
jbe short loc_12E6B
jmp short $+2
loc_12E46:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidAccount; "invalid account proof on execution laye"...
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp loc_12F68
loc_12E6B:
mov rdi, [rbp+var_10]
add rdi, 20h ; ' '
mov eax, dword ptr [rbp+var_B0]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rdi, rax
mov rsi, qword ptr [rbp+var_B0+8]
mov eax, dword ptr [rbp+var_B0]
mov edx, eax
call _memcpy
loc_12E97:
jmp short $+2
loc_12E99:
mov rax, [rbp+var_20]
mov [rbp+var_128], rax
mov rsi, [rbp+var_28]
lea rdi, [rbp+var_100]
lea rdx, aStorageproof; "storageProof"
call ssz_get
lea rax, [rbp+var_D0]
mov [rbp+var_120], rax
cmp [rbp+var_34], 3
jnz short loc_12EE7
mov rax, [rbp+var_18]
mov [rbp+var_110], rax
mov rax, [rbp+var_10]
mov [rbp+var_108], rax
jmp short loc_12EFC
loc_12EE7:
mov dword ptr [rbp+var_110], 0
mov [rbp+var_108], 0
loc_12EFC:
mov rsi, [rbp+var_120]
mov rdi, [rbp+var_128]
mov edx, dword ptr [rbp+var_110]
mov rcx, [rbp+var_108]
lea rax, [rbp+var_100]
mov r8, [rax]
mov [rsp+140h+var_140], r8
mov r8, [rax+8]
mov [rsp+140h+var_138], r8
mov rax, [rax+10h]
mov [rsp+140h+var_130], rax
call verify_storage
test al, 1
jnz short loc_12F64
jmp short $+2
loc_12F42:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidStorage; "invalid storage proof!"
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp short loc_12F68
loc_12F64:
mov [rbp+var_1], 1
loc_12F68:
mov al, [rbp+var_1]
and al, 1
add rsp, 140h
pop rbp
retn
| char eth_verify_account_proof_exec(long long a1, long long a2, long long a3, int a4, int a5, _QWORD *a6)
{
int v6; // r9d
_QWORD *v7; // rax
_QWORD *v8; // rcx
_QWORD *v9; // rax
_QWORD *v10; // rcx
int v11; // r9d
char v12; // al
int v14; // [rsp+18h] [rbp-128h]
long long v15; // [rsp+40h] [rbp-100h] BYREF
long long v16; // [rsp+48h] [rbp-F8h]
long long v17; // [rsp+50h] [rbp-F0h]
int v18; // [rsp+58h] [rbp-E8h]
_OWORD *v19; // [rsp+60h] [rbp-E0h]
int v20; // [rsp+6Ch] [rbp-D4h]
_OWORD v21[2]; // [rsp+70h] [rbp-D0h] BYREF
__int128 v22; // [rsp+90h] [rbp-B0h]
__int128 v23; // [rsp+A0h] [rbp-A0h] BYREF
_OWORD v24[2]; // [rsp+B0h] [rbp-90h] BYREF
unsigned int v25; // [rsp+D8h] [rbp-68h] BYREF
long long v26; // [rsp+E0h] [rbp-60h]
long long v27; // [rsp+F0h] [rbp-50h] BYREF
long long v28; // [rsp+F8h] [rbp-48h]
long long v29; // [rsp+100h] [rbp-40h]
int v30; // [rsp+10Ch] [rbp-34h]
long long v31; // [rsp+110h] [rbp-30h]
long long v32; // [rsp+118h] [rbp-28h]
long long v33; // [rsp+120h] [rbp-20h]
long long v34; // [rsp+128h] [rbp-18h]
_QWORD *v35; // [rsp+130h] [rbp-10h]
LODWORD(v34) = a5;
v35 = a6;
v33 = a1;
v32 = a2;
v31 = a3;
v30 = a4;
ssz_get(&v27, a2, "accountProof");
ssz_get(&v25, v32, "address");
memset(v24, 0, sizeof(v24));
v23 = 0LL;
v22 = 0LL;
memset(v21, 0, sizeof(v21));
keccak(v25, v26, v24);
if ( v30 == 3 )
{
v9 = v35;
v10 = EMPTY_ROOT_HASH;
*v35 = *(_QWORD *)EMPTY_ROOT_HASH;
v9[1] = v10[1];
v9[2] = v10[2];
v9[3] = v10[3];
}
else if ( v30 == 4 )
{
v7 = v35;
v8 = EMPTY_HASH;
*v35 = *(_QWORD *)EMPTY_HASH;
v7[1] = v8[1];
v7[2] = v8[2];
v7[3] = v8[3];
}
else
{
memset(v35, 0LL, 32LL);
}
v18 = 32;
v19 = v24;
v20 = patricia_verify(v31, 32, (unsigned int)v24, (unsigned int)&v23, v28, v6, v27, v28, v29);
if ( !v20 )
goto LABEL_10;
if ( v20 == 1 )
{
if ( !*((_QWORD *)&v23 + 1) || (unsigned int)rlp_decode(&v23, 0LL) != 2 )
{
LABEL_10:
c4_state_add_error(v33 + 112, "invalid account proof on execution layer!");
*(_BYTE *)(v33 + 104) = 0;
return 0;
}
if ( (unsigned int)rlp_decode(&v23, 2LL) != 1 || (unsigned int)v22 > 0x20 )
{
c4_state_add_error(v33 + 112, "invalid account proof for storage hash!");
*(_BYTE *)(v33 + 104) = 0;
return 0;
}
memcpy(v21, *((_QWORD *)&v22 + 1), (unsigned int)v22);
if ( v30 )
{
if ( (unsigned int)rlp_decode(&v23, (unsigned int)(v30 - 1)) != 1 || (unsigned int)v22 > 0x20 )
{
c4_state_add_error(v33 + 112, "invalid account proof on execution layer!");
*(_BYTE *)(v33 + 104) = 0;
return 0;
}
memcpy((char *)v35 - (unsigned int)v22 + 32, *((_QWORD *)&v22 + 1), (unsigned int)v22);
}
}
v14 = v33;
ssz_get(&v15, v32, "storageProof");
if ( v30 == 3 )
v12 = verify_storage(v14, (unsigned int)v21, v34, (_DWORD)v35, v16, v11, v15, v16, v17);
else
v12 = verify_storage(v14, (unsigned int)v21, 0, 0, v16, v11, v15, v16, v17);
if ( (v12 & 1) != 0 )
return 1;
c4_state_add_error(v33 + 112, "invalid storage proof!");
*(_BYTE *)(v33 + 104) = 0;
return 0;
}
| eth_verify_account_proof_exec:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x140
MOV dword ptr [RBP + -0x18],R8D
MOV qword ptr [RBP + -0x10],R9
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV qword ptr [RBP + -0x30],RDX
MOV dword ptr [RBP + -0x34],ECX
MOV RSI,qword ptr [RBP + -0x28]
LEA RDX,[0x152671]
LEA RDI,[RBP + -0x50]
CALL 0x0011c760
MOV RSI,qword ptr [RBP + -0x28]
LEA RDX,[0x15267e]
LEA RDI,[RBP + -0x68]
CALL 0x0011c760
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x80],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM0
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0xb0],XMM0
MOVAPS xmmword ptr [RBP + -0xc0],XMM0
MOVAPS xmmword ptr [RBP + -0xd0],XMM0
MOV EDI,dword ptr [RBP + -0x68]
MOV RSI,qword ptr [RBP + -0x60]
LEA RDX,[RBP + -0x90]
CALL 0x0011f4e0
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x114],EAX
SUB EAX,0x3
JZ 0x00112c1f
JMP 0x00112be7
LAB_00112be7:
MOV EAX,dword ptr [RBP + -0x114]
SUB EAX,0x4
JNZ 0x00112c4a
JMP 0x00112bf4
LAB_00112bf4:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [0x0016f200]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RDX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV RDX,qword ptr [RCX + 0x10]
MOV qword ptr [RAX + 0x10],RDX
MOV RCX,qword ptr [RCX + 0x18]
MOV qword ptr [RAX + 0x18],RCX
JMP 0x00112c5a
LAB_00112c1f:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [0x0016f208]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RDX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV RDX,qword ptr [RCX + 0x10]
MOV qword ptr [RAX + 0x10],RDX
MOV RCX,qword ptr [RCX + 0x18]
MOV qword ptr [RAX + 0x18],RCX
JMP 0x00112c5a
LAB_00112c4a:
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00105110
LAB_00112c5a:
MOV RDI,qword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0xe8],0x20
LEA RAX,[RBP + -0x90]
MOV qword ptr [RBP + -0xe0],RAX
MOV ESI,dword ptr [RBP + -0xe8]
MOV RDX,qword ptr [RBP + -0xe0]
LEA RAX,[RBP + -0x50]
LEA RCX,[RBP + -0xa0]
MOV R8,qword ptr [RAX]
MOV qword ptr [RSP],R8
MOV R8,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],R8
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001155e0
MOV dword ptr [RBP + -0xd4],EAX
CMP dword ptr [RBP + -0xd4],0x0
JNZ 0x00112ce2
JMP 0x00112cbd
LAB_00112cbd:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x153409]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00112f68
LAB_00112ce2:
CMP dword ptr [RBP + -0xd4],0x1
JNZ 0x00112e99
CMP qword ptr [RBP + -0x98],0x0
JNZ 0x00112d20
JMP 0x00112cfb
LAB_00112cfb:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x153409]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00112f68
LAB_00112d20:
LEA RDX,[RBP + -0xa0]
XOR ESI,ESI
MOV RDI,RDX
CALL 0x00115f10
CMP EAX,0x2
JZ 0x00112d5d
JMP 0x00112d38
LAB_00112d38:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x153409]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00112f68
LAB_00112d5d:
LEA RDI,[RBP + -0xa0]
MOV ESI,0x2
LEA RDX,[RBP + -0xb0]
CALL 0x00115f10
CMP EAX,0x1
JZ 0x00112da1
JMP 0x00112d7c
LAB_00112d7c:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x1536b9]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00112f68
LAB_00112da1:
CMP dword ptr [RBP + -0xb0],0x20
JBE 0x00112dd1
JMP 0x00112dac
LAB_00112dac:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x1536b9]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00112f68
LAB_00112dd1:
LEA RDI,[RBP + -0xd0]
MOV RSI,qword ptr [RBP + -0xa8]
MOV EAX,dword ptr [RBP + -0xb0]
MOV EDX,EAX
CALL 0x00105060
CMP dword ptr [RBP + -0x34],0x0
JZ 0x00112e97
MOV ESI,dword ptr [RBP + -0x34]
SUB ESI,0x1
LEA RDI,[RBP + -0xa0]
LEA RDX,[RBP + -0xb0]
CALL 0x00115f10
CMP EAX,0x1
JZ 0x00112e3b
JMP 0x00112e16
LAB_00112e16:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x153409]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00112f68
LAB_00112e3b:
CMP dword ptr [RBP + -0xb0],0x20
JBE 0x00112e6b
JMP 0x00112e46
LAB_00112e46:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x153409]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00112f68
LAB_00112e6b:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x20
MOV EAX,dword ptr [RBP + -0xb0]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0xa8]
MOV EAX,dword ptr [RBP + -0xb0]
MOV EDX,EAX
CALL 0x00105060
LAB_00112e97:
JMP 0x00112e99
LAB_00112e99:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x128],RAX
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x100]
LEA RDX,[0x152686]
CALL 0x0011c760
LEA RAX,[RBP + -0xd0]
MOV qword ptr [RBP + -0x120],RAX
CMP dword ptr [RBP + -0x34],0x3
JNZ 0x00112ee7
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x110],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x108],RAX
JMP 0x00112efc
LAB_00112ee7:
MOV dword ptr [RBP + -0x110],0x0
MOV qword ptr [RBP + -0x108],0x0
LAB_00112efc:
MOV RSI,qword ptr [RBP + -0x120]
MOV RDI,qword ptr [RBP + -0x128]
MOV EDX,dword ptr [RBP + -0x110]
MOV RCX,qword ptr [RBP + -0x108]
LEA RAX,[RBP + -0x100]
MOV R8,qword ptr [RAX]
MOV qword ptr [RSP],R8
MOV R8,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],R8
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00112f80
TEST AL,0x1
JNZ 0x00112f64
JMP 0x00112f42
LAB_00112f42:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x1536e1]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00112f68
LAB_00112f64:
MOV byte ptr [RBP + -0x1],0x1
LAB_00112f68:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x140
POP RBP
RET
|
bool eth_verify_account_proof_exec
(long param_1,int8 param_2,int8 param_3,int param_4,int4 param_5,
int8 *param_6)
{
int4 uVar1;
int *puVar2;
int *puVar3;
long lVar4;
int iVar5;
ulong uVar6;
bool bVar7;
int8 *local_110;
int1 local_108 [24];
int4 local_f0;
int8 *local_e8;
int local_dc;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
ulong local_b8;
void *pvStack_b0;
int8 local_a8;
long lStack_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int4 local_70 [2];
int8 local_68;
int1 local_58 [28];
int local_3c;
int8 local_38;
int8 local_30;
long local_28;
int4 local_20;
int8 *local_18;
local_3c = param_4;
local_38 = param_3;
local_30 = param_2;
local_28 = param_1;
local_20 = param_5;
local_18 = param_6;
ssz_get(local_58,param_2,"accountProof");
ssz_get(local_70,local_30,"address");
local_88 = 0;
uStack_80 = 0;
local_98 = 0;
uStack_90 = 0;
local_a8 = 0;
lStack_a0 = 0;
local_b8 = 0;
pvStack_b0 = (void *)0x0;
local_c8 = 0;
uStack_c0 = 0;
local_d8 = 0;
uStack_d0 = 0;
keccak(local_70[0],local_68,&local_98);
puVar3 = EMPTY_ROOT_HASH;
puVar2 = EMPTY_HASH;
if (local_3c == 3) {
*local_18 = *(int8 *)EMPTY_ROOT_HASH;
local_18[1] = *(int8 *)(puVar3 + 8);
local_18[2] = *(int8 *)(puVar3 + 0x10);
local_18[3] = *(int8 *)(puVar3 + 0x18);
}
else if (local_3c == 4) {
*local_18 = *(int8 *)EMPTY_HASH;
local_18[1] = *(int8 *)(puVar2 + 8);
local_18[2] = *(int8 *)(puVar2 + 0x10);
local_18[3] = *(int8 *)(puVar2 + 0x18);
}
else {
memset(local_18,0,0x20);
}
local_f0 = 0x20;
local_e8 = &local_98;
local_dc = patricia_verify(local_38,0x20,local_e8,&local_a8);
if (local_dc == 0) {
c4_state_add_error(local_28 + 0x70,"invalid account proof on execution layer!");
*(int1 *)(local_28 + 0x68) = 0;
return false;
}
if (local_dc == 1) {
if (lStack_a0 == 0) {
c4_state_add_error(local_28 + 0x70,"invalid account proof on execution layer!");
*(int1 *)(local_28 + 0x68) = 0;
return false;
}
iVar5 = rlp_decode(&local_a8,0);
if (iVar5 != 2) {
c4_state_add_error(local_28 + 0x70,"invalid account proof on execution layer!");
*(int1 *)(local_28 + 0x68) = 0;
return false;
}
iVar5 = rlp_decode(&local_a8,2,&local_b8);
if (iVar5 != 1) {
c4_state_add_error(local_28 + 0x70,"invalid account proof for storage hash!");
*(int1 *)(local_28 + 0x68) = 0;
return false;
}
if (0x20 < (uint)local_b8) {
c4_state_add_error(local_28 + 0x70,"invalid account proof for storage hash!");
*(int1 *)(local_28 + 0x68) = 0;
return false;
}
memcpy(&local_d8,pvStack_b0,local_b8 & 0xffffffff);
if (local_3c != 0) {
iVar5 = rlp_decode(&local_a8,local_3c + -1,&local_b8);
if (iVar5 != 1) {
c4_state_add_error(local_28 + 0x70,"invalid account proof on execution layer!");
*(int1 *)(local_28 + 0x68) = 0;
return false;
}
if (0x20 < (uint)local_b8) {
c4_state_add_error(local_28 + 0x70,"invalid account proof on execution layer!");
*(int1 *)(local_28 + 0x68) = 0;
return false;
}
memcpy((void *)((long)local_18 + (0x20 - (local_b8 & 0xffffffff))),pvStack_b0,
local_b8 & 0xffffffff);
}
}
lVar4 = local_28;
ssz_get(local_108,local_30,"storageProof");
if (local_3c == 3) {
local_110 = local_18;
uVar1 = local_20;
}
else {
uVar1 = 0;
local_110 = (int8 *)0x0;
}
uVar6 = verify_storage(lVar4,&local_d8,uVar1,local_110);
bVar7 = (uVar6 & 1) != 0;
if (!bVar7) {
c4_state_add_error(local_28 + 0x70,"invalid storage proof!");
*(int1 *)(local_28 + 0x68) = 0;
}
return bVar7;
}
| |
26,346 | eth_verify_account_proof_exec | corpus-core[P]colibri-stateless/src/chains/eth/verifier/eth_account.c | INTERNAL bool eth_verify_account_proof_exec(verify_ctx_t* ctx, ssz_ob_t* proof, bytes32_t state_root, eth_account_field_t field, bytes_t values) {
ssz_ob_t account_proof = ssz_get(proof, "accountProof");
ssz_ob_t address = ssz_get(proof, "address");
bytes32_t address_hash = {0};
bytes_t rlp_account = {0};
bytes_t field_value = {0};
bytes32_t storage_hash = {0};
keccak(address.bytes, address_hash);
switch (field) {
case ETH_ACCOUNT_CODE_HASH:
memcpy(values.data, EMPTY_HASH, 32);
break;
case ETH_ACCOUNT_STORAGE_HASH:
memcpy(values.data, EMPTY_ROOT_HASH, 32);
break;
default:
memset(values.data, 0, 32);
break;
}
patricia_result_t result = patricia_verify(state_root, bytes(address_hash, 32), account_proof, &rlp_account);
if (result == PATRICIA_INVALID) RETURN_VERIFY_ERROR(ctx, "invalid account proof on execution layer!");
if (result == PATRICIA_FOUND) { // 2 means not existing account
if (!rlp_account.data) RETURN_VERIFY_ERROR(ctx, "invalid account proof on execution layer!");
if (rlp_decode(&rlp_account, 0, &rlp_account) != RLP_LIST) RETURN_VERIFY_ERROR(ctx, "invalid account proof on execution layer!");
if (rlp_decode(&rlp_account, 2, &field_value) != RLP_ITEM) RETURN_VERIFY_ERROR(ctx, "invalid account proof for storage hash!");
// get the storage hash from the proof
if (field_value.len > 32) RETURN_VERIFY_ERROR(ctx, "invalid account proof for storage hash!");
memcpy(storage_hash, field_value.data, field_value.len);
// get the field value from the proof
if (field) {
if (rlp_decode(&rlp_account, field - 1, &field_value) != RLP_ITEM) RETURN_VERIFY_ERROR(ctx, "invalid account proof on execution layer!");
if (field_value.len > 32) RETURN_VERIFY_ERROR(ctx, "invalid account proof on execution layer!");
memcpy(values.data + 32 - field_value.len, field_value.data, field_value.len);
}
}
if (!verify_storage(ctx, ssz_get(proof, "storageProof"), storage_hash, field == ETH_ACCOUNT_STORAGE_HASH ? values : NULL_BYTES)) RETURN_VERIFY_ERROR(ctx, "invalid storage proof!");
return true;
} | O1 | c | eth_verify_account_proof_exec:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %r9, %r14
movl %r8d, 0x1c(%rsp)
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %rbp
leaq 0x2e6ee(%rip), %rdx # 0x3d68a
leaq 0xd8(%rsp), %rdi
callq 0x14ddd
leaq 0x2e6e7(%rip), %rdx # 0x3d697
leaq 0x168(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x14ddd
xorps %xmm0, %xmm0
leaq 0x140(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movl (%r13), %edi
movq 0x8(%r13), %rsi
callq 0x16aa8
cmpl $0x3, %r15d
je 0xf00b
cmpl $0x4, %r15d
jne 0xf022
movq 0x4b1c7(%rip), %rax # 0x5a1d0
jmp 0xf012
movq 0x4b1c6(%rip), %rax # 0x5a1d8
movups (%rax), %xmm0
movdqu 0x10(%rax), %xmm1
movdqu %xmm1, 0x10(%r14)
jmp 0xf02a
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movq 0xe8(%rsp), %rax
movq %rax, 0x10(%rsp)
movdqu 0xd8(%rsp), %xmm0
movdqu %xmm0, (%rsp)
leaq 0x140(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %rbx, %rdi
movl $0x20, %esi
callq 0x109a4
leaq 0x2f3b8(%rip), %rbx # 0x3e422
testl %eax, %eax
je 0xf358
cmpl $0x1, %eax
jne 0xf126
cmpq $0x0, 0x38(%rsp)
je 0xf358
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movq %rdi, %rdx
callq 0x10ef0
cmpl $0x2, %eax
jne 0xf358
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x2, %esi
callq 0x10ef0
leaq 0x2f618(%rip), %rsi # 0x3e6d2
cmpl $0x1, %eax
jne 0xf35b
movl 0x20(%rsp), %edx
cmpq $0x20, %rdx
ja 0xf35b
movq 0x28(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x5060
testl %r15d, %r15d
je 0xf126
leal -0x1(%r15), %esi
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x10ef0
cmpl $0x1, %eax
jne 0xf358
movl 0x20(%rsp), %edx
movq %rbx, %rsi
cmpq $0x20, %rdx
ja 0xf35b
movq %r14, %rdi
subq %rdx, %rdi
addq $0x20, %rdi
movq 0x28(%rsp), %rsi
callq 0x5060
leaq 0x2e572(%rip), %rdx # 0x3d69f
leaq 0xc0(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x14ddd
xorl %eax, %eax
cmpl $0x3, %r15d
cmovneq %rax, %r14
movl 0x1c(%rsp), %ecx
cmovnel %eax, %ecx
movl %ecx, 0x1c(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x90(%rsp)
movups (%rbx), %xmm0
movaps %xmm0, 0x80(%rsp)
testq %r14, %r14
je 0xf17d
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movq 0xd0(%rsp), %rax
movq %rax, 0x10(%rsp)
movdqu 0xc0(%rsp), %xmm0
movdqu %xmm0, (%rsp)
callq 0x142c2
testl %eax, %eax
je 0xf1d1
movq 0x4b030(%rip), %rcx # 0x5a1d8
movdqu (%rcx), %xmm0
movdqu 0x10(%rcx), %xmm1
pcmpeqb 0x70(%rsp), %xmm1
pcmpeqb 0x60(%rsp), %xmm0
pand %xmm1, %xmm0
pmovmskb %xmm0, %ecx
cmpl $0xffff, %ecx # imm = 0xFFFF
je 0xf37c
movq %rbp, 0x48(%rsp)
testl %eax, %eax
setle %r12b
jle 0xf3bb
movl %eax, %ebp
movl $0x20, %ebx
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %r14, %r13
pxor %xmm0, %xmm0
movdqa %xmm0, 0x130(%rsp)
movdqa %xmm0, 0x120(%rsp)
movdqa %xmm0, 0xb0(%rsp)
movdqa %xmm0, 0xa0(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x80(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x180(%rsp), %r14
movq %r14, %rdi
movl %r15d, %esi
callq 0x14147
leaq 0x108(%rsp), %rdi
movq %r14, %rsi
leaq 0x30128(%rip), %rdx # 0x3f380
callq 0x14ddd
leaq 0xf0(%rsp), %rdi
movq %r14, %rsi
leaq 0x2ee98(%rip), %rdx # 0x3e107
callq 0x14ddd
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movl 0xf0(%rsp), %edi
movq 0xf8(%rsp), %rsi
leaq 0x120(%rsp), %r14
movq %r14, %rdx
callq 0x16aa8
movq 0x118(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x108(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0xa0(%rsp), %rdi
movl $0x20, %esi
movq %r14, %rdx
leaq 0x50(%rsp), %rcx
callq 0x109a4
testl %eax, %eax
je 0xf399
movdqa 0xa0(%rsp), %xmm0
movdqa 0xb0(%rsp), %xmm1
pcmpeqb 0x70(%rsp), %xmm1
pcmpeqb 0x60(%rsp), %xmm0
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0xf3a2
movq %r13, %r14
testq %r13, %r13
je 0xf340
cmpl 0x1c(%rsp), %ebx
ja 0xf340
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
movq %rdi, %rdx
callq 0x10ef0
cmpl $0x1, %eax
jne 0xf340
movslq %ebx, %rdi
addq %r14, %rdi
movl 0x50(%rsp), %edx
subq %rdx, %rdi
movq 0x58(%rsp), %rsi
callq 0x5060
incq %r15
cmpq %rbp, %r15
setae %r12b
addl $0x20, %ebx
cmpq %r15, %rbp
jne 0xf1ef
jmp 0xf3bb
movq %rbx, %rsi
leaq 0x70(%rbp), %rdi
callq 0x18879
movb $0x0, 0x68(%rbp)
xorl %eax, %eax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x70(%rbp), %rdi
leaq 0x2f4aa(%rip), %rsi # 0x3e831
callq 0x18879
movb $0x0, 0x68(%rbp)
leaq 0x2f363(%rip), %rsi # 0x3e6fa
jmp 0xf35b
leaq 0x2f35a(%rip), %rsi # 0x3e6fa
jmp 0xf3a9
leaq 0x2f4d1(%rip), %rsi # 0x3e87a
movq 0x48(%rsp), %rbx
leaq 0x70(%rbx), %rdi
callq 0x18879
movb $0x0, 0x68(%rbx)
movb $0x1, %al
testb $0x1, %r12b
jne 0xf36a
leaq 0x2f330(%rip), %rsi # 0x3e6fa
movq 0x48(%rsp), %rbp
jmp 0xf35b
| eth_verify_account_proof_exec:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 198h
mov r14, r9
mov [rsp+1C8h+var_1AC], r8d
mov r15d, ecx
mov rbx, rdx
mov r12, rsi
mov rbp, rdi
lea rdx, aAccountproof; "accountProof"
lea rdi, [rsp+1C8h+var_F0]
call ssz_get
lea rdx, aAddress; "address"
lea r13, [rsp+1C8h+var_60]
mov rdi, r13
mov rsi, r12
call ssz_get
xorps xmm0, xmm0
lea rdx, [rsp+1C8h+var_88]
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
movaps [rsp+1C8h+var_198], xmm0
movaps [rsp+1C8h+var_1A8], xmm0
movaps [rsp+1C8h+var_158], xmm0
movaps [rsp+1C8h+var_168], xmm0
mov edi, [r13+0]
mov rsi, [r13+8]
call keccak
cmp r15d, 3
jz short loc_F00B
cmp r15d, 4
jnz short loc_F022
mov rax, cs:EMPTY_HASH
jmp short loc_F012
loc_F00B:
mov rax, cs:EMPTY_ROOT_HASH
loc_F012:
movups xmm0, xmmword ptr [rax]
movdqu xmm1, xmmword ptr [rax+10h]
movdqu xmmword ptr [r14+10h], xmm1
jmp short loc_F02A
loc_F022:
xorps xmm0, xmm0
movups xmmword ptr [r14+10h], xmm0
loc_F02A:
movups xmmword ptr [r14], xmm0
mov rax, [rsp+1C8h+var_E0]
mov [rsp+1C8h+var_1B8], rax
movdqu xmm0, [rsp+1C8h+var_F0]
movdqu [rsp+1C8h+var_1C8], xmm0
lea rdx, [rsp+1C8h+var_88]
lea rcx, [rsp+1C8h+var_198]
mov rdi, rbx
mov esi, 20h ; ' '
call patricia_verify
lea rbx, aInvalidAccount; "invalid account proof on execution laye"...
test eax, eax
jz loc_F358
cmp eax, 1
jnz loc_F126
cmp qword ptr [rsp+1C8h+var_198+8], 0
jz loc_F358
lea rdi, [rsp+1C8h+var_198]
xor esi, esi
mov rdx, rdi
call rlp_decode
cmp eax, 2
jnz loc_F358
lea rdi, [rsp+1C8h+var_198]
lea rdx, [rsp+1C8h+var_1A8]
mov esi, 2
call rlp_decode
lea rsi, aInvalidAccount_0; "invalid account proof for storage hash!"
cmp eax, 1
jnz loc_F35B
mov edx, dword ptr [rsp+1C8h+var_1A8]
cmp rdx, 20h ; ' '
ja loc_F35B
mov rsi, qword ptr [rsp+1C8h+var_1A8+8]
lea rdi, [rsp+1C8h+var_168]
call _memcpy
test r15d, r15d
jz short loc_F126
lea esi, [r15-1]
lea rdi, [rsp+1C8h+var_198]
lea rdx, [rsp+1C8h+var_1A8]
call rlp_decode
cmp eax, 1
jnz loc_F358
mov edx, dword ptr [rsp+1C8h+var_1A8]
mov rsi, rbx
cmp rdx, 20h ; ' '
ja loc_F35B
mov rdi, r14
sub rdi, rdx
add rdi, 20h ; ' '
mov rsi, qword ptr [rsp+1C8h+var_1A8+8]
call _memcpy
loc_F126:
lea rdx, aStorageproof; "storageProof"
lea rbx, [rsp+1C8h+var_108]
mov rdi, rbx
mov rsi, r12
call ssz_get
xor eax, eax
cmp r15d, 3
cmovnz r14, rax
mov ecx, [rsp+1C8h+var_1AC]
cmovnz ecx, eax
mov [rsp+1C8h+var_1AC], ecx
mov rax, [rbx+10h]
mov [rsp+1C8h+var_138], rax
movups xmm0, xmmword ptr [rbx]
movaps [rsp+1C8h+var_148], xmm0
test r14, r14
jz short loc_F17D
xorps xmm0, xmm0
movups xmmword ptr [r14+10h], xmm0
movups xmmword ptr [r14], xmm0
loc_F17D:
mov rax, [rsp+1C8h+var_F8]
mov [rsp+1C8h+var_1B8], rax
movdqu xmm0, [rsp+1C8h+var_108]
movdqu [rsp+1C8h+var_1C8], xmm0
call ssz_len
test eax, eax
jz short loc_F1D1
mov rcx, cs:EMPTY_ROOT_HASH
movdqu xmm0, xmmword ptr [rcx]
movdqu xmm1, xmmword ptr [rcx+10h]
pcmpeqb xmm1, [rsp+1C8h+var_158]
pcmpeqb xmm0, [rsp+1C8h+var_168]
pand xmm0, xmm1
pmovmskb ecx, xmm0
cmp ecx, 0FFFFh
jz loc_F37C
loc_F1D1:
mov [rsp+1C8h+var_180], rbp
test eax, eax
setle r12b
jle loc_F3BB
mov ebp, eax
mov ebx, 20h ; ' '
xor r15d, r15d
xor r12d, r12d
loc_F1EF:
mov r13, r14
pxor xmm0, xmm0
movdqa [rsp+1C8h+var_98], xmm0
movdqa [rsp+1C8h+var_A8], xmm0
movdqa [rsp+1C8h+var_118], xmm0
movdqa [rsp+1C8h+var_128], xmm0
mov rax, [rsp+1C8h+var_138]
mov [rsp+1C8h+var_1B8], rax
movaps xmm0, [rsp+1C8h+var_148]
movups [rsp+1C8h+var_1C8], xmm0
lea r14, [rsp+1C8h+var_48]
mov rdi, r14
mov esi, r15d
call ssz_at
lea rdi, [rsp+1C8h+var_C0]
mov rsi, r14
lea rdx, aMerkleProof+7; "proof"
call ssz_get
lea rdi, [rsp+1C8h+var_D8]
mov rsi, r14
lea rdx, aAggregatepubke+0Ch; "key"
call ssz_get
xorps xmm0, xmm0
movaps [rsp+1C8h+var_178], xmm0
mov edi, [rsp+1C8h+var_D8]
mov rsi, [rsp+1C8h+var_D0]
lea r14, [rsp+1C8h+var_A8]
mov rdx, r14
call keccak
mov rax, [rsp+1C8h+var_B0]
mov [rsp+1C8h+var_1B8], rax
movups xmm0, [rsp+1C8h+var_C0]
movups [rsp+1C8h+var_1C8], xmm0
lea rdi, [rsp+1C8h+var_128]
mov esi, 20h ; ' '
mov rdx, r14
lea rcx, [rsp+1C8h+var_178]
call patricia_verify
test eax, eax
jz loc_F399
movdqa xmm0, [rsp+1C8h+var_128]
movdqa xmm1, [rsp+1C8h+var_118]
pcmpeqb xmm1, [rsp+1C8h+var_158]
pcmpeqb xmm0, [rsp+1C8h+var_168]
pand xmm0, xmm1
pmovmskb eax, xmm0
cmp eax, 0FFFFh
jnz loc_F3A2
mov r14, r13
test r13, r13
jz short loc_F340
cmp ebx, [rsp+1C8h+var_1AC]
ja short loc_F340
lea rdi, [rsp+1C8h+var_178]
xor esi, esi
mov rdx, rdi
call rlp_decode
cmp eax, 1
jnz short loc_F340
movsxd rdi, ebx
add rdi, r14
mov edx, dword ptr [rsp+1C8h+var_178]
sub rdi, rdx
mov rsi, qword ptr [rsp+1C8h+var_178+8]
call _memcpy
loc_F340:
inc r15
cmp r15, rbp
setnb r12b
add ebx, 20h ; ' '
cmp rbp, r15
jnz loc_F1EF
jmp short loc_F3BB
loc_F358:
mov rsi, rbx
loc_F35B:
lea rdi, [rbp+70h]
call c4_state_add_error
mov byte ptr [rbp+68h], 0
xor eax, eax
loc_F36A:
add rsp, 198h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_F37C:
lea rdi, [rbp+70h]
lea rsi, aInvalidStorage; "invalid storage proof because an empty "...
call c4_state_add_error
mov byte ptr [rbp+68h], 0
lea rsi, aInvalidStorage_0; "invalid storage proof!"
jmp short loc_F35B
loc_F399:
lea rsi, aInvalidStorage_0; "invalid storage proof!"
jmp short loc_F3A9
loc_F3A2:
lea rsi, aInvalidStorage_1; "invalid storage root!"
loc_F3A9:
mov rbx, [rsp+1C8h+var_180]
lea rdi, [rbx+70h]
call c4_state_add_error
mov byte ptr [rbx+68h], 0
loc_F3BB:
mov al, 1
test r12b, 1
jnz short loc_F36A
lea rsi, aInvalidStorage_0; "invalid storage proof!"
mov rbp, [rsp+1C8h+var_180]
jmp short loc_F35B
| char eth_verify_account_proof_exec(long long a1, long long a2, int a3, int a4, unsigned int a5, __m128i *a6)
{
long long v10; // rbp
int v11; // r8d
int v12; // r9d
const __m128i *v13; // rax
__m128i v14; // xmm0
int v15; // eax
const char *v16; // rsi
int v17; // edx
int v18; // r8d
int v19; // r9d
unsigned int v20; // ecx
__m128i v21; // xmm0
int v22; // eax
int v23; // edx
int v24; // ecx
int v25; // r8d
int v26; // r9d
bool v27; // r12
unsigned long long v28; // rbp
int v29; // ebx
long long v30; // r15
int v31; // r8d
int v32; // r9d
char result; // al
const char *v34; // rsi
long long v35; // rbx
unsigned int v37; // [rsp+1Ch] [rbp-1ACh]
__int128 v38; // [rsp+20h] [rbp-1A8h] BYREF
__int128 v39; // [rsp+30h] [rbp-198h] BYREF
long long v40; // [rsp+48h] [rbp-180h]
__int128 v41; // [rsp+50h] [rbp-178h] BYREF
__m128i v42; // [rsp+60h] [rbp-168h] BYREF
__m128i v43; // [rsp+70h] [rbp-158h]
__m128i v44; // [rsp+80h] [rbp-148h]
long long v45; // [rsp+90h] [rbp-138h]
__m128i v46; // [rsp+A0h] [rbp-128h] BYREF
__m128i v47; // [rsp+B0h] [rbp-118h] BYREF
__m128i v48; // [rsp+C0h] [rbp-108h] BYREF
long long v49; // [rsp+D0h] [rbp-F8h]
__m128i v50; // [rsp+D8h] [rbp-F0h] BYREF
long long v51; // [rsp+E8h] [rbp-E0h]
unsigned int v52; // [rsp+F0h] [rbp-D8h] BYREF
long long v53; // [rsp+F8h] [rbp-D0h]
__int128 v54; // [rsp+108h] [rbp-C0h] BYREF
long long v55; // [rsp+118h] [rbp-B0h]
_OWORD v56[2]; // [rsp+120h] [rbp-A8h] BYREF
_BYTE v57[40]; // [rsp+140h] [rbp-88h] BYREF
unsigned int v58; // [rsp+168h] [rbp-60h] BYREF
long long v59; // [rsp+170h] [rbp-58h]
_BYTE v60[72]; // [rsp+180h] [rbp-48h] BYREF
v10 = a1;
ssz_get(&v50, a2, "accountProof");
ssz_get(&v58, a2, "address");
memset(v57, 0, 32);
v39 = 0LL;
v38 = 0LL;
v43 = 0LL;
v42 = 0LL;
keccak(v58, v59, v57);
if ( a4 == 3 )
{
v13 = (const __m128i *)EMPTY_ROOT_HASH;
}
else
{
if ( a4 != 4 )
{
v14 = 0LL;
a6[1] = 0LL;
goto LABEL_7;
}
v13 = (const __m128i *)EMPTY_HASH;
}
v14 = *v13;
a6[1] = _mm_loadu_si128(v13 + 1);
LABEL_7:
*a6 = v14;
v15 = patricia_verify(a3, 32, (unsigned int)v57, (unsigned int)&v39, v11, v12, *(_OWORD *)&_mm_loadu_si128(&v50), v51);
if ( !v15 )
goto LABEL_35;
if ( v15 != 1 )
goto LABEL_17;
if ( !*((_QWORD *)&v39 + 1) || (unsigned int)rlp_decode(&v39, 0LL, &v39) != 2 )
goto LABEL_35;
v16 = "invalid account proof for storage hash!";
if ( (unsigned int)rlp_decode(&v39, 2LL, &v38) != 1 || (unsigned int)v38 > 0x20uLL )
goto LABEL_36;
memcpy(&v42, *((_QWORD *)&v38 + 1), (unsigned int)v38);
if ( a4 )
{
if ( (unsigned int)rlp_decode(&v39, (unsigned int)(a4 - 1), &v38) == 1 )
{
v16 = "invalid account proof on execution layer!";
if ( (unsigned int)v38 <= 0x20uLL )
{
memcpy((char *)&a6[2] - (unsigned int)v38, *((_QWORD *)&v38 + 1), (unsigned int)v38);
goto LABEL_17;
}
LABEL_36:
c4_state_add_error(v10 + 112, v16);
*(_BYTE *)(v10 + 104) = 0;
return 0;
}
LABEL_35:
v16 = "invalid account proof on execution layer!";
goto LABEL_36;
}
LABEL_17:
ssz_get(&v48, a2, "storageProof");
if ( a4 != 3 )
a6 = 0LL;
v20 = a5;
if ( a4 != 3 )
v20 = 0;
v37 = v20;
v45 = v49;
v44 = v48;
if ( a6 )
{
a6[1] = 0LL;
*a6 = 0LL;
}
v21 = _mm_loadu_si128(&v48);
v22 = ssz_len((unsigned int)&v48, a2, v17, v20, v18, v19, v21.m128i_i8[0], v21.m128i_i32[2], v49);
if ( v22 )
{
v24 = _mm_movemask_epi8(
_mm_and_si128(
_mm_cmpeq_epi8(_mm_loadu_si128((const __m128i *)EMPTY_ROOT_HASH), v42),
_mm_cmpeq_epi8(_mm_loadu_si128((const __m128i *)EMPTY_ROOT_HASH + 1), v43)));
if ( v24 == 0xFFFF )
{
c4_state_add_error(a1 + 112, "invalid storage proof because an empty storage hash can not have values!");
*(_BYTE *)(a1 + 104) = 0;
v16 = "invalid storage proof!";
goto LABEL_36;
}
}
v40 = a1;
v27 = v22 <= 0;
if ( v22 > 0 )
{
v28 = (unsigned int)v22;
v29 = 32;
v30 = 0LL;
v27 = 0;
while ( 1 )
{
memset(v56, 0, sizeof(v56));
v47 = 0LL;
v46 = 0LL;
ssz_at((unsigned int)v60, v30, v23, v24, v25, v26, v44.m128i_i32[0], v44.m128i_i64[1], v45);
ssz_get(&v54, v60, "proof");
ssz_get(&v52, v60, "key");
v41 = 0LL;
keccak(v52, v53, v56);
if ( !(unsigned int)patricia_verify(
(unsigned int)&v46,
32,
(unsigned int)v56,
(unsigned int)&v41,
v31,
v32,
v54,
v55) )
{
v34 = "invalid storage proof!";
goto LABEL_41;
}
if ( _mm_movemask_epi8(_mm_and_si128(_mm_cmpeq_epi8(_mm_load_si128(&v46), v42), _mm_cmpeq_epi8(_mm_load_si128(&v47), v43))) != 0xFFFF )
break;
if ( a6 && v29 <= v37 && (unsigned int)rlp_decode(&v41, 0LL, &v41) == 1 )
memcpy((char *)&a6[v29 / 0x10u] - (unsigned int)v41, *((_QWORD *)&v41 + 1), (unsigned int)v41);
v27 = ++v30 >= v28;
v29 += 32;
if ( v28 == v30 )
goto LABEL_42;
}
v34 = "invalid storage root!";
LABEL_41:
v35 = v40;
c4_state_add_error(v40 + 112, v34);
*(_BYTE *)(v35 + 104) = 0;
}
LABEL_42:
result = 1;
if ( !v27 )
{
v16 = "invalid storage proof!";
v10 = v40;
goto LABEL_36;
}
return result;
}
| eth_verify_account_proof_exec:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x198
MOV R14,R9
MOV dword ptr [RSP + 0x1c],R8D
MOV R15D,ECX
MOV RBX,RDX
MOV R12,RSI
MOV RBP,RDI
LEA RDX,[0x13d68a]
LEA RDI,[RSP + 0xd8]
CALL 0x00114ddd
LEA RDX,[0x13d697]
LEA R13,[RSP + 0x168]
MOV RDI,R13
MOV RSI,R12
CALL 0x00114ddd
XORPS XMM0,XMM0
LEA RDX,[RSP + 0x140]
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOV EDI,dword ptr [R13]
MOV RSI,qword ptr [R13 + 0x8]
CALL 0x00116aa8
CMP R15D,0x3
JZ 0x0010f00b
CMP R15D,0x4
JNZ 0x0010f022
MOV RAX,qword ptr [0x0015a1d0]
JMP 0x0010f012
LAB_0010f00b:
MOV RAX,qword ptr [0x0015a1d8]
LAB_0010f012:
MOVUPS XMM0,xmmword ptr [RAX]
MOVDQU XMM1,xmmword ptr [RAX + 0x10]
MOVDQU xmmword ptr [R14 + 0x10],XMM1
JMP 0x0010f02a
LAB_0010f022:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x10],XMM0
LAB_0010f02a:
MOVUPS xmmword ptr [R14],XMM0
MOV RAX,qword ptr [RSP + 0xe8]
MOV qword ptr [RSP + 0x10],RAX
MOVDQU XMM0,xmmword ptr [RSP + 0xd8]
MOVDQU xmmword ptr [RSP],XMM0
LEA RDX,[RSP + 0x140]
LEA RCX,[RSP + 0x30]
MOV RDI,RBX
MOV ESI,0x20
CALL 0x001109a4
LEA RBX,[0x13e422]
TEST EAX,EAX
JZ 0x0010f358
CMP EAX,0x1
JNZ 0x0010f126
CMP qword ptr [RSP + 0x38],0x0
JZ 0x0010f358
LEA RDI,[RSP + 0x30]
XOR ESI,ESI
MOV RDX,RDI
CALL 0x00110ef0
CMP EAX,0x2
JNZ 0x0010f358
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0x20]
MOV ESI,0x2
CALL 0x00110ef0
LEA RSI,[0x13e6d2]
CMP EAX,0x1
JNZ 0x0010f35b
MOV EDX,dword ptr [RSP + 0x20]
CMP RDX,0x20
JA 0x0010f35b
MOV RSI,qword ptr [RSP + 0x28]
LEA RDI,[RSP + 0x60]
CALL 0x00105060
TEST R15D,R15D
JZ 0x0010f126
LEA ESI,[R15 + -0x1]
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0x20]
CALL 0x00110ef0
CMP EAX,0x1
JNZ 0x0010f358
MOV EDX,dword ptr [RSP + 0x20]
MOV RSI,RBX
CMP RDX,0x20
JA 0x0010f35b
MOV RDI,R14
SUB RDI,RDX
ADD RDI,0x20
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00105060
LAB_0010f126:
LEA RDX,[0x13d69f]
LEA RBX,[RSP + 0xc0]
MOV RDI,RBX
MOV RSI,R12
CALL 0x00114ddd
XOR EAX,EAX
CMP R15D,0x3
CMOVNZ R14,RAX
MOV ECX,dword ptr [RSP + 0x1c]
CMOVNZ ECX,EAX
MOV dword ptr [RSP + 0x1c],ECX
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RSP + 0x90],RAX
MOVUPS XMM0,xmmword ptr [RBX]
MOVAPS xmmword ptr [RSP + 0x80],XMM0
TEST R14,R14
JZ 0x0010f17d
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x10],XMM0
MOVUPS xmmword ptr [R14],XMM0
LAB_0010f17d:
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x10],RAX
MOVDQU XMM0,xmmword ptr [RSP + 0xc0]
MOVDQU xmmword ptr [RSP],XMM0
CALL 0x001142c2
TEST EAX,EAX
JZ 0x0010f1d1
MOV RCX,qword ptr [0x0015a1d8]
MOVDQU XMM0,xmmword ptr [RCX]
MOVDQU XMM1,xmmword ptr [RCX + 0x10]
PCMPEQB XMM1,xmmword ptr [RSP + 0x70]
PCMPEQB XMM0,xmmword ptr [RSP + 0x60]
PAND XMM0,XMM1
PMOVMSKB ECX,XMM0
CMP ECX,0xffff
JZ 0x0010f37c
LAB_0010f1d1:
MOV qword ptr [RSP + 0x48],RBP
TEST EAX,EAX
SETLE R12B
JLE 0x0010f3bb
MOV EBP,EAX
MOV EBX,0x20
XOR R15D,R15D
XOR R12D,R12D
LAB_0010f1ef:
MOV R13,R14
PXOR XMM0,XMM0
MOVDQA xmmword ptr [RSP + 0x130],XMM0
MOVDQA xmmword ptr [RSP + 0x120],XMM0
MOVDQA xmmword ptr [RSP + 0xb0],XMM0
MOVDQA xmmword ptr [RSP + 0xa0],XMM0
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x10],RAX
MOVAPS XMM0,xmmword ptr [RSP + 0x80]
MOVUPS xmmword ptr [RSP],XMM0
LEA R14,[RSP + 0x180]
MOV RDI,R14
MOV ESI,R15D
CALL 0x00114147
LEA RDI,[RSP + 0x108]
MOV RSI,R14
LEA RDX,[0x13f380]
CALL 0x00114ddd
LEA RDI,[RSP + 0xf0]
MOV RSI,R14
LEA RDX,[0x13e107]
CALL 0x00114ddd
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOV EDI,dword ptr [RSP + 0xf0]
MOV RSI,qword ptr [RSP + 0xf8]
LEA R14,[RSP + 0x120]
MOV RDX,R14
CALL 0x00116aa8
MOV RAX,qword ptr [RSP + 0x118]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x108]
MOVUPS xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0xa0]
MOV ESI,0x20
MOV RDX,R14
LEA RCX,[RSP + 0x50]
CALL 0x001109a4
TEST EAX,EAX
JZ 0x0010f399
MOVDQA XMM0,xmmword ptr [RSP + 0xa0]
MOVDQA XMM1,xmmword ptr [RSP + 0xb0]
PCMPEQB XMM1,xmmword ptr [RSP + 0x70]
PCMPEQB XMM0,xmmword ptr [RSP + 0x60]
PAND XMM0,XMM1
PMOVMSKB EAX,XMM0
CMP EAX,0xffff
JNZ 0x0010f3a2
MOV R14,R13
TEST R13,R13
JZ 0x0010f340
CMP EBX,dword ptr [RSP + 0x1c]
JA 0x0010f340
LEA RDI,[RSP + 0x50]
XOR ESI,ESI
MOV RDX,RDI
CALL 0x00110ef0
CMP EAX,0x1
JNZ 0x0010f340
MOVSXD RDI,EBX
ADD RDI,R14
MOV EDX,dword ptr [RSP + 0x50]
SUB RDI,RDX
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00105060
LAB_0010f340:
INC R15
CMP R15,RBP
SETNC R12B
ADD EBX,0x20
CMP RBP,R15
JNZ 0x0010f1ef
JMP 0x0010f3bb
LAB_0010f358:
MOV RSI,RBX
LAB_0010f35b:
LEA RDI,[RBP + 0x70]
CALL 0x00118879
MOV byte ptr [RBP + 0x68],0x0
XOR EAX,EAX
LAB_0010f36a:
ADD RSP,0x198
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010f37c:
LEA RDI,[RBP + 0x70]
LEA RSI,[0x13e831]
CALL 0x00118879
MOV byte ptr [RBP + 0x68],0x0
LEA RSI,[0x13e6fa]
JMP 0x0010f35b
LAB_0010f399:
LEA RSI,[0x13e6fa]
JMP 0x0010f3a9
LAB_0010f3a2:
LEA RSI,[0x13e87a]
LAB_0010f3a9:
MOV RBX,qword ptr [RSP + 0x48]
LEA RDI,[RBX + 0x70]
CALL 0x00118879
MOV byte ptr [RBX + 0x68],0x0
LAB_0010f3bb:
MOV AL,0x1
TEST R12B,0x1
JNZ 0x0010f36a
LEA RSI,[0x13e6fa]
MOV RBP,qword ptr [RSP + 0x48]
JMP 0x0010f35b
|
int8
eth_verify_account_proof_exec
(long param_1,int8 param_2,int8 param_3,int param_4,uint param_5,
int8 *param_6)
{
int8 uVar1;
long lVar2;
int iVar3;
uint uVar4;
int8 *puVar5;
uint uVar6;
char *pcVar7;
ulong uVar8;
bool bVar9;
int8 uVar10;
int8 uVar13;
int1 auVar11 [16];
int1 auVar12 [16];
int1 auVar14 [16];
int1 auVar15 [16];
ulong local_1a8;
void *pvStack_1a0;
int8 local_198;
long lStack_190;
long local_180;
ulong local_178;
void *pvStack_170;
int8 local_168;
int8 uStack_160;
int8 local_158;
int8 uStack_150;
int8 local_148;
int8 uStack_140;
int8 local_138;
int1 local_128 [16];
int1 local_118 [16];
int8 local_108;
int8 uStack_100;
int8 local_f8;
int1 local_f0 [24];
int4 local_d8 [2];
int8 local_d0;
int1 local_c0 [24];
int1 local_a8 [16];
int1 local_98 [16];
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int4 local_60 [2];
int8 local_58;
int1 local_48 [24];
ssz_get(local_f0,param_2,"accountProof");
ssz_get(local_60,param_2,"address");
local_78 = 0;
uStack_70 = 0;
local_88 = 0;
uStack_80 = 0;
local_198 = 0;
lStack_190 = 0;
local_1a8 = 0;
pvStack_1a0 = (void *)0x0;
local_158 = 0;
uStack_150 = 0;
local_168 = 0;
uStack_160 = 0;
keccak(local_60[0],local_58);
puVar5 = (int8 *)EMPTY_ROOT_HASH;
if ((param_4 == 3) || (puVar5 = (int8 *)EMPTY_HASH, param_4 == 4)) {
uVar10 = *puVar5;
uVar13 = puVar5[1];
uVar1 = puVar5[3];
param_6[2] = puVar5[2];
param_6[3] = uVar1;
}
else {
uVar10 = 0;
uVar13 = 0;
param_6[2] = 0;
param_6[3] = 0;
}
*param_6 = uVar10;
param_6[1] = uVar13;
iVar3 = patricia_verify(param_3,0x20,&local_88,&local_198);
if (iVar3 == 0) {
LAB_0010f358:
pcVar7 = "invalid account proof on execution layer!";
}
else {
if (iVar3 == 1) {
if ((lStack_190 == 0) || (iVar3 = rlp_decode(&local_198,0,&local_198), iVar3 != 2))
goto LAB_0010f358;
iVar3 = rlp_decode(&local_198,2,&local_1a8);
pcVar7 = "invalid account proof for storage hash!";
if ((iVar3 != 1) || (0x20 < (local_1a8 & 0xffffffff))) goto LAB_0010f35b;
memcpy(&local_168,pvStack_1a0,local_1a8 & 0xffffffff);
if (param_4 != 0) {
iVar3 = rlp_decode(&local_198,param_4 + -1,&local_1a8);
if (iVar3 != 1) goto LAB_0010f358;
uVar8 = local_1a8 & 0xffffffff;
pcVar7 = "invalid account proof on execution layer!";
if (0x20 < uVar8) goto LAB_0010f35b;
memcpy((void *)((long)param_6 + (0x20 - uVar8)),pvStack_1a0,uVar8);
}
}
ssz_get(&local_108,param_2,"storageProof");
if (param_4 != 3) {
param_6 = (int8 *)0x0;
}
puVar5 = (int8 *)(ulong)param_5;
if (param_4 != 3) {
puVar5 = (int8 *)0x0;
}
local_138 = local_f8;
local_148 = local_108;
uStack_140 = uStack_100;
if (param_6 != (int8 *)0x0) {
param_6[2] = 0;
param_6[3] = 0;
*param_6 = 0;
param_6[1] = 0;
}
uVar4 = ssz_len();
if (uVar4 != 0) {
auVar14[0] = -(EMPTY_ROOT_HASH[0x10] == (char)local_158);
auVar14[1] = -(EMPTY_ROOT_HASH[0x11] == local_158._1_1_);
auVar14[2] = -(EMPTY_ROOT_HASH[0x12] == local_158._2_1_);
auVar14[3] = -(EMPTY_ROOT_HASH[0x13] == local_158._3_1_);
auVar14[4] = -(EMPTY_ROOT_HASH[0x14] == local_158._4_1_);
auVar14[5] = -(EMPTY_ROOT_HASH[0x15] == local_158._5_1_);
auVar14[6] = -(EMPTY_ROOT_HASH[0x16] == local_158._6_1_);
auVar14[7] = -(EMPTY_ROOT_HASH[0x17] == local_158._7_1_);
auVar14[8] = -(EMPTY_ROOT_HASH[0x18] == (char)uStack_150);
auVar14[9] = -(EMPTY_ROOT_HASH[0x19] == uStack_150._1_1_);
auVar14[10] = -(EMPTY_ROOT_HASH[0x1a] == uStack_150._2_1_);
auVar14[0xb] = -(EMPTY_ROOT_HASH[0x1b] == uStack_150._3_1_);
auVar14[0xc] = -(EMPTY_ROOT_HASH[0x1c] == uStack_150._4_1_);
auVar14[0xd] = -(EMPTY_ROOT_HASH[0x1d] == uStack_150._5_1_);
auVar14[0xe] = -(EMPTY_ROOT_HASH[0x1e] == uStack_150._6_1_);
auVar14[0xf] = -(EMPTY_ROOT_HASH[0x1f] == uStack_150._7_1_);
auVar11[0] = -(*EMPTY_ROOT_HASH == (char)local_168);
auVar11[1] = -(EMPTY_ROOT_HASH[1] == local_168._1_1_);
auVar11[2] = -(EMPTY_ROOT_HASH[2] == local_168._2_1_);
auVar11[3] = -(EMPTY_ROOT_HASH[3] == local_168._3_1_);
auVar11[4] = -(EMPTY_ROOT_HASH[4] == local_168._4_1_);
auVar11[5] = -(EMPTY_ROOT_HASH[5] == local_168._5_1_);
auVar11[6] = -(EMPTY_ROOT_HASH[6] == local_168._6_1_);
auVar11[7] = -(EMPTY_ROOT_HASH[7] == local_168._7_1_);
auVar11[8] = -(EMPTY_ROOT_HASH[8] == (char)uStack_160);
auVar11[9] = -(EMPTY_ROOT_HASH[9] == uStack_160._1_1_);
auVar11[10] = -(EMPTY_ROOT_HASH[10] == uStack_160._2_1_);
auVar11[0xb] = -(EMPTY_ROOT_HASH[0xb] == uStack_160._3_1_);
auVar11[0xc] = -(EMPTY_ROOT_HASH[0xc] == uStack_160._4_1_);
auVar11[0xd] = -(EMPTY_ROOT_HASH[0xd] == uStack_160._5_1_);
auVar11[0xe] = -(EMPTY_ROOT_HASH[0xe] == uStack_160._6_1_);
auVar11[0xf] = -(EMPTY_ROOT_HASH[0xf] == uStack_160._7_1_);
auVar11 = auVar11 & auVar14;
if ((ushort)((ushort)(SUB161(auVar11 >> 7,0) & 1) |
(ushort)(SUB161(auVar11 >> 0xf,0) & 1) << 1 |
(ushort)(SUB161(auVar11 >> 0x17,0) & 1) << 2 |
(ushort)(SUB161(auVar11 >> 0x1f,0) & 1) << 3 |
(ushort)(SUB161(auVar11 >> 0x27,0) & 1) << 4 |
(ushort)(SUB161(auVar11 >> 0x2f,0) & 1) << 5 |
(ushort)(SUB161(auVar11 >> 0x37,0) & 1) << 6 |
(ushort)(SUB161(auVar11 >> 0x3f,0) & 1) << 7 |
(ushort)(SUB161(auVar11 >> 0x47,0) & 1) << 8 |
(ushort)(SUB161(auVar11 >> 0x4f,0) & 1) << 9 |
(ushort)(SUB161(auVar11 >> 0x57,0) & 1) << 10 |
(ushort)(SUB161(auVar11 >> 0x5f,0) & 1) << 0xb |
(ushort)(SUB161(auVar11 >> 0x67,0) & 1) << 0xc |
(ushort)(SUB161(auVar11 >> 0x6f,0) & 1) << 0xd |
(ushort)(SUB161(auVar11 >> 0x77,0) & 1) << 0xe |
(ushort)(byte)(auVar11[0xf] >> 7) << 0xf) == 0xffff) {
c4_state_add_error(param_1 + 0x70,
"invalid storage proof because an empty storage hash can not have values!"
);
*(int1 *)(param_1 + 0x68) = 0;
pcVar7 = "invalid storage proof!";
goto LAB_0010f35b;
}
}
bVar9 = (int)uVar4 < 1;
local_180 = param_1;
if (0 < (int)uVar4) {
uVar6 = 0x20;
uVar8 = 0;
bVar9 = false;
do {
local_98 = (int1 [16])0x0;
local_a8 = (int1 [16])0x0;
local_118 = (int1 [16])0x0;
local_128 = (int1 [16])0x0;
ssz_at(local_48,uVar8 & 0xffffffff);
ssz_get(local_c0,local_48,"proof");
ssz_get(local_d8,local_48,"key");
local_178 = 0;
pvStack_170 = (void *)0x0;
keccak(local_d8[0],local_d0,local_a8);
iVar3 = patricia_verify(local_128,0x20,local_a8,&local_178);
lVar2 = local_180;
if (iVar3 == 0) {
pcVar7 = "invalid storage proof!";
LAB_0010f3a9:
c4_state_add_error(local_180 + 0x70,pcVar7);
*(int1 *)(lVar2 + 0x68) = 0;
break;
}
auVar15[0] = -(local_118[0] == (char)local_158);
auVar15[1] = -(local_118[1] == local_158._1_1_);
auVar15[2] = -(local_118[2] == local_158._2_1_);
auVar15[3] = -(local_118[3] == local_158._3_1_);
auVar15[4] = -(local_118[4] == local_158._4_1_);
auVar15[5] = -(local_118[5] == local_158._5_1_);
auVar15[6] = -(local_118[6] == local_158._6_1_);
auVar15[7] = -(local_118[7] == local_158._7_1_);
auVar15[8] = -(local_118[8] == (char)uStack_150);
auVar15[9] = -(local_118[9] == uStack_150._1_1_);
auVar15[10] = -(local_118[10] == uStack_150._2_1_);
auVar15[0xb] = -(local_118[0xb] == uStack_150._3_1_);
auVar15[0xc] = -(local_118[0xc] == uStack_150._4_1_);
auVar15[0xd] = -(local_118[0xd] == uStack_150._5_1_);
auVar15[0xe] = -(local_118[0xe] == uStack_150._6_1_);
auVar15[0xf] = -(local_118[0xf] == uStack_150._7_1_);
auVar12[0] = -(local_128[0] == (char)local_168);
auVar12[1] = -(local_128[1] == local_168._1_1_);
auVar12[2] = -(local_128[2] == local_168._2_1_);
auVar12[3] = -(local_128[3] == local_168._3_1_);
auVar12[4] = -(local_128[4] == local_168._4_1_);
auVar12[5] = -(local_128[5] == local_168._5_1_);
auVar12[6] = -(local_128[6] == local_168._6_1_);
auVar12[7] = -(local_128[7] == local_168._7_1_);
auVar12[8] = -(local_128[8] == (char)uStack_160);
auVar12[9] = -(local_128[9] == uStack_160._1_1_);
auVar12[10] = -(local_128[10] == uStack_160._2_1_);
auVar12[0xb] = -(local_128[0xb] == uStack_160._3_1_);
auVar12[0xc] = -(local_128[0xc] == uStack_160._4_1_);
auVar12[0xd] = -(local_128[0xd] == uStack_160._5_1_);
auVar12[0xe] = -(local_128[0xe] == uStack_160._6_1_);
auVar12[0xf] = -(local_128[0xf] == uStack_160._7_1_);
auVar12 = auVar12 & auVar15;
if ((ushort)((ushort)(SUB161(auVar12 >> 7,0) & 1) |
(ushort)(SUB161(auVar12 >> 0xf,0) & 1) << 1 |
(ushort)(SUB161(auVar12 >> 0x17,0) & 1) << 2 |
(ushort)(SUB161(auVar12 >> 0x1f,0) & 1) << 3 |
(ushort)(SUB161(auVar12 >> 0x27,0) & 1) << 4 |
(ushort)(SUB161(auVar12 >> 0x2f,0) & 1) << 5 |
(ushort)(SUB161(auVar12 >> 0x37,0) & 1) << 6 |
(ushort)(SUB161(auVar12 >> 0x3f,0) & 1) << 7 |
(ushort)(SUB161(auVar12 >> 0x47,0) & 1) << 8 |
(ushort)(SUB161(auVar12 >> 0x4f,0) & 1) << 9 |
(ushort)(SUB161(auVar12 >> 0x57,0) & 1) << 10 |
(ushort)(SUB161(auVar12 >> 0x5f,0) & 1) << 0xb |
(ushort)(SUB161(auVar12 >> 0x67,0) & 1) << 0xc |
(ushort)(SUB161(auVar12 >> 0x6f,0) & 1) << 0xd |
(ushort)(SUB161(auVar12 >> 0x77,0) & 1) << 0xe |
(ushort)(byte)(auVar12[0xf] >> 7) << 0xf) != 0xffff) {
pcVar7 = "invalid storage root!";
goto LAB_0010f3a9;
}
if (((param_6 != (int8 *)0x0) && (uVar6 <= (uint)puVar5)) &&
(iVar3 = rlp_decode(&local_178,0,&local_178), iVar3 == 1)) {
memcpy((void *)((long)param_6 + ((long)(int)uVar6 - (local_178 & 0xffffffff))),pvStack_170
,local_178 & 0xffffffff);
}
uVar8 = uVar8 + 1;
bVar9 = uVar4 <= uVar8;
uVar6 = uVar6 + 0x20;
} while (uVar4 != uVar8);
}
if (bVar9) {
return 1;
}
pcVar7 = "invalid storage proof!";
param_1 = local_180;
}
LAB_0010f35b:
c4_state_add_error(param_1 + 0x70,pcVar7);
*(int1 *)(param_1 + 0x68) = 0;
return 0;
}
| |
26,347 | get_src_account | corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_ctx.h | static ssz_ob_t get_src_account(evmone_context_t* ctx, const address_t address, bool allow_missing) {
size_t len = ssz_len(ctx->src_accounts);
for (int i = 0; i < len; i++) {
ssz_ob_t account = ssz_at(ctx->src_accounts, i);
bytes_t addr = ssz_get(&account, "address").bytes;
if (memcmp(addr.data, address, 20) == 0)
return account;
}
if (ctx->parent)
return get_src_account(ctx->parent, address, allow_missing);
if (!ctx->ctx->state.error && !allow_missing) ctx->ctx->state.error = bprintf(NULL, "Missing account proof for 0x%x", bytes(address, 20));
return (ssz_ob_t) {0};
} | O0 | c | get_src_account:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movb %cl, %al
movq %rdi, -0x68(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xa0830
movl %eax, %eax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2dacc
movq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rax
addq $0x10, %rax
movl -0x24(%rbp), %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xa0580
movq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdi
leaq 0xafdc8(%rip), %rdx # 0xdd853
callq 0xa1c10
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x14, %edx
callq 0x23540
cmpl $0x0, %eax
jne 0x2dabc
jmp 0x2db58
jmp 0x2dabe
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2da45
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x2dafc
movq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rsi
movq -0x10(%rbp), %rdx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x2d9f0
jmp 0x2db58
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x78(%rax)
jne 0x2db48
testb $0x1, -0x11(%rbp)
jne 0x2db48
movl $0x14, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x60(%rbp), %edx
movq -0x58(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edi
leaq 0xafce4(%rip), %rsi # 0xdd816
movb $0x0, %al
callq 0x9ebf0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x78(%rax)
movq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x231c0
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| get_src_account:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_70], rdi
mov al, cl
mov [rbp+var_68], rdi
mov [rbp+var_8], rsi
mov [rbp+var_10], rdx
and al, 1
mov [rbp+var_11], al
mov rax, [rbp+var_8]
add rax, 10h
mov rcx, [rax]
mov [rsp+90h+var_90], rcx
mov rcx, [rax+8]
mov [rsp+90h+var_88], rcx
mov rax, [rax+10h]
mov [rsp+90h+var_80], rax
call ssz_len
mov eax, eax
mov [rbp+var_20], rax
mov [rbp+var_24], 0
loc_2DA45:
movsxd rax, [rbp+var_24]
cmp rax, [rbp+var_20]
jnb short loc_2DACC
mov rdi, [rbp+var_70]
mov rax, [rbp+var_8]
add rax, 10h
mov esi, [rbp+var_24]
mov rcx, [rax]
mov [rsp+90h+var_90], rcx
mov rcx, [rax+8]
mov [rsp+90h+var_88], rcx
mov rax, [rax+10h]
mov [rsp+90h+var_80], rax
call ssz_at
mov rsi, [rbp+var_70]
lea rdi, [rbp+var_50]
lea rdx, aCodeAddress+7; "address"
call ssz_get
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
mov rax, [rbp+var_48]
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_10]
mov edx, 14h
call _memcmp
cmp eax, 0
jnz short loc_2DABC
jmp loc_2DB58
loc_2DABC:
jmp short $+2
loc_2DABE:
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp loc_2DA45
loc_2DACC:
mov rax, [rbp+var_8]
cmp qword ptr [rax+90h], 0
jz short loc_2DAFC
mov rdi, [rbp+var_70]
mov rax, [rbp+var_8]
mov rsi, [rax+90h]
mov rdx, [rbp+var_10]
mov al, [rbp+var_11]
and al, 1
movzx ecx, al
call get_src_account
jmp short loc_2DB58
loc_2DAFC:
mov rax, [rbp+var_8]
mov rax, [rax+8]
cmp qword ptr [rax+78h], 0
jnz short loc_2DB48
test [rbp+var_11], 1
jnz short loc_2DB48
mov [rbp+var_60], 14h
mov rax, [rbp+var_10]
mov [rbp+var_58], rax
mov edx, [rbp+var_60]
mov rcx, [rbp+var_58]
xor eax, eax
mov edi, eax
lea rsi, aMissingAccount; "Missing account proof for 0x%x"
mov al, 0
call bprintf
mov rcx, rax
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rax+78h], rcx
loc_2DB48:
mov rdi, [rbp+var_70]
xor esi, esi
mov edx, 18h
call _memset
loc_2DB58:
mov rax, [rbp+var_68]
add rsp, 90h
pop rbp
retn
| long long get_src_account(long long a1, _QWORD *a2, long long a3, char a4, int a5, int a6)
{
int v6; // edx
int v7; // r8d
int v8; // r9d
long long v9; // rax
long long v11; // [rsp+40h] [rbp-50h] BYREF
long long v12; // [rsp+48h] [rbp-48h]
long long v13; // [rsp+58h] [rbp-38h]
long long v14; // [rsp+60h] [rbp-30h]
int i; // [rsp+6Ch] [rbp-24h]
unsigned long long v16; // [rsp+70h] [rbp-20h]
char v17; // [rsp+7Fh] [rbp-11h]
long long v18; // [rsp+80h] [rbp-10h]
_QWORD *v19; // [rsp+88h] [rbp-8h]
v19 = a2;
v18 = a3;
v17 = a4 & 1;
v16 = (unsigned int)ssz_len(a1, (_DWORD)a2, a3, a2[3], a5, a6, a2[2], a2[3], a2[4]);
for ( i = 0; i < v16; ++i )
{
ssz_at(a1, i, v6, v19[3], v7, v8, v19[2], v19[3], v19[4]);
ssz_get(&v11, a1, "address");
v13 = v11;
v14 = v12;
if ( !(unsigned int)memcmp(v12, v18, 20LL) )
return a1;
}
if ( v19[18] )
{
get_src_account(a1, v19[18], v18, v17 & 1);
}
else
{
if ( !*(_QWORD *)(v19[1] + 120LL) && (v17 & 1) == 0 )
{
v9 = bprintf(0, (unsigned int)"Missing account proof for 0x%x", 20, v18, v7, v8);
*(_QWORD *)(v19[1] + 120LL) = v9;
}
memset(a1, 0LL, 24LL);
}
return a1;
}
| get_src_account:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x70],RDI
MOV AL,CL
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x8],RSI
MOV qword ptr [RBP + -0x10],RDX
AND AL,0x1
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x10
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001a0830
MOV EAX,EAX
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x24],0x0
LAB_0012da45:
MOVSXD RAX,dword ptr [RBP + -0x24]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0012dacc
MOV RDI,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x10
MOV ESI,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001a0580
MOV RSI,qword ptr [RBP + -0x70]
LEA RDI,[RBP + -0x50]
LEA RDX,[0x1dd853]
CALL 0x001a1c10
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x14
CALL 0x00123540
CMP EAX,0x0
JNZ 0x0012dabc
JMP 0x0012db58
LAB_0012dabc:
JMP 0x0012dabe
LAB_0012dabe:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0012da45
LAB_0012dacc:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x90],0x0
JZ 0x0012dafc
MOV RDI,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0x90]
MOV RDX,qword ptr [RBP + -0x10]
MOV AL,byte ptr [RBP + -0x11]
AND AL,0x1
MOVZX ECX,AL
CALL 0x0012d9f0
JMP 0x0012db58
LAB_0012dafc:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
CMP qword ptr [RAX + 0x78],0x0
JNZ 0x0012db48
TEST byte ptr [RBP + -0x11],0x1
JNZ 0x0012db48
MOV dword ptr [RBP + -0x60],0x14
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV EDX,dword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
XOR EAX,EAX
MOV EDI,EAX
LEA RSI,[0x1dd816]
MOV AL,0x0
CALL 0x0019ebf0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x78],RCX
LAB_0012db48:
MOV RDI,qword ptr [RBP + -0x70]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x001231c0
LAB_0012db58:
MOV RAX,qword ptr [RBP + -0x68]
ADD RSP,0x90
POP RBP
RET
|
void * get_src_account(void *param_1,long param_2,void *param_3,byte param_4,int8 param_5,
int8 param_6)
{
uint uVar1;
int iVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
int8 local_58;
void *local_50;
int8 local_40;
void *local_38;
int local_2c;
ulong local_28;
byte local_19;
void *local_18;
long local_10;
local_19 = param_4 & 1;
uVar3 = *(int8 *)(param_2 + 0x10);
uVar4 = *(int8 *)(param_2 + 0x18);
uVar5 = *(int8 *)(param_2 + 0x20);
local_18 = param_3;
local_10 = param_2;
uVar1 = ssz_len();
local_28 = (ulong)uVar1;
local_2c = 0;
while( true ) {
if (local_28 <= (ulong)(long)local_2c) {
if (*(long *)(local_10 + 0x90) == 0) {
if ((*(long *)(*(long *)(local_10 + 8) + 0x78) == 0) && ((local_19 & 1) == 0)) {
uVar3 = bprintf(0,"Missing account proof for 0x%x",0x14,local_18,param_5,param_6,uVar3,
uVar4,uVar5);
*(int8 *)(*(long *)(local_10 + 8) + 0x78) = uVar3;
}
memset(param_1,0,0x18);
}
else {
get_src_account(param_1,*(int8 *)(local_10 + 0x90),local_18,local_19 & 1);
}
return param_1;
}
uVar3 = *(int8 *)(local_10 + 0x10);
uVar4 = *(int8 *)(local_10 + 0x18);
uVar5 = *(int8 *)(local_10 + 0x20);
ssz_at(param_1,local_2c);
ssz_get(&local_58,param_1,"address");
local_40 = local_58;
local_38 = local_50;
iVar2 = memcmp(local_50,local_18,0x14);
if (iVar2 == 0) break;
local_2c = local_2c + 1;
}
return param_1;
}
| |
26,348 | intx::bswap(unsigned int) | corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp | inline constexpr uint32_t bswap(uint32_t x) noexcept
{
#if __has_builtin(__builtin_bswap32)
return __builtin_bswap32(x);
#else
#ifdef _MSC_VER
if (!std::is_constant_evaluated())
return _byteswap_ulong(x);
#endif
const auto a = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0x00FF00FF);
return (a << 16) | (a >> 16);
#endif
} | O0 | cpp | intx::bswap(unsigned int):
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
bswapl %eax
popq %rbp
retq
nop
| _ZN4intx5bswapEj:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
bswap eax
pop rbp
retn
| long long intx::bswap(intx *this)
{
return _byteswap_ulong((unsigned int)this);
}
| bswap:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
BSWAP EAX
POP RBP
RET
|
/* intx::bswap(unsigned int) */
uint intx::bswap(uint param_1)
{
return param_1 >> 0x18 | (param_1 & 0xff0000) >> 8 | (param_1 & 0xff00) << 8 | param_1 << 0x18;
}
| |
26,349 | OpenSubdiv::v3_6_0::Far::PatchTable::GetPatchVertices(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle const&) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTable.cpp | ConstIndexArray
PatchTable::GetPatchVertices(PatchHandle const & handle) const {
PatchArray const & pa = getPatchArray(handle.arrayIndex);
Index vert = pa.vertIndex + handle.vertIndex;
return ConstIndexArray(&_patchVerts[vert], getPatchSize(pa.desc));
} | O3 | cpp | OpenSubdiv::v3_6_0::Far::PatchTable::GetPatchVertices(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle const&) const:
movslq (%rsi), %rax
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
imull $0xcccccccd, %ecx, %ecx # imm = 0xCCCCCCCD
cmpl %ecx, %eax
jge 0x6af61
leaq (%rax,%rax,4), %r8
movslq 0x8(%rdx,%r8,4), %rax
movslq 0x8(%rsi), %rcx
movq 0x20(%rdi), %rsi
movl (%rdx,%r8,4), %edi
decl %edi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpl $0x9, %edi
ja 0x6af59
movl %edi, %edx
leaq 0x50f3a(%rip), %rdi # 0xbbe90
movl (%rdi,%rdx,4), %edx
addq %rax, %rcx
leaq (%rsi,%rcx,4), %rax
retq
pushq %rax
leaq 0x514d4(%rip), %rdi # 0xbc43d
leaq 0x50fa2(%rip), %rsi # 0xbbf12
leaq 0x514ec(%rip), %rcx # 0xbc463
movl $0x90, %edx
callq 0x39540
nop
| _ZNK10OpenSubdiv6v3_6_03Far10PatchTable16GetPatchVerticesERKNS2_11PatchHandleE:
movsxd rax, dword ptr [rsi]
mov rdx, [rdi+8]
mov rcx, [rdi+10h]
sub rcx, rdx
shr rcx, 2
imul ecx, 0CCCCCCCDh
cmp eax, ecx
jge short loc_6AF61
lea r8, [rax+rax*4]
movsxd rax, dword ptr [rdx+r8*4+8]
movsxd rcx, dword ptr [rsi+8]
mov rsi, [rdi+20h]
mov edi, [rdx+r8*4]
dec edi
mov edx, 0FFFFFFFFh
cmp edi, 9
ja short loc_6AF59
mov edx, edi
lea rdi, dword_BBE90
mov edx, [rdi+rdx*4]
loc_6AF59:
add rcx, rax
lea rax, [rsi+rcx*4]
retn
loc_6AF61:
push rax
lea rdi, aArrayindexInde; "arrayIndex<(Index)GetNumPatchArrays()"
lea rsi, aWorkspaceLlm4b_16; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aConstPatchtabl; "const PatchTable::PatchArray &OpenSubdi"...
mov edx, 90h
call ___assert_fail
| long long OpenSubdiv::v3_6_0::Far::PatchTable::GetPatchVertices(_QWORD *a1, int *a2)
{
long long v2; // rax
long long v3; // rdx
v2 = *a2;
v3 = a1[1];
if ( (int)v2 >= (int)(-858993459 * ((unsigned long long)(a1[2] - v3) >> 2)) )
__assert_fail(
"arrayIndex<(Index)GetNumPatchArrays()",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTable.cpp",
144LL,
"const PatchTable::PatchArray &OpenSubdiv::v3_6_0::Far::PatchTable::getPatchArray(Index) const");
return a1[4] + 4 * (*(int *)(v3 + 20 * v2 + 8) + (long long)a2[2]);
}
| GetPatchVertices:
MOVSXD RAX,dword ptr [RSI]
MOV RDX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI + 0x10]
SUB RCX,RDX
SHR RCX,0x2
IMUL ECX,ECX,-0x33333333
CMP EAX,ECX
JGE 0x0016af61
LEA R8,[RAX + RAX*0x4]
MOVSXD RAX,dword ptr [RDX + R8*0x4 + 0x8]
MOVSXD RCX,dword ptr [RSI + 0x8]
MOV RSI,qword ptr [RDI + 0x20]
MOV EDI,dword ptr [RDX + R8*0x4]
DEC EDI
MOV EDX,0xffffffff
CMP EDI,0x9
JA 0x0016af59
MOV EDX,EDI
LEA RDI,[0x1bbe90]
MOV EDX,dword ptr [RDI + RDX*0x4]
LAB_0016af59:
ADD RCX,RAX
LEA RAX,[RSI + RCX*0x4]
RET
LAB_0016af61:
PUSH RAX
LEA RDI,[0x1bc43d]
LEA RSI,[0x1bbf12]
LEA RCX,[0x1bc463]
MOV EDX,0x90
CALL 0x00139540
|
/* OpenSubdiv::v3_6_0::Far::PatchTable::GetPatchVertices(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle
const&) const */
int1 [16] __thiscall
OpenSubdiv::v3_6_0::Far::PatchTable::GetPatchVertices(PatchTable *this,PatchHandle *param_1)
{
int iVar1;
long lVar2;
int iVar3;
ulong uVar4;
uint uVar5;
int1 auVar6 [16];
iVar1 = *(int *)param_1;
lVar2 = *(long *)(this + 8);
iVar3 = (int)((ulong)(*(long *)(this + 0x10) - lVar2) >> 2);
if (SBORROW4(iVar1,iVar3 * -0x33333333) != iVar1 + iVar3 * 0x33333333 < 0) {
uVar5 = *(int *)(lVar2 + (long)iVar1 * 0x14) - 1;
uVar4 = 0xffffffff;
if (uVar5 < 10) {
uVar4 = (ulong)*(uint *)(&DAT_001bbe90 + (ulong)uVar5 * 4);
}
auVar6._8_8_ = uVar4;
auVar6._0_8_ = *(long *)(this + 0x20) +
((long)*(int *)(param_1 + 8) + (long)*(int *)(lVar2 + 8 + (long)iVar1 * 0x14)) *
4;
return auVar6;
}
/* WARNING: Subroutine does not return */
__assert_fail("arrayIndex<(Index)GetNumPatchArrays()",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTable.cpp"
,0x90,
"const PatchTable::PatchArray &OpenSubdiv::v3_6_0::Far::PatchTable::getPatchArray(Index) const"
);
}
| |
26,350 | my_wildcmp_unicode_impl | eloqsql/strings/ctype-utf8.c | static
int my_wildcmp_unicode_impl(CHARSET_INFO *cs,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many,
MY_UNICASE_INFO *weights, int recurse_level)
{
int result= -1; /* Not found, using wildcards */
my_wc_t s_wc, w_wc;
int scan;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
if (my_string_stack_guard && my_string_stack_guard(recurse_level))
return 1;
while (wildstr != wildend)
{
while (1)
{
my_bool escaped= 0;
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
if (w_wc == (my_wc_t) w_many)
{
result= 1; /* Found an anchor char */
break;
}
wildstr+= scan;
if (w_wc == (my_wc_t) escape && wildstr < wildend)
{
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
wildstr+= scan;
escaped= 1;
}
if ((scan= mb_wc(cs, &s_wc, (const uchar*)str,
(const uchar*)str_end)) <= 0)
return 1;
str+= scan;
if (!escaped && w_wc == (my_wc_t) w_one)
{
result= 1; /* Found an anchor char */
}
else
{
if (weights)
{
my_tosort_unicode(weights, &s_wc, cs->state);
my_tosort_unicode(weights, &w_wc, cs->state);
}
if (s_wc != w_wc)
return 1; /* No match */
}
if (wildstr == wildend)
return (str != str_end); /* Match if both are at end */
}
if (w_wc == (my_wc_t) w_many)
{ /* Found w_many */
/* Remove any '%' and '_' from the wild search string */
for ( ; wildstr != wildend ; )
{
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
if (w_wc == (my_wc_t) w_many)
{
wildstr+= scan;
continue;
}
if (w_wc == (my_wc_t) w_one)
{
wildstr+= scan;
if ((scan= mb_wc(cs, &s_wc, (const uchar*)str,
(const uchar*)str_end)) <= 0)
return 1;
str+= scan;
continue;
}
break; /* Not a wild character */
}
if (wildstr == wildend)
return 0; /* Ok if w_many is last */
if (str == str_end)
return -1;
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
wildstr+= scan;
if (w_wc == (my_wc_t) escape)
{
if (wildstr < wildend)
{
if ((scan= mb_wc(cs, &w_wc, (const uchar*)wildstr,
(const uchar*)wildend)) <= 0)
return 1;
wildstr+= scan;
}
}
while (1)
{
/* Skip until the first character from wildstr is found */
while (str != str_end)
{
if ((scan= mb_wc(cs, &s_wc, (const uchar*)str,
(const uchar*)str_end)) <= 0)
return 1;
if (weights)
{
my_tosort_unicode(weights, &s_wc, cs->state);
my_tosort_unicode(weights, &w_wc, cs->state);
}
if (s_wc == w_wc)
break;
str+= scan;
}
if (str == str_end)
return -1;
str+= scan;
result= my_wildcmp_unicode_impl(cs, str, str_end, wildstr, wildend,
escape, w_one, w_many,
weights, recurse_level + 1);
if (result <= 0)
return result;
}
}
}
return (str != str_end ? 1 : 0);
} | O3 | c | my_wildcmp_unicode_impl:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, -0x54(%rbp)
movq %r8, %r12
movq %rcx, %r13
movq %rdx, -0x50(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
movl 0x28(%rbp), %eax
movq %rax, -0x60(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
leaq 0x322eef(%rip), %rax # 0x37a110
movq (%rax), %rax
testq %rax, %rax
je 0x5723b
movl 0x28(%rbp), %edi
callq *%rax
movl $0x1, %ebx
testl %eax, %eax
jne 0x575cb
cmpq %r12, %r13
je 0x573ca
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %ecx
cltq
movq %rax, -0x78(%rbp)
movslq -0x54(%rbp), %rax
movq %rax, -0x70(%rbp)
movslq %ecx, %rax
movq %rax, -0x68(%rbp)
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
movq %r13, %rdx
movq %r12, %rcx
movq -0x40(%rbp), %r14
callq *%r14
testl %eax, %eax
jle 0x575c6
movq -0x30(%rbp), %rcx
cmpq -0x78(%rbp), %rcx
je 0x573dc
movl %eax, %eax
addq %rax, %r13
cmpq -0x70(%rbp), %rcx
jne 0x572e2
cmpq %r12, %r13
jae 0x572e2
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq *%r14
testl %eax, %eax
jle 0x575c6
movl %eax, %ebx
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
movq %r14, %rax
movq -0x38(%rbp), %r14
movq %r14, %rdx
movq -0x50(%rbp), %rcx
callq *%rax
testl %eax, %eax
jle 0x575c6
movl %ebx, %ecx
addq %rcx, %r13
movl %eax, %eax
addq %rax, %r14
movq %r14, -0x38(%rbp)
jmp 0x57316
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdx
movq -0x50(%rbp), %rcx
callq *%r14
testl %eax, %eax
jle 0x575c6
movl %eax, %eax
addq %rax, %rbx
movq %rbx, -0x38(%rbp)
movq -0x68(%rbp), %rax
cmpq %rax, -0x30(%rbp)
je 0x573c1
movq -0x48(%rbp), %rax
movq 0x20(%rbp), %r8
testq %r8, %r8
je 0x573af
movl 0xc(%r15), %ecx
movq (%r8), %rdx
movl $0xfffd, %esi # imm = 0xFFFD
cmpq %rdx, %rax
ja 0x57364
movq 0x8(%r8), %rsi
movq %rax, %rdi
shrq $0x8, %rdi
movq (%rsi,%rdi,8), %rsi
testq %rsi, %rsi
je 0x5736b
xorl %edi, %edi
testw %cx, %cx
setns %dil
movzbl %al, %eax
leaq (%rax,%rax,2), %rax
leaq (%rsi,%rax,4), %rax
movl 0x4(%rax,%rdi,4), %esi
movq %rsi, -0x48(%rbp)
movq %rsi, %rax
movq -0x30(%rbp), %rsi
movl $0xfffd, %edi # imm = 0xFFFD
cmpq %rdx, %rsi
ja 0x573a6
movq 0x8(%r8), %rdx
movq %rsi, %rdi
shrq $0x8, %rdi
movq (%rdx,%rdi,8), %rdx
testq %rdx, %rdx
je 0x573b3
xorl %edi, %edi
testw %cx, %cx
setns %dil
movzbl %sil, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdx,%rcx,4), %rcx
movl 0x4(%rcx,%rdi,4), %edi
movq %rdi, -0x30(%rbp)
movq %rdi, %rsi
jmp 0x573b3
movq -0x30(%rbp), %rsi
movl $0x1, %ebx
cmpq %rsi, %rax
jne 0x575cb
cmpq %r12, %r13
jne 0x5725f
xorl %ebx, %ebx
movq -0x50(%rbp), %rax
cmpq %rax, -0x38(%rbp)
setne %bl
jmp 0x575cb
xorl %ebx, %ebx
cmpq %r12, %r13
je 0x575cb
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq *%r14
testl %eax, %eax
jle 0x575c6
movl %eax, %r14d
movq -0x30(%rbp), %rax
cmpq -0x78(%rbp), %rax
jne 0x57420
movl %r14d, %eax
addq %rax, %r13
cmpq %r12, %r13
movq -0x40(%rbp), %r14
jne 0x573e7
jmp 0x575cb
cmpq -0x68(%rbp), %rax
jne 0x5744e
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq *-0x40(%rbp)
testl %eax, %eax
jle 0x575c6
movl %r14d, %ecx
addq %rcx, %r13
movl %eax, %eax
addq %rax, -0x38(%rbp)
jmp 0x57412
movq -0x50(%rbp), %r14
cmpq %r14, -0x38(%rbp)
je 0x575dc
leaq -0x30(%rbp), %rsi
movq %r15, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq *-0x40(%rbp)
testl %eax, %eax
jle 0x575c6
movl %eax, %eax
addq %rax, %r13
movq -0x70(%rbp), %rax
cmpq %rax, -0x30(%rbp)
jne 0x574a5
cmpq %r12, %r13
jae 0x574a5
leaq -0x30(%rbp), %rsi
movq %r15, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq *-0x40(%rbp)
testl %eax, %eax
jle 0x575c6
movl %eax, %eax
addq %rax, %r13
movq -0x60(%rbp), %rax
incl %eax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rbx
cmpq %r14, %rbx
je 0x575dc
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq *-0x40(%rbp)
testl %eax, %eax
jle 0x575c6
movq -0x48(%rbp), %rcx
movq 0x20(%rbp), %rsi
testq %rsi, %rsi
je 0x5757a
movl 0xc(%r15), %edx
movq (%rsi), %rsi
movl $0xfffd, %edi # imm = 0xFFFD
cmpq %rsi, %rcx
ja 0x57528
movq 0x20(%rbp), %rdi
movq 0x8(%rdi), %rdi
movq %rcx, %r8
shrq $0x8, %r8
movq (%rdi,%r8,8), %rdi
testq %rdi, %rdi
je 0x5752f
xorl %r8d, %r8d
testw %dx, %dx
setns %r8b
movzbl %cl, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdi,%rcx,4), %rcx
movl 0x4(%rcx,%r8,4), %edi
movq %rdi, -0x48(%rbp)
movq %rdi, %rcx
movq -0x30(%rbp), %rdi
movl $0xfffd, %r8d # imm = 0xFFFD
cmpq %rsi, %rdi
ja 0x57571
movq 0x20(%rbp), %rsi
movq 0x8(%rsi), %rsi
movq %rdi, %r8
shrq $0x8, %r8
movq (%rsi,%r8,8), %rsi
testq %rsi, %rsi
je 0x5757e
xorl %r8d, %r8d
testw %dx, %dx
setns %r8b
movzbl %dil, %edx
leaq (%rdx,%rdx,2), %rdx
leaq (%rsi,%rdx,4), %rdx
movl 0x4(%rdx,%r8,4), %r8d
movq %r8, -0x30(%rbp)
movq %r8, %rdi
jmp 0x5757e
movq -0x30(%rbp), %rdi
movl %eax, %eax
addq %rax, %rbx
cmpq %rdi, %rcx
jne 0x574b3
movq %r15, %rdi
movq %rbx, -0x38(%rbp)
movq %rbx, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %r12, %r8
movl -0x54(%rbp), %r9d
pushq -0x60(%rbp)
pushq 0x20(%rbp)
movl 0x18(%rbp), %eax
pushq %rax
movl 0x10(%rbp), %eax
pushq %rax
callq 0x571de
addq $0x20, %rsp
movl %eax, %ebx
testl %eax, %eax
jg 0x574af
jmp 0x575cb
movl $0x1, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
jmp 0x575cb
| my_wildcmp_unicode_impl:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_54], r9d
mov r12, r8
mov r13, rcx
mov [rbp+var_50], rdx
mov [rbp+var_38], rsi
mov r15, rdi
mov eax, [rbp+arg_18]
mov [rbp+var_60], rax
mov rax, [rdi+0B8h]
mov rax, [rax+28h]
mov [rbp+var_40], rax
lea rax, my_string_stack_guard
mov rax, [rax]
test rax, rax
jz short loc_5723B
mov edi, [rbp+arg_18]
call rax
mov ebx, 1
test eax, eax
jnz loc_575CB
loc_5723B:
cmp r13, r12
jz loc_573CA
mov eax, [rbp+arg_8]
mov ecx, [rbp+arg_0]
cdqe
mov [rbp+var_78], rax
movsxd rax, [rbp+var_54]
mov [rbp+var_70], rax
movsxd rax, ecx
mov [rbp+var_68], rax
loc_5725F:
mov rdi, r15
lea rsi, [rbp+var_30]
mov rdx, r13
mov rcx, r12
mov r14, [rbp+var_40]
call r14
test eax, eax
jle loc_575C6
mov rcx, [rbp+var_30]
cmp rcx, [rbp+var_78]
jz loc_573DC
mov eax, eax
add r13, rax
cmp rcx, [rbp+var_70]
jnz short loc_572E2
cmp r13, r12
jnb short loc_572E2
mov rdi, r15
lea rsi, [rbp+var_30]
mov rdx, r13
mov rcx, r12
call r14
test eax, eax
jle loc_575C6
mov ebx, eax
mov rdi, r15
lea rsi, [rbp+var_48]
mov rax, r14
mov r14, [rbp+var_38]
mov rdx, r14
mov rcx, [rbp+var_50]
call rax
test eax, eax
jle loc_575C6
mov ecx, ebx
add r13, rcx
mov eax, eax
add r14, rax
mov [rbp+var_38], r14
jmp short loc_57316
loc_572E2:
mov rdi, r15
lea rsi, [rbp+var_48]
mov rbx, [rbp+var_38]
mov rdx, rbx
mov rcx, [rbp+var_50]
call r14
test eax, eax
jle loc_575C6
mov eax, eax
add rbx, rax
mov [rbp+var_38], rbx
mov rax, [rbp+var_68]
cmp [rbp+var_30], rax
jz loc_573C1
loc_57316:
mov rax, [rbp+var_48]
mov r8, [rbp+arg_10]
test r8, r8
jz loc_573AF
mov ecx, [r15+0Ch]
mov rdx, [r8]
mov esi, 0FFFDh
cmp rax, rdx
ja short loc_57364
mov rsi, [r8+8]
mov rdi, rax
shr rdi, 8
mov rsi, [rsi+rdi*8]
test rsi, rsi
jz short loc_5736B
xor edi, edi
test cx, cx
setns dil
movzx eax, al
lea rax, [rax+rax*2]
lea rax, [rsi+rax*4]
mov esi, [rax+rdi*4+4]
loc_57364:
mov [rbp+var_48], rsi
mov rax, rsi
loc_5736B:
mov rsi, [rbp+var_30]
mov edi, 0FFFDh
cmp rsi, rdx
ja short loc_573A6
mov rdx, [r8+8]
mov rdi, rsi
shr rdi, 8
mov rdx, [rdx+rdi*8]
test rdx, rdx
jz short loc_573B3
xor edi, edi
test cx, cx
setns dil
movzx ecx, sil
lea rcx, [rcx+rcx*2]
lea rcx, [rdx+rcx*4]
mov edi, [rcx+rdi*4+4]
loc_573A6:
mov [rbp+var_30], rdi
mov rsi, rdi
jmp short loc_573B3
loc_573AF:
mov rsi, [rbp+var_30]
loc_573B3:
mov ebx, 1
cmp rax, rsi
jnz loc_575CB
loc_573C1:
cmp r13, r12
jnz loc_5725F
loc_573CA:
xor ebx, ebx
mov rax, [rbp+var_50]
cmp [rbp+var_38], rax
setnz bl
jmp loc_575CB
loc_573DC:
xor ebx, ebx
cmp r13, r12
jz loc_575CB
loc_573E7:
mov rdi, r15
lea rsi, [rbp+var_30]
mov rdx, r13
mov rcx, r12
call r14
test eax, eax
jle loc_575C6
mov r14d, eax
mov rax, [rbp+var_30]
cmp rax, [rbp+var_78]
jnz short loc_57420
mov eax, r14d
add r13, rax
loc_57412:
cmp r13, r12
mov r14, [rbp+var_40]
jnz short loc_573E7
jmp loc_575CB
loc_57420:
cmp rax, [rbp+var_68]
jnz short loc_5744E
mov rdi, r15
lea rsi, [rbp+var_48]
mov rdx, [rbp+var_38]
mov rcx, [rbp+var_50]
call [rbp+var_40]
test eax, eax
jle loc_575C6
mov ecx, r14d
add r13, rcx
mov eax, eax
add [rbp+var_38], rax
jmp short loc_57412
loc_5744E:
mov r14, [rbp+var_50]
cmp [rbp+var_38], r14
jz loc_575DC
lea rsi, [rbp+var_30]
mov rdi, r15
mov rdx, r13
mov rcx, r12
call [rbp+var_40]
test eax, eax
jle loc_575C6
mov eax, eax
add r13, rax
mov rax, [rbp+var_70]
cmp [rbp+var_30], rax
jnz short loc_574A5
cmp r13, r12
jnb short loc_574A5
lea rsi, [rbp+var_30]
mov rdi, r15
mov rdx, r13
mov rcx, r12
call [rbp+var_40]
test eax, eax
jle loc_575C6
mov eax, eax
add r13, rax
loc_574A5:
mov rax, [rbp+var_60]
inc eax
mov [rbp+var_60], rax
loc_574AF:
mov rbx, [rbp+var_38]
loc_574B3:
cmp rbx, r14
jz loc_575DC
mov rdi, r15
lea rsi, [rbp+var_48]
mov rdx, rbx
mov rcx, r14
call [rbp+var_40]
test eax, eax
jle loc_575C6
mov rcx, [rbp+var_48]
mov rsi, [rbp+arg_10]
test rsi, rsi
jz loc_5757A
mov edx, [r15+0Ch]
mov rsi, [rsi]
mov edi, 0FFFDh
cmp rcx, rsi
ja short loc_57528
mov rdi, [rbp+arg_10]
mov rdi, [rdi+8]
mov r8, rcx
shr r8, 8
mov rdi, [rdi+r8*8]
test rdi, rdi
jz short loc_5752F
xor r8d, r8d
test dx, dx
setns r8b
movzx ecx, cl
lea rcx, [rcx+rcx*2]
lea rcx, [rdi+rcx*4]
mov edi, [rcx+r8*4+4]
loc_57528:
mov [rbp+var_48], rdi
mov rcx, rdi
loc_5752F:
mov rdi, [rbp+var_30]
mov r8d, 0FFFDh
cmp rdi, rsi
ja short loc_57571
mov rsi, [rbp+arg_10]
mov rsi, [rsi+8]
mov r8, rdi
shr r8, 8
mov rsi, [rsi+r8*8]
test rsi, rsi
jz short loc_5757E
xor r8d, r8d
test dx, dx
setns r8b
movzx edx, dil
lea rdx, [rdx+rdx*2]
lea rdx, [rsi+rdx*4]
mov r8d, [rdx+r8*4+4]
loc_57571:
mov [rbp+var_30], r8
mov rdi, r8
jmp short loc_5757E
loc_5757A:
mov rdi, [rbp+var_30]
loc_5757E:
mov eax, eax
add rbx, rax
cmp rcx, rdi
jnz loc_574B3
mov rdi, r15
mov [rbp+var_38], rbx
mov rsi, rbx
mov rdx, r14
mov rcx, r13
mov r8, r12
mov r9d, [rbp+var_54]
push [rbp+var_60]
push [rbp+arg_10]
mov eax, [rbp+arg_8]
push rax
mov eax, [rbp+arg_0]
push rax
call my_wildcmp_unicode_impl
add rsp, 20h
mov ebx, eax
test eax, eax
jg loc_574AF
jmp short loc_575CB
loc_575C6:
mov ebx, 1
loc_575CB:
mov eax, ebx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_575DC:
mov ebx, 0FFFFFFFFh
jmp short loc_575CB
| long long my_wildcmp_unicode_impl(
long long a1,
long long a2,
unsigned long long a3,
unsigned long long a4,
unsigned long long a5,
int a6,
int a7,
int a8,
unsigned long long *a9,
unsigned int a10)
{
unsigned int v13; // ebx
long long ( *v14)(long long, unsigned __int8 *, unsigned long long, unsigned long long); // r14
int v15; // eax
int v16; // eax
unsigned int v17; // ebx
long long ( *v18)(long long, unsigned long long *, long long, long long); // rax
long long v19; // r14
int v20; // eax
long long v21; // rbx
int v22; // eax
long long v23; // rax
int v24; // ecx
unsigned long long v25; // rdx
long long v26; // rsi
long long v27; // rsi
long long v28; // rsi
long long v29; // rdi
long long v30; // rdx
int v31; // eax
unsigned int v32; // r14d
int v33; // eax
int v34; // eax
unsigned long long v35; // r13
int v36; // eax
unsigned long long v37; // rbx
int v38; // eax
long long v39; // rcx
int v40; // edx
unsigned long long v41; // rsi
long long v42; // rdi
long long v43; // rdi
long long v44; // rdi
long long v45; // r8
long long v46; // rsi
unsigned long long v50; // [rsp+38h] [rbp-48h] BYREF
long long ( *v51)(long long, unsigned __int8 *, unsigned long long, unsigned long long); // [rsp+40h] [rbp-40h]
long long v52; // [rsp+48h] [rbp-38h]
unsigned __int8 v53[48]; // [rsp+50h] [rbp-30h] BYREF
v52 = a2;
v51 = *(long long ( **)(long long, unsigned __int8 *, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184)
+ 40LL);
if ( my_string_stack_guard )
{
v13 = 1;
if ( (unsigned int)my_string_stack_guard(a10) )
return v13;
}
if ( a4 == a5 )
return v52 != a3;
while ( 1 )
{
v14 = v51;
v15 = v51(a1, v53, a4, a5);
if ( v15 <= 0 )
return 1;
if ( *(_QWORD *)v53 == a8 )
break;
a4 += (unsigned int)v15;
if ( *(_QWORD *)v53 == a6 && a4 < a5 )
{
v16 = v14(a1, v53, a4, a5);
if ( v16 <= 0 )
return 1;
v17 = v16;
v18 = (long long ( *)(long long, unsigned long long *, long long, long long))v14;
v19 = v52;
v20 = v18(a1, &v50, v52, a3);
if ( v20 <= 0 )
return 1;
a4 += v17;
v52 = (unsigned int)v20 + v19;
LABEL_13:
v23 = v50;
if ( a9 )
{
v24 = *(_DWORD *)(a1 + 12);
v25 = *a9;
v26 = 65533LL;
if ( v50 > *a9 )
goto LABEL_17;
v27 = *(_QWORD *)(a9[1] + 8 * (v50 >> 8));
if ( v27 )
{
v26 = *(unsigned int *)(v27 + 12LL * (unsigned __int8)v50 + 4LL * ((v24 & 0x8000u) == 0) + 4);
LABEL_17:
v50 = v26;
v23 = v26;
}
v28 = *(_QWORD *)v53;
v29 = 65533LL;
if ( *(_QWORD *)v53 > v25 )
{
LABEL_21:
*(_QWORD *)v53 = v29;
v28 = v29;
}
else
{
v30 = *(_QWORD *)(a9[1] + 8LL * (*(_QWORD *)v53 >> 8));
if ( v30 )
{
v29 = *(unsigned int *)(v30 + 12LL * v53[0] + 4LL * ((v24 & 0x8000u) == 0) + 4);
goto LABEL_21;
}
}
}
else
{
v28 = *(_QWORD *)v53;
}
v13 = 1;
if ( v23 != v28 )
return v13;
goto LABEL_24;
}
v21 = v52;
v22 = v14(a1, (unsigned __int8 *)&v50, v52, a3);
if ( v22 <= 0 )
return 1;
v52 = (unsigned int)v22 + v21;
if ( *(_QWORD *)v53 != a7 )
goto LABEL_13;
LABEL_24:
if ( a4 == a5 )
return v52 != a3;
}
v13 = 0;
if ( a4 == a5 )
return v13;
while ( 2 )
{
v31 = v14(a1, v53, a4, a5);
if ( v31 <= 0 )
return 1;
v32 = v31;
if ( *(_QWORD *)v53 == a8 )
{
a4 += (unsigned int)v31;
LABEL_30:
v14 = v51;
if ( a4 == a5 )
return v13;
continue;
}
break;
}
if ( *(_QWORD *)v53 == a7 )
{
v33 = v51(a1, (unsigned __int8 *)&v50, v52, a3);
if ( v33 <= 0 )
return 1;
a4 += v32;
v52 += (unsigned int)v33;
goto LABEL_30;
}
if ( v52 == a3 )
return (unsigned int)-1;
v34 = v51(a1, v53, a4, a5);
if ( v34 <= 0 )
return 1;
v35 = (unsigned int)v34 + a4;
if ( *(_QWORD *)v53 != a6 || v35 >= a5 )
{
LABEL_41:
v37 = v52;
while ( 1 )
{
if ( v37 == a3 )
return (unsigned int)-1;
v38 = v51(a1, (unsigned __int8 *)&v50, v37, a3);
if ( v38 <= 0 )
return 1;
v39 = v50;
if ( !a9 )
{
v44 = *(_QWORD *)v53;
goto LABEL_54;
}
v40 = *(_DWORD *)(a1 + 12);
v41 = *a9;
v42 = 65533LL;
if ( v50 <= *a9 )
{
v43 = *(_QWORD *)(a9[1] + 8 * (v50 >> 8));
if ( !v43 )
goto LABEL_49;
v42 = *(unsigned int *)(v43 + 12LL * (unsigned __int8)v50 + 4LL * ((v40 & 0x8000u) == 0) + 4);
}
v50 = v42;
v39 = v42;
LABEL_49:
v44 = *(_QWORD *)v53;
v45 = 65533LL;
if ( *(_QWORD *)v53 > v41 )
goto LABEL_52;
v46 = *(_QWORD *)(a9[1] + 8LL * (*(_QWORD *)v53 >> 8));
if ( v46 )
{
v45 = *(unsigned int *)(v46 + 12LL * v53[0] + 4LL * ((v40 & 0x8000u) == 0) + 4);
LABEL_52:
*(_QWORD *)v53 = v45;
v44 = v45;
}
LABEL_54:
v37 += (unsigned int)v38;
if ( v39 == v44 )
{
v52 = v37;
v13 = my_wildcmp_unicode_impl(a1, v37, a3, v35, a5, a6, a7, a8, (long long)a9, a10 + 1);
if ( (int)v13 > 0 )
goto LABEL_41;
return v13;
}
}
}
v36 = v51(a1, v53, v35, a5);
if ( v36 > 0 )
{
LODWORD(v35) = v36 + v35;
goto LABEL_41;
}
return 1;
}
| my_wildcmp_unicode_impl:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV dword ptr [RBP + -0x54],R9D
MOV R12,R8
MOV R13,RCX
MOV qword ptr [RBP + -0x50],RDX
MOV qword ptr [RBP + -0x38],RSI
MOV R15,RDI
MOV EAX,dword ptr [RBP + 0x28]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[0x47a110]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0015723b
MOV EDI,dword ptr [RBP + 0x28]
CALL RAX
MOV EBX,0x1
TEST EAX,EAX
JNZ 0x001575cb
LAB_0015723b:
CMP R13,R12
JZ 0x001573ca
MOV EAX,dword ptr [RBP + 0x18]
MOV ECX,dword ptr [RBP + 0x10]
CDQE
MOV qword ptr [RBP + -0x78],RAX
MOVSXD RAX,dword ptr [RBP + -0x54]
MOV qword ptr [RBP + -0x70],RAX
MOVSXD RAX,ECX
MOV qword ptr [RBP + -0x68],RAX
LAB_0015725f:
MOV RDI,R15
LEA RSI,[RBP + -0x30]
MOV RDX,R13
MOV RCX,R12
MOV R14,qword ptr [RBP + -0x40]
CALL R14
TEST EAX,EAX
JLE 0x001575c6
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,qword ptr [RBP + -0x78]
JZ 0x001573dc
MOV EAX,EAX
ADD R13,RAX
CMP RCX,qword ptr [RBP + -0x70]
JNZ 0x001572e2
CMP R13,R12
JNC 0x001572e2
MOV RDI,R15
LEA RSI,[RBP + -0x30]
MOV RDX,R13
MOV RCX,R12
CALL R14
TEST EAX,EAX
JLE 0x001575c6
MOV EBX,EAX
MOV RDI,R15
LEA RSI,[RBP + -0x48]
MOV RAX,R14
MOV R14,qword ptr [RBP + -0x38]
MOV RDX,R14
MOV RCX,qword ptr [RBP + -0x50]
CALL RAX
TEST EAX,EAX
JLE 0x001575c6
MOV ECX,EBX
ADD R13,RCX
MOV EAX,EAX
ADD R14,RAX
MOV qword ptr [RBP + -0x38],R14
JMP 0x00157316
LAB_001572e2:
MOV RDI,R15
LEA RSI,[RBP + -0x48]
MOV RBX,qword ptr [RBP + -0x38]
MOV RDX,RBX
MOV RCX,qword ptr [RBP + -0x50]
CALL R14
TEST EAX,EAX
JLE 0x001575c6
MOV EAX,EAX
ADD RBX,RAX
MOV qword ptr [RBP + -0x38],RBX
MOV RAX,qword ptr [RBP + -0x68]
CMP qword ptr [RBP + -0x30],RAX
JZ 0x001573c1
LAB_00157316:
MOV RAX,qword ptr [RBP + -0x48]
MOV R8,qword ptr [RBP + 0x20]
TEST R8,R8
JZ 0x001573af
MOV ECX,dword ptr [R15 + 0xc]
MOV RDX,qword ptr [R8]
MOV ESI,0xfffd
CMP RAX,RDX
JA 0x00157364
MOV RSI,qword ptr [R8 + 0x8]
MOV RDI,RAX
SHR RDI,0x8
MOV RSI,qword ptr [RSI + RDI*0x8]
TEST RSI,RSI
JZ 0x0015736b
XOR EDI,EDI
TEST CX,CX
SETNS DIL
MOVZX EAX,AL
LEA RAX,[RAX + RAX*0x2]
LEA RAX,[RSI + RAX*0x4]
MOV ESI,dword ptr [RAX + RDI*0x4 + 0x4]
LAB_00157364:
MOV qword ptr [RBP + -0x48],RSI
MOV RAX,RSI
LAB_0015736b:
MOV RSI,qword ptr [RBP + -0x30]
MOV EDI,0xfffd
CMP RSI,RDX
JA 0x001573a6
MOV RDX,qword ptr [R8 + 0x8]
MOV RDI,RSI
SHR RDI,0x8
MOV RDX,qword ptr [RDX + RDI*0x8]
TEST RDX,RDX
JZ 0x001573b3
XOR EDI,EDI
TEST CX,CX
SETNS DIL
MOVZX ECX,SIL
LEA RCX,[RCX + RCX*0x2]
LEA RCX,[RDX + RCX*0x4]
MOV EDI,dword ptr [RCX + RDI*0x4 + 0x4]
LAB_001573a6:
MOV qword ptr [RBP + -0x30],RDI
MOV RSI,RDI
JMP 0x001573b3
LAB_001573af:
MOV RSI,qword ptr [RBP + -0x30]
LAB_001573b3:
MOV EBX,0x1
CMP RAX,RSI
JNZ 0x001575cb
LAB_001573c1:
CMP R13,R12
JNZ 0x0015725f
LAB_001573ca:
XOR EBX,EBX
MOV RAX,qword ptr [RBP + -0x50]
CMP qword ptr [RBP + -0x38],RAX
SETNZ BL
JMP 0x001575cb
LAB_001573dc:
XOR EBX,EBX
CMP R13,R12
JZ 0x001575cb
LAB_001573e7:
MOV RDI,R15
LEA RSI,[RBP + -0x30]
MOV RDX,R13
MOV RCX,R12
CALL R14
TEST EAX,EAX
JLE 0x001575c6
MOV R14D,EAX
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x78]
JNZ 0x00157420
MOV EAX,R14D
ADD R13,RAX
LAB_00157412:
CMP R13,R12
MOV R14,qword ptr [RBP + -0x40]
JNZ 0x001573e7
JMP 0x001575cb
LAB_00157420:
CMP RAX,qword ptr [RBP + -0x68]
JNZ 0x0015744e
MOV RDI,R15
LEA RSI,[RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x50]
CALL qword ptr [RBP + -0x40]
TEST EAX,EAX
JLE 0x001575c6
MOV ECX,R14D
ADD R13,RCX
MOV EAX,EAX
ADD qword ptr [RBP + -0x38],RAX
JMP 0x00157412
LAB_0015744e:
MOV R14,qword ptr [RBP + -0x50]
CMP qword ptr [RBP + -0x38],R14
JZ 0x001575dc
LEA RSI,[RBP + -0x30]
MOV RDI,R15
MOV RDX,R13
MOV RCX,R12
CALL qword ptr [RBP + -0x40]
TEST EAX,EAX
JLE 0x001575c6
MOV EAX,EAX
ADD R13,RAX
MOV RAX,qword ptr [RBP + -0x70]
CMP qword ptr [RBP + -0x30],RAX
JNZ 0x001574a5
CMP R13,R12
JNC 0x001574a5
LEA RSI,[RBP + -0x30]
MOV RDI,R15
MOV RDX,R13
MOV RCX,R12
CALL qword ptr [RBP + -0x40]
TEST EAX,EAX
JLE 0x001575c6
MOV EAX,EAX
ADD R13,RAX
LAB_001574a5:
MOV RAX,qword ptr [RBP + -0x60]
INC EAX
MOV qword ptr [RBP + -0x60],RAX
LAB_001574af:
MOV RBX,qword ptr [RBP + -0x38]
LAB_001574b3:
CMP RBX,R14
JZ 0x001575dc
MOV RDI,R15
LEA RSI,[RBP + -0x48]
MOV RDX,RBX
MOV RCX,R14
CALL qword ptr [RBP + -0x40]
TEST EAX,EAX
JLE 0x001575c6
MOV RCX,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + 0x20]
TEST RSI,RSI
JZ 0x0015757a
MOV EDX,dword ptr [R15 + 0xc]
MOV RSI,qword ptr [RSI]
MOV EDI,0xfffd
CMP RCX,RSI
JA 0x00157528
MOV RDI,qword ptr [RBP + 0x20]
MOV RDI,qword ptr [RDI + 0x8]
MOV R8,RCX
SHR R8,0x8
MOV RDI,qword ptr [RDI + R8*0x8]
TEST RDI,RDI
JZ 0x0015752f
XOR R8D,R8D
TEST DX,DX
SETNS R8B
MOVZX ECX,CL
LEA RCX,[RCX + RCX*0x2]
LEA RCX,[RDI + RCX*0x4]
MOV EDI,dword ptr [RCX + R8*0x4 + 0x4]
LAB_00157528:
MOV qword ptr [RBP + -0x48],RDI
MOV RCX,RDI
LAB_0015752f:
MOV RDI,qword ptr [RBP + -0x30]
MOV R8D,0xfffd
CMP RDI,RSI
JA 0x00157571
MOV RSI,qword ptr [RBP + 0x20]
MOV RSI,qword ptr [RSI + 0x8]
MOV R8,RDI
SHR R8,0x8
MOV RSI,qword ptr [RSI + R8*0x8]
TEST RSI,RSI
JZ 0x0015757e
XOR R8D,R8D
TEST DX,DX
SETNS R8B
MOVZX EDX,DIL
LEA RDX,[RDX + RDX*0x2]
LEA RDX,[RSI + RDX*0x4]
MOV R8D,dword ptr [RDX + R8*0x4 + 0x4]
LAB_00157571:
MOV qword ptr [RBP + -0x30],R8
MOV RDI,R8
JMP 0x0015757e
LAB_0015757a:
MOV RDI,qword ptr [RBP + -0x30]
LAB_0015757e:
MOV EAX,EAX
ADD RBX,RAX
CMP RCX,RDI
JNZ 0x001574b3
MOV RDI,R15
MOV qword ptr [RBP + -0x38],RBX
MOV RSI,RBX
MOV RDX,R14
MOV RCX,R13
MOV R8,R12
MOV R9D,dword ptr [RBP + -0x54]
PUSH qword ptr [RBP + -0x60]
PUSH qword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x18]
PUSH RAX
MOV EAX,dword ptr [RBP + 0x10]
PUSH RAX
CALL 0x001571de
ADD RSP,0x20
MOV EBX,EAX
TEST EAX,EAX
JG 0x001574af
JMP 0x001575cb
LAB_001575c6:
MOV EBX,0x1
LAB_001575cb:
MOV EAX,EBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001575dc:
MOV EBX,0xffffffff
JMP 0x001575cb
|
uint my_wildcmp_unicode_impl
(long param_1,long param_2,long param_3,ulong param_4,ulong param_5,int param_6,
int param_7,int param_8,ulong *param_9,int param_10)
{
long lVar1;
code *pcVar2;
ulong uVar3;
int iVar4;
uint uVar5;
uint uVar6;
short sVar7;
long lVar8;
ulong local_50;
code *local_48;
long local_40;
ulong local_38;
local_48 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
local_40 = param_2;
if ((my_string_stack_guard != (code *)0x0) &&
(iVar4 = (*my_string_stack_guard)(param_10), iVar4 != 0)) {
return 1;
}
if (param_4 != param_5) {
do {
pcVar2 = local_48;
uVar5 = (*local_48)(param_1,&local_38,param_4,param_5);
lVar8 = local_40;
if ((int)uVar5 < 1) {
return 1;
}
if (local_38 == (long)param_8) {
do {
if (param_4 == param_5) {
return 0;
}
uVar5 = (*pcVar2)(param_1,&local_38,param_4,param_5);
if ((int)uVar5 < 1) {
return 1;
}
if (local_38 != (long)param_8) {
if (local_38 != (long)param_7) {
if (local_40 == param_3) {
return 0xffffffff;
}
uVar5 = (*local_48)(param_1,&local_38,param_4,param_5);
if (0 < (int)uVar5) {
param_4 = param_4 + uVar5;
if ((local_38 == (long)param_6) && (param_4 < param_5)) {
uVar5 = (*local_48)(param_1,&local_38,param_4,param_5);
if ((int)uVar5 < 1) {
return 1;
}
param_4 = param_4 + uVar5;
}
lVar8 = local_40;
while( true ) {
if (lVar8 == param_3) {
return 0xffffffff;
}
uVar5 = (*local_48)(param_1,&local_50,lVar8,param_3);
if ((int)uVar5 < 1) break;
uVar3 = local_38;
if (param_9 != (ulong *)0x0) {
sVar7 = (short)*(int4 *)(param_1 + 0xc);
uVar3 = 0xfffd;
if ((local_50 <= *param_9) &&
(lVar1 = *(long *)(param_9[1] + (local_50 >> 8) * 8), uVar3 = local_50,
lVar1 != 0)) {
uVar3 = (ulong)*(uint *)(lVar1 + (local_50 & 0xff) * 0xc + 4 +
(ulong)(-1 < sVar7) * 4);
}
local_50 = uVar3;
uVar3 = 0xfffd;
if ((local_38 <= *param_9) &&
(lVar1 = *(long *)(param_9[1] + (local_38 >> 8) * 8), uVar3 = local_38,
lVar1 != 0)) {
uVar3 = (ulong)*(uint *)(lVar1 + (local_38 & 0xff) * 0xc + 4 +
(ulong)(-1 < sVar7) * 4);
}
}
local_38 = uVar3;
lVar8 = lVar8 + (ulong)uVar5;
if ((local_50 == local_38) &&
(local_40 = lVar8,
uVar5 = my_wildcmp_unicode_impl
(param_1,lVar8,param_3,param_4,param_5,param_6,param_7,
param_8,param_9,param_10 + 1), lVar8 = local_40,
(int)uVar5 < 1)) {
return uVar5;
}
}
return 1;
}
return 1;
}
uVar6 = (*local_48)(param_1,&local_50,local_40,param_3);
if ((int)uVar6 < 1) {
return 1;
}
local_40 = local_40 + (ulong)uVar6;
}
param_4 = param_4 + uVar5;
pcVar2 = local_48;
} while( true );
}
param_4 = param_4 + uVar5;
if ((local_38 == (long)param_6) && (param_4 < param_5)) {
uVar5 = (*pcVar2)(param_1,&local_38,param_4,param_5);
lVar8 = local_40;
if ((int)uVar5 < 1) {
return 1;
}
uVar6 = (*pcVar2)(param_1,&local_50,local_40,param_3);
if ((int)uVar6 < 1) {
return 1;
}
param_4 = param_4 + uVar5;
local_40 = lVar8 + (ulong)uVar6;
LAB_00157316:
uVar3 = local_38;
if (param_9 != (ulong *)0x0) {
sVar7 = (short)*(int4 *)(param_1 + 0xc);
uVar3 = 0xfffd;
if ((local_50 <= *param_9) &&
(lVar8 = *(long *)(param_9[1] + (local_50 >> 8) * 8), uVar3 = local_50, lVar8 != 0)) {
uVar3 = (ulong)*(uint *)(lVar8 + (local_50 & 0xff) * 0xc + 4 + (ulong)(-1 < sVar7) * 4);
}
local_50 = uVar3;
uVar3 = 0xfffd;
if ((local_38 <= *param_9) &&
(lVar8 = *(long *)(param_9[1] + (local_38 >> 8) * 8), uVar3 = local_38, lVar8 != 0)) {
uVar3 = (ulong)*(uint *)(lVar8 + (local_38 & 0xff) * 0xc + 4 + (ulong)(-1 < sVar7) * 4);
}
}
local_38 = uVar3;
if (local_50 != local_38) {
return 1;
}
}
else {
uVar5 = (*pcVar2)(param_1,&local_50,local_40,param_3);
if ((int)uVar5 < 1) {
return 1;
}
local_40 = lVar8 + (ulong)uVar5;
if (local_38 != (long)param_7) goto LAB_00157316;
}
} while (param_4 != param_5);
}
return (uint)(local_40 != param_3);
}
| |
26,351 | CLI::OptionBase<CLI::Option>::group(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | MikePodsytnik[P]TCRtrie/build_O3/_deps/cli11-src/include/CLI/Option.hpp | CRTP *group(const std::string &name) {
if(!detail::valid_alias_name_string(name)) {
throw IncorrectConstruction("Group names may not contain newlines or null characters");
}
group_ = name;
return static_cast<CRTP *>(this);
} | O3 | cpp | CLI::OptionBase<CLI::Option>::group(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1d325
testb %al, %al
je 0x1d0c7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7210
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x71d0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a625(%rip), %rsi # 0x37709
leaq 0x1a655(%rip), %rdx # 0x37740
leaq 0x8(%rsp), %rdi
callq 0x11f90
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1d41a
xorl %ebp, %ebp
leaq 0x2c48a(%rip), %rsi # 0x49598
leaq 0xc791(%rip), %rdx # 0x298a6
movq %rbx, %rdi
callq 0x7750
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d137
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7430
testb %bpl, %bpl
jne 0x1d141
jmp 0x1d149
movq %rax, %r14
movq %rbx, %rdi
callq 0x7310
movq %r14, %rdi
callq 0x7780
nop
| _ZN3CLI10OptionBaseINS_6OptionEE5groupERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14; __int64
push rbx; int
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
mov rdi, rsi; int
call _ZN3CLI6detail23valid_alias_name_stringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::detail::valid_alias_name_string(std::string const&)
test al, al
jz short loc_1D0C7
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_1D0C7:
mov edi, 38h ; '8'; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aGroupNamesMayN; "Group names may not contain newlines or"...
lea rdx, aGroupNamesMayN+37h; ""
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov bpl, 1
lea rsi, [rsp+48h+var_40]
mov rdi, rbx; int
call _ZN3CLI21IncorrectConstructionC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::IncorrectConstruction::IncorrectConstruction(std::string)
xor ebp, ebp
lea rsi, _ZTIN3CLI21IncorrectConstructionE; lptinfo
lea rdx, _ZN3CLI5ErrorD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_1D137
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1D137:
test bpl, bpl
jnz short loc_1D141
jmp short loc_1D149
mov r14, rax
loc_1D141:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_1D149:
mov rdi, r14
call __Unwind_Resume
| long long CLI::OptionBase<CLI::Option>::group(long long a1, long long a2, int a3, int a4, int a5, int a6)
{
void *exception; // rbx
void *v8; // [rsp+0h] [rbp-48h]
void *v9; // [rsp+0h] [rbp-48h]
void *v10; // [rsp+8h] [rbp-40h] BYREF
long long v11; // [rsp+10h] [rbp-38h]
_QWORD v12[2]; // [rsp+18h] [rbp-30h] BYREF
int v13; // [rsp+28h] [rbp-20h]
long long v14; // [rsp+30h] [rbp-18h]
if ( !(unsigned __int8)CLI::detail::valid_alias_name_string(a2, a2, a3, a4, a5, a6, v8, (int)v10, v11) )
{
exception = __cxa_allocate_exception(0x38uLL);
v10 = v12;
std::string::_M_construct<char const*>(
(long long)&v10,
"Group names may not contain newlines or null characters",
(long long)"");
CLI::IncorrectConstruction::IncorrectConstruction(
(int)exception,
v9,
(int)v10,
v11,
v12[0],
(void *)v12[1],
v13,
v14);
__cxa_throw(exception, (struct type_info *)&`typeinfo for'CLI::IncorrectConstruction, CLI::Error::~Error);
}
std::string::_M_assign(a1, a2);
return a1;
}
| group:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x0011d325
TEST AL,AL
JZ 0x0011d0c7
MOV RDI,RBX
MOV RSI,R14
CALL 0x00107210
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0011d0c7:
MOV EDI,0x38
CALL 0x001071d0
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_0011d0dd:
LEA RSI,[0x137709]
LEA RDX,[0x137740]
LEA RDI,[RSP + 0x8]
CALL 0x00111f90
MOV BPL,0x1
LAB_0011d0f8:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0011d41a
XOR EBP,EBP
LEA RSI,[0x149598]
LEA RDX,[0x1298a6]
MOV RDI,RBX
CALL 0x00107750
|
/* CLI::OptionBase<CLI::Option>::group(std::__cxx11::string const&) */
OptionBase<CLI::Option> * __thiscall
CLI::OptionBase<CLI::Option>::group(OptionBase<CLI::Option> *this,string *param_1)
{
char cVar1;
IncorrectConstruction *pIVar2;
int1 *local_40 [2];
int1 local_30 [16];
cVar1 = detail::valid_alias_name_string(param_1);
if (cVar1 != '\0') {
std::__cxx11::string::_M_assign((string *)this);
return this;
}
pIVar2 = (IncorrectConstruction *)__cxa_allocate_exception(0x38);
local_40[0] = local_30;
/* try { // try from 0011d0dd to 0011d0f4 has its CatchHandler @ 0011d13e */
std::__cxx11::string::_M_construct<char_const*>
(local_40,"Group names may not contain newlines or null characters","");
/* try { // try from 0011d0f8 to 0011d11c has its CatchHandler @ 0011d11d */
IncorrectConstruction::IncorrectConstruction(pIVar2,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(pIVar2,&IncorrectConstruction::typeinfo,Error::~Error);
}
| |
26,352 | minja::chat_template::try_raw_render(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) const | monkey531[P]llama/common/chat-template.hpp | std::string try_raw_render(
const nlohmann::ordered_json & messages,
const nlohmann::ordered_json & tools,
bool add_generation_prompt,
const nlohmann::ordered_json & extra_context = nlohmann::ordered_json()) const
{
try {
auto prompt = apply(messages, tools, add_generation_prompt, extra_context, /* adjust_inputs= */ false);
// fprintf(stderr, "try_raw_render: %s\n", prompt.c_str());
return prompt;
} catch (const std::exception & e) {
// fprintf(stderr, "try_raw_render error: %s\n", e.what());
return "";
}
} | O2 | cpp | minja::chat_template::try_raw_render(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) const:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
andl $0x0, (%rsp)
callq 0x79d16
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x5e211
movq %r14, %rdi
callq 0x23390
leaq 0x4d3de(%rip), %rsi # 0xab5d3
leaq 0x17(%rsp), %rdx
movq %rbx, %rdi
callq 0x28b3c
callq 0x23f00
jmp 0x5e1d3
movq %rax, %r14
callq 0x23f00
movq %r14, %rdi
callq 0x24030
movq %rax, %rdi
callq 0x28ddb
nop
| _ZNK5minja13chat_template14try_raw_renderERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEESH_bSH_:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
and [rsp+28h+var_28], 0
call _ZNK5minja13chat_template5applyERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEESH_bSH_b; minja::chat_template::apply(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool)
loc_5E1D3:
mov rax, rbx
add rsp, 18h
pop rbx
pop r14
retn
mov r14, rax
cmp edx, 1
jnz short loc_5E211
mov rdi, r14; void *
call ___cxa_begin_catch
lea rsi, aInfillMode+1Ch; ""
lea rdx, [rsp+28h+var_11]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
call ___cxa_end_catch
jmp short loc_5E1D3
mov r14, rax
call ___cxa_end_catch
loc_5E211:
mov rdi, r14
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long minja::chat_template::try_raw_render(long long a1, int a2, int a3, int a4, int a5, int a6)
{
minja::chat_template::apply(a1, a2, a3, a4, a5, a6, 0);
return a1;
}
| try_raw_render:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LAB_0015e1ca:
AND dword ptr [RSP],0x0
CALL 0x00179d16
LAB_0015e1d3:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* minja::chat_template::try_raw_render(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&, bool,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) const */
chat_template * __thiscall
minja::chat_template::try_raw_render
(chat_template *this,basic_json *param_1,basic_json *param_2,bool param_3,
basic_json *param_4)
{
int7 in_register_00000009;
/* try { // try from 0015e1ca to 0015e1d2 has its CatchHandler @ 0015e1de */
apply(this,param_1,SUB81(param_2,0),(basic_json *)CONCAT71(in_register_00000009,param_3),
SUB81(param_4,0));
return this;
}
| |
26,353 | quantize_q5_0 | ngxson[P]ggml-easy/ggml/src/ggml-quants.c | size_t quantize_q5_0(const float * GGML_RESTRICT src, void * GGML_RESTRICT dst, int64_t nrow, int64_t n_per_row, const float * quant_weights) {
if (!quant_weights) {
quantize_row_q5_0_ref(src, dst, (int64_t)nrow*n_per_row);
return nrow * ggml_row_size(GGML_TYPE_Q5_0, n_per_row);
}
size_t row_size = ggml_row_size(GGML_TYPE_Q5_0, n_per_row);
char * qrow = (char *)dst;
for (int64_t row = 0; row < nrow; ++row) {
quantize_row_q5_0_impl(src, (block_q5_0*)qrow, n_per_row, quant_weights);
src += n_per_row;
qrow += row_size;
}
return nrow * row_size;
} | O2 | c | quantize_q5_0:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r12
movq %r8, 0x40(%rsp)
testq %r8, %r8
je 0x353b1
pushq $0x6
popq %rdi
movq %r14, %rsi
callq 0x1e1b0
xorl %edi, %edi
testq %r14, %r14
movl $0x0, %r8d
cmovgq %r14, %r8
movq %rax, %rsi
cvtsi2ss %r14, %xmm0
movss %xmm0, 0x10(%rsp)
pushq $0x20
popq %rcx
movq %r14, %rax
cqto
idivq %rcx
testq %rax, %rax
cmovleq %rdi, %rax
movq %rax, 0x68(%rsp)
testq %rbx, %rbx
movl $0x0, %eax
cmovgq %rbx, %rax
movq %rax, 0x48(%rsp)
shlq $0x2, %r14
leaq 0x6(%r13), %rbp
movq %rbx, 0x38(%rsp)
movq %r14, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %r8, 0x20(%rsp)
cmpq 0x48(%rsp), %rdi
je 0x353d1
xorps %xmm1, %xmm1
xorl %eax, %eax
cmpq %rax, %r8
je 0x35244
movss (%r12,%rax,4), %xmm0
mulss %xmm0, %xmm0
addss %xmm0, %xmm1
incq %rax
jmp 0x3522c
movq %rdi, 0x58(%rsp)
divss 0x10(%rsp), %xmm1
movq %rbp, 0x50(%rsp)
movq 0x40(%rsp), %rbx
movq %r12, 0x18(%rsp)
xorl %r15d, %r15d
movss %xmm1, 0xc(%rsp)
movq %r13, 0x60(%rsp)
cmpq 0x68(%rsp), %r15
je 0x3537d
movq %r15, %r14
shlq $0x7, %r14
addq 0x18(%rsp), %r14
xorl %r13d, %r13d
cmpq $0x20, %r13
je 0x352d9
movss (%rbx,%r13,4), %xmm2
movss (%r12,%r13,4), %xmm0
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
ucomiss 0x1a381(%rip), %xmm0 # 0x4f628
jb 0x352af
sqrtss %xmm0, %xmm0
jmp 0x352c6
movss %xmm2, 0x14(%rsp)
callq 0x1eae0
movss 0x14(%rsp), %xmm2
movss 0xc(%rsp), %xmm1
mulss %xmm0, %xmm2
movss %xmm2, 0x90(%rsp,%r13,4)
incq %r13
jmp 0x35286
pushq $0x20
popq %rdi
pushq $0x10
popq %rsi
movq %r14, %rdx
leaq 0x70(%rsp), %rcx
leaq 0x90(%rsp), %r8
callq 0x3453c
callq 0x30a5a
imulq $0x16, %r15, %rcx
movq 0x60(%rsp), %r13
leaq (%rcx,%r13), %rdx
movw %ax, (%r13,%rcx)
xorl %eax, %eax
xorl %esi, %esi
cmpq $0x10, %rax
je 0x3535d
movzbl 0x70(%rsp,%rax), %edi
movl %edi, %r8d
shrl $0x4, %edi
andl $0x1, %edi
movl %eax, %ecx
shll %cl, %edi
movzbl 0x80(%rsp,%rax), %r9d
andb $0xf, %r8b
movl %r9d, %r10d
shlb $0x4, %r10b
orb %r8b, %r10b
shrl $0x4, %r9d
andl $0x1, %r9d
leal 0x10(%rax), %ecx
shll %cl, %r9d
movb %r10b, (%rbp,%rax)
addl %edi, %r9d
orl %r9d, %esi
incq %rax
jmp 0x35310
movl %esi, 0x2(%rdx)
incq %r15
movl $0x80, %eax
addq %rax, %r12
addq %rax, %rbx
addq $0x16, %rbp
movss 0xc(%rsp), %xmm1
jmp 0x3526c
movq 0x30(%rsp), %r14
movq 0x18(%rsp), %r12
addq %r14, %r12
movq 0x28(%rsp), %rsi
addq %rsi, %r13
movq 0x58(%rsp), %rdi
incq %rdi
movq 0x50(%rsp), %rbp
addq %rsi, %rbp
movq 0x38(%rsp), %rbx
movq 0x20(%rsp), %r8
jmp 0x3521c
movq %r14, %rdx
imulq %rbx, %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x1e9e0
pushq $0x6
popq %rdi
movq %r14, %rsi
callq 0x1e1b0
movq %rax, %rsi
imulq %rbx, %rsi
movq %rsi, %rax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| quantize_q5_0:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 118h
mov r14, rcx
mov rbx, rdx
mov r13, rsi
mov r12, rdi
mov [rsp+148h+var_108], r8
test r8, r8
jz loc_353B1
push 6
pop rdi
mov rsi, r14
call _ggml_row_size
xor edi, edi
test r14, r14
mov r8d, 0
cmovg r8, r14
mov rsi, rax
cvtsi2ss xmm0, r14
movss [rsp+148h+var_138], xmm0
push 20h ; ' '
pop rcx
mov rax, r14
cqo
idiv rcx
test rax, rax
cmovle rax, rdi
mov [rsp+148h+var_E0], rax
test rbx, rbx
mov eax, 0
cmovg rax, rbx
mov [rsp+148h+var_100], rax
shl r14, 2
lea rbp, [r13+6]
mov [rsp+148h+var_110], rbx
mov [rsp+148h+var_118], r14
mov [rsp+148h+var_120], rsi
mov [rsp+148h+var_128], r8
loc_3521C:
cmp rdi, [rsp+148h+var_100]
jz loc_353D1
xorps xmm1, xmm1
xor eax, eax
loc_3522C:
cmp r8, rax
jz short loc_35244
movss xmm0, dword ptr [r12+rax*4]
mulss xmm0, xmm0
addss xmm1, xmm0
inc rax
jmp short loc_3522C
loc_35244:
mov [rsp+148h+var_F0], rdi
divss xmm1, [rsp+148h+var_138]
mov [rsp+148h+var_F8], rbp
mov rbx, [rsp+148h+var_108]
mov [rsp+148h+var_130], r12
xor r15d, r15d
movss [rsp+148h+var_13C], xmm1
mov [rsp+148h+var_E8], r13
loc_3526C:
cmp r15, [rsp+148h+var_E0]
jz loc_3537D
mov r14, r15
shl r14, 7
add r14, [rsp+148h+var_130]
xor r13d, r13d
loc_35286:
cmp r13, 20h ; ' '
jz short loc_352D9
movss xmm2, dword ptr [rbx+r13*4]
movss xmm0, dword ptr [r12+r13*4]
mulss xmm0, xmm0
addss xmm0, xmm1
ucomiss xmm0, cs:dword_4F628
jb short loc_352AF
sqrtss xmm0, xmm0
jmp short loc_352C6
loc_352AF:
movss [rsp+148h+var_134], xmm2
call _sqrtf
movss xmm2, [rsp+148h+var_134]
movss xmm1, [rsp+148h+var_13C]
loc_352C6:
mulss xmm2, xmm0
movss [rsp+r13*4+148h+var_B8], xmm2
inc r13
jmp short loc_35286
loc_352D9:
push 20h ; ' '
pop rdi
push 10h
pop rsi
mov rdx, r14
lea rcx, [rsp+148h+var_D8]
lea r8, [rsp+148h+var_B8]
call make_qx_quants
call ggml_compute_fp32_to_fp16_0
imul rcx, r15, 16h
mov r13, [rsp+148h+var_E8]
lea rdx, [rcx+r13]
mov [r13+rcx+0], ax
xor eax, eax
xor esi, esi
loc_35310:
cmp rax, 10h
jz short loc_3535D
movzx edi, [rsp+rax+148h+var_D8]
mov r8d, edi
shr edi, 4
and edi, 1
mov ecx, eax
shl edi, cl
movzx r9d, [rsp+rax+148h+var_C8]
and r8b, 0Fh
mov r10d, r9d
shl r10b, 4
or r10b, r8b
shr r9d, 4
and r9d, 1
lea ecx, [rax+10h]
shl r9d, cl
mov [rbp+rax+0], r10b
add r9d, edi
or esi, r9d
inc rax
jmp short loc_35310
loc_3535D:
mov [rdx+2], esi
inc r15
mov eax, 80h
add r12, rax
add rbx, rax
add rbp, 16h
movss xmm1, [rsp+148h+var_13C]
jmp loc_3526C
loc_3537D:
mov r14, [rsp+148h+var_118]
mov r12, [rsp+148h+var_130]
add r12, r14
mov rsi, [rsp+148h+var_120]
add r13, rsi
mov rdi, [rsp+148h+var_F0]
inc rdi
mov rbp, [rsp+148h+var_F8]
add rbp, rsi
mov rbx, [rsp+148h+var_110]
mov r8, [rsp+148h+var_128]
jmp loc_3521C
loc_353B1:
mov rdx, r14
imul rdx, rbx
mov rdi, r12
mov rsi, r13
call _quantize_row_q5_0_ref
push 6
pop rdi
mov rsi, r14
call _ggml_row_size
mov rsi, rax
loc_353D1:
imul rsi, rbx
mov rax, rsi
add rsp, 118h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long quantize_q5_0(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
__m128i a6,
double a7,
double a8,
double a9,
double a10,
double a11,
__m128 a12)
{
long long v13; // rbx
long long v14; // r13
long long v15; // r12
unsigned long long v16; // rax
double v17; // xmm4_8
double v18; // xmm5_8
long long v19; // rdi
long long v20; // r8
unsigned long long v21; // rsi
long long v22; // rax
long long v23; // rdx
long long v24; // rax
long long v25; // rbp
double v26; // xmm1_8
long long i; // rax
long long v28; // rbx
long long v29; // r15
long long j; // r13
__int16 v31; // ax
long long v32; // rax
unsigned int v33; // r8d
int v34; // r9d
unsigned int v36; // [rsp+Ch] [rbp-13Ch]
unsigned int v37; // [rsp+14h] [rbp-134h]
long long v38; // [rsp+18h] [rbp-130h]
long long v39; // [rsp+20h] [rbp-128h]
unsigned long long v40; // [rsp+28h] [rbp-120h]
long long v41; // [rsp+38h] [rbp-110h]
long long v43; // [rsp+48h] [rbp-100h]
long long v44; // [rsp+50h] [rbp-F8h]
long long v45; // [rsp+58h] [rbp-F0h]
long long v46; // [rsp+60h] [rbp-E8h]
long long v47; // [rsp+68h] [rbp-E0h]
_BYTE v48[32]; // [rsp+70h] [rbp-D8h] BYREF
_DWORD v49[46]; // [rsp+90h] [rbp-B8h] BYREF
v13 = a3;
v14 = a2;
v15 = a1;
if ( a5 )
{
v16 = ggml_row_size(6u, a4);
v19 = 0LL;
v20 = 0LL;
if ( a4 > 0 )
v20 = a4;
v21 = v16;
*(float *)a6.m128i_i32 = (float)(int)a4;
v22 = a4 / 32;
v23 = a4 % 32;
if ( a4 / 32 <= 0 )
v22 = 0LL;
v47 = v22;
v24 = 0LL;
if ( v13 > 0 )
v24 = v13;
v43 = v24;
v25 = v14 + 6;
v41 = v13;
v40 = v21;
v39 = v20;
while ( v19 != v43 )
{
v26 = 0.0;
for ( i = 0LL; v20 != i; ++i )
{
a6 = (__m128i)*(unsigned int *)(v15 + 4 * i);
*(float *)a6.m128i_i32 = *(float *)a6.m128i_i32 * *(float *)a6.m128i_i32;
*(float *)&v26 = *(float *)&v26 + *(float *)a6.m128i_i32;
}
v45 = v19;
*(float *)&v26 = *(float *)&v26 / (float)(int)a4;
v44 = v25;
v28 = a5;
v38 = v15;
v29 = 0LL;
v36 = LODWORD(v26);
v46 = v14;
while ( v29 != v47 )
{
for ( j = 0LL; j != 32; ++j )
{
*(_QWORD *)&a8 = *(unsigned int *)(v28 + 4 * j);
a6 = (__m128i)*(unsigned int *)(v15 + 4 * j);
*(float *)a6.m128i_i32 = (float)(*(float *)a6.m128i_i32 * *(float *)a6.m128i_i32) + *(float *)&v26;
if ( *(float *)a6.m128i_i32 < 0.0 )
{
v37 = *(_DWORD *)(v28 + 4 * j);
sqrtf(v19, v21, v23);
*(_QWORD *)&a8 = v37;
*(_QWORD *)&v26 = v36;
}
else
{
*(float *)a6.m128i_i32 = fsqrt(*(float *)a6.m128i_i32);
}
*(float *)&a8 = *(float *)&a8 * *(float *)a6.m128i_i32;
v49[j] = LODWORD(a8);
}
v19 = 32LL;
make_qx_quants(
32LL,
16,
v38 + (v29 << 7),
(long long)v48,
(long long)v49,
*(double *)a6.m128i_i64,
v26,
a8,
a9,
v17,
v18,
a12);
v31 = ggml_compute_fp32_to_fp16_0(a6);
v14 = v46;
v23 = 22 * v29 + v46;
*(_WORD *)v23 = v31;
v32 = 0LL;
v21 = 0LL;
while ( v32 != 16 )
{
v33 = (unsigned __int8)v48[v32];
v19 = ((v33 >> 4) & 1) << v32;
v34 = ((unsigned __int8)v48[v32 + 16] >> 4) & 1;
*(_BYTE *)(v25 + v32) = v33 & 0xF | (16 * v48[v32 + 16]);
v21 = ((_DWORD)v19 + (v34 << (v32++ + 16))) | (unsigned int)v21;
}
*(_DWORD *)(v23 + 2) = v21;
++v29;
v15 += 128LL;
v28 += 128LL;
v25 += 22LL;
*(_QWORD *)&v26 = v36;
}
v15 = 4 * a4 + v38;
v21 = v40;
v14 += v40;
v19 = v45 + 1;
v25 = v40 + v44;
v13 = v41;
v20 = v39;
}
}
else
{
quantize_row_q5_0_ref(a1, a2, a3 * a4);
v21 = ggml_row_size(6u, a4);
}
return v13 * v21;
}
| quantize_q5_0:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x118
MOV R14,RCX
MOV RBX,RDX
MOV R13,RSI
MOV R12,RDI
MOV qword ptr [RSP + 0x40],R8
TEST R8,R8
JZ 0x001353b1
PUSH 0x6
POP RDI
MOV RSI,R14
CALL 0x0011e1b0
XOR EDI,EDI
TEST R14,R14
MOV R8D,0x0
CMOVG R8,R14
MOV RSI,RAX
CVTSI2SS XMM0,R14
MOVSS dword ptr [RSP + 0x10],XMM0
PUSH 0x20
POP RCX
MOV RAX,R14
CQO
IDIV RCX
TEST RAX,RAX
CMOVLE RAX,RDI
MOV qword ptr [RSP + 0x68],RAX
TEST RBX,RBX
MOV EAX,0x0
CMOVG RAX,RBX
MOV qword ptr [RSP + 0x48],RAX
SHL R14,0x2
LEA RBP,[R13 + 0x6]
MOV qword ptr [RSP + 0x38],RBX
MOV qword ptr [RSP + 0x30],R14
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],R8
LAB_0013521c:
CMP RDI,qword ptr [RSP + 0x48]
JZ 0x001353d1
XORPS XMM1,XMM1
XOR EAX,EAX
LAB_0013522c:
CMP R8,RAX
JZ 0x00135244
MOVSS XMM0,dword ptr [R12 + RAX*0x4]
MULSS XMM0,XMM0
ADDSS XMM1,XMM0
INC RAX
JMP 0x0013522c
LAB_00135244:
MOV qword ptr [RSP + 0x58],RDI
DIVSS XMM1,dword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x50],RBP
MOV RBX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x18],R12
XOR R15D,R15D
MOVSS dword ptr [RSP + 0xc],XMM1
MOV qword ptr [RSP + 0x60],R13
LAB_0013526c:
CMP R15,qword ptr [RSP + 0x68]
JZ 0x0013537d
MOV R14,R15
SHL R14,0x7
ADD R14,qword ptr [RSP + 0x18]
XOR R13D,R13D
LAB_00135286:
CMP R13,0x20
JZ 0x001352d9
MOVSS XMM2,dword ptr [RBX + R13*0x4]
MOVSS XMM0,dword ptr [R12 + R13*0x4]
MULSS XMM0,XMM0
ADDSS XMM0,XMM1
UCOMISS XMM0,dword ptr [0x0014f628]
JC 0x001352af
SQRTSS XMM0,XMM0
JMP 0x001352c6
LAB_001352af:
MOVSS dword ptr [RSP + 0x14],XMM2
CALL 0x0011eae0
MOVSS XMM2,dword ptr [RSP + 0x14]
MOVSS XMM1,dword ptr [RSP + 0xc]
LAB_001352c6:
MULSS XMM2,XMM0
MOVSS dword ptr [RSP + R13*0x4 + 0x90],XMM2
INC R13
JMP 0x00135286
LAB_001352d9:
PUSH 0x20
POP RDI
PUSH 0x10
POP RSI
MOV RDX,R14
LEA RCX,[RSP + 0x70]
LEA R8,[RSP + 0x90]
CALL 0x0013453c
CALL 0x00130a5a
IMUL RCX,R15,0x16
MOV R13,qword ptr [RSP + 0x60]
LEA RDX,[RCX + R13*0x1]
MOV word ptr [R13 + RCX*0x1],AX
XOR EAX,EAX
XOR ESI,ESI
LAB_00135310:
CMP RAX,0x10
JZ 0x0013535d
MOVZX EDI,byte ptr [RSP + RAX*0x1 + 0x70]
MOV R8D,EDI
SHR EDI,0x4
AND EDI,0x1
MOV ECX,EAX
SHL EDI,CL
MOVZX R9D,byte ptr [RSP + RAX*0x1 + 0x80]
AND R8B,0xf
MOV R10D,R9D
SHL R10B,0x4
OR R10B,R8B
SHR R9D,0x4
AND R9D,0x1
LEA ECX,[RAX + 0x10]
SHL R9D,CL
MOV byte ptr [RBP + RAX*0x1],R10B
ADD R9D,EDI
OR ESI,R9D
INC RAX
JMP 0x00135310
LAB_0013535d:
MOV dword ptr [RDX + 0x2],ESI
INC R15
MOV EAX,0x80
ADD R12,RAX
ADD RBX,RAX
ADD RBP,0x16
MOVSS XMM1,dword ptr [RSP + 0xc]
JMP 0x0013526c
LAB_0013537d:
MOV R14,qword ptr [RSP + 0x30]
MOV R12,qword ptr [RSP + 0x18]
ADD R12,R14
MOV RSI,qword ptr [RSP + 0x28]
ADD R13,RSI
MOV RDI,qword ptr [RSP + 0x58]
INC RDI
MOV RBP,qword ptr [RSP + 0x50]
ADD RBP,RSI
MOV RBX,qword ptr [RSP + 0x38]
MOV R8,qword ptr [RSP + 0x20]
JMP 0x0013521c
LAB_001353b1:
MOV RDX,R14
IMUL RDX,RBX
MOV RDI,R12
MOV RSI,R13
CALL 0x0011e9e0
PUSH 0x6
POP RDI
MOV RSI,R14
CALL 0x0011e1b0
MOV RSI,RAX
LAB_001353d1:
IMUL RSI,RBX
MOV RAX,RSI
ADD RSP,0x118
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long quantize_q5_0(long param_1,long param_2,long param_3,long param_4,long param_5)
{
float fVar1;
byte bVar2;
byte bVar3;
int2 uVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
long lVar9;
long lVar10;
uint uVar11;
long lVar12;
long lVar13;
long lVar14;
long lVar15;
long lVar16;
float fVar17;
float fVar18;
byte local_d8 [32];
float local_b8 [34];
if (param_5 == 0) {
quantize_row_q5_0_ref(param_1,param_2,param_4 * param_3);
lVar5 = ggml_row_size(6,param_4);
}
else {
lVar5 = ggml_row_size(6,param_4);
lVar12 = 0;
lVar13 = 0;
if (0 < param_4) {
lVar13 = param_4;
}
lVar6 = param_4 / 0x20;
if (param_4 / 0x20 < 1) {
lVar6 = lVar12;
}
lVar7 = 0;
if (0 < param_3) {
lVar7 = param_3;
}
lVar10 = param_2 + 6;
for (; lVar12 != lVar7; lVar12 = lVar12 + 1) {
fVar18 = 0.0;
for (lVar8 = 0; lVar13 != lVar8; lVar8 = lVar8 + 1) {
fVar1 = *(float *)(param_1 + lVar8 * 4);
fVar18 = fVar18 + fVar1 * fVar1;
}
lVar8 = param_5;
lVar9 = lVar10;
lVar14 = param_1;
for (lVar16 = 0; lVar16 != lVar6; lVar16 = lVar16 + 1) {
for (lVar15 = 0; lVar15 != 0x20; lVar15 = lVar15 + 1) {
fVar1 = *(float *)(lVar8 + lVar15 * 4);
fVar17 = *(float *)(lVar14 + lVar15 * 4);
fVar17 = fVar17 * fVar17 + fVar18 / (float)param_4;
if (fVar17 < DAT_0014f628) {
fVar17 = sqrtf(fVar17);
}
else {
fVar17 = SQRT(fVar17);
}
local_b8[lVar15] = fVar1 * fVar17;
}
make_qx_quants(0x20,0x10,lVar16 * 0x80 + param_1,local_d8,local_b8);
uVar4 = ggml_compute_fp32_to_fp16();
*(int2 *)(param_2 + lVar16 * 0x16) = uVar4;
uVar11 = 0;
for (lVar15 = 0; lVar15 != 0x10; lVar15 = lVar15 + 1) {
bVar2 = local_d8[lVar15];
bVar3 = local_d8[lVar15 + 0x10];
*(byte *)(lVar9 + lVar15) = bVar3 << 4 | bVar2 & 0xf;
uVar11 = uVar11 | ((bVar3 >> 4 & 1) << ((byte)lVar15 + 0x10 & 0x1f)) +
((bVar2 >> 4 & 1) << ((byte)lVar15 & 0x1f));
}
*(uint *)(lVar16 * 0x16 + param_2 + 2) = uVar11;
lVar14 = lVar14 + 0x80;
lVar8 = lVar8 + 0x80;
lVar9 = lVar9 + 0x16;
}
param_1 = param_1 + param_4 * 4;
param_2 = param_2 + lVar5;
lVar10 = lVar10 + lVar5;
}
}
return lVar5 * param_3;
}
| |
26,354 | my_mb_wc_utf8mb3_quick | eloqsql/strings/ctype-utf8.h | static inline int
my_mb_wc_utf8mb3_quick(my_wc_t * pwc, const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0x80)
{
*pwc = c;
return 1;
}
else if (c < 0xc2)
return MY_CS_ILSEQ;
else if (c < 0xe0)
{
if (s+2 > e) /* We need 2 characters */
return MY_CS_TOOSMALL2;
if (!(IS_CONTINUATION_BYTE(s[1])))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
else if (c < 0xf0)
{
if (s+3 > e) /* We need 3 characters */
return MY_CS_TOOSMALL3;
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
return MY_CS_ILSEQ;
} | O0 | c | my_mb_wc_utf8mb3_quick:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x65f16
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x66093
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x80, %eax
jge 0x65f43
movzbl -0x21(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x66093
movzbl -0x21(%rbp), %eax
cmpl $0xc2, %eax
jge 0x65f5a
movl $0x0, -0x4(%rbp)
jmp 0x66093
movzbl -0x21(%rbp), %eax
cmpl $0xe0, %eax
jge 0x65fd0
movq -0x18(%rbp), %rax
addq $0x2, %rax
cmpq -0x20(%rbp), %rax
jbe 0x65f7f
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x66093
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jl 0x65f9d
movl $0x0, -0x4(%rbp)
jmp 0x66093
movzbl -0x21(%rbp), %eax
andl $0x1f, %eax
movslq %eax, %rcx
shlq $0x6, %rcx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x66093
movzbl -0x21(%rbp), %eax
cmpl $0xf0, %eax
jge 0x66086
movq -0x18(%rbp), %rax
addq $0x3, %rax
cmpq -0x20(%rbp), %rax
jbe 0x65ff9
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0x66093
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x66037
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x66037
movzbl -0x21(%rbp), %eax
cmpl $0xe1, %eax
jge 0x66040
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa0, %eax
jge 0x66040
movl $0x0, -0x4(%rbp)
jmp 0x66093
movzbl -0x21(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
shlq $0xc, %rcx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0x6, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x66093
jmp 0x66088
jmp 0x6608a
jmp 0x6608c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| my_mb_wc_utf8mb3_quick_0:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jb short loc_65F16
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_66093
loc_65F16:
mov rax, [rbp+var_18]
mov al, [rax]
mov [rbp+var_21], al
movzx eax, [rbp+var_21]
cmp eax, 80h
jge short loc_65F43
movzx eax, [rbp+var_21]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_66093
loc_65F43:
movzx eax, [rbp+var_21]
cmp eax, 0C2h
jge short loc_65F5A
mov [rbp+var_4], 0
jmp loc_66093
loc_65F5A:
movzx eax, [rbp+var_21]
cmp eax, 0E0h
jge short loc_65FD0
mov rax, [rbp+var_18]
add rax, 2
cmp rax, [rbp+var_20]
jbe short loc_65F7F
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_66093
loc_65F7F:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jl short loc_65F9D
mov [rbp+var_4], 0
jmp loc_66093
loc_65F9D:
movzx eax, [rbp+var_21]
and eax, 1Fh
movsxd rcx, eax
shl rcx, 6
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 2
jmp loc_66093
loc_65FD0:
movzx eax, [rbp+var_21]
cmp eax, 0F0h
jge loc_66086
mov rax, [rbp+var_18]
add rax, 3
cmp rax, [rbp+var_20]
jbe short loc_65FF9
mov [rbp+var_4], 0FFFFFF99h
jmp loc_66093
loc_65FF9:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_66037
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_66037
movzx eax, [rbp+var_21]
cmp eax, 0E1h
jge short loc_66040
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
cmp eax, 0A0h
jge short loc_66040
loc_66037:
mov [rbp+var_4], 0
jmp short loc_66093
loc_66040:
movzx eax, [rbp+var_21]
and eax, 0Fh
movsxd rcx, eax
shl rcx, 0Ch
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
shl rax, 6
or rcx, rax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 3
jmp short loc_66093
loc_66086:
jmp short $+2
loc_66088:
jmp short $+2
loc_6608A:
jmp short $+2
loc_6608C:
mov [rbp+var_4], 0
loc_66093:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_mb_wc_utf8mb3_quick_0(unsigned long long *a1, unsigned __int8 *a2, unsigned long long a3)
{
unsigned __int8 v4; // [rsp+1h] [rbp-21h]
if ( (unsigned long long)a2 < a3 )
{
v4 = *a2;
if ( *a2 >= 0x80u )
{
if ( v4 >= 0xC2u )
{
if ( v4 >= 0xE0u )
{
if ( v4 >= 0xF0u )
{
return 0;
}
else if ( (unsigned long long)(a2 + 3) <= a3 )
{
if ( (a2[1] ^ 0x80) < 64 && (a2[2] ^ 0x80) < 64 && (v4 >= 0xE1u || a2[1] >= 0xA0u) )
{
*a1 = a2[2] ^ 0x80u | ((long long)(a2[1] ^ 0x80u) << 6) | ((unsigned long long)(v4 & 0xF) << 12);
return 3;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-103;
}
}
else if ( (unsigned long long)(a2 + 2) <= a3 )
{
if ( (a2[1] ^ 0x80) < 64 )
{
*a1 = a2[1] ^ 0x80u | ((unsigned long long)(v4 & 0x1F) << 6);
return 2;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
return 0;
}
}
else
{
*a1 = v4;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_mb_wc_utf8mb3_quick:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JC 0x00165f16
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x00166093
LAB_00165f16:
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x21],AL
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0x80
JGE 0x00165f43
MOVZX EAX,byte ptr [RBP + -0x21]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00166093
LAB_00165f43:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xc2
JGE 0x00165f5a
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00166093
LAB_00165f5a:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe0
JGE 0x00165fd0
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x00165f7f
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x00166093
LAB_00165f7f:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JL 0x00165f9d
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00166093
LAB_00165f9d:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0x1f
MOVSXD RCX,EAX
SHL RCX,0x6
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00166093
LAB_00165fd0:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf0
JGE 0x00166086
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x00165ff9
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x00166093
LAB_00165ff9:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x00166037
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x00166037
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe1
JGE 0x00166040
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa0
JGE 0x00166040
LAB_00166037:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00166093
LAB_00166040:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0xf
MOVSXD RCX,EAX
SHL RCX,0xc
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
SHL RAX,0x6
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x3
JMP 0x00166093
LAB_00166086:
JMP 0x00166088
LAB_00166088:
JMP 0x0016608a
LAB_0016608a:
JMP 0x0016608c
LAB_0016608c:
MOV dword ptr [RBP + -0x4],0x0
LAB_00166093:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_mb_wc_utf8mb3_quick(ulong *param_1,byte *param_2,byte *param_3)
{
byte bVar1;
int4 local_c;
if (param_2 < param_3) {
bVar1 = *param_2;
if (bVar1 < 0x80) {
*param_1 = (ulong)bVar1;
local_c = 1;
}
else if (bVar1 < 0xc2) {
local_c = 0;
}
else if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
local_c = 0xffffff9a;
}
else if ((param_2[1] ^ 0x80) < 0x40) {
*param_1 = (long)(int)(bVar1 & 0x1f) << 6 | (long)(int)(param_2[1] ^ 0x80);
local_c = 2;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf0) {
if (param_3 < param_2 + 3) {
local_c = 0xffffff99;
}
else if ((((param_2[1] ^ 0x80) < 0x40) && ((param_2[2] ^ 0x80) < 0x40)) &&
((0xe0 < bVar1 || (0x9f < param_2[1])))) {
*param_1 = (long)(int)(bVar1 & 0xf) << 0xc | (long)(int)(param_2[1] ^ 0x80) << 6 |
(long)(int)(param_2[2] ^ 0x80);
local_c = 3;
}
else {
local_c = 0;
}
}
else {
local_c = 0;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
26,355 | ftxui::ComponentBase::ActiveChild() | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/component/component.cpp | Component ComponentBase::ActiveChild() {
for (auto& child : children_) {
if (child->Focusable()) {
return child;
}
}
return nullptr;
} | O3 | cpp | ftxui::ComponentBase::ActiveChild():
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %r15
cmpq %r15, %r14
je 0x27108
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
jne 0x27117
addq $0x10, %r14
jmp 0x270f0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x2710e
movq 0x31e7f(%rip), %rcx # 0x58fb0
cmpb $0x0, (%rcx)
je 0x2713b
incl 0x8(%rax)
jmp 0x2710e
lock
incl 0x8(%rax)
jmp 0x2710e
nop
| _ZN5ftxui13ComponentBase11ActiveChildEv:
push r15
push r14
push rbx
mov rbx, rdi
mov r14, [rsi+8]
mov r15, [rsi+10h]
loc_270F0:
cmp r14, r15
jz short loc_27108
mov rdi, [r14]
mov rax, [rdi]
call qword ptr [rax+30h]
test al, al
jnz short loc_27117
add r14, 10h
jmp short loc_270F0
loc_27108:
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
loc_2710E:
mov rax, rbx
pop rbx
pop r14
pop r15
retn
loc_27117:
mov rax, [r14]
mov [rbx], rax
mov rax, [r14+8]
mov [rbx+8], rax
test rax, rax
jz short loc_2710E
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_2713B
inc dword ptr [rax+8]
jmp short loc_2710E
loc_2713B:
lock inc dword ptr [rax+8]
jmp short loc_2710E
| ftxui::ComponentBase * ftxui::ComponentBase::ActiveChild(ftxui::ComponentBase *this, long long a2)
{
_QWORD *v2; // r14
_QWORD *v3; // r15
long long v5; // rax
v2 = *(_QWORD **)(a2 + 8);
v3 = *(_QWORD **)(a2 + 16);
while ( 1 )
{
if ( v2 == v3 )
{
*(_OWORD *)this = 0LL;
return this;
}
if ( (*(unsigned __int8 ( **)(_QWORD))(*(_QWORD *)*v2 + 48LL))(*v2) )
break;
v2 += 2;
}
*(_QWORD *)this = *v2;
v5 = v2[1];
*((_QWORD *)this + 1) = v5;
if ( v5 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v5 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v5 + 8));
}
return this;
}
| ActiveChild:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV R14,qword ptr [RSI + 0x8]
MOV R15,qword ptr [RSI + 0x10]
LAB_001270f0:
CMP R14,R15
JZ 0x00127108
MOV RDI,qword ptr [R14]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x30]
TEST AL,AL
JNZ 0x00127117
ADD R14,0x10
JMP 0x001270f0
LAB_00127108:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_0012710e:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
LAB_00127117:
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RBX + 0x8],RAX
TEST RAX,RAX
JZ 0x0012710e
MOV RCX,qword ptr [0x00158fb0]
CMP byte ptr [RCX],0x0
JZ 0x0012713b
INC dword ptr [RAX + 0x8]
JMP 0x0012710e
LAB_0012713b:
INC.LOCK dword ptr [RAX + 0x8]
JMP 0x0012710e
|
/* ftxui::ComponentBase::ActiveChild() */
void ftxui::ComponentBase::ActiveChild(void)
{
int8 *puVar1;
long lVar2;
char cVar3;
long in_RSI;
int8 *in_RDI;
int8 *puVar4;
puVar4 = *(int8 **)(in_RSI + 8);
puVar1 = *(int8 **)(in_RSI + 0x10);
while( true ) {
if (puVar4 == puVar1) {
*in_RDI = 0;
in_RDI[1] = 0;
return;
}
cVar3 = (**(code **)(*(long *)*puVar4 + 0x30))();
if (cVar3 != '\0') break;
puVar4 = puVar4 + 2;
}
*in_RDI = *puVar4;
lVar2 = puVar4[1];
in_RDI[1] = lVar2;
if (lVar2 == 0) {
return;
}
if (*PTR___libc_single_threaded_00158fb0 != '\0') {
*(int *)(lVar2 + 8) = *(int *)(lVar2 + 8) + 1;
return;
}
LOCK();
*(int *)(lVar2 + 8) = *(int *)(lVar2 + 8) + 1;
UNLOCK();
return;
}
| |
26,356 | testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::~Matcher() | AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h | class GTEST_API_ Matcher<std::string>
: public internal::MatcherBase<std::string> {
public:
Matcher() = default;
explicit Matcher(const MatcherInterface<const std::string&>* impl)
: internal::MatcherBase<std::string>(impl) {}
explicit Matcher(const MatcherInterface<std::string>* impl)
: internal::MatcherBase<std::string>(impl) {}
template <typename M, typename = typename std::remove_reference<
M>::type::is_gtest_matcher>
Matcher(M&& m) // NOLINT
: internal::MatcherBase<std::string>(std::forward<M>(m)) {}
// Allows the user to write str instead of Eq(str) sometimes, where
// str is a string object.
Matcher(const std::string& s); // NOLINT
// Allows the user to write "foo" instead of Eq("foo") sometimes.
Matcher(const char* s); // NOLINT
} | O0 | c | testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::~Matcher():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xec280
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x16720
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN7testing7MatcherINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED0Ev:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rdi, [rsp+18h+var_8]
mov [rsp+18h+var_10], rdi
call _ZN7testing7MatcherINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; testing::Matcher<std::string>::~Matcher()
mov rdi, [rsp+18h+var_10]; void *
mov esi, 18h; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
add rsp, 18h
retn
| void testing::Matcher<std::string>::~Matcher(void *a1)
{
testing::Matcher<std::string>::~Matcher((long long)a1);
operator delete(a1, 0x18uLL);
}
| ~Matcher:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x001ec280
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x18
CALL 0x00116720
ADD RSP,0x18
RET
|
/* testing::Matcher<std::__cxx11::string >::~Matcher() */
void __thiscall
testing::Matcher<std::__cxx11::string>::~Matcher(Matcher<std::__cxx11::string> *this)
{
~Matcher(this);
operator_delete(this,0x18);
return;
}
| |
26,357 | my_wc_mb_bin | eloqsql/strings/ctype-bin.c | int my_wc_mb_bin(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
if (s >= e)
return MY_CS_TOOSMALL;
if (wc < 256)
{
s[0]= (char) wc;
return 1;
}
return MY_CS_ILUNI;
} | O0 | c | my_wc_mb_bin:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x89ab7
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x89add
cmpq $0x100, -0x18(%rbp) # imm = 0x100
jae 0x89ad6
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x89add
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_wc_mb_bin:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_89AB7
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_89ADD
loc_89AB7:
cmp [rbp+var_18], 100h
jnb short loc_89AD6
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp short loc_89ADD
loc_89AD6:
mov [rbp+var_4], 0
loc_89ADD:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_wc_mb_bin(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
if ( (unsigned long long)a3 < a4 )
{
if ( a2 >= 0x100 )
{
return 0;
}
else
{
*a3 = a2;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_bin:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x00189ab7
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x00189add
LAB_00189ab7:
CMP qword ptr [RBP + -0x18],0x100
JNC 0x00189ad6
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00189add
LAB_00189ad6:
MOV dword ptr [RBP + -0x4],0x0
LAB_00189add:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_wc_mb_bin(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
int4 local_c;
if (param_3 < param_4) {
if (param_2 < 0x100) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
local_c = 0;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
26,358 | cli::group::match_set(cli::match_state&) const | msxemulator/build_O3/_deps/picotool-src/cli.h | match_type match_set(match_state& ms) const {
// because of repeatability, we keep matching until there is nothing left to match
// vector<match_type> types(elements.size(), match_type::not_yet);
bool had_any_matches = false;
bool final_pass = false;
do {
bool matches_this_time = false;
bool errors_this_time = false;
bool not_min_this_time = false;
for (size_t i=0;i<elements.size();i++) {
// if (types[i] == match_type::not_yet) {
auto ms_prime = ms;
ms_prime.apply_settings_from();
match_type t = elements[i]->match(ms_prime);
assert(t != match_type::not_yet);
if (t == match_type::match) {
// we got a match, so record in ms and try again
// (if the matchable isn't repeatable it will no match next time)
// types[i] = match_type::not_yet;
ms_prime.save_settings_into();
ms = ms_prime;
had_any_matches = true;
matches_this_time = true;
} else if (t == match_type::error) {
if (final_pass) {
ms_prime.save_settings_into();
ms = ms_prime;
return t;
}
errors_this_time = true;
} else {
if (ms.get_match_count(elements[i]) < elements[i]->min()) {
if (final_pass) {
ms.error_message = elements[i]->missing ? elements[i]->missing() : "missing required argument";
return match_type::error;
}
not_min_this_time = true;
}
}
// }
}
if (final_pass) break;
if (!matches_this_time) {
if (errors_this_time || not_min_this_time) {
final_pass = true;
} else {
break;
}
}
} while (true);
return had_any_matches ? match_type::match : match_type::no_match;
} | O3 | c | cli::group::match_set(cli::match_state&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x88(%rsp), %r12
leaq 0x18(%rsi), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsi), %r13
leaq 0x48(%rsi), %rax
movq %rax, 0x8(%rsp)
leaq 0x78(%rsi), %rax
movq %rax, 0x18(%rsp)
movl $0x80, %eax
leaq (%rsi,%rax), %rcx
movq %rcx, 0x38(%rsp)
leaq 0x70(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0xe0(%rdi), %rax
movq 0xe8(%rdi), %rcx
movl $0x0, 0x4(%rsp)
movl $0x0, (%rsp)
movq %r13, 0x68(%rsp)
cmpq %rax, %rcx
je 0x4edcf
xorl %r14d, %r14d
xorl %ebp, %ebp
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0x38d04
leaq 0x98(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x1d410
movb 0x8(%r13), %al
movb %al, 0x28(%r12)
movq (%r13), %rax
movq %rax, 0x20(%r12)
leaq 0xb8(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4f1ea
leaq 0xe8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4f182
movq 0xe8(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0xe0(%r15), %rax
movq (%rax,%r14), %rdi
movq (%rdi), %rax
leaq 0x70(%rsp), %rsi
callq *0x10(%rax)
cmpl $0x2, %eax
je 0x4ebd6
cmpl $0x1, %eax
jne 0x4ec5e
movq 0xe8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
leaq 0x70(%rsp), %rsi
callq 0x4f3d2
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xf2a0
movb 0x28(%r12), %al
movb %al, 0x8(%r13)
movq 0x20(%r12), %rax
movq %rax, (%r13)
movq 0x8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x4f6f2
movq 0xe8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x4f966
movb $0x1, %al
movl %eax, 0x4(%rsp)
movb $0x1, %al
movq %rax, 0x30(%rsp)
movb $0x1, %r12b
jmp 0x4ed22
movb $0x1, %r12b
testb $0x1, (%rsp)
je 0x4ecbf
movq 0xe8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x88(%rsp), %r12
movq %rbx, %rdi
leaq 0x70(%rsp), %rsi
callq 0x4f3d2
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xf2a0
movb 0x28(%r12), %al
movb %al, 0x8(%r13)
movq 0x20(%r12), %rax
movq %rax, (%r13)
movq 0x8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x4f6f2
movq 0xe8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x4f966
xorl %r12d, %r12d
jmp 0x4ed22
movq 0xe0(%r15), %rax
movq (%rax,%r14), %rax
movq %rax, 0x48(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x4f9b0
movl (%rax), %ecx
movq 0xe0(%r15), %rax
movq (%rax,%r14), %rax
movb $0x1, %r12b
cmpl 0x88(%rax), %ecx
jge 0x4ed22
movb $0x1, %r12b
testb $0x1, (%rsp)
je 0x4ecc8
cmpq $0x0, 0x38(%rax)
je 0x4ecd1
leaq 0x28(%rax), %rsi
leaq 0x48(%rsp), %r13
movq %r13, %rdi
callq *0x40(%rax)
leaq 0x58(%rsp), %r12
jmp 0x4ecf6
movb $0x1, %al
movq %rax, 0x28(%rsp)
jmp 0x4ed22
movb $0x1, %al
movq %rax, 0x20(%rsp)
jmp 0x4ed22
leaq 0x58(%rsp), %r12
movq %r12, 0x48(%rsp)
leaq 0x48(%rsp), %r13
movq %r13, %rdi
leaq 0x56eb9(%rip), %rsi # 0xa5ba3
leaq 0x56ecb(%rip), %rdx # 0xa5bbc
callq 0x5c00c
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0xf580
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x4ed1a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xf470
xorl %r12d, %r12d
movq 0x68(%rsp), %r13
movq 0xf0(%rsp), %rdi
testq %rdi, %rdi
je 0x4ed34
callq 0x4bd0a
leaq 0xb8(%rsp), %rdi
callq 0x4f3be
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x4ed66
movq 0x98(%rsp), %rsi
incq %rsi
callq 0xf470
leaq 0x70(%rsp), %rdi
callq 0x1d254
testb %r12b, %r12b
je 0x4ede4
incq %rbp
movq 0xe0(%r15), %rax
movq 0xe8(%r15), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x4, %rdx
addq $0x10, %r14
cmpq %rdx, %rbp
leaq 0x88(%rsp), %r12
jb 0x4eaba
testb $0x1, (%rsp)
jne 0x4edcf
testb $0x1, 0x30(%rsp)
jne 0x4ea91
movq 0x28(%rsp), %rsi
orb 0x20(%rsp), %sil
movb $0x1, %dl
movl %edx, (%rsp)
testb $0x1, %sil
jne 0x4ea91
movl 0x4(%rsp), %eax
notb %al
movzbl %al, %eax
andl $0x1, %eax
leal 0x1(,%rax,2), %eax
jmp 0x4ede9
movl $0x2, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ee4c
jmp 0x4ee4c
movq %rax, %rbx
jmp 0x4ee16
jmp 0x4ee4c
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x4f3be
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x4ee40
movq 0x98(%rsp), %rsi
incq %rsi
callq 0xf470
jmp 0x4ee40
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x1d254
jmp 0x4ee59
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x4f142
movq %rbx, %rdi
callq 0xf7d0
nop
| _ZNK3cli5group9match_setERNS_11match_stateE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov rbx, rsi
mov r15, rdi
lea r12, [rsp+128h+var_A0]
lea rax, [rsi+18h]
mov [rsp+128h+var_118], rax
lea r13, [rsi+38h]
lea rax, [rsi+48h]
mov [rsp+128h+var_120], rax
lea rax, [rsi+78h]
mov [rsp+128h+var_110], rax
mov eax, 80h
lea rcx, [rsi+rax]
mov [rsp+128h+var_F0], rcx
lea rcx, [rsp+128h+var_B8]
add rax, rcx
mov [rsp+128h+var_E8], rax
mov rax, [rdi+0E0h]
mov rcx, [rdi+0E8h]
mov [rsp+128h+var_124], 0
mov [rsp+128h+var_128], 0
mov [rsp+128h+var_C0], r13
loc_4EA91:
cmp rcx, rax
jz loc_4EDCF
xor r14d, r14d
xor ebp, ebp
mov [rsp+128h+var_108], 0
mov [rsp+128h+var_100], 0
mov [rsp+128h+var_F8], 0
loc_4EABA:
lea rdi, [rsp+128h+var_B8]
mov rsi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
lea rax, [rsp+128h+var_90]
mov [rsp+128h+var_A0], rax
mov rsi, [rbx+18h]
mov rdx, [rbx+20h]
add rdx, rsi
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov al, [r13+8]
mov [r12+28h], al
mov rax, [r13+0]
mov [r12+20h], rax
lea rdi, [rsp+128h+var_70]
mov rsi, [rsp+128h+var_120]
call _ZNSt8_Rb_treeIPKN3cli9matchableESt4pairIKS3_iESt10_Select1stIS6_ESt4lessIS3_ESaIS6_EEC2ERKSC_; std::_Rb_tree<cli::matchable const*,std::pair<cli::matchable const* const,int>,std::_Select1st<std::pair<cli::matchable const* const,int>>,std::less<cli::matchable const*>,std::allocator<std::pair<cli::matchable const* const,int>>>::_Rb_tree(std::_Rb_tree<cli::matchable const*,std::pair<cli::matchable const* const,int>,std::_Select1st<std::pair<cli::matchable const* const,int>>,std::less<cli::matchable const*>,std::allocator<std::pair<cli::matchable const* const,int>>> const&)
lea rdi, [rsp+128h+var_40]
mov rsi, [rsp+128h+var_110]
call _ZN3cli15settings_holderC2ERKS0_; cli::settings_holder::settings_holder(cli::settings_holder const&)
mov rdi, [rsp+128h+var_40]
mov rax, [rdi]
call qword ptr [rax+10h]
mov rax, [r15+0E0h]
mov rdi, [rax+r14]
mov rax, [rdi]
lea rsi, [rsp+128h+var_B8]
call qword ptr [rax+10h]
cmp eax, 2
jz loc_4EBD6
cmp eax, 1
jnz loc_4EC5E
mov rdi, [rsp+128h+var_40]
mov rax, [rdi]
call qword ptr [rax+8]
mov rdi, rbx
lea rsi, [rsp+128h+var_B8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEaSERKS7_; std::vector<std::string>::operator=(std::vector<std::string> const&)
mov rdi, [rsp+128h+var_118]
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
mov al, [r12+28h]
mov [r13+8], al
mov rax, [r12+20h]
mov [r13+0], rax
mov rdi, [rsp+128h+var_120]
lea rsi, [rsp+128h+var_70]
call _ZNSt8_Rb_treeIPKN3cli9matchableESt4pairIKS3_iESt10_Select1stIS6_ESt4lessIS3_ESaIS6_EEaSERKSC_; std::_Rb_tree<cli::matchable const*,std::pair<cli::matchable const* const,int>,std::_Select1st<std::pair<cli::matchable const* const,int>>,std::less<cli::matchable const*>,std::allocator<std::pair<cli::matchable const* const,int>>>::operator=(std::_Rb_tree<cli::matchable const*,std::pair<cli::matchable const* const,int>,std::_Select1st<std::pair<cli::matchable const* const,int>>,std::less<cli::matchable const*>,std::allocator<std::pair<cli::matchable const* const,int>>> const&)
mov rax, [rsp+128h+var_40]
mov rcx, [rsp+128h+var_110]
mov [rcx], rax
mov rdi, [rsp+128h+var_F0]
mov rsi, [rsp+128h+var_E8]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEaSERKS2_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(std::__shared_count<(__gnu_cxx::_Lock_policy)2> const&)
mov al, 1
mov [rsp+128h+var_124], eax
mov al, 1
mov [rsp+128h+var_F8], rax
mov r12b, 1
jmp loc_4ED22
loc_4EBD6:
mov r12b, 1
test byte ptr [rsp+128h+var_128], 1
jz loc_4ECBF
mov rdi, [rsp+128h+var_40]
mov rax, [rdi]
call qword ptr [rax+8]
lea r12, [rsp+128h+var_A0]
mov rdi, rbx
lea rsi, [rsp+128h+var_B8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEaSERKS7_; std::vector<std::string>::operator=(std::vector<std::string> const&)
mov rdi, [rsp+128h+var_118]
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
mov al, [r12+28h]
mov [r13+8], al
mov rax, [r12+20h]
mov [r13+0], rax
mov rdi, [rsp+128h+var_120]
lea rsi, [rsp+128h+var_70]
call _ZNSt8_Rb_treeIPKN3cli9matchableESt4pairIKS3_iESt10_Select1stIS6_ESt4lessIS3_ESaIS6_EEaSERKSC_; std::_Rb_tree<cli::matchable const*,std::pair<cli::matchable const* const,int>,std::_Select1st<std::pair<cli::matchable const* const,int>>,std::less<cli::matchable const*>,std::allocator<std::pair<cli::matchable const* const,int>>>::operator=(std::_Rb_tree<cli::matchable const*,std::pair<cli::matchable const* const,int>,std::_Select1st<std::pair<cli::matchable const* const,int>>,std::less<cli::matchable const*>,std::allocator<std::pair<cli::matchable const* const,int>>> const&)
mov rax, [rsp+128h+var_40]
mov rcx, [rsp+128h+var_110]
mov [rcx], rax
mov rdi, [rsp+128h+var_F0]
mov rsi, [rsp+128h+var_E8]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEaSERKS2_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(std::__shared_count<(__gnu_cxx::_Lock_policy)2> const&)
xor r12d, r12d
jmp loc_4ED22
loc_4EC5E:
mov rax, [r15+0E0h]
mov rax, [rax+r14]
mov [rsp+128h+var_E0], rax
mov rdi, [rsp+128h+var_120]
lea rsi, [rsp+128h+var_E0]
call _ZNSt3mapIPKN3cli9matchableEiSt4lessIS3_ESaISt4pairIKS3_iEEEixEOS3_; std::map<cli::matchable const*,int>::operator[](cli::matchable const*&&)
mov ecx, [rax]
mov rax, [r15+0E0h]
mov rax, [rax+r14]
mov r12b, 1
cmp ecx, [rax+88h]
jge loc_4ED22
mov r12b, 1
test byte ptr [rsp+128h+var_128], 1
jz short loc_4ECC8
cmp qword ptr [rax+38h], 0
jz short loc_4ECD1
lea rsi, [rax+28h]
lea r13, [rsp+128h+var_E0]
mov rdi, r13
call qword ptr [rax+40h]
lea r12, [rsp+128h+var_D0]
jmp short loc_4ECF6
loc_4ECBF:
mov al, 1
mov [rsp+128h+var_100], rax
jmp short loc_4ED22
loc_4ECC8:
mov al, 1
mov [rsp+128h+var_108], rax
jmp short loc_4ED22
loc_4ECD1:
lea r12, [rsp+128h+var_D0]
mov [rsp+128h+var_E0], r12
lea r13, [rsp+128h+var_E0]
mov rdi, r13
lea rsi, aMissingRequire; "missing required argument"
lea rdx, aMissingRequire+19h; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_4ECF6:
mov rdi, [rsp+128h+var_118]
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [rsp+128h+var_E0]; void *
cmp rdi, r12
jz short loc_4ED1A
mov rsi, [rsp+128h+var_D0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4ED1A:
xor r12d, r12d
mov r13, [rsp+128h+var_C0]
loc_4ED22:
mov rdi, [rsp+128h+var_38]
test rdi, rdi
jz short loc_4ED34
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4ED34:
lea rdi, [rsp+128h+var_70]
call _ZNSt8_Rb_treeIPKN3cli9matchableESt4pairIKS3_iESt10_Select1stIS6_ESt4lessIS3_ESaIS6_EED2Ev; std::_Rb_tree<cli::matchable const*,std::pair<cli::matchable const* const,int>,std::_Select1st<std::pair<cli::matchable const* const,int>>,std::less<cli::matchable const*>,std::allocator<std::pair<cli::matchable const* const,int>>>::~_Rb_tree()
mov rdi, [rsp+128h+var_A0]; void *
lea rax, [rsp+128h+var_90]
cmp rdi, rax
jz short loc_4ED66
mov rsi, [rsp+128h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4ED66:
lea rdi, [rsp+128h+var_B8]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
test r12b, r12b
jz short loc_4EDE4
inc rbp
mov rax, [r15+0E0h]
mov rcx, [r15+0E8h]
mov rdx, rcx
sub rdx, rax
sar rdx, 4
add r14, 10h
cmp rbp, rdx
lea r12, [rsp+128h+var_A0]
jb loc_4EABA
test byte ptr [rsp+128h+var_128], 1
jnz short loc_4EDCF
test byte ptr [rsp+128h+var_F8], 1
jnz loc_4EA91
mov rsi, [rsp+128h+var_100]
or sil, byte ptr [rsp+128h+var_108]
mov dl, 1
mov [rsp+128h+var_128], edx
test sil, 1
jnz loc_4EA91
loc_4EDCF:
mov eax, [rsp+128h+var_124]
not al
movzx eax, al
and eax, 1
lea eax, ds:1[rax*2]
jmp short loc_4EDE9
loc_4EDE4:
mov eax, 2
loc_4EDE9:
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_4EE4C
jmp short loc_4EE4C
mov rbx, rax
jmp short loc_4EE16
jmp short loc_4EE4C
mov rbx, rax
lea rdi, [rsp+arg_B0]
call _ZNSt8_Rb_treeIPKN3cli9matchableESt4pairIKS3_iESt10_Select1stIS6_ESt4lessIS3_ESaIS6_EED2Ev; std::_Rb_tree<cli::matchable const*,std::pair<cli::matchable const* const,int>,std::_Select1st<std::pair<cli::matchable const* const,int>>,std::less<cli::matchable const*>,std::allocator<std::pair<cli::matchable const* const,int>>>::~_Rb_tree()
loc_4EE16:
mov rdi, [rsp+arg_80]; void *
lea rax, [rsp+arg_90]
cmp rdi, rax
jz short loc_4EE40
mov rsi, [rsp+arg_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_4EE40
mov rbx, rax
loc_4EE40:
lea rdi, [rsp+arg_68]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_4EE59
loc_4EE4C:
mov rbx, rax
lea rdi, [rsp+arg_68]; this
call _ZN3cli11match_stateD2Ev; cli::match_state::~match_state()
loc_4EE59:
mov rdi, rbx
call __Unwind_Resume
| long long cli::group::match_set(cli::group *this, cli::match_state *a2)
{
char *v2; // r13
long long v3; // rax
long long v4; // rcx
long long v5; // r14
unsigned long long v6; // rbp
int v7; // eax
char v8; // r12
int v9; // ecx
long long v10; // rax
char v12; // [rsp+0h] [rbp-128h]
char v13; // [rsp+4h] [rbp-124h]
char *v14; // [rsp+8h] [rbp-120h]
char *v15; // [rsp+10h] [rbp-118h]
_QWORD *v16; // [rsp+18h] [rbp-110h]
char v17; // [rsp+20h] [rbp-108h]
char v18; // [rsp+28h] [rbp-100h]
char v19; // [rsp+30h] [rbp-F8h]
char *v20; // [rsp+38h] [rbp-F0h]
void *v21[2]; // [rsp+48h] [rbp-E0h] BYREF
_QWORD v22[2]; // [rsp+58h] [rbp-D0h] BYREF
char *v23; // [rsp+68h] [rbp-C0h]
void *v24[3]; // [rsp+70h] [rbp-B8h] BYREF
void *v25; // [rsp+88h] [rbp-A0h] BYREF
_QWORD v26[2]; // [rsp+98h] [rbp-90h] BYREF
long long v27; // [rsp+A8h] [rbp-80h]
char v28; // [rsp+B0h] [rbp-78h]
_BYTE v29[48]; // [rsp+B8h] [rbp-70h] BYREF
long long v30; // [rsp+E8h] [rbp-40h] BYREF
volatile signed __int32 *v31[7]; // [rsp+F0h] [rbp-38h] BYREF
v15 = (char *)a2 + 24;
v2 = (char *)a2 + 56;
v14 = (char *)a2 + 72;
v16 = (_QWORD *)((char *)a2 + 120);
v20 = (char *)a2 + 128;
v3 = *((_QWORD *)this + 28);
v4 = *((_QWORD *)this + 29);
v13 = 0;
v12 = 0;
v23 = (char *)a2 + 56;
while ( v4 != v3 )
{
v5 = 0LL;
v6 = 0LL;
v17 = 0;
v18 = 0;
v19 = 0;
do
{
std::vector<std::string>::vector((long long)v24, a2);
v25 = v26;
std::string::_M_construct<char *>((long long)&v25, *((_BYTE **)a2 + 3), *((_QWORD *)a2 + 3) + *((_QWORD *)a2 + 4));
v28 = v2[8];
v27 = *(_QWORD *)v2;
std::_Rb_tree<cli::matchable const*,std::pair<cli::matchable const* const,int>,std::_Select1st<std::pair<cli::matchable const* const,int>>,std::less<cli::matchable const*>,std::allocator<std::pair<cli::matchable const* const,int>>>::_Rb_tree(
v29,
v14);
cli::settings_holder::settings_holder(&v30, v16);
(*(void ( **)(long long))(*(_QWORD *)v30 + 16LL))(v30);
v7 = (*(long long ( **)(_QWORD, void **))(**(_QWORD **)(*((_QWORD *)this + 28) + v5) + 16LL))(
*(_QWORD *)(*((_QWORD *)this + 28) + v5),
v24);
if ( v7 == 2 )
{
v8 = 1;
if ( (v12 & 1) != 0 )
{
(*(void ( **)(long long))(*(_QWORD *)v30 + 8LL))(v30);
std::vector<std::string>::operator=(a2, v24);
std::string::_M_assign(v15);
v2[8] = v28;
*(_QWORD *)v2 = v27;
std::_Rb_tree<cli::matchable const*,std::pair<cli::matchable const* const,int>,std::_Select1st<std::pair<cli::matchable const* const,int>>,std::less<cli::matchable const*>,std::allocator<std::pair<cli::matchable const* const,int>>>::operator=(
v14,
v29);
*v16 = v30;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(v20, v31);
v8 = 0;
}
else
{
v18 = 1;
}
}
else if ( v7 == 1 )
{
(*(void ( **)(long long))(*(_QWORD *)v30 + 8LL))(v30);
std::vector<std::string>::operator=(a2, v24);
std::string::_M_assign(v15);
v2[8] = v28;
*(_QWORD *)v2 = v27;
std::_Rb_tree<cli::matchable const*,std::pair<cli::matchable const* const,int>,std::_Select1st<std::pair<cli::matchable const* const,int>>,std::less<cli::matchable const*>,std::allocator<std::pair<cli::matchable const* const,int>>>::operator=(
v14,
v29);
*v16 = v30;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(v20, v31);
v13 = 1;
v19 = 1;
v8 = 1;
}
else
{
v21[0] = *(void **)(*((_QWORD *)this + 28) + v5);
v9 = *(_DWORD *)std::map<cli::matchable const*,int>::operator[](v14, v21);
v10 = *(_QWORD *)(*((_QWORD *)this + 28) + v5);
v8 = 1;
if ( v9 < *(_DWORD *)(v10 + 136) )
{
v8 = 1;
if ( (v12 & 1) != 0 )
{
if ( *(_QWORD *)(v10 + 56) )
{
(*(void ( **)(void **, long long))(v10 + 64))(v21, v10 + 40);
}
else
{
v21[0] = v22;
std::string::_M_construct<char const*>(v21, "missing required argument", "");
}
std::string::operator=(v15, v21);
if ( v21[0] != v22 )
operator delete(v21[0], v22[0] + 1LL);
v8 = 0;
v2 = v23;
}
else
{
v17 = 1;
}
}
}
if ( v31[0] )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v31[0]);
std::_Rb_tree<cli::matchable const*,std::pair<cli::matchable const* const,int>,std::_Select1st<std::pair<cli::matchable const* const,int>>,std::less<cli::matchable const*>,std::allocator<std::pair<cli::matchable const* const,int>>>::~_Rb_tree(v29);
if ( v25 != v26 )
operator delete(v25, v26[0] + 1LL);
std::vector<std::string>::~vector(v24);
if ( !v8 )
return 2LL;
++v6;
v3 = *((_QWORD *)this + 28);
v4 = *((_QWORD *)this + 29);
v5 += 16LL;
}
while ( v6 < (v4 - v3) >> 4 );
if ( (v12 & 1) != 0 )
break;
if ( (v19 & 1) == 0 )
{
v12 = 1;
if ( (((unsigned __int8)v17 | (unsigned __int8)v18) & 1) == 0 )
break;
}
}
return 2 * (unsigned int)((v13 & 1) == 0) + 1;
}
| match_set:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV RBX,RSI
MOV R15,RDI
LEA R12,[RSP + 0x88]
LEA RAX,[RSI + 0x18]
MOV qword ptr [RSP + 0x10],RAX
LEA R13,[RSI + 0x38]
LEA RAX,[RSI + 0x48]
MOV qword ptr [RSP + 0x8],RAX
LEA RAX,[RSI + 0x78]
MOV qword ptr [RSP + 0x18],RAX
MOV EAX,0x80
LEA RCX,[RSI + RAX*0x1]
MOV qword ptr [RSP + 0x38],RCX
LEA RCX,[RSP + 0x70]
ADD RAX,RCX
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RDI + 0xe0]
MOV RCX,qword ptr [RDI + 0xe8]
MOV dword ptr [RSP + 0x4],0x0
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x68],R13
LAB_0014ea91:
CMP RCX,RAX
JZ 0x0014edcf
XOR R14D,R14D
XOR EBP,EBP
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x0
LAB_0014eaba:
LEA RDI,[RSP + 0x70]
MOV RSI,RBX
CALL 0x00138d04
LEA RAX,[RSP + 0x98]
MOV qword ptr [RSP + 0x88],RAX
MOV RSI,qword ptr [RBX + 0x18]
MOV RDX,qword ptr [RBX + 0x20]
ADD RDX,RSI
LAB_0014eae2:
MOV RDI,R12
CALL 0x0011d410
MOV AL,byte ptr [R13 + 0x8]
MOV byte ptr [R12 + 0x28],AL
MOV RAX,qword ptr [R13]
MOV qword ptr [R12 + 0x20],RAX
LAB_0014eafc:
LEA RDI,[RSP + 0xb8]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0014f1ea
LAB_0014eb0e:
LEA RDI,[RSP + 0xe8]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x0014f182
MOV RDI,qword ptr [RSP + 0xe8]
MOV RAX,qword ptr [RDI]
LAB_0014eb2b:
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R15 + 0xe0]
MOV RDI,qword ptr [RAX + R14*0x1]
MOV RAX,qword ptr [RDI]
LAB_0014eb3c:
LEA RSI,[RSP + 0x70]
CALL qword ptr [RAX + 0x10]
CMP EAX,0x2
JZ 0x0014ebd6
CMP EAX,0x1
JNZ 0x0014ec5e
MOV RDI,qword ptr [RSP + 0xe8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
MOV RDI,RBX
LEA RSI,[RSP + 0x70]
CALL 0x0014f3d2
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,R12
CALL 0x0010f2a0
MOV AL,byte ptr [R12 + 0x28]
MOV byte ptr [R13 + 0x8],AL
MOV RAX,qword ptr [R12 + 0x20]
MOV qword ptr [R13],RAX
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0xb8]
CALL 0x0014f6f2
MOV RAX,qword ptr [RSP + 0xe8]
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RCX],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x40]
CALL 0x0014f966
MOV AL,0x1
MOV dword ptr [RSP + 0x4],EAX
MOV AL,0x1
MOV qword ptr [RSP + 0x30],RAX
MOV R12B,0x1
JMP 0x0014ed22
LAB_0014ebd6:
MOV R12B,0x1
TEST byte ptr [RSP],0x1
JZ 0x0014ecbf
MOV RDI,qword ptr [RSP + 0xe8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LEA R12,[RSP + 0x88]
MOV RDI,RBX
LEA RSI,[RSP + 0x70]
CALL 0x0014f3d2
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,R12
CALL 0x0010f2a0
MOV AL,byte ptr [R12 + 0x28]
MOV byte ptr [R13 + 0x8],AL
MOV RAX,qword ptr [R12 + 0x20]
MOV qword ptr [R13],RAX
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0xb8]
CALL 0x0014f6f2
MOV RAX,qword ptr [RSP + 0xe8]
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RCX],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x40]
CALL 0x0014f966
XOR R12D,R12D
JMP 0x0014ed22
LAB_0014ec5e:
MOV RAX,qword ptr [R15 + 0xe0]
MOV RAX,qword ptr [RAX + R14*0x1]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x48]
CALL 0x0014f9b0
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [R15 + 0xe0]
MOV RAX,qword ptr [RAX + R14*0x1]
MOV R12B,0x1
CMP ECX,dword ptr [RAX + 0x88]
JGE 0x0014ed22
MOV R12B,0x1
TEST byte ptr [RSP],0x1
JZ 0x0014ecc8
CMP qword ptr [RAX + 0x38],0x0
JZ 0x0014ecd1
LEA RSI,[RAX + 0x28]
LAB_0014ecad:
LEA R13,[RSP + 0x48]
MOV RDI,R13
CALL qword ptr [RAX + 0x40]
LEA R12,[RSP + 0x58]
JMP 0x0014ecf6
LAB_0014ecbf:
MOV AL,0x1
MOV qword ptr [RSP + 0x28],RAX
JMP 0x0014ed22
LAB_0014ecc8:
MOV AL,0x1
MOV qword ptr [RSP + 0x20],RAX
JMP 0x0014ed22
LAB_0014ecd1:
LEA R12,[RSP + 0x58]
MOV qword ptr [RSP + 0x48],R12
LAB_0014ecdb:
LEA R13,[RSP + 0x48]
MOV RDI,R13
LEA RSI,[0x1a5ba3]
LEA RDX,[0x1a5bbc]
CALL 0x0015c00c
LAB_0014ecf6:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,R13
CALL 0x0010f580
MOV RDI,qword ptr [RSP + 0x48]
CMP RDI,R12
JZ 0x0014ed1a
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0010f470
LAB_0014ed1a:
XOR R12D,R12D
MOV R13,qword ptr [RSP + 0x68]
LAB_0014ed22:
MOV RDI,qword ptr [RSP + 0xf0]
TEST RDI,RDI
JZ 0x0014ed34
CALL 0x0014bd0a
LAB_0014ed34:
LEA RDI,[RSP + 0xb8]
CALL 0x0014f3be
MOV RDI,qword ptr [RSP + 0x88]
LEA RAX,[RSP + 0x98]
CMP RDI,RAX
JZ 0x0014ed66
MOV RSI,qword ptr [RSP + 0x98]
INC RSI
CALL 0x0010f470
LAB_0014ed66:
LEA RDI,[RSP + 0x70]
CALL 0x0011d254
TEST R12B,R12B
JZ 0x0014ede4
INC RBP
MOV RAX,qword ptr [R15 + 0xe0]
MOV RCX,qword ptr [R15 + 0xe8]
MOV RDX,RCX
SUB RDX,RAX
SAR RDX,0x4
ADD R14,0x10
CMP RBP,RDX
LEA R12,[RSP + 0x88]
JC 0x0014eaba
TEST byte ptr [RSP],0x1
JNZ 0x0014edcf
TEST byte ptr [RSP + 0x30],0x1
JNZ 0x0014ea91
MOV RSI,qword ptr [RSP + 0x28]
OR SIL,byte ptr [RSP + 0x20]
MOV DL,0x1
MOV dword ptr [RSP],EDX
TEST SIL,0x1
JNZ 0x0014ea91
LAB_0014edcf:
MOV EAX,dword ptr [RSP + 0x4]
NOT AL
MOVZX EAX,AL
AND EAX,0x1
LEA EAX,[0x1 + RAX*0x2]
JMP 0x0014ede9
LAB_0014ede4:
MOV EAX,0x2
LAB_0014ede9:
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* cli::group::match_set(cli::match_state&) const */
char __thiscall cli::group::match_set(group *this,match_state *param_1)
{
string *this_00;
_Rb_tree *this_01;
settings_holder *psVar1;
bool bVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
int iVar7;
long lVar8;
int *piVar9;
long lVar10;
ulong uVar11;
match_state *pmVar12;
long lVar13;
byte local_124;
matchable *local_e0 [2];
long local_d0 [2];
match_state *local_c0;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_b8 [24];
long *local_a0 [2];
long local_90 [2];
int8 local_80;
match_state local_78;
_Rb_tree<cli::matchable_const*,std::pair<cli::matchable_const*const,int>,std::_Select1st<std::pair<cli::matchable_const*const,int>>,std::less<cli::matchable_const*>,std::allocator<std::pair<cli::matchable_const*const,int>>>
local_70 [48];
long *local_40;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_38;
this_00 = (string *)(param_1 + 0x18);
pmVar12 = param_1 + 0x38;
this_01 = (_Rb_tree *)(param_1 + 0x48);
psVar1 = (settings_holder *)(param_1 + 0x78);
lVar8 = *(long *)(this + 0xe0);
lVar10 = *(long *)(this + 0xe8);
local_124 = 0;
bVar3 = false;
local_c0 = pmVar12;
while (lVar10 != lVar8) {
lVar13 = 0;
uVar11 = 0;
bVar6 = false;
bVar5 = false;
bVar4 = false;
do {
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
(local_b8,param_1);
local_a0[0] = local_90;
/* try { // try from 0014eae2 to 0014eae9 has its CatchHandler @ 0014ee3d */
std::__cxx11::string::_M_construct<char*>
(local_a0,*(long *)(param_1 + 0x18),
*(long *)(param_1 + 0x20) + *(long *)(param_1 + 0x18));
local_78 = pmVar12[8];
local_80 = *(int8 *)pmVar12;
/* try { // try from 0014eafc to 0014eb0d has its CatchHandler @ 0014edff */
std::
_Rb_tree<cli::matchable_const*,std::pair<cli::matchable_const*const,int>,std::_Select1st<std::pair<cli::matchable_const*const,int>>,std::less<cli::matchable_const*>,std::allocator<std::pair<cli::matchable_const*const,int>>>
::_Rb_tree(local_70,this_01);
/* try { // try from 0014eb0e to 0014eb1f has its CatchHandler @ 0014ee06 */
settings_holder::settings_holder((settings_holder *)&local_40,psVar1);
/* try { // try from 0014eb2b to 0014eb2d has its CatchHandler @ 0014ee04 */
(**(code **)(*local_40 + 0x10))();
/* try { // try from 0014eb3c to 0014ec7c has its CatchHandler @ 0014ee4c */
iVar7 = (**(code **)(**(long **)(*(long *)(this + 0xe0) + lVar13) + 0x10))
(*(long **)(*(long *)(this + 0xe0) + lVar13),local_b8);
if (iVar7 == 2) {
bVar2 = true;
if (bVar3) {
(**(code **)(*local_40 + 8))();
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator=
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,
local_b8);
std::__cxx11::string::_M_assign(this_00);
pmVar12[8] = local_78;
*(int8 *)pmVar12 = local_80;
std::
_Rb_tree<cli::matchable_const*,std::pair<cli::matchable_const*const,int>,std::_Select1st<std::pair<cli::matchable_const*const,int>>,std::less<cli::matchable_const*>,std::allocator<std::pair<cli::matchable_const*const,int>>>
::operator=((_Rb_tree<cli::matchable_const*,std::pair<cli::matchable_const*const,int>,std::_Select1st<std::pair<cli::matchable_const*const,int>>,std::less<cli::matchable_const*>,std::allocator<std::pair<cli::matchable_const*const,int>>>
*)this_01,(_Rb_tree *)local_70);
*(long **)psVar1 = local_40;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)(param_1 + 0x80),
(__shared_count *)&local_38);
bVar2 = false;
}
else {
bVar5 = true;
}
}
else if (iVar7 == 1) {
(**(code **)(*local_40 + 8))();
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator=
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,
local_b8);
std::__cxx11::string::_M_assign(this_00);
pmVar12[8] = local_78;
*(int8 *)pmVar12 = local_80;
std::
_Rb_tree<cli::matchable_const*,std::pair<cli::matchable_const*const,int>,std::_Select1st<std::pair<cli::matchable_const*const,int>>,std::less<cli::matchable_const*>,std::allocator<std::pair<cli::matchable_const*const,int>>>
::operator=((_Rb_tree<cli::matchable_const*,std::pair<cli::matchable_const*const,int>,std::_Select1st<std::pair<cli::matchable_const*const,int>>,std::less<cli::matchable_const*>,std::allocator<std::pair<cli::matchable_const*const,int>>>
*)this_01,(_Rb_tree *)local_70);
*(long **)psVar1 = local_40;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)(param_1 + 0x80),
(__shared_count *)&local_38);
local_124 = 1;
bVar4 = true;
bVar2 = true;
}
else {
local_e0[0] = *(matchable **)(*(long *)(this + 0xe0) + lVar13);
piVar9 = (int *)std::
map<cli::matchable_const*,int,std::less<cli::matchable_const*>,std::allocator<std::pair<cli::matchable_const*const,int>>>
::operator[]((map<cli::matchable_const*,int,std::less<cli::matchable_const*>,std::allocator<std::pair<cli::matchable_const*const,int>>>
*)this_01,local_e0);
lVar8 = *(long *)(*(long *)(this + 0xe0) + lVar13);
bVar2 = true;
if (*piVar9 < *(int *)(lVar8 + 0x88)) {
bVar2 = true;
if (bVar3) {
if (*(long *)(lVar8 + 0x38) == 0) {
local_e0[0] = (matchable *)local_d0;
/* try { // try from 0014ecdb to 0014ecf5 has its CatchHandler @ 0014edfb */
std::__cxx11::string::_M_construct<char_const*>
((string *)local_e0,"missing required argument","");
}
else {
/* try { // try from 0014ecad to 0014ecb7 has its CatchHandler @ 0014edfd */
(**(code **)(lVar8 + 0x40))(local_e0,lVar8 + 0x28);
}
std::__cxx11::string::operator=(this_00,(string *)local_e0);
if (local_e0[0] != (matchable *)local_d0) {
operator_delete(local_e0[0],local_d0[0] + 1);
}
bVar2 = false;
pmVar12 = local_c0;
}
else {
bVar6 = true;
}
}
}
if (local_38 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_38);
}
std::
_Rb_tree<cli::matchable_const*,std::pair<cli::matchable_const*const,int>,std::_Select1st<std::pair<cli::matchable_const*const,int>>,std::less<cli::matchable_const*>,std::allocator<std::pair<cli::matchable_const*const,int>>>
::~_Rb_tree(local_70);
if (local_a0[0] != local_90) {
operator_delete(local_a0[0],local_90[0] + 1);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_b8);
if (!bVar2) {
return '\x02';
}
uVar11 = uVar11 + 1;
lVar8 = *(long *)(this + 0xe0);
lVar10 = *(long *)(this + 0xe8);
lVar13 = lVar13 + 0x10;
} while (uVar11 < (ulong)(lVar10 - lVar8 >> 4));
if ((bVar3) || ((!bVar4 && (bVar3 = true, !bVar5 && !bVar6)))) break;
}
return (~local_124 & 1) * '\x02' + '\x01';
}
| |
26,359 | translog_set_only_in_buffers | eloqsql/storage/maria/ma_loghandler.c | static void translog_set_only_in_buffers(TRANSLOG_ADDRESS in_buffers)
{
DBUG_ENTER("translog_set_only_in_buffers");
mysql_mutex_lock(&log_descriptor.sent_to_disk_lock);
DBUG_PRINT("enter", ("in_buffers: " LSN_FMT " "
"in_buffers_only: " LSN_FMT,
LSN_IN_PARTS(in_buffers),
LSN_IN_PARTS(log_descriptor.in_buffers_only)));
/* LSN_IMPOSSIBLE == 0 => it will work for very first time */
if (cmp_translog_addr(in_buffers, log_descriptor.in_buffers_only) > 0)
{
if (translog_status != TRANSLOG_OK)
goto end;
log_descriptor.in_buffers_only= in_buffers;
DBUG_PRINT("info", ("set new in_buffers_only"));
}
end:
mysql_mutex_unlock(&log_descriptor.sent_to_disk_lock);
DBUG_VOID_RETURN;
} | O0 | c | translog_set_only_in_buffers:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x41c51d(%rip), %rdi # 0x47a660
addq $0x800cc0, %rdi # imm = 0x800CC0
leaq 0xf4e68(%rip), %rsi # 0x152fb9
movl $0x911, %edx # imm = 0x911
callq 0x510a0
jmp 0x5e15d
movq -0x8(%rbp), %rax
subq 0xc1d1b0(%rip), %rax # 0xc7b318
cmpq $0x0, %rax
jle 0x5e188
cmpl $0x1, 0x41b2db(%rip) # 0x479450
je 0x5e179
jmp 0x5e18a
movq -0x8(%rbp), %rax
movq %rax, 0xc1d194(%rip) # 0xc7b318
jmp 0x5e186
jmp 0x5e188
jmp 0x5e18a
leaq 0x41c4cf(%rip), %rdi # 0x47a660
addq $0x800cc0, %rdi # imm = 0x800CC0
callq 0x51110
jmp 0x5e19f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| translog_set_only_in_buffers:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
lea rdi, log_descriptor
add rdi, 800CC0h
lea rsi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 911h
call inline_mysql_mutex_lock_8
jmp short $+2
loc_5E15D:
mov rax, [rbp+var_8]
sub rax, cs:qword_C7B318
cmp rax, 0
jle short loc_5E188
cmp cs:translog_status, 1
jz short loc_5E179
jmp short loc_5E18A
loc_5E179:
mov rax, [rbp+var_8]
mov cs:qword_C7B318, rax
jmp short $+2
loc_5E186:
jmp short $+2
loc_5E188:
jmp short $+2
loc_5E18A:
lea rdi, log_descriptor
add rdi, 800CC0h
call inline_mysql_mutex_unlock_8
jmp short $+2
loc_5E19F:
add rsp, 10h
pop rbp
retn
| long long translog_set_only_in_buffers(long long a1)
{
inline_mysql_mutex_lock_8(
(long long)&log_descriptor[1048984],
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x911u);
if ( a1 - qword_C7B318 > 0 && translog_status == 1 )
qword_C7B318 = a1;
return inline_mysql_mutex_unlock_8((long long)&log_descriptor[1048984]);
}
| translog_set_only_in_buffers:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
LEA RDI,[0x57a660]
ADD RDI,0x800cc0
LEA RSI,[0x252fb9]
MOV EDX,0x911
CALL 0x001510a0
JMP 0x0015e15d
LAB_0015e15d:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr [0x00d7b318]
CMP RAX,0x0
JLE 0x0015e188
CMP dword ptr [0x00579450],0x1
JZ 0x0015e179
JMP 0x0015e18a
LAB_0015e179:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [0x00d7b318],RAX
JMP 0x0015e186
LAB_0015e186:
JMP 0x0015e188
LAB_0015e188:
JMP 0x0015e18a
LAB_0015e18a:
LEA RDI,[0x57a660]
ADD RDI,0x800cc0
CALL 0x00151110
JMP 0x0015e19f
LAB_0015e19f:
ADD RSP,0x10
POP RBP
RET
|
void translog_set_only_in_buffers(long param_1)
{
long lVar1;
inline_mysql_mutex_lock
(&DAT_00d7b320,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x911);
lVar1 = DAT_00d7b318;
if ((param_1 - DAT_00d7b318 < 1) || (lVar1 = param_1, translog_status == 1)) {
DAT_00d7b318 = lVar1;
}
inline_mysql_mutex_unlock(&DAT_00d7b320);
return;
}
| |
26,360 | std::vector<int, std::allocator<int>> string_split<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char) | monkey531[P]llama/common/common.h | static std::vector<T> string_split(const std::string & str, char delim) {
static_assert(!std::is_same<T, std::string>::value, "Please use the specialized version for std::string");
std::vector<T> values;
std::istringstream str_stream(str);
std::string token;
while (std::getline(str_stream, token, delim)) {
T value;
std::istringstream token_stream(token);
token_stream >> value;
values.push_back(value);
}
return values;
} | O2 | c | std::vector<int, std::allocator<int>> string_split<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x24f10
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %r15
pushq $0x2c
popq %rbp
leaq 0x1a8(%rsp), %r12
pushq $0x8
popq %r13
leaq 0x4(%rsp), %r14
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x250c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x48578
movq %r12, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x24f10
movq %r12, %rdi
movq %r14, %rsi
callq 0x245a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a826
movq %r12, %rdi
callq 0x24440
jmp 0x4852d
leaq 0x8(%rsp), %rdi
callq 0x25258
leaq 0x28(%rsp), %rdi
callq 0x24440
movq %rbx, %rax
addq $0x328, %rsp # imm = 0x328
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x485d1
jmp 0x485a8
movq %rax, %r14
jmp 0x485bd
movq %rax, %r14
leaq 0x1a8(%rsp), %rdi
callq 0x24440
leaq 0x8(%rsp), %rdi
callq 0x25258
leaq 0x28(%rsp), %rdi
callq 0x24440
movq %rbx, %rdi
callq 0x38874
movq %r14, %rdi
callq 0x24fe0
nop
| _ZL12string_splitIiESt6vectorIT_SaIS1_EERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEc:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 328h
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
and qword ptr [rdi+10h], 0
lea rdi, [rsp+358h+var_330]
push 8
pop rdx
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::istringstream::basic_istringstream(std::string const&,std::_Ios_Openmode)
lea rax, [rsp+358h+var_340]
mov [rax-10h], rax
and qword ptr [rax-8], 0
mov byte ptr [rax], 0
lea r15, [rsp+358h+var_350]
push 2Ch ; ','
pop rbp
lea r12, [rsp+358h+var_1B0]
push 8
pop r13
lea r14, [rsp+358h+var_354]
loc_4852D:
lea rdi, [rsp+358h+var_330]
mov rsi, r15
mov edx, ebp
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EES4_; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &,char)
mov rcx, [rax]
mov rcx, [rcx-18h]
test byte ptr [rax+rcx+20h], 5
jnz short loc_48578
mov rdi, r12
mov rsi, r15
mov edx, r13d
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::istringstream::basic_istringstream(std::string const&,std::_Ios_Openmode)
mov rdi, r12
mov rsi, r14
call __ZNSirsERi; std::istream::operator>>(int &)
mov rdi, rbx
mov rsi, r14
call _ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
mov rdi, r12
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED1Ev; std::istringstream::~istringstream()
jmp short loc_4852D
loc_48578:
lea rdi, [rsp+358h+var_350]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+358h+var_330]
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED1Ev; std::istringstream::~istringstream()
mov rax, rbx
add rsp, 328h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
jmp short loc_485D1
jmp short $+2
loc_485A8:
mov r14, rax
jmp short loc_485BD
mov r14, rax
lea rdi, [rsp+arg_1A0]
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED1Ev; std::istringstream::~istringstream()
loc_485BD:
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED1Ev; std::istringstream::~istringstream()
loc_485D1:
mov rdi, rbx
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
mov rdi, r14
call __Unwind_Resume
| long long string_split<int>(long long a1, long long a2)
{
_QWORD *v2; // rax
unsigned int v4; // [rsp+4h] [rbp-354h] BYREF
_QWORD v5[2]; // [rsp+8h] [rbp-350h] BYREF
char v6; // [rsp+18h] [rbp-340h] BYREF
_BYTE v7[384]; // [rsp+28h] [rbp-330h] BYREF
_BYTE v8[432]; // [rsp+1A8h] [rbp-1B0h] BYREF
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
std::istringstream::basic_istringstream(v7, a2, 8LL);
v5[0] = &v6;
v5[1] = 0LL;
v6 = 0;
while ( 1 )
{
v2 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(v7, v5, 44LL);
if ( (*((_BYTE *)v2 + *(_QWORD *)(*v2 - 24LL) + 32) & 5) != 0 )
break;
std::istringstream::basic_istringstream(v8, v5, 8LL);
std::istream::operator>>(v8, &v4);
std::vector<int>::push_back(a1, &v4);
std::istringstream::~istringstream(v8);
}
std::string::~string(v5);
std::istringstream::~istringstream(v7);
return a1;
}
| string_split<int>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x328
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
AND qword ptr [RDI + 0x10],0x0
LAB_001484f6:
LEA RDI,[RSP + 0x28]
PUSH 0x8
POP RDX
CALL 0x00124f10
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
AND qword ptr [RAX + -0x8],0x0
MOV byte ptr [RAX],0x0
LEA R15,[RSP + 0x8]
PUSH 0x2c
POP RBP
LEA R12,[RSP + 0x1a8]
PUSH 0x8
POP R13
LEA R14,[RSP + 0x4]
LAB_0014852d:
LEA RDI,[RSP + 0x28]
MOV RSI,R15
MOV EDX,EBP
CALL 0x001250c0
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
TEST byte ptr [RAX + RCX*0x1 + 0x20],0x5
JNZ 0x00148578
LAB_0014854a:
MOV RDI,R12
MOV RSI,R15
MOV EDX,R13D
CALL 0x00124f10
LAB_00148558:
MOV RDI,R12
MOV RSI,R14
CALL 0x001245a0
MOV RDI,RBX
MOV RSI,R14
CALL 0x0012a826
LAB_0014856e:
MOV RDI,R12
CALL 0x00124440
JMP 0x0014852d
LAB_00148578:
LEA RDI,[RSP + 0x8]
CALL 0x00125258
LEA RDI,[RSP + 0x28]
CALL 0x00124440
MOV RAX,RBX
ADD RSP,0x328
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* std::vector<int, std::allocator<int> > string_split<int>(std::__cxx11::string const&, char) */
string * string_split<int>(string *param_1,char param_2)
{
istream *piVar1;
int7 in_register_00000031;
int local_354;
int1 *local_350;
int8 local_348;
int1 local_340 [16];
istringstream local_330 [384];
istream local_1b0 [384];
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
/* try { // try from 001484f6 to 00148502 has its CatchHandler @ 001485a1 */
std::__cxx11::istringstream::istringstream(local_330,CONCAT71(in_register_00000031,param_2),8);
local_350 = local_340;
local_348 = 0;
local_340[0] = 0;
while( true ) {
/* try { // try from 0014852d to 0014853b has its CatchHandler @ 001485a8 */
piVar1 = std::getline<char,std::char_traits<char>,std::allocator<char>>
((istream *)local_330,(string *)&local_350,',');
if (((byte)piVar1[*(long *)(*(long *)piVar1 + -0x18) + 0x20] & 5) != 0) break;
/* try { // try from 0014854a to 00148557 has its CatchHandler @ 001485a6 */
std::__cxx11::istringstream::istringstream((istringstream *)local_1b0,(string *)&local_350,8);
/* try { // try from 00148558 to 0014856d has its CatchHandler @ 001485ad */
std::istream::operator>>(local_1b0,&local_354);
std::vector<int,std::allocator<int>>::push_back
((vector<int,std::allocator<int>> *)param_1,&local_354);
std::__cxx11::istringstream::~istringstream((istringstream *)local_1b0);
}
std::__cxx11::string::~string((string *)&local_350);
std::__cxx11::istringstream::~istringstream(local_330);
return param_1;
}
| |
26,361 | mysql_stat | eloqsql/libmariadb/libmariadb/mariadb_lib.c | char * STDCALL
mysql_stat(MYSQL *mysql)
{
if (ma_simple_command(mysql, COM_STATISTICS,0,0,0,0))
return mysql->net.last_error;
mysql->net.read_pos[mysql->packet_length]=0; /* End of stat string */
if (!mysql->net.read_pos[0])
{
SET_CLIENT_ERROR(mysql, CR_WRONG_HOST_INFO , SQLSTATE_UNKNOWN, 0);
return mysql->net.last_error;
}
return((char*) mysql->net.read_pos);
} | O3 | c | mysql_stat:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4d0(%rdi), %rax
movl $0x9, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *0x10(%rax)
testl %eax, %eax
je 0x1ba29
addq $0x97, %rbx
movq %rbx, %r14
jmp 0x1ba97
movq 0x20(%rbx), %rax
movq 0x358(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x20(%rbx), %r14
cmpb $0x0, (%r14)
jne 0x1ba97
movl $0x7d9, 0x90(%rbx) # imm = 0x7D9
leaq 0x297(%rbx), %rdi
leaq 0x2cfd6(%rip), %rax # 0x48a30
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r15d, %r15d
movb %r15b, 0x29c(%rbx)
leaq 0x97(%rbx), %r14
leaq 0x2cfc1(%rip), %rax # 0x48a40
movq 0x48(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
movq %r14, %rdi
callq 0x13220
movb %r15b, 0x296(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mysql_stat:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov rax, [rdi+4D0h]
mov esi, 9
xor edx, edx
xor ecx, ecx
xor r8d, r8d
xor r9d, r9d
call qword ptr [rax+10h]
test eax, eax
jz short loc_1BA29
add rbx, 97h
mov r14, rbx
jmp short loc_1BA97
loc_1BA29:
mov rax, [rbx+20h]
mov rcx, [rbx+358h]
mov byte ptr [rax+rcx], 0
mov r14, [rbx+20h]
cmp byte ptr [r14], 0
jnz short loc_1BA97
mov dword ptr [rbx+90h], 7D9h
lea rdi, [rbx+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r15d, r15d
mov [rbx+29Ch], r15b
lea r14, [rbx+97h]
lea rax, client_errors
mov rsi, [rax+48h]
mov edx, 1FFh
mov rdi, r14
call _strncpy
mov [rbx+296h], r15b
loc_1BA97:
mov rax, r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| _BYTE * mysql_stat(long long a1)
{
long long v1; // rax
_BYTE *v2; // r14
if ( (*(unsigned int ( **)(long long, long long, _QWORD, _QWORD, _QWORD, _QWORD, long long))(*(_QWORD *)(a1 + 1232)
+ 16LL))(
a1,
9LL,
0LL,
0LL,
0LL,
0LL,
v1) )
{
return (_BYTE *)(a1 + 151);
}
*(_BYTE *)(*(_QWORD *)(a1 + 32) + *(_QWORD *)(a1 + 856)) = 0;
v2 = *(_BYTE **)(a1 + 32);
if ( !*v2 )
{
*(_DWORD *)(a1 + 144) = 2009;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
v2 = (_BYTE *)(a1 + 151);
strncpy(a1 + 151, client_errors[9], 511LL);
*(_BYTE *)(a1 + 662) = 0;
}
return v2;
}
| mysql_stat:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x4d0]
MOV ESI,0x9
XOR EDX,EDX
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL qword ptr [RAX + 0x10]
TEST EAX,EAX
JZ 0x0011ba29
ADD RBX,0x97
MOV R14,RBX
JMP 0x0011ba97
LAB_0011ba29:
MOV RAX,qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x358]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV R14,qword ptr [RBX + 0x20]
CMP byte ptr [R14],0x0
JNZ 0x0011ba97
MOV dword ptr [RBX + 0x90],0x7d9
LEA RDI,[RBX + 0x297]
LEA RAX,[0x148a30]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R15D,R15D
MOV byte ptr [RBX + 0x29c],R15B
LEA R14,[RBX + 0x97]
LEA RAX,[0x148a40]
MOV RSI,qword ptr [RAX + 0x48]
MOV EDX,0x1ff
MOV RDI,R14
CALL 0x00113220
MOV byte ptr [RBX + 0x296],R15B
LAB_0011ba97:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
char * mysql_stat(long param_1)
{
int iVar1;
char *__dest;
iVar1 = (**(code **)(*(long *)(param_1 + 0x4d0) + 0x10))(param_1,9,0,0,0,0);
if (iVar1 == 0) {
*(int1 *)(*(long *)(param_1 + 0x20) + *(long *)(param_1 + 0x358)) = 0;
__dest = *(char **)(param_1 + 0x20);
if (*__dest == '\0') {
*(int4 *)(param_1 + 0x90) = 0x7d9;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
__dest = (char *)(param_1 + 0x97);
strncpy(__dest,PTR_s_Wrong_host_info_00148a88,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
}
}
else {
__dest = (char *)(param_1 + 0x97);
}
return __dest;
}
| |
26,362 | mi_memmap_file | eloqsql/storage/myisam/mi_packrec.c | my_bool _mi_memmap_file(MI_INFO *info)
{
MYISAM_SHARE *share=info->s;
my_bool eom;
DBUG_ENTER("mi_memmap_file");
if (!info->s->file_map)
{
my_off_t data_file_length= share->state.state.data_file_length;
if (myisam_mmap_size != SIZE_T_MAX)
{
mysql_mutex_lock(&THR_LOCK_myisam_mmap);
eom= data_file_length > myisam_mmap_size - myisam_mmap_used - MEMMAP_EXTRA_MARGIN;
if (!eom)
myisam_mmap_used+= data_file_length + MEMMAP_EXTRA_MARGIN;
mysql_mutex_unlock(&THR_LOCK_myisam_mmap);
}
else
eom= data_file_length > myisam_mmap_size - MEMMAP_EXTRA_MARGIN;
if (eom)
{
DBUG_PRINT("warning", ("File is too large for mmap"));
DBUG_RETURN(0);
}
if (mysql_file_seek(info->dfile, 0L, MY_SEEK_END, MYF(0)) <
share->state.state.data_file_length+MEMMAP_EXTRA_MARGIN)
{
DBUG_PRINT("warning",("File isn't extended for memmap"));
if (myisam_mmap_size != SIZE_T_MAX)
{
mysql_mutex_lock(&THR_LOCK_myisam_mmap);
myisam_mmap_used-= data_file_length + MEMMAP_EXTRA_MARGIN;
mysql_mutex_unlock(&THR_LOCK_myisam_mmap);
}
DBUG_RETURN(0);
}
if (mi_dynmap_file(info,
share->state.state.data_file_length +
MEMMAP_EXTRA_MARGIN))
{
if (myisam_mmap_size != SIZE_T_MAX)
{
mysql_mutex_lock(&THR_LOCK_myisam_mmap);
myisam_mmap_used-= data_file_length + MEMMAP_EXTRA_MARGIN;
mysql_mutex_unlock(&THR_LOCK_myisam_mmap);
}
DBUG_RETURN(0);
}
}
info->opt_flag|= MEMMAP_USED;
info->read_record= share->read_record= _mi_read_mempack_record;
share->read_rnd= _mi_read_rnd_mempack_record;
DBUG_RETURN(1);
} | O3 | c | mi_memmap_file:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq (%rdi), %r13
cmpq $0x0, 0x270(%r13)
je 0x9ce2e
orb $0x20, 0x1c8(%rbx)
leaq 0x1cd(%rip), %rax # 0x9cfd8
movq %rax, 0x298(%r13)
movq %rax, 0x140(%rbx)
leaq 0x259(%rip), %rax # 0x9d079
movq %rax, 0x2b8(%r13)
movb $0x1, %al
jmp 0x9cf78
movq 0x40(%r13), %r12
leaq 0x310e8f(%rip), %r14 # 0x3adcc8
cmpq $-0x1, (%r14)
je 0x9cea3
leaq 0xb942f2(%rip), %r15 # 0xc31138
cmpq $0x0, 0x40(%r15)
jne 0x9cf87
leaq 0xb942e0(%rip), %rdi # 0xc31138
callq 0x2a230
movq (%r14), %r14
leaq 0xb8b091(%rip), %rax # 0xc27ef8
movq (%rax), %rcx
subq %rcx, %r14
addq $-0x7, %r14
cmpq %r14, %r12
ja 0x9ce80
addq %r12, %rcx
addq $0x7, %rcx
movq %rcx, (%rax)
movq 0x40(%r15), %rdi
testq %rdi, %rdi
jne 0x9cf91
leaq 0xb942a4(%rip), %rdi # 0xc31138
callq 0x2a1f0
cmpq %r14, %r12
jbe 0x9cead
jmp 0x9cf76
cmpq $-0x8, %r12
ja 0x9cf76
movl 0x1c0(%rbx), %r14d
leaq 0x311b5d(%rip), %r15 # 0x3aea18
movq (%r15), %rax
leaq -0x78(%rbp), %rdi
movl %r14d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x9cfa6
movl %r14d, %edi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0xc056c
movq 0x40(%r13), %rsi
addq $0x7, %rsi
cmpq %rsi, %rax
leaq 0x310dcc(%rip), %r14 # 0x3adcc8
jae 0x9cf19
cmpq $-0x1, (%r14)
je 0x9cf76
leaq 0xb9422d(%rip), %rbx # 0xc31138
cmpq $0x0, 0x40(%rbx)
je 0x9cf41
callq 0x30164
jmp 0x9cf4d
movq %rbx, %rdi
callq 0x918c8
testb %al, %al
je 0x9cdfd
cmpq $-0x1, (%r14)
je 0x9cf76
leaq 0xb94202(%rip), %rbx # 0xc31138
cmpq $0x0, 0x40(%rbx)
jne 0x9cfce
leaq 0xb941f0(%rip), %rdi # 0xc31138
callq 0x2a230
leaq 0xb8afa4(%rip), %rax # 0xc27ef8
movq (%rax), %rcx
subq %r12, %rcx
addq $-0x7, %rcx
movq %rcx, (%rax)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
jne 0x9cfc3
leaq 0xb941c7(%rip), %rdi # 0xc31138
callq 0x2a1f0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x300cc
jmp 0x9ce5d
leaq 0x311a80(%rip), %rax # 0x3aea18
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x9ce8d
leaq -0x30(%rbp), %rcx
movq %rax, %rdi
movl %r14d, %esi
movq %rcx, %r14
movq %rcx, %rdx
callq 0x300e9
movq (%r14), %rax
jmp 0x9ceea
movq (%r15), %rax
callq *0x160(%rax)
jmp 0x9cf6a
callq 0x30146
jmp 0x9cf4d
| _mi_memmap_file:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
mov r13, [rdi]
cmp qword ptr [r13+270h], 0
jz short loc_9CE2E
loc_9CDFD:
or byte ptr [rbx+1C8h], 20h
lea rax, _mi_read_mempack_record
mov [r13+298h], rax
mov [rbx+140h], rax
lea rax, _mi_read_rnd_mempack_record
mov [r13+2B8h], rax
mov al, 1
jmp loc_9CF78
loc_9CE2E:
mov r12, [r13+40h]
lea r14, myisam_mmap_size
cmp qword ptr [r14], 0FFFFFFFFFFFFFFFFh
jz short loc_9CEA3
lea r15, THR_LOCK_myisam_mmap
cmp qword ptr [r15+40h], 0
jnz loc_9CF87
lea rdi, THR_LOCK_myisam_mmap
call _pthread_mutex_lock
loc_9CE5D:
mov r14, [r14]
lea rax, myisam_mmap_used
mov rcx, [rax]
sub r14, rcx
add r14, 0FFFFFFFFFFFFFFF9h
cmp r12, r14
ja short loc_9CE80
add rcx, r12
add rcx, 7
mov [rax], rcx
loc_9CE80:
mov rdi, [r15+40h]
test rdi, rdi
jnz loc_9CF91
loc_9CE8D:
lea rdi, THR_LOCK_myisam_mmap
call _pthread_mutex_unlock
cmp r12, r14
jbe short loc_9CEAD
jmp loc_9CF76
loc_9CEA3:
cmp r12, 0FFFFFFFFFFFFFFF8h
ja loc_9CF76
loc_9CEAD:
mov r14d, [rbx+1C0h]
lea r15, PSI_server
mov rax, [r15]
lea rdi, [rbp+var_78]
mov esi, r14d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_9CFA6
mov edi, r14d
xor esi, esi
mov edx, 2
xor ecx, ecx
call my_seek
loc_9CEEA:
mov rsi, [r13+40h]
add rsi, 7
cmp rax, rsi
lea r14, myisam_mmap_size
jnb short loc_9CF19
cmp qword ptr [r14], 0FFFFFFFFFFFFFFFFh
jz short loc_9CF76
lea rbx, THR_LOCK_myisam_mmap
cmp qword ptr [rbx+40h], 0
jz short loc_9CF41
call _mi_memmap_file_cold_4
jmp short loc_9CF4D
loc_9CF19:
mov rdi, rbx
call mi_dynmap_file
test al, al
jz loc_9CDFD
cmp qword ptr [r14], 0FFFFFFFFFFFFFFFFh
jz short loc_9CF76
lea rbx, THR_LOCK_myisam_mmap
cmp qword ptr [rbx+40h], 0
jnz loc_9CFCE
loc_9CF41:
lea rdi, THR_LOCK_myisam_mmap
call _pthread_mutex_lock
loc_9CF4D:
lea rax, myisam_mmap_used
mov rcx, [rax]
sub rcx, r12
add rcx, 0FFFFFFFFFFFFFFF9h
mov [rax], rcx
mov rdi, [rbx+40h]
test rdi, rdi
jnz short loc_9CFC3
loc_9CF6A:
lea rdi, THR_LOCK_myisam_mmap
call _pthread_mutex_unlock
loc_9CF76:
xor eax, eax
loc_9CF78:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9CF87:
call _mi_memmap_file_cold_1
jmp loc_9CE5D
loc_9CF91:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_9CE8D
loc_9CFA6:
lea rcx, [rbp+var_30]
mov rdi, rax
mov esi, r14d
mov r14, rcx
mov rdx, rcx
call _mi_memmap_file_cold_2
mov rax, [r14]
jmp loc_9CEEA
loc_9CFC3:
mov rax, [r15]
call qword ptr [rax+160h]
jmp short loc_9CF6A
loc_9CFCE:
call _mi_memmap_file_cold_3
jmp loc_9CF4D
| char mi_memmap_file(unsigned int *a1)
{
_QWORD *v1; // r13
unsigned long long v3; // r12
unsigned long long v4; // r14
unsigned int v5; // r14d
long long v6; // rax
unsigned long long v7; // rax
unsigned long long v8; // rsi
_BYTE v9[72]; // [rsp+8h] [rbp-78h] BYREF
unsigned long long v10[6]; // [rsp+50h] [rbp-30h] BYREF
v1 = *(_QWORD **)a1;
if ( *(_QWORD *)(*(_QWORD *)a1 + 624LL) )
goto LABEL_2;
v3 = v1[8];
if ( myisam_mmap_size == -1LL )
{
if ( v3 > 0xFFFFFFFFFFFFFFF8LL )
return 0;
}
else
{
if ( THR_LOCK_myisam_mmap[8] )
mi_memmap_file_cold_1();
else
pthread_mutex_lock(THR_LOCK_myisam_mmap);
v4 = myisam_mmap_size - myisam_mmap_used - 7LL;
if ( v3 <= v4 )
myisam_mmap_used += v3 + 7;
if ( THR_LOCK_myisam_mmap[8] )
PSI_server[44]();
pthread_mutex_unlock(THR_LOCK_myisam_mmap);
if ( v3 > v4 )
return 0;
}
v5 = a1[112];
v6 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v9, v5, 8LL);
if ( v6 )
{
mi_memmap_file_cold_2(v6, v5, v10);
v7 = v10[0];
}
else
{
v7 = my_seek(v5, 0LL, 2LL, 0LL);
}
v8 = v1[8] + 7LL;
if ( v7 >= v8 )
{
if ( !(unsigned __int8)mi_dynmap_file(a1, v8) )
{
LABEL_2:
*((_BYTE *)a1 + 456) |= 0x20u;
v1[83] = mi_read_mempack_record;
*((_QWORD *)a1 + 40) = mi_read_mempack_record;
v1[87] = mi_read_rnd_mempack_record;
return 1;
}
if ( myisam_mmap_size != -1LL )
{
if ( THR_LOCK_myisam_mmap[8] )
{
mi_memmap_file_cold_3();
goto LABEL_23;
}
goto LABEL_22;
}
}
else if ( myisam_mmap_size != -1LL )
{
if ( THR_LOCK_myisam_mmap[8] )
{
mi_memmap_file_cold_4();
LABEL_23:
myisam_mmap_used = myisam_mmap_used - v3 - 7;
if ( THR_LOCK_myisam_mmap[8] )
PSI_server[44]();
pthread_mutex_unlock(THR_LOCK_myisam_mmap);
return 0;
}
LABEL_22:
pthread_mutex_lock(THR_LOCK_myisam_mmap);
goto LABEL_23;
}
return 0;
}
| _mi_memmap_file:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV R13,qword ptr [RDI]
CMP qword ptr [R13 + 0x270],0x0
JZ 0x0019ce2e
LAB_0019cdfd:
OR byte ptr [RBX + 0x1c8],0x20
LEA RAX,[0x19cfd8]
MOV qword ptr [R13 + 0x298],RAX
MOV qword ptr [RBX + 0x140],RAX
LEA RAX,[0x19d079]
MOV qword ptr [R13 + 0x2b8],RAX
MOV AL,0x1
JMP 0x0019cf78
LAB_0019ce2e:
MOV R12,qword ptr [R13 + 0x40]
LEA R14,[0x4adcc8]
CMP qword ptr [R14],-0x1
JZ 0x0019cea3
LEA R15,[0xd31138]
CMP qword ptr [R15 + 0x40],0x0
JNZ 0x0019cf87
LEA RDI,[0xd31138]
CALL 0x0012a230
LAB_0019ce5d:
MOV R14,qword ptr [R14]
LEA RAX,[0xd27ef8]
MOV RCX,qword ptr [RAX]
SUB R14,RCX
ADD R14,-0x7
CMP R12,R14
JA 0x0019ce80
ADD RCX,R12
ADD RCX,0x7
MOV qword ptr [RAX],RCX
LAB_0019ce80:
MOV RDI,qword ptr [R15 + 0x40]
TEST RDI,RDI
JNZ 0x0019cf91
LAB_0019ce8d:
LEA RDI,[0xd31138]
CALL 0x0012a1f0
CMP R12,R14
JBE 0x0019cead
JMP 0x0019cf76
LAB_0019cea3:
CMP R12,-0x8
JA 0x0019cf76
LAB_0019cead:
MOV R14D,dword ptr [RBX + 0x1c0]
LEA R15,[0x4aea18]
MOV RAX,qword ptr [R15]
LEA RDI,[RBP + -0x78]
MOV ESI,R14D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0019cfa6
MOV EDI,R14D
XOR ESI,ESI
MOV EDX,0x2
XOR ECX,ECX
CALL 0x001c056c
LAB_0019ceea:
MOV RSI,qword ptr [R13 + 0x40]
ADD RSI,0x7
CMP RAX,RSI
LEA R14,[0x4adcc8]
JNC 0x0019cf19
CMP qword ptr [R14],-0x1
JZ 0x0019cf76
LEA RBX,[0xd31138]
CMP qword ptr [RBX + 0x40],0x0
JZ 0x0019cf41
CALL 0x00130164
JMP 0x0019cf4d
LAB_0019cf19:
MOV RDI,RBX
CALL 0x001918c8
TEST AL,AL
JZ 0x0019cdfd
CMP qword ptr [R14],-0x1
JZ 0x0019cf76
LEA RBX,[0xd31138]
CMP qword ptr [RBX + 0x40],0x0
JNZ 0x0019cfce
LAB_0019cf41:
LEA RDI,[0xd31138]
CALL 0x0012a230
LAB_0019cf4d:
LEA RAX,[0xd27ef8]
MOV RCX,qword ptr [RAX]
SUB RCX,R12
ADD RCX,-0x7
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JNZ 0x0019cfc3
LAB_0019cf6a:
LEA RDI,[0xd31138]
CALL 0x0012a1f0
LAB_0019cf76:
XOR EAX,EAX
LAB_0019cf78:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019cf87:
CALL 0x001300cc
JMP 0x0019ce5d
LAB_0019cf91:
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0019ce8d
LAB_0019cfa6:
LEA RCX,[RBP + -0x30]
MOV RDI,RAX
MOV ESI,R14D
MOV R14,RCX
MOV RDX,RCX
CALL 0x001300e9
MOV RAX,qword ptr [R14]
JMP 0x0019ceea
LAB_0019cfc3:
MOV RAX,qword ptr [R15]
CALL qword ptr [RAX + 0x160]
JMP 0x0019cf6a
LAB_0019cfce:
CALL 0x00130146
JMP 0x0019cf4d
|
int8 _mi_memmap_file(long *param_1)
{
int4 uVar1;
long lVar2;
ulong uVar3;
char cVar4;
long lVar5;
ulong uVar6;
int1 local_80 [72];
ulong local_38;
lVar2 = *param_1;
if (*(long *)(lVar2 + 0x270) != 0) {
LAB_0019cdfd:
*(byte *)(param_1 + 0x39) = *(byte *)(param_1 + 0x39) | 0x20;
*(code **)(lVar2 + 0x298) = _mi_read_mempack_record;
param_1[0x28] = (long)_mi_read_mempack_record;
*(code **)(lVar2 + 0x2b8) = _mi_read_rnd_mempack_record;
return 0x19d001;
}
uVar3 = *(ulong *)(lVar2 + 0x40);
if (myisam_mmap_size == -1) {
if (0xfffffffffffffff8 < uVar3) {
return 0;
}
}
else {
if (THR_LOCK_myisam_mmap._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_myisam_mmap);
}
else {
_mi_memmap_file_cold_1();
}
uVar6 = (myisam_mmap_size - myisam_mmap_used) - 7;
if (uVar3 <= uVar6) {
myisam_mmap_used = myisam_mmap_used + uVar3 + 7;
}
if (THR_LOCK_myisam_mmap._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_myisam_mmap);
if (uVar6 < uVar3) {
return 0;
}
}
uVar1 = (int4)param_1[0x38];
lVar5 = (**(code **)(PSI_server + 0x158))(local_80,uVar1,8);
if (lVar5 == 0) {
local_38 = my_seek(uVar1,0,2,0);
}
else {
_mi_memmap_file_cold_2(lVar5,uVar1,&local_38);
}
if (local_38 < *(long *)(lVar2 + 0x40) + 7U) {
if (myisam_mmap_size == -1) {
return 0;
}
if (THR_LOCK_myisam_mmap._64_8_ != 0) {
_mi_memmap_file_cold_4();
goto LAB_0019cf4d;
}
}
else {
cVar4 = mi_dynmap_file(param_1);
if (cVar4 == '\0') goto LAB_0019cdfd;
if (myisam_mmap_size == -1) {
return 0;
}
if (THR_LOCK_myisam_mmap._64_8_ != 0) {
_mi_memmap_file_cold_3();
goto LAB_0019cf4d;
}
}
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_myisam_mmap);
LAB_0019cf4d:
myisam_mmap_used = (myisam_mmap_used - uVar3) + -7;
if (THR_LOCK_myisam_mmap._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_myisam_mmap);
return 0;
}
| |
26,363 | LefDefParser::lefwMacroPinVLO(double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwMacroPinVLO(double voltage)
{
lefwObsoleteNum = LEFW_MACRO_VLO;
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (!lefwIsMacroPin)
return LEFW_BAD_ORDER;
if (versionNum >= 5.4)
return LEFW_OBSOLETE;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " VLO %.11g ;\n", voltage);
else
fprintf(lefwFile, " VLO %.11g ;\n", voltage);
lefwLines++;
lefwState = LEFW_MACRO;
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwMacroPinVLO(double):
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movl $0x39, 0x11254(%rip) # 0x32d48
leaq 0x11305(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0x21b0e
movl $0x1, 0x14(%rsp)
jmp 0x21bd1
leaq 0x1153f(%rip), %rax # 0x33054
cmpl $0x0, (%rax)
jne 0x21b27
movl $0x2, 0x14(%rsp)
jmp 0x21bd1
leaq 0x11572(%rip), %rax # 0x330a0
cmpl $0x0, (%rax)
jne 0x21b40
movl $0x2, 0x14(%rsp)
jmp 0x21bd1
movsd 0x111f8(%rip), %xmm0 # 0x32d40
movsd 0x76b0(%rip), %xmm1 # 0x29200
ucomisd %xmm1, %xmm0
jb 0x21b60
movl $0x7, 0x14(%rsp)
jmp 0x21bd1
cmpl $0x0, 0x11585(%rip) # 0x330ec
je 0x21b89
leaq 0x11290(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x9d16(%rip), %rsi # 0x2b896
movb $0x1, %al
callq 0x289b0
jmp 0x21ba7
leaq 0x11270(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x9cf6(%rip), %rsi # 0x2b896
movb $0x1, %al
callq 0x1100
leaq 0x1149e(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x11492(%rip), %rax # 0x3304c
movl %ecx, (%rax)
leaq 0x1148d(%rip), %rax # 0x33050
movl $0x21, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| _ZN12LefDefParser15lefwMacroPinVLOEd:
sub rsp, 18h
movsd [rsp+18h+var_10], xmm0
mov cs:_ZN12LefDefParserL15lefwObsoleteNumE, 39h ; '9'; LefDefParser::lefwObsoleteNum
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_21B0E
mov [rsp+18h+var_4], 1
jmp loc_21BD1
loc_21B0E:
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
jnz short loc_21B27
mov [rsp+18h+var_4], 2
jmp loc_21BD1
loc_21B27:
lea rax, _ZN12LefDefParser14lefwIsMacroPinE; LefDefParser::lefwIsMacroPin
cmp dword ptr [rax], 0
jnz short loc_21B40
mov [rsp+18h+var_4], 2
jmp loc_21BD1
loc_21B40:
movsd xmm0, cs:_ZN12LefDefParserL10versionNumE; LefDefParser::versionNum
movsd xmm1, cs:dbl_29200
ucomisd xmm0, xmm1
jb short loc_21B60
mov [rsp+18h+var_4], 7
jmp short loc_21BD1
loc_21B60:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_21B89
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
lea rsi, aVlo11g; " VLO %.11g ;\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_21BA7
loc_21B89:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
lea rsi, aVlo11g; " VLO %.11g ;\n"
mov al, 1
call _fprintf
loc_21BA7:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 21h ; '!'
mov [rsp+18h+var_4], 0
loc_21BD1:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long LefDefParser::lefwMacroPinVLO(
LefDefParser *this,
double a2,
long long a3,
int a4,
int a5,
int a6,
int a7)
{
LefDefParser::lefwObsoleteNum = 57;
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwIsMacroPin )
{
if ( *(double *)&LefDefParser::versionNum < 5.4 )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" VLO %.11g ;\n", a4, a5, a6, a7);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " VLO %.11g ;\n", a2);
++LefDefParser::lefwLines;
LefDefParser::lefwState = 33;
return 0;
}
else
{
return 7;
}
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwMacroPinVLO:
SUB RSP,0x18
MOVSD qword ptr [RSP + 0x8],XMM0
MOV dword ptr [0x00132d48],0x39
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x00121b0e
MOV dword ptr [RSP + 0x14],0x1
JMP 0x00121bd1
LAB_00121b0e:
LEA RAX,[0x133054]
CMP dword ptr [RAX],0x0
JNZ 0x00121b27
MOV dword ptr [RSP + 0x14],0x2
JMP 0x00121bd1
LAB_00121b27:
LEA RAX,[0x1330a0]
CMP dword ptr [RAX],0x0
JNZ 0x00121b40
MOV dword ptr [RSP + 0x14],0x2
JMP 0x00121bd1
LAB_00121b40:
MOVSD XMM0,qword ptr [0x00132d40]
MOVSD XMM1,qword ptr [0x00129200]
UCOMISD XMM0,XMM1
JC 0x00121b60
MOV dword ptr [RSP + 0x14],0x7
JMP 0x00121bd1
LAB_00121b60:
CMP dword ptr [0x001330ec],0x0
JZ 0x00121b89
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x12b896]
MOV AL,0x1
CALL 0x001289b0
JMP 0x00121ba7
LAB_00121b89:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x12b896]
MOV AL,0x1
CALL 0x00101100
LAB_00121ba7:
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
LEA RAX,[0x133050]
MOV dword ptr [RAX],0x21
MOV dword ptr [RSP + 0x14],0x0
LAB_00121bd1:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwMacroPinVLO(double) */
int4 LefDefParser::lefwMacroPinVLO(double param_1)
{
int4 local_4;
lefwObsoleteNum = 0x39;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if (lefwDidInit == 0) {
local_4 = 2;
}
else if (lefwIsMacroPin == 0) {
local_4 = 2;
}
else if (versionNum < DAT_00129200) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," VLO %.11g ;\n",param_1);
}
else {
encPrint(lefwFile," VLO %.11g ;\n",param_1);
}
lefwLines = lefwLines + 1;
lefwState = 0x21;
local_4 = 0;
}
else {
local_4 = 7;
}
return local_4;
}
| |
26,364 | std::shared_ptr<item> version_item::parse<__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>>(__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, unsigned int) | msxemulator/build_O3/_deps/picotool-src/bintool/metadata.h | static std::shared_ptr<item> parse(I& it, I end, uint32_t header) {
// todo validate
uint32_t major_minor = *it++;
uint16_t major = major_minor >> 16;
uint16_t minor = major_minor & 0xffff;
unsigned int otp_row_count = header >> 24;
uint16_t rollback = 0;
std::vector<uint16_t> otp_rows;
if (otp_row_count) {
unsigned int pair = *it++;
// todo endian
rollback = (uint16_t) pair;
for(unsigned int i=0;i<otp_row_count;i++) {
if (i&1) pair = *it++;
otp_rows.push_back((uint16_t)(pair >> ((1^(i&1))*16)));
}
}
return std::make_shared<version_item>(major, minor, rollback, otp_rows);
} | O3 | c | std::shared_ptr<item> version_item::parse<__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>>(__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, unsigned int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdi, 0x40(%rsp)
movq (%rsi), %rax
leaq 0x4(%rax), %rcx
movq %rcx, (%rsi)
movl (%rax), %ecx
movw %cx, 0xa(%rsp)
shrl $0x10, %ecx
movw %cx, 0xc(%rsp)
movw $0x0, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x1000000, %ebp # imm = 0x1000000
jb 0x773cc
movq %rsi, %r14
shrl $0x18, %ebp
leaq 0x8(%rax), %rcx
movq %rcx, (%rsi)
movl 0x4(%rax), %ebx
movw %bx, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
leaq 0x30(%rsp), %r12
movl %r13d, %ecx
andl $0x1, %ecx
je 0x77390
movq (%r14), %rax
leaq 0x4(%rax), %rdx
movq %rdx, (%r14)
movl (%rax), %ebx
shll $0x4, %ecx
xorb $0x10, %cl
movl %ebx, %eax
shrl %cl, %eax
movw %ax, 0x30(%rsp)
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x773b9
movw %ax, (%rsi)
addq $0x2, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x773c4
movq %r15, %rdi
movq %r12, %rdx
callq 0x647b0
incl %r13d
cmpl %r13d, %ebp
jne 0x7737c
leaq 0x38(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rsi
leaq 0xf(%rsp), %rdx
leaq 0xc(%rsp), %rcx
leaq 0xa(%rsp), %r8
leaq 0x8(%rsp), %r9
callq 0x64492
movaps 0x30(%rsp), %xmm0
movq 0x40(%rsp), %rbx
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x77424
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0xf470
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x77438
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x77452
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0xf470
movq %rbx, %rdi
callq 0xf7d0
| _ZN12version_item5parseIN9__gnu_cxx17__normal_iteratorIPjSt6vectorIjSaIjEEEEEESt10shared_ptrI4itemERT_SB_j:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov ebp, ecx
mov [rsp+78h+var_38], rdi
mov rax, [rsi]
lea rcx, [rax+4]
mov [rsi], rcx
mov ecx, [rax]
mov [rsp+78h+var_6E], cx
shr ecx, 10h
mov [rsp+78h+var_6C], cx
mov [rsp+78h+var_70], 0
xorps xmm0, xmm0
movaps xmmword ptr [rsp+78h+var_68], xmm0
mov [rsp+78h+var_58], 0
cmp ebp, 1000000h
jb short loc_773CC
mov r14, rsi
shr ebp, 18h
lea rcx, [rax+8]
mov [rsi], rcx
mov ebx, [rax+4]
mov [rsp+78h+var_70], bx
xor r13d, r13d
lea r15, [rsp+78h+var_68]
lea r12, [rsp+78h+var_48]
loc_7737C:
mov ecx, r13d
and ecx, 1
jz short loc_77390
mov rax, [r14]
lea rdx, [rax+4]
mov [r14], rdx
mov ebx, [rax]
loc_77390:
shl ecx, 4
xor cl, 10h
mov eax, ebx
shr eax, cl
mov word ptr [rsp+78h+var_48], ax
mov rsi, [rsp+78h+var_68+8]
cmp rsi, [rsp+78h+var_58]
jz short loc_773B9
mov [rsi], ax
add rsi, 2
mov [rsp+78h+var_68+8], rsi
jmp short loc_773C4
loc_773B9:
mov rdi, r15
mov rdx, r12
call _ZNSt6vectorItSaItEE17_M_realloc_insertIJtEEEvN9__gnu_cxx17__normal_iteratorIPtS1_EEDpOT_; std::vector<ushort>::_M_realloc_insert<ushort>(__gnu_cxx::__normal_iterator<ushort *,std::vector<ushort>>,ushort &&)
loc_773C4:
inc r13d
cmp ebp, r13d
jnz short loc_7737C
loc_773CC:
lea rdi, [rsp+78h+var_48+8]
mov qword ptr [rdi-8], 0
lea rax, [rsp+78h+var_68]
mov [rsp+78h+var_78], rax
lea rsi, [rsp+78h+var_48]
lea rdx, [rsp+78h+var_69]
lea rcx, [rsp+78h+var_6C]
lea r8, [rsp+78h+var_6E]
lea r9, [rsp+78h+var_70]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEC2I12version_itemSaIS4_EJRtS6_S6_RSt6vectorItSaItEEEEERPT_St20_Sp_alloc_shared_tagIT0_EDpOT1_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<version_item,std::allocator<version_item>,ushort &,ushort &,ushort &,std::vector<ushort> &>(version_item *&,std::_Sp_alloc_shared_tag<std::allocator<version_item>>,ushort &,ushort &,ushort &,std::vector<ushort> &)
movaps xmm0, [rsp+78h+var_48]
mov rbx, [rsp+78h+var_38]
movups xmmword ptr [rbx], xmm0
mov rdi, [rsp+78h+var_68]; void *
test rdi, rdi
jz short loc_77424
mov rsi, [rsp+78h+var_58]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_77424:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_77438:
mov rbx, rax
mov rdi, [rsp+arg_8]; void *
test rdi, rdi
jz short loc_77452
mov rsi, [rsp+arg_18]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_77452:
mov rdi, rbx
call __Unwind_Resume
| _OWORD * version_item::parse<__gnu_cxx::__normal_iterator<unsigned int *,std::vector<unsigned int>>>(
_OWORD *a1,
unsigned int **a2,
int a3,
unsigned int a4)
{
unsigned int *v5; // rax
unsigned int v6; // ecx
unsigned int v8; // ebp
unsigned int v9; // ebx
int v10; // r13d
unsigned int *v11; // rax
unsigned int v12; // eax
char *v13; // rsi
_OWORD *v14; // rbx
__int16 v16; // [rsp+8h] [rbp-70h] BYREF
__int16 v17; // [rsp+Ah] [rbp-6Eh] BYREF
__int16 v18; // [rsp+Ch] [rbp-6Ch] BYREF
char v19; // [rsp+Fh] [rbp-69h] BYREF
void *v20[2]; // [rsp+10h] [rbp-68h] BYREF
void *v21; // [rsp+20h] [rbp-58h]
__int128 v22; // [rsp+30h] [rbp-48h] BYREF
_OWORD *v23; // [rsp+40h] [rbp-38h]
v23 = a1;
v5 = (*a2)++;
v6 = *v5;
v17 = *v5;
v18 = HIWORD(v6);
v16 = 0;
*(_OWORD *)v20 = 0LL;
v21 = 0LL;
if ( a4 >= 0x1000000 )
{
v8 = HIBYTE(a4);
*a2 = v5 + 2;
v9 = v5[1];
v16 = v9;
v10 = 0;
do
{
if ( (v10 & 1) != 0 )
{
v11 = (*a2)++;
v9 = *v11;
}
v12 = v9 >> ((16 * (v10 & 1)) ^ 0x10);
LOWORD(v22) = v12;
v13 = (char *)v20[1];
if ( v20[1] == v21 )
{
std::vector<unsigned short>::_M_realloc_insert<unsigned short>((long long *)v20, (long long)v20[1], &v22);
}
else
{
*(_WORD *)v20[1] = v12;
v20[1] = v13 + 2;
}
++v10;
}
while ( v8 != v10 );
}
*(_QWORD *)&v22 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<version_item,std::allocator<version_item>,unsigned short &,unsigned short &,unsigned short &,std::vector<unsigned short> &>(
(_QWORD *)&v22 + 1,
&v22,
(long long)&v19,
&v18,
&v17,
&v16,
(long long *)v20);
v14 = v23;
*v23 = v22;
if ( v20[0] )
operator delete(v20[0], (unsigned long long)v21 - (unsigned long long)v20[0]);
return v14;
}
| parse<__gnu_cxx::__normal_iterator<unsigned_int*,std::vector<unsigned_int,std::allocator<unsigned_int>>>>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBP,ECX
MOV qword ptr [RSP + 0x40],RDI
MOV RAX,qword ptr [RSI]
LEA RCX,[RAX + 0x4]
MOV qword ptr [RSI],RCX
MOV ECX,dword ptr [RAX]
MOV word ptr [RSP + 0xa],CX
SHR ECX,0x10
MOV word ptr [RSP + 0xc],CX
MOV word ptr [RSP + 0x8],0x0
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
CMP EBP,0x1000000
JC 0x001773cc
MOV R14,RSI
SHR EBP,0x18
LEA RCX,[RAX + 0x8]
MOV qword ptr [RSI],RCX
MOV EBX,dword ptr [RAX + 0x4]
MOV word ptr [RSP + 0x8],BX
XOR R13D,R13D
LEA R15,[RSP + 0x10]
LEA R12,[RSP + 0x30]
LAB_0017737c:
MOV ECX,R13D
AND ECX,0x1
JZ 0x00177390
MOV RAX,qword ptr [R14]
LEA RDX,[RAX + 0x4]
MOV qword ptr [R14],RDX
MOV EBX,dword ptr [RAX]
LAB_00177390:
SHL ECX,0x4
XOR CL,0x10
MOV EAX,EBX
SHR EAX,CL
MOV word ptr [RSP + 0x30],AX
MOV RSI,qword ptr [RSP + 0x18]
CMP RSI,qword ptr [RSP + 0x20]
JZ 0x001773b9
MOV word ptr [RSI],AX
ADD RSI,0x2
MOV qword ptr [RSP + 0x18],RSI
JMP 0x001773c4
LAB_001773b9:
MOV RDI,R15
MOV RDX,R12
CALL 0x001647b0
LAB_001773c4:
INC R13D
CMP EBP,R13D
JNZ 0x0017737c
LAB_001773cc:
LEA RDI,[RSP + 0x38]
MOV qword ptr [RDI + -0x8],0x0
LAB_001773d9:
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
LEA RSI,[RSP + 0x30]
LEA RDX,[RSP + 0xf]
LEA RCX,[RSP + 0xc]
LEA R8,[RSP + 0xa]
LEA R9,[RSP + 0x8]
CALL 0x00164492
LAB_00177400:
MOVAPS XMM0,xmmword ptr [RSP + 0x30]
MOV RBX,qword ptr [RSP + 0x40]
MOVUPS xmmword ptr [RBX],XMM0
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x00177424
MOV RSI,qword ptr [RSP + 0x20]
SUB RSI,RDI
CALL 0x0010f470
LAB_00177424:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* std::shared_ptr<item> version_item::parse<__gnu_cxx::__normal_iterator<unsigned int*,
std::vector<unsigned int, std::allocator<unsigned int> > >
>(__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned
int> > >&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int,
std::allocator<unsigned int> > >, unsigned int) */
version_item * __thiscall
version_item::
parse<__gnu_cxx::__normal_iterator<unsigned_int*,std::vector<unsigned_int,std::allocator<unsigned_int>>>>
(version_item *this,long *param_1,int8 param_3,uint param_4)
{
int4 *puVar1;
uint *puVar2;
version_item *pvVar3;
int2 uVar4;
uint uVar5;
uint uVar6;
int2 local_70;
int2 local_6e;
int2 local_6c;
int1 local_69;
void *local_68;
int2 *puStack_60;
int2 *local_58;
int8 local_48;
int8 uStack_40;
version_item *local_38;
puVar1 = (int4 *)*param_1;
*param_1 = (long)(puVar1 + 1);
local_6e = (int2)*puVar1;
local_6c = (int2)((uint)*puVar1 >> 0x10);
local_70 = 0;
local_68 = (void *)0x0;
puStack_60 = (int2 *)0x0;
local_58 = (int2 *)0x0;
local_38 = this;
if (0xffffff < param_4) {
*param_1 = (long)(puVar1 + 2);
uVar5 = puVar1[1];
local_70 = (int2)uVar5;
uVar6 = 0;
do {
if ((uVar6 & 1) != 0) {
puVar2 = (uint *)*param_1;
*param_1 = (long)(puVar2 + 1);
uVar5 = *puVar2;
}
uVar4 = (int2)(uVar5 >> ((byte)((uVar6 & 1) << 4) ^ 0x10));
local_48 = CONCAT62(local_48._2_6_,uVar4);
if (puStack_60 == local_58) {
/* try { // try from 001773b9 to 001773c3 has its CatchHandler @ 00177438 */
std::vector<unsigned_short,std::allocator<unsigned_short>>::
_M_realloc_insert<unsigned_short>
((vector<unsigned_short,std::allocator<unsigned_short>> *)&local_68,puStack_60,
&local_48);
}
else {
*puStack_60 = uVar4;
puStack_60 = puStack_60 + 1;
}
uVar6 = uVar6 + 1;
} while (param_4 >> 0x18 != uVar6);
}
local_48 = 0;
/* try { // try from 001773d9 to 001773ff has its CatchHandler @ 00177436 */
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::
__shared_count<version_item,std::allocator<version_item>,unsigned_short&,unsigned_short&,unsigned_short&,std::vector<unsigned_short,std::allocator<unsigned_short>>&>
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_40,&local_48,&local_69,&local_6c,
&local_6e,&local_70,&local_68);
pvVar3 = local_38;
*(int8 *)local_38 = local_48;
*(int8 *)(local_38 + 8) = uStack_40;
if (local_68 != (void *)0x0) {
operator_delete(local_68,(long)local_58 - (long)local_68);
}
return pvVar3;
}
| |
26,365 | normalize_dirname | eloqsql/mysys/mf_pack.c | size_t normalize_dirname(char *to, const char *from)
{
size_t length;
char buff[FN_REFLEN + 1];
DBUG_ENTER("normalize_dirname");
/*
Despite the name, this actually converts the name to the system's
format (TODO: name this properly).
*/
(void) intern_filename(buff, from);
length= strlen(buff); /* Fix that '/' is last */
if (length &&
#ifdef FN_DEVCHAR
buff[length - 1] != FN_DEVCHAR &&
#endif
buff[length - 1] != FN_LIBCHAR && buff[length - 1] != '/')
{
/* we need reserve 2 bytes for the trailing slash and the zero */
if (length >= sizeof (buff) - 1)
length= sizeof (buff) - 2;
buff[length]= FN_LIBCHAR;
buff[length + 1]= '\0';
}
length=cleanup_dirname(to, buff);
DBUG_RETURN(length);
} | O0 | c | normalize_dirname:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
callq 0xe8ca0
leaq -0x210(%rbp), %rdi
callq 0x2a350
movq %rax, -0x228(%rbp)
cmpq $0x0, -0x228(%rbp)
je 0xe931c
movq -0x228(%rbp), %rax
subq $0x1, %rax
movsbl -0x210(%rbp,%rax), %eax
cmpl $0x2f, %eax
je 0xe931c
movq -0x228(%rbp), %rax
subq $0x1, %rax
movsbl -0x210(%rbp,%rax), %eax
cmpl $0x2f, %eax
je 0xe931c
cmpq $0x200, -0x228(%rbp) # imm = 0x200
jb 0xe92fe
movq $0x1ff, -0x228(%rbp) # imm = 0x1FF
movq -0x228(%rbp), %rax
movb $0x2f, -0x210(%rbp,%rax)
movq -0x228(%rbp), %rax
movb $0x0, -0x20f(%rbp,%rax)
movq -0x218(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0xe8d90
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rax
movq %rax, -0x230(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xe9366
movq -0x230(%rbp), %rax
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
callq 0x2a270
nopl (%rax,%rax)
| normalize_dirname:
push rbp
mov rbp, rsp
sub rsp, 230h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
call intern_filename
lea rdi, [rbp+var_210]
call _strlen
mov [rbp+var_228], rax
cmp [rbp+var_228], 0
jz short loc_E931C
mov rax, [rbp+var_228]
sub rax, 1
movsx eax, [rbp+rax+var_210]
cmp eax, 2Fh ; '/'
jz short loc_E931C
mov rax, [rbp+var_228]
sub rax, 1
movsx eax, [rbp+rax+var_210]
cmp eax, 2Fh ; '/'
jz short loc_E931C
cmp [rbp+var_228], 200h
jb short loc_E92FE
mov [rbp+var_228], 1FFh
loc_E92FE:
mov rax, [rbp+var_228]
mov [rbp+rax+var_210], 2Fh ; '/'
mov rax, [rbp+var_228]
mov [rbp+rax+var_20F], 0
loc_E931C:
mov rdi, [rbp+var_218]
lea rsi, [rbp+var_210]
call cleanup_dirname
mov [rbp+var_228], rax
mov rax, [rbp+var_228]
mov [rbp+var_230], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_E9366
mov rax, [rbp+var_230]
add rsp, 230h
pop rbp
retn
loc_E9366:
call ___stack_chk_fail
| long long normalize_dirname(long long a1, _BYTE *a2)
{
unsigned long long v3; // [rsp+8h] [rbp-228h]
long long v4; // [rsp+18h] [rbp-218h]
_BYTE v5[520]; // [rsp+20h] [rbp-210h] BYREF
unsigned long long v6; // [rsp+228h] [rbp-8h]
v6 = __readfsqword(0x28u);
v4 = a1;
intern_filename((long long)v5, a2);
v3 = strlen(v5);
if ( v3 && v5[v3 - 1] != 47 )
{
if ( v3 >= 0x200 )
v3 = 511LL;
v5[v3] = 47;
v5[v3 + 1] = 0;
}
return cleanup_dirname(v4, v5);
}
| normalize_dirname:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x230
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
CALL 0x001e8ca0
LEA RDI,[RBP + -0x210]
CALL 0x0012a350
MOV qword ptr [RBP + -0x228],RAX
CMP qword ptr [RBP + -0x228],0x0
JZ 0x001e931c
MOV RAX,qword ptr [RBP + -0x228]
SUB RAX,0x1
MOVSX EAX,byte ptr [RBP + RAX*0x1 + -0x210]
CMP EAX,0x2f
JZ 0x001e931c
MOV RAX,qword ptr [RBP + -0x228]
SUB RAX,0x1
MOVSX EAX,byte ptr [RBP + RAX*0x1 + -0x210]
CMP EAX,0x2f
JZ 0x001e931c
CMP qword ptr [RBP + -0x228],0x200
JC 0x001e92fe
MOV qword ptr [RBP + -0x228],0x1ff
LAB_001e92fe:
MOV RAX,qword ptr [RBP + -0x228]
MOV byte ptr [RBP + RAX*0x1 + -0x210],0x2f
MOV RAX,qword ptr [RBP + -0x228]
MOV byte ptr [RBP + RAX*0x1 + -0x20f],0x0
LAB_001e931c:
MOV RDI,qword ptr [RBP + -0x218]
LEA RSI,[RBP + -0x210]
CALL 0x001e8d90
MOV qword ptr [RBP + -0x228],RAX
MOV RAX,qword ptr [RBP + -0x228]
MOV qword ptr [RBP + -0x230],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001e9366
MOV RAX,qword ptr [RBP + -0x230]
ADD RSP,0x230
POP RBP
RET
LAB_001e9366:
CALL 0x0012a270
|
int8 normalize_dirname(int8 param_1,int8 param_2)
{
int8 uVar1;
long in_FS_OFFSET;
size_t local_230;
int8 local_220;
char local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_220 = param_1;
intern_filename(local_218,param_2);
local_230 = strlen(local_218);
if (((local_230 != 0) && (local_218[local_230 - 1] != '/')) && (local_218[local_230 - 1] != '/'))
{
if (0x1ff < local_230) {
local_230 = 0x1ff;
}
local_218[local_230] = '/';
local_218[local_230 + 1] = '\0';
}
uVar1 = cleanup_dirname(local_220,local_218);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return uVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
26,366 | mysql_shutdown_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_shutdown_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_shutdown,
(parms->mysql, parms->shutdown_level),
parms->mysql,
int,
r_int)
} | O0 | c | mysql_shutdown_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x43030
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| mysql_shutdown_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov esi, [rax+8]
call mysql_shutdown
mov [rbp+var_14], eax
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| _DWORD * mysql_shutdown_start_internal(long long a1)
{
_DWORD *result; // rax
_DWORD *v2; // [rsp+0h] [rbp-20h]
v2 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
v2[2] = mysql_shutdown(*(_QWORD *)a1, *(_DWORD *)(a1 + 8));
result = v2;
*v2 = 0;
return result;
}
| mysql_shutdown_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RAX + 0x8]
CALL 0x00143030
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_shutdown_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_shutdown(*param_1,(int)param_1[1]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
26,367 | ma_write_undo_key_insert | eloqsql/storage/maria/ma_write.c | int _ma_write_undo_key_insert(MARIA_HA *info, const MARIA_KEY *key,
my_off_t *root, my_off_t new_root, LSN *res_lsn)
{
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= key->keyinfo;
uchar log_data[LSN_STORE_SIZE + FILEID_STORE_SIZE +
KEY_NR_STORE_SIZE];
const uchar *key_value;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
struct st_msg_to_write_hook_for_undo_key msg;
uint key_length;
/* Save if we need to write a clr record */
lsn_store(log_data, info->trn->undo_lsn);
key_nr_store(log_data + LSN_STORE_SIZE + FILEID_STORE_SIZE,
keyinfo->key_nr);
key_length= key->data_length + key->ref_length;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= key->data;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= key_length;
msg.root= root;
msg.value= new_root;
msg.auto_increment= 0;
key_value= key->data;
if (share->base.auto_key == ((uint) keyinfo->key_nr + 1))
{
const HA_KEYSEG *keyseg= keyinfo->seg;
uchar reversed[MARIA_MAX_KEY_BUFF];
if (keyseg->flag & HA_SWAP_KEY)
{
/* We put key from log record to "data record" packing format... */
const uchar *key_ptr= key->data, *key_end= key->data + keyseg->length;
uchar *to= reversed + keyseg->length;
do
{
*--to= *key_ptr++;
} while (key_ptr != key_end);
key_value= to;
}
/* ... so that we can read it with: */
msg.auto_increment=
ma_retrieve_auto_increment(key_value, keyseg->type);
/* and write_hook_for_undo_key_insert() will pick this. */
}
return translog_write_record(res_lsn, LOGREC_UNDO_KEY_INSERT,
info->trn, info,
(translog_size_t)
log_array[TRANSLOG_INTERNAL_PARTS + 0].length +
key_length,
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data + LSN_STORE_SIZE, &msg) ? -1 : 0;
} | O3 | c | ma_write_undo_key_insert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa50, %rsp # imm = 0xA50
movq %r8, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
movq (%rdi), %r9
movq 0x8(%rsi), %r8
movq 0x8(%rdi), %rax
movq 0x98(%rax), %rdi
movq %rdi, %r10
shrq $0x20, %r10
leaq -0x32(%rbp), %r11
movb %r10b, (%r11)
movq %rdi, %r10
shrq $0x28, %r10
movb %r10b, 0x1(%r11)
movq %rdi, %r10
shrq $0x30, %r10
movb %r10b, 0x2(%r11)
movl %edi, 0x3(%r11)
movzbl 0xa5(%r8), %r10d
movb %r10b, 0x9(%r11)
movl 0x14(%rsi), %r15d
addl 0x10(%rsi), %r15d
movq %r11, -0xa50(%rbp)
movq $0xa, -0xa48(%rbp)
movq (%rsi), %rdi
movq %rdi, -0xa40(%rbp)
movq %r15, -0xa38(%rbp)
movq %rdx, -0xa30(%rbp)
movq %rcx, -0xa28(%rbp)
movq $0x0, -0xa18(%rbp)
incl %r10d
cmpl %r10d, 0x3ec(%r9)
jne 0x5522a
movq 0xc0(%r8), %rax
testb $0x40, 0x12(%rax)
je 0x55216
movzwl 0x14(%rax), %ecx
leaq -0xa10(%rbp), %rdx
movb (%rdi), %sil
incq %rdi
movb %sil, -0xa11(%rbp,%rcx)
decq %rcx
jne 0x55200
movq %rdx, %rdi
movzbl 0x18(%rax), %esi
callq 0x3df0f
movq %rax, -0xa18(%rbp)
movq 0x8(%r14), %rax
leaq -0x2b(%rbp), %r10
addl $0xa, %r15d
subq $0x8, %rsp
leaq -0xa30(%rbp), %r11
leaq -0xa70(%rbp), %r12
movq %rbx, %rdi
movl $0x15, %esi
movq %rax, %rdx
movq %r14, %rcx
movl %r15d, %r8d
movl $0x4, %r9d
pushq %r11
pushq %r10
pushq %r12
callq 0x2ad29
addq $0x20, %rsp
movl %eax, %ecx
xorl %eax, %eax
negb %cl
sbbl %eax, %eax
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0x55291
addq $0xa50, %rsp # imm = 0xA50
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29220
| _ma_write_undo_key_insert:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 0A50h
mov rbx, r8
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
mov r9, [rdi]
mov r8, [rsi+8]
mov rax, [rdi+8]
mov rdi, [rax+98h]
mov r10, rdi
shr r10, 20h
lea r11, [rbp+var_32]
mov [r11], r10b
mov r10, rdi
shr r10, 28h
mov [r11+1], r10b
mov r10, rdi
shr r10, 30h
mov [r11+2], r10b
mov [r11+3], edi
movzx r10d, byte ptr [r8+0A5h]
mov [r11+9], r10b
mov r15d, [rsi+14h]
add r15d, [rsi+10h]
mov [rbp+var_A50], r11
mov [rbp+var_A48], 0Ah
mov rdi, [rsi]
mov [rbp+var_A40], rdi
mov [rbp+var_A38], r15
mov [rbp+var_A30], rdx
mov [rbp+var_A28], rcx
mov [rbp+var_A18], 0
inc r10d
cmp [r9+3ECh], r10d
jnz short loc_5522A
mov rax, [r8+0C0h]
test byte ptr [rax+12h], 40h
jz short loc_55216
movzx ecx, word ptr [rax+14h]
lea rdx, [rbp+var_A10]
loc_55200:
mov sil, [rdi]
inc rdi
mov byte ptr [rbp+rcx+var_A18+7], sil
dec rcx
jnz short loc_55200
mov rdi, rdx
loc_55216:
movzx esi, byte ptr [rax+18h]
call ma_retrieve_auto_increment
mov [rbp+var_A18], rax
mov rax, [r14+8]
loc_5522A:
lea r10, [rbp+var_2B]
add r15d, 0Ah
sub rsp, 8
lea r11, [rbp+var_A30]
lea r12, [rbp+var_A70]
mov rdi, rbx
mov esi, 15h
mov rdx, rax
mov rcx, r14
mov r8d, r15d
mov r9d, 4
push r11
push r10
push r12
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_28]
jnz short loc_55291
add rsp, 0A50h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_55291:
call ___stack_chk_fail
| long long ma_write_undo_key_insert(long long *a1, long long a2, long long a3, long long a4, unsigned long long a5)
{
long long v7; // r9
long long v8; // r8
long long v9; // rax
long long v10; // rdi
long long v11; // r15
unsigned __int8 *v12; // rdi
long long v13; // rax
long long v14; // rcx
char v15; // si
__int128 v17; // [rsp+0h] [rbp-A70h] BYREF
_BYTE *v18; // [rsp+20h] [rbp-A50h]
long long v19; // [rsp+28h] [rbp-A48h]
unsigned __int8 *v20; // [rsp+30h] [rbp-A40h]
long long v21; // [rsp+38h] [rbp-A38h]
_QWORD v22[3]; // [rsp+40h] [rbp-A30h] BYREF
long long auto_increment; // [rsp+58h] [rbp-A18h]
char v24; // [rsp+60h] [rbp-A10h] BYREF
_BYTE v25[3]; // [rsp+A3Eh] [rbp-32h] BYREF
int v26; // [rsp+A41h] [rbp-2Fh]
__int16 v27; // [rsp+A45h] [rbp-2Bh] BYREF
unsigned __int8 v28; // [rsp+A47h] [rbp-29h]
unsigned long long v29; // [rsp+A48h] [rbp-28h]
v29 = __readfsqword(0x28u);
v7 = *a1;
v8 = *(_QWORD *)(a2 + 8);
v9 = a1[1];
v10 = *(_QWORD *)(v9 + 152);
v25[0] = BYTE4(v10);
v25[1] = BYTE5(v10);
v25[2] = BYTE6(v10);
v26 = v10;
v28 = *(_BYTE *)(v8 + 165);
v11 = (unsigned int)(*(_DWORD *)(a2 + 16) + *(_DWORD *)(a2 + 20));
v18 = v25;
v19 = 10LL;
v12 = *(unsigned __int8 **)a2;
v20 = *(unsigned __int8 **)a2;
v21 = v11;
v22[0] = a3;
v22[1] = a4;
auto_increment = 0LL;
if ( *(_DWORD *)(v7 + 1004) == v28 + 1 )
{
v13 = *(_QWORD *)(v8 + 192);
if ( (*(_BYTE *)(v13 + 18) & 0x40) != 0 )
{
v14 = *(unsigned __int16 *)(v13 + 20);
do
{
v15 = *v12++;
*((_BYTE *)&auto_increment + v14-- + 7) = v15;
}
while ( v14 );
v12 = (unsigned __int8 *)&v24;
}
auto_increment = ma_retrieve_auto_increment(v12, *(unsigned __int8 *)(v13 + 24));
v9 = a1[1];
}
return (unsigned int)-((unsigned __int8)translog_write_record(
a5,
(int *)((char *)&dword_14 + 1),
v9,
a1,
(int)v11 + 10,
4,
&v17,
&v27,
(long long)v22) != 0);
}
| _ma_write_undo_key_insert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xa50
MOV RBX,R8
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV R9,qword ptr [RDI]
MOV R8,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RAX + 0x98]
MOV R10,RDI
SHR R10,0x20
LEA R11,[RBP + -0x32]
MOV byte ptr [R11],R10B
MOV R10,RDI
SHR R10,0x28
MOV byte ptr [R11 + 0x1],R10B
MOV R10,RDI
SHR R10,0x30
MOV byte ptr [R11 + 0x2],R10B
MOV dword ptr [R11 + 0x3],EDI
MOVZX R10D,byte ptr [R8 + 0xa5]
MOV byte ptr [R11 + 0x9],R10B
MOV R15D,dword ptr [RSI + 0x14]
ADD R15D,dword ptr [RSI + 0x10]
MOV qword ptr [RBP + -0xa50],R11
MOV qword ptr [RBP + -0xa48],0xa
MOV RDI,qword ptr [RSI]
MOV qword ptr [RBP + -0xa40],RDI
MOV qword ptr [RBP + -0xa38],R15
MOV qword ptr [RBP + -0xa30],RDX
MOV qword ptr [RBP + -0xa28],RCX
MOV qword ptr [RBP + -0xa18],0x0
INC R10D
CMP dword ptr [R9 + 0x3ec],R10D
JNZ 0x0015522a
MOV RAX,qword ptr [R8 + 0xc0]
TEST byte ptr [RAX + 0x12],0x40
JZ 0x00155216
MOVZX ECX,word ptr [RAX + 0x14]
LEA RDX,[RBP + -0xa10]
LAB_00155200:
MOV SIL,byte ptr [RDI]
INC RDI
MOV byte ptr [RBP + RCX*0x1 + -0xa11],SIL
DEC RCX
JNZ 0x00155200
MOV RDI,RDX
LAB_00155216:
MOVZX ESI,byte ptr [RAX + 0x18]
CALL 0x0013df0f
MOV qword ptr [RBP + -0xa18],RAX
MOV RAX,qword ptr [R14 + 0x8]
LAB_0015522a:
LEA R10,[RBP + -0x2b]
ADD R15D,0xa
SUB RSP,0x8
LEA R11,[RBP + -0xa30]
LEA R12,[RBP + -0xa70]
MOV RDI,RBX
MOV ESI,0x15
MOV RDX,RAX
MOV RCX,R14
MOV R8D,R15D
MOV R9D,0x4
PUSH R11
PUSH R10
PUSH R12
CALL 0x0012ad29
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 + -0x28]
JNZ 0x00155291
ADD RSP,0xa50
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00155291:
CALL 0x00129220
|
int _ma_write_undo_key_insert
(long *param_1,long *param_2,int8 param_3,int8 param_4,int8 param_5)
{
int1 uVar1;
int8 uVar2;
char cVar3;
long lVar4;
ulong uVar5;
int1 *puVar6;
int1 *puVar7;
uint uVar8;
long in_FS_OFFSET;
int1 local_a78 [32];
int1 *local_a58;
int8 local_a50;
int1 *local_a48;
ulong local_a40;
int8 local_a38;
int8 local_a30;
int8 local_a20;
int1 local_a18 [2526];
int1 local_3a;
int1 local_39;
int1 local_38;
int4 local_37;
int1 local_33 [2];
byte local_31;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
lVar4 = param_1[1];
uVar2 = *(int8 *)(lVar4 + 0x98);
local_a58 = &local_3a;
local_3a = (int1)((ulong)uVar2 >> 0x20);
local_39 = (int1)((ulong)uVar2 >> 0x28);
local_38 = (int1)((ulong)uVar2 >> 0x30);
local_37 = (int4)uVar2;
local_31 = *(byte *)(param_2[1] + 0xa5);
uVar8 = *(int *)((long)param_2 + 0x14) + (int)param_2[2];
local_a40 = (ulong)uVar8;
local_a50 = 10;
local_a48 = (int1 *)*param_2;
local_a20 = 0;
local_a38 = param_3;
local_a30 = param_4;
if (*(int *)(*param_1 + 0x3ec) == local_31 + 1) {
lVar4 = *(long *)(param_2[1] + 0xc0);
puVar7 = local_a48;
if ((*(byte *)(lVar4 + 0x12) & 0x40) != 0) {
uVar5 = (ulong)*(ushort *)(lVar4 + 0x14);
puVar7 = local_a18;
puVar6 = local_a48;
do {
uVar1 = *puVar6;
puVar6 = puVar6 + 1;
local_a18[uVar5 - 1] = uVar1;
uVar5 = uVar5 - 1;
} while (uVar5 != 0);
}
local_a20 = ma_retrieve_auto_increment(puVar7,*(int1 *)(lVar4 + 0x18));
lVar4 = param_1[1];
}
cVar3 = translog_write_record
(param_5,0x15,lVar4,param_1,uVar8 + 10,4,local_a78,local_33,&local_a38);
if (*(long *)(in_FS_OFFSET + 0x28) != local_30) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return -(uint)(cVar3 != '\0');
}
| |
26,368 | ma_tls_close | eloqsql/libmariadb/libmariadb/secure/openssl.c | my_bool ma_tls_close(MARIADB_TLS *ctls)
{
int i, rc;
SSL *ssl;
SSL_CTX *ctx= NULL;
if (!ctls || !ctls->ssl)
return 1;
ssl= (SSL *)ctls->ssl;
ctx= SSL_get_SSL_CTX(ssl);
if (ctx)
SSL_CTX_free(ctx);
SSL_set_quiet_shutdown(ssl, 1);
/* 2 x pending + 2 * data = 4 */
for (i=0; i < 4; i++)
if ((rc= SSL_shutdown(ssl)))
break;
/* Since we transferred ownership of BIO to ssl, BIO will
automatically freed - no need for an explicit BIO_free_all */
SSL_free(ssl);
ctls->ssl= NULL;
return rc;
} | O3 | c | ma_tls_close:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb $0x1, %r15b
testq %rdi, %rdi
je 0x2d89f
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x2d89f
movq %r14, %rdi
callq 0x130f0
testq %rax, %rax
je 0x2d861
movq %rax, %rdi
callq 0x13090
movq %r14, %rdi
movl $0x1, %esi
callq 0x134a0
movl $0x3, %r12d
movq %r14, %rdi
callq 0x13510
movl %eax, %r15d
subl $0x1, %r12d
setb %al
testl %r15d, %r15d
jne 0x2d88f
testb %al, %al
je 0x2d874
movq %r14, %rdi
callq 0x13280
movq $0x0, 0x10(%rbx)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| ma_tls_close:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r15b, 1
test rdi, rdi
jz short loc_2D89F
mov rbx, rdi
mov r14, [rdi+10h]
test r14, r14
jz short loc_2D89F
mov rdi, r14
call _SSL_get_SSL_CTX
test rax, rax
jz short loc_2D861
mov rdi, rax
call _SSL_CTX_free
loc_2D861:
mov rdi, r14
mov esi, 1
call _SSL_set_quiet_shutdown
mov r12d, 3
loc_2D874:
mov rdi, r14
call _SSL_shutdown
mov r15d, eax
sub r12d, 1
setb al
test r15d, r15d
jnz short loc_2D88F
test al, al
jz short loc_2D874
loc_2D88F:
mov rdi, r14
call _SSL_free
mov qword ptr [rbx+10h], 0
loc_2D89F:
mov eax, r15d
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long ma_tls_close(long long a1)
{
unsigned int v1; // r15d
long long v2; // r14
long long SSL_CTX; // rax
int v4; // r12d
bool v5; // cf
LOBYTE(v1) = 1;
if ( a1 )
{
v2 = *(_QWORD *)(a1 + 16);
if ( v2 )
{
SSL_CTX = SSL_get_SSL_CTX(*(_QWORD *)(a1 + 16));
if ( SSL_CTX )
SSL_CTX_free(SSL_CTX);
SSL_set_quiet_shutdown(v2, 1LL);
v4 = 3;
do
{
v1 = SSL_shutdown(v2);
v5 = v4-- == 0;
}
while ( !v1 && !v5 );
SSL_free(v2);
*(_QWORD *)(a1 + 16) = 0LL;
}
}
return v1;
}
| ma_tls_close:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15B,0x1
TEST RDI,RDI
JZ 0x0012d89f
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x10]
TEST R14,R14
JZ 0x0012d89f
MOV RDI,R14
CALL 0x001130f0
TEST RAX,RAX
JZ 0x0012d861
MOV RDI,RAX
CALL 0x00113090
LAB_0012d861:
MOV RDI,R14
MOV ESI,0x1
CALL 0x001134a0
MOV R12D,0x3
LAB_0012d874:
MOV RDI,R14
CALL 0x00113510
MOV R15D,EAX
SUB R12D,0x1
SETC AL
TEST R15D,R15D
JNZ 0x0012d88f
TEST AL,AL
JZ 0x0012d874
LAB_0012d88f:
MOV RDI,R14
CALL 0x00113280
MOV qword ptr [RBX + 0x10],0x0
LAB_0012d89f:
MOV EAX,R15D
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
ulong ma_tls_close(long param_1)
{
SSL *ssl;
uint uVar1;
SSL_CTX *pSVar2;
int iVar3;
int8 unaff_R15;
ulong uVar4;
bool bVar5;
uVar4 = CONCAT71((int7)((ulong)unaff_R15 >> 8),1);
if ((param_1 != 0) && (ssl = *(SSL **)(param_1 + 0x10), ssl != (SSL *)0x0)) {
pSVar2 = SSL_get_SSL_CTX(ssl);
if (pSVar2 != (SSL_CTX *)0x0) {
SSL_CTX_free(pSVar2);
}
SSL_set_quiet_shutdown(ssl,1);
iVar3 = 3;
do {
uVar1 = SSL_shutdown(ssl);
uVar4 = (ulong)uVar1;
bVar5 = iVar3 != 0;
iVar3 = iVar3 + -1;
if (uVar1 != 0) break;
} while (bVar5);
SSL_free(ssl);
*(int8 *)(param_1 + 0x10) = 0;
}
return uVar4 & 0xffffffff;
}
| |
26,369 | ma_dynstr_append_mem | eloqsql/libmariadb/libmariadb/ma_string.c | my_bool ma_dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
size_t length)
{
char *new_ptr;
if (str->length+length >= str->max_length)
{
size_t new_length=(str->length+length+str->alloc_increment)/
str->alloc_increment;
new_length*=str->alloc_increment;
if (!(new_ptr=(char*) realloc(str->str,new_length)))
return TRUE;
str->str=new_ptr;
str->max_length=new_length;
}
memcpy(str->str + str->length,append,length);
str->length+=length;
str->str[str->length]=0; /* Safety for C programs */
return FALSE;
} | O0 | c | ma_dynstr_append_mem:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x3b604
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x18(%rcx), %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x18(%rcx)
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
imulq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x13730
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3b5ed
movb $0x1, -0x1(%rbp)
jmp 0x3b647
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13370
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
| ma_dynstr_append_mem:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+8]
add rax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
jb short loc_3B604
mov rax, [rbp+var_10]
mov rax, [rax+8]
add rax, [rbp+var_20]
mov rcx, [rbp+var_10]
add rax, [rcx+18h]
mov rcx, [rbp+var_10]
xor edx, edx
div qword ptr [rcx+18h]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rax, [rax+18h]
imul rax, [rbp+var_30]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rsi, [rbp+var_30]
call _realloc
mov [rbp+var_28], rax
cmp rax, 0
jnz short loc_3B5ED
mov [rbp+var_1], 1
jmp short loc_3B647
loc_3B5ED:
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
loc_3B604:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
add rdi, [rax+8]
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+8]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
mov byte ptr [rax+rcx], 0
mov [rbp+var_1], 0
loc_3B647:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char ma_dynstr_append_mem(long long *a1, long long a2, long long a3)
{
unsigned long long v4; // [rsp+0h] [rbp-30h]
long long v5; // [rsp+8h] [rbp-28h]
if ( a3 + a1[1] < (unsigned long long)a1[2] )
goto LABEL_5;
v4 = (a1[3] + a3 + a1[1]) / (unsigned long long)a1[3] * a1[3];
v5 = realloc(*a1, v4);
if ( v5 )
{
*a1 = v5;
a1[2] = v4;
LABEL_5:
memcpy(a1[1] + *a1, a2, a3);
a1[1] += a3;
*(_BYTE *)(*a1 + a1[1]) = 0;
return 0;
}
return 1;
}
| ma_dynstr_append_mem:
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 RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JC 0x0013b604
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RCX + 0x18]
MOV RCX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV qword ptr [RCX + 0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
IMUL RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00113730
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JNZ 0x0013b5ed
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0013b647
LAB_0013b5ed:
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
LAB_0013b604:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
ADD RDI,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00113370
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV byte ptr [RBP + -0x1],0x0
LAB_0013b647:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 ma_dynstr_append_mem(long *param_1,void *param_2,size_t param_3)
{
size_t __size;
void *pvVar1;
if ((ulong)param_1[2] <= param_1[1] + param_3) {
__size = param_1[3] * ((param_1[1] + param_3 + param_1[3]) / (ulong)param_1[3]);
pvVar1 = realloc((void *)*param_1,__size);
if (pvVar1 == (void *)0x0) {
return 1;
}
*param_1 = (long)pvVar1;
param_1[2] = __size;
}
memcpy((void *)(*param_1 + param_1[1]),param_2,param_3);
param_1[1] = param_3 + param_1[1];
*(int1 *)(*param_1 + param_1[1]) = 0;
return 0;
}
| |
26,370 | get_date | eloqsql/mysys/mf_getdate.c | void get_date(register char * to, int flag, time_t date)
{
reg2 struct tm *start_time;
time_t skr;
#if defined(HAVE_LOCALTIME_R) && defined(_REENTRANT)
struct tm tm_tmp;
#endif
skr=date ? date : (time_t) my_time(0);
#if defined(HAVE_LOCALTIME_R) && defined(_REENTRANT)
if (flag & GETDATE_GMT)
gmtime_r(&skr,&tm_tmp);
else
localtime_r(&skr,&tm_tmp);
start_time= &tm_tmp;
#else
if (flag & GETDATE_GMT)
start_time= gmtime(&skr);
else
start_time= localtime(&skr);
#endif
if (flag & GETDATE_SHORT_DATE)
sprintf(to,"%02d%02d%02d",
start_time->tm_year % 100,
start_time->tm_mon+1,
start_time->tm_mday);
else
sprintf(to, ((flag & GETDATE_FIXEDLENGTH) ?
"%4d-%02d-%02d" : "%d-%02d-%02d"),
start_time->tm_year+1900,
start_time->tm_mon+1,
start_time->tm_mday);
if (flag & GETDATE_DATE_TIME)
sprintf(strend(to),
((flag & GETDATE_FIXEDLENGTH) ?
" %02d:%02d:%02d" : " %2d:%02d:%02d"),
start_time->tm_hour,
start_time->tm_min,
start_time->tm_sec);
else if (flag & GETDATE_HHMMSSTIME)
sprintf(strend(to),"%02d%02d%02d",
start_time->tm_hour,
start_time->tm_min,
start_time->tm_sec);
} | O3 | c | get_date:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebx
movq %rdi, %r14
testq %rdx, %rdx
jne 0xb4ca7
callq 0xc22a4
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
mulq %rcx
shrq $0x12, %rdx
movq %rdx, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
testb $0x8, %bl
jne 0xb4cbf
callq 0x2b140
jmp 0xb4cc4
callq 0x2b750
testb $0x2, %bl
jne 0xb4d06
testb $0x10, %bl
leaq 0x54409(%rip), %rax # 0x1090dc
leaq 0x543f4(%rip), %rcx # 0x1090ce
cmoveq %rax, %rcx
movl $0x76c, %r8d # imm = 0x76C
addl -0x3c(%rbp), %r8d
movl -0x44(%rbp), %eax
movl -0x40(%rbp), %r9d
incl %r9d
movl %eax, (%rsp)
movq %r14, %rdi
movl $0x1, %esi
movq $-0x1, %rdx
jmp 0xb4d47
movslq -0x3c(%rbp), %r8
imulq $0x51eb851f, %r8, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x25, %rax
addl %ecx, %eax
imull $0x64, %eax, %eax
subl %eax, %r8d
movl -0x44(%rbp), %eax
movl -0x40(%rbp), %r9d
incl %r9d
movl %eax, (%rsp)
leaq 0x54389(%rip), %rcx # 0x1090c1
movq %r14, %rdi
movl $0x1, %esi
movq $-0x1, %rdx
xorl %eax, %eax
callq 0x2bb50
testb $0x1, %bl
jne 0xb4d77
testb $0x4, %bl
je 0xb4db8
movq %r14, %rdi
callq 0xfbd54
movl -0x48(%rbp), %r8d
movl -0x50(%rbp), %ecx
movl -0x4c(%rbp), %r9d
movl %ecx, (%rsp)
leaq 0x5434c(%rip), %rcx # 0x1090c1
jmp 0xb4da2
movq %r14, %rdi
callq 0xfbd54
testb $0x10, %bl
leaq 0x54370(%rip), %rdx # 0x1090f9
leaq 0x54359(%rip), %rcx # 0x1090e9
cmoveq %rdx, %rcx
movl -0x48(%rbp), %r8d
movl -0x50(%rbp), %edx
movl -0x4c(%rbp), %r9d
movl %edx, (%rsp)
movq %rax, %rdi
movl $0x1, %esi
movq $-0x1, %rdx
xorl %eax, %eax
callq 0x2bb50
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
| get_date:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 50h
mov ebx, esi
mov r14, rdi
test rdx, rdx
jnz short loc_B4CA7
call my_hrtime
mov rcx, 431BDE82D7B634DBh
mul rcx
shr rdx, 12h
loc_B4CA7:
mov [rbp+var_18], rdx
lea rdi, [rbp+var_18]
lea rsi, [rbp+var_50]
test bl, 8
jnz short loc_B4CBF
call _localtime_r
jmp short loc_B4CC4
loc_B4CBF:
call _gmtime_r
loc_B4CC4:
test bl, 2
jnz short loc_B4D06
test bl, 10h
lea rax, aD02d02d; "%d-%02d-%02d"
lea rcx, a4d02d02d; "%4d-%02d-%02d"
cmovz rcx, rax
mov r8d, 76Ch
add r8d, [rbp+var_3C]
mov eax, [rbp+var_44]
mov r9d, [rbp+var_40]
inc r9d
mov [rsp+60h+var_60], eax
mov rdi, r14
mov esi, 1
mov rdx, 0FFFFFFFFFFFFFFFFh
jmp short loc_B4D47
loc_B4D06:
movsxd r8, [rbp+var_3C]
imul rax, r8, 51EB851Fh
mov rcx, rax
shr rcx, 3Fh
sar rax, 25h
add eax, ecx
imul eax, 64h ; 'd'
sub r8d, eax
mov eax, [rbp+var_44]
mov r9d, [rbp+var_40]
inc r9d
mov [rsp+60h+var_60], eax
lea rcx, a02d02d02d; "%02d%02d%02d"
mov rdi, r14
mov esi, 1
mov rdx, 0FFFFFFFFFFFFFFFFh
loc_B4D47:
xor eax, eax
call ___sprintf_chk
test bl, 1
jnz short loc_B4D77
test bl, 4
jz short loc_B4DB8
mov rdi, r14
call strend
mov r8d, [rbp+var_48]
mov ecx, [rbp+var_50]
mov r9d, [rbp+var_4C]
mov [rsp+60h+var_60], ecx
lea rcx, a02d02d02d; "%02d%02d%02d"
jmp short loc_B4DA2
loc_B4D77:
mov rdi, r14
call strend
test bl, 10h
lea rdx, a2d02d02d; " %2d:%02d:%02d"
lea rcx, a02d02d02d_0; " %02d:%02d:%02d"
cmovz rcx, rdx
mov r8d, [rbp+var_48]
mov edx, [rbp+var_50]
mov r9d, [rbp+var_4C]
mov [rsp+60h+var_60], edx
loc_B4DA2:
mov rdi, rax
mov esi, 1
mov rdx, 0FFFFFFFFFFFFFFFFh
xor eax, eax
call ___sprintf_chk
loc_B4DB8:
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
| long long get_date(long long a1, long long a2, unsigned long long a3)
{
const char *v3; // rcx
long long v4; // r8
long long v5; // r9
long long result; // rax
long long v7; // rax
long long v8; // rax
const char *v9; // rcx
int v10; // [rsp+0h] [rbp-60h]
long long v11; // [rsp+0h] [rbp-60h]
int v12; // [rsp+10h] [rbp-50h] BYREF
unsigned int v13; // [rsp+14h] [rbp-4Ch]
unsigned int v14; // [rsp+18h] [rbp-48h]
int v15; // [rsp+1Ch] [rbp-44h]
int v16; // [rsp+20h] [rbp-40h]
int v17; // [rsp+24h] [rbp-3Ch]
unsigned long long v18; // [rsp+48h] [rbp-18h] BYREF
if ( !a3 )
a3 = my_hrtime(a1, a2) / 0xF4240uLL;
v18 = a3;
if ( (a2 & 8) != 0 )
gmtime_r(&v18, &v12);
else
localtime_r(&v18, &v12);
if ( (a2 & 2) != 0 )
{
v4 = (unsigned int)(v17 % 100);
v5 = (unsigned int)(v16 + 1);
v10 = v15;
v3 = "%02d%02d%02d";
}
else
{
v3 = "%4d-%02d-%02d";
if ( (a2 & 0x10) == 0 )
v3 = "%d-%02d-%02d";
v4 = (unsigned int)(v17 + 1900);
v5 = (unsigned int)(v16 + 1);
v10 = v15;
}
result = __sprintf_chk(a1, 1LL, -1LL, v3, v4, v5, v10);
if ( (a2 & 1) != 0 )
{
v8 = strend(a1);
v9 = " %02d:%02d:%02d";
if ( (a2 & 0x10) == 0 )
v9 = " %2d:%02d:%02d";
LODWORD(v11) = v12;
return __sprintf_chk(v8, 1LL, -1LL, v9, v14, v13, v11);
}
else if ( (a2 & 4) != 0 )
{
v7 = strend(a1);
LODWORD(v11) = v12;
return __sprintf_chk(v7, 1LL, -1LL, "%02d%02d%02d", v14, v13, v11);
}
return result;
}
| get_date:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV EBX,ESI
MOV R14,RDI
TEST RDX,RDX
JNZ 0x001b4ca7
CALL 0x001c22a4
MOV RCX,0x431bde82d7b634db
MUL RCX
SHR RDX,0x12
LAB_001b4ca7:
MOV qword ptr [RBP + -0x18],RDX
LEA RDI,[RBP + -0x18]
LEA RSI,[RBP + -0x50]
TEST BL,0x8
JNZ 0x001b4cbf
CALL 0x0012b140
JMP 0x001b4cc4
LAB_001b4cbf:
CALL 0x0012b750
LAB_001b4cc4:
TEST BL,0x2
JNZ 0x001b4d06
TEST BL,0x10
LEA RAX,[0x2090dc]
LEA RCX,[0x2090ce]
CMOVZ RCX,RAX
MOV R8D,0x76c
ADD R8D,dword ptr [RBP + -0x3c]
MOV EAX,dword ptr [RBP + -0x44]
MOV R9D,dword ptr [RBP + -0x40]
INC R9D
MOV dword ptr [RSP],EAX
MOV RDI,R14
MOV ESI,0x1
MOV RDX,-0x1
JMP 0x001b4d47
LAB_001b4d06:
MOVSXD R8,dword ptr [RBP + -0x3c]
IMUL RAX,R8,0x51eb851f
MOV RCX,RAX
SHR RCX,0x3f
SAR RAX,0x25
ADD EAX,ECX
IMUL EAX,EAX,0x64
SUB R8D,EAX
MOV EAX,dword ptr [RBP + -0x44]
MOV R9D,dword ptr [RBP + -0x40]
INC R9D
MOV dword ptr [RSP],EAX
LEA RCX,[0x2090c1]
MOV RDI,R14
MOV ESI,0x1
MOV RDX,-0x1
LAB_001b4d47:
XOR EAX,EAX
CALL 0x0012bb50
TEST BL,0x1
JNZ 0x001b4d77
TEST BL,0x4
JZ 0x001b4db8
MOV RDI,R14
CALL 0x001fbd54
MOV R8D,dword ptr [RBP + -0x48]
MOV ECX,dword ptr [RBP + -0x50]
MOV R9D,dword ptr [RBP + -0x4c]
MOV dword ptr [RSP],ECX
LEA RCX,[0x2090c1]
JMP 0x001b4da2
LAB_001b4d77:
MOV RDI,R14
CALL 0x001fbd54
TEST BL,0x10
LEA RDX,[0x2090f9]
LEA RCX,[0x2090e9]
CMOVZ RCX,RDX
MOV R8D,dword ptr [RBP + -0x48]
MOV EDX,dword ptr [RBP + -0x50]
MOV R9D,dword ptr [RBP + -0x4c]
MOV dword ptr [RSP],EDX
LAB_001b4da2:
MOV RDI,RAX
MOV ESI,0x1
MOV RDX,-0x1
XOR EAX,EAX
CALL 0x0012bb50
LAB_001b4db8:
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
|
void get_date(int8 param_1,ulong param_2,ulong param_3)
{
int8 uVar1;
char *pcVar2;
tm local_58;
ulong local_20;
if (param_3 == 0) {
param_3 = my_hrtime();
param_3 = param_3 / 1000000;
}
local_20 = param_3;
if ((param_2 & 8) == 0) {
localtime_r((time_t *)&local_20,&local_58);
}
else {
gmtime_r((time_t *)&local_20,&local_58);
}
if ((param_2 & 2) == 0) {
pcVar2 = "%4d-%02d-%02d";
if ((param_2 & 0x10) == 0) {
pcVar2 = "%d-%02d-%02d";
}
local_58.tm_year = local_58.tm_year + 0x76c;
}
else {
local_58.tm_year = local_58.tm_year % 100;
pcVar2 = "%02d%02d%02d";
}
__sprintf_chk(param_1,1,0xffffffffffffffff,pcVar2,local_58.tm_year,local_58.tm_mon + 1,
local_58.tm_mday);
if ((param_2 & 1) == 0) {
if ((param_2 & 4) == 0) {
return;
}
uVar1 = strend(param_1);
pcVar2 = "%02d%02d%02d";
}
else {
uVar1 = strend(param_1);
pcVar2 = " %02d:%02d:%02d";
if ((param_2 & 0x10) == 0) {
pcVar2 = " %2d:%02d:%02d";
}
}
__sprintf_chk(uVar1,1,0xffffffffffffffff,pcVar2,local_58.tm_hour,local_58.tm_min,local_58.tm_sec);
return;
}
| |
26,371 | 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 0xe0c56
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq 0xe8(%rcx), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0xe0ca2
callq 0x2a740
movl $0x1b, (%rax)
callq 0xf6080
movl $0x1b, (%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe0db2
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xe0cbb
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 0xe0920
cmpl $0x0, %eax
je 0xe0d1a
movl $0x1, -0x4(%rbp)
jmp 0xe0db2
cmpq $0x0, -0x20(%rbp)
je 0xe0d73
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 0xe0d7a
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xe0dac
cmpq $0x0, -0x20(%rbp)
je 0xe0dac
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_E0C56:
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_E0CA2
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_E0DB2
loc_E0CA2:
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_E0CBB:
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_E0D1A
mov [rbp+var_4], 1
jmp loc_E0DB2
loc_E0D1A:
cmp [rbp+var_20], 0
jz short loc_E0D73
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_E0D7A
loc_E0D73:
mov [rbp+var_2C], 0
loc_E0D7A:
cmp [rbp+var_2C], 0
jnz short loc_E0DAC
cmp [rbp+var_20], 0
jz short loc_E0DAC
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_E0DAC:
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
loc_E0DB2:
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 0x001e0c56
LAB_001e0c56:
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 0x001e0ca2
CALL 0x0012a740
MOV dword ptr [RAX],0x1b
CALL 0x001f6080
MOV dword ptr [RAX],0x1b
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001e0db2
LAB_001e0ca2:
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 0x001e0cbb
LAB_001e0cbb:
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 0x001e0920
CMP EAX,0x0
JZ 0x001e0d1a
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e0db2
LAB_001e0d1a:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e0d73
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 0x001e0d7a
LAB_001e0d73:
MOV dword ptr [RBP + -0x2c],0x0
LAB_001e0d7a:
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x001e0dac
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e0dac
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_001e0dac:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
LAB_001e0db2:
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,372 | void ggml::cpu::aarch64::gemm<block_q4_0, 8l, 4l>(int, float*, unsigned long, void const*, void const*, int, int) | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp | void gemm<block_q4_0, 8, 4>(int n, float * s, size_t bs, const void * vx, const void * vy, int nr, int nc) {
ggml_gemm_q4_0_4x8_q8_0(n, s, bs, vx, vy, nr, nc);
} | O2 | cpp | void ggml::cpu::aarch64::gemm<block_q4_0, 8l, 4l>(int, float*, unsigned long, void const*, void const*, int, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r11
pushq $0x20
popq %r10
movl %edi, %eax
cltd
idivl %r10d
movq %r8, 0x8(%rsp)
movq %rcx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
testb $0x1f, %dil
jne 0x28a31
testb $0x3, %r9b
jne 0x28a50
movl 0x130(%rsp), %ecx
testb $0x3, %cl
jne 0x28a6f
movl %r9d, %edx
sarl $0x2, %edx
movl %ecx, %esi
sarl $0x2, %esi
movl %eax, %edi
sarl $0x1f, %edi
andnl %eax, %edi, %edi
movq %rdi, 0x90(%rsp)
movslq %eax, %rdi
sarl $0x1f, %ecx
andnl %esi, %ecx, %eax
movq %rax, 0x70(%rsp)
sarl $0x1f, %r9d
andnl %edx, %r9d, %eax
movq %rax, 0x58(%rsp)
movq 0x8(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x20(%rsp)
imulq $0x88, %rdi, %rax
movq %rax, 0x50(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0x28(%rsp)
imulq $0x48, %rdi, %rax
movq %rax, 0x68(%rsp)
movq %r11, %rax
shlq $0x4, %rax
movq %rax, 0x40(%rsp)
shlq $0x2, %r11
movq %r11, 0x78(%rsp)
xorl %eax, %eax
movq 0x1d797(%rip), %rbx # 0x45f68
cmpq 0x58(%rsp), %rax
je 0x28a1f
movq %rax, 0x60(%rsp)
imulq 0x28(%rsp), %rax
imulq $0x88, %rax, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
xorl %eax, %eax
cmpq 0x70(%rsp), %rax
je 0x289fb
movq %rax, 0x38(%rsp)
leaq 0xb0(%rsp), %rax
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x2884a
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x28841
andl $0x0, (%rax,%rdx,4)
incq %rdx
jmp 0x28832
incq %rcx
addq $0x10, %rax
jmp 0x2882a
movq 0x38(%rsp), %rax
imulq 0x28(%rsp), %rax
imulq $0x48, %rax, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x88(%rsp)
movq (%rsp), %r13
movq 0x20(%rsp), %rax
xorl %ecx, %ecx
cmpq 0x90(%rsp), %rcx
je 0x2899e
imulq $0x48, %rcx, %rdi
addq 0x88(%rsp), %rdi
movq %rcx, 0x98(%rsp)
imulq $0x88, %rcx, %r15
addq 0x80(%rsp), %r15
movq %r13, 0xa8(%rsp)
movq %rax, 0xa0(%rsp)
xorl %esi, %esi
cmpq $0x2, %rsi
je 0x28974
movq %rax, %r11
xorl %r12d, %r12d
cmpq $0x4, %r12
je 0x28964
movzwl (%r15,%r12,2), %edx
vmovss (%rbx,%rdx,4), %xmm0
movq %r13, %r9
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x28958
xorl %r8d, %r8d
xorl %r14d, %r14d
cmpq $0x8, %r8
je 0x28922
movsbl (%r9,%r8), %r10d
movl %r10d, %ebp
shlb $0x4, %bpl
movsbl %bpl, %ebp
andl $-0x10, %r10d
movsbl -0x40(%r11,%r8), %ecx
imull %ebp, %ecx
movsbl (%r11,%r8), %ebp
imull %r10d, %ebp
addl %ecx, %ebp
sarl $0x4, %ebp
addl %ebp, %r14d
incq %r8
jmp 0x288e9
vcvtsi2ss %r14d, %xmm2, %xmm1
movzwl (%rdi,%rdx,2), %r8d
vmulss (%rbx,%r8,4), %xmm1, %xmm1
movq %r12, %r8
shlq $0x4, %r8
addq %rsp, %r8
addq $0xb0, %r8
vfmadd213ss (%r8,%rdx,4), %xmm0, %xmm1 # xmm1 = (xmm0 * xmm1) + mem
vmovss %xmm1, (%r8,%rdx,4)
incq %rdx
addq $0x8, %r9
jmp 0x288dd
incq %r12
addq $0x8, %r11
jmp 0x288c4
incq %rsi
addq $0x20, %rax
addq $0x20, %r13
jmp 0x288b4
movq 0x98(%rsp), %rcx
incq %rcx
movq 0xa0(%rsp), %rax
addq $0x88, %rax
movq 0xa8(%rsp), %r13
addq $0x48, %r13
jmp 0x28871
leaq 0xb0(%rsp), %rax
movq 0x30(%rsp), %rcx
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x289d8
xorl %esi, %esi
cmpq $0x4, %rsi
je 0x289ca
vmovss (%rax,%rsi,4), %xmm0
vmovss %xmm0, (%rcx,%rsi,4)
incq %rsi
jmp 0x289b5
incq %rdx
addq 0x78(%rsp), %rcx
addq $0x10, %rax
jmp 0x289ad
movq 0x38(%rsp), %rcx
incq %rcx
movq (%rsp), %rax
addq 0x68(%rsp), %rax
movq %rax, (%rsp)
movq %rcx, %rax
addq $0x10, 0x30(%rsp)
jmp 0x28810
movq 0x60(%rsp), %rcx
incq %rcx
movq 0x50(%rsp), %rax
addq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
addq %rax, 0x10(%rsp)
movq %rcx, %rax
jmp 0x287d1
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdf10(%rip), %rdi # 0x36948
leaq 0xddd7(%rip), %rsi # 0x36816
leaq 0xe18b(%rip), %rcx # 0x36bd1
movl $0x64f, %edx # imm = 0x64F
callq 0x8460
leaq 0xe16e(%rip), %rdi # 0x36bc5
leaq 0xddb8(%rip), %rsi # 0x36816
leaq 0xe16c(%rip), %rcx # 0x36bd1
movl $0x650, %edx # imm = 0x650
callq 0x8460
leaq 0xdf55(%rip), %rdi # 0x369cb
leaq 0xdd99(%rip), %rsi # 0x36816
leaq 0xe14d(%rip), %rcx # 0x36bd1
movl $0x651, %edx # imm = 0x651
callq 0x8460
| _ZN4ggml3cpu7aarch644gemmI10block_q4_0Ll8ELl4EEEviPfmPKvS6_ii:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov r11, rdx
push 20h ; ' '
pop r10
mov eax, edi
cdq
idiv r10d
mov [rsp+128h+var_120], r8
mov [rsp+128h+var_110], rcx
mov [rsp+128h+var_118], rsi
test dil, 1Fh
jnz loc_28A31
test r9b, 3
jnz loc_28A50
mov ecx, [rsp+128h+arg_0]
test cl, 3
jnz loc_28A6F
mov edx, r9d
sar edx, 2
mov esi, ecx
sar esi, 2
mov edi, eax
sar edi, 1Fh
andn edi, edi, eax
mov [rsp+128h+var_98], rdi
movsxd rdi, eax
sar ecx, 1Fh
andn eax, ecx, esi
mov [rsp+128h+var_B8], rax
sar r9d, 1Fh
andn eax, r9d, edx
mov [rsp+128h+var_D0], rax
mov rax, [rsp+128h+var_120]
add rax, 48h ; 'H'
mov [rsp+128h+var_108], rax
imul rax, rdi, 88h
mov [rsp+128h+var_D8], rax
mov rax, [rsp+128h+var_110]
add rax, 8
mov [rsp+128h+var_E0], rax
mov [rsp+128h+var_100], rdi
imul rax, rdi, 48h ; 'H'
mov [rsp+128h+var_C0], rax
mov rax, r11
shl rax, 4
mov [rsp+128h+var_E8], rax
shl r11, 2
mov [rsp+128h+var_B0], r11
xor eax, eax
mov rbx, cs:ggml_table_f32_f16_ptr
loc_287D1:
cmp rax, [rsp+128h+var_D0]
jz loc_28A1F
mov [rsp+128h+var_C8], rax
imul rax, [rsp+128h+var_100]
imul rax, 88h
add rax, [rsp+128h+var_120]
mov [rsp+128h+var_A8], rax
mov rax, [rsp+128h+var_118]
mov [rsp+128h+var_F8], rax
mov rax, [rsp+128h+var_E0]
mov [rsp+128h+var_128], rax
xor eax, eax
loc_28810:
cmp rax, [rsp+128h+var_B8]
jz loc_289FB
mov [rsp+128h+var_F0], rax
lea rax, [rsp+128h+var_78]
xor ecx, ecx
loc_2882A:
cmp rcx, 4
jz short loc_2884A
xor edx, edx
loc_28832:
cmp rdx, 4
jz short loc_28841
and dword ptr [rax+rdx*4], 0
inc rdx
jmp short loc_28832
loc_28841:
inc rcx
add rax, 10h
jmp short loc_2882A
loc_2884A:
mov rax, [rsp+128h+var_F0]
imul rax, [rsp+128h+var_100]
imul rax, 48h ; 'H'
add rax, [rsp+128h+var_110]
mov [rsp+128h+var_A0], rax
mov r13, [rsp+128h+var_128]
mov rax, [rsp+128h+var_108]
xor ecx, ecx
loc_28871:
cmp rcx, [rsp+128h+var_98]
jz loc_2899E
imul rdi, rcx, 48h ; 'H'
add rdi, [rsp+128h+var_A0]
mov [rsp+128h+var_90], rcx
imul r15, rcx, 88h
add r15, [rsp+128h+var_A8]
mov [rsp+128h+var_80], r13
mov [rsp+128h+var_88], rax
xor esi, esi
loc_288B4:
cmp rsi, 2
jz loc_28974
mov r11, rax
xor r12d, r12d
loc_288C4:
cmp r12, 4
jz loc_28964
movzx edx, word ptr [r15+r12*2]
vmovss xmm0, dword ptr [rbx+rdx*4]
mov r9, r13
xor edx, edx
loc_288DD:
cmp rdx, 4
jz short loc_28958
xor r8d, r8d
xor r14d, r14d
loc_288E9:
cmp r8, 8
jz short loc_28922
movsx r10d, byte ptr [r9+r8]
mov ebp, r10d
shl bpl, 4
movsx ebp, bpl
and r10d, 0FFFFFFF0h
movsx ecx, byte ptr [r11+r8-40h]
imul ecx, ebp
movsx ebp, byte ptr [r11+r8]
imul ebp, r10d
add ebp, ecx
sar ebp, 4
add r14d, ebp
inc r8
jmp short loc_288E9
loc_28922:
vcvtsi2ss xmm1, xmm2, r14d
movzx r8d, word ptr [rdi+rdx*2]
vmulss xmm1, xmm1, dword ptr [rbx+r8*4]
mov r8, r12
shl r8, 4
add r8, rsp
add r8, 0B0h
vfmadd213ss xmm1, xmm0, dword ptr [r8+rdx*4]
vmovss dword ptr [r8+rdx*4], xmm1
inc rdx
add r9, 8
jmp short loc_288DD
loc_28958:
inc r12
add r11, 8
jmp loc_288C4
loc_28964:
inc rsi
add rax, 20h ; ' '
add r13, 20h ; ' '
jmp loc_288B4
loc_28974:
mov rcx, [rsp+128h+var_90]
inc rcx
mov rax, [rsp+128h+var_88]
add rax, 88h
mov r13, [rsp+128h+var_80]
add r13, 48h ; 'H'
jmp loc_28871
loc_2899E:
lea rax, [rsp+128h+var_78]
mov rcx, [rsp+128h+var_F8]
xor edx, edx
loc_289AD:
cmp rdx, 4
jz short loc_289D8
xor esi, esi
loc_289B5:
cmp rsi, 4
jz short loc_289CA
vmovss xmm0, dword ptr [rax+rsi*4]
vmovss dword ptr [rcx+rsi*4], xmm0
inc rsi
jmp short loc_289B5
loc_289CA:
inc rdx
add rcx, [rsp+128h+var_B0]
add rax, 10h
jmp short loc_289AD
loc_289D8:
mov rcx, [rsp+128h+var_F0]
inc rcx
mov rax, [rsp+128h+var_128]
add rax, [rsp+128h+var_C0]
mov [rsp+128h+var_128], rax
mov rax, rcx
add [rsp+128h+var_F8], 10h
jmp loc_28810
loc_289FB:
mov rcx, [rsp+128h+var_C8]
inc rcx
mov rax, [rsp+128h+var_D8]
add [rsp+128h+var_108], rax
mov rax, [rsp+128h+var_E8]
add [rsp+128h+var_118], rax
mov rax, rcx
jmp loc_287D1
loc_28A1F:
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_28A31:
lea rdi, aNQk0; "n % qk == 0"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlGemmQ4_0; "void ggml_gemm_q4_0_4x8_q8_0(int, float"...
mov edx, 64Fh
call ___assert_fail
loc_28A50:
lea rdi, aNr40; "nr % 4 == 0"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlGemmQ4_0; "void ggml_gemm_q4_0_4x8_q8_0(int, float"...
mov edx, 650h
call ___assert_fail
loc_28A6F:
lea rdi, aNcNcolsInterle; "nc % ncols_interleaved == 0"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlGemmQ4_0; "void ggml_gemm_q4_0_4x8_q8_0(int, float"...
mov edx, 651h
call ___assert_fail
| long long ggml::cpu::aarch64::gemm<block_q4_0,8l,4l>(
int a1,
long long a2,
long long a3,
long long a4,
long long a5,
int a6,
double a7,
double a8,
__m128 _XMM2,
int a10)
{
int v10; // eax
long long result; // rax
long long v13; // rax
_OWORD *v14; // rax
long long i; // rcx
long long j; // rdx
long long v17; // r13
long long v18; // rax
long long k; // rcx
long long m; // rsi
long long v21; // r11
long long n; // r12
long long v25; // r9
long long v27; // r8
int v28; // r14d
long long ii; // rdx
long long v38; // [rsp+0h] [rbp-128h]
long long v42; // [rsp+20h] [rbp-108h]
long long v43; // [rsp+28h] [rbp-100h]
long long v44; // [rsp+30h] [rbp-F8h]
long long v45; // [rsp+38h] [rbp-F0h]
long long v46; // [rsp+40h] [rbp-E8h]
long long v47; // [rsp+50h] [rbp-D8h]
long long v48; // [rsp+58h] [rbp-D0h]
long long v49; // [rsp+60h] [rbp-C8h]
long long v50; // [rsp+68h] [rbp-C0h]
long long v51; // [rsp+78h] [rbp-B0h]
long long v52; // [rsp+80h] [rbp-A8h]
long long v53; // [rsp+90h] [rbp-98h]
long long v54; // [rsp+A0h] [rbp-88h]
long long v55; // [rsp+A8h] [rbp-80h]
_OWORD v56[7]; // [rsp+B0h] [rbp-78h] BYREF
v10 = a1 / 32;
if ( (a1 & 0x1F) != 0 )
__assert_fail(
"n % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp",
1615LL,
"void ggml_gemm_q4_0_4x8_q8_0(int, float *__restrict, size_t, const void *__restrict, const void *__restrict, int, int)");
if ( (a6 & 3) != 0 )
__assert_fail(
"nr % 4 == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp",
1616LL,
"void ggml_gemm_q4_0_4x8_q8_0(int, float *__restrict, size_t, const void *__restrict, const void *__restrict, int, int)");
if ( (a10 & 3) != 0 )
__assert_fail(
"nc % ncols_interleaved == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp");
v53 = v10 & (unsigned int)~(v10 >> 31);
v48 = (a6 >> 2) & (unsigned int)~(a6 >> 31);
v42 = a5 + 72;
v47 = 136LL * v10;
v43 = v10;
v50 = 72LL * v10;
v46 = 16 * a3;
v51 = 4 * a3;
result = 0LL;
_RBX = &ggml_table_f32_f16;
while ( result != v48 )
{
v49 = result;
v52 = a5 + 136 * v43 * result;
v44 = a2;
v38 = a4 + 8;
v13 = 0LL;
while ( v13 != ((a10 >> 2) & ~(a10 >> 31)) )
{
v45 = v13;
v14 = v56;
for ( i = 0LL; i != 4; ++i )
{
for ( j = 0LL; j != 4; ++j )
*((_DWORD *)v14 + j) = 0;
++v14;
}
v17 = v38;
v18 = v42;
for ( k = 0LL; k != v53; ++k )
{
v55 = v17;
v54 = v18;
for ( m = 0LL; m != 2; ++m )
{
v21 = v18;
for ( n = 0LL; n != 4; ++n )
{
_RDX = *(unsigned __int16 *)(v52 + 136 * k + 2 * n);
__asm { vmovss xmm0, dword ptr [rbx+rdx*4] }
v25 = v17;
for ( _RDX = 0LL; _RDX != 4; ++_RDX )
{
v27 = 0LL;
v28 = 0;
while ( v27 != 8 )
{
v28 += (int)((char)(16 * *(_BYTE *)(v25 + v27)) * *(char *)(v21 + v27 - 64)
+ (*(char *)(v25 + v27) & 0xFFFFFFF0) * *(char *)(v21 + v27)) >> 4;
++v27;
}
__asm
{
vcvtsi2ss xmm1, xmm2, r14d
vmulss xmm1, xmm1, dword ptr [rbx+r8*4]
}
_R8 = &v56[n];
__asm
{
vfmadd213ss xmm1, xmm0, dword ptr [r8+rdx*4]
vmovss dword ptr [r8+rdx*4], xmm1
}
v25 += 8LL;
}
v21 += 8LL;
}
v18 += 32LL;
v17 += 32LL;
}
v18 = v54 + 136;
v17 = v55 + 72;
}
_RAX = v56;
_RCX = v44;
for ( ii = 0LL; ii != 4; ++ii )
{
for ( _RSI = 0LL; _RSI != 4; ++_RSI )
{
__asm
{
vmovss xmm0, dword ptr [rax+rsi*4]
vmovss dword ptr [rcx+rsi*4], xmm0
}
}
_RCX += v51;
++_RAX;
}
v38 += v50;
v13 = v45 + 1;
v44 += 16LL;
}
v42 += v47;
a2 += v46;
result = v49 + 1;
}
return result;
}
| gemm<block_q4_0,8l,4l>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV R11,RDX
PUSH 0x20
POP R10
MOV EAX,EDI
CDQ
IDIV R10D
MOV qword ptr [RSP + 0x8],R8
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x10],RSI
TEST DIL,0x1f
JNZ 0x00128a31
TEST R9B,0x3
JNZ 0x00128a50
MOV ECX,dword ptr [RSP + 0x130]
TEST CL,0x3
JNZ 0x00128a6f
MOV EDX,R9D
SAR EDX,0x2
MOV ESI,ECX
SAR ESI,0x2
MOV EDI,EAX
SAR EDI,0x1f
ANDN EDI,EDI,EAX
MOV qword ptr [RSP + 0x90],RDI
MOVSXD RDI,EAX
SAR ECX,0x1f
ANDN EAX,ECX,ESI
MOV qword ptr [RSP + 0x70],RAX
SAR R9D,0x1f
ANDN EAX,R9D,EDX
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x48
MOV qword ptr [RSP + 0x20],RAX
IMUL RAX,RDI,0x88
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x8
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x28],RDI
IMUL RAX,RDI,0x48
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,R11
SHL RAX,0x4
MOV qword ptr [RSP + 0x40],RAX
SHL R11,0x2
MOV qword ptr [RSP + 0x78],R11
XOR EAX,EAX
MOV RBX,qword ptr [0x00145f68]
LAB_001287d1:
CMP RAX,qword ptr [RSP + 0x58]
JZ 0x00128a1f
MOV qword ptr [RSP + 0x60],RAX
IMUL RAX,qword ptr [RSP + 0x28]
IMUL RAX,RAX,0x88
ADD RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP],RAX
XOR EAX,EAX
LAB_00128810:
CMP RAX,qword ptr [RSP + 0x70]
JZ 0x001289fb
MOV qword ptr [RSP + 0x38],RAX
LEA RAX,[RSP + 0xb0]
XOR ECX,ECX
LAB_0012882a:
CMP RCX,0x4
JZ 0x0012884a
XOR EDX,EDX
LAB_00128832:
CMP RDX,0x4
JZ 0x00128841
AND dword ptr [RAX + RDX*0x4],0x0
INC RDX
JMP 0x00128832
LAB_00128841:
INC RCX
ADD RAX,0x10
JMP 0x0012882a
LAB_0012884a:
MOV RAX,qword ptr [RSP + 0x38]
IMUL RAX,qword ptr [RSP + 0x28]
IMUL RAX,RAX,0x48
ADD RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x88],RAX
MOV R13,qword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x20]
XOR ECX,ECX
LAB_00128871:
CMP RCX,qword ptr [RSP + 0x90]
JZ 0x0012899e
IMUL RDI,RCX,0x48
ADD RDI,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x98],RCX
IMUL R15,RCX,0x88
ADD R15,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0xa8],R13
MOV qword ptr [RSP + 0xa0],RAX
XOR ESI,ESI
LAB_001288b4:
CMP RSI,0x2
JZ 0x00128974
MOV R11,RAX
XOR R12D,R12D
LAB_001288c4:
CMP R12,0x4
JZ 0x00128964
MOVZX EDX,word ptr [R15 + R12*0x2]
VMOVSS XMM0,dword ptr [RBX + RDX*0x4]
MOV R9,R13
XOR EDX,EDX
LAB_001288dd:
CMP RDX,0x4
JZ 0x00128958
XOR R8D,R8D
XOR R14D,R14D
LAB_001288e9:
CMP R8,0x8
JZ 0x00128922
MOVSX R10D,byte ptr [R9 + R8*0x1]
MOV EBP,R10D
SHL BPL,0x4
MOVSX EBP,BPL
AND R10D,0xfffffff0
MOVSX ECX,byte ptr [R11 + R8*0x1 + -0x40]
IMUL ECX,EBP
MOVSX EBP,byte ptr [R11 + R8*0x1]
IMUL EBP,R10D
ADD EBP,ECX
SAR EBP,0x4
ADD R14D,EBP
INC R8
JMP 0x001288e9
LAB_00128922:
VCVTSI2SS XMM1,XMM2,R14D
MOVZX R8D,word ptr [RDI + RDX*0x2]
VMULSS XMM1,XMM1,dword ptr [RBX + R8*0x4]
MOV R8,R12
SHL R8,0x4
ADD R8,RSP
ADD R8,0xb0
VFMADD213SS XMM1,XMM0,dword ptr [R8 + RDX*0x4]
VMOVSS dword ptr [R8 + RDX*0x4],XMM1
INC RDX
ADD R9,0x8
JMP 0x001288dd
LAB_00128958:
INC R12
ADD R11,0x8
JMP 0x001288c4
LAB_00128964:
INC RSI
ADD RAX,0x20
ADD R13,0x20
JMP 0x001288b4
LAB_00128974:
MOV RCX,qword ptr [RSP + 0x98]
INC RCX
MOV RAX,qword ptr [RSP + 0xa0]
ADD RAX,0x88
MOV R13,qword ptr [RSP + 0xa8]
ADD R13,0x48
JMP 0x00128871
LAB_0012899e:
LEA RAX,[RSP + 0xb0]
MOV RCX,qword ptr [RSP + 0x30]
XOR EDX,EDX
LAB_001289ad:
CMP RDX,0x4
JZ 0x001289d8
XOR ESI,ESI
LAB_001289b5:
CMP RSI,0x4
JZ 0x001289ca
VMOVSS XMM0,dword ptr [RAX + RSI*0x4]
VMOVSS dword ptr [RCX + RSI*0x4],XMM0
INC RSI
JMP 0x001289b5
LAB_001289ca:
INC RDX
ADD RCX,qword ptr [RSP + 0x78]
ADD RAX,0x10
JMP 0x001289ad
LAB_001289d8:
MOV RCX,qword ptr [RSP + 0x38]
INC RCX
MOV RAX,qword ptr [RSP]
ADD RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP],RAX
MOV RAX,RCX
ADD qword ptr [RSP + 0x30],0x10
JMP 0x00128810
LAB_001289fb:
MOV RCX,qword ptr [RSP + 0x60]
INC RCX
MOV RAX,qword ptr [RSP + 0x50]
ADD qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x40]
ADD qword ptr [RSP + 0x10],RAX
MOV RAX,RCX
JMP 0x001287d1
LAB_00128a1f:
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00128a31:
LEA RDI,[0x136948]
LEA RSI,[0x136816]
LEA RCX,[0x136bd1]
MOV EDX,0x64f
CALL 0x00108460
LAB_00128a50:
LEA RDI,[0x136bc5]
LEA RSI,[0x136816]
LEA RCX,[0x136bd1]
MOV EDX,0x650
CALL 0x00108460
LAB_00128a6f:
LEA RDI,[0x1369cb]
LEA RSI,[0x136816]
LEA RCX,[0x136bd1]
MOV EDX,0x651
CALL 0x00108460
|
/* void ggml::cpu::aarch64::gemm<block_q4_0, 8l, 4l>(int, float*, unsigned long, void const*, void
const*, int, int) */
void ggml::cpu::aarch64::gemm<block_q4_0,8l,4l>
(int param_1,float *param_2,ulong param_3,void *param_4,void *param_5,int param_6,
int param_7)
{
uint uVar1;
int1 auVar2 [16];
int *puVar3;
uint uVar4;
long lVar5;
uint *puVar6;
long lVar7;
ulong uVar8;
float *pfVar9;
ulong uVar10;
ulong uVar11;
long lVar12;
long lVar13;
long lVar14;
long lVar15;
long lVar16;
long lVar17;
long lVar18;
long lVar19;
long lVar20;
int iVar21;
long local_128;
float *local_118;
long local_108;
float *local_f8;
uint local_78 [18];
puVar3 = PTR_ggml_table_f32_f16_00145f68;
uVar4 = param_1 / 0x20;
if ((param_1 & 0x1fU) != 0) {
/* WARNING: Subroutine does not return */
__assert_fail("n % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp"
,0x64f,
"void ggml_gemm_q4_0_4x8_q8_0(int, float *__restrict, size_t, const void *__restrict, const void *__restrict, int, int)"
);
}
if ((param_6 & 3U) == 0) {
if ((param_7 & 3U) == 0) {
lVar15 = (long)(int)uVar4;
local_108 = (long)param_5 + 0x48;
local_118 = param_2;
for (uVar11 = 0; uVar11 != (uint)(~(param_6 >> 0x1f) & param_6 >> 2); uVar11 = uVar11 + 1) {
local_f8 = local_118;
local_128 = (long)param_4 + 8;
for (uVar10 = 0; uVar10 != (uint)(~(param_7 >> 0x1f) & param_7 >> 2); uVar10 = uVar10 + 1) {
puVar6 = local_78;
for (lVar7 = 0; lVar7 != 4; lVar7 = lVar7 + 1) {
for (lVar12 = 0; lVar12 != 4; lVar12 = lVar12 + 1) {
puVar6[lVar12] = 0;
}
puVar6 = puVar6 + 4;
}
lVar7 = local_108;
lVar12 = local_128;
for (uVar8 = 0; uVar8 != (~((int)uVar4 >> 0x1f) & uVar4); uVar8 = uVar8 + 1) {
lVar5 = lVar7;
lVar20 = lVar12;
for (lVar14 = 0; lVar14 != 2; lVar14 = lVar14 + 1) {
lVar18 = lVar5;
for (lVar19 = 0; lVar19 != 4; lVar19 = lVar19 + 1) {
uVar1 = *(uint *)(puVar3 + (ulong)*(ushort *)
((long)param_5 +
lVar19 * 2 +
uVar8 * 0x88 + uVar11 * lVar15 * 0x88) * 4);
lVar17 = lVar20;
for (lVar13 = 0; lVar13 != 4; lVar13 = lVar13 + 1) {
iVar21 = 0;
for (lVar16 = 0; lVar16 != 8; lVar16 = lVar16 + 1) {
iVar21 = iVar21 + ((int)((int)*(char *)(lVar18 + lVar16) *
((int)*(char *)(lVar17 + lVar16) & 0xfffffff0U) +
(int)*(char *)(lVar18 + -0x40 + lVar16) *
(int)(char)(*(char *)(lVar17 + lVar16) << 4)) >> 4);
}
auVar2 = vfmadd213ss_fma(ZEXT416((uint)((float)iVar21 *
*(float *)(puVar3 + (ulong)*(ushort *)
((long)param_4
+ lVar13 * 2 +
uVar8 * 0x48
+ uVar10 *
lVar15 * 0x48) * 4))),ZEXT416(uVar1),
ZEXT416(local_78[lVar19 * 4 + lVar13]));
local_78[lVar19 * 4 + lVar13] = auVar2._0_4_;
lVar17 = lVar17 + 8;
}
lVar18 = lVar18 + 8;
}
lVar5 = lVar5 + 0x20;
lVar20 = lVar20 + 0x20;
}
lVar7 = lVar7 + 0x88;
lVar12 = lVar12 + 0x48;
}
puVar6 = local_78;
pfVar9 = local_f8;
for (lVar7 = 0; lVar7 != 4; lVar7 = lVar7 + 1) {
for (lVar12 = 0; lVar12 != 4; lVar12 = lVar12 + 1) {
pfVar9[lVar12] = (float)puVar6[lVar12];
}
pfVar9 = pfVar9 + param_3;
puVar6 = puVar6 + 4;
}
local_128 = local_128 + lVar15 * 0x48;
local_f8 = local_f8 + 4;
}
local_108 = local_108 + lVar15 * 0x88;
local_118 = local_118 + param_3 * 4;
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("nc % ncols_interleaved == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp"
,0x651,
"void ggml_gemm_q4_0_4x8_q8_0(int, float *__restrict, size_t, const void *__restrict, const void *__restrict, int, int)"
);
}
/* WARNING: Subroutine does not return */
__assert_fail("nr % 4 == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp"
,0x650,
"void ggml_gemm_q4_0_4x8_q8_0(int, float *__restrict, size_t, const void *__restrict, const void *__restrict, int, int)"
);
}
| |
26,373 | void ggml::cpu::aarch64::gemm<block_q4_0, 8l, 4l>(int, float*, unsigned long, void const*, void const*, int, int) | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp | void gemm<block_q4_0, 8, 4>(int n, float * s, size_t bs, const void * vx, const void * vy, int nr, int nc) {
ggml_gemm_q4_0_4x8_q8_0(n, s, bs, vx, vy, nr, nc);
} | O3 | cpp | void ggml::cpu::aarch64::gemm<block_q4_0, 8l, 4l>(int, float*, unsigned long, void const*, void const*, int, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, 0x40(%rsp)
movq %rcx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
leal 0x1f(%rdi), %eax
testl %edi, %edi
cmovnsl %edi, %eax
movq %rdi, 0x60(%rsp)
testb $0x1f, %dil
jne 0x2b2c1
testb $0x3, %r9b
jne 0x2b2e0
movl 0x100(%rsp), %ecx
movq %rcx, (%rsp)
testb $0x3, %cl
jne 0x2b2ff
sarl $0x2, %r9d
testl %r9d, %r9d
jle 0x2b2ac
sarl $0x5, %eax
movq (%rsp), %rcx
sarl $0x2, %ecx
movq %rcx, (%rsp)
movq %rdx, %rcx
shlq $0x4, %rcx
movq %rcx, 0x50(%rsp)
shlq $0x2, %rdx
movslq %eax, %rcx
movl %r9d, %eax
movq %rax, 0x48(%rsp)
movl %ecx, %eax
movq %rax, 0x78(%rsp)
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
leaq (,%rcx,8), %rax
leaq (%rax,%rax,8), %rax
movq %rax, 0x58(%rsp)
movq $0x0, 0x8(%rsp)
vxorps %xmm0, %xmm0, %xmm0
leaq 0x80(%rsp), %r8
movq 0x1de89(%rip), %rbp # 0x48f68
vpbroadcastb 0xe65f(%rip), %xmm1 # 0x39747
cmpl $0x0, (%rsp)
jle 0x2b28a
movq 0x8(%rsp), %rax
imulq 0x38(%rsp), %rax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %r14
addq 0x40(%rsp), %r14
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x68(%rsp)
movq %rsi, 0x70(%rsp)
vmovups %ymm0, 0xa0(%rsp)
vmovups %ymm0, 0x80(%rsp)
cmpl $0x20, 0x60(%rsp)
jl 0x2b241
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r11
xorl %r12d, %r12d
movq %r12, %rax
shlq $0x7, %rax
leaq (%rax,%r12,8), %rax
addq %r14, %rax
movb $0x1, %dil
xorl %r15d, %r15d
leaq (%r11,%r15), %r10
movq %r8, %r13
xorl %esi, %esi
movzwl (%rax,%rsi,2), %r9d
vmovss (%rbp,%r9,4), %xmm2
leaq (%r15,%rsi,8), %r9
vpmovsxbd 0x48(%rax,%r9), %ymm3
vpmovsxbd 0x8(%rax,%r9), %ymm4
xorl %r9d, %r9d
vmovq (%r10,%r9,8), %xmm5
vpand %xmm1, %xmm5, %xmm6
vpmovsxbd %xmm6, %ymm6
vpmulld %ymm6, %ymm3, %ymm6
vpsllw $0x4, %xmm5, %xmm5
vpand %xmm1, %xmm5, %xmm5
vpmovsxbd %xmm5, %ymm5
vpmulld %ymm4, %ymm5, %ymm5
vpaddd %ymm5, %ymm6, %ymm5
vpsrad $0x4, %ymm5, %ymm5
vextracti128 $0x1, %ymm5, %xmm6
vphaddd %xmm5, %xmm6, %xmm5
vphaddd %xmm5, %xmm5, %xmm5
vphaddd %xmm5, %xmm5, %xmm5
vcvtdq2ps %xmm5, %xmm5
movzwl (%rcx,%r9,2), %ebx
vmulss (%rbp,%rbx,4), %xmm5, %xmm5
vfmadd213ss (%r13,%r9,4), %xmm2, %xmm5 # xmm5 = (xmm2 * xmm5) + mem
vmovss %xmm5, (%r13,%r9,4)
incq %r9
cmpq $0x4, %r9
jne 0x2b19a
incq %rsi
addq $0x10, %r13
cmpq $0x4, %rsi
jne 0x2b179
movl $0x20, %r15d
testb $0x1, %dil
movl $0x0, %edi
jne 0x2b170
incq %r12
addq $0x48, %r11
addq $0x48, %rcx
cmpq 0x78(%rsp), %r12
jne 0x2b15c
movq 0x70(%rsp), %rsi
movq %rsi, %rax
xorl %ecx, %ecx
vmovups 0x80(%rsp,%rcx), %xmm2
vmovups %xmm2, (%rax)
addq $0x10, %rcx
addq %rdx, %rax
cmpq $0x40, %rcx
jne 0x2b24b
movq 0x68(%rsp), %rcx
incq %rcx
movq 0x58(%rsp), %rax
addq %rax, 0x20(%rsp)
addq %rax, 0x28(%rsp)
addq $0x10, %rsi
cmpq (%rsp), %rcx
jne 0x2b128
movq 0x8(%rsp), %rcx
incq %rcx
movq 0x50(%rsp), %rax
addq %rax, 0x18(%rsp)
movq %rcx, 0x8(%rsp)
cmpq 0x48(%rsp), %rcx
jne 0x2b0e8
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
leaq 0xe77a(%rip), %rdi # 0x39a42
leaq 0xe641(%rip), %rsi # 0x39910
leaq 0xe9f5(%rip), %rcx # 0x39ccb
movl $0x64f, %edx # imm = 0x64F
callq 0x83b0
leaq 0xe9d8(%rip), %rdi # 0x39cbf
leaq 0xe622(%rip), %rsi # 0x39910
leaq 0xe9d6(%rip), %rcx # 0x39ccb
movl $0x650, %edx # imm = 0x650
callq 0x83b0
leaq 0xe7bf(%rip), %rdi # 0x39ac5
leaq 0xe603(%rip), %rsi # 0x39910
leaq 0xe9b7(%rip), %rcx # 0x39ccb
movl $0x651, %edx # imm = 0x651
callq 0x83b0
| _ZN4ggml3cpu7aarch644gemmI10block_q4_0Ll8ELl4EEEviPfmPKvS6_ii:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov [rsp+0F8h+var_B8], r8
mov [rsp+0F8h+var_E8], rcx
mov [rsp+0F8h+var_E0], rsi
lea eax, [rdi+1Fh]
test edi, edi
cmovns eax, edi
mov [rsp+0F8h+var_98], rdi
test dil, 1Fh
jnz loc_2B2C1
test r9b, 3
jnz loc_2B2E0
mov ecx, [rsp+0F8h+arg_0]
mov [rsp+0F8h+var_F8], rcx
test cl, 3
jnz loc_2B2FF
sar r9d, 2
test r9d, r9d
jle loc_2B2AC
sar eax, 5
mov rcx, [rsp+0F8h+var_F8]
sar ecx, 2
mov [rsp+0F8h+var_F8], rcx
mov rcx, rdx
shl rcx, 4
mov [rsp+0F8h+var_A8], rcx
shl rdx, 2
movsxd rcx, eax
mov eax, r9d
mov [rsp+0F8h+var_B0], rax
mov eax, ecx
mov [rsp+0F8h+var_80], rax
mov rax, [rsp+0F8h+var_E8]
add rax, 8
mov [rsp+0F8h+var_C8], rax
mov [rsp+0F8h+var_C0], rcx
lea rax, ds:0[rcx*8]
lea rax, [rax+rax*8]
mov [rsp+0F8h+var_A0], rax
mov [rsp+0F8h+var_F0], 0
vxorps xmm0, xmm0, xmm0
lea r8, [rsp+0F8h+var_78]
mov rbp, cs:ggml_table_f32_f16_ptr
vpbroadcastb xmm1, cs:byte_39747
loc_2B0E8:
cmp dword ptr [rsp+0F8h+var_F8], 0
jle loc_2B28A
mov rax, [rsp+0F8h+var_F0]
imul rax, [rsp+0F8h+var_C0]
mov rcx, rax
shl rcx, 7
lea r14, [rcx+rax*8]
add r14, [rsp+0F8h+var_B8]
mov rsi, [rsp+0F8h+var_E0]
mov rax, [rsp+0F8h+var_E8]
mov [rsp+0F8h+var_D0], rax
mov rax, [rsp+0F8h+var_C8]
mov [rsp+0F8h+var_D8], rax
xor ecx, ecx
loc_2B128:
mov [rsp+0F8h+var_90], rcx
mov [rsp+0F8h+var_88], rsi
vmovups [rsp+0F8h+var_58], ymm0
vmovups [rsp+0F8h+var_78], ymm0
cmp dword ptr [rsp+0F8h+var_98], 20h ; ' '
jl loc_2B241
mov rcx, [rsp+0F8h+var_D0]
mov r11, [rsp+0F8h+var_D8]
xor r12d, r12d
loc_2B15C:
mov rax, r12
shl rax, 7
lea rax, [rax+r12*8]
add rax, r14
mov dil, 1
xor r15d, r15d
loc_2B170:
lea r10, [r11+r15]
mov r13, r8
xor esi, esi
loc_2B179:
movzx r9d, word ptr [rax+rsi*2]
vmovss xmm2, dword ptr [rbp+r9*4+0]
lea r9, [r15+rsi*8]
vpmovsxbd ymm3, qword ptr [rax+r9+48h]
vpmovsxbd ymm4, qword ptr [rax+r9+8]
xor r9d, r9d
loc_2B19A:
vmovq xmm5, qword ptr [r10+r9*8]
vpand xmm6, xmm5, xmm1
vpmovsxbd ymm6, xmm6
vpmulld ymm6, ymm3, ymm6
vpsllw xmm5, xmm5, 4
vpand xmm5, xmm5, xmm1
vpmovsxbd ymm5, xmm5
vpmulld ymm5, ymm5, ymm4
vpaddd ymm5, ymm6, ymm5
vpsrad ymm5, ymm5, 4
vextracti128 xmm6, ymm5, 1
vphaddd xmm5, xmm6, xmm5
vphaddd xmm5, xmm5, xmm5
vphaddd xmm5, xmm5, xmm5
vcvtdq2ps xmm5, xmm5
movzx ebx, word ptr [rcx+r9*2]
vmulss xmm5, xmm5, dword ptr [rbp+rbx*4+0]
vfmadd213ss xmm5, xmm2, dword ptr [r13+r9*4+0]
vmovss dword ptr [r13+r9*4+0], xmm5
inc r9
cmp r9, 4
jnz short loc_2B19A
inc rsi
add r13, 10h
cmp rsi, 4
jnz loc_2B179
mov r15d, 20h ; ' '
test dil, 1
mov edi, 0
jnz loc_2B170
inc r12
add r11, 48h ; 'H'
add rcx, 48h ; 'H'
cmp r12, [rsp+0F8h+var_80]
jnz loc_2B15C
loc_2B241:
mov rsi, [rsp+0F8h+var_88]
mov rax, rsi
xor ecx, ecx
loc_2B24B:
vmovups xmm2, xmmword ptr [rsp+rcx+0F8h+var_78]
vmovups xmmword ptr [rax], xmm2
add rcx, 10h
add rax, rdx
cmp rcx, 40h ; '@'
jnz short loc_2B24B
mov rcx, [rsp+0F8h+var_90]
inc rcx
mov rax, [rsp+0F8h+var_A0]
add [rsp+0F8h+var_D8], rax
add [rsp+0F8h+var_D0], rax
add rsi, 10h
cmp rcx, [rsp+0F8h+var_F8]
jnz loc_2B128
loc_2B28A:
mov rcx, [rsp+0F8h+var_F0]
inc rcx
mov rax, [rsp+0F8h+var_A8]
add [rsp+0F8h+var_E0], rax
mov [rsp+0F8h+var_F0], rcx
cmp rcx, [rsp+0F8h+var_B0]
jnz loc_2B0E8
loc_2B2AC:
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
vzeroupper
retn
loc_2B2C1:
lea rdi, aNQk0; "n % qk == 0"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlGemmQ4_0; "void ggml_gemm_q4_0_4x8_q8_0(int, float"...
mov edx, 64Fh
call ___assert_fail
loc_2B2E0:
lea rdi, aNr40; "nr % 4 == 0"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlGemmQ4_0; "void ggml_gemm_q4_0_4x8_q8_0(int, float"...
mov edx, 650h
call ___assert_fail
loc_2B2FF:
lea rdi, aNcNcolsInterle; "nc % ncols_interleaved == 0"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlGemmQ4_0; "void ggml_gemm_q4_0_4x8_q8_0(int, float"...
mov edx, 651h
call ___assert_fail
| long long ggml::cpu::aarch64::gemm<block_q4_0,8l,4l>(
int a1,
long long a2,
long long a3,
long long a4,
long long a5,
int a6,
__m128 _XMM0,
int a8)
{
long long result; // rax
int v10; // r9d
long long v11; // rdx
long long v15; // rsi
long long v16; // rcx
long long v17; // rcx
long long v18; // r11
long long v19; // r12
char v21; // di
long long v22; // r15
long long i; // rsi
bool v49; // zf
long long v53; // [rsp+0h] [rbp-F8h]
long long v54; // [rsp+8h] [rbp-F0h]
long long v57; // [rsp+20h] [rbp-D8h]
long long v58; // [rsp+28h] [rbp-D0h]
long long v59; // [rsp+30h] [rbp-C8h]
long long v60; // [rsp+38h] [rbp-C0h]
long long v61; // [rsp+48h] [rbp-B0h]
long long v62; // [rsp+50h] [rbp-A8h]
long long v63; // [rsp+58h] [rbp-A0h]
long long v65; // [rsp+68h] [rbp-90h]
long long v66; // [rsp+70h] [rbp-88h]
long long v67; // [rsp+78h] [rbp-80h]
__m256 v68; // [rsp+80h] [rbp-78h] BYREF
result = (unsigned int)(a1 + 31);
if ( a1 >= 0 )
result = (unsigned int)a1;
if ( (a1 & 0x1F) != 0 )
__assert_fail(
"n % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp",
1615LL,
"void ggml_gemm_q4_0_4x8_q8_0(int, float *__restrict, size_t, const void *__restrict, const void *__restrict, int, int)");
if ( (a6 & 3) != 0 )
__assert_fail(
"nr % 4 == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp",
1616LL,
"void ggml_gemm_q4_0_4x8_q8_0(int, float *__restrict, size_t, const void *__restrict, const void *__restrict, int, int)");
if ( (a8 & 3) != 0 )
__assert_fail(
"nc % ncols_interleaved == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp");
v10 = a6 >> 2;
if ( v10 > 0 )
{
v53 = (unsigned int)(a8 >> 2);
v62 = 16 * a3;
v11 = 4 * a3;
v61 = (unsigned int)v10;
v67 = (unsigned int)((int)result >> 5);
v59 = a4 + 8;
v60 = (int)result >> 5;
v63 = 72 * v60;
v54 = 0LL;
__asm { vxorps xmm0, xmm0, xmm0 }
_RBP = &ggml_table_f32_f16;
__asm { vpbroadcastb xmm1, cs:byte_39747 }
do
{
if ( (int)v53 > 0 )
{
v15 = a2;
v58 = a4;
v57 = v59;
v16 = 0LL;
do
{
v65 = v16;
v66 = v15;
__asm
{
vmovups [rsp+0F8h+var_58], ymm0
vmovups [rsp+0F8h+var_78], ymm0
}
if ( a1 >= 32 )
{
v17 = v58;
v18 = v57;
v19 = 0LL;
do
{
_RAX = a5 + 136 * v60 * v54 + 136 * v19;
v21 = 1;
v22 = 0LL;
do
{
_R10 = v18 + v22;
_R13 = &v68;
for ( i = 0LL; i != 4; ++i )
{
_R9 = *(unsigned __int16 *)(_RAX + 2 * i);
__asm { vmovss xmm2, dword ptr [rbp+r9*4+0] }
_R9 = v22 + 8 * i;
__asm
{
vpmovsxbd ymm3, qword ptr [rax+r9+48h]
vpmovsxbd ymm4, qword ptr [rax+r9+8]
}
for ( _R9 = 0LL; _R9 != 4; ++_R9 )
{
__asm
{
vmovq xmm5, qword ptr [r10+r9*8]
vpand xmm6, xmm5, xmm1
vpmovsxbd ymm6, xmm6
vpmulld ymm6, ymm3, ymm6
vpsllw xmm5, xmm5, 4
vpand xmm5, xmm5, xmm1
vpmovsxbd ymm5, xmm5
vpmulld ymm5, ymm5, ymm4
vpaddd ymm5, ymm6, ymm5
vpsrad ymm5, ymm5, 4
vextracti128 xmm6, ymm5, 1
vphaddd xmm5, xmm6, xmm5
vphaddd xmm5, xmm5, xmm5
vphaddd xmm5, xmm5, xmm5
vcvtdq2ps xmm5, xmm5
vmulss xmm5, xmm5, dword ptr [rbp+rbx*4+0]
vfmadd213ss xmm5, xmm2, dword ptr [r13+r9*4+0]
vmovss dword ptr [r13+r9*4+0], xmm5
}
}
_R13 = (__m256 *)((char *)_R13 + 16);
}
v22 = 32LL;
v49 = (v21 & 1) == 0;
v21 = 0;
}
while ( !v49 );
++v19;
v18 += 72LL;
v17 += 72LL;
}
while ( v19 != v67 );
}
_RAX = v66;
for ( _RCX = 0LL; _RCX != 64; _RCX += 16LL )
{
__asm
{
vmovups xmm2, xmmword ptr [rsp+rcx+0F8h+var_78]
vmovups xmmword ptr [rax], xmm2
}
_RAX += v11;
}
v16 = v65 + 1;
v57 += v63;
v58 += v63;
v15 = v66 + 16;
}
while ( v65 + 1 != v53 );
}
result = v62;
a2 += v62;
++v54;
}
while ( v54 != v61 );
}
__asm { vzeroupper }
return result;
}
| gemm<block_q4_0,8l,4l>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RSP + 0x40],R8
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x18],RSI
LEA EAX,[RDI + 0x1f]
TEST EDI,EDI
CMOVNS EAX,EDI
MOV qword ptr [RSP + 0x60],RDI
TEST DIL,0x1f
JNZ 0x0012b2c1
TEST R9B,0x3
JNZ 0x0012b2e0
MOV ECX,dword ptr [RSP + 0x100]
MOV qword ptr [RSP],RCX
TEST CL,0x3
JNZ 0x0012b2ff
SAR R9D,0x2
TEST R9D,R9D
JLE 0x0012b2ac
SAR EAX,0x5
MOV RCX,qword ptr [RSP]
SAR ECX,0x2
MOV qword ptr [RSP],RCX
MOV RCX,RDX
SHL RCX,0x4
MOV qword ptr [RSP + 0x50],RCX
SHL RDX,0x2
MOVSXD RCX,EAX
MOV EAX,R9D
MOV qword ptr [RSP + 0x48],RAX
MOV EAX,ECX
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,0x8
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RCX
LEA RAX,[RCX*0x8]
LEA RAX,[RAX + RAX*0x8]
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x8],0x0
VXORPS XMM0,XMM0,XMM0
LEA R8,[RSP + 0x80]
MOV RBP,qword ptr [0x00148f68]
VPBROADCASTB XMM1,byte ptr [0x00139747]
LAB_0012b0e8:
CMP dword ptr [RSP],0x0
JLE 0x0012b28a
MOV RAX,qword ptr [RSP + 0x8]
IMUL RAX,qword ptr [RSP + 0x38]
MOV RCX,RAX
SHL RCX,0x7
LEA R14,[RCX + RAX*0x8]
ADD R14,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
XOR ECX,ECX
LAB_0012b128:
MOV qword ptr [RSP + 0x68],RCX
MOV qword ptr [RSP + 0x70],RSI
VMOVUPS ymmword ptr [RSP + 0xa0],YMM0
VMOVUPS ymmword ptr [RSP + 0x80],YMM0
CMP dword ptr [RSP + 0x60],0x20
JL 0x0012b241
MOV RCX,qword ptr [RSP + 0x28]
MOV R11,qword ptr [RSP + 0x20]
XOR R12D,R12D
LAB_0012b15c:
MOV RAX,R12
SHL RAX,0x7
LEA RAX,[RAX + R12*0x8]
ADD RAX,R14
MOV DIL,0x1
XOR R15D,R15D
LAB_0012b170:
LEA R10,[R11 + R15*0x1]
MOV R13,R8
XOR ESI,ESI
LAB_0012b179:
MOVZX R9D,word ptr [RAX + RSI*0x2]
VMOVSS XMM2,dword ptr [RBP + R9*0x4]
LEA R9,[R15 + RSI*0x8]
VPMOVSXBD YMM3,qword ptr [RAX + R9*0x1 + 0x48]
VPMOVSXBD YMM4,qword ptr [RAX + R9*0x1 + 0x8]
XOR R9D,R9D
LAB_0012b19a:
VMOVQ XMM5,qword ptr [R10 + R9*0x8]
VPAND XMM6,XMM5,XMM1
VPMOVSXBD YMM6,XMM6
VPMULLD YMM6,YMM3,YMM6
VPSLLW XMM5,XMM5,0x4
VPAND XMM5,XMM5,XMM1
VPMOVSXBD YMM5,XMM5
VPMULLD YMM5,YMM5,YMM4
VPADDD YMM5,YMM6,YMM5
VPSRAD YMM5,YMM5,0x4
VEXTRACTI128 XMM6,YMM5,0x1
VPHADDD XMM5,XMM6,XMM5
VPHADDD XMM5,XMM5,XMM5
VPHADDD XMM5,XMM5,XMM5
VCVTDQ2PS XMM5,XMM5
MOVZX EBX,word ptr [RCX + R9*0x2]
VMULSS XMM5,XMM5,dword ptr [RBP + RBX*0x4]
VFMADD213SS XMM5,XMM2,dword ptr [R13 + R9*0x4]
VMOVSS dword ptr [R13 + R9*0x4],XMM5
INC R9
CMP R9,0x4
JNZ 0x0012b19a
INC RSI
ADD R13,0x10
CMP RSI,0x4
JNZ 0x0012b179
MOV R15D,0x20
TEST DIL,0x1
MOV EDI,0x0
JNZ 0x0012b170
INC R12
ADD R11,0x48
ADD RCX,0x48
CMP R12,qword ptr [RSP + 0x78]
JNZ 0x0012b15c
LAB_0012b241:
MOV RSI,qword ptr [RSP + 0x70]
MOV RAX,RSI
XOR ECX,ECX
LAB_0012b24b:
VMOVUPS XMM2,xmmword ptr [RSP + RCX*0x1 + 0x80]
VMOVUPS xmmword ptr [RAX],XMM2
ADD RCX,0x10
ADD RAX,RDX
CMP RCX,0x40
JNZ 0x0012b24b
MOV RCX,qword ptr [RSP + 0x68]
INC RCX
MOV RAX,qword ptr [RSP + 0x58]
ADD qword ptr [RSP + 0x20],RAX
ADD qword ptr [RSP + 0x28],RAX
ADD RSI,0x10
CMP RCX,qword ptr [RSP]
JNZ 0x0012b128
LAB_0012b28a:
MOV RCX,qword ptr [RSP + 0x8]
INC RCX
MOV RAX,qword ptr [RSP + 0x50]
ADD qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x8],RCX
CMP RCX,qword ptr [RSP + 0x48]
JNZ 0x0012b0e8
LAB_0012b2ac:
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
VZEROUPPER
RET
LAB_0012b2c1:
LEA RDI,[0x139a42]
LEA RSI,[0x139910]
LEA RCX,[0x139ccb]
MOV EDX,0x64f
CALL 0x001083b0
LAB_0012b2e0:
LEA RDI,[0x139cbf]
LEA RSI,[0x139910]
LEA RCX,[0x139ccb]
MOV EDX,0x650
CALL 0x001083b0
LAB_0012b2ff:
LEA RDI,[0x139ac5]
LEA RSI,[0x139910]
LEA RCX,[0x139ccb]
MOV EDX,0x651
CALL 0x001083b0
|
/* void ggml::cpu::aarch64::gemm<block_q4_0, 8l, 4l>(int, float*, unsigned long, void const*, void
const*, int, int) */
void ggml::cpu::aarch64::gemm<block_q4_0,8l,4l>
(int param_1,float *param_2,ulong param_3,void *param_4,void *param_5,int param_6,
int param_7)
{
uint uVar1;
int1 auVar2 [16];
int1 auVar3 [32];
int1 auVar4 [32];
int1 auVar5 [32];
long lVar6;
int8 uVar7;
long lVar8;
int *puVar9;
bool bVar10;
int iVar11;
uint uVar12;
float *pfVar13;
void *pvVar14;
ulong uVar15;
float *pfVar16;
long lVar17;
bool bVar18;
long lVar19;
long lVar20;
ulong uVar21;
int8 *puVar22;
long lVar23;
int1 auVar24 [16];
int1 auVar25 [16];
int1 auVar26 [16];
int1 auVar27 [32];
ulong local_f0;
float *local_e0;
long local_d8;
void *local_d0;
int8 local_78 [9];
puVar9 = PTR_ggml_table_f32_f16_00148f68;
iVar11 = param_1 + 0x1f;
if (-1 < param_1) {
iVar11 = param_1;
}
if ((param_1 & 0x1fU) != 0) {
/* WARNING: Subroutine does not return */
__assert_fail("n % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp"
,0x64f,
"void ggml_gemm_q4_0_4x8_q8_0(int, float *__restrict, size_t, const void *__restrict, const void *__restrict, int, int)"
);
}
if ((param_6 & 3U) != 0) {
/* WARNING: Subroutine does not return */
__assert_fail("nr % 4 == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp"
,0x650,
"void ggml_gemm_q4_0_4x8_q8_0(int, float *__restrict, size_t, const void *__restrict, const void *__restrict, int, int)"
);
}
if ((param_7 & 3U) != 0) {
/* WARNING: Subroutine does not return */
__assert_fail("nc % ncols_interleaved == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp"
,0x651,
"void ggml_gemm_q4_0_4x8_q8_0(int, float *__restrict, size_t, const void *__restrict, const void *__restrict, int, int)"
);
}
if (0 < param_6 >> 2) {
uVar12 = iVar11 >> 5;
lVar6 = (long)(int)uVar12 * 0x48;
local_f0 = 0;
auVar24[1] = DAT_00139747;
auVar24[0] = DAT_00139747;
auVar24[2] = DAT_00139747;
auVar24[3] = DAT_00139747;
auVar24[4] = DAT_00139747;
auVar24[5] = DAT_00139747;
auVar24[6] = DAT_00139747;
auVar24[7] = DAT_00139747;
auVar24[8] = DAT_00139747;
auVar24[9] = DAT_00139747;
auVar24[10] = DAT_00139747;
auVar24[0xb] = DAT_00139747;
auVar24[0xc] = DAT_00139747;
auVar24[0xd] = DAT_00139747;
auVar24[0xe] = DAT_00139747;
auVar24[0xf] = DAT_00139747;
local_e0 = param_2;
do {
if (0 < param_7 >> 2) {
uVar15 = 0;
pfVar16 = local_e0;
local_d8 = (long)param_4 + 8;
local_d0 = param_4;
do {
local_78[4] = 0;
local_78[5] = 0;
local_78[6] = 0;
local_78[7] = 0;
local_78[0] = 0;
local_78[1] = 0;
local_78[2] = 0;
local_78[3] = 0;
if (0x1f < param_1) {
uVar21 = 0;
pvVar14 = local_d0;
lVar20 = local_d8;
do {
lVar8 = uVar21 * 0x88 + local_f0 * (long)(int)uVar12 * 0x88;
lVar23 = 0;
bVar10 = true;
do {
bVar18 = bVar10;
lVar17 = 0;
puVar22 = local_78;
do {
uVar1 = *(uint *)(puVar9 + (ulong)*(ushort *)((long)param_5 + lVar17 * 2 + lVar8)
* 4);
lVar19 = lVar23 + lVar17 * 8;
auVar26._8_8_ = 0;
auVar26._0_8_ = *(ulong *)((long)param_5 + lVar19 + lVar8 + 0x48);
auVar3 = vpmovsxbd_avx2(auVar26);
auVar2._8_8_ = 0;
auVar2._0_8_ = *(ulong *)((long)param_5 + lVar19 + lVar8 + 8);
auVar4 = vpmovsxbd_avx2(auVar2);
lVar19 = 0;
do {
auVar25._8_8_ = 0;
auVar25._0_8_ = *(ulong *)(lVar20 + lVar23 + lVar19 * 8);
auVar26 = vpand_avx(auVar25,auVar24);
auVar27 = vpmovsxbd_avx2(auVar26);
auVar5 = vpmulld_avx2(auVar3,auVar27);
auVar26 = vpsllw_avx(auVar25,4);
auVar26 = vpand_avx(auVar26,auVar24);
auVar27 = vpmovsxbd_avx2(auVar26);
auVar27 = vpmulld_avx2(auVar27,auVar4);
auVar27 = vpaddd_avx2(auVar5,auVar27);
auVar27 = vpsrad_avx2(auVar27,4);
auVar26 = vphaddd_avx(auVar27._16_16_,auVar27._0_16_);
auVar26 = vphaddd_avx(auVar26,auVar26);
auVar26 = vphaddd_avx(auVar26,auVar26);
auVar26 = vcvtdq2ps_avx(auVar26);
auVar26 = vfmadd213ss_fma(ZEXT416((uint)(auVar26._0_4_ *
*(float *)(puVar9 + (ulong)*(ushort *)
((long)
pvVar14 + lVar19 * 2) * 4))),ZEXT416(uVar1),
ZEXT416(*(uint *)((long)puVar22 + lVar19 * 4)));
*(int *)((long)puVar22 + lVar19 * 4) = auVar26._0_4_;
lVar19 = lVar19 + 1;
} while (lVar19 != 4);
lVar17 = lVar17 + 1;
puVar22 = puVar22 + 2;
} while (lVar17 != 4);
lVar23 = 0x20;
bVar10 = false;
} while (bVar18);
uVar21 = uVar21 + 1;
lVar20 = lVar20 + 0x48;
pvVar14 = (void *)((long)pvVar14 + 0x48);
} while (uVar21 != uVar12);
}
lVar20 = 0;
pfVar13 = pfVar16;
do {
uVar7 = *(int8 *)((long)local_78 + lVar20 + 8);
*(int8 *)pfVar13 = *(int8 *)((long)local_78 + lVar20);
*(int8 *)(pfVar13 + 2) = uVar7;
lVar20 = lVar20 + 0x10;
pfVar13 = pfVar13 + param_3;
} while (lVar20 != 0x40);
uVar15 = uVar15 + 1;
local_d8 = local_d8 + lVar6;
local_d0 = (void *)((long)local_d0 + lVar6);
pfVar16 = pfVar16 + 4;
} while (uVar15 != (uint)(param_7 >> 2));
}
local_f0 = local_f0 + 1;
local_e0 = local_e0 + param_3 * 4;
} while (local_f0 != (uint)(param_6 >> 2));
}
return;
}
| |
26,374 | ConfigString::ConfigString(char const*) | untodesu[P]voxelius/core/config.cc | ConfigString::ConfigString(const char *default_value)
{
m_value = default_value;
} | O2 | cpp | ConfigString::ConfigString(char const*):
pushq %r14
pushq %rbx
pushq %rax
leaq 0xbafcf(%rip), %rax # 0x1092d0
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq %rbx, %rdi
callq 0x17df0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x17ec8
movq %r14, %rdi
callq 0x17cd0
| _ZN12ConfigStringC2EPKc:
push r14; Alternative name is 'ConfigString::ConfigString(char const*)'
push rbx
push rax
lea rax, off_1092D0
mov [rdi], rax
lea rbx, [rdi+8]
lea rax, [rdi+18h]
mov [rdi+8], rax
and qword ptr [rdi+10h], 0
mov byte ptr [rdi+18h], 0
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKc; std::string::assign(char const*)
add rsp, 8
pop rbx
pop r14
retn
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
| void ConfigString::ConfigString(
ConfigString *this,
const char *a2,
long long a3,
long long a4,
long long a5,
long long a6)
{
*(_QWORD *)this = off_1092D0;
*((_QWORD *)this + 1) = (char *)this + 24;
*((_QWORD *)this + 2) = 0LL;
*((_BYTE *)this + 24) = 0;
std::string::assign((char *)this + 8, a2, a3, a4, a5, a6);
}
| ConfigString:
PUSH R14
PUSH RBX
PUSH RAX
LEA RAX,[0x2092d0]
MOV qword ptr [RDI],RAX
LEA RBX,[RDI + 0x8]
LEA RAX,[RDI + 0x18]
MOV qword ptr [RDI + 0x8],RAX
AND qword ptr [RDI + 0x10],0x0
MOV byte ptr [RDI + 0x18],0x0
LAB_0014e319:
MOV RDI,RBX
CALL 0x00117df0
LAB_0014e321:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* ConfigString::ConfigString(char const*) */
void __thiscall ConfigString::ConfigString(ConfigString *this,char *param_1)
{
*(int ***)this = &PTR__ConfigString_002092d0;
*(ConfigString **)(this + 8) = this + 0x18;
*(int8 *)(this + 0x10) = 0;
this[0x18] = (ConfigString)0x0;
/* try { // try from 0014e319 to 0014e320 has its CatchHandler @ 0014e329 */
std::__cxx11::string::assign((char *)(this + 8));
return;
}
| |
26,375 | mysql_local_infile_read | eloqsql/libmariadb/libmariadb/ma_loaddata.c | static
int mysql_local_infile_read(void *ptr, char * buf, unsigned int buf_len)
{
MYSQL_INFILE_INFO *info = (MYSQL_INFILE_INFO *)ptr;
size_t count;
count= ma_read((void *)buf, 1, (size_t)buf_len, info->fp);
if (count == (size_t)-1)
{
info->error_no = errno;
snprintf((char *)info->error_msg, sizeof(info->error_msg),
CER(CR_FILE_READ), info->filename, info->error_no);
}
return((int)count);
} | O0 | c | mysql_local_infile_read:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %edx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
callq 0x36870
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x2d7a0
callq 0x13050
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
leaq 0x32973(%rip), %rax # 0x600f0
movq 0x28(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x210(%rax), %rcx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %r8d
movl $0x201, %esi # imm = 0x201
movb $0x0, %al
callq 0x136d0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| mysql_local_infile_read:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
mov rax, [rbp+var_20]
mov rcx, [rax]
mov esi, 1
call ma_read
mov [rbp+var_28], rax
cmp [rbp+var_28], 0FFFFFFFFFFFFFFFFh
jnz short loc_2D7A0
call ___errno_location
mov ecx, [rax]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rdi, [rbp+var_20]
add rdi, 0Ch
lea rax, mariadb_client_errors
mov rdx, [rax+28h]
mov rax, [rbp+var_20]
mov rcx, [rax+210h]
mov rax, [rbp+var_20]
mov r8d, [rax+8]
mov esi, 201h
mov al, 0
call _snprintf
loc_2D7A0:
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
| long long mysql_local_infile_read(long long a1, long long a2, unsigned int a3)
{
long long v4; // [rsp+8h] [rbp-28h]
v4 = ma_read(a2, 1LL, a3, *(_QWORD *)a1);
if ( v4 == -1 )
{
*(_DWORD *)(a1 + 8) = *(_DWORD *)__errno_location();
snprintf(a1 + 12, 513LL, mariadb_client_errors[5], *(_QWORD *)(a1 + 528), *(unsigned int *)(a1 + 8));
}
return v4;
}
| mysql_local_infile_read:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV ESI,0x1
CALL 0x00136870
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],-0x1
JNZ 0x0012d7a0
CALL 0x00113050
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0xc
LEA RAX,[0x1600f0]
MOV RDX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x210]
MOV RAX,qword ptr [RBP + -0x20]
MOV R8D,dword ptr [RAX + 0x8]
MOV ESI,0x201
MOV AL,0x0
CALL 0x001136d0
LAB_0012d7a0:
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
long mysql_local_infile_read(int8 *param_1,int8 param_2,int4 param_3)
{
long lVar1;
int *piVar2;
lVar1 = ma_read(param_2,1,param_3,*param_1);
if (lVar1 == -1) {
piVar2 = __errno_location();
*(int *)(param_1 + 1) = *piVar2;
snprintf((char *)((long)param_1 + 0xc),0x201,(char *)mariadb_client_errors._40_8_,param_1[0x42],
(ulong)*(uint *)(param_1 + 1));
}
return lVar1;
}
| |
26,376 | pcmp | eloqsql/strings/ctype-simple.c | static int pcmp(const void * f, const void * s)
{
const uni_idx *F= (const uni_idx*) f;
const uni_idx *S= (const uni_idx*) s;
int res;
if (!(res=((S->nchars)-(F->nchars))))
res=((F->uidx.from)-(S->uidx.to));
return res;
} | O0 | c | pcmp:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jne 0x7c375
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
movzwl 0xa(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| pcmp:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov eax, [rax]
mov rcx, [rbp+var_18]
sub eax, [rcx]
mov [rbp+var_24], eax
cmp eax, 0
jnz short loc_7C375
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+8]
mov rcx, [rbp+var_20]
movzx ecx, word ptr [rcx+0Ah]
sub eax, ecx
mov [rbp+var_24], eax
loc_7C375:
mov eax, [rbp+var_24]
pop rbp
retn
| long long pcmp(long long a1, long long a2)
{
unsigned int v3; // [rsp+0h] [rbp-24h]
v3 = *(_DWORD *)a2 - *(_DWORD *)a1;
if ( !v3 )
return *(unsigned __int16 *)(a1 + 8) - (unsigned int)*(unsigned __int16 *)(a2 + 10);
return v3;
}
| pcmp:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
SUB EAX,dword ptr [RCX]
MOV dword ptr [RBP + -0x24],EAX
CMP EAX,0x0
JNZ 0x0017c375
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,word ptr [RCX + 0xa]
SUB EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
LAB_0017c375:
MOV EAX,dword ptr [RBP + -0x24]
POP RBP
RET
|
int pcmp(int *param_1,int *param_2)
{
int local_2c;
local_2c = *param_2 - *param_1;
if (local_2c == 0) {
local_2c = (uint)*(ushort *)(param_1 + 2) - (uint)*(ushort *)((long)param_2 + 10);
}
return local_2c;
}
| |
26,377 | string_buffer_concat_value | bluesky950520[P]quickjs/quickjs.c | static int string_buffer_concat_value(StringBuffer *s, JSValue v)
{
JSString *p;
JSValue v1;
int res;
if (s->error_status) {
/* prevent exception overload */
return -1;
}
if (unlikely(JS_VALUE_GET_TAG(v) != JS_TAG_STRING)) {
v1 = JS_ToString(s->ctx, v);
if (JS_IsException(v1))
return string_buffer_set_error(s);
p = JS_VALUE_GET_STRING(v1);
res = string_buffer_concat(s, p, 0, p->len);
JS_FreeValue(s->ctx, v1);
return res;
}
p = JS_VALUE_GET_STRING(v);
return string_buffer_concat(s, p, 0, p->len);
} | O0 | c | string_buffer_concat_value:
subq $0x58, %rsp
movq %rsi, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x846fb
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x847f8
movq 0x48(%rsp), %rax
cmpl $-0x7, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x847c8
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x28a80
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x84777
movq 0x38(%rsp), %rdi
callq 0x6eb90
movl %eax, 0x54(%rsp)
jmp 0x847f8
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %ecx
xorl %edx, %edx
callq 0x6e970
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x229d0
movl 0x1c(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x847f8
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %ecx
xorl %edx, %edx
callq 0x6e970
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
| string_buffer_concat_value:
sub rsp, 58h
mov [rsp+58h+var_18], rsi
mov [rsp+58h+var_10], rdx
mov [rsp+58h+var_20], rdi
mov rax, [rsp+58h+var_20]
cmp dword ptr [rax+1Ch], 0
jz short loc_846FB
mov [rsp+58h+var_4], 0FFFFFFFFh
jmp loc_847F8
loc_846FB:
mov rax, [rsp+58h+var_10]
cmp eax, 0FFFFFFF9h
setnz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_847C8
mov rax, [rsp+58h+var_20]
mov rdi, [rax]
mov rsi, [rsp+58h+var_18]
mov rdx, [rsp+58h+var_10]
call JS_ToString
mov [rsp+58h+var_50], rax
mov [rsp+58h+var_48], rdx
mov rax, [rsp+58h+var_50]
mov [rsp+58h+var_38], rax
mov rax, [rsp+58h+var_48]
mov [rsp+58h+var_30], rax
mov rdi, [rsp+58h+var_38]
mov rsi, [rsp+58h+var_30]
call JS_IsException_1
cmp eax, 0
jz short loc_84777
mov rdi, [rsp+58h+var_20]
call string_buffer_set_error
mov [rsp+58h+var_4], eax
jmp loc_847F8
loc_84777:
mov rax, [rsp+58h+var_38]
mov [rsp+58h+var_28], rax
mov rdi, [rsp+58h+var_20]
mov rsi, [rsp+58h+var_28]
mov rax, [rsp+58h+var_28]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov ecx, eax
xor edx, edx
call string_buffer_concat
mov [rsp+58h+var_3C], eax
mov rax, [rsp+58h+var_20]
mov rdi, [rax]
mov rsi, [rsp+58h+var_38]
mov rdx, [rsp+58h+var_30]
call JS_FreeValue
mov eax, [rsp+58h+var_3C]
mov [rsp+58h+var_4], eax
jmp short loc_847F8
loc_847C8:
mov rax, [rsp+58h+var_18]
mov [rsp+58h+var_28], rax
mov rdi, [rsp+58h+var_20]
mov rsi, [rsp+58h+var_28]
mov rax, [rsp+58h+var_28]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov ecx, eax
xor edx, edx
call string_buffer_concat
mov [rsp+58h+var_4], eax
loc_847F8:
mov eax, [rsp+58h+var_4]
add rsp, 58h
retn
| long long string_buffer_concat_value(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
long long v6; // rdx
long long v8; // [rsp+8h] [rbp-50h]
unsigned int v9; // [rsp+1Ch] [rbp-3Ch]
long long v10; // [rsp+28h] [rbp-30h]
if ( *(_DWORD *)(a1 + 28) )
{
return (unsigned int)-1;
}
else if ( (_DWORD)a3 == -7 )
{
return (unsigned int)string_buffer_concat(a1, a2, 0, *(_DWORD *)(a2 + 4) & 0x7FFFFFFF);
}
else
{
v8 = JS_ToString(*(_QWORD *)a1, a2, a3, a4, a5, a6);
v10 = v6;
if ( JS_IsException_1(v8, v6) )
{
return (unsigned int)string_buffer_set_error(a1);
}
else
{
v9 = string_buffer_concat(a1, v8, 0, *(_DWORD *)(v8 + 4) & 0x7FFFFFFF);
JS_FreeValue(*(_QWORD *)a1, v8, v10);
return v9;
}
}
}
| string_buffer_concat_value:
SUB RSP,0x58
MOV qword ptr [RSP + 0x40],RSI
MOV qword ptr [RSP + 0x48],RDX
MOV qword ptr [RSP + 0x38],RDI
MOV RAX,qword ptr [RSP + 0x38]
CMP dword ptr [RAX + 0x1c],0x0
JZ 0x001846fb
MOV dword ptr [RSP + 0x54],0xffffffff
JMP 0x001847f8
LAB_001846fb:
MOV RAX,qword ptr [RSP + 0x48]
CMP EAX,-0x7
SETNZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001847c8
MOV RAX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x00128a80
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x00184777
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x0016eb90
MOV dword ptr [RSP + 0x54],EAX
JMP 0x001847f8
LAB_00184777:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV ECX,EAX
XOR EDX,EDX
CALL 0x0016e970
MOV dword ptr [RSP + 0x1c],EAX
MOV RAX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x001229d0
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x54],EAX
JMP 0x001847f8
LAB_001847c8:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV ECX,EAX
XOR EDX,EDX
CALL 0x0016e970
MOV dword ptr [RSP + 0x54],EAX
LAB_001847f8:
MOV EAX,dword ptr [RSP + 0x54]
ADD RSP,0x58
RET
|
int4 string_buffer_concat_value(int8 *param_1,long param_2,int8 param_3)
{
int iVar1;
long lVar2;
int1 auVar3 [16];
int4 local_4;
if (*(int *)((long)param_1 + 0x1c) == 0) {
if ((int)param_3 == -7) {
local_4 = string_buffer_concat
(param_1,param_2,0,(uint)*(int8 *)(param_2 + 4) & 0x7fffffff);
}
else {
auVar3 = JS_ToString(*param_1,param_2,param_3);
lVar2 = auVar3._0_8_;
iVar1 = JS_IsException(lVar2,auVar3._8_8_);
if (iVar1 == 0) {
local_4 = string_buffer_concat
(param_1,lVar2,0,(uint)*(int8 *)(lVar2 + 4) & 0x7fffffff);
JS_FreeValue(*param_1,lVar2,auVar3._8_8_);
}
else {
local_4 = string_buffer_set_error(param_1);
}
}
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
| |
26,378 | ma_init | eloqsql/libmariadb/libmariadb/ma_init.c | void ma_init(void)
{
if (ma_init_done)
return;
ma_init_done=1;
{
#ifdef _WIN32
my_win_init();
#endif
return;
}
} | O0 | c | ma_init:
pushq %rbp
movq %rsp, %rbp
leaq 0x3bfbf6(%rip), %rax # 0x46d5f1
cmpb $0x0, (%rax)
je 0xada02
jmp 0xada0c
leaq 0x3bfbe8(%rip), %rax # 0x46d5f1
movb $0x1, (%rax)
popq %rbp
retq
nop
| ma_init:
push rbp
mov rbp, rsp
lea rax, ma_init_done
cmp byte ptr [rax], 0
jz short loc_ADA02
jmp short loc_ADA0C
loc_ADA02:
lea rax, ma_init_done
mov byte ptr [rax], 1
loc_ADA0C:
pop rbp
retn
| void *ma_init()
{
void *result; // rax
result = &ma_init_done;
if ( !ma_init_done )
{
result = &ma_init_done;
ma_init_done = 1;
}
return result;
}
| ma_init:
PUSH RBP
MOV RBP,RSP
LEA RAX,[0x56d5f1]
CMP byte ptr [RAX],0x0
JZ 0x001ada02
JMP 0x001ada0c
LAB_001ada02:
LEA RAX,[0x56d5f1]
MOV byte ptr [RAX],0x1
LAB_001ada0c:
POP RBP
RET
|
void ma_init(void)
{
if (ma_init_done == '\0') {
ma_init_done = '\x01';
}
return;
}
| |
26,379 | ma_tls_get_finger_print | eloqsql/libmariadb/libmariadb/secure/openssl.c | unsigned int ma_tls_get_finger_print(MARIADB_TLS *ctls, char *fp, unsigned int len)
{
X509 *cert= NULL;
MYSQL *mysql;
unsigned int fp_len;
if (!ctls || !ctls->ssl)
return 0;
mysql= SSL_get_app_data(ctls->ssl);
if (!(cert= SSL_get_peer_certificate(ctls->ssl)))
{
my_set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
ER(CR_SSL_CONNECTION_ERROR),
"Unable to get server certificate");
goto end;
}
if (len < EVP_MAX_MD_SIZE)
{
my_set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
ER(CR_SSL_CONNECTION_ERROR),
"Finger print buffer too small");
goto end;
}
if (!X509_digest(cert, EVP_sha1(), (unsigned char *)fp, &fp_len))
{
my_set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
ER(CR_SSL_CONNECTION_ERROR),
"invalid finger print of server certificate");
goto end;
}
X509_free(cert);
return (fp_len);
end:
X509_free(cert);
return 0;
} | O0 | c | ma_tls_get_finger_print:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x694cd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x694d9
movl $0x0, -0x4(%rbp)
jmp 0x695e6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
callq 0x38320
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x38ac0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x69537
movq -0x30(%rbp), %rdi
leaq 0x1e04c2(%rip), %rax # 0x2499d0
movq (%rax), %rdx
leaq 0x1e04c8(%rip), %rax # 0x2499e0
movq 0xd0(%rax), %rcx
movl $0x7ea, %esi # imm = 0x7EA
leaq 0x76725(%rip), %r8 # 0xdfc50
movb $0x0, %al
callq 0x47bd0
jmp 0x695d6
cmpl $0x40, -0x1c(%rbp)
jae 0x6956e
movq -0x30(%rbp), %rdi
leaq 0x1e0488(%rip), %rax # 0x2499d0
movq (%rax), %rdx
leaq 0x1e048e(%rip), %rax # 0x2499e0
movq 0xd0(%rax), %rcx
movl $0x7ea, %esi # imm = 0x7EA
leaq 0x76738(%rip), %r8 # 0xdfc9d
movb $0x0, %al
callq 0x47bd0
jmp 0x695d6
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x38350
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x38250
cmpl $0x0, %eax
jne 0x695c5
movq -0x30(%rbp), %rdi
leaq 0x1e0431(%rip), %rax # 0x2499d0
movq (%rax), %rdx
leaq 0x1e0437(%rip), %rax # 0x2499e0
movq 0xd0(%rax), %rcx
movl $0x7ea, %esi # imm = 0x7EA
leaq 0x766ff(%rip), %r8 # 0xdfcbb
movb $0x0, %al
callq 0x47bd0
jmp 0x695d6
movq -0x28(%rbp), %rdi
callq 0x38bf0
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x695e6
movq -0x28(%rbp), %rdi
callq 0x38bf0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
| ma_tls_get_finger_print:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], 0
cmp [rbp+var_10], 0
jz short loc_694CD
mov rax, [rbp+var_10]
cmp qword ptr [rax+10h], 0
jnz short loc_694D9
loc_694CD:
mov [rbp+var_4], 0
jmp loc_695E6
loc_694D9:
mov rax, [rbp+var_10]
mov rdi, [rax+10h]
xor esi, esi
call _SSL_get_ex_data
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rdi, [rax+10h]
call _SSL_get1_peer_certificate
mov [rbp+var_28], rax
cmp rax, 0
jnz short loc_69537
mov rdi, [rbp+var_30]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+0D0h]
mov esi, 7EAh
lea r8, aUnableToGetSer; "Unable to get server certificate"
mov al, 0
call my_set_error
jmp loc_695D6
loc_69537:
cmp [rbp+var_1C], 40h ; '@'
jnb short loc_6956E
mov rdi, [rbp+var_30]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+0D0h]
mov esi, 7EAh
lea r8, aFingerPrintBuf; "Finger print buffer too small"
mov al, 0
call my_set_error
jmp short loc_695D6
loc_6956E:
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
call _EVP_sha1
mov rdi, [rbp+var_40]
mov rsi, rax
mov rdx, [rbp+var_18]
lea rcx, [rbp+var_34]
call _X509_digest
cmp eax, 0
jnz short loc_695C5
mov rdi, [rbp+var_30]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+0D0h]
mov esi, 7EAh
lea r8, aInvalidFingerP; "invalid finger print of server certific"...
mov al, 0
call my_set_error
jmp short loc_695D6
loc_695C5:
mov rdi, [rbp+var_28]
call _X509_free
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
jmp short loc_695E6
loc_695D6:
mov rdi, [rbp+var_28]
call _X509_free
mov [rbp+var_4], 0
loc_695E6:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long ma_tls_get_finger_print(long long a1, long long a2, unsigned int a3)
{
long long v3; // rax
unsigned int v5; // [rsp+Ch] [rbp-34h] BYREF
long long v6; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+18h] [rbp-28h]
unsigned int v8; // [rsp+24h] [rbp-1Ch]
long long v9; // [rsp+28h] [rbp-18h]
long long v10; // [rsp+30h] [rbp-10h]
v10 = a1;
v9 = a2;
v8 = a3;
v7 = 0LL;
if ( a1 && *(_QWORD *)(v10 + 16) )
{
v6 = SSL_get_ex_data(*(_QWORD *)(v10 + 16), 0LL);
v7 = SSL_get1_peer_certificate(*(_QWORD *)(v10 + 16));
if ( v7 )
{
if ( v8 >= 0x40 )
{
v3 = EVP_sha1();
if ( (unsigned int)X509_digest(v7, v3, v9, &v5) )
{
X509_free(v7);
return v5;
}
my_set_error(
v6,
0x7EAu,
(long long)SQLSTATE_UNKNOWN,
(long long)client_errors[26],
"invalid finger print of server certificate");
}
else
{
my_set_error(v6, 0x7EAu, (long long)SQLSTATE_UNKNOWN, (long long)client_errors[26], "Finger print buffer too small");
}
}
else
{
my_set_error(
v6,
0x7EAu,
(long long)SQLSTATE_UNKNOWN,
(long long)client_errors[26],
"Unable to get server certificate");
}
X509_free(v7);
return 0;
}
return 0;
}
| ma_tls_get_finger_print:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],0x0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001694cd
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x10],0x0
JNZ 0x001694d9
LAB_001694cd:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001695e6
LAB_001694d9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x10]
XOR ESI,ESI
CALL 0x00138320
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x00138ac0
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JNZ 0x00169537
MOV RDI,qword ptr [RBP + -0x30]
LEA RAX,[0x3499d0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x3499e0]
MOV RCX,qword ptr [RAX + 0xd0]
MOV ESI,0x7ea
LEA R8,[0x1dfc50]
MOV AL,0x0
CALL 0x00147bd0
JMP 0x001695d6
LAB_00169537:
CMP dword ptr [RBP + -0x1c],0x40
JNC 0x0016956e
MOV RDI,qword ptr [RBP + -0x30]
LEA RAX,[0x3499d0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x3499e0]
MOV RCX,qword ptr [RAX + 0xd0]
MOV ESI,0x7ea
LEA R8,[0x1dfc9d]
MOV AL,0x0
CALL 0x00147bd0
JMP 0x001695d6
LAB_0016956e:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
CALL 0x00138350
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,RAX
MOV RDX,qword ptr [RBP + -0x18]
LEA RCX,[RBP + -0x34]
CALL 0x00138250
CMP EAX,0x0
JNZ 0x001695c5
MOV RDI,qword ptr [RBP + -0x30]
LEA RAX,[0x3499d0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x3499e0]
MOV RCX,qword ptr [RAX + 0xd0]
MOV ESI,0x7ea
LEA R8,[0x1dfcbb]
MOV AL,0x0
CALL 0x00147bd0
JMP 0x001695d6
LAB_001695c5:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00138bf0
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001695e6
LAB_001695d6:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00138bf0
MOV dword ptr [RBP + -0x4],0x0
LAB_001695e6:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4 ma_tls_get_finger_print(long param_1,uchar *param_2,uint param_3)
{
int iVar1;
X509 *data;
EVP_MD *type;
uint local_3c;
void *local_38;
X509 *local_30;
uint local_24;
uchar *local_20;
long local_18;
local_30 = (X509 *)0x0;
if ((param_1 != 0) && (*(long *)(param_1 + 0x10) != 0)) {
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
local_38 = SSL_get_ex_data(*(SSL **)(param_1 + 0x10),0);
data = (X509 *)SSL_get1_peer_certificate(*(int8 *)(local_18 + 0x10));
local_30 = data;
if (data == (X509 *)0x0) {
my_set_error(local_38,0x7ea,SQLSTATE_UNKNOWN,PTR_s_TLS_SSL_error_____100s_00349ab0,
"Unable to get server certificate");
}
else if (local_24 < 0x40) {
my_set_error(local_38,0x7ea,SQLSTATE_UNKNOWN,PTR_s_TLS_SSL_error_____100s_00349ab0,
"Finger print buffer too small");
}
else {
type = EVP_sha1();
iVar1 = X509_digest(data,type,local_20,&local_3c);
if (iVar1 != 0) {
X509_free(local_30);
return local_3c;
}
my_set_error(local_38,0x7ea,SQLSTATE_UNKNOWN,PTR_s_TLS_SSL_error_____100s_00349ab0,
"invalid finger print of server certificate");
}
X509_free(local_30);
}
return 0;
}
| |
26,380 | ma_clear_session_state | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static void ma_clear_session_state(MYSQL *mysql)
{
uint i;
if (!mysql || !mysql->extension)
return;
for (i= SESSION_TRACK_BEGIN; i <= SESSION_TRACK_END; i++)
{
list_free(mysql->extension->session_state[i].list, 0);
}
memset(mysql->extension->session_state, 0, sizeof(struct st_mariadb_session_state) * SESSION_TRACK_TYPES);
} | O0 | c | ma_clear_session_state:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x26101
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4f0(%rax)
jne 0x26103
jmp 0x26159
movl $0x0, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
ja 0x2613e
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rax
addq $0x8, %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x2acf0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2610a
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0x13250
addq $0x10, %rsp
popq %rbp
retq
nop
| ma_clear_session_state:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
cmp [rbp+var_8], 0
jz short loc_26101
mov rax, [rbp+var_8]
cmp qword ptr [rax+4F0h], 0
jnz short loc_26103
loc_26101:
jmp short loc_26159
loc_26103:
mov [rbp+var_C], 0
loc_2610A:
cmp [rbp+var_C], 5
ja short loc_2613E
mov rax, [rbp+var_8]
mov rax, [rax+4F0h]
add rax, 8
mov ecx, [rbp+var_C]
shl rcx, 4
add rax, rcx
mov rdi, [rax]
xor esi, esi
call list_free
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
jmp short loc_2610A
loc_2613E:
mov rax, [rbp+var_8]
mov rdi, [rax+4F0h]
add rdi, 8
xor esi, esi
mov edx, 60h ; '`'
call _memset
loc_26159:
add rsp, 10h
pop rbp
retn
| long long ma_clear_session_state(long long a1)
{
long long result; // rax
unsigned int i; // [rsp+4h] [rbp-Ch]
if ( a1 )
{
result = a1;
if ( *(_QWORD *)(a1 + 1264) )
{
for ( i = 0; i <= 5; ++i )
list_free(*(_QWORD *)(16LL * i + *(_QWORD *)(a1 + 1264) + 8LL), 0LL);
return memset(*(_QWORD *)(a1 + 1264) + 8LL, 0LL, 96LL);
}
}
return result;
}
| ma_clear_session_state:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00126101
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x4f0],0x0
JNZ 0x00126103
LAB_00126101:
JMP 0x00126159
LAB_00126103:
MOV dword ptr [RBP + -0xc],0x0
LAB_0012610a:
CMP dword ptr [RBP + -0xc],0x5
JA 0x0012613e
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x4f0]
ADD RAX,0x8
MOV ECX,dword ptr [RBP + -0xc]
SHL RCX,0x4
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
XOR ESI,ESI
CALL 0x0012acf0
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x0012610a
LAB_0012613e:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x4f0]
ADD RDI,0x8
XOR ESI,ESI
MOV EDX,0x60
CALL 0x00113250
LAB_00126159:
ADD RSP,0x10
POP RBP
RET
|
void ma_clear_session_state(long param_1)
{
uint local_14;
if ((param_1 != 0) && (*(long *)(param_1 + 0x4f0) != 0)) {
for (local_14 = 0; local_14 < 6; local_14 = local_14 + 1) {
list_free(*(int8 *)(*(long *)(param_1 + 0x4f0) + 8 + (ulong)local_14 * 0x10));
}
memset((void *)(*(long *)(param_1 + 0x4f0) + 8),0,0x60);
}
return;
}
| |
26,381 | skip_trailing_space | eloqsql/strings/strings_def.h | static inline const uchar *skip_trailing_space(const uchar *ptr,size_t len)
{
const uchar *end= ptr + len;
if (len > 20)
{
const uchar *end_words= (const uchar *)(intptr)
(((ulonglong)(intptr)end) / SIZEOF_INT * SIZEOF_INT);
const uchar *start_words= (const uchar *)(intptr)
((((ulonglong)(intptr)ptr) + SIZEOF_INT - 1) / SIZEOF_INT * SIZEOF_INT);
DBUG_ASSERT(((ulonglong)(intptr)ptr) >= SIZEOF_INT);
if (end_words > ptr)
{
while (end > end_words && end[-1] == 0x20)
end--;
if (end[-1] == 0x20 && start_words < end_words)
while (end > start_words && ((unsigned *)end)[-1] == SPACE_INT)
end -= SIZEOF_INT;
}
}
while (end > ptr && end[-1] == 0x20)
end--;
return (end);
} | O0 | c | skip_trailing_space:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x14, -0x10(%rbp)
jbe 0x35b6a
movq -0x18(%rbp), %rax
shrq $0x2, %rax
shlq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
shlq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x35acd
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jbe 0x35b68
jmp 0x35add
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x29(%rbp)
jbe 0x35afd
movq -0x18(%rbp), %rax
movzbl -0x1(%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x35b06
jmp 0x35b14
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x35add
movq -0x18(%rbp), %rax
movzbl -0x1(%rax), %eax
cmpl $0x20, %eax
jne 0x35b66
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x35b66
jmp 0x35b2d
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x2a(%rbp)
jbe 0x35b4d
movq -0x18(%rbp), %rax
cmpl $0x20202020, -0x4(%rax) # imm = 0x20202020
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x35b56
jmp 0x35b64
movq -0x18(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x35b2d
jmp 0x35b66
jmp 0x35b68
jmp 0x35b6a
jmp 0x35b6c
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x2b(%rbp)
jbe 0x35b8c
movq -0x18(%rbp), %rax
movzbl -0x1(%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
testb $0x1, %al
jne 0x35b95
jmp 0x35ba3
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x35b6c
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| skip_trailing_space:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
add rax, [rbp+var_10]
mov [rbp+var_18], rax
cmp [rbp+var_10], 14h
jbe loc_35B6A
mov rax, [rbp+var_18]
shr rax, 2
shl rax, 2
mov [rbp+var_20], rax
mov rax, [rbp+var_8]
add rax, 4
sub rax, 1
shr rax, 2
shl rax, 2
mov [rbp+var_28], rax
jmp short $+2
loc_35ACD:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_8]
jbe loc_35B68
jmp short $+2
loc_35ADD:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_20]
mov [rbp+var_29], al
jbe short loc_35AFD
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax-1]
cmp eax, 20h ; ' '
setz al
mov [rbp+var_29], al
loc_35AFD:
mov al, [rbp+var_29]
test al, 1
jnz short loc_35B06
jmp short loc_35B14
loc_35B06:
mov rax, [rbp+var_18]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_18], rax
jmp short loc_35ADD
loc_35B14:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax-1]
cmp eax, 20h ; ' '
jnz short loc_35B66
mov rax, [rbp+var_28]
cmp rax, [rbp+var_20]
jnb short loc_35B66
jmp short $+2
loc_35B2D:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_28]
mov [rbp+var_2A], al
jbe short loc_35B4D
mov rax, [rbp+var_18]
cmp dword ptr [rax-4], 20202020h
setz al
mov [rbp+var_2A], al
loc_35B4D:
mov al, [rbp+var_2A]
test al, 1
jnz short loc_35B56
jmp short loc_35B64
loc_35B56:
mov rax, [rbp+var_18]
add rax, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rax
jmp short loc_35B2D
loc_35B64:
jmp short $+2
loc_35B66:
jmp short $+2
loc_35B68:
jmp short $+2
loc_35B6A:
jmp short $+2
loc_35B6C:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_8]
mov [rbp+var_2B], al
jbe short loc_35B8C
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax-1]
cmp eax, 20h ; ' '
setz al
mov [rbp+var_2B], al
loc_35B8C:
mov al, [rbp+var_2B]
test al, 1
jnz short loc_35B95
jmp short loc_35BA3
loc_35B95:
mov rax, [rbp+var_18]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_18], rax
jmp short loc_35B6C
loc_35BA3:
mov rax, [rbp+var_18]
pop rbp
retn
| unsigned long long skip_trailing_space(unsigned long long a1, unsigned long long a2)
{
bool v3; // [rsp+1h] [rbp-2Bh]
bool v4; // [rsp+2h] [rbp-2Ah]
bool v5; // [rsp+3h] [rbp-29h]
unsigned long long v6; // [rsp+4h] [rbp-28h]
unsigned long long v7; // [rsp+Ch] [rbp-20h]
unsigned long long v8; // [rsp+14h] [rbp-18h]
v8 = a2 + a1;
if ( a2 > 0x14 )
{
v7 = 4 * (v8 >> 2);
v6 = 4 * ((a1 + 3) >> 2);
if ( v7 > a1 )
{
while ( 1 )
{
v5 = 0;
if ( v8 > v7 )
v5 = *(_BYTE *)(v8 - 1) == 32;
if ( !v5 )
break;
--v8;
}
if ( *(_BYTE *)(v8 - 1) == 32 && v6 < v7 )
{
while ( 1 )
{
v4 = 0;
if ( v8 > v6 )
v4 = *(_DWORD *)(v8 - 4) == 538976288;
if ( !v4 )
break;
v8 -= 4LL;
}
}
}
}
while ( 1 )
{
v3 = 0;
if ( v8 > a1 )
v3 = *(_BYTE *)(v8 - 1) == 32;
if ( !v3 )
break;
--v8;
}
return v8;
}
| skip_trailing_space:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x10],0x14
JBE 0x00135b6a
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x4
SUB RAX,0x1
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00135acd
LAB_00135acd:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x8]
JBE 0x00135b68
JMP 0x00135add
LAB_00135add:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x20]
MOV byte ptr [RBP + -0x29],AL
JBE 0x00135afd
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x20
SETZ AL
MOV byte ptr [RBP + -0x29],AL
LAB_00135afd:
MOV AL,byte ptr [RBP + -0x29]
TEST AL,0x1
JNZ 0x00135b06
JMP 0x00135b14
LAB_00135b06:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00135add
LAB_00135b14:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x20
JNZ 0x00135b66
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x00135b66
JMP 0x00135b2d
LAB_00135b2d:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x2a],AL
JBE 0x00135b4d
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + -0x4],0x20202020
SETZ AL
MOV byte ptr [RBP + -0x2a],AL
LAB_00135b4d:
MOV AL,byte ptr [RBP + -0x2a]
TEST AL,0x1
JNZ 0x00135b56
JMP 0x00135b64
LAB_00135b56:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,-0x4
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00135b2d
LAB_00135b64:
JMP 0x00135b66
LAB_00135b66:
JMP 0x00135b68
LAB_00135b68:
JMP 0x00135b6a
LAB_00135b6a:
JMP 0x00135b6c
LAB_00135b6c:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x8]
MOV byte ptr [RBP + -0x2b],AL
JBE 0x00135b8c
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x20
SETZ AL
MOV byte ptr [RBP + -0x2b],AL
LAB_00135b8c:
MOV AL,byte ptr [RBP + -0x2b]
TEST AL,0x1
JNZ 0x00135b95
JMP 0x00135ba3
LAB_00135b95:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00135b6c
LAB_00135ba3:
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET
|
ulong skip_trailing_space(ulong param_1,ulong param_2)
{
ulong uVar1;
ulong uVar2;
bool bVar3;
ulong local_20;
local_20 = param_1 + param_2;
if (0x14 < param_2) {
uVar1 = local_20 & 0xfffffffffffffffc;
uVar2 = param_1 + 3 & 0xfffffffffffffffc;
if (param_1 < uVar1) {
while( true ) {
bVar3 = false;
if (uVar1 < local_20) {
bVar3 = *(char *)(local_20 - 1) == ' ';
}
if (!bVar3) break;
local_20 = local_20 - 1;
}
if ((*(char *)(local_20 - 1) == ' ') && (uVar2 < uVar1)) {
while( true ) {
bVar3 = false;
if (uVar2 < local_20) {
bVar3 = *(int *)(local_20 - 4) == 0x20202020;
}
if (!bVar3) break;
local_20 = local_20 - 4;
}
}
}
}
while( true ) {
bVar3 = false;
if (param_1 < local_20) {
bVar3 = *(char *)(local_20 - 1) == ' ';
}
if (!bVar3) break;
local_20 = local_20 - 1;
}
return local_20;
}
| |
26,382 | find_sh | bluesky950520[P]quickjs/quickjs-libc.c | static JSOSSignalHandler *find_sh(JSThreadState *ts, int sig_num)
{
JSOSSignalHandler *sh;
struct list_head *el;
list_for_each(el, &ts->os_signal_handlers) {
sh = list_entry(el, JSOSSignalHandler, link);
if (sh->sig_num == sig_num)
return sh;
}
return NULL;
} | O0 | c | find_sh:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
je 0x1ce00
movq -0x28(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rsp), %eax
jne 0x1cdee
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1ce09
jmp 0x1cdf0
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x1cdb7
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
| find_sh:
mov [rsp+var_10], rdi
mov [rsp+var_14], esi
mov rax, [rsp+var_10]
mov rax, [rax+18h]
mov [rsp+var_28], rax
loc_1CDB7:
mov rax, [rsp+var_28]
mov rcx, [rsp+var_10]
add rcx, 10h
cmp rax, rcx
jz short loc_1CE00
mov rax, [rsp+var_28]
mov [rsp+var_20], rax
mov rax, [rsp+var_20]
mov eax, [rax+10h]
cmp eax, [rsp+var_14]
jnz short loc_1CDEE
mov rax, [rsp+var_20]
mov [rsp+var_8], rax
jmp short loc_1CE09
loc_1CDEE:
jmp short $+2
loc_1CDF0:
mov rax, [rsp+var_28]
mov rax, [rax+8]
mov [rsp+var_28], rax
jmp short loc_1CDB7
loc_1CE00:
mov [rsp+var_8], 0
loc_1CE09:
mov rax, [rsp+var_8]
retn
| long long find_sh(long long a1, int a2)
{
long long i; // [rsp+0h] [rbp-28h]
for ( i = *(_QWORD *)(a1 + 24); i != a1 + 16; i = *(_QWORD *)(i + 8) )
{
if ( *(_DWORD *)(i + 16) == a2 )
return i;
}
return 0LL;
}
| find_sh:
MOV qword ptr [RSP + -0x10],RDI
MOV dword ptr [RSP + -0x14],ESI
MOV RAX,qword ptr [RSP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + -0x28],RAX
LAB_0011cdb7:
MOV RAX,qword ptr [RSP + -0x28]
MOV RCX,qword ptr [RSP + -0x10]
ADD RCX,0x10
CMP RAX,RCX
JZ 0x0011ce00
MOV RAX,qword ptr [RSP + -0x28]
MOV qword ptr [RSP + -0x20],RAX
MOV RAX,qword ptr [RSP + -0x20]
MOV EAX,dword ptr [RAX + 0x10]
CMP EAX,dword ptr [RSP + -0x14]
JNZ 0x0011cdee
MOV RAX,qword ptr [RSP + -0x20]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x0011ce09
LAB_0011cdee:
JMP 0x0011cdf0
LAB_0011cdf0:
MOV RAX,qword ptr [RSP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + -0x28],RAX
JMP 0x0011cdb7
LAB_0011ce00:
MOV qword ptr [RSP + -0x8],0x0
LAB_0011ce09:
MOV RAX,qword ptr [RSP + -0x8]
RET
|
long find_sh(long param_1,int param_2)
{
long local_28;
local_28 = *(long *)(param_1 + 0x18);
while( true ) {
if (local_28 == param_1 + 0x10) {
return 0;
}
if (*(int *)(local_28 + 0x10) == param_2) break;
local_28 = *(long *)(local_28 + 8);
}
return local_28;
}
| |
26,383 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [30], char const*>(char const (&) [30], char const*&&) | monkey531[P]llama/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O1 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [30], char const*>(char const (&) [30], char const*&&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x18300
addq 0x8(%r14), %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x18a20
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18cd0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x181d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x7badd
movq (%r12), %rsi
incq %rsi
callq 0x186a0
movq %r14, %rdi
callq 0x18bb0
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA39_KcS8_EEET_DpOT0_:
push r15
push r14
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
call _strlen
add rax, [r14+8]
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_7BADD
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7BADD:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[39],std::string>(
long long a1,
long long a2,
_QWORD *a3)
{
long long v4; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = strlen(a2);
std::string::reserve(a1, a3[1] + v4);
std::string::append(a1, a2);
std::string::_M_append(a1, *a3);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[39],std::__cxx11::string>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
CALL 0x00118300
ADD RAX,qword ptr [R14 + 0x8]
LAB_0017ba92:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00118a20
MOV RDI,RBX
MOV RSI,R15
CALL 0x00118cd0
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x001181d0
LAB_0017bab7:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [39], std::__cxx11::string >(char const (&) [39], std::__cxx11::string&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[39],std::__cxx11::string>
(detail *this,char *param_1,string *param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_1);
/* try { // try from 0017ba92 to 0017bab6 has its CatchHandler @ 0017bac6 */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::_M_append((char *)this,*(ulong *)param_2);
return this;
}
| |
26,384 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [30], char const*>(char const (&) [30], char const*&&) | monkey531[P]llama/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O2 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [30], char const*>(char const (&) [30], char const*&&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3d0a1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x20a30
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x87a10
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d98
movq %r14, %rdi
callq 0x20bb0
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA28_KcPS9_EEET_DpOT0_:
push r15
push r14
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
and qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
mov rsi, rdx
call _ZN8nlohmann16json_abi_v3_11_36detail13concat_lengthIJPKcEEEmS4_DpRKT_; nlohmann::json_abi_v3_11_3::detail::concat_length<char const*>(char const*,char const* const&)
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA28_KcJPS9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_
mov rax, rbx
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[28],char const*>(
long long a1,
long long a2,
_QWORD *a3)
{
long long v4; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = nlohmann::json_abi_v3_11_3::detail::concat_length<char const*>(a2, a3);
std::string::reserve(a1, v4);
ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA28_KcJPS9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_(
a1,
a2,
a3);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[28],char_const*>:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
AND qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
MOV RSI,RDX
CALL 0x0013d0a1
LAB_001879c3:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00120a30
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x00187a10
LAB_001879dc:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [28], char const*>(char const (&) [28], char const*&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[28],char_const*>
(detail *this,char *param_1,char **param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
concat_length<char_const*>(param_1,param_2);
/* try { // try from 001879c3 to 001879db has its CatchHandler @ 001879e5 */
std::__cxx11::string::reserve((ulong)this);
_ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA28_KcJPS9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_
(this,param_1,param_2);
return this;
}
| |
26,385 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [30], char const*>(char const (&) [30], char const*&&) | monkey531[P]llama/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O3 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [30], char const*>(char const (&) [30], char const*&&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x18300
movq %rax, %r12
movq (%r14), %rdi
callq 0x18300
addq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x18a20
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18cd0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x18cd0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0xa0bc3
movq (%r13), %rsi
incq %rsi
callq 0x186a0
movq %r14, %rdi
callq 0x18bb0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA28_KcPS9_EEET_DpOT0_:
push r15
push r14
push r13
push r12
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea r13, [rdi+10h]
mov [rdi], r13
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
call _strlen
mov r12, rax
mov rdi, [r14]
call _strlen
add r12, rax
mov rdi, rbx
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r14]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r13
jz short loc_A0BC3
mov rsi, [r13+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A0BC3:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[28],char const*>(
long long a1,
long long a2,
_QWORD *a3)
{
long long v4; // r12
long long v5; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = strlen(a2);
v5 = strlen(*a3);
std::string::reserve(a1, v5 + v4);
std::string::append(a1, a2);
std::string::append(a1, *a3);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[28],char_const*>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA R13,[RDI + 0x10]
MOV qword ptr [RDI],R13
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
CALL 0x00118300
MOV R12,RAX
MOV RDI,qword ptr [R14]
CALL 0x00118300
ADD R12,RAX
LAB_001a0b7e:
MOV RDI,RBX
MOV RSI,R12
CALL 0x00118a20
MOV RDI,RBX
MOV RSI,R15
CALL 0x00118cd0
MOV RSI,qword ptr [R14]
MOV RDI,RBX
CALL 0x00118cd0
LAB_001a0b9f:
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [28], char const*>(char const (&) [28], char const*&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[28],char_const*>
(detail *this,char *param_1,char **param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_1);
strlen(*param_2);
/* try { // try from 001a0b7e to 001a0b9e has its CatchHandler @ 001a0bac */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::append((char *)this);
return this;
}
| |
26,386 | mi_update_status_with_lock | eloqsql/storage/myisam/mi_locking.c | static void mi_update_status_with_lock(MI_INFO *info)
{
my_bool locked= 0;
if (info->state == &info->save_state)
{
locked= 1;
mysql_mutex_lock(&info->s->lock.mutex);
}
mi_update_status(info);
if (locked)
mysql_mutex_unlock(&info->s->lock.mutex);
} | O3 | c | mi_update_status_with_lock:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x7f28d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7f46a
movq (%rbx), %rax
leaq 0x3a0(%rax), %rdi
cmpq $0x0, 0x3e0(%rax)
jne 0x7f2d2
callq 0x2a220
movq %rbx, %rdi
callq 0x7f46a
movq (%rbx), %rbx
movq 0x3e0(%rbx), %rdi
addq $0x3a0, %rbx # imm = 0x3A0
testq %rdi, %rdi
jne 0x7f2e5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2a1e0
leaq 0x63fdb(%rip), %rsi # 0xe32b4
movl $0x176, %edx # imm = 0x176
callq 0x30603
jmp 0x7f2a6
leaq 0x30ff6c(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x7f2c4
| mi_update_status_with_lock:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
lea rax, [rdi+10h]
cmp [rdi+8], rax
jz short loc_7F28D
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp mi_update_status
loc_7F28D:
mov rax, [rbx]
lea rdi, [rax+3A0h]
cmp qword ptr [rax+3E0h], 0
jnz short loc_7F2D2
call _pthread_mutex_lock
loc_7F2A6:
mov rdi, rbx
call mi_update_status
mov rbx, [rbx]
mov rdi, [rbx+3E0h]
add rbx, 3A0h
test rdi, rdi
jnz short loc_7F2E5
loc_7F2C4:
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp _pthread_mutex_unlock
loc_7F2D2:
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 176h
call psi_mutex_lock
jmp short loc_7F2A6
loc_7F2E5:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_7F2C4
| long long mi_update_status_with_lock(_QWORD *a1)
{
long long v3; // rdi
long long v4; // rbx
long long v5; // rdi
long long v6; // rbx
if ( (_QWORD *)a1[1] != a1 + 2 )
return mi_update_status(a1);
v3 = *a1 + 928LL;
if ( *(_QWORD *)(*a1 + 992LL) )
psi_mutex_lock(v3, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_locking.c", 0x176u);
else
pthread_mutex_lock(v3);
mi_update_status(a1);
v4 = *a1;
v5 = *(_QWORD *)(v4 + 992);
v6 = v4 + 928;
if ( v5 )
((void ( *)(long long))PSI_server[44])(v5);
return pthread_mutex_unlock(v6);
}
| mi_update_status_with_lock:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
CMP qword ptr [RDI + 0x8],RAX
JZ 0x0017f28d
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0017f46a
LAB_0017f28d:
MOV RAX,qword ptr [RBX]
LEA RDI,[RAX + 0x3a0]
CMP qword ptr [RAX + 0x3e0],0x0
JNZ 0x0017f2d2
CALL 0x0012a220
LAB_0017f2a6:
MOV RDI,RBX
CALL 0x0017f46a
MOV RBX,qword ptr [RBX]
MOV RDI,qword ptr [RBX + 0x3e0]
ADD RBX,0x3a0
TEST RDI,RDI
JNZ 0x0017f2e5
LAB_0017f2c4:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0012a1e0
LAB_0017f2d2:
LEA RSI,[0x1e32b4]
MOV EDX,0x176
CALL 0x00130603
JMP 0x0017f2a6
LAB_0017f2e5:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0017f2c4
|
void mi_update_status_with_lock(long *param_1)
{
pthread_mutex_t *__mutex;
long lVar1;
if ((long *)param_1[1] != param_1 + 2) {
mi_update_status(param_1);
return;
}
__mutex = (pthread_mutex_t *)(*param_1 + 0x3a0);
if (*(long *)(*param_1 + 0x3e0) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_locking.c",
0x176);
}
mi_update_status(param_1);
lVar1 = *param_1;
if (*(long *)(lVar1 + 0x3e0) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)(lVar1 + 0x3a0));
return;
}
| |
26,387 | my_large_malloc | eloqsql/mysys/my_largepage.c | uchar *my_large_malloc(size_t *size, myf my_flags)
{
uchar *ptr= NULL;
#ifdef _WIN32
DWORD alloc_type= MEM_COMMIT | MEM_RESERVE;
size_t orig_size= *size;
DBUG_ENTER("my_large_malloc");
if (my_use_large_pages)
{
alloc_type|= MEM_LARGE_PAGES;
/* Align block size to my_large_page_size */
*size= MY_ALIGN(*size, (size_t) my_large_page_size);
}
ptr= VirtualAlloc(NULL, *size, alloc_type, PAGE_READWRITE);
if (!ptr)
{
if (my_flags & MY_WME)
{
if (my_use_large_pages)
{
my_printf_error(EE_OUTOFMEMORY,
"Couldn't allocate %zu bytes (MEM_LARGE_PAGES page "
"size %zu); Windows error %lu",
MYF(ME_WARNING | ME_ERROR_LOG_ONLY), *size,
my_large_page_size, GetLastError());
}
else
{
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_ERROR_LOG), *size);
}
}
if (my_use_large_pages)
{
*size= orig_size;
ptr= VirtualAlloc(NULL, *size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (!ptr && my_flags & MY_WME)
{
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_ERROR_LOG), *size);
}
}
}
#elif defined(HAVE_MMAP)
int mapflag;
int page_i= 0;
size_t large_page_size= 0;
size_t aligned_size= *size;
DBUG_ENTER("my_large_malloc");
while (1)
{
mapflag= MAP_PRIVATE | OS_MAP_ANON;
if (my_use_large_pages)
{
large_page_size= my_next_large_page_size(*size, &page_i);
/* this might be 0, in which case we do a standard mmap */
if (large_page_size)
{
#if defined(MAP_HUGETLB) /* linux 2.6.32 */
mapflag|= MAP_HUGETLB;
#if defined(MAP_HUGE_SHIFT) /* Linux-3.8+ */
mapflag|= my_bit_log2_size_t(large_page_size) << MAP_HUGE_SHIFT;
#else
# warning "No explicit large page (HUGETLB pages) support in Linux < 3.8"
#endif
#elif defined(MAP_ALIGNED)
mapflag|= MAP_ALIGNED(my_bit_log2_size_t(large_page_size));
#if defined(MAP_ALIGNED_SUPER)
mapflag|= MAP_ALIGNED_SUPER;
#endif
#endif
aligned_size= MY_ALIGN(*size, (size_t) large_page_size);
}
else
{
aligned_size= *size;
}
}
ptr= mmap(NULL, aligned_size, PROT_READ | PROT_WRITE, mapflag, -1, 0);
if (ptr == (void*) -1)
{
ptr= NULL;
if (my_flags & MY_WME)
{
if (large_page_size)
{
my_printf_error(EE_OUTOFMEMORY,
"Couldn't allocate %zu bytes (Large/HugeTLB memory "
"page size %zu); errno %u; continuing to smaller size",
MYF(ME_WARNING | ME_ERROR_LOG_ONLY),
aligned_size, large_page_size, errno);
}
else
{
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_ERROR_LOG), aligned_size);
}
}
/* try next smaller memory size */
if (large_page_size && errno == ENOMEM)
continue;
/* other errors are more serious */
break;
}
else /* success */
{
if (large_page_size)
{
/*
we do need to record the adjustment so that munmap gets called with
the right size. This is only the case for HUGETLB pages.
*/
*size= aligned_size;
}
break;
}
if (large_page_size == 0)
{
break; /* no more options to try */
}
}
#else
DBUG_RETURN(my_malloc_lock(*size, my_flags));
#endif /* defined(HAVE_MMAP) */
if (ptr != NULL)
{
MEM_MAKE_DEFINED(ptr, *size);
}
DBUG_RETURN(ptr);
} | O3 | c | my_large_malloc:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq (%rdi), %rbx
xorl %r14d, %r14d
xorl %r13d, %r13d
movl $0x22, %ecx
cmpb $0x1, 0x35221e(%rip) # 0x3b8fc0
jne 0x66df9
movq -0x30(%rbp), %rax
movq (%rax), %rbx
cmpl $0x9, %r14d
movl $0x8, %edx
cmovgel %r14d, %edx
cmpl $0x7, %r14d
jg 0x66df6
movslq %r14d, %rsi
leaq 0x352208(%rip), %rax # 0x3b8fd0
leaq (%rax,%rsi,8), %rdi
subq %rdx, %rsi
xorl %eax, %eax
movq (%rdi), %r13
testq %r13, %r13
je 0x66df3
cmpq %rbx, %r13
jbe 0x66e76
decq %rax
addq $0x8, %rdi
cmpq %rax, %rsi
jne 0x66dd1
movl %edx, %r14d
jmp 0x66df6
subl %eax, %r14d
xorl %r13d, %r13d
xorl %edi, %edi
movq %rbx, %rsi
movl $0x3, %edx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x283b0
cmpq $-0x1, %rax
jne 0x671ed
testb $0x10, %r15b
jne 0x66e34
testq %r13, %r13
je 0x671e8
callq 0x28050
movq %rax, %r12
jmp 0x66e66
testq %r13, %r13
je 0x671fe
callq 0x28050
movq %rax, %r12
movl (%rax), %r9d
movl $0x880, %edx # imm = 0x880
movl $0x5, %edi
leaq 0x348b7(%rip), %rsi # 0x9b710
movq %rbx, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x5c039
cmpl $0xc, (%r12)
je 0x66d96
jmp 0x671e8
movq %r13, %rcx
shrq $0x20, %rcx
jne 0x66eb3
cmpq $0x10000, %r13 # imm = 0x10000
jae 0x66eea
cmpq $0x100, %r13 # imm = 0x100
jae 0x66f4b
cmpq $0x10, %r13
jae 0x66fd9
cmpq $0x4, %r13
jae 0x67113
movl %r13d, %ecx
shrl %ecx
jmp 0x671c1
movq %r13, %rdx
shrq $0x30, %rdx
jne 0x66f1c
movq %r13, %rdx
shrq $0x28, %rdx
jne 0x66f70
movq %r13, %rdx
shrq $0x24, %rdx
jne 0x66ffd
movq %r13, %rdx
shrq $0x22, %rdx
jne 0x67124
shrl %ecx
jmp 0x671be
cmpq $0x1000000, %r13 # imm = 0x1000000
jae 0x66f92
cmpq $0x100000, %r13 # imm = 0x100000
jae 0x67028
cmpq $0x40000, %r13 # imm = 0x40000
jae 0x6713c
movl %r13d, %ecx
shrl $0x11, %ecx
jmp 0x671a0
movq %r13, %rdx
shrq $0x38, %rdx
jne 0x66fb7
movq %r13, %rdx
shrq $0x34, %rdx
jne 0x6704f
movq %r13, %rdx
shrq $0x32, %rdx
jne 0x6714d
shrl $0x11, %ecx
jmp 0x671bb
cmpq $0x1000, %r13 # imm = 0x1000
jae 0x6707a
cmpq $0x400, %r13 # imm = 0x400
jae 0x67162
movl %r13d, %ecx
shrl $0x9, %ecx
jmp 0x67171
movq %r13, %rdx
shrq $0x2c, %rdx
jne 0x670a1
movq %r13, %rdx
shrq $0x2a, %rdx
jne 0x67176
shrl $0x9, %ecx
jmp 0x67189
cmpq $0x10000000, %r13 # imm = 0x10000000
jae 0x670cc
cmpq $0x4000000, %r13 # imm = 0x4000000
jae 0x6718e
movl %r13d, %ecx
shrl $0x19, %ecx
jmp 0x6719d
movq %r13, %rdx
shrq $0x3c, %rdx
jne 0x670ef
movq %r13, %rdx
shrq $0x3a, %rdx
jne 0x671a5
shrl $0x19, %ecx
jmp 0x671b8
cmpq $0x80, %r13
movl $0x3, %edx
sbbl $0x0, %edx
movl %r13d, %ecx
shrl $0x5, %ecx
cmpq $0x40, %r13
cmovael %edx, %ecx
orl $0x4, %ecx
jmp 0x671c1
movq %r13, %rdx
shrq $0x26, %rdx
movq %r13, %rsi
shrq $0x27, %rsi
cmpq $0x1, %rsi
movl $0x3, %esi
sbbl $0x0, %esi
shrl $0x5, %ecx
testq %rdx, %rdx
cmovnel %esi, %ecx
orl $0x4, %ecx
jmp 0x671be
cmpq $0x800000, %r13 # imm = 0x800000
movl $0x3, %edx
sbbl $0x0, %edx
movl %r13d, %ecx
shrl $0x15, %ecx
cmpq $0x400000, %r13 # imm = 0x400000
cmovael %edx, %ecx
orl $0x4, %ecx
jmp 0x671a0
movq %r13, %rdx
shrq $0x36, %rdx
movq %r13, %rsi
shrq $0x37, %rsi
cmpq $0x1, %rsi
movl $0x3, %esi
sbbl $0x0, %esi
shrl $0x15, %ecx
testq %rdx, %rdx
cmovnel %esi, %ecx
orl $0x4, %ecx
jmp 0x671bb
cmpq $0x8000, %r13 # imm = 0x8000
movl $0x3, %edx
sbbl $0x0, %edx
movl %r13d, %ecx
shrl $0xd, %ecx
cmpq $0x4000, %r13 # imm = 0x4000
cmovael %edx, %ecx
orl $0x4, %ecx
jmp 0x67171
movq %r13, %rdx
shrq $0x2e, %rdx
movq %r13, %rsi
shrq $0x2f, %rsi
cmpq $0x1, %rsi
movl $0x3, %esi
sbbl $0x0, %esi
shrl $0xd, %ecx
testq %rdx, %rdx
cmovnel %esi, %ecx
orl $0x4, %ecx
jmp 0x67189
movl %r13d, %edx
notl %edx
shrl $0x1f, %edx
xorl $0x3, %edx
movl %r13d, %ecx
shrl $0x1d, %ecx
cmpq $0x40000000, %r13 # imm = 0x40000000
cmovael %edx, %ecx
orl $0x4, %ecx
jmp 0x6719d
movq %r13, %rdx
shrq $0x3e, %rdx
xorl %esi, %esi
testq %r13, %r13
setns %sil
xorl $0x3, %esi
shrl $0x1d, %ecx
testq %rdx, %rdx
cmovnel %esi, %ecx
orl $0x4, %ecx
jmp 0x671b8
cmpq $0x8, %r13
movl $0x3, %ecx
sbbl $0x0, %ecx
jmp 0x671c1
movq %r13, %rcx
shrq $0x23, %rcx
cmpq $0x1, %rcx
movl $0x3, %ecx
sbbl $0x0, %ecx
jmp 0x671be
cmpq $0x80000, %r13 # imm = 0x80000
movl $0x3, %ecx
sbbl $0x0, %ecx
jmp 0x671a0
movq %r13, %rcx
shrq $0x33, %rcx
cmpq $0x1, %rcx
movl $0x3, %ecx
sbbl $0x0, %ecx
jmp 0x671bb
cmpq $0x800, %r13 # imm = 0x800
movl $0x3, %ecx
sbbl $0x0, %ecx
addl $0x8, %ecx
jmp 0x671c1
movq %r13, %rcx
shrq $0x2b, %rcx
cmpq $0x1, %rcx
movl $0x3, %ecx
sbbl $0x0, %ecx
addl $0x8, %ecx
jmp 0x671be
cmpq $0x8000000, %r13 # imm = 0x8000000
movl $0x3, %ecx
sbbl $0x0, %ecx
addl $0x8, %ecx
addl $0x10, %ecx
jmp 0x671c1
movq %r13, %rcx
shrq $0x3b, %rcx
cmpq $0x1, %rcx
movl $0x3, %ecx
sbbl $0x0, %ecx
addl $0x8, %ecx
addl $0x10, %ecx
addl $0x20, %ecx
movl %r14d, %r14d
subq %rax, %r14
incq %r14
shll $0x1a, %ecx
orl $0x40022, %ecx # imm = 0x40022
leaq (%rbx,%r13), %rax
decq %rax
movq %r13, %rbx
negq %rbx
andq %rax, %rbx
jmp 0x66df9
xorl %r12d, %r12d
jmp 0x67215
movq %rax, %r12
testq %r13, %r13
je 0x67215
movq -0x30(%rbp), %rax
movq %rbx, (%rax)
jmp 0x67215
xorl %r12d, %r12d
movl $0x44, %esi
movl $0x5, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x5bf1f
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_large_malloc:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rsi
mov [rbp+var_30], rdi
mov rbx, [rdi]
xor r14d, r14d
xor r13d, r13d
loc_66D96:
mov ecx, 22h ; '"'
cmp cs:my_use_large_pages, 1
jnz short loc_66DF9
mov rax, [rbp+var_30]
mov rbx, [rax]
cmp r14d, 9
mov edx, 8
cmovge edx, r14d
cmp r14d, 7
jg short loc_66DF6
movsxd rsi, r14d
lea rax, my_large_page_sizes
lea rdi, [rax+rsi*8]
sub rsi, rdx
xor eax, eax
loc_66DD1:
mov r13, [rdi]
test r13, r13
jz short loc_66DF3
cmp r13, rbx
jbe loc_66E76
dec rax
add rdi, 8
cmp rsi, rax
jnz short loc_66DD1
mov r14d, edx
jmp short loc_66DF6
loc_66DF3:
sub r14d, eax
loc_66DF6:
xor r13d, r13d
loc_66DF9:
xor edi, edi
mov rsi, rbx
mov edx, 3
mov r8d, 0FFFFFFFFh
xor r9d, r9d
call _mmap64
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz loc_671ED
test r15b, 10h
jnz short loc_66E34
test r13, r13
jz loc_671E8
call ___errno_location
mov r12, rax
jmp short loc_66E66
loc_66E34:
test r13, r13
jz loc_671FE
call ___errno_location
mov r12, rax
mov r9d, [rax]
mov edx, 880h
mov edi, 5
lea rsi, aCouldnTAllocat; "Couldn't allocate %zu bytes (Large/Huge"...
mov rcx, rbx
mov r8, r13
xor eax, eax
call my_printf_error
loc_66E66:
cmp dword ptr [r12], 0Ch
jz loc_66D96
jmp loc_671E8
loc_66E76:
mov rcx, r13
shr rcx, 20h
jnz short loc_66EB3
cmp r13, 10000h
jnb short loc_66EEA
cmp r13, 100h
jnb loc_66F4B
cmp r13, 10h
jnb loc_66FD9
cmp r13, 4
jnb loc_67113
mov ecx, r13d
shr ecx, 1
jmp loc_671C1
loc_66EB3:
mov rdx, r13
shr rdx, 30h
jnz short loc_66F1C
mov rdx, r13
shr rdx, 28h
jnz loc_66F70
mov rdx, r13
shr rdx, 24h
jnz loc_66FFD
mov rdx, r13
shr rdx, 22h
jnz loc_67124
shr ecx, 1
jmp loc_671BE
loc_66EEA:
cmp r13, 1000000h
jnb loc_66F92
cmp r13, offset unk_100000
jnb loc_67028
cmp r13, 40000h
jnb loc_6713C
mov ecx, r13d
shr ecx, 11h
jmp loc_671A0
loc_66F1C:
mov rdx, r13
shr rdx, 38h
jnz loc_66FB7
mov rdx, r13
shr rdx, 34h
jnz loc_6704F
mov rdx, r13
shr rdx, 32h
jnz loc_6714D
shr ecx, 11h
jmp loc_671BB
loc_66F4B:
cmp r13, 1000h
jnb loc_6707A
cmp r13, 400h
jnb loc_67162
mov ecx, r13d
shr ecx, 9
jmp loc_67171
loc_66F70:
mov rdx, r13
shr rdx, 2Ch
jnz loc_670A1
mov rdx, r13
shr rdx, 2Ah
jnz loc_67176
shr ecx, 9
jmp loc_67189
loc_66F92:
cmp r13, 10000000h
jnb loc_670CC
cmp r13, 4000000h
jnb loc_6718E
mov ecx, r13d
shr ecx, 19h
jmp loc_6719D
loc_66FB7:
mov rdx, r13
shr rdx, 3Ch
jnz loc_670EF
mov rdx, r13
shr rdx, 3Ah
jnz loc_671A5
shr ecx, 19h
jmp loc_671B8
loc_66FD9:
cmp r13, 80h
mov edx, 3
sbb edx, 0
mov ecx, r13d
shr ecx, 5
cmp r13, 40h ; '@'
cmovnb ecx, edx
or ecx, 4
jmp loc_671C1
loc_66FFD:
mov rdx, r13
shr rdx, 26h
mov rsi, r13
shr rsi, 27h
cmp rsi, 1
mov esi, 3
sbb esi, 0
shr ecx, 5
test rdx, rdx
cmovnz ecx, esi
or ecx, 4
jmp loc_671BE
loc_67028:
cmp r13, 800000h
mov edx, 3
sbb edx, 0
mov ecx, r13d
shr ecx, 15h
cmp r13, 400000h
cmovnb ecx, edx
or ecx, 4
jmp loc_671A0
loc_6704F:
mov rdx, r13
shr rdx, 36h
mov rsi, r13
shr rsi, 37h
cmp rsi, 1
mov esi, 3
sbb esi, 0
shr ecx, 15h
test rdx, rdx
cmovnz ecx, esi
or ecx, 4
jmp loc_671BB
loc_6707A:
cmp r13, 8000h
mov edx, 3
sbb edx, 0
mov ecx, r13d
shr ecx, 0Dh
cmp r13, 4000h
cmovnb ecx, edx
or ecx, 4
jmp loc_67171
loc_670A1:
mov rdx, r13
shr rdx, 2Eh
mov rsi, r13
shr rsi, 2Fh
cmp rsi, 1
mov esi, 3
sbb esi, 0
shr ecx, 0Dh
test rdx, rdx
cmovnz ecx, esi
or ecx, 4
jmp loc_67189
loc_670CC:
mov edx, r13d
not edx
shr edx, 1Fh
xor edx, 3
mov ecx, r13d
shr ecx, 1Dh
cmp r13, 40000000h
cmovnb ecx, edx
or ecx, 4
jmp loc_6719D
loc_670EF:
mov rdx, r13
shr rdx, 3Eh
xor esi, esi
test r13, r13
setns sil
xor esi, 3
shr ecx, 1Dh
test rdx, rdx
cmovnz ecx, esi
or ecx, 4
jmp loc_671B8
loc_67113:
cmp r13, 8
mov ecx, 3
sbb ecx, 0
jmp loc_671C1
loc_67124:
mov rcx, r13
shr rcx, 23h
cmp rcx, 1
mov ecx, 3
sbb ecx, 0
jmp loc_671BE
loc_6713C:
cmp r13, offset loc_80000
mov ecx, 3
sbb ecx, 0
jmp short loc_671A0
loc_6714D:
mov rcx, r13
shr rcx, 33h
cmp rcx, 1
mov ecx, 3
sbb ecx, 0
jmp short loc_671BB
loc_67162:
cmp r13, 800h
mov ecx, 3
sbb ecx, 0
loc_67171:
add ecx, 8
jmp short loc_671C1
loc_67176:
mov rcx, r13
shr rcx, 2Bh
cmp rcx, 1
mov ecx, 3
sbb ecx, 0
loc_67189:
add ecx, 8
jmp short loc_671BE
loc_6718E:
cmp r13, 8000000h
mov ecx, 3
sbb ecx, 0
loc_6719D:
add ecx, 8
loc_671A0:
add ecx, 10h
jmp short loc_671C1
loc_671A5:
mov rcx, r13
shr rcx, 3Bh
cmp rcx, 1
mov ecx, 3
sbb ecx, 0
loc_671B8:
add ecx, 8
loc_671BB:
add ecx, 10h
loc_671BE:
add ecx, 20h ; ' '
loc_671C1:
mov r14d, r14d
sub r14, rax
inc r14
shl ecx, 1Ah
or ecx, 40022h
lea rax, [rbx+r13]
dec rax
mov rbx, r13
neg rbx
and rbx, rax
jmp loc_66DF9
loc_671E8:
xor r12d, r12d
jmp short loc_67215
loc_671ED:
mov r12, rax
test r13, r13
jz short loc_67215
mov rax, [rbp+var_30]
mov [rax], rbx
jmp short loc_67215
loc_671FE:
xor r12d, r12d
mov esi, 44h ; 'D'
mov edi, 5
mov rdx, rbx
xor eax, eax
call my_error
loc_67215:
mov rax, r12
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_large_malloc(
unsigned long long *a1,
char a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
unsigned long long v10; // rbx
int v11; // r14d
unsigned long long v12; // r13
long long v13; // rcx
long long v14; // rdx
unsigned long long *v15; // rdi
long long v16; // rax
long long v17; // rax
_DWORD *v18; // r12
__m128 v19; // xmm4
__m128 v20; // xmm5
int v21; // ecx
int v22; // ecx
int v23; // ecx
int v24; // ecx
int v25; // ecx
int v26; // ecx
int v27; // ecx
int v28; // ecx
unsigned int v29; // ecx
int v30; // ecx
unsigned int v31; // ecx
int v32; // ecx
unsigned int v33; // ecx
int v34; // ecx
unsigned int v35; // ecx
int v36; // ecx
long long v37; // r12
unsigned long long *v39; // [rsp+0h] [rbp-30h]
v39 = a1;
v10 = *a1;
v11 = 0;
v12 = 0LL;
while ( 1 )
{
v13 = 34LL;
if ( my_use_large_pages == 1 )
{
v10 = *v39;
v14 = 8LL;
if ( v11 >= 9 )
v14 = (unsigned int)v11;
if ( v11 > 7 )
{
LABEL_12:
v12 = 0LL;
}
else
{
v15 = &my_large_page_sizes[v11];
v16 = 0LL;
while ( 1 )
{
v12 = *v15;
if ( !*v15 )
{
v11 -= v16;
goto LABEL_12;
}
if ( v12 <= v10 )
break;
--v16;
++v15;
if ( v11 - v14 == v16 )
{
v11 = v14;
goto LABEL_12;
}
}
if ( HIDWORD(v12) )
{
if ( HIWORD(v12) )
{
if ( HIBYTE(v12) )
{
if ( v12 >> 60 )
{
v36 = HIDWORD(v12) >> 29;
if ( v12 >> 62 )
v36 = ((v12 & 0x8000000000000000LL) == 0LL) ^ 3;
v28 = v36 | 4;
}
else if ( v12 >> 58 )
{
v28 = 3 - (v12 >> 59 == 0);
}
else
{
v28 = HIDWORD(v12) >> 25;
}
v24 = v28 + 8;
}
else if ( v12 >> 52 )
{
v32 = HIDWORD(v12) >> 21;
if ( v12 >> 54 )
v32 = 3 - (v12 >> 55 == 0);
v24 = v32 | 4;
}
else if ( v12 >> 50 )
{
v24 = 3 - (v12 >> 51 == 0);
}
else
{
v24 = HIDWORD(v12) >> 17;
}
v22 = v24 + 16;
}
else if ( v12 >> 40 )
{
if ( v12 >> 44 )
{
v34 = HIDWORD(v12) >> 13;
if ( v12 >> 46 )
v34 = 3 - (v12 >> 47 == 0);
v26 = v34 | 4;
}
else if ( v12 >> 42 )
{
v26 = 3 - (v12 >> 43 == 0);
}
else
{
v26 = HIDWORD(v12) >> 9;
}
v22 = v26 + 8;
}
else if ( v12 >> 36 )
{
v30 = HIDWORD(v12) >> 5;
if ( v12 >> 38 )
v30 = 3 - (v12 >> 39 == 0);
v22 = v30 | 4;
}
else if ( v12 >> 34 )
{
v22 = 3 - (v12 >> 35 == 0);
}
else
{
v22 = HIDWORD(v12) >> 1;
}
v21 = v22 + 32;
}
else if ( v12 >= 0x10000 )
{
if ( v12 >= 0x1000000 )
{
if ( v12 >= 0x10000000 )
{
v35 = (unsigned int)v12 >> 29;
if ( v12 >= 0x40000000 )
v35 = ((v12 & 0x80000000) == 0LL) ^ 3;
v27 = v35 | 4;
}
else if ( v12 >= 0x4000000 )
{
v27 = 3 - (v12 < 0x8000000);
}
else
{
v27 = (unsigned int)v12 >> 25;
}
v23 = v27 + 8;
}
else if ( v12 >= (unsigned long long)&unk_100000 )
{
v31 = (unsigned int)v12 >> 21;
if ( v12 >= 0x400000 )
v31 = 3 - (v12 < 0x800000);
v23 = v31 | 4;
}
else if ( v12 >= 0x40000 )
{
v23 = 3 - (v12 < (unsigned long long)&loc_80000);
}
else
{
v23 = (unsigned int)v12 >> 17;
}
v21 = v23 + 16;
}
else if ( v12 >= 0x100 )
{
if ( v12 >= 0x1000 )
{
v33 = (unsigned int)v12 >> 13;
if ( v12 >= 0x4000 )
v33 = 3 - (v12 < 0x8000);
v25 = v33 | 4;
}
else if ( v12 >= 0x400 )
{
v25 = 3 - (v12 < 0x800);
}
else
{
v25 = (unsigned int)v12 >> 9;
}
v21 = v25 + 8;
}
else if ( v12 >= 0x10 )
{
v29 = (unsigned int)v12 >> 5;
if ( v12 >= 0x40 )
v29 = 3 - (v12 < 0x80);
v21 = v29 | 4;
}
else if ( v12 >= 4 )
{
v21 = 3 - (v12 < 8);
}
else
{
v21 = (unsigned int)v12 >> 1;
}
v11 = v11 - v16 + 1;
v13 = (v21 << 26) | 0x40022u;
v10 = (v10 + v12 - 1) & -(long long)v12;
}
}
v17 = mmap64(0LL, v10, 3LL, v13, 0xFFFFFFFFLL, 0LL, v39);
if ( v17 != -1 )
break;
if ( (a2 & 0x10) != 0 )
{
if ( !v12 )
{
v37 = 0LL;
my_error(5u, 68LL, v10);
return v37;
}
v18 = (_DWORD *)__errno_location(0LL);
my_printf_error(
a3,
a4,
a5,
a6,
v19,
v20,
a9,
a10,
5LL,
(long long)"Couldn't allocate %zu bytes (Large/HugeTLB memory page size %zu); errno %u; continuing to smaller size",
2176LL,
v10,
v12,
(unsigned int)*v18,
(char)v39);
}
else
{
if ( !v12 )
return 0LL;
v18 = (_DWORD *)__errno_location(0LL);
}
if ( *v18 != 12 )
return 0LL;
}
v37 = v17;
if ( v12 )
*v39 = v10;
return v37;
}
| my_large_malloc:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV qword ptr [RBP + -0x30],RDI
MOV RBX,qword ptr [RDI]
XOR R14D,R14D
XOR R13D,R13D
LAB_00166d96:
MOV ECX,0x22
CMP byte ptr [0x004b8fc0],0x1
JNZ 0x00166df9
MOV RAX,qword ptr [RBP + -0x30]
MOV RBX,qword ptr [RAX]
CMP R14D,0x9
MOV EDX,0x8
CMOVGE EDX,R14D
CMP R14D,0x7
JG 0x00166df6
MOVSXD RSI,R14D
LEA RAX,[0x4b8fd0]
LEA RDI,[RAX + RSI*0x8]
SUB RSI,RDX
XOR EAX,EAX
LAB_00166dd1:
MOV R13,qword ptr [RDI]
TEST R13,R13
JZ 0x00166df3
CMP R13,RBX
JBE 0x00166e76
DEC RAX
ADD RDI,0x8
CMP RSI,RAX
JNZ 0x00166dd1
MOV R14D,EDX
JMP 0x00166df6
LAB_00166df3:
SUB R14D,EAX
LAB_00166df6:
XOR R13D,R13D
LAB_00166df9:
XOR EDI,EDI
MOV RSI,RBX
MOV EDX,0x3
MOV R8D,0xffffffff
XOR R9D,R9D
CALL 0x001283b0
CMP RAX,-0x1
JNZ 0x001671ed
TEST R15B,0x10
JNZ 0x00166e34
TEST R13,R13
JZ 0x001671e8
CALL 0x00128050
MOV R12,RAX
JMP 0x00166e66
LAB_00166e34:
TEST R13,R13
JZ 0x001671fe
CALL 0x00128050
MOV R12,RAX
MOV R9D,dword ptr [RAX]
MOV EDX,0x880
MOV EDI,0x5
LEA RSI,[0x19b710]
MOV RCX,RBX
MOV R8,R13
XOR EAX,EAX
CALL 0x0015c039
LAB_00166e66:
CMP dword ptr [R12],0xc
JZ 0x00166d96
JMP 0x001671e8
LAB_00166e76:
MOV RCX,R13
SHR RCX,0x20
JNZ 0x00166eb3
CMP R13,0x10000
JNC 0x00166eea
CMP R13,0x100
JNC 0x00166f4b
CMP R13,0x10
JNC 0x00166fd9
CMP R13,0x4
JNC 0x00167113
MOV ECX,R13D
SHR ECX,0x1
JMP 0x001671c1
LAB_00166eb3:
MOV RDX,R13
SHR RDX,0x30
JNZ 0x00166f1c
MOV RDX,R13
SHR RDX,0x28
JNZ 0x00166f70
MOV RDX,R13
SHR RDX,0x24
JNZ 0x00166ffd
MOV RDX,R13
SHR RDX,0x22
JNZ 0x00167124
SHR ECX,0x1
JMP 0x001671be
LAB_00166eea:
CMP R13,0x1000000
JNC 0x00166f92
CMP R13,0x100000
JNC 0x00167028
CMP R13,0x40000
JNC 0x0016713c
MOV ECX,R13D
SHR ECX,0x11
JMP 0x001671a0
LAB_00166f1c:
MOV RDX,R13
SHR RDX,0x38
JNZ 0x00166fb7
MOV RDX,R13
SHR RDX,0x34
JNZ 0x0016704f
MOV RDX,R13
SHR RDX,0x32
JNZ 0x0016714d
SHR ECX,0x11
JMP 0x001671bb
LAB_00166f4b:
CMP R13,0x1000
JNC 0x0016707a
CMP R13,0x400
JNC 0x00167162
MOV ECX,R13D
SHR ECX,0x9
JMP 0x00167171
LAB_00166f70:
MOV RDX,R13
SHR RDX,0x2c
JNZ 0x001670a1
MOV RDX,R13
SHR RDX,0x2a
JNZ 0x00167176
SHR ECX,0x9
JMP 0x00167189
LAB_00166f92:
CMP R13,0x10000000
JNC 0x001670cc
CMP R13,0x4000000
JNC 0x0016718e
MOV ECX,R13D
SHR ECX,0x19
JMP 0x0016719d
LAB_00166fb7:
MOV RDX,R13
SHR RDX,0x3c
JNZ 0x001670ef
MOV RDX,R13
SHR RDX,0x3a
JNZ 0x001671a5
SHR ECX,0x19
JMP 0x001671b8
LAB_00166fd9:
CMP R13,0x80
MOV EDX,0x3
SBB EDX,0x0
MOV ECX,R13D
SHR ECX,0x5
CMP R13,0x40
CMOVNC ECX,EDX
OR ECX,0x4
JMP 0x001671c1
LAB_00166ffd:
MOV RDX,R13
SHR RDX,0x26
MOV RSI,R13
SHR RSI,0x27
CMP RSI,0x1
MOV ESI,0x3
SBB ESI,0x0
SHR ECX,0x5
TEST RDX,RDX
CMOVNZ ECX,ESI
OR ECX,0x4
JMP 0x001671be
LAB_00167028:
CMP R13,0x800000
MOV EDX,0x3
SBB EDX,0x0
MOV ECX,R13D
SHR ECX,0x15
CMP R13,0x400000
CMOVNC ECX,EDX
OR ECX,0x4
JMP 0x001671a0
LAB_0016704f:
MOV RDX,R13
SHR RDX,0x36
MOV RSI,R13
SHR RSI,0x37
CMP RSI,0x1
MOV ESI,0x3
SBB ESI,0x0
SHR ECX,0x15
TEST RDX,RDX
CMOVNZ ECX,ESI
OR ECX,0x4
JMP 0x001671bb
LAB_0016707a:
CMP R13,0x8000
MOV EDX,0x3
SBB EDX,0x0
MOV ECX,R13D
SHR ECX,0xd
CMP R13,0x4000
CMOVNC ECX,EDX
OR ECX,0x4
JMP 0x00167171
LAB_001670a1:
MOV RDX,R13
SHR RDX,0x2e
MOV RSI,R13
SHR RSI,0x2f
CMP RSI,0x1
MOV ESI,0x3
SBB ESI,0x0
SHR ECX,0xd
TEST RDX,RDX
CMOVNZ ECX,ESI
OR ECX,0x4
JMP 0x00167189
LAB_001670cc:
MOV EDX,R13D
NOT EDX
SHR EDX,0x1f
XOR EDX,0x3
MOV ECX,R13D
SHR ECX,0x1d
CMP R13,0x40000000
CMOVNC ECX,EDX
OR ECX,0x4
JMP 0x0016719d
LAB_001670ef:
MOV RDX,R13
SHR RDX,0x3e
XOR ESI,ESI
TEST R13,R13
SETNS SIL
XOR ESI,0x3
SHR ECX,0x1d
TEST RDX,RDX
CMOVNZ ECX,ESI
OR ECX,0x4
JMP 0x001671b8
LAB_00167113:
CMP R13,0x8
MOV ECX,0x3
SBB ECX,0x0
JMP 0x001671c1
LAB_00167124:
MOV RCX,R13
SHR RCX,0x23
CMP RCX,0x1
MOV ECX,0x3
SBB ECX,0x0
JMP 0x001671be
LAB_0016713c:
CMP R13,0x80000
MOV ECX,0x3
SBB ECX,0x0
JMP 0x001671a0
LAB_0016714d:
MOV RCX,R13
SHR RCX,0x33
CMP RCX,0x1
MOV ECX,0x3
SBB ECX,0x0
JMP 0x001671bb
LAB_00167162:
CMP R13,0x800
MOV ECX,0x3
SBB ECX,0x0
LAB_00167171:
ADD ECX,0x8
JMP 0x001671c1
LAB_00167176:
MOV RCX,R13
SHR RCX,0x2b
CMP RCX,0x1
MOV ECX,0x3
SBB ECX,0x0
LAB_00167189:
ADD ECX,0x8
JMP 0x001671be
LAB_0016718e:
CMP R13,0x8000000
MOV ECX,0x3
SBB ECX,0x0
LAB_0016719d:
ADD ECX,0x8
LAB_001671a0:
ADD ECX,0x10
JMP 0x001671c1
LAB_001671a5:
MOV RCX,R13
SHR RCX,0x3b
CMP RCX,0x1
MOV ECX,0x3
SBB ECX,0x0
LAB_001671b8:
ADD ECX,0x8
LAB_001671bb:
ADD ECX,0x10
LAB_001671be:
ADD ECX,0x20
LAB_001671c1:
MOV R14D,R14D
SUB R14,RAX
INC R14
SHL ECX,0x1a
OR ECX,0x40022
LEA RAX,[RBX + R13*0x1]
DEC RAX
MOV RBX,R13
NEG RBX
AND RBX,RAX
JMP 0x00166df9
LAB_001671e8:
XOR R12D,R12D
JMP 0x00167215
LAB_001671ed:
MOV R12,RAX
TEST R13,R13
JZ 0x00167215
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RBX
JMP 0x00167215
LAB_001671fe:
XOR R12D,R12D
MOV ESI,0x44
MOV EDI,0x5
MOV RDX,RBX
XOR EAX,EAX
CALL 0x0015bf1f
LAB_00167215:
MOV RAX,R12
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void * my_large_malloc(ulong *param_1,ulong param_2)
{
long lVar1;
void *pvVar2;
int *piVar3;
uint uVar4;
ulong uVar5;
ulong __len;
ulong *puVar6;
ulong uVar7;
int iVar8;
ulong uVar9;
__len = *param_1;
uVar9 = 0;
uVar7 = 0;
do {
uVar4 = 0x22;
if (my_use_large_pages == '\x01') {
__len = *param_1;
iVar8 = (int)uVar9;
uVar5 = 8;
if (8 < iVar8) {
uVar5 = uVar9 & 0xffffffff;
}
uVar7 = uVar9;
if (iVar8 < 8) {
puVar6 = &my_large_page_sizes + iVar8;
lVar1 = 0;
do {
uVar7 = *puVar6;
if (uVar7 == 0) {
uVar7 = (ulong)(uint)(iVar8 - (int)lVar1);
break;
}
if (uVar7 <= __len) {
if (uVar7 >> 0x20 == 0) {
if (uVar7 < 0x10000) {
if (uVar7 < 0x100) {
if (uVar7 < 0x10) {
if (uVar7 < 4) {
uVar4 = (uint)(uVar7 >> 1) & 0x7fffffff;
}
else {
uVar4 = 3 - (uVar7 < 8);
}
}
else {
uVar4 = (uint)(uVar7 >> 5) & 0x7ffffff;
if (0x3f < uVar7) {
uVar4 = 3 - (uVar7 < 0x80);
}
uVar4 = uVar4 | 4;
}
}
else {
if (uVar7 < 0x1000) {
if (uVar7 < 0x400) {
uVar4 = (uint)(uVar7 >> 9) & 0x7fffff;
}
else {
uVar4 = 3 - (uVar7 < 0x800);
}
}
else {
uVar4 = (uint)(uVar7 >> 0xd) & 0x7ffff;
if (0x3fff < uVar7) {
uVar4 = 3 - (uVar7 < 0x8000);
}
uVar4 = uVar4 | 4;
}
uVar4 = uVar4 + 8;
}
}
else {
if (uVar7 < 0x1000000) {
if (uVar7 < 0x100000) {
if (uVar7 < 0x40000) {
uVar4 = (uint)(uVar7 >> 0x11) & 0x7fff;
}
else {
uVar4 = 3 - (uVar7 < 0x80000);
}
}
else {
uVar4 = (uint)(uVar7 >> 0x15) & 0x7ff;
if (0x3fffff < uVar7) {
uVar4 = 3 - (uVar7 < 0x800000);
}
uVar4 = uVar4 | 4;
}
}
else {
if (uVar7 < 0x10000000) {
if (uVar7 < 0x4000000) {
uVar4 = (uint)(uVar7 >> 0x19) & 0x7f;
}
else {
uVar4 = 3 - (uVar7 < 0x8000000);
}
}
else {
uVar4 = (uint)(uVar7 >> 0x1d) & 7;
if (0x3fffffff < uVar7) {
uVar4 = ~(uint)uVar7 >> 0x1f ^ 3;
}
uVar4 = uVar4 | 4;
}
uVar4 = uVar4 + 8;
}
uVar4 = uVar4 + 0x10;
}
}
else {
uVar4 = (uint)(uVar7 >> 0x20);
if (uVar7 >> 0x30 == 0) {
if (uVar7 >> 0x28 == 0) {
if (uVar7 >> 0x24 == 0) {
if (uVar7 >> 0x22 == 0) {
uVar4 = uVar4 >> 1;
}
else {
uVar4 = 3 - (uVar7 >> 0x23 == 0);
}
}
else {
uVar4 = uVar4 >> 5;
if (uVar7 >> 0x26 != 0) {
uVar4 = 3 - (uVar7 >> 0x27 == 0);
}
uVar4 = uVar4 | 4;
}
}
else {
if (uVar7 >> 0x2c == 0) {
if (uVar7 >> 0x2a == 0) {
uVar4 = uVar4 >> 9;
}
else {
uVar4 = 3 - (uVar7 >> 0x2b == 0);
}
}
else {
uVar4 = uVar4 >> 0xd;
if (uVar7 >> 0x2e != 0) {
uVar4 = 3 - (uVar7 >> 0x2f == 0);
}
uVar4 = uVar4 | 4;
}
uVar4 = uVar4 + 8;
}
}
else {
if (uVar7 >> 0x38 == 0) {
if (uVar7 >> 0x34 == 0) {
if (uVar7 >> 0x32 == 0) {
uVar4 = uVar4 >> 0x11;
}
else {
uVar4 = 3 - (uVar7 >> 0x33 == 0);
}
}
else {
uVar4 = uVar4 >> 0x15;
if (uVar7 >> 0x36 != 0) {
uVar4 = 3 - (uVar7 >> 0x37 == 0);
}
uVar4 = uVar4 | 4;
}
}
else {
if (uVar7 >> 0x3c == 0) {
if (uVar7 >> 0x3a == 0) {
uVar4 = uVar4 >> 0x19;
}
else {
uVar4 = 3 - (uVar7 >> 0x3b == 0);
}
}
else {
uVar4 = uVar4 >> 0x1d;
if (uVar7 >> 0x3e != 0) {
uVar4 = -1 < (long)uVar7 ^ 3;
}
uVar4 = uVar4 | 4;
}
uVar4 = uVar4 + 8;
}
uVar4 = uVar4 + 0x10;
}
uVar4 = uVar4 + 0x20;
}
uVar9 = ((uVar9 & 0xffffffff) - lVar1) + 1;
uVar4 = uVar4 << 0x1a | 0x40022;
__len = -uVar7 & (__len + uVar7) - 1;
goto LAB_00166df9;
}
lVar1 = lVar1 + -1;
puVar6 = puVar6 + 1;
uVar7 = uVar5;
} while ((long)iVar8 - uVar5 != lVar1);
}
uVar9 = uVar7;
uVar7 = 0;
}
LAB_00166df9:
pvVar2 = mmap64((void *)0x0,__len,3,uVar4,-1,0);
if (pvVar2 != (void *)0xffffffffffffffff) {
if (uVar7 != 0) {
*param_1 = __len;
return pvVar2;
}
return pvVar2;
}
if ((param_2 & 0x10) == 0) {
if (uVar7 == 0) {
return (void *)0x0;
}
piVar3 = __errno_location();
}
else {
if (uVar7 == 0) {
my_error(5,0x44,__len);
return (void *)0x0;
}
piVar3 = __errno_location();
my_printf_error(5,
"Couldn\'t allocate %zu bytes (Large/HugeTLB memory page size %zu); errno %u; continuing to smaller size"
,0x880,__len,uVar7);
}
if (*piVar3 != 0xc) {
return (void *)0x0;
}
} while( true );
}
| |
26,388 | my_strntoull10rnd_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static ulonglong
my_strntoull10rnd_mb2_or_mb4(CHARSET_INFO *cs,
const char *nptr, size_t length,
int unsign_fl,
char **endptr, int *err)
{
char buf[256], *b= buf;
ulonglong res;
const uchar *end, *s= (const uchar*) nptr;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
int cnv;
/* Cut too long strings */
if (length >= sizeof(buf))
length= sizeof(buf)-1;
end= s + length;
while ((cnv= mb_wc(cs, &wc, s, end)) > 0)
{
s+= cnv;
if (wc > (int) (uchar) 'e' || !wc)
break; /* Can't be a number part */
*b++= (char) wc;
}
res= my_strntoull10rnd_8bit(cs, buf, b - buf, unsign_fl, endptr, err);
*endptr= (char*) nptr + cs->mbminlen * (size_t) (*endptr - buf);
return res;
} | O0 | c | my_strntoull10rnd_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x118(%rbp)
movq %rsi, -0x120(%rbp)
movq %rdx, -0x128(%rbp)
movl %ecx, -0x12c(%rbp)
movq %r8, -0x138(%rbp)
movq %r9, -0x140(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x120(%rbp), %rax
movq %rax, -0x160(%rbp)
movq -0x118(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x170(%rbp)
cmpq $0x100, -0x128(%rbp) # imm = 0x100
jb 0xae26e
movq $0xff, -0x128(%rbp)
movq -0x160(%rbp), %rax
addq -0x128(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x170(%rbp), %rax
movq -0x118(%rbp), %rdi
movq -0x160(%rbp), %rdx
movq -0x158(%rbp), %rcx
leaq -0x168(%rbp), %rsi
callq *%rax
movl %eax, -0x174(%rbp)
cmpl $0x0, %eax
jle 0xae308
movl -0x174(%rbp), %ecx
movq -0x160(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x160(%rbp)
cmpq $0x65, -0x168(%rbp)
ja 0xae2e1
cmpq $0x0, -0x168(%rbp)
jne 0xae2e3
jmp 0xae308
movq -0x168(%rbp), %rax
movb %al, %cl
movq -0x148(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x148(%rbp)
movb %cl, (%rax)
jmp 0xae283
movq -0x118(%rbp), %rdi
movq -0x148(%rbp), %rdx
leaq -0x110(%rbp), %rsi
movq %rsi, -0x188(%rbp)
subq %rsi, %rdx
movl -0x12c(%rbp), %ecx
movq -0x138(%rbp), %r8
movq -0x140(%rbp), %r9
callq 0x98b80
movq -0x188(%rbp), %rdi
movq %rax, -0x150(%rbp)
movq -0x120(%rbp), %rcx
movq -0x118(%rbp), %rax
movl 0x98(%rax), %eax
movl %eax, %edx
movq -0x138(%rbp), %rax
movq (%rax), %rsi
subq %rdi, %rsi
imulq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x150(%rbp), %rax
movq %rax, -0x180(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xae3ab
movq -0x180(%rbp), %rax
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
callq 0x372c0
| my_strntoull10rnd_mb2_or_mb4:
push rbp
mov rbp, rsp
sub rsp, 190h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_118], rdi
mov [rbp+var_120], rsi
mov [rbp+var_128], rdx
mov [rbp+var_12C], ecx
mov [rbp+var_138], r8
mov [rbp+var_140], r9
lea rax, [rbp+var_110]
mov [rbp+var_148], rax
mov rax, [rbp+var_120]
mov [rbp+var_160], rax
mov rax, [rbp+var_118]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov [rbp+var_170], rax
cmp [rbp+var_128], 100h
jb short loc_AE26E
mov [rbp+var_128], 0FFh
loc_AE26E:
mov rax, [rbp+var_160]
add rax, [rbp+var_128]
mov [rbp+var_158], rax
loc_AE283:
mov rax, [rbp+var_170]
mov rdi, [rbp+var_118]
mov rdx, [rbp+var_160]
mov rcx, [rbp+var_158]
lea rsi, [rbp+var_168]
call rax
mov [rbp+var_174], eax
cmp eax, 0
jle short loc_AE308
mov ecx, [rbp+var_174]
mov rax, [rbp+var_160]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_160], rax
cmp [rbp+var_168], 65h ; 'e'
ja short loc_AE2E1
cmp [rbp+var_168], 0
jnz short loc_AE2E3
loc_AE2E1:
jmp short loc_AE308
loc_AE2E3:
mov rax, [rbp+var_168]
mov cl, al
mov rax, [rbp+var_148]
mov rdx, rax
add rdx, 1
mov [rbp+var_148], rdx
mov [rax], cl
jmp loc_AE283
loc_AE308:
mov rdi, [rbp+var_118]
mov rdx, [rbp+var_148]
lea rsi, [rbp+var_110]
mov [rbp+var_188], rsi
sub rdx, rsi
mov ecx, [rbp+var_12C]
mov r8, [rbp+var_138]
mov r9, [rbp+var_140]
call my_strntoull10rnd_8bit
mov rdi, [rbp+var_188]
mov [rbp+var_150], rax
mov rcx, [rbp+var_120]
mov rax, [rbp+var_118]
mov eax, [rax+98h]
mov edx, eax
mov rax, [rbp+var_138]
mov rsi, [rax]
sub rsi, rdi
imul rdx, rsi
add rcx, rdx
mov [rax], rcx
mov rax, [rbp+var_150]
mov [rbp+var_180], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_AE3AB
mov rax, [rbp+var_180]
add rsp, 190h
pop rbp
retn
loc_AE3AB:
call ___stack_chk_fail
| long long my_strntoull10rnd_mb2_or_mb4(
long long a1,
long long a2,
unsigned long long a3,
int a4,
_QWORD *a5,
int *a6)
{
_BYTE *v6; // rax
int v8; // [rsp+1Ch] [rbp-174h]
long long ( *v9)(long long, unsigned long long *, long long, long long); // [rsp+20h] [rbp-170h]
unsigned long long v10; // [rsp+28h] [rbp-168h] BYREF
long long v11; // [rsp+30h] [rbp-160h]
long long v12; // [rsp+38h] [rbp-158h]
long long v13; // [rsp+40h] [rbp-150h]
_BYTE *v14; // [rsp+48h] [rbp-148h]
int *v15; // [rsp+50h] [rbp-140h]
_QWORD *v16; // [rsp+58h] [rbp-138h]
int v17; // [rsp+64h] [rbp-12Ch]
long long v18; // [rsp+68h] [rbp-128h]
long long v19; // [rsp+70h] [rbp-120h]
long long v20; // [rsp+78h] [rbp-118h]
_BYTE v21[264]; // [rsp+80h] [rbp-110h] BYREF
unsigned long long v22; // [rsp+188h] [rbp-8h]
v22 = __readfsqword(0x28u);
v20 = a1;
v19 = a2;
v18 = a3;
v17 = a4;
v16 = a5;
v15 = a6;
v14 = v21;
v11 = a2;
v9 = *(long long ( **)(long long, unsigned long long *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
if ( a3 >= 0x100 )
v18 = 255LL;
v12 = v18 + v11;
while ( 1 )
{
v8 = v9(v20, &v10, v11, v12);
if ( v8 <= 0 )
break;
v11 += v8;
if ( v10 > 0x65 || !v10 )
break;
v6 = v14++;
*v6 = v10;
}
v13 = my_strntoull10rnd_8bit(v20, v21, v14 - v21, v17, v16, v15);
*v16 = (*v16 - (_QWORD)v21) * *(unsigned int *)(v20 + 152) + v19;
return v13;
}
| my_strntoull10rnd_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x190
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x118],RDI
MOV qword ptr [RBP + -0x120],RSI
MOV qword ptr [RBP + -0x128],RDX
MOV dword ptr [RBP + -0x12c],ECX
MOV qword ptr [RBP + -0x138],R8
MOV qword ptr [RBP + -0x140],R9
LEA RAX,[RBP + -0x110]
MOV qword ptr [RBP + -0x148],RAX
MOV RAX,qword ptr [RBP + -0x120]
MOV qword ptr [RBP + -0x160],RAX
MOV RAX,qword ptr [RBP + -0x118]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x170],RAX
CMP qword ptr [RBP + -0x128],0x100
JC 0x001ae26e
MOV qword ptr [RBP + -0x128],0xff
LAB_001ae26e:
MOV RAX,qword ptr [RBP + -0x160]
ADD RAX,qword ptr [RBP + -0x128]
MOV qword ptr [RBP + -0x158],RAX
LAB_001ae283:
MOV RAX,qword ptr [RBP + -0x170]
MOV RDI,qword ptr [RBP + -0x118]
MOV RDX,qword ptr [RBP + -0x160]
MOV RCX,qword ptr [RBP + -0x158]
LEA RSI,[RBP + -0x168]
CALL RAX
MOV dword ptr [RBP + -0x174],EAX
CMP EAX,0x0
JLE 0x001ae308
MOV ECX,dword ptr [RBP + -0x174]
MOV RAX,qword ptr [RBP + -0x160]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x160],RAX
CMP qword ptr [RBP + -0x168],0x65
JA 0x001ae2e1
CMP qword ptr [RBP + -0x168],0x0
JNZ 0x001ae2e3
LAB_001ae2e1:
JMP 0x001ae308
LAB_001ae2e3:
MOV RAX,qword ptr [RBP + -0x168]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x148]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x148],RDX
MOV byte ptr [RAX],CL
JMP 0x001ae283
LAB_001ae308:
MOV RDI,qword ptr [RBP + -0x118]
MOV RDX,qword ptr [RBP + -0x148]
LEA RSI,[RBP + -0x110]
MOV qword ptr [RBP + -0x188],RSI
SUB RDX,RSI
MOV ECX,dword ptr [RBP + -0x12c]
MOV R8,qword ptr [RBP + -0x138]
MOV R9,qword ptr [RBP + -0x140]
CALL 0x00198b80
MOV RDI,qword ptr [RBP + -0x188]
MOV qword ptr [RBP + -0x150],RAX
MOV RCX,qword ptr [RBP + -0x120]
MOV RAX,qword ptr [RBP + -0x118]
MOV EAX,dword ptr [RAX + 0x98]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x138]
MOV RSI,qword ptr [RAX]
SUB RSI,RDI
IMUL RDX,RSI
ADD RCX,RDX
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x150]
MOV qword ptr [RBP + -0x180],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001ae3ab
MOV RAX,qword ptr [RBP + -0x180]
ADD RSP,0x190
POP RBP
RET
LAB_001ae3ab:
CALL 0x001372c0
|
int8
my_strntoull10rnd_mb2_or_mb4
(long param_1,long param_2,ulong param_3,int4 param_4,long *param_5,
int8 param_6)
{
code *pcVar1;
int iVar2;
long in_FS_OFFSET;
ulong local_170;
long local_168;
long local_160;
int8 local_158;
int1 *local_150;
int8 local_148;
long *local_140;
int4 local_134;
ulong local_130;
long local_128;
long local_120;
int1 local_118 [264];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
local_130 = param_3;
if (0xff < param_3) {
local_130 = 0xff;
}
local_160 = param_2 + local_130;
local_168 = param_2;
local_150 = local_118;
local_148 = param_6;
local_140 = param_5;
local_134 = param_4;
local_128 = param_2;
local_120 = param_1;
while (((iVar2 = (*pcVar1)(local_120,&local_170,local_168,local_160), 0 < iVar2 &&
(local_168 = local_168 + iVar2, local_170 < 0x66)) && (local_170 != 0))) {
*local_150 = (char)local_170;
local_150 = local_150 + 1;
}
local_158 = my_strntoull10rnd_8bit
(local_120,local_118,(long)local_150 - (long)local_118,local_134,local_140,
local_148);
*local_140 = local_128 + (ulong)*(uint *)(local_120 + 0x98) * (*local_140 - (long)local_118);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_158;
}
| |
26,389 | Item_ref::cleanup_excluding_fields_processor(void*) | eloqsql/sql/item.h | bool cleanup_excluding_fields_processor(void *arg) override
{
Item *item= real_item();
if (item && item->type() == FIELD_ITEM &&
((Item_field *)item)->field)
return 0;
return cleanup_processor(arg);
} | O0 | c | Item_ref::cleanup_excluding_fields_processor(void*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq (%rdi), %rax
callq *0x2f0(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x873822
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0xc8(%rax)
cmpl $0x0, %eax
jne 0x873822
movq -0x20(%rbp), %rax
cmpq $0x0, 0xf8(%rax)
je 0x873822
movb $0x0, -0x1(%rbp)
jmp 0x873838
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x330(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN8Item_ref34cleanup_excluding_fields_processorEPv:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]
mov [rbp+var_28], rdi
mov rax, [rdi]
call qword ptr [rax+2F0h]
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_873822
mov rdi, [rbp+var_20]
mov rax, [rdi]
call qword ptr [rax+0C8h]
cmp eax, 0
jnz short loc_873822
mov rax, [rbp+var_20]
cmp qword ptr [rax+0F8h], 0
jz short loc_873822
mov [rbp+var_1], 0
jmp short loc_873838
loc_873822:
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_18]
mov rax, [rdi]
call qword ptr [rax+330h]
and al, 1
mov [rbp+var_1], al
loc_873838:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
| char Item_ref::cleanup_excluding_fields_processor(Item_ref *this, void *a2)
{
_QWORD *v3; // [rsp+10h] [rbp-20h]
v3 = (_QWORD *)(*(long long ( **)(Item_ref *))(*(_QWORD *)this + 752LL))(this);
if ( v3 && !(*(unsigned int ( **)(_QWORD *))(*v3 + 200LL))(v3) && v3[31] )
return 0;
else
return (*(long long ( **)(Item_ref *, void *))(*(_QWORD *)this + 816LL))(this, a2) & 1;
}
| __cxx_global_var_init.227:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x50
LEA RDI,[0x1ddc6f0]
MOV ESI,0x3e
LEA RDX,[0x14a0554]
LEA RCX,[0x14a055a]
XOR R8D,R8D
LEA R9,[0x1bde230]
LEA R14,[0x1bde250]
LEA RBX,[0x1bde270]
LEA R11,[0x1bde290]
LEA R10,[0x149ffe5]
LEA RAX,[0x1bde020]
MOV qword ptr [RSP],R14
MOV qword ptr [RSP + 0x8],RBX
MOV qword ptr [RSP + 0x10],R11
MOV dword ptr [RSP + 0x18],0x6
MOV dword ptr [RSP + 0x20],0x8
MOV dword ptr [RSP + 0x28],0x2e
MOV dword ptr [RSP + 0x30],0x2c
MOV qword ptr [RSP + 0x38],R10
MOV qword ptr [RSP + 0x40],RAX
CALL 0x00b46fc0
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
|
void __cxx_global_var_init_227(void)
{
MY_LOCALE::MY_LOCALE
((MY_LOCALE *)my_locale_ar_KW,0x3e,"ar_KW","Arabic - Kuwait",false,
(st_typelib *)my_locale_typelib_month_names_ar_BH,
(st_typelib *)my_locale_typelib_ab_month_names_ar_BH,
(st_typelib *)my_locale_typelib_day_names_ar_BH,
(st_typelib *)my_locale_typelib_ab_day_names_ar_BH,6,8,0x2e,0x2c,"\x03",
(my_locale_errmsgs *)&global_errmsgs);
return;
}
| |
26,390 | mi_get_last_key | eloqsql/storage/myisam/mi_search.c | uchar *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
uchar *lastkey, uchar *endpos, uint *return_key_length)
{
uint nod_flag;
uchar *lastpos;
DBUG_ENTER("_mi_get_last_key");
DBUG_PRINT("enter",("page:%p endpos: %p", page,
endpos));
nod_flag=mi_test_if_nod(page);
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
{
lastpos=endpos-keyinfo->keylength-nod_flag;
*return_key_length=keyinfo->keylength;
if (lastpos > page)
bmove((uchar*) lastkey,(uchar*) lastpos,keyinfo->keylength+nod_flag);
}
else
{
lastpos=(page+=2+nod_flag);
lastkey[0]=0;
while (page < endpos)
{
lastpos=page;
*return_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,lastkey);
if (*return_key_length == 0)
{
DBUG_PRINT("error",("Couldn't find last key: page: %p",
page));
mi_print_error(info->s, HA_ERR_CRASHED);
my_errno=HA_ERR_CRASHED;
DBUG_RETURN(0);
}
}
}
DBUG_PRINT("exit",("lastpos: %p length: %u", lastpos,
*return_key_length));
DBUG_RETURN(lastpos);
} | O0 | c | mi_get_last_key:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
jmp 0xc1a02
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xc1a25
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0xc1a2c
xorl %eax, %eax
movl %eax, -0x4c(%rbp)
jmp 0xc1a2c
movl -0x4c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movzwl 0xa(%rax), %eax
andl $0x28, %eax
cmpl $0x0, %eax
jne 0xc1aa3
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movl -0x3c(%rbp), %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x12(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xc1a9e
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x18(%rbp), %rax
movzwl 0x12(%rax), %eax
addl -0x3c(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2a130
jmp 0xc1b32
movl -0x3c(%rbp), %ecx
addl $0x2, %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0xc1b30
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq -0x28(%rbp), %rcx
leaq -0x20(%rbp), %rdx
callq *%rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xc1b2e
jmp 0xc1aff
jmp 0xc1b01
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x268(%rax), %rsi
movl $0x7e, %edi
callq 0xae570
callq 0xf60c0
movl $0x7e, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xc1b40
jmp 0xc1ac1
jmp 0xc1b32
jmp 0xc1b34
jmp 0xc1b36
jmp 0xc1b38
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _mi_get_last_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 [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
jmp short $+2
loc_C1A02:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
and eax, 80h
cmp eax, 0
jz short loc_C1A25
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+17Ch]
mov [rbp+var_4C], eax
jmp short loc_C1A2C
loc_C1A25:
xor eax, eax
mov [rbp+var_4C], eax
jmp short $+2
loc_C1A2C:
mov eax, [rbp+var_4C]
mov [rbp+var_3C], eax
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+0Ah]
and eax, 28h
cmp eax, 0
jnz short loc_C1AA3
mov rax, [rbp+var_30]
mov rcx, [rbp+var_18]
movzx ecx, word ptr [rcx+12h]
movsxd rdx, ecx
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov ecx, [rbp+var_3C]
mov edx, ecx
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
movzx ecx, word ptr [rax+12h]
mov rax, [rbp+var_38]
mov [rax], ecx
mov rax, [rbp+var_48]
cmp rax, [rbp+var_20]
jbe short loc_C1A9E
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_48]
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+12h]
add eax, [rbp+var_3C]
mov eax, eax
mov edx, eax
call _memmove
loc_C1A9E:
jmp loc_C1B32
loc_C1AA3:
mov ecx, [rbp+var_3C]
add ecx, 2
mov rax, [rbp+var_20]
mov ecx, ecx
add rax, rcx
mov [rbp+var_20], rax
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov byte ptr [rax], 0
loc_C1AC1:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jnb short loc_C1B30
mov rax, [rbp+var_20]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
mov rax, [rax+48h]
mov rdi, [rbp+var_18]
mov esi, [rbp+var_3C]
mov rcx, [rbp+var_28]
lea rdx, [rbp+var_20]
call rax
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax], ecx
mov rax, [rbp+var_38]
cmp dword ptr [rax], 0
jnz short loc_C1B2E
jmp short $+2
loc_C1AFF:
jmp short $+2
loc_C1B01:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rsi, [rax+268h]
mov edi, 7Eh ; '~'
call mi_report_error
call _my_thread_var
mov dword ptr [rax], 7Eh ; '~'
mov [rbp+var_8], 0
jmp short loc_C1B40
loc_C1B2E:
jmp short loc_C1AC1
loc_C1B30:
jmp short $+2
loc_C1B32:
jmp short $+2
loc_C1B34:
jmp short $+2
loc_C1B36:
jmp short $+2
loc_C1B38:
mov rax, [rbp+var_48]
mov [rbp+var_8], rax
loc_C1B40:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| _BYTE * mi_get_last_key(long long a1, long long a2, _BYTE *a3, _BYTE *a4, unsigned long long a5, _DWORD *a6)
{
const char *v6; // rsi
unsigned int v8; // [rsp+4h] [rbp-4Ch]
_BYTE *v9; // [rsp+8h] [rbp-48h]
_BYTE *v13; // [rsp+30h] [rbp-20h] BYREF
long long v14; // [rsp+38h] [rbp-18h]
long long v15; // [rsp+40h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
if ( (*a3 & 0x80) != 0 )
v8 = *(_DWORD *)(*(_QWORD *)v15 + 380LL);
else
v8 = 0;
if ( (*(_WORD *)(v14 + 10) & 0x28) != 0 )
{
v13 += v8 + 2;
v9 = v13;
*a4 = 0;
while ( (unsigned long long)v13 < a5 )
{
v9 = v13;
*a6 = (*(long long ( **)(long long, _QWORD, _BYTE **, _BYTE *))(v14 + 72))(v14, v8, &v13, a4);
if ( !*a6 )
{
v6 = *(const char **)(*(_QWORD *)v15 + 616LL);
mi_report_error(126, (long long)v6);
*(_DWORD *)my_thread_var(126LL, v6) = 126;
return 0LL;
}
}
}
else
{
v9 = (_BYTE *)(a5 - *(unsigned __int16 *)(v14 + 18) - v8);
*a6 = *(unsigned __int16 *)(v14 + 18);
if ( v9 > v13 )
memmove(a4, v9, v8 + *(unsigned __int16 *)(v14 + 18));
}
return v9;
}
| _mi_get_last_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 qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
JMP 0x001c1a02
LAB_001c1a02:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001c1a25
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x17c]
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x001c1a2c
LAB_001c1a25:
XOR EAX,EAX
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x001c1a2c
LAB_001c1a2c:
MOV EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0xa]
AND EAX,0x28
CMP EAX,0x0
JNZ 0x001c1aa3
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,word ptr [RCX + 0x12]
MOVSXD RDX,ECX
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV ECX,dword ptr [RBP + -0x3c]
MOV EDX,ECX
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX ECX,word ptr [RAX + 0x12]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001c1a9e
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0x12]
ADD EAX,dword ptr [RBP + -0x3c]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x0012a130
LAB_001c1a9e:
JMP 0x001c1b32
LAB_001c1aa3:
MOV ECX,dword ptr [RBP + -0x3c]
ADD ECX,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],0x0
LAB_001c1ac1:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x001c1b30
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x48]
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x28]
LEA RDX,[RBP + -0x20]
CALL RAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
CMP dword ptr [RAX],0x0
JNZ 0x001c1b2e
JMP 0x001c1aff
LAB_001c1aff:
JMP 0x001c1b01
LAB_001c1b01:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x268]
MOV EDI,0x7e
CALL 0x001ae570
CALL 0x001f60c0
MOV dword ptr [RAX],0x7e
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001c1b40
LAB_001c1b2e:
JMP 0x001c1ac1
LAB_001c1b30:
JMP 0x001c1b32
LAB_001c1b32:
JMP 0x001c1b34
LAB_001c1b34:
JMP 0x001c1b36
LAB_001c1b36:
JMP 0x001c1b38
LAB_001c1b38:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x8],RAX
LAB_001c1b40:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
byte * _mi_get_last_key(long *param_1,long param_2,byte *param_3,int1 *param_4,byte *param_5,
uint *param_6)
{
uint uVar1;
int4 *puVar2;
uint local_54;
byte *local_50;
byte *local_28;
long local_20;
long *local_18;
byte *local_10;
if ((*param_3 & 0x80) == 0) {
local_54 = 0;
}
else {
local_54 = *(uint *)(*param_1 + 0x17c);
}
local_20 = param_2;
local_18 = param_1;
if ((*(ushort *)(param_2 + 10) & 0x28) == 0) {
local_50 = param_5 + (-(ulong)local_54 - (long)(int)(uint)*(ushort *)(param_2 + 0x12));
*param_6 = (uint)*(ushort *)(param_2 + 0x12);
if (param_3 < local_50) {
local_28 = param_3;
memmove(param_4,local_50,(ulong)(*(ushort *)(param_2 + 0x12) + local_54));
}
LAB_001c1b32:
local_10 = local_50;
}
else {
local_50 = param_3 + (local_54 + 2);
*param_4 = 0;
local_28 = local_50;
do {
if (param_5 <= local_28) goto LAB_001c1b32;
local_50 = local_28;
uVar1 = (**(code **)(local_20 + 0x48))(local_20,local_54,&local_28,param_4);
*param_6 = uVar1;
} while (*param_6 != 0);
mi_report_error(0x7e,*(int8 *)(*local_18 + 0x268));
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x7e;
local_10 = (byte *)0x0;
}
return local_10;
}
| |
26,391 | parse_pop | navaro[P]qoraal-tictactoe/build_O3/_deps/qoraal_engine-src/src/tool/parse.c | static bool
parse_pop (void)
{
PARSER_SECTION_T * ps = _parser_stack ;
if (ps) {
_parser_stack = ps->next ;
engine_port_free (heapParser, ps) ;
}
if (_parser_stack) {
_parser_state = _parser_stack->state ;
}
else {
_parser_state = parseNone ;
}
return ps ? true : false ;
} | O3 | c | parse_pop:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x3412a(%rip), %rbx # 0x3f0e8
xorl %r14d, %r14d
testq %rbx, %rbx
je 0xafed
movq (%rbx), %rax
movq %rax, 0x34118(%rip) # 0x3f0e8
movl $0x1, %edi
movq %rbx, %rsi
callq 0xd999
movq 0x34104(%rip), %rax # 0x3f0e8
testq %rax, %rax
je 0xafed
movl 0x8(%rax), %r14d
testq %rbx, %rbx
setne %al
movl %r14d, 0x340b6(%rip) # 0x3f0b0
popq %rbx
popq %r14
popq %rbp
retq
| parse_pop:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, cs:_parser_stack
xor r14d, r14d
test rbx, rbx
jz short loc_AFED
mov rax, [rbx]
mov cs:_parser_stack, rax
mov edi, 1
mov rsi, rbx
call engine_port_free
mov rax, cs:_parser_stack
test rax, rax
jz short loc_AFED
mov r14d, [rax+8]
loc_AFED:
test rbx, rbx
setnz al
mov cs:_parser_state, r14d
pop rbx
pop r14
pop rbp
retn
| bool parse_pop()
{
long long v0; // rbx
int v1; // r14d
bool result; // al
v0 = parser_stack;
v1 = 0;
if ( parser_stack )
{
parser_stack = *(_QWORD *)parser_stack;
engine_port_free(1LL, v0);
if ( parser_stack )
v1 = *(_DWORD *)(parser_stack + 8);
}
result = v0 != 0;
parser_state = v1;
return result;
}
| parse_pop:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,qword ptr [0x0013f0e8]
XOR R14D,R14D
TEST RBX,RBX
JZ 0x0010afed
MOV RAX,qword ptr [RBX]
MOV qword ptr [0x0013f0e8],RAX
MOV EDI,0x1
MOV RSI,RBX
CALL 0x0010d999
MOV RAX,qword ptr [0x0013f0e8]
TEST RAX,RAX
JZ 0x0010afed
MOV R14D,dword ptr [RAX + 0x8]
LAB_0010afed:
TEST RBX,RBX
SETNZ AL
MOV dword ptr [0x0013f0b0],R14D
POP RBX
POP R14
POP RBP
RET
|
bool parse_pop(void)
{
int8 *puVar1;
int4 uVar2;
puVar1 = _parser_stack;
uVar2 = 0;
if (_parser_stack != (int8 *)0x0) {
_parser_stack = (int8 *)*_parser_stack;
engine_port_free(1,puVar1);
uVar2 = 0;
if (_parser_stack != (int8 *)0x0) {
uVar2 = *(int4 *)(_parser_stack + 1);
}
}
_parser_state = uVar2;
return puVar1 != (int8 *)0x0;
}
| |
26,392 | ma_write_blob_record | eloqsql/storage/maria/ma_dynrec.c | my_bool _ma_write_blob_record(MARIA_HA *info, const uchar *record)
{
uchar *rec_buff;
int error;
ulong reclength,reclength2,extra;
my_bool buff_alloced;
extra= (ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER)+MARIA_SPLIT_LENGTH+
MARIA_DYN_DELETE_BLOCK_HEADER+1);
reclength= (info->s->base.pack_reclength +
_ma_calc_total_blob_length(info,record)+ extra);
alloc_on_stack(*info->stack_end_ptr, rec_buff, buff_alloced, reclength);
if (!rec_buff)
{
my_errno= HA_ERR_OUT_OF_MEM; /* purecov: inspected */
return(1);
}
reclength2= _ma_rec_pack(info,
rec_buff+ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER),
record);
if (!reclength2)
{
error= 1;
goto err;
}
DBUG_PRINT("info",("reclength: %lu reclength2: %lu",
reclength, reclength2));
DBUG_ASSERT(reclength2 <= reclength);
error= write_dynamic_record(info,
rec_buff+ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER),
reclength2);
err:
stack_alloc_free(rec_buff, buff_alloced);
return(error != 0);
} | O0 | c | ma_write_blob_record:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq $0x5d, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x3a0(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3c550
movq %rax, %rcx
movq -0x68(%rbp), %rax
addq %rcx, %rax
addq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq (%rax), %rax
leaq -0x58(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
jbe 0x3c48c
movq -0x60(%rbp), %rcx
subq -0x58(%rbp), %rcx
movl $0x10000, %eax # imm = 0x10000
cmpq %rcx, %rax
jb 0x3c46d
movq -0x60(%rbp), %rcx
subq -0x58(%rbp), %rcx
movl $0x8000, %eax # imm = 0x8000
cmpq %rcx, %rax
jae 0x3c48c
movl $0x1000, %eax # imm = 0x1000
cmpq -0x58(%rbp), %rax
ja 0x3c48c
movb $0x0, -0x49(%rbp)
movq -0x38(%rbp), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x28(%rbp)
jmp 0x3c4a4
movb $0x1, -0x49(%rbp)
movq -0x38(%rbp), %rsi
xorl %edi, %edi
movl $0x10010, %edx # imm = 0x10010
callq 0xf3250
movq %rax, -0x28(%rbp)
jmp 0x3c4a6
cmpq $0x0, -0x28(%rbp)
jne 0x3c4be
callq 0xf5ab0
movl $0x80, (%rax)
movb $0x1, -0x9(%rbp)
jmp 0x3c528
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
movq -0x20(%rbp), %rdx
callq 0x3b490
movl %eax, %eax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3c4e9
movl $0x1, -0x2c(%rbp)
jmp 0x3c50c
jmp 0x3c4eb
jmp 0x3c4ed
jmp 0x3c4ef
jmp 0x3c4f1
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
movq -0x40(%rbp), %rdx
callq 0x3ba80
movsbl %al, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movsbl -0x49(%rbp), %esi
callq 0x3c5f0
cmpl $0x0, -0x2c(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x69(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3c548
movb -0x69(%rbp), %al
movq %rbp, %rsp
popq %rbp
retq
callq 0x2a270
nopl (%rax)
| _ma_write_blob_record:
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_48], 5Dh ; ']'
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+3A0h]
mov [rbp+var_68], rax
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
call _ma_calc_total_blob_length
mov rcx, rax
mov rax, [rbp+var_68]
add rax, rcx
add rax, [rbp+var_48]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_58], rax
mov rax, [rbp+var_18]
mov rax, [rax+78h]
mov rax, [rax]
lea rcx, [rbp+var_58]
sub rax, rcx
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
cmp rax, [rbp+var_58]
jbe short loc_3C48C
mov rcx, [rbp+var_60]
sub rcx, [rbp+var_58]
mov eax, 10000h
cmp rax, rcx
jb short loc_3C46D
mov rcx, [rbp+var_60]
sub rcx, [rbp+var_58]
mov eax, 8000h
cmp rax, rcx
jnb short loc_3C48C
mov eax, 1000h
cmp rax, [rbp+var_58]
ja short loc_3C48C
loc_3C46D:
mov [rbp+var_49], 0
mov rcx, [rbp+var_38]
add rcx, 0Fh
and rcx, 0FFFFFFFFFFFFFFF0h
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_28], rax
jmp short loc_3C4A4
loc_3C48C:
mov [rbp+var_49], 1
mov rsi, [rbp+var_38]
xor edi, edi
mov edx, offset stru_10010
call my_malloc
mov [rbp+var_28], rax
loc_3C4A4:
jmp short $+2
loc_3C4A6:
cmp [rbp+var_28], 0
jnz short loc_3C4BE
call _my_thread_var
mov dword ptr [rax], 80h
mov [rbp+var_9], 1
jmp short loc_3C528
loc_3C4BE:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_28]
add rsi, 18h
mov rdx, [rbp+var_20]
call _ma_rec_pack
mov eax, eax
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
jnz short loc_3C4E9
mov [rbp+var_2C], 1
jmp short loc_3C50C
loc_3C4E9:
jmp short $+2
loc_3C4EB:
jmp short $+2
loc_3C4ED:
jmp short $+2
loc_3C4EF:
jmp short $+2
loc_3C4F1:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_28]
add rsi, 18h
mov rdx, [rbp+var_40]
call write_dynamic_record
movsx eax, al
mov [rbp+var_2C], eax
loc_3C50C:
mov rdi, [rbp+var_28]
movsx esi, [rbp+var_49]
call stack_alloc_free
cmp [rbp+var_2C], 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_9], al
loc_3C528:
mov al, [rbp+var_9]
mov [rbp+var_69], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3C548
mov al, [rbp+var_69]
mov rsp, rbp
pop rbp
retn
loc_3C548:
call ___stack_chk_fail
| bool ma_write_blob_record(long long a1, _BYTE *a2)
{
unsigned int v2; // eax
long long v4; // [rsp+0h] [rbp-70h] BYREF
long long v5; // [rsp+8h] [rbp-68h]
unsigned long long v6; // [rsp+10h] [rbp-60h]
unsigned long long v7; // [rsp+18h] [rbp-58h] BYREF
char v8; // [rsp+27h] [rbp-49h]
long long v9; // [rsp+28h] [rbp-48h]
long long v10; // [rsp+30h] [rbp-40h]
unsigned long long v11; // [rsp+38h] [rbp-38h]
int v12; // [rsp+44h] [rbp-2Ch]
char *v13; // [rsp+48h] [rbp-28h]
_BYTE *v14; // [rsp+50h] [rbp-20h]
_QWORD *v15; // [rsp+58h] [rbp-18h]
unsigned long long v17; // [rsp+68h] [rbp-8h]
v17 = __readfsqword(0x28u);
v15 = (_QWORD *)a1;
v14 = a2;
v9 = 93LL;
v5 = *(_QWORD *)(*(_QWORD *)a1 + 928LL);
v11 = ma_calc_total_blob_length(a1, a2) + v5 + 93;
v7 = v11;
v6 = **(_QWORD **)(a1 + 120) - (_QWORD)&v7;
if ( v6 <= v11 || v6 - v7 <= 0x10000 && (v6 - v7 <= 0x8000 || v7 < 0x1000) )
{
v8 = 1;
v13 = (char *)my_malloc(0LL, v11, &stru_10010);
}
else
{
v8 = 0;
v13 = (char *)&v4 - ((v11 + 15) & 0xFFFFFFFFFFFFFFF0LL);
}
if ( v13 )
{
v2 = ma_rec_pack(v15, v13 + 24, v14);
v10 = v2;
if ( v2 )
v12 = write_dynamic_record(v15, (long long)(v13 + 24), v10);
else
v12 = 1;
stack_alloc_free(v13, (unsigned int)v8);
return v12 != 0;
}
else
{
*(_DWORD *)my_thread_var() = 128;
return 1;
}
}
| _ma_write_blob_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x48],0x5d
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x3a0]
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0013c550
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,RCX
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RAX]
LEA RCX,[RBP + -0x58]
SUB RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
CMP RAX,qword ptr [RBP + -0x58]
JBE 0x0013c48c
MOV RCX,qword ptr [RBP + -0x60]
SUB RCX,qword ptr [RBP + -0x58]
MOV EAX,0x10000
CMP RAX,RCX
JC 0x0013c46d
MOV RCX,qword ptr [RBP + -0x60]
SUB RCX,qword ptr [RBP + -0x58]
MOV EAX,0x8000
CMP RAX,RCX
JNC 0x0013c48c
MOV EAX,0x1000
CMP RAX,qword ptr [RBP + -0x58]
JA 0x0013c48c
LAB_0013c46d:
MOV byte ptr [RBP + -0x49],0x0
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,0xf
AND RCX,-0x10
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0013c4a4
LAB_0013c48c:
MOV byte ptr [RBP + -0x49],0x1
MOV RSI,qword ptr [RBP + -0x38]
XOR EDI,EDI
MOV EDX,0x10010
CALL 0x001f3250
MOV qword ptr [RBP + -0x28],RAX
LAB_0013c4a4:
JMP 0x0013c4a6
LAB_0013c4a6:
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x0013c4be
CALL 0x001f5ab0
MOV dword ptr [RAX],0x80
MOV byte ptr [RBP + -0x9],0x1
JMP 0x0013c528
LAB_0013c4be:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x18
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0013b490
MOV EAX,EAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
JNZ 0x0013c4e9
MOV dword ptr [RBP + -0x2c],0x1
JMP 0x0013c50c
LAB_0013c4e9:
JMP 0x0013c4eb
LAB_0013c4eb:
JMP 0x0013c4ed
LAB_0013c4ed:
JMP 0x0013c4ef
LAB_0013c4ef:
JMP 0x0013c4f1
LAB_0013c4f1:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x18
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x0013ba80
MOVSX EAX,AL
MOV dword ptr [RBP + -0x2c],EAX
LAB_0013c50c:
MOV RDI,qword ptr [RBP + -0x28]
MOVSX ESI,byte ptr [RBP + -0x49]
CALL 0x0013c5f0
CMP dword ptr [RBP + -0x2c],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x9],AL
LAB_0013c528:
MOV AL,byte ptr [RBP + -0x9]
MOV byte ptr [RBP + -0x69],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013c548
MOV AL,byte ptr [RBP + -0x69]
MOV RSP,RBP
POP RBP
RET
LAB_0013c548:
CALL 0x0012a270
|
int8 _ma_write_blob_record(long *param_1,int8 param_2)
{
int8 uVar1;
long *plVar2;
char cVar3;
uint uVar4;
long lVar5;
int4 *puVar6;
ulong uVar7;
int1 *puVar8;
int iVar9;
int1 *puVar10;
long in_FS_OFFSET;
int1 auStack_78 [7];
bool local_71;
long local_70;
ulong local_68;
ulong local_60;
char local_51;
long local_50;
ulong local_48;
ulong local_40;
int local_34;
int1 *local_30;
int8 local_28;
long *local_20;
bool local_11;
long local_10;
puVar8 = auStack_78;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_50 = 0x5d;
local_70 = *(long *)(*param_1 + 0x3a0);
local_28 = param_2;
local_20 = param_1;
lVar5 = _ma_calc_total_blob_length(param_1,param_2);
local_60 = local_70 + lVar5 + local_50;
local_68 = *(long *)local_20[0xf] - (long)&local_60;
local_40 = local_60;
if ((local_60 < local_68) &&
((0x10000 < local_68 - local_60 || ((0x8000 < local_68 - local_60 && (0xfff < local_60)))))) {
local_51 = '\0';
puVar8 = auStack_78 + -(local_60 + 0xf & 0xfffffffffffffff0);
local_30 = puVar8;
}
else {
local_51 = '\x01';
local_30 = (int1 *)my_malloc(0,local_60,0x10010);
}
plVar2 = local_20;
uVar1 = local_28;
if (local_30 == (int1 *)0x0) {
*(int8 *)(puVar8 + -8) = 0x13c4b2;
puVar6 = (int4 *)_my_thread_var();
*puVar6 = 0x80;
local_11 = true;
}
else {
puVar10 = local_30 + 0x18;
*(int8 *)(puVar8 + -8) = 0x13c4d3;
uVar4 = _ma_rec_pack(plVar2,puVar10,uVar1);
plVar2 = local_20;
uVar7 = (ulong)uVar4;
local_48 = uVar7;
if (uVar7 == 0) {
local_34 = 1;
}
else {
puVar10 = local_30 + 0x18;
*(int8 *)(puVar8 + -8) = 0x13c506;
cVar3 = write_dynamic_record(plVar2,puVar10,uVar7);
local_34 = (int)cVar3;
}
puVar10 = local_30;
iVar9 = (int)local_51;
*(int8 *)(puVar8 + -8) = 0x13c519;
stack_alloc_free(puVar10,iVar9);
local_11 = local_34 != 0;
}
local_71 = local_11;
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_11);
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar8 + -8) = 0x13c54d;
__stack_chk_fail();
}
| |
26,393 | mbedtls_hmac_drbg_seed | msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/hmac_drbg.c | int mbedtls_hmac_drbg_seed(mbedtls_hmac_drbg_context *ctx,
const mbedtls_md_info_t *md_info,
int (*f_entropy)(void *, unsigned char *, size_t),
void *p_entropy,
const unsigned char *custom,
size_t len)
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t md_size;
if ((ret = mbedtls_md_setup(&ctx->md_ctx, md_info, 1)) != 0) {
return ret;
}
/* The mutex is initialized iff the md context is set up. */
#if defined(MBEDTLS_THREADING_C)
mbedtls_mutex_init(&ctx->mutex);
#endif
md_size = mbedtls_md_get_size(md_info);
/*
* Set initial working state.
* Use the V memory location, which is currently all 0, to initialize the
* MD context with an all-zero key. Then set V to its initial value.
*/
if ((ret = mbedtls_md_hmac_starts(&ctx->md_ctx, ctx->V, md_size)) != 0) {
return ret;
}
memset(ctx->V, 0x01, md_size);
ctx->f_entropy = f_entropy;
ctx->p_entropy = p_entropy;
if (ctx->entropy_len == 0) {
/*
* See SP800-57 5.6.1 (p. 65-66) for the security strength provided by
* each hash function, then according to SP800-90A rev1 10.1 table 2,
* min_entropy_len (in bits) is security_strength.
*
* (This also matches the sizes used in the NIST test vectors.)
*/
ctx->entropy_len = md_size <= 20 ? 16 : /* 160-bits hash -> 128 bits */
md_size <= 28 ? 24 : /* 224-bits hash -> 192 bits */
32; /* better (256+) -> 256 bits */
}
if ((ret = hmac_drbg_reseed_core(ctx, custom, len,
1 /* add nonce */)) != 0) {
return ret;
}
return 0;
} | O3 | c | mbedtls_hmac_drbg_seed:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
movl $0x1, %edx
callq 0x8a4a1
testl %eax, %eax
jne 0x89bb9
movq %rbx, (%rsp)
movq %rbp, %rdi
callq 0x8abb4
movzbl %al, %ebp
leaq 0x18(%r15), %rbx
movq %r15, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x8a89d
testl %eax, %eax
je 0x89bc8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
movq %rbp, %rdx
callq 0xf2b0
movq %r13, 0x70(%r15)
movq %r12, 0x78(%r15)
cmpq $0x0, 0x60(%r15)
jne 0x89c09
xorl %eax, %eax
cmpb $0x1d, %bpl
setae %al
cmpb $0x15, %bpl
leaq 0x18(,%rax,8), %rax
movl $0x10, %ecx
cmovaeq %rax, %rcx
movq %rcx, 0x60(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq (%rsp), %rdx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x89a6e
| mbedtls_hmac_drbg_seed:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, r9
mov r14, r8
mov r12, rcx
mov r13, rdx
mov rbp, rsi
mov r15, rdi
mov edx, 1
call mbedtls_md_setup
test eax, eax
jnz short loc_89BB9
mov [rsp+38h+var_38], rbx
mov rdi, rbp
call mbedtls_md_get_size
movzx ebp, al
lea rbx, [r15+18h]
mov rdi, r15
mov rsi, rbx
mov rdx, rbp
call mbedtls_md_hmac_starts
test eax, eax
jz short loc_89BC8
loc_89BB9:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_89BC8:
mov rdi, rbx
mov esi, 1
mov rdx, rbp
call _memset
mov [r15+70h], r13
mov [r15+78h], r12
cmp qword ptr [r15+60h], 0
jnz short loc_89C09
xor eax, eax
cmp bpl, 1Dh
setnb al
cmp bpl, 15h
lea rax, ds:18h[rax*8]
mov ecx, 10h
cmovnb rcx, rax
mov [r15+60h], rcx
loc_89C09:
mov rdi, r15
mov rsi, r14
mov rdx, [rsp+38h+var_38]
mov ecx, 1
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp hmac_drbg_reseed_core
| long long mbedtls_hmac_drbg_seed(
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
unsigned long long a6)
{
long long result; // rax
long long size; // rbp
long long v12; // rcx
result = mbedtls_md_setup(a1, a2, 1LL);
if ( !(_DWORD)result )
{
size = (unsigned __int8)mbedtls_md_get_size(a2);
result = mbedtls_md_hmac_starts(a1, a1 + 3, size);
if ( !(_DWORD)result )
{
memset(a1 + 3, 1LL, size);
a1[14] = a3;
a1[15] = a4;
if ( !a1[12] )
{
v12 = 16LL;
if ( (unsigned __int8)size >= 0x15u )
v12 = 8LL * ((unsigned __int8)size >= 0x1Du) + 24;
a1[12] = v12;
}
return hmac_drbg_reseed_core((long long)a1, a5, a6, 1);
}
}
return result;
}
| mbedtls_hmac_drbg_seed:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,R9
MOV R14,R8
MOV R12,RCX
MOV R13,RDX
MOV RBP,RSI
MOV R15,RDI
MOV EDX,0x1
CALL 0x0018a4a1
TEST EAX,EAX
JNZ 0x00189bb9
MOV qword ptr [RSP],RBX
MOV RDI,RBP
CALL 0x0018abb4
MOVZX EBP,AL
LEA RBX,[R15 + 0x18]
MOV RDI,R15
MOV RSI,RBX
MOV RDX,RBP
CALL 0x0018a89d
TEST EAX,EAX
JZ 0x00189bc8
LAB_00189bb9:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00189bc8:
MOV RDI,RBX
MOV ESI,0x1
MOV RDX,RBP
CALL 0x0010f2b0
MOV qword ptr [R15 + 0x70],R13
MOV qword ptr [R15 + 0x78],R12
CMP qword ptr [R15 + 0x60],0x0
JNZ 0x00189c09
XOR EAX,EAX
CMP BPL,0x1d
SETNC AL
CMP BPL,0x15
LEA RAX,[0x18 + RAX*0x8]
MOV ECX,0x10
CMOVNC RCX,RAX
MOV qword ptr [R15 + 0x60],RCX
LAB_00189c09:
MOV RDI,R15
MOV RSI,R14
MOV RDX,qword ptr [RSP]
MOV ECX,0x1
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00189a6e
|
void mbedtls_hmac_drbg_seed
(long param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6)
{
byte bVar1;
int iVar2;
long lVar3;
iVar2 = mbedtls_md_setup(param_1,param_2,1);
if (iVar2 == 0) {
bVar1 = mbedtls_md_get_size(param_2);
iVar2 = mbedtls_md_hmac_starts(param_1,(void *)(param_1 + 0x18),(ulong)bVar1);
if (iVar2 == 0) {
memset((void *)(param_1 + 0x18),1,(ulong)bVar1);
*(int8 *)(param_1 + 0x70) = param_3;
*(int8 *)(param_1 + 0x78) = param_4;
if (*(long *)(param_1 + 0x60) == 0) {
lVar3 = 0x10;
if (0x14 < bVar1) {
lVar3 = (ulong)(0x1c < bVar1) * 8 + 0x18;
}
*(long *)(param_1 + 0x60) = lVar3;
}
hmac_drbg_reseed_core(param_1,param_5,param_6,1);
return;
}
}
return;
}
| |
26,394 | my_end | eloqsql/mysys/my_init.c | void my_end(int infoflag)
{
/*
this code is suboptimal to workaround a bug in
Sun CC: Sun C++ 5.6 2004/06/02 for x86, and should not be
optimized until this compiler is not in use anymore
*/
FILE *info_file= DBUG_FILE;
my_bool print_info= (info_file != stderr);
if (!my_init_done)
return;
/*
We do not use DBUG_ENTER here, as after cleanup DBUG is no longer
operational, so we cannot use DBUG_RETURN.
*/
DBUG_PRINT("info",("Shutting down: infoflag: %d print_info: %d",
infoflag, print_info));
if (!info_file)
{
info_file= stderr;
print_info= 0;
}
if ((infoflag & MY_CHECK_ERROR) || print_info)
{ /* Test if some file is left open */
char ebuff[512];
uint i, open_files, open_streams;
for (open_streams= open_files= i= 0 ; i < my_file_limit ; i++)
{
if (my_file_info[i].type == UNOPEN)
continue;
if (my_file_info[i].type == STREAM_BY_FOPEN ||
my_file_info[i].type == STREAM_BY_FDOPEN)
open_streams++;
else
open_files++;
#ifdef EXTRA_DEBUG
fprintf(stderr, EE(EE_FILE_NOT_CLOSED), my_file_info[i].name, i);
fputc('\n', stderr);
#endif
}
if (open_files || open_streams)
{
my_snprintf(ebuff, sizeof(ebuff), EE(EE_OPEN_WARNING),
open_files, open_streams);
my_message_stderr(EE_OPEN_WARNING, ebuff, ME_BELL);
DBUG_PRINT("error", ("%s", ebuff));
}
#ifdef CHECK_UNLIKELY
end_my_likely(info_file);
#endif
}
free_charsets();
my_error_unregister_all();
my_once_free();
if ((infoflag & MY_GIVE_INFO) || print_info)
{
#ifdef HAVE_GETRUSAGE
struct rusage rus;
#ifdef HAVE_valgrind
/* Purify assumes that rus is uninitialized after getrusage call */
bzero((char*) &rus, sizeof(rus));
#endif
if (!getrusage(RUSAGE_SELF, &rus))
fprintf(info_file,"\n\
User time %.2f, System time %.2f\n\
Maximum resident set size %ld, Integral resident set size %ld\n\
Non-physical pagefaults %ld, Physical pagefaults %ld, Swaps %ld\n\
Blocks in %ld out %ld, Messages in %ld out %ld, Signals %ld\n\
Voluntary context switches %ld, Involuntary context switches %ld\n",
(rus.ru_utime.tv_sec * SCALE_SEC +
rus.ru_utime.tv_usec / SCALE_USEC) / 100.0,
(rus.ru_stime.tv_sec * SCALE_SEC +
rus.ru_stime.tv_usec / SCALE_USEC) / 100.0,
rus.ru_maxrss, rus.ru_idrss,
rus.ru_minflt, rus.ru_majflt,
rus.ru_nswap, rus.ru_inblock, rus.ru_oublock,
rus.ru_msgsnd, rus.ru_msgrcv, rus.ru_nsignals,
rus.ru_nvcsw, rus.ru_nivcsw);
#endif
#if defined(_MSC_VER)
_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDERR );
_CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDERR );
_CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
_CrtCheckMemory();
#endif
}
my_thread_end();
my_thread_global_end();
if (!(infoflag & MY_DONT_FREE_DBUG))
DBUG_END(); /* Must be done as late as possible */
my_mutex_end();
#if defined(SAFE_MUTEX)
/*
Check on destroying of mutexes. A few may be left that will get cleaned
up by C++ destructors
*/
safe_mutex_end((infoflag & (MY_GIVE_INFO | MY_CHECK_ERROR)) ? stderr :
(FILE *) 0);
#endif /* defined(SAFE_MUTEX) */
#ifdef _WIN32
WSACleanup();
#endif
/* At very last, delete mysys key, it is used everywhere including DBUG */
pthread_key_delete(THR_KEY_mysys);
my_init_done= my_thr_key_mysys_exists= 0;
} | O0 | c | my_end:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x308, %rsp # imm = 0x308
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movl %edi, -0x234(%rbp)
movq 0x1ac122(%rip), %rax # 0x1d5fe0
movq (%rax), %rax
movq %rax, -0x240(%rbp)
movq -0x240(%rbp), %rax
movq 0x1ac10a(%rip), %rcx # 0x1d5fe0
cmpq (%rcx), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x241(%rbp)
leaq 0x363b7a(%rip), %rax # 0x38da68
cmpb $0x0, (%rax)
jne 0x29ef8
jmp 0x2a1f1
jmp 0x29efa
jmp 0x29efc
cmpq $0x0, -0x240(%rbp)
jne 0x29f1e
movq 0x1ac0d3(%rip), %rax # 0x1d5fe0
movq (%rax), %rax
movq %rax, -0x240(%rbp)
movb $0x0, -0x241(%rbp)
movl -0x234(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x29f3c
movsbl -0x241(%rbp), %eax
cmpl $0x0, %eax
je 0x2a05a
movl $0x0, -0x248(%rbp)
movl $0x0, -0x24c(%rbp)
movl $0x0, -0x250(%rbp)
movl -0x248(%rbp), %eax
leaq 0x1ac689(%rip), %rcx # 0x1d65f0
cmpl (%rcx), %eax
jae 0x29ffe
leaq 0x1ac682(%rip), %rax # 0x1d65f8
movq (%rax), %rax
movl -0x248(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0x29f8e
jmp 0x29fea
leaq 0x1ac663(%rip), %rax # 0x1d65f8
movq (%rax), %rax
movl -0x248(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x3, 0x8(%rax)
je 0x29fc8
leaq 0x1ac646(%rip), %rax # 0x1d65f8
movq (%rax), %rax
movl -0x248(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x4, 0x8(%rax)
jne 0x29fd9
movl -0x250(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x250(%rbp)
jmp 0x29fe8
movl -0x24c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24c(%rbp)
jmp 0x29fea
movl -0x248(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x248(%rbp)
jmp 0x29f5a
cmpl $0x0, -0x24c(%rbp)
jne 0x2a010
cmpl $0x0, -0x250(%rbp)
je 0x2a058
leaq -0x230(%rbp), %rdi
leaq 0x1acb22(%rip), %rax # 0x1d6b40
movq 0x90(%rax), %rdx
movl -0x24c(%rbp), %ecx
movl -0x250(%rbp), %r8d
movl $0x200, %esi # imm = 0x200
movb $0x0, %al
callq 0x7cfe0
leaq -0x230(%rbp), %rsi
movl $0x13, %edi
movl $0x4, %edx
callq 0x2aa10
jmp 0x2a056
jmp 0x2a058
jmp 0x2a05a
callq 0x2e1b0
callq 0x36b30
callq 0x2ad80
movl -0x234(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x2a087
movsbl -0x241(%rbp), %eax
cmpl $0x0, %eax
je 0x2a1ac
xorl %edi, %edi
leaq -0x2e0(%rbp), %rsi
callq 0x241a0
cmpl $0x0, %eax
jne 0x2a1aa
movq -0x240(%rbp), %rdi
imulq $0x64, -0x2e0(%rbp), %rax
movq %rax, -0x2f0(%rbp)
movq -0x2d8(%rbp), %rax
movl $0x2710, %ecx # imm = 0x2710
cqto
idivq %rcx
movq %rax, %rcx
movq -0x2f0(%rbp), %rax
addq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd 0x5bba1(%rip), %xmm1 # 0x85c80
divsd %xmm1, %xmm0
imulq $0x64, -0x2d0(%rbp), %rax
movq %rax, -0x2e8(%rbp)
movq -0x2c8(%rbp), %rax
movl $0x2710, %ecx # imm = 0x2710
cqto
idivq %rcx
movq %rax, %rcx
movq -0x2e8(%rbp), %rax
addq %rcx, %rax
cvtsi2sd %rax, %xmm1
movsd 0x5bb63(%rip), %xmm2 # 0x85c80
divsd %xmm2, %xmm1
movq -0x2c0(%rbp), %rdx
movq -0x2b0(%rbp), %rcx
movq -0x2a0(%rbp), %r8
movq -0x298(%rbp), %r9
movq -0x290(%rbp), %r13
movq -0x288(%rbp), %r12
movq -0x280(%rbp), %r15
movq -0x278(%rbp), %r14
movq -0x270(%rbp), %rbx
movq -0x268(%rbp), %r11
movq -0x260(%rbp), %r10
movq -0x258(%rbp), %rax
leaq 0x569cd(%rip), %rsi # 0x80b49
movq %r13, (%rsp)
movq %r12, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movb $0x2, %al
callq 0x24430
jmp 0x2a1ac
callq 0x2b5b0
callq 0x2b320
movl -0x234(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x2a1ca
jmp 0x2a1c6
jmp 0x2a1c8
jmp 0x2a1ca
callq 0x2bdb0
leaq 0x364576(%rip), %rax # 0x38e74c
movl (%rax), %edi
callq 0x24360
leaq 0x3642a0(%rip), %rax # 0x38e484
movb $0x0, (%rax)
leaq 0x36387a(%rip), %rax # 0x38da68
movb $0x0, (%rax)
movq %fs:0x28, %rax
movq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2a215
addq $0x308, %rsp # imm = 0x308
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24300
nopw (%rax,%rax)
| my_end:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 308h
mov rax, fs:28h
mov [rbp+var_30], rax
mov [rbp+var_234], edi
mov rax, cs:stderr_ptr
mov rax, [rax]
mov [rbp+var_240], rax
mov rax, [rbp+var_240]
mov rcx, cs:stderr_ptr
cmp rax, [rcx]
setnz al
and al, 1
movzx eax, al
mov [rbp+var_241], al
lea rax, my_init_done
cmp byte ptr [rax], 0
jnz short loc_29EF8
jmp loc_2A1F1
loc_29EF8:
jmp short $+2
loc_29EFA:
jmp short $+2
loc_29EFC:
cmp [rbp+var_240], 0
jnz short loc_29F1E
mov rax, cs:stderr_ptr
mov rax, [rax]
mov [rbp+var_240], rax
mov [rbp+var_241], 0
loc_29F1E:
mov eax, [rbp+var_234]
and eax, 1
cmp eax, 0
jnz short loc_29F3C
movsx eax, [rbp+var_241]
cmp eax, 0
jz loc_2A05A
loc_29F3C:
mov [rbp+var_248], 0
mov [rbp+var_24C], 0
mov [rbp+var_250], 0
loc_29F5A:
mov eax, [rbp+var_248]
lea rcx, my_file_limit
cmp eax, [rcx]
jnb loc_29FFE
lea rax, my_file_info
mov rax, [rax]
mov ecx, [rbp+var_248]
shl rcx, 4
add rax, rcx
cmp dword ptr [rax+8], 0
jnz short loc_29F8E
jmp short loc_29FEA
loc_29F8E:
lea rax, my_file_info
mov rax, [rax]
mov ecx, [rbp+var_248]
shl rcx, 4
add rax, rcx
cmp dword ptr [rax+8], 3
jz short loc_29FC8
lea rax, my_file_info
mov rax, [rax]
mov ecx, [rbp+var_248]
shl rcx, 4
add rax, rcx
cmp dword ptr [rax+8], 4
jnz short loc_29FD9
loc_29FC8:
mov eax, [rbp+var_250]
add eax, 1
mov [rbp+var_250], eax
jmp short loc_29FE8
loc_29FD9:
mov eax, [rbp+var_24C]
add eax, 1
mov [rbp+var_24C], eax
loc_29FE8:
jmp short $+2
loc_29FEA:
mov eax, [rbp+var_248]
add eax, 1
mov [rbp+var_248], eax
jmp loc_29F5A
loc_29FFE:
cmp [rbp+var_24C], 0
jnz short loc_2A010
cmp [rbp+var_250], 0
jz short loc_2A058
loc_2A010:
lea rdi, [rbp+var_230]
lea rax, globerrs
mov rdx, [rax+90h]
mov ecx, [rbp+var_24C]
mov r8d, [rbp+var_250]
mov esi, 200h
mov al, 0
call my_snprintf
lea rsi, [rbp+var_230]
mov edi, 13h
mov edx, 4
call my_message_stderr
jmp short $+2
loc_2A056:
jmp short $+2
loc_2A058:
jmp short $+2
loc_2A05A:
call free_charsets
call my_error_unregister_all
call my_once_free
mov eax, [rbp+var_234]
and eax, 2
cmp eax, 0
jnz short loc_2A087
movsx eax, [rbp+var_241]
cmp eax, 0
jz loc_2A1AC
loc_2A087:
xor edi, edi
lea rsi, [rbp+var_2E0]
call _getrusage
cmp eax, 0
jnz loc_2A1AA
mov rdi, [rbp+var_240]
imul rax, [rbp+var_2E0], 64h ; 'd'
mov [rbp+var_2F0], rax
mov rax, [rbp+var_2D8]
mov ecx, 2710h
cqo
idiv rcx
mov rcx, rax
mov rax, [rbp+var_2F0]
add rax, rcx
cvtsi2sd xmm0, rax
movsd xmm1, cs:qword_85C80
divsd xmm0, xmm1
imul rax, [rbp+var_2D0], 64h ; 'd'
mov [rbp+var_2E8], rax
mov rax, [rbp+var_2C8]
mov ecx, 2710h
cqo
idiv rcx
mov rcx, rax
mov rax, [rbp+var_2E8]
add rax, rcx
cvtsi2sd xmm1, rax
movsd xmm2, cs:qword_85C80
divsd xmm1, xmm2
mov rdx, [rbp+var_2C0]
mov rcx, [rbp+var_2B0]
mov r8, [rbp+var_2A0]
mov r9, [rbp+var_298]
mov r13, [rbp+var_290]
mov r12, [rbp+var_288]
mov r15, [rbp+var_280]
mov r14, [rbp+var_278]
mov rbx, [rbp+var_270]
mov r11, [rbp+var_268]
mov r10, [rbp+var_260]
mov rax, [rbp+var_258]
lea rsi, aUserTime2fSyst; "\nUser time %.2f, System time %.2f\nMax"...
mov [rsp+330h+var_330], r13
mov [rsp+330h+var_328], r12
mov [rsp+330h+var_320], r15
mov [rsp+330h+var_318], r14
mov [rsp+330h+var_310], rbx
mov [rsp+330h+var_308], r11
mov [rsp+330h+var_300], r10
mov [rsp+330h+var_2F8], rax
mov al, 2
call _fprintf
loc_2A1AA:
jmp short $+2
loc_2A1AC:
call my_thread_end
call my_thread_global_end
mov eax, [rbp+var_234]
and eax, 4
cmp eax, 0
jnz short loc_2A1CA
jmp short $+2
loc_2A1C6:
jmp short $+2
loc_2A1C8:
jmp short $+2
loc_2A1CA:
call my_mutex_end
lea rax, THR_KEY_mysys
mov edi, [rax]
call _pthread_key_delete
lea rax, my_thr_key_mysys_exists
mov byte ptr [rax], 0
lea rax, my_init_done
mov byte ptr [rax], 0
loc_2A1F1:
mov rax, fs:28h
mov rcx, [rbp+var_30]
cmp rax, rcx
jnz short loc_2A215
add rsp, 308h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2A215:
call ___stack_chk_fail
| unsigned long long my_end(int a1, long long a2, long long a3, long long a4, long long a5, int a6)
{
_QWORD v7[2]; // [rsp+50h] [rbp-2E0h] BYREF
long long v8; // [rsp+60h] [rbp-2D0h]
long long v9; // [rsp+68h] [rbp-2C8h]
long long v10; // [rsp+70h] [rbp-2C0h]
long long v11; // [rsp+80h] [rbp-2B0h]
long long v12; // [rsp+90h] [rbp-2A0h]
long long v13; // [rsp+98h] [rbp-298h]
long long v14; // [rsp+A0h] [rbp-290h]
long long v15; // [rsp+A8h] [rbp-288h]
long long v16; // [rsp+B0h] [rbp-280h]
long long v17; // [rsp+B8h] [rbp-278h]
long long v18; // [rsp+C0h] [rbp-270h]
long long v19; // [rsp+C8h] [rbp-268h]
long long v20; // [rsp+D0h] [rbp-260h]
long long v21; // [rsp+D8h] [rbp-258h]
int v22; // [rsp+E0h] [rbp-250h]
int v23; // [rsp+E4h] [rbp-24Ch]
unsigned int v24; // [rsp+E8h] [rbp-248h]
char v25; // [rsp+EFh] [rbp-241h]
long long v26; // [rsp+F0h] [rbp-240h]
int v27; // [rsp+FCh] [rbp-234h]
_BYTE v28[512]; // [rsp+100h] [rbp-230h] BYREF
unsigned long long v29; // [rsp+300h] [rbp-30h]
v29 = __readfsqword(0x28u);
v27 = a1;
v26 = stderr;
v25 = 0;
if ( my_init_done )
{
if ( !v26 )
{
v26 = stderr;
v25 = 0;
}
if ( (v27 & 1) != 0 )
{
v24 = 0;
v23 = 0;
v22 = 0;
while ( v24 < my_file_limit )
{
if ( *((_DWORD *)my_file_info + 4 * v24 + 2) )
{
if ( *((_DWORD *)my_file_info + 4 * v24 + 2) == 3 || *((_DWORD *)my_file_info + 4 * v24 + 2) == 4 )
++v22;
else
++v23;
}
++v24;
}
if ( v23 || v22 )
{
my_snprintf((unsigned int)v28, 512, (unsigned int)globerrs[18], v23, v22, a6);
my_message_stderr(19LL, v28, 4LL);
}
}
free_charsets();
my_error_unregister_all();
my_once_free();
if ( (v27 & 2) != 0 && !(unsigned int)getrusage(0LL, v7) )
fprintf(
v26,
"\n"
"User time %.2f, System time %.2f\n"
"Maximum resident set size %ld, Integral resident set size %ld\n"
"Non-physical pagefaults %ld, Physical pagefaults %ld, Swaps %ld\n"
"Blocks in %ld out %ld, Messages in %ld out %ld, Signals %ld\n"
"Voluntary context switches %ld, Involuntary context switches %ld\n",
(double)(int)(v7[1] / 10000LL + 100 * LODWORD(v7[0])) / 100.0,
(double)(int)(v9 / 10000 + 100 * v8) / 100.0,
v10,
v11,
v12,
v13,
v14,
v15,
v16,
v17,
v18,
v19,
v20,
v21);
my_thread_end();
my_thread_global_end();
my_mutex_end();
pthread_key_delete(THR_KEY_mysys);
my_thr_key_mysys_exists = 0;
my_init_done = 0;
}
return __readfsqword(0x28u);
}
| my_end:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x308
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV dword ptr [RBP + -0x234],EDI
MOV RAX,qword ptr [0x002d5fe0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x240],RAX
MOV RAX,qword ptr [RBP + -0x240]
MOV RCX,qword ptr [0x002d5fe0]
CMP RAX,qword ptr [RCX]
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x241],AL
LEA RAX,[0x48da68]
CMP byte ptr [RAX],0x0
JNZ 0x00129ef8
JMP 0x0012a1f1
LAB_00129ef8:
JMP 0x00129efa
LAB_00129efa:
JMP 0x00129efc
LAB_00129efc:
CMP qword ptr [RBP + -0x240],0x0
JNZ 0x00129f1e
MOV RAX,qword ptr [0x002d5fe0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x240],RAX
MOV byte ptr [RBP + -0x241],0x0
LAB_00129f1e:
MOV EAX,dword ptr [RBP + -0x234]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x00129f3c
MOVSX EAX,byte ptr [RBP + -0x241]
CMP EAX,0x0
JZ 0x0012a05a
LAB_00129f3c:
MOV dword ptr [RBP + -0x248],0x0
MOV dword ptr [RBP + -0x24c],0x0
MOV dword ptr [RBP + -0x250],0x0
LAB_00129f5a:
MOV EAX,dword ptr [RBP + -0x248]
LEA RCX,[0x2d65f0]
CMP EAX,dword ptr [RCX]
JNC 0x00129ffe
LEA RAX,[0x2d65f8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x248]
SHL RCX,0x4
ADD RAX,RCX
CMP dword ptr [RAX + 0x8],0x0
JNZ 0x00129f8e
JMP 0x00129fea
LAB_00129f8e:
LEA RAX,[0x2d65f8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x248]
SHL RCX,0x4
ADD RAX,RCX
CMP dword ptr [RAX + 0x8],0x3
JZ 0x00129fc8
LEA RAX,[0x2d65f8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x248]
SHL RCX,0x4
ADD RAX,RCX
CMP dword ptr [RAX + 0x8],0x4
JNZ 0x00129fd9
LAB_00129fc8:
MOV EAX,dword ptr [RBP + -0x250]
ADD EAX,0x1
MOV dword ptr [RBP + -0x250],EAX
JMP 0x00129fe8
LAB_00129fd9:
MOV EAX,dword ptr [RBP + -0x24c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24c],EAX
LAB_00129fe8:
JMP 0x00129fea
LAB_00129fea:
MOV EAX,dword ptr [RBP + -0x248]
ADD EAX,0x1
MOV dword ptr [RBP + -0x248],EAX
JMP 0x00129f5a
LAB_00129ffe:
CMP dword ptr [RBP + -0x24c],0x0
JNZ 0x0012a010
CMP dword ptr [RBP + -0x250],0x0
JZ 0x0012a058
LAB_0012a010:
LEA RDI,[RBP + -0x230]
LEA RAX,[0x2d6b40]
MOV RDX,qword ptr [RAX + 0x90]
MOV ECX,dword ptr [RBP + -0x24c]
MOV R8D,dword ptr [RBP + -0x250]
MOV ESI,0x200
MOV AL,0x0
CALL 0x0017cfe0
LEA RSI,[RBP + -0x230]
MOV EDI,0x13
MOV EDX,0x4
CALL 0x0012aa10
JMP 0x0012a056
LAB_0012a056:
JMP 0x0012a058
LAB_0012a058:
JMP 0x0012a05a
LAB_0012a05a:
CALL 0x0012e1b0
CALL 0x00136b30
CALL 0x0012ad80
MOV EAX,dword ptr [RBP + -0x234]
AND EAX,0x2
CMP EAX,0x0
JNZ 0x0012a087
MOVSX EAX,byte ptr [RBP + -0x241]
CMP EAX,0x0
JZ 0x0012a1ac
LAB_0012a087:
XOR EDI,EDI
LEA RSI,[RBP + -0x2e0]
CALL 0x001241a0
CMP EAX,0x0
JNZ 0x0012a1aa
MOV RDI,qword ptr [RBP + -0x240]
IMUL RAX,qword ptr [RBP + -0x2e0],0x64
MOV qword ptr [RBP + -0x2f0],RAX
MOV RAX,qword ptr [RBP + -0x2d8]
MOV ECX,0x2710
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x2f0]
ADD RAX,RCX
CVTSI2SD XMM0,RAX
MOVSD XMM1,qword ptr [0x00185c80]
DIVSD XMM0,XMM1
IMUL RAX,qword ptr [RBP + -0x2d0],0x64
MOV qword ptr [RBP + -0x2e8],RAX
MOV RAX,qword ptr [RBP + -0x2c8]
MOV ECX,0x2710
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x2e8]
ADD RAX,RCX
CVTSI2SD XMM1,RAX
MOVSD XMM2,qword ptr [0x00185c80]
DIVSD XMM1,XMM2
MOV RDX,qword ptr [RBP + -0x2c0]
MOV RCX,qword ptr [RBP + -0x2b0]
MOV R8,qword ptr [RBP + -0x2a0]
MOV R9,qword ptr [RBP + -0x298]
MOV R13,qword ptr [RBP + -0x290]
MOV R12,qword ptr [RBP + -0x288]
MOV R15,qword ptr [RBP + -0x280]
MOV R14,qword ptr [RBP + -0x278]
MOV RBX,qword ptr [RBP + -0x270]
MOV R11,qword ptr [RBP + -0x268]
MOV R10,qword ptr [RBP + -0x260]
MOV RAX,qword ptr [RBP + -0x258]
LEA RSI,[0x180b49]
MOV qword ptr [RSP],R13
MOV qword ptr [RSP + 0x8],R12
MOV qword ptr [RSP + 0x10],R15
MOV qword ptr [RSP + 0x18],R14
MOV qword ptr [RSP + 0x20],RBX
MOV qword ptr [RSP + 0x28],R11
MOV qword ptr [RSP + 0x30],R10
MOV qword ptr [RSP + 0x38],RAX
MOV AL,0x2
CALL 0x00124430
LAB_0012a1aa:
JMP 0x0012a1ac
LAB_0012a1ac:
CALL 0x0012b5b0
CALL 0x0012b320
MOV EAX,dword ptr [RBP + -0x234]
AND EAX,0x4
CMP EAX,0x0
JNZ 0x0012a1ca
JMP 0x0012a1c6
LAB_0012a1c6:
JMP 0x0012a1c8
LAB_0012a1c8:
JMP 0x0012a1ca
LAB_0012a1ca:
CALL 0x0012bdb0
LEA RAX,[0x48e74c]
MOV EDI,dword ptr [RAX]
CALL 0x00124360
LEA RAX,[0x48e484]
MOV byte ptr [RAX],0x0
LEA RAX,[0x48da68]
MOV byte ptr [RAX],0x0
LAB_0012a1f1:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x30]
CMP RAX,RCX
JNZ 0x0012a215
ADD RSP,0x308
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012a215:
CALL 0x00124300
|
void my_end(uint param_1)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
bool bVar3;
rusage local_2e8;
int local_258;
int local_254;
uint local_250;
bool local_249;
FILE *local_248;
uint local_23c;
int1 local_238 [512];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_248 = *(FILE **)PTR_stderr_002d5fe0;
bVar2 = local_248 != *(FILE **)PTR_stderr_002d5fe0;
local_249 = bVar2;
local_23c = param_1;
if (my_init_done != '\0') {
bVar3 = local_248 == (FILE *)0x0;
if (bVar3) {
local_248 = *(FILE **)PTR_stderr_002d5fe0;
}
bVar3 = !bVar3;
local_249 = bVar3 && bVar2;
if (((param_1 & 1) != 0) || (bVar3 && bVar2)) {
local_254 = 0;
local_258 = 0;
for (local_250 = 0; local_250 < my_file_limit; local_250 = local_250 + 1) {
if (*(int *)(my_file_info + (ulong)local_250 * 0x10 + 8) != 0) {
if ((*(int *)(my_file_info + (ulong)local_250 * 0x10 + 8) == 3) ||
(*(int *)(my_file_info + (ulong)local_250 * 0x10 + 8) == 4)) {
local_258 = local_258 + 1;
}
else {
local_254 = local_254 + 1;
}
}
}
if ((local_254 != 0) || (local_258 != 0)) {
my_snprintf(local_238,0x200,globerrs._144_8_,local_254,local_258);
my_message_stderr(0x13,local_238,4);
}
}
free_charsets();
my_error_unregister_all();
my_once_free();
if ((((local_23c & 2) != 0) || (local_249 != false)) &&
(iVar1 = getrusage(RUSAGE_SELF,&local_2e8), iVar1 == 0)) {
fprintf(local_248,
"\nUser time %.2f, System time %.2f\nMaximum resident set size %ld, Integral resident set size %ld\nNon-physical pagefaults %ld, Physical pagefaults %ld, Swaps %ld\nBlocks in %ld out %ld, Messages in %ld out %ld, Signals %ld\nVoluntary context switches %ld, Involuntary context switches %ld\n"
,(double)(local_2e8.ru_utime.tv_sec * 100 + local_2e8.ru_utime.tv_usec / 10000) /
DAT_00185c80,
(double)(local_2e8.ru_stime.tv_sec * 100 + local_2e8.ru_stime.tv_usec / 10000) /
DAT_00185c80,local_2e8.ru_maxrss,local_2e8.ru_idrss,local_2e8.ru_minflt,
local_2e8.ru_majflt,local_2e8.ru_nswap,local_2e8.ru_inblock,local_2e8.ru_oublock,
local_2e8.ru_msgsnd,local_2e8.ru_msgrcv,local_2e8.ru_nsignals,local_2e8.ru_nvcsw,
local_2e8.ru_nivcsw);
}
my_thread_end();
my_thread_global_end();
my_mutex_end();
pthread_key_delete(THR_KEY_mysys);
my_thr_key_mysys_exists = 0;
my_init_done = '\0';
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
26,395 | expand_tilde | eloqsql/mysys/mf_pack.c | static char * expand_tilde(char **path)
{
if (path[0][0] == FN_LIBCHAR)
return home_dir; /* ~/ expanded to home */
#ifdef HAVE_GETPWNAM
{
char *str,save;
struct passwd *user_entry;
if (!(str=strchr(*path,FN_LIBCHAR)))
str=strend(*path);
save= *str; *str= '\0';
user_entry=getpwnam(*path);
*str=save;
endpwent();
if (user_entry)
{
*path=str;
return user_entry->pw_dir;
}
}
#endif
return (char *) 0;
} | O0 | c | expand_tilde:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x750ae
leaq 0x37dea6(%rip), %rax # 0x3f2f48
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7512f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x2f, %esi
callq 0x364f0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x750d9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xc6250
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x36720
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
callq 0x36b30
cmpq $0x0, -0x28(%rbp)
je 0x75127
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7512f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| expand_tilde:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_750AE
lea rax, home_dir
mov rax, [rax]
mov [rbp+var_8], rax
jmp loc_7512F
loc_750AE:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov esi, 2Fh ; '/'
call _strchr
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_750D9
mov rax, [rbp+var_10]
mov rdi, [rax]
call strend
mov [rbp+var_18], rax
loc_750D9:
mov rax, [rbp+var_18]
mov al, [rax]
mov [rbp+var_19], al
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov rdi, [rax]
call _getpwnam
mov [rbp+var_28], rax
mov cl, [rbp+var_19]
mov rax, [rbp+var_18]
mov [rax], cl
call _endpwent
cmp [rbp+var_28], 0
jz short loc_75127
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_28]
mov rax, [rax+20h]
mov [rbp+var_8], rax
jmp short loc_7512F
loc_75127:
mov [rbp+var_8], 0
loc_7512F:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long expand_tilde(char **a1)
{
long long v2; // [rsp+8h] [rbp-28h]
char v3; // [rsp+17h] [rbp-19h]
char *v4; // [rsp+18h] [rbp-18h]
if ( **a1 == 47 )
return home_dir;
v4 = (char *)strchr(*a1, 47LL);
if ( !v4 )
v4 = (char *)strend(*a1);
v3 = *v4;
*v4 = 0;
v2 = getpwnam(*a1);
*v4 = v3;
endpwent();
if ( !v2 )
return 0LL;
*a1 = v4;
return *(_QWORD *)(v2 + 32);
}
| expand_tilde:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x001750ae
LEA RAX,[0x4f2f48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017512f
LAB_001750ae:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV ESI,0x2f
CALL 0x001364f0
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x001750d9
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x001c6250
MOV qword ptr [RBP + -0x18],RAX
LAB_001750d9:
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00136720
MOV qword ptr [RBP + -0x28],RAX
MOV CL,byte ptr [RBP + -0x19]
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],CL
CALL 0x00136b30
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00175127
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017512f
LAB_00175127:
MOV qword ptr [RBP + -0x8],0x0
LAB_0017512f:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
char * expand_tilde(int8 *param_1)
{
char cVar1;
passwd *ppVar2;
char *local_20;
char *local_10;
if (*(char *)*param_1 == '/') {
local_10 = home_dir;
}
else {
local_20 = strchr((char *)*param_1,0x2f);
if (local_20 == (char *)0x0) {
local_20 = (char *)strend(*param_1);
}
cVar1 = *local_20;
*local_20 = '\0';
ppVar2 = getpwnam((char *)*param_1);
*local_20 = cVar1;
endpwent();
if (ppVar2 == (passwd *)0x0) {
local_10 = (char *)0x0;
}
else {
*param_1 = local_20;
local_10 = ppVar2->pw_dir;
}
}
return local_10;
}
| |
26,396 | YAML::detail::node& YAML::detail::node::get<char [18]>(char const (&) [18], std::shared_ptr<YAML::detail::memory_holder>) | aimrt_mujoco_sim/_deps/yaml-cpp-src/include/yaml-cpp/node/detail/node.h | node& get(const Key& key, shared_memory_holder pMemory) {
node& value = m_pRef->get(key, pMemory);
value.add_dependency(*this);
return value;
} | O3 | c | YAML::detail::node& YAML::detail::node::get<char [18]>(char const (&) [18], std::shared_ptr<YAML::detail::memory_holder>):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x63c3e
movq 0x4c2d0(%rip), %rcx # 0xaff00
cmpb $0x0, (%rcx)
je 0x63c3a
incl 0x8(%rax)
jmp 0x63c3e
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rdx
callq 0x63c8a
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x63c5a
callq 0x1ed80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a384
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x63c82
callq 0x1ed80
movq %rbx, %rdi
callq 0x1ffd0
| _ZN4YAML6detail4node3getIA13_cEERS1_RKT_St10shared_ptrINS0_13memory_holderEE:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
mov rdi, [rdi]
mov rax, [rdx]
mov [rsp+28h+var_20], rax
mov rax, [rdx+8]
mov [rsp+28h+var_18], rax
test rax, rax
jz short loc_63C3E
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_63C3A
inc dword ptr [rax+8]
jmp short loc_63C3E
loc_63C3A:
lock inc dword ptr [rax+8]
loc_63C3E:
lea rdx, [rsp+28h+var_20]
call _ZN4YAML6detail8node_ref3getIA13_cEERNS0_4nodeERKT_St10shared_ptrINS0_13memory_holderEE; YAML::detail::node_ref::get<char [13]>(char [13] const&,std::shared_ptr<YAML::detail::memory_holder>)
mov r14, rax
mov rdi, [rsp+28h+var_18]
test rdi, rdi
jz short loc_63C5A
call __ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_63C5A:
mov rdi, r14; this
mov rsi, rbx; YAML::detail::node *
call _ZN4YAML6detail4node14add_dependencyERS1_; YAML::detail::node::add_dependency(YAML::detail::node&)
mov rax, r14
add rsp, 18h
pop rbx
pop r14
retn
mov rbx, rax
mov rdi, [rsp+arg_8]
test rdi, rdi
jz short loc_63C82
call __ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_63C82:
mov rdi, rbx
call __Unwind_Resume
| YAML::detail::node * YAML::detail::node::get<char [13]>(
YAML::detail::node *a1,
int a2,
long long *a3,
void *a4,
int a5,
int a6)
{
long long v7; // rdi
long long v8; // rax
YAML::detail::node *v9; // r14
long long v11; // [rsp+8h] [rbp-20h] BYREF
long long v12; // [rsp+10h] [rbp-18h]
v7 = *(_QWORD *)a1;
v11 = *a3;
v8 = a3[1];
v12 = v8;
if ( v8 )
{
a4 = &_libc_single_threaded;
if ( _libc_single_threaded )
++*(_DWORD *)(v8 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v8 + 8));
}
v9 = (YAML::detail::node *)YAML::detail::node_ref::get<char [13]>(v7, a2, (unsigned int)&v11, (_DWORD)a4, a5, a6);
if ( v12 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v12);
YAML::detail::node::add_dependency(v9, a1);
return v9;
}
| get<char[13]>:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDX]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RDX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
TEST RAX,RAX
JZ 0x00163c3e
MOV RCX,qword ptr [0x001aff00]
CMP byte ptr [RCX],0x0
JZ 0x00163c3a
INC dword ptr [RAX + 0x8]
JMP 0x00163c3e
LAB_00163c3a:
INC.LOCK dword ptr [RAX + 0x8]
LAB_00163c3e:
LEA RDX,[RSP + 0x8]
CALL 0x00163c8a
LAB_00163c48:
MOV R14,RAX
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x00163c5a
CALL 0x0011ed80
LAB_00163c5a:
MOV RDI,R14
MOV RSI,RBX
CALL 0x0013a384
MOV RAX,R14
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* YAML::detail::node& YAML::detail::node::get<char [13]>(char const (&) [13],
std::shared_ptr<YAML::detail::memory_holder>) */
node * __thiscall
YAML::detail::node::get<char[13]>(node *this,int8 param_1,int8 *param_3)
{
node_ref *pnVar1;
node *this_00;
int8 local_20;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_18;
pnVar1 = *(node_ref **)this;
local_20 = *param_3;
local_18 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_3[1];
if (local_18 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_001aff00 == '\0') {
LOCK();
*(int *)(local_18 + 8) = *(int *)(local_18 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_18 + 8) = *(int *)(local_18 + 8) + 1;
}
}
/* try { // try from 00163c3e to 00163c47 has its CatchHandler @ 00163c70 */
this_00 = node_ref::get<char[13]>(pnVar1,param_1,&local_20);
if (local_18 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_18);
}
add_dependency(this_00,this);
return this_00;
}
| |
26,397 | void nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::dump_integer<long, 0>(long) | hkr04[P]cpp-mcp/common/json.hpp | void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
{{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
{{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
{{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
{{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
{{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
{{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
{{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
{{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
{{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
{{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
}
};
// special case for "0"
if (x == 0)
{
o->write_character('0');
return;
}
// use a pointer to fill the buffer
auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
number_unsigned_t abs_value;
unsigned int n_chars{};
if (is_negative_number(x))
{
*buffer_ptr = '-';
abs_value = remove_sign(static_cast<number_integer_t>(x));
// account one more byte for the minus sign
n_chars = 1 + count_digits(abs_value);
}
else
{
abs_value = static_cast<number_unsigned_t>(x);
n_chars = count_digits(abs_value);
}
// spare 1 byte for '\0'
JSON_ASSERT(n_chars < number_buffer.size() - 1);
// jump to the end to generate the string from backward,
// so we later avoid reversing the result
buffer_ptr += n_chars;
// Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
// See: https://www.youtube.com/watch?v=o4-CwDo2zpg
while (abs_value >= 100)
{
const auto digits_index = static_cast<unsigned>((abs_value % 100));
abs_value /= 100;
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
if (abs_value >= 10)
{
const auto digits_index = static_cast<unsigned>(abs_value);
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
else
{
*(--buffer_ptr) = static_cast<char>('0' + abs_value);
}
o->write_characters(number_buffer.data(), n_chars);
} | O0 | cpp | void nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::dump_integer<long, 0>(long):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x7a04c
movq 0x10(%rsp), %rdi
callq 0x78c40
movq %rax, %rdi
movq (%rdi), %rax
movl $0x30, %esi
callq *(%rax)
jmp 0x7a24f
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x7a9d0
movq 0x10(%rsp), %rdi
movq %rax, 0x30(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x38(%rsp), %rsi
callq 0x7ac20
testb $0x1, %al
jne 0x7a07c
jmp 0x7a0b0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rax
movb $0x2d, (%rax)
movq 0x38(%rsp), %rsi
callq 0x7aa00
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
callq 0x7aa20
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x7a0cd
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
callq 0x7aa20
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
cmpq $0x64, 0x28(%rsp)
jb 0x7a183
movq 0x28(%rsp), %rax
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x28(%rsp)
movl 0x20(%rsp), %eax
movl %eax, %esi
leaq 0x577a9(%rip), %rdi # 0xd18cb
callq 0x7aab0
movq %rax, %rdi
movl $0x1, %esi
callq 0x7aae0
movb (%rax), %cl
movq 0x30(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x30(%rsp)
movb %cl, -0x1(%rax)
movl 0x20(%rsp), %eax
movl %eax, %esi
leaq 0x57774(%rip), %rdi # 0xd18cb
callq 0x7aab0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7aae0
movb (%rax), %cl
movq 0x30(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x30(%rsp)
movb %cl, -0x1(%rax)
jmp 0x7a0e0
cmpq $0xa, 0x28(%rsp)
jb 0x7a1ff
movq 0x28(%rsp), %rax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, %esi
leaq 0x5772a(%rip), %rdi # 0xd18cb
callq 0x7aab0
movq %rax, %rdi
movl $0x1, %esi
callq 0x7aae0
movb (%rax), %cl
movq 0x30(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x30(%rsp)
movb %cl, -0x1(%rax)
movl 0x1c(%rsp), %eax
movl %eax, %esi
leaq 0x576f5(%rip), %rdi # 0xd18cb
callq 0x7aab0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7aae0
movb (%rax), %cl
movq 0x30(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x30(%rsp)
movb %cl, -0x1(%rax)
jmp 0x7a21e
movq 0x28(%rsp), %rax
addq $0x30, %rax
movb %al, %cl
movq 0x30(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x30(%rsp)
movb %cl, -0x1(%rax)
movq 0x10(%rsp), %rdi
callq 0x78c40
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
callq 0x7ab10
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl 0x24(%rsp), %eax
movl %eax, %edx
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov rax, [rsp+48h+var_8]
mov [rsp+48h+var_38], rax
cmp [rsp+48h+var_10], 0
jnz short loc_7A04C
mov rdi, [rsp+48h+var_38]
call _ZNKSt19__shared_ptr_accessIN8nlohmann16json_abi_v3_11_36detail23output_adapter_protocolIcEELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
mov rax, [rdi]
mov esi, 30h ; '0'
call qword ptr [rax]
jmp loc_7A24F
loc_7A04C:
mov rdi, [rsp+48h+var_38]
add rdi, 10h
call _ZNSt5arrayIcLm64EE5beginEv; std::array<char,64ul>::begin(void)
mov rdi, [rsp+48h+var_38]
mov [rsp+48h+var_18], rax
mov [rsp+48h+var_24], 0
mov rsi, [rsp+48h+var_10]
call _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE18is_negative_numberIlTnNSt9enable_ifIXsr3std9is_signedIT_EE5valueEiE4typeELi0EEEbSJ_
test al, 1
jnz short loc_7A07C
jmp short loc_7A0B0
loc_7A07C:
mov rdi, [rsp+48h+var_38]
mov rax, [rsp+48h+var_18]
mov byte ptr [rax], 2Dh ; '-'
mov rsi, [rsp+48h+var_10]
call _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE11remove_signEl; nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::remove_sign(long)
mov rdi, [rsp+48h+var_38]
mov [rsp+48h+var_20], rax
mov rsi, [rsp+48h+var_20]
call _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12count_digitsEm; nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::count_digits(ulong)
add eax, 1
mov [rsp+48h+var_24], eax
jmp short loc_7A0CD
loc_7A0B0:
mov rdi, [rsp+48h+var_38]
mov rax, [rsp+48h+var_10]
mov [rsp+48h+var_20], rax
mov rsi, [rsp+48h+var_20]
call _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12count_digitsEm; nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::count_digits(ulong)
mov [rsp+48h+var_24], eax
loc_7A0CD:
mov ecx, [rsp+48h+var_24]
mov rax, [rsp+48h+var_18]
mov ecx, ecx
add rax, rcx
mov [rsp+48h+var_18], rax
loc_7A0E0:
cmp [rsp+48h+var_20], 64h ; 'd'
jb loc_7A183
mov rax, [rsp+48h+var_20]
mov ecx, 64h ; 'd'
xor edx, edx
div rcx
mov eax, edx
mov [rsp+48h+var_28], eax
mov rax, [rsp+48h+var_20]
mov ecx, 64h ; 'd'
xor edx, edx
div rcx
mov [rsp+48h+var_20], rax
mov eax, [rsp+48h+var_28]
mov esi, eax
lea rdi, _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
call _ZNKSt5arrayIS_IcLm2EELm100EEixEm; std::array<std::array<char,2ul>,100ul>::operator[](ulong)
mov rdi, rax
mov esi, 1
call _ZNKSt5arrayIcLm2EEixEm; std::array<char,2ul>::operator[](ulong)
mov cl, [rax]
mov rax, [rsp+48h+var_18]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rsp+48h+var_18], rdx
mov [rax-1], cl
mov eax, [rsp+48h+var_28]
mov esi, eax
lea rdi, _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
call _ZNKSt5arrayIS_IcLm2EELm100EEixEm; std::array<std::array<char,2ul>,100ul>::operator[](ulong)
mov rdi, rax
xor eax, eax
mov esi, eax
call _ZNKSt5arrayIcLm2EEixEm; std::array<char,2ul>::operator[](ulong)
mov cl, [rax]
mov rax, [rsp+48h+var_18]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rsp+48h+var_18], rdx
mov [rax-1], cl
jmp loc_7A0E0
loc_7A183:
cmp [rsp+48h+var_20], 0Ah
jb short loc_7A1FF
mov rax, [rsp+48h+var_20]
mov [rsp+48h+var_2C], eax
mov eax, [rsp+48h+var_2C]
mov esi, eax
lea rdi, _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
call _ZNKSt5arrayIS_IcLm2EELm100EEixEm; std::array<std::array<char,2ul>,100ul>::operator[](ulong)
mov rdi, rax
mov esi, 1
call _ZNKSt5arrayIcLm2EEixEm; std::array<char,2ul>::operator[](ulong)
mov cl, [rax]
mov rax, [rsp+48h+var_18]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rsp+48h+var_18], rdx
mov [rax-1], cl
mov eax, [rsp+48h+var_2C]
mov esi, eax
lea rdi, _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
call _ZNKSt5arrayIS_IcLm2EELm100EEixEm; std::array<std::array<char,2ul>,100ul>::operator[](ulong)
mov rdi, rax
xor eax, eax
mov esi, eax
call _ZNKSt5arrayIcLm2EEixEm; std::array<char,2ul>::operator[](ulong)
mov cl, [rax]
mov rax, [rsp+48h+var_18]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rsp+48h+var_18], rdx
mov [rax-1], cl
jmp short loc_7A21E
loc_7A1FF:
mov rax, [rsp+48h+var_20]
add rax, 30h ; '0'
mov cl, al
mov rax, [rsp+48h+var_18]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rsp+48h+var_18], rdx
mov [rax-1], cl
loc_7A21E:
mov rdi, [rsp+48h+var_38]
call _ZNKSt19__shared_ptr_accessIN8nlohmann16json_abi_v3_11_36detail23output_adapter_protocolIcEELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, [rsp+48h+var_38]
mov [rsp+48h+var_40], rax
add rdi, 10h
call _ZNSt5arrayIcLm64EE4dataEv; std::array<char,64ul>::data(void)
mov rdi, [rsp+48h+var_40]
mov rsi, rax
mov eax, [rsp+48h+var_24]
mov edx, eax
mov rax, [rdi]
call qword ptr [rax+8]
loc_7A24F:
add rsp, 48h
retn
| long long ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_(
long long a1,
unsigned long long a2)
{
long long ( ***v2)(_QWORD, long long); // rax
long long v4; // rax
long long v5; // rax
long long v6; // rax
long long v7; // rax
long long v8; // rax
long long v9; // [rsp+8h] [rbp-40h]
unsigned int v10; // [rsp+20h] [rbp-28h]
unsigned int v11; // [rsp+24h] [rbp-24h]
unsigned long long v12; // [rsp+28h] [rbp-20h]
_BYTE *v13; // [rsp+30h] [rbp-18h]
_BYTE *v14; // [rsp+30h] [rbp-18h]
if ( a2 )
{
v13 = (_BYTE *)std::array<char,64ul>::begin(a1 + 16);
if ( (ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE18is_negative_numberIlTnNSt9enable_ifIXsr3std9is_signedIT_EE5valueEiE4typeELi0EEEbSJ_(
a1,
a2) & 1) != 0 )
{
*v13 = 45;
v12 = nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::remove_sign(
a1,
a2);
v11 = nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::count_digits(
a1,
v12)
+ 1;
}
else
{
v12 = a2;
v11 = nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::count_digits(
a1,
a2);
}
v14 = &v13[v11];
while ( v12 >= 0x64 )
{
v10 = v12 % 0x64;
v12 /= 0x64uLL;
v4 = std::array<std::array<char,2ul>,100ul>::operator[](
&ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99,
v10);
*(v14 - 1) = *(_BYTE *)std::array<char,2ul>::operator[](v4, 1LL);
v5 = std::array<std::array<char,2ul>,100ul>::operator[](
&ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99,
v10);
v14 -= 2;
*v14 = *(_BYTE *)std::array<char,2ul>::operator[](v5, 0LL);
}
if ( v12 < 0xA )
{
*(v14 - 1) = v12 + 48;
}
else
{
v6 = std::array<std::array<char,2ul>,100ul>::operator[](
&ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99,
(unsigned int)v12);
*(v14 - 1) = *(_BYTE *)std::array<char,2ul>::operator[](v6, 1LL);
v7 = std::array<std::array<char,2ul>,100ul>::operator[](
&ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99,
(unsigned int)v12);
*(v14 - 2) = *(_BYTE *)std::array<char,2ul>::operator[](v7, 0LL);
}
v9 = std::__shared_ptr_access<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(a1);
v8 = std::array<char,64ul>::data(a1 + 16);
return (*(long long ( **)(long long, long long, _QWORD))(*(_QWORD *)v9 + 8LL))(v9, v8, v11);
}
else
{
v2 = (long long ( ***)(_QWORD, long long))std::__shared_ptr_access<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(a1);
return (**v2)(v2, 48LL);
}
}
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV qword ptr [RSP + 0x38],RSI
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x38],0x0
JNZ 0x0017a04c
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00178c40
MOV RDI,RAX
MOV RAX,qword ptr [RDI]
MOV ESI,0x30
CALL qword ptr [RAX]
JMP 0x0017a24f
LAB_0017a04c:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x10
CALL 0x0017a9d0
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RAX
MOV dword ptr [RSP + 0x24],0x0
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x0017ac20
TEST AL,0x1
JNZ 0x0017a07c
JMP 0x0017a0b0
LAB_0017a07c:
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x30]
MOV byte ptr [RAX],0x2d
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x0017aa00
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x28],RAX
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x0017aa20
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
JMP 0x0017a0cd
LAB_0017a0b0:
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x28],RAX
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x0017aa20
MOV dword ptr [RSP + 0x24],EAX
LAB_0017a0cd:
MOV ECX,dword ptr [RSP + 0x24]
MOV RAX,qword ptr [RSP + 0x30]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RSP + 0x30],RAX
LAB_0017a0e0:
CMP qword ptr [RSP + 0x28],0x64
JC 0x0017a183
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,0x64
XOR EDX,EDX
DIV RCX
MOV EAX,EDX
MOV dword ptr [RSP + 0x20],EAX
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,0x64
XOR EDX,EDX
DIV RCX
MOV qword ptr [RSP + 0x28],RAX
MOV EAX,dword ptr [RSP + 0x20]
MOV ESI,EAX
LEA RDI,[0x1d18cb]
CALL 0x0017aab0
MOV RDI,RAX
MOV ESI,0x1
CALL 0x0017aae0
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RSP + 0x30]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RSP + 0x30],RDX
MOV byte ptr [RAX + -0x1],CL
MOV EAX,dword ptr [RSP + 0x20]
MOV ESI,EAX
LEA RDI,[0x1d18cb]
CALL 0x0017aab0
MOV RDI,RAX
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0017aae0
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RSP + 0x30]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RSP + 0x30],RDX
MOV byte ptr [RAX + -0x1],CL
JMP 0x0017a0e0
LAB_0017a183:
CMP qword ptr [RSP + 0x28],0xa
JC 0x0017a1ff
MOV RAX,qword ptr [RSP + 0x28]
MOV dword ptr [RSP + 0x1c],EAX
MOV EAX,dword ptr [RSP + 0x1c]
MOV ESI,EAX
LEA RDI,[0x1d18cb]
CALL 0x0017aab0
MOV RDI,RAX
MOV ESI,0x1
CALL 0x0017aae0
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RSP + 0x30]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RSP + 0x30],RDX
MOV byte ptr [RAX + -0x1],CL
MOV EAX,dword ptr [RSP + 0x1c]
MOV ESI,EAX
LEA RDI,[0x1d18cb]
CALL 0x0017aab0
MOV RDI,RAX
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0017aae0
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RSP + 0x30]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RSP + 0x30],RDX
MOV byte ptr [RAX + -0x1],CL
JMP 0x0017a21e
LAB_0017a1ff:
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x30]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RSP + 0x30],RDX
MOV byte ptr [RAX + -0x1],CL
LAB_0017a21e:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00178c40
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
ADD RDI,0x10
CALL 0x0017ab10
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV EAX,dword ptr [RSP + 0x24]
MOV EDX,EAX
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0017a24f:
ADD RSP,0x48
RET
|
void _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_
(__shared_ptr_access<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>,(__gnu_cxx::_Lock_policy)2,false,false>
*param_1,ulong param_2)
{
int1 auVar1 [16];
int iVar2;
uint uVar3;
int8 *puVar4;
int1 *puVar5;
ulong uVar6;
array<char,2ul> *paVar7;
long *plVar8;
int8 uVar9;
uint local_24;
ulong local_20;
int1 *local_18;
if (param_2 == 0) {
puVar4 = (int8 *)
std::
__shared_ptr_access<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->(param_1);
(**(code **)*puVar4)(puVar4,0x30);
}
else {
puVar5 = (int1 *)std::array<char,64ul>::begin((array<char,64ul> *)(param_1 + 0x10));
uVar6 = _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE18is_negative_numberIlTnNSt9enable_ifIXsr3std9is_signedIT_EE5valueEiE4typeELi0EEEbSJ_
(param_1,param_2);
if ((uVar6 & 1) == 0) {
local_24 = nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::count_digits((serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)param_1,param_2);
local_20 = param_2;
}
else {
*puVar5 = 0x2d;
local_20 = nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::remove_sign((serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)param_1,param_2);
iVar2 = nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::count_digits((serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)param_1,local_20);
local_24 = iVar2 + 1;
}
local_18 = puVar5 + local_24;
while (99 < local_20) {
auVar1._8_8_ = 0;
auVar1._0_8_ = local_20;
uVar3 = SUB164(auVar1 % ZEXT816(100),0);
local_20 = local_20 / 100;
paVar7 = (array<char,2ul> *)
std::array<std::array<char,2ul>,100ul>::operator[]
((array<std::array<char,2ul>,100ul> *)
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
,(ulong)uVar3);
puVar5 = (int1 *)std::array<char,2ul>::operator[](paVar7,1);
local_18[-1] = *puVar5;
paVar7 = (array<char,2ul> *)
std::array<std::array<char,2ul>,100ul>::operator[]
((array<std::array<char,2ul>,100ul> *)
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
,(ulong)uVar3);
puVar5 = (int1 *)std::array<char,2ul>::operator[](paVar7,0);
local_18[-2] = *puVar5;
local_18 = local_18 + -2;
}
if (local_20 < 10) {
local_18[-1] = (char)local_20 + '0';
}
else {
paVar7 = (array<char,2ul> *)
std::array<std::array<char,2ul>,100ul>::operator[]
((array<std::array<char,2ul>,100ul> *)
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
,local_20 & 0xffffffff);
puVar5 = (int1 *)std::array<char,2ul>::operator[](paVar7,1);
local_18[-1] = *puVar5;
paVar7 = (array<char,2ul> *)
std::array<std::array<char,2ul>,100ul>::operator[]
((array<std::array<char,2ul>,100ul> *)
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
,local_20 & 0xffffffff);
puVar5 = (int1 *)std::array<char,2ul>::operator[](paVar7,0);
local_18[-2] = *puVar5;
}
plVar8 = (long *)std::
__shared_ptr_access<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->(param_1);
uVar9 = std::array<char,64ul>::data((array<char,64ul> *)(param_1 + 0x10));
(**(code **)(*plVar8 + 8))(plVar8,uVar9,local_24);
}
return;
}
| |
26,398 | void nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::dump_integer<long, 0>(long) | hkr04[P]cpp-mcp/common/json.hpp | void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
{{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
{{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
{{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
{{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
{{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
{{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
{{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
{{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
{{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
{{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
}
};
// special case for "0"
if (x == 0)
{
o->write_character('0');
return;
}
// use a pointer to fill the buffer
auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
number_unsigned_t abs_value;
unsigned int n_chars{};
if (is_negative_number(x))
{
*buffer_ptr = '-';
abs_value = remove_sign(static_cast<number_integer_t>(x));
// account one more byte for the minus sign
n_chars = 1 + count_digits(abs_value);
}
else
{
abs_value = static_cast<number_unsigned_t>(x);
n_chars = count_digits(abs_value);
}
// spare 1 byte for '\0'
JSON_ASSERT(n_chars < number_buffer.size() - 1);
// jump to the end to generate the string from backward,
// so we later avoid reversing the result
buffer_ptr += n_chars;
// Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
// See: https://www.youtube.com/watch?v=o4-CwDo2zpg
while (abs_value >= 100)
{
const auto digits_index = static_cast<unsigned>((abs_value % 100));
abs_value /= 100;
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
if (abs_value >= 10)
{
const auto digits_index = static_cast<unsigned>(abs_value);
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
else
{
*(--buffer_ptr) = static_cast<char>('0' + abs_value);
}
o->write_characters(number_buffer.data(), n_chars);
} | O2 | cpp | void nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::dump_integer<long, 0>(long):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0xd4ca
movq %rsi, %r15
leaq 0x10(%rbx), %r14
testq %rsi, %rsi
js 0xd4dd
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7ee
jmp 0xd4f1
movq (%rbx), %rdi
movq (%rdi), %rax
movq (%rax), %rax
pushq $0x30
popq %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movb $0x2d, 0x10(%rbx)
negq %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7ee
incl %eax
movl %eax, %ecx
leaq (%r14,%rcx), %rsi
pushq $0x64
popq %r8
leaq 0x2b77e(%rip), %rdi # 0x38c80
cmpq $0x64, %r15
jb 0xd523
movq %r15, %rax
xorl %edx, %edx
divq %r8
movl %edx, %edx
movzwl (%rdi,%rdx,2), %edx
movw %dx, -0x2(%rsi)
addq $-0x2, %rsi
movq %rax, %r15
jmp 0xd502
cmpq $0xa, %r15
jb 0xd53a
movb (%rdi,%r15,2), %al
movb 0x1(%rdi,%r15,2), %dl
movb %dl, -0x1(%rsi)
pushq $-0x2
popq %rdx
jmp 0xd544
orb $0x30, %r15b
pushq $-0x1
popq %rdx
movl %r15d, %eax
movb %al, (%rsi,%rdx)
movq (%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %r14, %rsi
movq %rcx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_:
push r15
push r14
push rbx
mov rbx, rdi
test rsi, rsi
jz short loc_D4CA
mov r15, rsi
lea r14, [rbx+10h]
test rsi, rsi
js short loc_D4DD
mov rdi, rbx
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12count_digitsEm; nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::count_digits(ulong)
jmp short loc_D4F1
loc_D4CA:
mov rdi, [rbx]
mov rax, [rdi]
mov rax, [rax]
push 30h ; '0'
pop rsi
pop rbx
pop r14
pop r15
jmp rax
loc_D4DD:
mov byte ptr [rbx+10h], 2Dh ; '-'
neg r15
mov rdi, rbx
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12count_digitsEm; nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::count_digits(ulong)
inc eax
loc_D4F1:
mov ecx, eax
lea rsi, [r14+rcx]
push 64h ; 'd'
pop r8
lea rdi, _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
loc_D502:
cmp r15, 64h ; 'd'
jb short loc_D523
mov rax, r15
xor edx, edx
div r8
mov edx, edx
movzx edx, word ptr [rdi+rdx*2]
mov [rsi-2], dx
add rsi, 0FFFFFFFFFFFFFFFEh
mov r15, rax
jmp short loc_D502
loc_D523:
cmp r15, 0Ah
jb short loc_D53A
mov al, [rdi+r15*2]
mov dl, [rdi+r15*2+1]
mov [rsi-1], dl
push 0FFFFFFFFFFFFFFFEh
pop rdx
jmp short loc_D544
loc_D53A:
or r15b, 30h
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov eax, r15d
loc_D544:
mov [rsi+rdx], al
mov rdi, [rbx]
mov rax, [rdi]
mov rax, [rax+8]
mov rsi, r14
mov rdx, rcx
pop rbx
pop r14
pop r15
jmp rax
| long long ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_(
_QWORD *a1,
long long a2)
{
unsigned long long v2; // r15
unsigned int v3; // eax
long long v5; // rcx
long long v6; // rsi
char v7; // al
long long v8; // rdx
if ( !a2 )
return (**(long long ( ***)(_QWORD, long long))*a1)(*a1, 48LL);
v2 = a2;
if ( a2 < 0 )
{
*((_BYTE *)a1 + 16) = 45;
v2 = -a2;
v3 = nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::count_digits(
a1,
-a2)
+ 1;
}
else
{
v3 = nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::count_digits(
a1,
a2);
}
v5 = v3;
v6 = (long long)a1 + v3 + 16;
while ( v2 >= 0x64 )
{
*(_WORD *)(v6 - 2) = *((_WORD *)&ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ v2 % 0x64);
v6 -= 2LL;
v2 /= 0x64uLL;
}
if ( v2 < 0xA )
{
v8 = -1LL;
v7 = v2 | 0x30;
}
else
{
v7 = *((_BYTE *)&ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ 2 * v2);
*(_BYTE *)(v6 - 1) = *((_BYTE *)&ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ 2 * v2
+ 1);
v8 = -2LL;
}
*(_BYTE *)(v6 + v8) = v7;
return (*(long long ( **)(_QWORD, _QWORD *, long long))(*(_QWORD *)*a1 + 8LL))(*a1, a1 + 2, v5);
}
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
TEST RSI,RSI
JZ 0x0010d4ca
MOV R15,RSI
LEA R14,[RBX + 0x10]
TEST RSI,RSI
JS 0x0010d4dd
MOV RDI,RBX
MOV RSI,R15
CALL 0x0010d7ee
JMP 0x0010d4f1
LAB_0010d4ca:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX]
PUSH 0x30
POP RSI
POP RBX
POP R14
POP R15
JMP RAX
LAB_0010d4dd:
MOV byte ptr [RBX + 0x10],0x2d
NEG R15
MOV RDI,RBX
MOV RSI,R15
CALL 0x0010d7ee
INC EAX
LAB_0010d4f1:
MOV ECX,EAX
LEA RSI,[R14 + RCX*0x1]
PUSH 0x64
POP R8
LEA RDI,[0x138c80]
LAB_0010d502:
CMP R15,0x64
JC 0x0010d523
MOV RAX,R15
XOR EDX,EDX
DIV R8
MOV EDX,EDX
MOVZX EDX,word ptr [RDI + RDX*0x2]
MOV word ptr [RSI + -0x2],DX
ADD RSI,-0x2
MOV R15,RAX
JMP 0x0010d502
LAB_0010d523:
CMP R15,0xa
JC 0x0010d53a
MOV AL,byte ptr [RDI + R15*0x2]
MOV DL,byte ptr [RDI + R15*0x2 + 0x1]
MOV byte ptr [RSI + -0x1],DL
PUSH -0x2
POP RDX
JMP 0x0010d544
LAB_0010d53a:
OR R15B,0x30
PUSH -0x1
POP RDX
MOV EAX,R15D
LAB_0010d544:
MOV byte ptr [RSI + RDX*0x1],AL
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x8]
MOV RSI,R14
MOV RDX,RCX
POP RBX
POP R14
POP R15
JMP RAX
|
void _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_
(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*param_1,ulong param_2)
{
uint uVar1;
int iVar2;
long lVar3;
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*psVar4;
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
sVar5;
if (param_2 != 0) {
if ((long)param_2 < 0) {
param_1[0x10] =
(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)0x2d;
param_2 = -param_2;
iVar2 = nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::count_digits(param_1,param_2);
uVar1 = iVar2 + 1;
}
else {
uVar1 = nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::count_digits(param_1,param_2);
}
psVar4 = param_1 + 0x10 + uVar1;
for (; 99 < param_2; param_2 = param_2 / 100) {
*(int2 *)(psVar4 + -2) =
*(int2 *)
(
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ (param_2 % 100) * 2);
psVar4 = psVar4 + -2;
}
if (param_2 < 10) {
sVar5 = (serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)((byte)param_2 | 0x30);
lVar3 = -1;
}
else {
sVar5 = *(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)(
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ param_2 * 2);
psVar4[-1] = *(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)(
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ param_2 * 2 + 1);
lVar3 = -2;
}
psVar4[lVar3] = sVar5;
/* WARNING: Could not recover jumptable at 0x0010d55c. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(**(long **)param_1 + 8))(*(long **)param_1,param_1 + 0x10,(ulong)uVar1);
return;
}
/* WARNING: Could not recover jumptable at 0x0010d4db. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)**(int8 **)param_1)(*(int8 **)param_1,0x30);
return;
}
| |
26,399 | void nlohmann::json_abi_v3_11_3::detail::int_to_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long) | monkey531[P]llama/common/json.hpp | void int_to_string( string_type& target, std::size_t value )
{
// For ADL
using std::to_string;
target = to_string(value);
} | O3 | cpp | void nlohmann::json_abi_v3_11_3::detail::int_to_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %esi
cmpq $0xa, %r14
jb 0x70e58
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r14, %rcx
cmpq $0x63, %rcx
jbe 0x70e51
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0x70e56
cmpq $0x2710, %rcx # imm = 0x2710
jb 0x70e58
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0x70e1b
addl $-0x3, %esi
jmp 0x70e58
addl $-0x2, %esi
jmp 0x70e58
decl %esi
movl %esi, %esi
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x187a0
movq (%r15), %rdi
movl 0x8(%r15), %esi
movq %r14, %rdx
callq 0x49253
movq %rbx, %rdi
movq %r15, %rsi
callq 0x187f0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x70ea2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZN8nlohmann16json_abi_v3_11_36detail13int_to_stringINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEvRT_m:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
mov esi, 1
cmp r14, 0Ah
jb short loc_70E58
mov esi, 4
mov rdi, 346DC5D63886594Bh
mov rcx, r14
loc_70E1B:
cmp rcx, 63h ; 'c'
jbe short loc_70E51
cmp rcx, 3E7h
jbe short loc_70E56
cmp rcx, 2710h
jb short loc_70E58
mov rax, rcx
mul rdi
shr rdx, 0Bh
add esi, 4
cmp rcx, 1869Fh
mov rcx, rdx
ja short loc_70E1B
add esi, 0FFFFFFFDh
jmp short loc_70E58
loc_70E51:
add esi, 0FFFFFFFEh
jmp short loc_70E58
loc_70E56:
dec esi
loc_70E58:
mov esi, esi
lea r12, [rsp+48h+var_30]
mov [r12-10h], r12
lea r15, [rsp+48h+var_40]
mov rdi, r15
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov rdi, [r15]
mov esi, [r15+8]
mov rdx, r14
call _ZNSt8__detail18__to_chars_10_implImEEvPcjT_; std::__detail::__to_chars_10_impl<ulong>(char *,uint,ulong)
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r15]; void *
cmp rdi, r12
jz short loc_70EA2
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_70EA2:
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
| void nlohmann::json_abi_v3_11_3::detail::int_to_string<std::string>(long long a1, unsigned long long a2)
{
unsigned int v3; // esi
unsigned long long v4; // rcx
bool v5; // cc
char *v6; // [rsp+8h] [rbp-40h] BYREF
int v7; // [rsp+10h] [rbp-38h]
_QWORD v8[6]; // [rsp+18h] [rbp-30h] BYREF
v3 = 1;
if ( a2 >= 0xA )
{
v3 = 4;
v4 = a2;
while ( 1 )
{
if ( v4 <= 0x63 )
{
v3 -= 2;
goto LABEL_10;
}
if ( v4 <= 0x3E7 )
break;
if ( v4 < 0x2710 )
goto LABEL_10;
v3 += 4;
v5 = v4 <= 0x1869F;
v4 /= 0x2710uLL;
if ( v5 )
{
v3 -= 3;
goto LABEL_10;
}
}
--v3;
}
LABEL_10:
v6 = (char *)v8;
std::string::_M_construct(&v6, v3, 0LL);
std::__detail::__to_chars_10_impl<unsigned long>(v6, v7, a2);
std::string::operator=(a1, &v6);
if ( v6 != (char *)v8 )
operator delete(v6, v8[0] + 1LL);
}
| int_to_string<std::__cxx11::string>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
MOV ESI,0x1
CMP R14,0xa
JC 0x00170e58
MOV ESI,0x4
MOV RDI,0x346dc5d63886594b
MOV RCX,R14
LAB_00170e1b:
CMP RCX,0x63
JBE 0x00170e51
CMP RCX,0x3e7
JBE 0x00170e56
CMP RCX,0x2710
JC 0x00170e58
MOV RAX,RCX
MUL RDI
SHR RDX,0xb
ADD ESI,0x4
CMP RCX,0x1869f
MOV RCX,RDX
JA 0x00170e1b
ADD ESI,-0x3
JMP 0x00170e58
LAB_00170e51:
ADD ESI,-0x2
JMP 0x00170e58
LAB_00170e56:
DEC ESI
LAB_00170e58:
MOV ESI,ESI
LEA R12,[RSP + 0x18]
MOV qword ptr [R12 + -0x10],R12
LEA R15,[RSP + 0x8]
MOV RDI,R15
XOR EDX,EDX
CALL 0x001187a0
MOV RDI,qword ptr [R15]
MOV ESI,dword ptr [R15 + 0x8]
MOV RDX,R14
CALL 0x00149253
MOV RDI,RBX
MOV RSI,R15
CALL 0x001187f0
MOV RDI,qword ptr [R15]
CMP RDI,R12
JZ 0x00170ea2
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001186a0
LAB_00170ea2:
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
/* void nlohmann::json_abi_v3_11_3::detail::int_to_string<std::__cxx11::string
>(std::__cxx11::string&, unsigned long) */
void nlohmann::json_abi_v3_11_3::detail::int_to_string<std::__cxx11::string>
(string *param_1,ulong param_2)
{
bool bVar1;
char cVar2;
ulong uVar3;
char cVar4;
long *local_40;
uint local_38;
long local_30 [2];
cVar4 = '\x01';
if (9 < param_2) {
uVar3 = param_2;
cVar2 = '\x04';
do {
cVar4 = cVar2;
if (uVar3 < 100) {
cVar4 = cVar4 + -2;
goto LAB_00170e58;
}
if (uVar3 < 1000) {
cVar4 = cVar4 + -1;
goto LAB_00170e58;
}
if (uVar3 < 10000) goto LAB_00170e58;
bVar1 = 99999 < uVar3;
uVar3 = uVar3 / 10000;
cVar2 = cVar4 + '\x04';
} while (bVar1);
cVar4 = cVar4 + '\x01';
}
LAB_00170e58:
local_40 = local_30;
std::__cxx11::string::_M_construct((ulong)&local_40,cVar4);
std::__detail::__to_chars_10_impl<unsigned_long>((char *)local_40,local_38,param_2);
std::__cxx11::string::operator=(param_1,(string *)&local_40);
if (local_40 != local_30) {
operator_delete(local_40,local_30[0] + 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.