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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
3,200 | OpenSubdiv::v3_6_0::Far::PatchTable::StencilTablePtr OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::acquireStencilTable<double>(OpenSubdiv::v3_6_0::Far::PatchTable::StencilTablePtr&) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp | PatchTableBuilder::StencilTablePtr
PatchTableBuilder::LocalPointHelper::acquireStencilTable(
StencilTablePtr& stencilTableMember) {
StencilTableReal<REAL> * stencilTable = stencilTableMember.Get<REAL>();
if (stencilTable) {
if (stencilTable->GetNumStencils() > 0) {
stencilTable->finalize();
} else {
delete stencilTable;
stencilTable = 0;
}
}
stencilTableMember.Set();
return StencilTablePtr(stencilTable);
} | O3 | cpp | OpenSubdiv::v3_6_0::Far::PatchTable::StencilTablePtr OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::acquireStencilTable<double>(OpenSubdiv::v3_6_0::Far::PatchTable::StencilTablePtr&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x70c9c
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
shrq $0x2, %rax
testl %eax, %eax
jle 0x70c93
movq %r14, %rdi
callq 0x381d0
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
leaq 0x28(%r14), %r15
shrq $0x2, %rax
movslq %eax, %rsi
movq %r15, %rdi
callq 0x39670
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
jle 0x70c9f
movq (%r15), %rdx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xorl %esi, %esi
xorl %edi, %edi
movl %edi, (%rdx,%rsi,4)
addl (%rax,%rsi,4), %edi
incq %rsi
cmpq %rsi, %rcx
jne 0x70c83
jmp 0x70c9f
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
xorl %r14d, %r14d
movq $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelper19acquireStencilTableIdEENS1_10PatchTable15StencilTablePtrERS6_:
push r15
push r14
push rbx
mov rbx, rsi
mov r14, [rsi]
test r14, r14
jz short loc_70C9C
mov rax, [r14+18h]
sub rax, [r14+10h]
shr rax, 2
test eax, eax
jle short loc_70C93
mov rdi, r14
call __ZN10OpenSubdiv6v3_6_03Far16StencilTableRealIdE11shrinkToFitEv; OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::shrinkToFit(void)
mov rax, [r14+18h]
sub rax, [r14+10h]
lea r15, [r14+28h]
shr rax, 2
movsxd rsi, eax
mov rdi, r15
call __ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
mov rax, [r14+10h]
mov rcx, [r14+18h]
sub rcx, rax
shr rcx, 2
test ecx, ecx
jle short loc_70C9F
mov rdx, [r15]
and ecx, 7FFFFFFFh
xor esi, esi
xor edi, edi
loc_70C83:
mov [rdx+rsi*4], edi
add edi, [rax+rsi*4]
inc rsi
cmp rcx, rsi
jnz short loc_70C83
jmp short loc_70C9F
loc_70C93:
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+8]
loc_70C9C:
xor r14d, r14d
loc_70C9F:
mov qword ptr [rbx], 0
mov rax, r14
pop rbx
pop r14
pop r15
retn
| _QWORD * OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::acquireStencilTable<double>(
long long a1,
_QWORD *a2)
{
_QWORD *v3; // r14
long long v4; // rax
long long v5; // rdx
long long v6; // rcx
long long v7; // rsi
int v8; // edi
v3 = (_QWORD *)*a2;
if ( !*a2 )
goto LABEL_8;
if ( (int)((v3[3] - v3[2]) >> 2) <= 0 )
{
(*(void ( **)(_QWORD))(*v3 + 8LL))(*a2);
LABEL_8:
v3 = 0LL;
goto LABEL_9;
}
OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::shrinkToFit(*a2);
std::vector<int>::resize(v3 + 5, (int)((v3[3] - v3[2]) >> 2));
v4 = v3[2];
if ( (int)((unsigned long long)(v3[3] - v4) >> 2) > 0 )
{
v5 = v3[5];
v6 = ((unsigned long long)(v3[3] - v4) >> 2) & 0x7FFFFFFF;
v7 = 0LL;
v8 = 0;
do
{
*(_DWORD *)(v5 + 4 * v7) = v8;
v8 += *(_DWORD *)(v4 + 4 * v7++);
}
while ( v6 != v7 );
}
LABEL_9:
*a2 = 0LL;
return v3;
}
| acquireStencilTable<double>:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,qword ptr [RSI]
TEST R14,R14
JZ 0x00170c9c
MOV RAX,qword ptr [R14 + 0x18]
SUB RAX,qword ptr [R14 + 0x10]
SHR RAX,0x2
TEST EAX,EAX
JLE 0x00170c93
MOV RDI,R14
CALL 0x001381d0
MOV RAX,qword ptr [R14 + 0x18]
SUB RAX,qword ptr [R14 + 0x10]
LEA R15,[R14 + 0x28]
SHR RAX,0x2
MOVSXD RSI,EAX
MOV RDI,R15
CALL 0x00139670
MOV RAX,qword ptr [R14 + 0x10]
MOV RCX,qword ptr [R14 + 0x18]
SUB RCX,RAX
SHR RCX,0x2
TEST ECX,ECX
JLE 0x00170c9f
MOV RDX,qword ptr [R15]
AND ECX,0x7fffffff
XOR ESI,ESI
XOR EDI,EDI
LAB_00170c83:
MOV dword ptr [RDX + RSI*0x4],EDI
ADD EDI,dword ptr [RAX + RSI*0x4]
INC RSI
CMP RCX,RSI
JNZ 0x00170c83
JMP 0x00170c9f
LAB_00170c93:
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x8]
LAB_00170c9c:
XOR R14D,R14D
LAB_00170c9f:
MOV qword ptr [RBX],0x0
MOV RAX,R14
POP RBX
POP R14
POP R15
RET
|
/* OpenSubdiv::v3_6_0::Far::PatchTable::StencilTablePtr
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::acquireStencilTable<double>(OpenSubdiv::v3_6_0::Far::PatchTable::StencilTablePtr&)
*/
StencilTableReal<double> * __thiscall
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::acquireStencilTable<double>
(LocalPointHelper *this,StencilTablePtr_conflict *param_1)
{
long lVar1;
long lVar2;
uint uVar3;
ulong uVar4;
int iVar5;
StencilTableReal<double> *this_00;
this_00 = *(StencilTableReal<double> **)param_1;
if (this_00 != (StencilTableReal<double> *)0x0) {
if (0 < (int)((ulong)(*(long *)(this_00 + 0x18) - *(long *)(this_00 + 0x10)) >> 2)) {
StencilTableReal<double>::shrinkToFit(this_00);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(this_00 + 0x28),
(long)(int)((ulong)(*(long *)(this_00 + 0x18) - *(long *)(this_00 + 0x10)) >> 2));
lVar1 = *(long *)(this_00 + 0x10);
uVar3 = (uint)((ulong)(*(long *)(this_00 + 0x18) - lVar1) >> 2);
if (0 < (int)uVar3) {
lVar2 = *(long *)(this_00 + 0x28);
uVar4 = 0;
iVar5 = 0;
do {
*(int *)(lVar2 + uVar4 * 4) = iVar5;
iVar5 = iVar5 + *(int *)(lVar1 + uVar4 * 4);
uVar4 = uVar4 + 1;
} while ((uVar3 & 0x7fffffff) != uVar4);
}
goto LAB_00170c9f;
}
(**(code **)(*(long *)this_00 + 8))(this_00);
}
this_00 = (StencilTableReal<double> *)0x0;
LAB_00170c9f:
*(int8 *)param_1 = 0;
return this_00;
}
|
|
3,201 | ssz_union_selector | corpus-core[P]colibri-stateless/src/util/ssz_builder.c | uint8_t ssz_union_selector(const ssz_def_t* union_types, size_t union_types_len, const char* name, const ssz_def_t** def) {
*def = NULL;
for (int i = 0; i < union_types_len; i++) {
if (union_types[i].name == name || strcmp(union_types[i].name, name) == 0) {
*def = union_types + i;
return i;
}
}
return 0;
} | O0 | c | ssz_union_selector:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xa2a87
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
je 0xa2a5c
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x23320
cmpl $0x0, %eax
jne 0xa2a7a
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
movb %al, -0x1(%rbp)
jmp 0xa2a8b
jmp 0xa2a7c
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa2a1a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ssz_union_selector:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_28]
mov qword ptr [rax], 0
mov [rbp+var_2C], 0
loc_A2A1A:
movsxd rax, [rbp+var_2C]
cmp rax, [rbp+var_18]
jnb short loc_A2A87
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_2C]
shl rcx, 5
add rax, rcx
mov rax, [rax]
cmp rax, [rbp+var_20]
jz short loc_A2A5C
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_2C]
shl rcx, 5
add rax, rcx
mov rdi, [rax]
mov rsi, [rbp+var_20]
call _strcmp
cmp eax, 0
jnz short loc_A2A7A
loc_A2A5C:
mov rcx, [rbp+var_10]
movsxd rax, [rbp+var_2C]
shl rax, 5
add rcx, rax
mov rax, [rbp+var_28]
mov [rax], rcx
mov eax, [rbp+var_2C]
mov [rbp+var_1], al
jmp short loc_A2A8B
loc_A2A7A:
jmp short $+2
loc_A2A7C:
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp short loc_A2A1A
loc_A2A87:
mov [rbp+var_1], 0
loc_A2A8B:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char ssz_union_selector(long long a1, unsigned long long a2, long long a3, _QWORD *a4)
{
int i; // [rsp+4h] [rbp-2Ch]
*a4 = 0LL;
for ( i = 0; i < a2; ++i )
{
if ( *(_QWORD *)(32LL * i + a1) == a3 || !(unsigned int)strcmp(*(_QWORD *)(32LL * i + a1), a3) )
{
*a4 = 32LL * i + a1;
return i;
}
}
return 0;
}
| ssz_union_selector:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],0x0
MOV dword ptr [RBP + -0x2c],0x0
LAB_001a2a1a:
MOVSXD RAX,dword ptr [RBP + -0x2c]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x001a2a87
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x2c]
SHL RCX,0x5
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001a2a5c
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x2c]
SHL RCX,0x5
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00123320
CMP EAX,0x0
JNZ 0x001a2a7a
LAB_001a2a5c:
MOV RCX,qword ptr [RBP + -0x10]
MOVSXD RAX,dword ptr [RBP + -0x2c]
SHL RAX,0x5
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0x2c]
MOV byte ptr [RBP + -0x1],AL
JMP 0x001a2a8b
LAB_001a2a7a:
JMP 0x001a2a7c
LAB_001a2a7c:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001a2a1a
LAB_001a2a87:
MOV byte ptr [RBP + -0x1],0x0
LAB_001a2a8b:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int8 ssz_union_selector(long param_1,ulong param_2,char *param_3,long *param_4)
{
int iVar1;
ulong uVar2;
int4 local_34;
int1 local_9;
*param_4 = 0;
local_34 = 0;
do {
uVar2 = (ulong)(int)local_34;
if (param_2 <= uVar2) {
local_9 = 0;
LAB_001a2a8b:
return CONCAT71((int7)(uVar2 >> 8),local_9);
}
if (*(char **)(param_1 + (long)(int)local_34 * 0x20) == param_3) {
LAB_001a2a5c:
*param_4 = param_1 + (long)(int)local_34 * 0x20;
uVar2 = (ulong)local_34;
local_9 = (int1)local_34;
goto LAB_001a2a8b;
}
iVar1 = strcmp(*(char **)(param_1 + (long)(int)local_34 * 0x20),param_3);
if (iVar1 == 0) goto LAB_001a2a5c;
local_34 = local_34 + 1;
} while( true );
}
|
|
3,202 | ssz_union_selector | corpus-core[P]colibri-stateless/src/util/ssz_builder.c | uint8_t ssz_union_selector(const ssz_def_t* union_types, size_t union_types_len, const char* name, const ssz_def_t** def) {
*def = NULL;
for (int i = 0; i < union_types_len; i++) {
if (union_types[i].name == name || strcmp(union_types[i].name, name) == 0) {
*def = union_types + i;
return i;
}
}
return 0;
} | O3 | c | ssz_union_selector:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq $0x0, (%rcx)
testq %rsi, %rsi
je 0x54777
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
xorl %ebx, %ebx
movq (%r12), %rdi
cmpq %r15, %rdi
je 0x5477b
movq %r15, %rsi
callq 0x212e0
testl %eax, %eax
je 0x5477b
incq %rbx
addq $0x20, %r12
cmpq %rbx, %r13
jne 0x54756
xorl %ebx, %ebx
jmp 0x5477e
movq %r12, (%r14)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| ssz_union_selector:
push r15
push r14
push r13
push r12
push rbx
mov qword ptr [rcx], 0
test rsi, rsi
jz short loc_54777
mov r14, rcx
mov r15, rdx
mov r13, rsi
mov r12, rdi
xor ebx, ebx
loc_54756:
mov rdi, [r12]
cmp rdi, r15
jz short loc_5477B
mov rsi, r15
call _strcmp
test eax, eax
jz short loc_5477B
inc rbx
add r12, 20h ; ' '
cmp r13, rbx
jnz short loc_54756
loc_54777:
xor ebx, ebx
jmp short loc_5477E
loc_5477B:
mov [r14], r12
loc_5477E:
mov eax, ebx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long ssz_union_selector(_QWORD *a1, long long a2, long long a3, _QWORD *a4)
{
long long v7; // rbx
*a4 = 0LL;
if ( a2 )
{
v7 = 0LL;
while ( *a1 != a3 && (unsigned int)strcmp(*a1, a3) )
{
++v7;
a1 += 4;
if ( a2 == v7 )
goto LABEL_6;
}
*a4 = a1;
}
else
{
LABEL_6:
LODWORD(v7) = 0;
}
return (unsigned int)v7;
}
| ssz_union_selector:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV qword ptr [RCX],0x0
TEST RSI,RSI
JZ 0x00154777
MOV R14,RCX
MOV R15,RDX
MOV R13,RSI
MOV R12,RDI
XOR EBX,EBX
LAB_00154756:
MOV RDI,qword ptr [R12]
CMP RDI,R15
JZ 0x0015477b
MOV RSI,R15
CALL 0x001212e0
TEST EAX,EAX
JZ 0x0015477b
INC RBX
ADD R12,0x20
CMP R13,RBX
JNZ 0x00154756
LAB_00154777:
XOR EBX,EBX
JMP 0x0015477e
LAB_0015477b:
MOV qword ptr [R14],R12
LAB_0015477e:
MOV EAX,EBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
ulong ssz_union_selector(int8 *param_1,ulong param_2,char *param_3,int8 *param_4)
{
int iVar1;
ulong uVar2;
*param_4 = 0;
if (param_2 != 0) {
uVar2 = 0;
do {
if ((char *)*param_1 == param_3) {
LAB_0015477b:
*param_4 = param_1;
goto LAB_0015477e;
}
iVar1 = strcmp((char *)*param_1,param_3);
if (iVar1 == 0) goto LAB_0015477b;
uVar2 = uVar2 + 1;
param_1 = param_1 + 4;
} while (param_2 != uVar2);
}
uVar2 = 0;
LAB_0015477e:
return uVar2 & 0xffffffff;
}
|
|
3,203 | Common::BytesToHexString[abi:cxx11](std::span<unsigned char const, 18446744073709551615ul>) | Dolphin-anty/Source/Core/Common/StringUtil.cpp | std::string BytesToHexString(std::span<const u8> bytes)
{
return fmt::format("{:02x}", fmt::join(bytes, ""));
} | O0 | cpp | Common::BytesToHexString[abi:cxx11](std::span<unsigned char const, 18446744073709551615ul>):
subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x78(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
leaq 0x7642c(%rip), %rax # 0x9f806
movq %rax, 0x58(%rsp)
movq $0x6, 0x60(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, 0xe0(%rsp)
leaq 0x76391(%rip), %rax # 0x9f78d
movq %rax, 0xd8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xd8(%rsp), %rcx
movq %rcx, (%rax)
movq 0xd8(%rsp), %rdi
callq 0x9760
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x68(%rsp), %rsi
callq 0x2b480
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x58(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq %rdi, 0xd0(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xc8(%rsp)
movq %rax, 0xb8(%rsp)
leaq 0xc0(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0xf0(%rsp)
movq 0xf0(%rsp), %rcx
movq 0xf8(%rsp), %rax
movq %rcx, 0xa8(%rsp)
movq %rax, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x32390
movq 0x18(%rsp), %rdi
movq %rax, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
leaq 0x98(%rsp), %rax
movq %rax, 0x110(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x110(%rsp), %rcx
movq 0x108(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x118(%rsp), %rax
movq %rcx, 0x130(%rsp)
movq $0xf, 0x128(%rsp)
movq %rax, 0x120(%rsp)
movq 0x130(%rsp), %rax
movq 0x128(%rsp), %rcx
movq %rcx, (%rax)
movq 0x120(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
movq 0x98(%rsp), %rcx
movq 0xa0(%rsp), %r8
callq 0x4f2c0
movq 0x20(%rsp), %rax
addq $0x138, %rsp # imm = 0x138
retq
nopl (%rax)
| _ZN6Common16BytesToHexStringB5cxx11ESt4spanIKhLm18446744073709551615EE:
sub rsp, 138h
mov [rsp+138h+var_120], rdi
mov rax, rdi
mov [rsp+138h+var_118], rax
mov [rsp+138h+var_C0], rdi
mov [rsp+138h+var_D0], rsi
mov [rsp+138h+var_C8], rdx
lea rax, a02x_0; "{:02x}"
mov [rsp+138h+var_E0], rax
mov [rsp+138h+var_D8], 6
lea rax, [rsp+138h+var_110]
mov [rsp+138h+var_58], rax
lea rax, asc_9F789+4; ""
mov [rsp+138h+var_60], rax
mov rax, [rsp+138h+var_58]
mov [rsp+138h+var_130], rax
mov rcx, [rsp+138h+var_60]
mov [rax], rcx
mov rdi, [rsp+138h+var_60]
call _strlen
mov rcx, rax
mov rax, [rsp+138h+var_130]
mov [rax+8], rcx
mov rdx, [rsp+138h+var_110]
mov rcx, [rsp+138h+var_108]
lea rdi, [rsp+138h+var_100]
mov [rsp+138h+var_128], rdi
lea rsi, [rsp+138h+var_D0]
call _ZN3fmt3v104joinIRSt4spanIKhLm18446744073709551615EEEENS0_9join_viewIDTclsr3stdE5beginclsr3stdE7declvalIRT_EEEEDTclsr3stdE3endclsr3stdE7declvalIS8_EEEEcEEOS7_NS0_17basic_string_viewIcEE
mov rax, [rsp+138h+var_128]
mov rdi, [rsp+138h+var_120]
mov rdx, [rsp+138h+var_E0]
mov rcx, [rsp+138h+var_D8]
mov [rsp+138h+var_68], rdi
mov [rsp+138h+var_78], rdx
mov [rsp+138h+var_70], rcx
mov [rsp+138h+var_80], rax
lea rax, [rsp+138h+var_78]
mov [rsp+138h+var_50], rax
mov rax, [rsp+138h+var_50]
movups xmm0, xmmword ptr [rax]
movaps [rsp+138h+var_48], xmm0
mov rcx, qword ptr [rsp+138h+var_48]
mov rax, qword ptr [rsp+138h+var_48+8]
mov [rsp+138h+var_90], rcx
mov [rsp+138h+var_88], rax
mov rdi, [rsp+138h+var_80]
call _ZN3fmt3v1016make_format_argsINS0_20basic_format_contextINS0_8appenderEcEEJNS0_9join_viewIN9__gnu_cxx17__normal_iteratorIPKhSt4spanIS8_Lm18446744073709551615EEEESC_cEEEEENS0_16format_arg_storeIT_JDpNSt9remove_cvINSt16remove_referenceIT0_E4typeEE4typeEEEEDpRSI_; fmt::v10::make_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>,fmt::v10::join_view<__gnu_cxx::__normal_iterator<uchar const*,std::span<uchar const,18446744073709551615ul>>,__gnu_cxx::__normal_iterator<uchar const*,std::span<uchar const,18446744073709551615ul>>,char>>(fmt::v10::join_view<__gnu_cxx::__normal_iterator<uchar const*,std::span<uchar const,18446744073709551615ul>>,__gnu_cxx::__normal_iterator<uchar const*,std::span<uchar const,18446744073709551615ul>>,char>&)
mov rdi, [rsp+138h+var_120]
mov [rsp+138h+var_B8], rax
mov [rsp+138h+var_B0], rdx
lea rax, [rsp+138h+var_A0]
mov [rsp+138h+var_28], rax
lea rax, [rsp+138h+var_B8]
mov [rsp+138h+var_30], rax
mov rcx, [rsp+138h+var_28]
mov rax, [rsp+138h+var_30]
mov [rsp+138h+var_20], rax
mov rax, [rsp+138h+var_20]
mov [rsp+138h+var_8], rcx
mov [rsp+138h+var_10], 0Fh
mov [rsp+138h+var_18], rax
mov rax, [rsp+138h+var_8]
mov rcx, [rsp+138h+var_10]
mov [rax], rcx
mov rcx, [rsp+138h+var_18]
mov [rax+8], rcx
mov rsi, [rsp+138h+var_90]
mov rdx, [rsp+138h+var_88]
mov rcx, [rsp+138h+var_A0]
mov r8, [rsp+138h+var_98]
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>>)
mov rax, [rsp+138h+var_118]
add rsp, 138h
retn
| long long Common::BytesToHexString[abi:cxx11](long long a1, long long a2, long long a3)
{
long long v3; // rdx
char *v5; // [rsp+28h] [rbp-110h] BYREF
long long v6; // [rsp+30h] [rbp-108h]
_BYTE v7[32]; // [rsp+38h] [rbp-100h] BYREF
__int128 v8; // [rsp+58h] [rbp-E0h]
_QWORD v9[3]; // [rsp+68h] [rbp-D0h] BYREF
_QWORD v10[3]; // [rsp+80h] [rbp-B8h] BYREF
_QWORD v11[2]; // [rsp+98h] [rbp-A0h] BYREF
__int128 v12; // [rsp+A8h] [rbp-90h]
_BYTE *v13; // [rsp+B8h] [rbp-80h]
__int128 v14; // [rsp+C0h] [rbp-78h] BYREF
long long v15; // [rsp+D0h] [rbp-68h]
char *v16; // [rsp+D8h] [rbp-60h]
char **v17; // [rsp+E0h] [rbp-58h]
__int128 *v18; // [rsp+E8h] [rbp-50h]
__int128 v19; // [rsp+F0h] [rbp-48h]
_QWORD *v20; // [rsp+108h] [rbp-30h]
_QWORD *v21; // [rsp+110h] [rbp-28h]
_QWORD *v22; // [rsp+118h] [rbp-20h]
_QWORD *v23; // [rsp+120h] [rbp-18h]
long long v24; // [rsp+128h] [rbp-10h]
_QWORD *v25; // [rsp+130h] [rbp-8h]
v9[2] = a1;
v9[0] = a2;
v9[1] = a3;
*(_QWORD *)&v8 = "{:02x}";
*((_QWORD *)&v8 + 1) = 6LL;
v17 = &v5;
v16 = "";
v5 = "";
v6 = strlen("");
fmt::v10::join<std::span<unsigned char const,18446744073709551615ul> &>(v7, v9, v5, v6);
v15 = a1;
v14 = v8;
v13 = v7;
v18 = &v14;
v19 = v8;
v12 = v8;
v10[0] = fmt::v10::make_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>,fmt::v10::join_view<__gnu_cxx::__normal_iterator<unsigned char const*,std::span<unsigned char const,18446744073709551615ul>>,__gnu_cxx::__normal_iterator<unsigned char const*,std::span<unsigned char const,18446744073709551615ul>>,char>>(v7);
v10[1] = v3;
v21 = v11;
v20 = v10;
v22 = v10;
v25 = v11;
v24 = 15LL;
v23 = v10;
v11[0] = 15LL;
v11[1] = v10;
fmt::v10::vformat[abi:cxx11](a1, v12, *((_QWORD *)&v12 + 1), 15LL, v10);
return a1;
}
| BytesToHexString[abi:cxx11]:
SUB RSP,0x138
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x78],RDI
MOV qword ptr [RSP + 0x68],RSI
MOV qword ptr [RSP + 0x70],RDX
LEA RAX,[0x19f806]
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],0x6
LEA RAX,[RSP + 0x28]
MOV qword ptr [RSP + 0xe0],RAX
LEA RAX,[0x19f78d]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSP + 0xe0]
MOV qword ptr [RSP + 0x8],RAX
MOV RCX,qword ptr [RSP + 0xd8]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RSP + 0xd8]
CALL 0x00109760
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x30]
LEA RDI,[RSP + 0x38]
MOV qword ptr [RSP + 0x10],RDI
LEA RSI,[RSP + 0x68]
CALL 0x0012b480
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x58]
MOV RCX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0xd0],RDI
MOV qword ptr [RSP + 0xc0],RDX
MOV qword ptr [RSP + 0xc8],RCX
MOV qword ptr [RSP + 0xb8],RAX
LEA RAX,[RSP + 0xc0]
MOV qword ptr [RSP + 0xe8],RAX
MOV RAX,qword ptr [RSP + 0xe8]
MOVUPS XMM0,xmmword ptr [RAX]
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
MOV RCX,qword ptr [RSP + 0xf0]
MOV RAX,qword ptr [RSP + 0xf8]
MOV qword ptr [RSP + 0xa8],RCX
MOV qword ptr [RSP + 0xb0],RAX
MOV RDI,qword ptr [RSP + 0xb8]
CALL 0x00132390
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x80],RAX
MOV qword ptr [RSP + 0x88],RDX
LEA RAX,[RSP + 0x98]
MOV qword ptr [RSP + 0x110],RAX
LEA RAX,[RSP + 0x80]
MOV qword ptr [RSP + 0x108],RAX
MOV RCX,qword ptr [RSP + 0x110]
MOV RAX,qword ptr [RSP + 0x108]
MOV qword ptr [RSP + 0x118],RAX
MOV RAX,qword ptr [RSP + 0x118]
MOV qword ptr [RSP + 0x130],RCX
MOV qword ptr [RSP + 0x128],0xf
MOV qword ptr [RSP + 0x120],RAX
MOV RAX,qword ptr [RSP + 0x130]
MOV RCX,qword ptr [RSP + 0x128]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x120]
MOV qword ptr [RAX + 0x8],RCX
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDX,qword ptr [RSP + 0xb0]
MOV RCX,qword ptr [RSP + 0x98]
MOV R8,qword ptr [RSP + 0xa0]
CALL 0x0014f2c0
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x138
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
/* Common::BytesToHexString[abi:cxx11](std::span<unsigned char const, 18446744073709551615ul>) */
int8
Common::BytesToHexString_abi_cxx11_(int8 param_1,int8 param_2,int8 param_3)
{
size_t sVar1;
int *local_110 [2];
join_view local_100 [32];
char *local_e0;
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_c0;
int1 local_b8 [16];
int1 local_a0 [16];
char *local_90;
int8 local_88;
join_view *local_80;
char *local_78;
int8 uStack_70;
int8 local_68;
int *local_60;
int **local_58;
int8 *local_50;
char *local_48;
int8 uStack_40;
int1 *local_30;
int1 *local_28;
int1 *local_20;
int1 *local_18;
int8 local_10;
int1 *local_8;
local_e0 = "{:02x}";
local_d8 = 6;
local_58 = local_110;
local_60 = &DAT_0019f78d;
local_110[0] = &DAT_0019f78d;
local_d0 = param_2;
local_c8 = param_3;
local_c0 = param_1;
sVar1 = strlen("");
_ZN3fmt3v104joinIRSt4spanIKhLm18446744073709551615EEEENS0_9join_viewIDTclsr3stdE5beginclsr3stdE7declvalIRT_EEEEDTclsr3stdE3endclsr3stdE7declvalIS8_EEEEcEEOS7_NS0_17basic_string_viewIcEE
(local_100,&local_d0,local_110[0],sVar1);
local_78 = local_e0;
uStack_70 = local_d8;
local_50 = &local_78;
local_90 = local_e0;
local_88 = local_d8;
local_80 = local_100;
local_68 = param_1;
local_48 = local_90;
uStack_40 = local_88;
local_b8 = fmt::v10::
make_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>,fmt::v10::join_view<__gnu_cxx::__normal_iterator<unsigned_char_const*,std::span<unsigned_char_const,18446744073709551615ul>>,__gnu_cxx::__normal_iterator<unsigned_char_const*,std::span<unsigned_char_const,18446744073709551615ul>>,char>>
(local_100);
local_28 = local_a0;
local_30 = local_b8;
local_10 = 0xf;
local_20 = local_30;
local_18 = local_30;
local_8 = local_28;
fmt::v10::vformat_abi_cxx11_(param_1,local_90,local_88,0xf,local_30);
return param_1;
}
|
|
3,204 | stbi_loadf_from_callbacks | monkey531[P]llama/examples/llava/../../common/stb_image.h | STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
return stbi__loadf_main(&s,x,y,comp,req_comp);
} | O3 | c | stbi_loadf_from_callbacks:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq 0x10(%rdi), %rax
leaq 0x38(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups (%rdi), %xmm0
movups %xmm0, -0x28(%rcx)
movq %rsi, -0x10(%rcx)
movabsq $0x8000000001, %rax # imm = 0x8000000001
movq %rax, -0x8(%rcx)
movl $0x0, 0x80(%rcx)
movq %rcx, 0x98(%rcx)
movq %rcx, 0x88(%rcx)
movq %rsp, %r13
movq %r13, %rdi
callq 0x3bf07
movq 0xc8(%r13), %rax
movq %rax, 0xd8(%r13)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x28e51
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| stbi_loadf_from_callbacks:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E0h
mov ebx, r9d
mov r14, r8
mov r15, rcx
mov r12, rdx
mov rax, [rdi+10h]
lea rcx, [rsp+108h+var_D0]
mov [rcx-18h], rax
movups xmm0, xmmword ptr [rdi]
movups xmmword ptr [rcx-28h], xmm0
mov [rcx-10h], rsi
mov rax, 8000000001h
mov [rcx-8], rax
mov dword ptr [rcx+80h], 0
mov [rcx+98h], rcx
mov [rcx+88h], rcx
mov r13, rsp
mov rdi, r13
call _ZL19stbi__refill_bufferP13stbi__context; stbi__refill_buffer(stbi__context *)
mov rax, [r13+0C8h]
mov [r13+0D8h], rax
mov rdi, r13
mov rsi, r12
mov rdx, r15
mov rcx, r14
mov r8d, ebx
call _ZL16stbi__loadf_mainP13stbi__contextPiS1_S1_i; stbi__loadf_main(stbi__context *,int *,int *,int *,int)
add rsp, 0E0h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| char * stbi_loadf_from_callbacks(long long a1, long long a2, int *a3, int *a4, int *a5, int a6)
{
_OWORD v11[2]; // [rsp+0h] [rbp-108h] BYREF
long long v12; // [rsp+20h] [rbp-E8h]
long long v13; // [rsp+28h] [rbp-E0h]
long long v14; // [rsp+30h] [rbp-D8h]
_BYTE v15[128]; // [rsp+38h] [rbp-D0h] BYREF
int v16; // [rsp+B8h] [rbp-50h]
_BYTE *v17; // [rsp+C0h] [rbp-48h]
long long v18; // [rsp+C8h] [rbp-40h]
_BYTE *v19; // [rsp+D0h] [rbp-38h]
long long v20; // [rsp+D8h] [rbp-30h]
v12 = *(_QWORD *)(a1 + 16);
v11[1] = *(_OWORD *)a1;
v13 = a2;
v14 = 0x8000000001LL;
v16 = 0;
v19 = v15;
v17 = v15;
stbi__refill_buffer(v11);
v20 = v18;
return stbi__loadf_main((long long)v11, a3, a4, a5, a6);
}
| stbi_loadf_from_callbacks:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe0
MOV EBX,R9D
MOV R14,R8
MOV R15,RCX
MOV R12,RDX
MOV RAX,qword ptr [RDI + 0x10]
LEA RCX,[RSP + 0x38]
MOV qword ptr [RCX + -0x18],RAX
MOVUPS XMM0,xmmword ptr [RDI]
MOVUPS xmmword ptr [RCX + -0x28],XMM0
MOV qword ptr [RCX + -0x10],RSI
MOV RAX,0x8000000001
MOV qword ptr [RCX + -0x8],RAX
MOV dword ptr [RCX + 0x80],0x0
MOV qword ptr [RCX + 0x98],RCX
MOV qword ptr [RCX + 0x88],RCX
MOV R13,RSP
MOV RDI,R13
CALL 0x0013bf07
MOV RAX,qword ptr [R13 + 0xc8]
MOV qword ptr [R13 + 0xd8],RAX
MOV RDI,R13
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
MOV R8D,EBX
CALL 0x00128e51
ADD RSP,0xe0
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
void stbi_loadf_from_callbacks
(int8 *param_1,int8 param_2,int *param_3,int *param_4,int *param_5,
int param_6)
{
stbi__context asStack_108 [16];
int8 local_f8;
int8 uStack_f0;
int8 local_e8;
int8 local_e0;
int8 local_d8;
int1 local_d0 [128];
int4 local_50;
int1 *local_48;
int8 local_40;
int1 *local_38;
int8 local_30;
local_e8 = param_1[2];
local_48 = local_d0;
local_f8 = *param_1;
uStack_f0 = param_1[1];
local_d8 = 0x8000000001;
local_50 = 0;
local_e0 = param_2;
local_38 = local_48;
stbi__refill_buffer(asStack_108);
local_30 = local_40;
stbi__loadf_main(asStack_108,param_3,param_4,param_5,param_6);
return;
}
|
|
3,205 | 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;
} | O3 | c | ma_dynstr_append_mem:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
leaq (%rdi,%rdx), %r12
cmpq 0x10(%r14), %r12
jb 0x27cb2
movq 0x18(%r14), %rsi
addq %rsi, %r12
movq %r12, %rax
xorl %edx, %edx
divq %rsi
subq %rdx, %r12
movq %rcx, %rdi
movq %r12, %rsi
callq 0x13740
testq %rax, %rax
je 0x27cda
movq %rax, %rcx
movq %rax, (%r14)
movq %r12, 0x10(%r14)
movq 0x8(%r14), %rdi
addq %rcx, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x13390
addq 0x8(%r14), %rbx
movq %rbx, 0x8(%r14)
movq (%r14), %rax
movb $0x0, (%rax,%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x27cd1
| ma_dynstr_append_mem:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdx
mov r15, rsi
mov r14, rdi
mov rcx, [rdi]
mov rdi, [rdi+8]
lea r12, [rdi+rdx]
cmp r12, [r14+10h]
jb short loc_27CB2
mov rsi, [r14+18h]
add r12, rsi
mov rax, r12
xor edx, edx
div rsi
sub r12, rdx
mov rdi, rcx
mov rsi, r12
call _realloc
test rax, rax
jz short loc_27CDA
mov rcx, rax
mov [r14], rax
mov [r14+10h], r12
mov rdi, [r14+8]
loc_27CB2:
add rdi, rcx
mov rsi, r15
mov rdx, rbx
call _memcpy
add rbx, [r14+8]
mov [r14+8], rbx
mov rax, [r14]
mov byte ptr [rax+rbx], 0
xor eax, eax
loc_27CD1:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_27CDA:
mov al, 1
jmp short loc_27CD1
| long long ma_dynstr_append_mem(long long *a1, long long a2, long long a3)
{
long long v5; // rcx
long long v6; // rdi
unsigned long long v7; // r12
long long v8; // rax
long long v9; // rbx
v5 = *a1;
v6 = a1[1];
if ( v6 + a3 < (unsigned long long)a1[2] )
goto LABEL_4;
v7 = a1[3] + v6 + a3 - (a1[3] + v6 + a3) % (unsigned long long)a1[3];
v8 = realloc(v5, v7);
if ( v8 )
{
v5 = v8;
*a1 = v8;
a1[2] = v7;
v6 = a1[1];
LABEL_4:
memcpy(v5 + v6, a2, a3);
v9 = a1[1] + a3;
a1[1] = v9;
*(_BYTE *)(*a1 + v9) = 0;
return 0LL;
}
return 1LL;
}
| ma_dynstr_append_mem:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
MOV RCX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
LEA R12,[RDI + RDX*0x1]
CMP R12,qword ptr [R14 + 0x10]
JC 0x00127cb2
MOV RSI,qword ptr [R14 + 0x18]
ADD R12,RSI
MOV RAX,R12
XOR EDX,EDX
DIV RSI
SUB R12,RDX
MOV RDI,RCX
MOV RSI,R12
CALL 0x00113740
TEST RAX,RAX
JZ 0x00127cda
MOV RCX,RAX
MOV qword ptr [R14],RAX
MOV qword ptr [R14 + 0x10],R12
MOV RDI,qword ptr [R14 + 0x8]
LAB_00127cb2:
ADD RDI,RCX
MOV RSI,R15
MOV RDX,RBX
CALL 0x00113390
ADD RBX,qword ptr [R14 + 0x8]
MOV qword ptr [R14 + 0x8],RBX
MOV RAX,qword ptr [R14]
MOV byte ptr [RAX + RBX*0x1],0x0
XOR EAX,EAX
LAB_00127cd1:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00127cda:
MOV AL,0x1
JMP 0x00127cd1
|
int8 ma_dynstr_append_mem(long *param_1,void *param_2,size_t param_3)
{
void *__ptr;
long lVar1;
ulong uVar2;
size_t __size;
__ptr = (void *)*param_1;
lVar1 = param_1[1];
if ((ulong)param_1[2] <= lVar1 + param_3) {
uVar2 = lVar1 + param_3 + param_1[3];
__size = uVar2 - uVar2 % (ulong)param_1[3];
__ptr = realloc(__ptr,__size);
if (__ptr == (void *)0x0) {
return 1;
}
*param_1 = (long)__ptr;
param_1[2] = __size;
lVar1 = param_1[1];
}
memcpy((void *)(lVar1 + (long)__ptr),param_2,param_3);
lVar1 = param_1[1];
param_1[1] = param_3 + lVar1;
*(int1 *)(*param_1 + param_3 + lVar1) = 0;
return 0;
}
|
|
3,206 | print_xml_tag | eloqsql/client/mysqldump.c | static void print_xml_tag(FILE * xml_file, const char* sbeg,
const char* line_end,
const char* tag_name,
const char* first_attribute_name, ...)
{
va_list arg_list;
const char *attribute_name, *attribute_value;
fputs(sbeg, xml_file);
fputc('<', xml_file);
fputs(tag_name, xml_file);
va_start(arg_list, first_attribute_name);
attribute_name= first_attribute_name;
while (attribute_name != NullS)
{
attribute_value= va_arg(arg_list, char *);
DBUG_ASSERT(attribute_value != NullS);
fputc(' ', xml_file);
fputs(attribute_name, xml_file);
fputc('\"', xml_file);
print_quoted_xml(xml_file, attribute_value, strlen(attribute_value), 0);
fputc('\"', xml_file);
attribute_name= va_arg(arg_list, char *);
}
va_end(arg_list);
fputc('>', xml_file);
fputs(line_end, xml_file);
check_io(xml_file);
} | O0 | c | print_xml_tag:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
testb %al, %al
je 0x3f8fe
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x38340
movq -0x8(%rbp), %rsi
movl $0x3c, %edi
callq 0x388b0
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x38340
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x28, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x3fab9
leaq -0x40(%rbp), %rax
movq %rax, -0x110(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x104(%rbp)
cmpl $0x28, %eax
ja 0x3f9b3
movq -0x110(%rbp), %rcx
movl -0x104(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x118(%rbp)
jmp 0x3f9d0
movq -0x110(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x3f9e0
movq -0x8(%rbp), %rsi
movl $0x20, %edi
callq 0x388b0
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x38340
movq -0x8(%rbp), %rsi
movl $0x22, %edi
callq 0x388b0
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x50(%rbp), %rdi
callq 0x38410
movq -0x138(%rbp), %rdi
movq -0x130(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x440e0
movq -0x8(%rbp), %rsi
movl $0x22, %edi
callq 0x388b0
leaq -0x40(%rbp), %rax
movq %rax, -0x128(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x11c(%rbp)
cmpl $0x28, %eax
ja 0x3fa89
movq -0x128(%rbp), %rcx
movl -0x11c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x140(%rbp)
jmp 0x3faa6
movq -0x128(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x3f96d
movq -0x8(%rbp), %rsi
movl $0x3e, %edi
callq 0x388b0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x38340
movq -0x8(%rbp), %rdi
callq 0x38d60
addq $0x140, %rsp # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
| print_xml_tag:
push rbp
mov rbp, rsp
sub rsp, 140h
test al, al
jz short loc_3F8FE
movaps [rbp+var_D0], xmm0
movaps [rbp+var_C0], xmm1
movaps [rbp+var_B0], xmm2
movaps [rbp+var_A0], xmm3
movaps [rbp+var_90], xmm4
movaps [rbp+var_80], xmm5
movaps [rbp+var_70], xmm6
movaps [rbp+var_60], xmm7
loc_3F8FE:
mov [rbp+var_D8], r9
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 rdi, [rbp+var_10]
mov rsi, [rbp+var_8]
call _fputs
mov rsi, [rbp+var_8]
mov edi, 3Ch ; '<'
call _fputc
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_8]
call _fputs
lea rax, [rbp+var_40]
lea rcx, [rbp+var_100]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 28h ; '('
mov rax, [rbp+var_28]
mov [rbp+var_48], rax
loc_3F96D:
cmp [rbp+var_48], 0
jz loc_3FAB9
lea rax, [rbp+var_40]
mov [rbp+var_110], rax
mov eax, [rbp+var_40]
mov [rbp+var_104], eax
cmp eax, 28h ; '('
ja short loc_3F9B3
mov rcx, [rbp+var_110]
mov edx, [rbp+var_104]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_118], rax
jmp short loc_3F9D0
loc_3F9B3:
mov rcx, [rbp+var_110]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_118], rax
loc_3F9D0:
mov rax, [rbp+var_118]
mov rax, [rax]
mov [rbp+var_50], rax
jmp short $+2
loc_3F9E0:
mov rsi, [rbp+var_8]
mov edi, 20h ; ' '
call _fputc
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_8]
call _fputs
mov rsi, [rbp+var_8]
mov edi, 22h ; '"'
call _fputc
mov rax, [rbp+var_8]
mov [rbp+var_138], rax
mov rax, [rbp+var_50]
mov [rbp+var_130], rax
mov rdi, [rbp+var_50]
call _strlen
mov rdi, [rbp+var_138]
mov rsi, [rbp+var_130]
mov rdx, rax
xor ecx, ecx
call print_quoted_xml
mov rsi, [rbp+var_8]
mov edi, 22h ; '"'
call _fputc
lea rax, [rbp+var_40]
mov [rbp+var_128], rax
mov eax, [rbp+var_40]
mov [rbp+var_11C], eax
cmp eax, 28h ; '('
ja short loc_3FA89
mov rcx, [rbp+var_128]
mov edx, [rbp+var_11C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_140], rax
jmp short loc_3FAA6
loc_3FA89:
mov rcx, [rbp+var_128]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_140], rax
loc_3FAA6:
mov rax, [rbp+var_140]
mov rax, [rax]
mov [rbp+var_48], rax
jmp loc_3F96D
loc_3FAB9:
mov rsi, [rbp+var_8]
mov edi, 3Eh ; '>'
call _fputc
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_8]
call _fputs
mov rdi, [rbp+var_8]
call check_io
add rsp, 140h
pop rbp
retn
| long long print_xml_tag(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char *v15; // rax
long long v16; // rax
char *v17; // rax
long long v19; // [rsp+8h] [rbp-138h]
long long v20; // [rsp+10h] [rbp-130h]
char v21; // [rsp+40h] [rbp-100h] BYREF
long long v22; // [rsp+68h] [rbp-D8h]
__m128 v23; // [rsp+70h] [rbp-D0h]
__m128 v24; // [rsp+80h] [rbp-C0h]
__m128 v25; // [rsp+90h] [rbp-B0h]
__m128 v26; // [rsp+A0h] [rbp-A0h]
__m128 v27; // [rsp+B0h] [rbp-90h]
__m128 v28; // [rsp+C0h] [rbp-80h]
__m128 v29; // [rsp+D0h] [rbp-70h]
__m128 v30; // [rsp+E0h] [rbp-60h]
long long v31; // [rsp+F0h] [rbp-50h]
long long i; // [rsp+F8h] [rbp-48h]
int v33; // [rsp+100h] [rbp-40h]
int v34; // [rsp+104h] [rbp-3Ch]
char *v35; // [rsp+108h] [rbp-38h]
char *v36; // [rsp+110h] [rbp-30h]
long long v37; // [rsp+118h] [rbp-28h]
long long v38; // [rsp+120h] [rbp-20h]
long long v39; // [rsp+128h] [rbp-18h]
long long v40; // [rsp+130h] [rbp-10h]
long long v41; // [rsp+138h] [rbp-8h]
v23 = a7;
v24 = a8;
v25 = a9;
v26 = a10;
v27 = a11;
v28 = a12;
v29 = a13;
v30 = a14;
v22 = a6;
v41 = a1;
v40 = a2;
v39 = a3;
v38 = a4;
v37 = a5;
fputs(a2, a1);
fputc(60LL, a1);
fputs(v38, a1);
v36 = &v21;
v35 = &a15;
v34 = 48;
v33 = 40;
for ( i = v37; i; i = *(_QWORD *)v17 )
{
if ( (unsigned int)v33 > 0x28 )
{
v15 = v35;
v35 += 8;
}
else
{
v15 = &v36[v33];
v33 += 8;
}
v31 = *(_QWORD *)v15;
fputc(32LL, v41);
fputs(i, v41);
fputc(34LL, v41);
v19 = v41;
v20 = v31;
v16 = strlen(v31);
print_quoted_xml(v19, v20, v16, 0LL);
fputc(34LL, v41);
if ( (unsigned int)v33 > 0x28 )
{
v17 = v35;
v35 += 8;
}
else
{
v17 = &v36[v33];
v33 += 8;
}
}
fputc(62LL, v41);
fputs(v39, v41);
return check_io(v41);
}
| print_xml_tag:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x140
TEST AL,AL
JZ 0x0013f8fe
MOVAPS xmmword ptr [RBP + -0xd0],XMM0
MOVAPS xmmword ptr [RBP + -0xc0],XMM1
MOVAPS xmmword ptr [RBP + -0xb0],XMM2
MOVAPS xmmword ptr [RBP + -0xa0],XMM3
MOVAPS xmmword ptr [RBP + -0x90],XMM4
MOVAPS xmmword ptr [RBP + -0x80],XMM5
MOVAPS xmmword ptr [RBP + -0x70],XMM6
MOVAPS xmmword ptr [RBP + -0x60],XMM7
LAB_0013f8fe:
MOV qword ptr [RBP + -0xd8],R9
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 RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x00138340
MOV RSI,qword ptr [RBP + -0x8]
MOV EDI,0x3c
CALL 0x001388b0
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x00138340
LEA RAX,[RBP + -0x40]
LEA RCX,[RBP + -0x100]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x28
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
LAB_0013f96d:
CMP qword ptr [RBP + -0x48],0x0
JZ 0x0013fab9
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x110],RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x104],EAX
CMP EAX,0x28
JA 0x0013f9b3
MOV RCX,qword ptr [RBP + -0x110]
MOV EDX,dword ptr [RBP + -0x104]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x118],RAX
JMP 0x0013f9d0
LAB_0013f9b3:
MOV RCX,qword ptr [RBP + -0x110]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x118],RAX
LAB_0013f9d0:
MOV RAX,qword ptr [RBP + -0x118]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0013f9e0
LAB_0013f9e0:
MOV RSI,qword ptr [RBP + -0x8]
MOV EDI,0x20
CALL 0x001388b0
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x00138340
MOV RSI,qword ptr [RBP + -0x8]
MOV EDI,0x22
CALL 0x001388b0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x138],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x130],RAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x00138410
MOV RDI,qword ptr [RBP + -0x138]
MOV RSI,qword ptr [RBP + -0x130]
MOV RDX,RAX
XOR ECX,ECX
CALL 0x001440e0
MOV RSI,qword ptr [RBP + -0x8]
MOV EDI,0x22
CALL 0x001388b0
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x128],RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x11c],EAX
CMP EAX,0x28
JA 0x0013fa89
MOV RCX,qword ptr [RBP + -0x128]
MOV EDX,dword ptr [RBP + -0x11c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x140],RAX
JMP 0x0013faa6
LAB_0013fa89:
MOV RCX,qword ptr [RBP + -0x128]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x140],RAX
LAB_0013faa6:
MOV RAX,qword ptr [RBP + -0x140]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0013f96d
LAB_0013fab9:
MOV RSI,qword ptr [RBP + -0x8]
MOV EDI,0x3e
CALL 0x001388b0
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x00138340
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00138d60
ADD RSP,0x140
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
void print_xml_tag(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
FILE *param_9,char *param_10,char *param_11,char *param_12,char *param_13,
int8 param_14)
{
char *pcVar1;
FILE *pFVar2;
char in_AL;
size_t sVar3;
long *local_148;
long *local_120;
int1 local_108 [40];
int8 local_e0;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
char *local_58;
char *local_50;
uint local_48;
int4 local_44;
long *local_40;
int1 *local_38;
char *local_30;
char *local_28;
char *local_20;
char *local_18;
FILE *local_10;
if (in_AL != '\0') {
local_d8 = param_1;
local_c8 = param_2;
local_b8 = param_3;
local_a8 = param_4;
local_98 = param_5;
local_88 = param_6;
local_78 = param_7;
local_68 = param_8;
}
local_e0 = param_14;
local_30 = param_13;
local_28 = param_12;
local_20 = param_11;
local_18 = param_10;
local_10 = param_9;
fputs(param_10,param_9);
fputc(0x3c,local_10);
fputs(local_28,local_10);
local_38 = local_108;
local_40 = (long *)&stack0x00000008;
local_44 = 0x30;
local_48 = 0x28;
local_50 = local_30;
while (local_50 != (char *)0x0) {
if (local_48 < 0x29) {
local_120 = (long *)(local_38 + (int)local_48);
local_48 = local_48 + 8;
}
else {
local_120 = local_40;
local_40 = local_40 + 1;
}
local_58 = (char *)*local_120;
fputc(0x20,local_10);
fputs(local_50,local_10);
fputc(0x22,local_10);
pFVar2 = local_10;
pcVar1 = local_58;
sVar3 = strlen(local_58);
print_quoted_xml(pFVar2,pcVar1,sVar3,0);
fputc(0x22,local_10);
if (local_48 < 0x29) {
local_148 = (long *)(local_38 + (int)local_48);
local_48 = local_48 + 8;
}
else {
local_148 = local_40;
local_40 = local_40 + 1;
}
local_50 = (char *)*local_148;
}
fputc(0x3e,local_10);
fputs(local_20,local_10);
check_io(local_10);
return;
}
|
|
3,207 | print_xml_tag | eloqsql/client/mysqldump.c | static void print_xml_tag(FILE * xml_file, const char* sbeg,
const char* line_end,
const char* tag_name,
const char* first_attribute_name, ...)
{
va_list arg_list;
const char *attribute_name, *attribute_value;
fputs(sbeg, xml_file);
fputc('<', xml_file);
fputs(tag_name, xml_file);
va_start(arg_list, first_attribute_name);
attribute_name= first_attribute_name;
while (attribute_name != NullS)
{
attribute_value= va_arg(arg_list, char *);
DBUG_ASSERT(attribute_value != NullS);
fputc(' ', xml_file);
fputs(attribute_name, xml_file);
fputc('\"', xml_file);
print_quoted_xml(xml_file, attribute_value, strlen(attribute_value), 0);
fputc('\"', xml_file);
attribute_name= va_arg(arg_list, char *);
}
va_end(arg_list);
fputc('>', xml_file);
fputs(line_end, xml_file);
check_io(xml_file);
} | O3 | c | print_xml_tag:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
leaq -0xf0(%rbp), %r12
movq %r9, 0x28(%r12)
testb %al, %al
je 0x3e2a3
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x37340
movl $0x3c, %edi
movq %rbx, %rsi
callq 0x378e0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x37340
movabsq $0x3000000028, %rax # imm = 0x3000000028
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %r12, -0x30(%rbp)
leaq 0x638be(%rip), %r15 # 0xa1ba5
movl $0x28, %eax
cmpl $0x28, %eax
ja 0x3e2ff
movl %eax, %ecx
addq -0x30(%rbp), %rcx
addl $0x8, %eax
movl %eax, -0x40(%rbp)
jmp 0x3e30b
movq -0x38(%rbp), %rcx
leaq 0x8(%rcx), %rax
movq %rax, -0x38(%rbp)
movq (%rcx), %r12
movl $0x20, %edi
movq %rbx, %rsi
callq 0x378e0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x37340
movl $0x22, %edi
movq %rbx, %rsi
callq 0x378e0
movq %r12, %rdi
callq 0x37410
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x42326
movl $0x22, %edi
movq %rbx, %rsi
callq 0x378e0
movl -0x40(%rbp), %eax
cmpq $0x28, %rax
ja 0x3e370
movq %rax, %rcx
addq -0x30(%rbp), %rcx
addl $0x8, %eax
movl %eax, -0x40(%rbp)
jmp 0x3e37c
movq -0x38(%rbp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, -0x38(%rbp)
movq (%rcx), %r15
testq %r15, %r15
jne 0x3e2ec
movl $0x3e, %edi
movq %rbx, %rsi
callq 0x378e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37340
movq %rbx, %rdi
callq 0x38cfc
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| print_xml_tag:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 0D0h
mov r15, rcx
mov r14, rdx
mov rbx, rdi
lea r12, [rbp+var_F0]
mov [r12+28h], r9
test al, al
jz short loc_3E2A3
movaps [rbp+var_C0], xmm0
movaps [rbp+var_B0], xmm1
movaps [rbp+var_A0], xmm2
movaps [rbp+var_90], xmm3
movaps [rbp+var_80], xmm4
movaps [rbp+var_70], xmm5
movaps [rbp+var_60], xmm6
movaps [rbp+var_50], xmm7
loc_3E2A3:
mov rdi, rsi
mov rsi, rbx
call _fputs
mov edi, 3Ch ; '<'
mov rsi, rbx
call _fputc
mov rdi, r15
mov rsi, rbx
call _fputs
mov rax, 3000000028h
mov [rbp+var_40], rax
lea rax, [rbp+arg_0]
mov [rbp+var_38], rax
mov [rbp+var_30], r12
lea r15, aFieldName+6; "name="
mov eax, 28h ; '('
loc_3E2EC:
cmp eax, 28h ; '('
ja short loc_3E2FF
mov ecx, eax
add rcx, [rbp+var_30]
add eax, 8
mov dword ptr [rbp+var_40], eax
jmp short loc_3E30B
loc_3E2FF:
mov rcx, [rbp+var_38]
lea rax, [rcx+8]
mov [rbp+var_38], rax
loc_3E30B:
mov r12, [rcx]
mov edi, 20h ; ' '
mov rsi, rbx
call _fputc
mov rdi, r15
mov rsi, rbx
call _fputs
mov edi, 22h ; '"'
mov rsi, rbx
call _fputc
mov rdi, r12
call _strlen
mov rdi, rbx
mov rsi, r12
mov rdx, rax
xor ecx, ecx
call print_quoted_xml
mov edi, 22h ; '"'
mov rsi, rbx
call _fputc
mov eax, dword ptr [rbp+var_40]
cmp rax, 28h ; '('
ja short loc_3E370
mov rcx, rax
add rcx, [rbp+var_30]
add eax, 8
mov dword ptr [rbp+var_40], eax
jmp short loc_3E37C
loc_3E370:
mov rcx, [rbp+var_38]
lea rdx, [rcx+8]
mov [rbp+var_38], rdx
loc_3E37C:
mov r15, [rcx]
test r15, r15
jnz loc_3E2EC
mov edi, 3Eh ; '>'
mov rsi, rbx
call _fputc
mov rdi, r14
mov rsi, rbx
call _fputs
mov rdi, rbx
call check_io
add rsp, 0D0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long print_xml_tag(
long long a1,
long long a2,
long long a3,
long long a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
long long a13,
long long a14,
char a15)
{
long long v17; // rdx
char *v18; // r15
unsigned int v19; // eax
char *v20; // rcx
long long v21; // r12
long long v22; // rdx
long long v23; // rax
char **v24; // rcx
long long v25; // rdx
long long v26; // rdx
long long v27; // rcx
long long v28; // r8
long long v29; // r9
char v31; // [rsp+0h] [rbp-F0h] BYREF
long long v32; // [rsp+28h] [rbp-C8h]
__m128 v33; // [rsp+30h] [rbp-C0h]
__m128 v34; // [rsp+40h] [rbp-B0h]
__m128 v35; // [rsp+50h] [rbp-A0h]
__m128 v36; // [rsp+60h] [rbp-90h]
__m128 v37; // [rsp+70h] [rbp-80h]
__m128 v38; // [rsp+80h] [rbp-70h]
__m128 v39; // [rsp+90h] [rbp-60h]
__m128 v40; // [rsp+A0h] [rbp-50h]
long long v41; // [rsp+B0h] [rbp-40h]
char *v42; // [rsp+B8h] [rbp-38h]
char *v43; // [rsp+C0h] [rbp-30h]
v33 = a5;
v34 = a6;
v35 = a7;
v36 = a8;
v37 = a9;
v38 = a10;
v39 = a11;
v40 = a12;
v32 = a14;
fputs(a2, a1, a3);
fputc(60LL, a1);
fputs(a4, a1, v17);
v41 = 0x3000000028LL;
v42 = &a15;
v43 = &v31;
v18 = "name=";
v19 = 40;
do
{
if ( v19 > 0x28 )
{
v20 = v42;
v42 += 8;
}
else
{
v20 = &v43[v19];
LODWORD(v41) = v19 + 8;
}
v21 = *(_QWORD *)v20;
fputc(32LL, a1);
fputs(v18, a1, v22);
fputc(34LL, a1);
v23 = strlen(v21);
print_quoted_xml(a1, v21, v23, 0LL);
fputc(34LL, a1);
v19 = v41;
if ( (unsigned int)v41 > 0x28uLL )
{
v24 = (char **)v42;
v42 += 8;
}
else
{
v24 = (char **)&v43[(unsigned int)v41];
v19 = v41 + 8;
LODWORD(v41) = v41 + 8;
}
v18 = *v24;
}
while ( *v24 );
fputc(62LL, a1);
fputs(a3, a1, v25);
return check_io(a1, a1, v26, v27, v28, v29, v31);
}
| print_xml_tag:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xd0
MOV R15,RCX
MOV R14,RDX
MOV RBX,RDI
LEA R12,[RBP + -0xf0]
MOV qword ptr [R12 + 0x28],R9
TEST AL,AL
JZ 0x0013e2a3
MOVAPS xmmword ptr [RBP + -0xc0],XMM0
MOVAPS xmmword ptr [RBP + -0xb0],XMM1
MOVAPS xmmword ptr [RBP + -0xa0],XMM2
MOVAPS xmmword ptr [RBP + -0x90],XMM3
MOVAPS xmmword ptr [RBP + -0x80],XMM4
MOVAPS xmmword ptr [RBP + -0x70],XMM5
MOVAPS xmmword ptr [RBP + -0x60],XMM6
MOVAPS xmmword ptr [RBP + -0x50],XMM7
LAB_0013e2a3:
MOV RDI,RSI
MOV RSI,RBX
CALL 0x00137340
MOV EDI,0x3c
MOV RSI,RBX
CALL 0x001378e0
MOV RDI,R15
MOV RSI,RBX
CALL 0x00137340
MOV RAX,0x3000000028
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV qword ptr [RBP + -0x30],R12
LEA R15,[0x1a1ba5]
MOV EAX,0x28
LAB_0013e2ec:
CMP EAX,0x28
JA 0x0013e2ff
MOV ECX,EAX
ADD RCX,qword ptr [RBP + -0x30]
ADD EAX,0x8
MOV dword ptr [RBP + -0x40],EAX
JMP 0x0013e30b
LAB_0013e2ff:
MOV RCX,qword ptr [RBP + -0x38]
LEA RAX,[RCX + 0x8]
MOV qword ptr [RBP + -0x38],RAX
LAB_0013e30b:
MOV R12,qword ptr [RCX]
MOV EDI,0x20
MOV RSI,RBX
CALL 0x001378e0
MOV RDI,R15
MOV RSI,RBX
CALL 0x00137340
MOV EDI,0x22
MOV RSI,RBX
CALL 0x001378e0
MOV RDI,R12
CALL 0x00137410
MOV RDI,RBX
MOV RSI,R12
MOV RDX,RAX
XOR ECX,ECX
CALL 0x00142326
MOV EDI,0x22
MOV RSI,RBX
CALL 0x001378e0
MOV EAX,dword ptr [RBP + -0x40]
CMP RAX,0x28
JA 0x0013e370
MOV RCX,RAX
ADD RCX,qword ptr [RBP + -0x30]
ADD EAX,0x8
MOV dword ptr [RBP + -0x40],EAX
JMP 0x0013e37c
LAB_0013e370:
MOV RCX,qword ptr [RBP + -0x38]
LEA RDX,[RCX + 0x8]
MOV qword ptr [RBP + -0x38],RDX
LAB_0013e37c:
MOV R15,qword ptr [RCX]
TEST R15,R15
JNZ 0x0013e2ec
MOV EDI,0x3e
MOV RSI,RBX
CALL 0x001378e0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00137340
MOV RDI,RBX
CALL 0x00138cfc
ADD RSP,0xd0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void print_xml_tag(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
FILE *param_9,char *param_10,char *param_11,char *param_12,int8 param_13,
int8 param_14)
{
char *__s;
char in_AL;
ulong uVar1;
size_t sVar2;
long *plVar3;
char *__s_00;
int1 local_f8 [40];
int8 local_d0;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
ulong local_48;
long *local_40;
int1 *local_38;
if (in_AL != '\0') {
local_c8 = param_1;
local_b8 = param_2;
local_a8 = param_3;
local_98 = param_4;
local_88 = param_5;
local_78 = param_6;
local_68 = param_7;
local_58 = param_8;
}
local_d0 = param_14;
fputs(param_10,param_9);
fputc(0x3c,param_9);
fputs(param_12,param_9);
local_48 = 0x3000000028;
local_40 = (long *)&stack0x00000008;
__s_00 = "name=";
uVar1 = 0x28;
local_38 = local_f8;
do {
if ((uint)uVar1 < 0x29) {
local_48 = CONCAT44(local_48._4_4_,(uint)uVar1 + 8);
plVar3 = (long *)(local_38 + uVar1);
}
else {
plVar3 = local_40;
local_40 = local_40 + 1;
}
__s = (char *)*plVar3;
fputc(0x20,param_9);
fputs(__s_00,param_9);
fputc(0x22,param_9);
sVar2 = strlen(__s);
print_quoted_xml(param_9,__s,sVar2,0);
fputc(0x22,param_9);
uVar1 = local_48 & 0xffffffff;
if (uVar1 < 0x29) {
plVar3 = (long *)(local_38 + uVar1);
uVar1 = (ulong)((int)local_48 + 8U);
local_48 = CONCAT44(local_48._4_4_,(int)local_48 + 8U);
}
else {
plVar3 = local_40;
local_40 = local_40 + 1;
}
__s_00 = (char *)*plVar3;
} while (__s_00 != (char *)0x0);
fputc(0x3e,param_9);
fputs(param_11,param_9);
check_io(param_9);
return;
}
|
|
3,208 | my_strnncollsp_tis620 | eloqsql/strings/ctype-tis620.c | static
int my_strnncollsp_tis620(CHARSET_INFO * cs __attribute__((unused)),
const uchar *a0, size_t a_length,
const uchar *b0, size_t b_length)
{
uchar buf[80], *end, *a, *b, *alloced= NULL;
size_t length;
int res= 0;
a= buf;
if ((a_length + b_length +2) > (int) sizeof(buf))
alloced= a= (uchar*) my_malloc(PSI_INSTRUMENT_ME, a_length+b_length+2, MYF(MY_FAE));
b= a + a_length+1;
if (a_length)
memcpy((char*) a, (char*) a0, a_length);
a[a_length]= 0; /* if length(a0)> len1, need to put 'end of string' */
if (b_length)
memcpy((char *)b, (char *)b0, b_length);
b[b_length]= 0; /* put end of string */
a_length= thai2sortable(a, a_length);
b_length= thai2sortable(b, b_length);
end= a + (length= MY_MIN(a_length, b_length));
while (a < end)
{
if (*a++ != *b++)
{
res= ((int) a[-1] - (int) b[-1]);
goto ret;
}
}
res= a_length == b_length ? 0 :
a_length < b_length ?
-my_strnncollsp_padspace_bin(b, b_length - length) :
my_strnncollsp_padspace_bin(a, a_length - length);
ret:
if (alloced)
my_free(alloced);
return res;
} | O3 | c | my_strnncollsp_tis620:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, -0x90(%rbp)
movq %rdx, %r15
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq (%rdx,%r8), %rsi
addq $0x2, %rsi
cmpq $0x51, %rsi
jb 0xbe970
movl $0x8, %edx
xorl %edi, %edi
callq 0xa63e5
movq %rax, %r12
movq %rax, -0x88(%rbp)
jmp 0xbe97f
movq $0x0, -0x88(%rbp)
leaq -0x80(%rbp), %r12
leaq (%r12,%r15), %r13
testq %r15, %r15
je 0xbe996
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2a0a0
leaq (%r12,%r15), %rbx
incq %rbx
movb $0x0, (%r13)
testq %r14, %r14
je 0xbe9b9
movq %rbx, %rdi
movq -0x90(%rbp), %rsi
movq %r14, %rdx
callq 0x2a0a0
movb $0x0, (%rbx,%r14)
movq %r12, %rdi
movq %r15, %rsi
callq 0xbeb17
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbeb17
cmpq %r14, %r15
movq %r14, %rax
cmovbq %r15, %rax
leaq (%r12,%rax), %rcx
cmpq %rcx, %r12
jae 0xbe9ff
movzbl (%r12), %r13d
movzbl 0x1(%r12,%r15), %edx
incq %r12
cmpb %dl, %r13b
je 0xbe9e2
subl %edx, %r13d
jmp 0xbea34
xorl %r13d, %r13d
cmpq %r14, %r15
je 0xbea34
jae 0xbea23
leaq (%r15,%r12), %rdi
incq %rdi
subq %rax, %r14
movq %r14, %rsi
callq 0xb302d
movl %eax, %r13d
negl %r13d
jmp 0xbea34
subq %rax, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0xb302d
movl %eax, %r13d
movq -0x88(%rbp), %rdi
testq %rdi, %rdi
je 0xbea45
callq 0xa6612
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xbea66
movl %r13d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a270
| my_strnncollsp_tis620:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, r8
mov [rbp+var_90], rcx
mov r15, rdx
mov rbx, rsi
mov rax, fs:28h
mov [rbp+var_30], rax
lea rsi, [rdx+r8]
add rsi, 2
cmp rsi, 51h ; 'Q'
jb short loc_BE970
mov edx, 8
xor edi, edi
call my_malloc
mov r12, rax
mov [rbp+var_88], rax
jmp short loc_BE97F
loc_BE970:
mov [rbp+var_88], 0
lea r12, [rbp+var_80]
loc_BE97F:
lea r13, [r12+r15]
test r15, r15
jz short loc_BE996
mov rdi, r12
mov rsi, rbx
mov rdx, r15
call _memcpy
loc_BE996:
lea rbx, [r12+r15]
inc rbx
mov byte ptr [r13+0], 0
test r14, r14
jz short loc_BE9B9
mov rdi, rbx
mov rsi, [rbp+var_90]
mov rdx, r14
call _memcpy
loc_BE9B9:
mov byte ptr [rbx+r14], 0
mov rdi, r12
mov rsi, r15
call thai2sortable
mov rdi, rbx
mov rsi, r14
call thai2sortable
cmp r15, r14
mov rax, r14
cmovb rax, r15
lea rcx, [r12+rax]
loc_BE9E2:
cmp r12, rcx
jnb short loc_BE9FF
movzx r13d, byte ptr [r12]
movzx edx, byte ptr [r12+r15+1]
inc r12
cmp r13b, dl
jz short loc_BE9E2
sub r13d, edx
jmp short loc_BEA34
loc_BE9FF:
xor r13d, r13d
cmp r15, r14
jz short loc_BEA34
jnb short loc_BEA23
lea rdi, [r15+r12]
inc rdi
sub r14, rax
mov rsi, r14
call my_strnncollsp_padspace_bin
mov r13d, eax
neg r13d
jmp short loc_BEA34
loc_BEA23:
sub r15, rax
mov rdi, r12
mov rsi, r15
call my_strnncollsp_padspace_bin
mov r13d, eax
loc_BEA34:
mov rdi, [rbp+var_88]
test rdi, rdi
jz short loc_BEA45
call my_free
loc_BEA45:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_BEA66
mov eax, r13d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_BEA66:
call ___stack_chk_fail
| long long my_strnncollsp_tis620(long long a1, long long a2, unsigned long long a3, long long a4, unsigned long long a5)
{
unsigned long long v8; // rsi
unsigned __int8 *v9; // r12
unsigned long long v10; // rax
unsigned __int8 *v11; // rcx
int v12; // r13d
int v13; // edx
unsigned int v14; // r13d
long long v17; // [rsp+8h] [rbp-88h]
char v18; // [rsp+10h] [rbp-80h] BYREF
unsigned long long v19; // [rsp+60h] [rbp-30h]
v19 = __readfsqword(0x28u);
v8 = a3 + a5 + 2;
if ( v8 < 0x51 )
{
v17 = 0LL;
v9 = (unsigned __int8 *)&v18;
}
else
{
v9 = (unsigned __int8 *)my_malloc(0, v8, 8);
v17 = (long long)v9;
}
if ( a3 )
memcpy(v9, a2, a3);
v9[a3] = 0;
if ( a5 )
memcpy(&v9[a3 + 1], a4, a5);
v9[a3 + 1 + a5] = 0;
thai2sortable(v9, a3);
thai2sortable(&v9[a3 + 1], a5);
v10 = a5;
if ( a3 < a5 )
v10 = a3;
v11 = &v9[v10];
while ( v9 < v11 )
{
v12 = *v9;
v13 = v9[a3 + 1];
++v9;
if ( (_BYTE)v12 != (_BYTE)v13 )
{
v14 = v12 - v13;
goto LABEL_18;
}
}
v14 = 0;
if ( a3 != a5 )
{
if ( a3 >= a5 )
v14 = my_strnncollsp_padspace_bin((long long)v9, a3 - v10);
else
v14 = -(int)my_strnncollsp_padspace_bin((long long)&v9[a3 + 1], a5 - v10);
}
LABEL_18:
if ( v17 )
my_free(v17);
return v14;
}
| my_strnncollsp_tis620:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,R8
MOV qword ptr [RBP + -0x90],RCX
MOV R15,RDX
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA RSI,[RDX + R8*0x1]
ADD RSI,0x2
CMP RSI,0x51
JC 0x001be970
MOV EDX,0x8
XOR EDI,EDI
CALL 0x001a63e5
MOV R12,RAX
MOV qword ptr [RBP + -0x88],RAX
JMP 0x001be97f
LAB_001be970:
MOV qword ptr [RBP + -0x88],0x0
LEA R12,[RBP + -0x80]
LAB_001be97f:
LEA R13,[R12 + R15*0x1]
TEST R15,R15
JZ 0x001be996
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R15
CALL 0x0012a0a0
LAB_001be996:
LEA RBX,[R12 + R15*0x1]
INC RBX
MOV byte ptr [R13],0x0
TEST R14,R14
JZ 0x001be9b9
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x90]
MOV RDX,R14
CALL 0x0012a0a0
LAB_001be9b9:
MOV byte ptr [RBX + R14*0x1],0x0
MOV RDI,R12
MOV RSI,R15
CALL 0x001beb17
MOV RDI,RBX
MOV RSI,R14
CALL 0x001beb17
CMP R15,R14
MOV RAX,R14
CMOVC RAX,R15
LEA RCX,[R12 + RAX*0x1]
LAB_001be9e2:
CMP R12,RCX
JNC 0x001be9ff
MOVZX R13D,byte ptr [R12]
MOVZX EDX,byte ptr [R12 + R15*0x1 + 0x1]
INC R12
CMP R13B,DL
JZ 0x001be9e2
SUB R13D,EDX
JMP 0x001bea34
LAB_001be9ff:
XOR R13D,R13D
CMP R15,R14
JZ 0x001bea34
JNC 0x001bea23
LEA RDI,[R15 + R12*0x1]
INC RDI
SUB R14,RAX
MOV RSI,R14
CALL 0x001b302d
MOV R13D,EAX
NEG R13D
JMP 0x001bea34
LAB_001bea23:
SUB R15,RAX
MOV RDI,R12
MOV RSI,R15
CALL 0x001b302d
MOV R13D,EAX
LAB_001bea34:
MOV RDI,qword ptr [RBP + -0x88]
TEST RDI,RDI
JZ 0x001bea45
CALL 0x001a6612
LAB_001bea45:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001bea66
MOV EAX,R13D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001bea66:
CALL 0x0012a270
|
int my_strnncollsp_tis620
(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5)
{
byte *pbVar1;
byte bVar2;
byte *__dest;
byte *pbVar3;
ulong uVar4;
int iVar5;
long in_FS_OFFSET;
byte *local_90;
byte local_88 [80];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = param_3 + param_5 + 2;
if (uVar4 < 0x51) {
local_90 = (byte *)0x0;
__dest = local_88;
}
else {
__dest = (byte *)my_malloc(0,uVar4,8);
local_90 = __dest;
}
if (param_3 != 0) {
memcpy(__dest,param_2,param_3);
}
pbVar3 = __dest + param_3 + 1;
__dest[param_3] = 0;
if (param_5 != 0) {
memcpy(pbVar3,param_4,param_5);
}
pbVar3[param_5] = 0;
thai2sortable(__dest,param_3);
thai2sortable(pbVar3,param_5);
uVar4 = param_5;
if (param_3 < param_5) {
uVar4 = param_3;
}
pbVar3 = __dest + uVar4;
do {
if (pbVar3 <= __dest) {
iVar5 = 0;
if (param_3 != param_5) {
if (param_3 < param_5) {
iVar5 = my_strnncollsp_padspace_bin(__dest + param_3 + 1,param_5 - uVar4);
iVar5 = -iVar5;
}
else {
iVar5 = my_strnncollsp_padspace_bin(__dest,param_3 - uVar4);
}
}
goto LAB_001bea34;
}
bVar2 = *__dest;
pbVar1 = __dest + param_3 + 1;
__dest = __dest + 1;
} while (bVar2 == *pbVar1);
iVar5 = (uint)bVar2 - (uint)*pbVar1;
LAB_001bea34:
if (local_90 != (byte *)0x0) {
my_free();
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return iVar5;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
3,209 | ma_pvio_close | eloqsql/libmariadb/libmariadb/ma_pvio.c | void ma_pvio_close(MARIADB_PVIO *pvio)
{
/* free internal structures and close connection */
if (pvio)
{
#ifdef HAVE_TLS
if (pvio->ctls)
{
ma_pvio_tls_close(pvio->ctls);
free(pvio->ctls);
}
#endif
if (pvio && pvio->methods->close)
pvio->methods->close(pvio);
if (pvio->cache)
free(pvio->cache);
free(pvio);
}
} | O0 | c | ma_pvio_close:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x47ad1
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x47a88
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x48240
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x361a0
cmpq $0x0, -0x8(%rbp)
je 0x47ab0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x48(%rax)
je 0x47ab0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x47ac8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x361a0
movq -0x8(%rbp), %rdi
callq 0x361a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| ma_pvio_close:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
cmp [rbp+var_8], 0
jz short loc_47AD1
mov rax, [rbp+var_8]
cmp qword ptr [rax+38h], 0
jz short loc_47A88
mov rax, [rbp+var_8]
mov rdi, [rax+38h]
call ma_pvio_tls_close
mov rax, [rbp+var_8]
mov rdi, [rax+38h]
call _free
loc_47A88:
cmp [rbp+var_8], 0
jz short loc_47AB0
mov rax, [rbp+var_8]
mov rax, [rax+48h]
cmp qword ptr [rax+48h], 0
jz short loc_47AB0
mov rax, [rbp+var_8]
mov rax, [rax+48h]
mov rax, [rax+48h]
mov rdi, [rbp+var_8]
call rax
loc_47AB0:
mov rax, [rbp+var_8]
cmp qword ptr [rax+8], 0
jz short loc_47AC8
mov rax, [rbp+var_8]
mov rdi, [rax+8]
call _free
loc_47AC8:
mov rdi, [rbp+var_8]
call _free
loc_47AD1:
add rsp, 10h
pop rbp
retn
| long long ma_pvio_close(_QWORD *a1)
{
long long result; // rax
if ( a1 )
{
if ( a1[7] )
{
ma_pvio_tls_close(a1[7]);
free(a1[7]);
}
if ( *(_QWORD *)(a1[9] + 72LL) )
(*(void ( **)(_QWORD *))(a1[9] + 72LL))(a1);
if ( a1[1] )
free(a1[1]);
return free(a1);
}
return result;
}
| ma_pvio_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00147ad1
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x38],0x0
JZ 0x00147a88
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x38]
CALL 0x00148240
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x38]
CALL 0x001361a0
LAB_00147a88:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00147ab0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x48]
CMP qword ptr [RAX + 0x48],0x0
JZ 0x00147ab0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RAX + 0x48]
MOV RDI,qword ptr [RBP + -0x8]
CALL RAX
LAB_00147ab0:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x00147ac8
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001361a0
LAB_00147ac8:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001361a0
LAB_00147ad1:
ADD RSP,0x10
POP RBP
RET
|
void ma_pvio_close(void *param_1)
{
if (param_1 != (void *)0x0) {
if (*(long *)((long)param_1 + 0x38) != 0) {
ma_pvio_tls_close(*(int8 *)((long)param_1 + 0x38));
free(*(void **)((long)param_1 + 0x38));
}
if ((param_1 != (void *)0x0) && (*(long *)(*(long *)((long)param_1 + 0x48) + 0x48) != 0)) {
(**(code **)(*(long *)((long)param_1 + 0x48) + 0x48))(param_1);
}
if (*(long *)((long)param_1 + 8) != 0) {
free(*(void **)((long)param_1 + 8));
}
free(param_1);
}
return;
}
|
|
3,210 | sigint_handler(int) | monkey531[P]llama/examples/infill/infill.cpp | static void sigint_handler(int signo) {
if (signo == SIGINT) {
if (!is_interacting) {
is_interacting = true;
} else {
console::cleanup();
LOG("\n");
common_perf_print(*g_ctx, *g_smpl);
// make sure all logs are flushed
LOG("Interrupted by user\n");
common_log_pause(common_log_main());
_exit(130);
}
}
} | O0 | cpp | sigint_handler(int):
pushq %rax
movl %edi, 0x4(%rsp)
cmpl $0x2, 0x4(%rsp)
jne 0x629ea
testb $0x1, 0x244691(%rip) # 0x2a6fe8
jne 0x62965
movb $0x1, 0x244688(%rip) # 0x2a6fe8
jmp 0x629e8
callq 0x19fb30
xorl %eax, %eax
leaq 0x244dad(%rip), %rcx # 0x2a7720
cmpl (%rcx), %eax
jg 0x6298f
callq 0x1c1ac0
movq %rax, %rdi
xorl %esi, %esi
leaq 0x1a7b7e(%rip), %rdx # 0x20a506
movb $0x0, %al
callq 0x1c1bb0
jmp 0x62991
movq 0x244640(%rip), %rax # 0x2a6fd8
movq (%rax), %rdi
movq 0x24463e(%rip), %rax # 0x2a6fe0
movq (%rax), %rsi
callq 0x1c63f0
xorl %eax, %eax
leaq 0x244d6d(%rip), %rcx # 0x2a7720
cmpl (%rcx), %eax
jg 0x629cf
callq 0x1c1ac0
movq %rax, %rdi
xorl %esi, %esi
leaq 0x1a7fac(%rip), %rdx # 0x20a974
movb $0x0, %al
callq 0x1c1bb0
jmp 0x629d1
callq 0x1c1ac0
movq %rax, %rdi
callq 0x1c1b50
movl $0x82, %edi
callq 0x5b230
jmp 0x629ea
popq %rax
retq
nopl (%rax)
| _ZL14sigint_handleri:
push rax
mov [rsp+8+var_4], edi
cmp [rsp+8+var_4], 2
jnz loc_629EA
test cs:_ZL14is_interacting, 1; is_interacting
jnz short loc_62965
mov cs:_ZL14is_interacting, 1; is_interacting
jmp loc_629E8
loc_62965:
call _ZN7console7cleanupEv; console::cleanup(void)
xor eax, eax
lea rcx, common_log_verbosity_thold
cmp eax, [rcx]
jg short loc_6298F
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
xor esi, esi
lea rdx, aInfillMode+1Bh; "\n"
mov al, 0
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_6298F:
jmp short $+2
loc_62991:
mov rax, cs:_ZL5g_ctx; g_ctx
mov rdi, [rax]
mov rax, cs:_ZL6g_smpl; g_smpl
mov rsi, [rax]
call _Z17common_perf_printPK13llama_contextPK14common_sampler; common_perf_print(llama_context const*,common_sampler const*)
xor eax, eax
lea rcx, common_log_verbosity_thold
cmp eax, [rcx]
jg short loc_629CF
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
xor esi, esi
lea rdx, aInterruptedByU; "Interrupted by user\n"
mov al, 0
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_629CF:
jmp short $+2
loc_629D1:
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax; common_log *
call _Z16common_log_pauseP10common_log; common_log_pause(common_log *)
mov edi, 82h
call __exit
loc_629E8:
jmp short $+2
loc_629EA:
pop rax
retn
| unsigned long long sigint_handler(console *a1)
{
unsigned int v1; // eax
int v2; // eax
int v3; // ecx
int v4; // r8d
int v5; // r9d
int v6; // eax
int v7; // ecx
int v8; // r8d
int v9; // r9d
common_log *v10; // rax
if ( (_DWORD)a1 == 2 )
{
if ( (is_interacting & 1) != 0 )
{
console::cleanup(a1);
if ( common_log_verbosity_thold >= 0 )
{
v2 = common_log_main();
common_log_add(v2, 0, (unsigned int)"\n", v3, v4, v5);
}
common_perf_print(*(_QWORD *)g_ctx, *(_QWORD *)g_smpl);
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
common_log_add(v6, 0, (unsigned int)"Interrupted by user\n", v7, v8, v9);
}
v10 = (common_log *)common_log_main();
common_log_pause(v10);
_exit(130LL);
}
is_interacting = 1;
}
return __PAIR64__((unsigned int)a1, v1);
}
| sigint_handler:
PUSH RAX
MOV dword ptr [RSP + 0x4],EDI
CMP dword ptr [RSP + 0x4],0x2
JNZ 0x001629ea
TEST byte ptr [0x003a6fe8],0x1
JNZ 0x00162965
MOV byte ptr [0x003a6fe8],0x1
JMP 0x001629e8
LAB_00162965:
CALL 0x0029fb30
XOR EAX,EAX
LEA RCX,[0x3a7720]
CMP EAX,dword ptr [RCX]
JG 0x0016298f
CALL 0x002c1ac0
MOV RDI,RAX
XOR ESI,ESI
LEA RDX,[0x30a506]
MOV AL,0x0
CALL 0x002c1bb0
LAB_0016298f:
JMP 0x00162991
LAB_00162991:
MOV RAX,qword ptr [0x003a6fd8]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [0x003a6fe0]
MOV RSI,qword ptr [RAX]
CALL 0x002c63f0
XOR EAX,EAX
LEA RCX,[0x3a7720]
CMP EAX,dword ptr [RCX]
JG 0x001629cf
CALL 0x002c1ac0
MOV RDI,RAX
XOR ESI,ESI
LEA RDX,[0x30a974]
MOV AL,0x0
CALL 0x002c1bb0
LAB_001629cf:
JMP 0x001629d1
LAB_001629d1:
CALL 0x002c1ac0
MOV RDI,RAX
CALL 0x002c1b50
MOV EDI,0x82
CALL 0x0015b230
LAB_001629e8:
JMP 0x001629ea
LAB_001629ea:
POP RAX
RET
|
/* sigint_handler(int) */
int8 sigint_handler(int param_1)
{
int4 in_EAX;
int8 uVar1;
common_log *pcVar2;
int8 uStack_8;
uStack_8 = CONCAT44(param_1,in_EAX);
if (param_1 == 2) {
if ((is_interacting & 1) != 0) {
console::cleanup();
if (-1 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,0,"\n");
}
common_perf_print((llama_context *)*g_ctx,(common_sampler *)*g_smpl);
if (-1 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,0,"Interrupted by user\n");
}
pcVar2 = (common_log *)common_log_main();
common_log_pause(pcVar2);
/* WARNING: Subroutine does not return */
_exit(0x82);
}
is_interacting = 1;
}
return uStack_8;
}
|
|
3,211 | calculate_alphas_cumprod(float*, float, float, int) | 7CodeWizard[P]stablediffusion/stable-diffusion.cpp | void calculate_alphas_cumprod(float* alphas_cumprod,
float linear_start = 0.00085f,
float linear_end = 0.0120,
int timesteps = TIMESTEPS) {
float ls_sqrt = sqrtf(linear_start);
float le_sqrt = sqrtf(linear_end);
float amount = le_sqrt - ls_sqrt;
float product = 1.0f;
for (int i = 0; i < timesteps; i++) {
float beta = ls_sqrt + amount * ((float)i / (timesteps - 1));
product *= 1.0f - powf(beta, 2.0f);
alphas_cumprod[i] = product;
}
} | O0 | cpp | calculate_alphas_cumprod(float*, float, float, int):
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movss %xmm1, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movss 0x2c(%rsp), %xmm0
callq 0xbdb0
movss %xmm0, 0x20(%rsp)
movss 0x28(%rsp), %xmm0
callq 0xbdb0
movss %xmm0, 0x1c(%rsp)
movss 0x1c(%rsp), %xmm0
subss 0x20(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
movss 0x149d8f(%rip), %xmm0 # 0x17d004
movss %xmm0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x33313
movss 0x20(%rsp), %xmm1
movss 0x18(%rsp), %xmm0
cvtsi2ssl 0x10(%rsp), %xmm2
movl 0x24(%rsp), %eax
subl $0x1, %eax
cvtsi2ss %eax, %xmm3
divss %xmm3, %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
movss 0x14bf06(%rip), %xmm1 # 0x17f1d4
callq 0xbb90
movaps %xmm0, %xmm1
movss 0x149d26(%rip), %xmm0 # 0x17d004
subss %xmm1, %xmm0
mulss 0x14(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
movq 0x30(%rsp), %rax
movslq 0x10(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x33283
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| _Z24calculate_alphas_cumprodPfffi:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
movss [rsp+38h+var_C], xmm0
movss [rsp+38h+var_10], xmm1
mov [rsp+38h+var_14], esi
movss xmm0, [rsp+38h+var_C]
call _sqrtf
movss [rsp+38h+var_18], xmm0
movss xmm0, [rsp+38h+var_10]
call _sqrtf
movss [rsp+38h+var_1C], xmm0
movss xmm0, [rsp+38h+var_1C]
subss xmm0, [rsp+38h+var_18]
movss [rsp+38h+var_20], xmm0
movss xmm0, cs:flt_17D004
movss [rsp+38h+var_24], xmm0
mov [rsp+38h+var_28], 0
loc_33283:
mov eax, [rsp+38h+var_28]
cmp eax, [rsp+38h+var_14]
jge loc_33313
movss xmm1, [rsp+38h+var_18]
movss xmm0, [rsp+38h+var_20]
cvtsi2ss xmm2, [rsp+38h+var_28]
mov eax, [rsp+38h+var_14]
sub eax, 1
cvtsi2ss xmm3, eax
divss xmm2, xmm3
mulss xmm0, xmm2
addss xmm0, xmm1
movss [rsp+38h+var_2C], xmm0
movss xmm0, [rsp+38h+var_2C]
movss xmm1, cs:dword_17F1D4
call _powf
movaps xmm1, xmm0
movss xmm0, cs:flt_17D004
subss xmm0, xmm1
mulss xmm0, [rsp+38h+var_24]
movss [rsp+38h+var_24], xmm0
movss xmm0, [rsp+38h+var_24]
mov rax, [rsp+38h+var_8]
movsxd rcx, [rsp+38h+var_28]
movss dword ptr [rax+rcx*4], xmm0
mov eax, [rsp+38h+var_28]
add eax, 1
mov [rsp+38h+var_28], eax
jmp loc_33283
loc_33313:
add rsp, 38h
retn
| long long calculate_alphas_cumprod(float *a1, float a2, float a3, int a4)
{
long long result; // rax
double v5; // xmm0_8
int i; // [rsp+10h] [rbp-28h]
float v7; // [rsp+14h] [rbp-24h]
float v8; // [rsp+18h] [rbp-20h]
float v9; // [rsp+20h] [rbp-18h]
v9 = sqrtf(a2);
v8 = sqrtf(a3) - v9;
v7 = 1.0;
for ( i = 0; ; ++i )
{
result = (unsigned int)i;
if ( i >= a4 )
break;
v5 = powf((float)(v8 * (float)((float)i / (float)(a4 - 1))) + v9, 2.0);
v7 = (float)(1.0 - *(float *)&v5) * v7;
a1[i] = v7;
}
return result;
}
| calculate_alphas_cumprod:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOVSS dword ptr [RSP + 0x2c],XMM0
MOVSS dword ptr [RSP + 0x28],XMM1
MOV dword ptr [RSP + 0x24],ESI
MOVSS XMM0,dword ptr [RSP + 0x2c]
CALL 0x0010bdb0
MOVSS dword ptr [RSP + 0x20],XMM0
MOVSS XMM0,dword ptr [RSP + 0x28]
CALL 0x0010bdb0
MOVSS dword ptr [RSP + 0x1c],XMM0
MOVSS XMM0,dword ptr [RSP + 0x1c]
SUBSS XMM0,dword ptr [RSP + 0x20]
MOVSS dword ptr [RSP + 0x18],XMM0
MOVSS XMM0,dword ptr [0x0027d004]
MOVSS dword ptr [RSP + 0x14],XMM0
MOV dword ptr [RSP + 0x10],0x0
LAB_00133283:
MOV EAX,dword ptr [RSP + 0x10]
CMP EAX,dword ptr [RSP + 0x24]
JGE 0x00133313
MOVSS XMM1,dword ptr [RSP + 0x20]
MOVSS XMM0,dword ptr [RSP + 0x18]
CVTSI2SS XMM2,dword ptr [RSP + 0x10]
MOV EAX,dword ptr [RSP + 0x24]
SUB EAX,0x1
CVTSI2SS XMM3,EAX
DIVSS XMM2,XMM3
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RSP + 0xc],XMM0
MOVSS XMM0,dword ptr [RSP + 0xc]
MOVSS XMM1,dword ptr [0x0027f1d4]
CALL 0x0010bb90
MOVAPS XMM1,XMM0
MOVSS XMM0,dword ptr [0x0027d004]
SUBSS XMM0,XMM1
MULSS XMM0,dword ptr [RSP + 0x14]
MOVSS dword ptr [RSP + 0x14],XMM0
MOVSS XMM0,dword ptr [RSP + 0x14]
MOV RAX,qword ptr [RSP + 0x30]
MOVSXD RCX,dword ptr [RSP + 0x10]
MOVSS dword ptr [RAX + RCX*0x4],XMM0
MOV EAX,dword ptr [RSP + 0x10]
ADD EAX,0x1
MOV dword ptr [RSP + 0x10],EAX
JMP 0x00133283
LAB_00133313:
ADD RSP,0x38
RET
|
/* calculate_alphas_cumprod(float*, float, float, int) */
void calculate_alphas_cumprod(float *param_1,float param_2,float param_3,int param_4)
{
float fVar1;
float fVar2;
float fVar3;
int local_28;
float local_24;
fVar1 = sqrtf(param_2);
fVar2 = sqrtf(param_3);
local_24 = DAT_0027d004;
for (local_28 = 0; local_28 < param_4; local_28 = local_28 + 1) {
fVar3 = powf((fVar2 - fVar1) * ((float)local_28 / (float)(param_4 + -1)) + fVar1,DAT_0027f1d4);
local_24 = (DAT_0027d004 - fVar3) * local_24;
param_1[local_28] = local_24;
}
return;
}
|
|
3,212 | calculate_alphas_cumprod(float*, float, float, int) | 7CodeWizard[P]stablediffusion/stable-diffusion.cpp | void calculate_alphas_cumprod(float* alphas_cumprod,
float linear_start = 0.00085f,
float linear_end = 0.0120,
int timesteps = TIMESTEPS) {
float ls_sqrt = sqrtf(linear_start);
float le_sqrt = sqrtf(linear_end);
float amount = le_sqrt - ls_sqrt;
float product = 1.0f;
for (int i = 0; i < timesteps; i++) {
float beta = ls_sqrt + amount * ((float)i / (timesteps - 1));
product *= 1.0f - powf(beta, 2.0f);
alphas_cumprod[i] = product;
}
} | O1 | cpp | calculate_alphas_cumprod(float*, float, float, int):
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jb 0x30de2
sqrtss %xmm0, %xmm6
jmp 0x30df9
movss %xmm1, 0x4(%rsp)
callq 0xab40
xorps %xmm2, %xmm2
movss 0x4(%rsp), %xmm1
movaps %xmm0, %xmm6
ucomiss %xmm2, %xmm1
jb 0x30e07
xorps %xmm0, %xmm0
sqrtss %xmm1, %xmm0
jmp 0x30e1b
movaps %xmm1, %xmm0
movss %xmm6, 0x4(%rsp)
callq 0xab40
movss 0x4(%rsp), %xmm6
testl %r14d, %r14d
jle 0x30e6e
subss %xmm6, %xmm0
leal -0x1(%r14), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movl %r14d, %eax
movss 0x8a1ce(%rip), %xmm2 # 0xbb008
xorl %ecx, %ecx
movaps %xmm2, %xmm3
xorps %xmm4, %xmm4
cvtsi2ss %ecx, %xmm4
divss %xmm1, %xmm4
mulss %xmm0, %xmm4
addss %xmm6, %xmm4
mulss %xmm4, %xmm4
movaps %xmm2, %xmm5
subss %xmm4, %xmm5
mulss %xmm5, %xmm3
movss %xmm3, (%rbx,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x30e3f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _Z24calculate_alphas_cumprodPfffi:
push r14
push rbx
push rax
mov r14d, esi
mov rbx, rdi
xorps xmm2, xmm2
ucomiss xmm0, xmm2
jb short loc_30DE2
sqrtss xmm6, xmm0
jmp short loc_30DF9
loc_30DE2:
movss [rsp+18h+var_14], xmm1
call _sqrtf
xorps xmm2, xmm2
movss xmm1, [rsp+18h+var_14]
movaps xmm6, xmm0
loc_30DF9:
ucomiss xmm1, xmm2
jb short loc_30E07
xorps xmm0, xmm0
sqrtss xmm0, xmm1
jmp short loc_30E1B
loc_30E07:
movaps xmm0, xmm1
movss [rsp+18h+var_14], xmm6
call _sqrtf
movss xmm6, [rsp+18h+var_14]
loc_30E1B:
test r14d, r14d
jle short loc_30E6E
subss xmm0, xmm6
lea eax, [r14-1]
xorps xmm1, xmm1
cvtsi2ss xmm1, eax
mov eax, r14d
movss xmm2, cs:dword_BB008
xor ecx, ecx
movaps xmm3, xmm2
loc_30E3F:
xorps xmm4, xmm4
cvtsi2ss xmm4, ecx
divss xmm4, xmm1
mulss xmm4, xmm0
addss xmm4, xmm6
mulss xmm4, xmm4
movaps xmm5, xmm2
subss xmm5, xmm4
mulss xmm3, xmm5
movss dword ptr [rbx+rcx*4], xmm3
inc rcx
cmp rax, rcx
jnz short loc_30E3F
loc_30E6E:
add rsp, 8
pop rbx
pop r14
retn
| void calculate_alphas_cumprod(float *a1, float a2, float a3, int a4)
{
float v4; // xmm6_4
double v5; // xmm0_8
double v6; // xmm0_8
float v7; // xmm0_4
long long v8; // rcx
float v9; // xmm3_4
if ( a2 < 0.0 )
{
v5 = sqrtf(a1);
v4 = *(float *)&v5;
}
else
{
v4 = fsqrt(a2);
}
if ( a3 < 0.0 )
v6 = sqrtf(a1);
else
*(float *)&v6 = fsqrt(a3);
if ( a4 > 0 )
{
v7 = *(float *)&v6 - v4;
v8 = 0LL;
v9 = 1.0;
do
{
v9 = v9
* (float)(1.0
- (float)((float)((float)((float)((float)(int)v8 / (float)(a4 - 1)) * v7) + v4)
* (float)((float)((float)((float)(int)v8 / (float)(a4 - 1)) * v7) + v4)));
a1[v8++] = v9;
}
while ( a4 != v8 );
}
}
| |||
3,213 | mariadb_field_attr | eloqsql/libmariadb/libmariadb/mariadb_lib.c | int STDCALL
mariadb_field_attr(MARIADB_CONST_STRING *attr,
const MYSQL_FIELD *field,
enum mariadb_field_attr_t type)
{
MA_FIELD_EXTENSION *ext= (MA_FIELD_EXTENSION*) field->extension;
if (!ext || type > MARIADB_FIELD_ATTR_LAST)
{
*attr= null_const_string;
return 1;
}
*attr= ext->metadata[type];
return 0;
} | O0 | c | mariadb_field_attr:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1fd28
cmpl $0x1, -0x1c(%rbp)
jbe 0x1fd4a
movq -0x10(%rbp), %rax
movq 0x406ed(%rip), %rcx # 0x60420
movq %rcx, (%rax)
movq 0x406eb(%rip), %rcx # 0x60428
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x1fd71
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mariadb_field_attr:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov rax, [rbp+var_18]
mov rax, [rax+78h]
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jz short loc_1FD28
cmp [rbp+var_1C], 1
jbe short loc_1FD4A
loc_1FD28:
mov rax, [rbp+var_10]
mov rcx, cs:null_const_string
mov [rax], rcx
mov rcx, cs:qword_60428
mov [rax+8], rcx
mov [rbp+var_4], 1
jmp short loc_1FD71
loc_1FD4A:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_28]
mov edx, [rbp+var_1C]
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov [rbp+var_4], 0
loc_1FD71:
mov eax, [rbp+var_4]
pop rbp
retn
| long long mariadb_field_attr(_QWORD *a1, long long a2, unsigned int a3)
{
long long v3; // rdx
long long v5; // [rsp+0h] [rbp-28h]
v5 = *(_QWORD *)(a2 + 120);
if ( v5 && a3 <= 1 )
{
v3 = 16LL * a3;
*a1 = *(_QWORD *)(v3 + v5);
a1[1] = *(_QWORD *)(v3 + v5 + 8);
return 0;
}
else
{
*a1 = null_const_string;
a1[1] = qword_60428;
return 1;
}
}
| mariadb_field_attr:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0011fd28
CMP dword ptr [RBP + -0x1c],0x1
JBE 0x0011fd4a
LAB_0011fd28:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [0x00160420]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [0x00160428]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0011fd71
LAB_0011fd4a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x1c]
SHL RDX,0x4
ADD RCX,RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RBP + -0x4],0x0
LAB_0011fd71:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 mariadb_field_attr(int8 *param_1,long param_2,uint param_3)
{
int8 *puVar1;
int4 local_c;
if ((*(long *)(param_2 + 0x78) == 0) || (1 < param_3)) {
*param_1 = null_const_string;
param_1[1] = DAT_00160428;
local_c = 1;
}
else {
puVar1 = (int8 *)(*(long *)(param_2 + 0x78) + (ulong)param_3 * 0x10);
*param_1 = *puVar1;
param_1[1] = puVar1[1];
local_c = 0;
}
return local_c;
}
|
|
3,214 | my_once_alloc | eloqsql/mysys/my_once.c | void* my_once_alloc(size_t Size, myf MyFlags)
{
size_t get_size, max_left;
uchar* point;
reg1 USED_MEM *next;
reg2 USED_MEM **prev;
Size= ALIGN_SIZE(Size);
prev= &my_once_root_block;
max_left=0;
for (next=my_once_root_block ; next && next->left < Size ; next= next->next)
{
if (next->left > max_left)
max_left=next->left;
prev= &next->next;
}
if (! next)
{ /* Time to alloc new block */
get_size= Size+ALIGN_SIZE(sizeof(USED_MEM));
if (max_left*4 < my_once_extra && get_size < my_once_extra)
get_size=my_once_extra; /* Normal alloc */
if ((next = (USED_MEM*) malloc(get_size)) == 0)
{
my_errno=errno;
if (MyFlags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_FATAL), get_size);
return((uchar*) 0);
}
DBUG_PRINT("test",("my_once_malloc %lu byte malloced", (ulong) get_size));
next->next= 0;
next->size= get_size;
next->left= get_size-ALIGN_SIZE(sizeof(USED_MEM));
*prev=next;
}
point= (uchar*) ((char*) next+ (next->size-next->left));
next->left-= Size;
if (MyFlags & MY_ZEROFILL)
bzero(point, Size);
return((void*) point);
} | O0 | c | my_once_alloc:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movq %rax, -0x10(%rbp)
leaq 0x3b6d25(%rip), %rax # 0x4102b0
movq %rax, -0x40(%rbp)
movq $0x0, -0x28(%rbp)
leaq 0x3b6d12(%rip), %rax # 0x4102b0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x41(%rbp)
je 0x595c3
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x595cc
jmp 0x595fb
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x28(%rbp), %rax
jbe 0x595e6
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x595a5
cmpq $0x0, -0x38(%rbp)
jne 0x596d4
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
shlq $0x2, %rax
leaq 0x1ba82f(%rip), %rcx # 0x213e50
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x59647
movq -0x20(%rbp), %rax
leaq 0x1ba81d(%rip), %rcx # 0x213e50
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x59647
leaq 0x1ba80f(%rip), %rax # 0x213e50
movl (%rax), %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x26440
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x5969e
callq 0x26050
movl (%rax), %eax
movl %eax, -0x48(%rbp)
callq 0x5a430
movl -0x48(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
andq $0x18, %rax
cmpq $0x0, %rax
je 0x59691
movq -0x20(%rbp), %rdx
movl $0x5, %edi
movl $0x1004, %esi # imm = 0x1004
movb $0x0, %al
callq 0x64910
movq $0x0, -0x8(%rbp)
jmp 0x59727
jmp 0x596a0
jmp 0x596a2
movq -0x38(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
subq $0x18, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x38(%rbp), %rdx
subq 0x8(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
andq $0x20, %rax
cmpq $0x0, %rax
je 0x5971f
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x261c0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_once_alloc:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_10], rax
lea rax, my_once_root_block
mov [rbp+var_40], rax
mov [rbp+var_28], 0
lea rax, my_once_root_block
mov rax, [rax]
mov [rbp+var_38], rax
loc_595A5:
xor eax, eax
cmp [rbp+var_38], 0
mov [rbp+var_41], al
jz short loc_595C3
mov rax, [rbp+var_38]
mov rax, [rax+8]
cmp rax, [rbp+var_10]
setb al
mov [rbp+var_41], al
loc_595C3:
mov al, [rbp+var_41]
test al, 1
jnz short loc_595CC
jmp short loc_595FB
loc_595CC:
mov rax, [rbp+var_38]
mov rax, [rax+8]
cmp rax, [rbp+var_28]
jbe short loc_595E6
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_28], rax
loc_595E6:
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_38], rax
jmp short loc_595A5
loc_595FB:
cmp [rbp+var_38], 0
jnz loc_596D4
mov rax, [rbp+var_10]
add rax, 18h
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
shl rax, 2
lea rcx, my_once_extra
mov ecx, [rcx]
cmp rax, rcx
jnb short loc_59647
mov rax, [rbp+var_20]
lea rcx, my_once_extra
mov ecx, [rcx]
cmp rax, rcx
jnb short loc_59647
lea rax, my_once_extra
mov eax, [rax]
mov [rbp+var_20], rax
loc_59647:
mov rdi, [rbp+var_20]
call _malloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_5969E
call ___errno_location
mov eax, [rax]
mov [rbp+var_48], eax
call _my_thread_var
mov ecx, [rbp+var_48]
mov [rax], ecx
mov rax, [rbp+var_18]
and rax, 18h
cmp rax, 0
jz short loc_59691
mov rdx, [rbp+var_20]
mov edi, 5
mov esi, 1004h
mov al, 0
call my_error
loc_59691:
mov [rbp+var_8], 0
jmp loc_59727
loc_5969E:
jmp short $+2
loc_596A0:
jmp short $+2
loc_596A2:
mov rax, [rbp+var_38]
mov qword ptr [rax], 0
mov rcx, [rbp+var_20]
mov rax, [rbp+var_38]
mov [rax+10h], rcx
mov rcx, [rbp+var_20]
sub rcx, 18h
mov rax, [rbp+var_38]
mov [rax+8], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_40]
mov [rax], rcx
loc_596D4:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_38]
mov rcx, [rcx+10h]
mov rdx, [rbp+var_38]
sub rcx, [rdx+8]
add rax, rcx
mov [rbp+var_30], rax
mov rdx, [rbp+var_10]
mov rax, [rbp+var_38]
mov rcx, [rax+8]
sub rcx, rdx
mov [rax+8], rcx
mov rax, [rbp+var_18]
and rax, 20h
cmp rax, 0
jz short loc_5971F
mov rdi, [rbp+var_30]
mov rdx, [rbp+var_10]
xor esi, esi
call _memset
loc_5971F:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_59727:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| char * my_once_alloc(long long a1, char a2)
{
int v2; // r8d
int v3; // r9d
int v5; // [rsp+8h] [rbp-48h]
bool v6; // [rsp+Fh] [rbp-41h]
_QWORD *v7; // [rsp+10h] [rbp-40h]
_QWORD *i; // [rsp+18h] [rbp-38h]
char *v9; // [rsp+20h] [rbp-30h]
unsigned long long v10; // [rsp+28h] [rbp-28h]
unsigned long long v11; // [rsp+30h] [rbp-20h]
unsigned long long v12; // [rsp+40h] [rbp-10h]
v12 = (a1 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v7 = &my_once_root_block;
v10 = 0LL;
for ( i = (_QWORD *)my_once_root_block; ; i = (_QWORD *)*i )
{
v6 = 0;
if ( i )
v6 = i[1] < v12;
if ( !v6 )
break;
if ( i[1] > v10 )
v10 = i[1];
v7 = i;
}
if ( !i )
{
v11 = v12 + 24;
if ( 4 * v10 < my_once_extra && v11 < my_once_extra )
v11 = my_once_extra;
i = (_QWORD *)malloc(v11);
if ( !i )
{
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var() = v5;
if ( (a2 & 0x18) != 0 )
my_error(5, 4100, v11, v5, v2, v3);
return 0LL;
}
*i = 0LL;
i[2] = v11;
i[1] = v11 - 24;
*v7 = i;
}
v9 = (char *)i + i[2] - i[1];
i[1] -= v12;
if ( (a2 & 0x20) != 0 )
memset(v9, 0LL, v12);
return v9;
}
| my_once_alloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
MOV qword ptr [RBP + -0x10],RAX
LEA RAX,[0x5102b0]
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x28],0x0
LEA RAX,[0x5102b0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
LAB_001595a5:
XOR EAX,EAX
CMP qword ptr [RBP + -0x38],0x0
MOV byte ptr [RBP + -0x41],AL
JZ 0x001595c3
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x10]
SETC AL
MOV byte ptr [RBP + -0x41],AL
LAB_001595c3:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x001595cc
JMP 0x001595fb
LAB_001595cc:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001595e6
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_001595e6:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001595a5
LAB_001595fb:
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001596d4
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x2
LEA RCX,[0x313e50]
MOV ECX,dword ptr [RCX]
CMP RAX,RCX
JNC 0x00159647
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x313e50]
MOV ECX,dword ptr [RCX]
CMP RAX,RCX
JNC 0x00159647
LEA RAX,[0x313e50]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
LAB_00159647:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00126440
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x0015969e
CALL 0x00126050
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x48],EAX
CALL 0x0015a430
MOV ECX,dword ptr [RBP + -0x48]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x18
CMP RAX,0x0
JZ 0x00159691
MOV RDX,qword ptr [RBP + -0x20]
MOV EDI,0x5
MOV ESI,0x1004
MOV AL,0x0
CALL 0x00164910
LAB_00159691:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00159727
LAB_0015969e:
JMP 0x001596a0
LAB_001596a0:
JMP 0x001596a2
LAB_001596a2:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],0x0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x20]
SUB RCX,0x18
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],RCX
LAB_001596d4:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX + 0x10]
MOV RDX,qword ptr [RBP + -0x38]
SUB RCX,qword ptr [RDX + 0x8]
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RDX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x8]
SUB RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x20
CMP RAX,0x0
JZ 0x0015971f
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x001261c0
LAB_0015971f:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_00159727:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
void * my_once_alloc(long param_1,ulong param_2)
{
int iVar1;
ulong __n;
int *piVar2;
void *__s;
bool bVar3;
int8 *local_48;
int8 *local_40;
ulong local_30;
size_t local_28;
__n = param_1 + 7U & 0xfffffffffffffff8;
local_48 = &my_once_root_block;
local_30 = 0;
local_40 = my_once_root_block;
while( true ) {
bVar3 = false;
if (local_40 != (int8 *)0x0) {
bVar3 = (ulong)local_40[1] < __n;
}
if (!bVar3) break;
if (local_30 < (ulong)local_40[1]) {
local_30 = local_40[1];
}
local_48 = local_40;
local_40 = (int8 *)*local_40;
}
if (local_40 == (int8 *)0x0) {
local_28 = __n + 0x18;
if ((local_30 << 2 < (ulong)my_once_extra) && (local_28 < my_once_extra)) {
local_28 = (size_t)my_once_extra;
}
local_40 = (int8 *)malloc(local_28);
if (local_40 == (int8 *)0x0) {
piVar2 = __errno_location();
iVar1 = *piVar2;
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar1;
if ((param_2 & 0x18) != 0) {
my_error(5,0x1004,local_28);
}
return (void *)0x0;
}
*local_40 = 0;
local_40[2] = local_28;
local_40[1] = local_28 - 0x18;
*local_48 = local_40;
}
__s = (void *)((long)local_40 + (local_40[2] - local_40[1]));
local_40[1] = local_40[1] - __n;
if ((param_2 & 0x20) != 0) {
memset(__s,0,__n);
}
return __s;
}
|
|
3,215 | ma_calc_blob_length | eloqsql/storage/maria/ma_dynrec.c | ulong _ma_calc_blob_length(uint length, const uchar *pos)
{
switch (length) {
case 1:
return (uint) (uchar) *pos;
case 2:
return (uint) uint2korr(pos);
case 3:
return uint3korr(pos);
case 4:
return uint4korr(pos);
default:
break;
}
return 0; /* Impossible */
} | O3 | c | ma_calc_blob_length:
pushq %rbp
movq %rsp, %rbp
decl %edi
cmpl $0x3, %edi
ja 0x691fb
leaq 0x9c507(%rip), %rax # 0x1056dc
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movzbl (%rsi), %eax
jmp 0x691fd
movzwl (%rsi), %ecx
movzbl 0x2(%rsi), %eax
shll $0x10, %eax
orq %rcx, %rax
jmp 0x691fd
movl (%rsi), %eax
jmp 0x691fd
movzwl (%rsi), %eax
jmp 0x691fd
xorl %eax, %eax
popq %rbp
retq
| _ma_calc_blob_length:
push rbp
mov rbp, rsp
dec edi; switch 4 cases
cmp edi, 3
ja short def_691DC; jumptable 00000000000691DC default case
lea rax, jpt_691DC
movsxd rcx, ds:(jpt_691DC - 1056DCh)[rax+rdi*4]
add rcx, rax
jmp rcx; switch jump
loc_691DE:
movzx eax, byte ptr [rsi]; jumptable 00000000000691DC case 1
jmp short loc_691FD
loc_691E3:
movzx ecx, word ptr [rsi]; jumptable 00000000000691DC case 3
movzx eax, byte ptr [rsi+2]
shl eax, 10h
or rax, rcx
jmp short loc_691FD
loc_691F2:
mov eax, [rsi]; jumptable 00000000000691DC case 4
jmp short loc_691FD
loc_691F6:
movzx eax, word ptr [rsi]; jumptable 00000000000691DC case 2
jmp short loc_691FD
def_691DC:
xor eax, eax; jumptable 00000000000691DC default case
loc_691FD:
pop rbp
retn
| unsigned long long ma_calc_blob_length(int a1, unsigned __int8 *a2)
{
unsigned long long result; // rax
switch ( a1 )
{
case 1:
result = *a2;
break;
case 2:
result = *(unsigned __int16 *)a2;
break;
case 3:
result = *(unsigned __int16 *)a2 | (unsigned long long)(a2[2] << 16);
break;
case 4:
result = *(unsigned int *)a2;
break;
default:
result = 0LL;
break;
}
return result;
}
| _ma_calc_blob_length:
PUSH RBP
MOV RBP,RSP
DEC EDI
CMP EDI,0x3
JA 0x001691fb
LEA RAX,[0x2056dc]
MOVSXD RCX,dword ptr [RAX + RDI*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_1:
MOVZX EAX,byte ptr [RSI]
JMP 0x001691fd
caseD_3:
MOVZX ECX,word ptr [RSI]
MOVZX EAX,byte ptr [RSI + 0x2]
SHL EAX,0x10
OR RAX,RCX
JMP 0x001691fd
caseD_4:
MOV EAX,dword ptr [RSI]
JMP 0x001691fd
caseD_2:
MOVZX EAX,word ptr [RSI]
JMP 0x001691fd
default:
XOR EAX,EAX
LAB_001691fd:
POP RBP
RET
|
uint _ma_calc_blob_length(int4 param_1,uint *param_2)
{
uint uVar1;
switch(param_1) {
case 1:
uVar1 = (uint)(byte)*param_2;
break;
case 2:
uVar1 = (uint)(ushort)*param_2;
break;
case 3:
uVar1 = (uint)(uint3)*param_2;
break;
case 4:
uVar1 = *param_2;
break;
default:
uVar1 = 0;
}
return uVar1;
}
|
|
3,216 | stmt_set_error | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | void stmt_set_error(MYSQL_STMT *stmt,
unsigned int error_nr,
const char *sqlstate,
const char *format,
...)
{
va_list ap;
const char *error= NULL;
if (error_nr >= CR_MIN_ERROR && error_nr <= CR_MYSQL_LAST_ERROR)
error= ER(error_nr);
else if (error_nr >= CER_MIN_ERROR && error_nr <= CR_MARIADB_LAST_ERROR)
error= CER(error_nr);
stmt->last_errno= error_nr;
ma_strmake(stmt->sqlstate, sqlstate, SQLSTATE_LENGTH);
va_start(ap, format);
vsnprintf(stmt->last_error, MYSQL_ERRMSG_SIZE,
format ? format : error ? error : "", ap);
va_end(ap);
return;
} | O0 | c | stmt_set_error:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
testb %al, %al
je 0x2d31e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x48(%rbp)
cmpl $0x7d0, -0xc(%rbp) # imm = 0x7D0
jb 0x2d372
cmpl $0x80d, -0xc(%rbp) # imm = 0x80D
ja 0x2d372
movl -0xc(%rbp), %eax
subl $0x7d0, %eax # imm = 0x7D0
movl %eax, %eax
movl %eax, %ecx
leaq 0x3d038(%rip), %rax # 0x6a3a0
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0x2d3a1
cmpl $0x1388, -0xc(%rbp) # imm = 0x1388
jb 0x2d39f
cmpl $0x1397, -0xc(%rbp) # imm = 0x1397
ja 0x2d39f
movl -0xc(%rbp), %eax
subl $0x1388, %eax # imm = 0x1388
movl %eax, %eax
movl %eax, %ecx
leaq 0x3d209(%rip), %rax # 0x6a5a0
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0x2d3a1
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x108(%rax)
movq -0x8(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
movq -0x18(%rbp), %rsi
movl $0x5, %edx
callq 0x39d40
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
movq -0x8(%rbp), %rax
addq $0x10c, %rax # imm = 0x10C
movq %rax, -0x108(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2d410
movq -0x20(%rbp), %rax
movq %rax, -0x110(%rbp)
jmp 0x2d442
cmpq $0x0, -0x48(%rbp)
je 0x2d424
movq -0x48(%rbp), %rax
movq %rax, -0x118(%rbp)
jmp 0x2d434
leaq 0x264b7(%rip), %rax # 0x538e2
movq %rax, -0x118(%rbp)
jmp 0x2d434
movq -0x118(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x108(%rbp), %rdi
movq -0x110(%rbp), %rdx
movl $0x200, %esi # imm = 0x200
leaq -0x40(%rbp), %rcx
callq 0x132a0
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
| stmt_set_error:
push rbp
mov rbp, rsp
sub rsp, 120h
test al, al
jz short loc_2D31E
movaps [rbp+var_D0], xmm0
movaps [rbp+var_C0], xmm1
movaps [rbp+var_B0], xmm2
movaps [rbp+var_A0], xmm3
movaps [rbp+var_90], xmm4
movaps [rbp+var_80], xmm5
movaps [rbp+var_70], xmm6
movaps [rbp+var_60], xmm7
loc_2D31E:
mov [rbp+var_D8], r9
mov [rbp+var_E0], r8
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_48], 0
cmp [rbp+var_C], 7D0h
jb short loc_2D372
cmp [rbp+var_C], 80Dh
ja short loc_2D372
mov eax, [rbp+var_C]
sub eax, 7D0h
mov eax, eax
mov ecx, eax
lea rax, client_errors
mov rax, [rax+rcx*8]
mov [rbp+var_48], rax
jmp short loc_2D3A1
loc_2D372:
cmp [rbp+var_C], 1388h
jb short loc_2D39F
cmp [rbp+var_C], 1397h
ja short loc_2D39F
mov eax, [rbp+var_C]
sub eax, 1388h
mov eax, eax
mov ecx, eax
lea rax, mariadb_client_errors
mov rax, [rax+rcx*8]
mov [rbp+var_48], rax
loc_2D39F:
jmp short $+2
loc_2D3A1:
mov ecx, [rbp+var_C]
mov rax, [rbp+var_8]
mov [rax+108h], ecx
mov rdi, [rbp+var_8]
add rdi, 30Dh
mov rsi, [rbp+var_18]
mov edx, 5
call ma_strmake
lea rax, [rbp+var_40]
lea rcx, [rbp+var_100]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 20h ; ' '
mov rax, [rbp+var_8]
add rax, 10Ch
mov [rbp+var_108], rax
cmp [rbp+var_20], 0
jz short loc_2D410
mov rax, [rbp+var_20]
mov [rbp+var_110], rax
jmp short loc_2D442
loc_2D410:
cmp [rbp+var_48], 0
jz short loc_2D424
mov rax, [rbp+var_48]
mov [rbp+var_118], rax
jmp short loc_2D434
loc_2D424:
lea rax, aExecuteTestWit+29h; ""
mov [rbp+var_118], rax
jmp short $+2
loc_2D434:
mov rax, [rbp+var_118]
mov [rbp+var_110], rax
loc_2D442:
mov rdi, [rbp+var_108]
mov rdx, [rbp+var_110]
mov esi, 200h
lea rcx, [rbp+var_40]
call _vsnprintf
add rsp, 120h
pop rbp
retn
| long long stmt_set_error(long long a1, unsigned int a2, long long a3, long long a4, ...)
{
char *v5; // [rsp+8h] [rbp-118h]
long long v6; // [rsp+18h] [rbp-108h]
char *v7; // [rsp+D8h] [rbp-48h]
va_list va; // [rsp+E0h] [rbp-40h] BYREF
long long v9; // [rsp+100h] [rbp-20h]
long long v10; // [rsp+108h] [rbp-18h]
unsigned int v11; // [rsp+114h] [rbp-Ch]
long long v12; // [rsp+118h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v7 = 0LL;
if ( a2 < 0x7D0 || v11 > 0x80D )
{
if ( v11 >= 0x1388 && v11 <= 0x1397 )
v7 = mariadb_client_errors[v11 - 5000];
}
else
{
v7 = client_errors[v11 - 2000];
}
*(_DWORD *)(v12 + 264) = v11;
ma_strmake(v12 + 781, v10, 5LL);
va_start(va, a4);
v6 = v12 + 268;
if ( v9 )
return vsnprintf(v6, 512LL, v9, va);
if ( v7 )
v5 = v7;
else
v5 = "";
return vsnprintf(v6, 512LL, v5, va);
}
| stmt_set_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x120
TEST AL,AL
JZ 0x0012d31e
MOVAPS xmmword ptr [RBP + -0xd0],XMM0
MOVAPS xmmword ptr [RBP + -0xc0],XMM1
MOVAPS xmmword ptr [RBP + -0xb0],XMM2
MOVAPS xmmword ptr [RBP + -0xa0],XMM3
MOVAPS xmmword ptr [RBP + -0x90],XMM4
MOVAPS xmmword ptr [RBP + -0x80],XMM5
MOVAPS xmmword ptr [RBP + -0x70],XMM6
MOVAPS xmmword ptr [RBP + -0x60],XMM7
LAB_0012d31e:
MOV qword ptr [RBP + -0xd8],R9
MOV qword ptr [RBP + -0xe0],R8
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x48],0x0
CMP dword ptr [RBP + -0xc],0x7d0
JC 0x0012d372
CMP dword ptr [RBP + -0xc],0x80d
JA 0x0012d372
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x7d0
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x16a3a0]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0012d3a1
LAB_0012d372:
CMP dword ptr [RBP + -0xc],0x1388
JC 0x0012d39f
CMP dword ptr [RBP + -0xc],0x1397
JA 0x0012d39f
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1388
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x16a5a0]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x48],RAX
LAB_0012d39f:
JMP 0x0012d3a1
LAB_0012d3a1:
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x108],ECX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x30d
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x5
CALL 0x00139d40
LEA RAX,[RBP + -0x40]
LEA RCX,[RBP + -0x100]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x20
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x10c
MOV qword ptr [RBP + -0x108],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0012d410
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x110],RAX
JMP 0x0012d442
LAB_0012d410:
CMP qword ptr [RBP + -0x48],0x0
JZ 0x0012d424
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x118],RAX
JMP 0x0012d434
LAB_0012d424:
LEA RAX,[0x1538e2]
MOV qword ptr [RBP + -0x118],RAX
JMP 0x0012d434
LAB_0012d434:
MOV RAX,qword ptr [RBP + -0x118]
MOV qword ptr [RBP + -0x110],RAX
LAB_0012d442:
MOV RDI,qword ptr [RBP + -0x108]
MOV RDX,qword ptr [RBP + -0x110]
MOV ESI,0x200
LEA RCX,[RBP + -0x40]
CALL 0x001132a0
ADD RSP,0x120
POP RBP
RET
|
void stmt_set_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
long param_9,uint param_10,int8 param_11,char *param_12,int8 param_13
,int8 param_14)
{
char in_AL;
char *local_120;
char *local_118;
int1 local_108 [32];
int8 local_e8;
int8 local_e0;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
char *local_50;
int4 local_48;
int4 local_44;
int1 *local_40;
int1 *local_38;
char *local_28;
int8 local_20;
uint local_14;
long local_10;
if (in_AL != '\0') {
local_d8 = param_1;
local_c8 = param_2;
local_b8 = param_3;
local_a8 = param_4;
local_98 = param_5;
local_88 = param_6;
local_78 = param_7;
local_68 = param_8;
}
local_50 = (char *)0x0;
if ((param_10 < 2000) || (0x80d < param_10)) {
if ((4999 < param_10) && (param_10 < 0x1398)) {
local_50 = *(char **)(mariadb_client_errors + (ulong)(param_10 - 5000) * 8);
}
}
else {
local_50 = (&client_errors)[param_10 - 2000];
}
*(uint *)(param_9 + 0x108) = param_10;
local_e8 = param_13;
local_e0 = param_14;
local_28 = param_12;
local_20 = param_11;
local_14 = param_10;
local_10 = param_9;
ma_strmake(param_9 + 0x30d,param_11,5);
local_38 = local_108;
local_40 = &stack0x00000008;
local_44 = 0x30;
local_48 = 0x20;
if (local_28 == (char *)0x0) {
if (local_50 == (char *)0x0) {
local_120 = "";
}
else {
local_120 = local_50;
}
local_118 = local_120;
}
else {
local_118 = local_28;
}
vsnprintf((char *)(local_10 + 0x10c),0x200,local_118,&local_48);
return;
}
|
|
3,217 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at(unsigned long) | monkey531[P]llama/common/json.hpp | reference at(size_type idx)
{
// at only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
JSON_TRY
{
return set_parent(m_data.m_value.array->at(idx));
}
JSON_CATCH (std::out_of_range&)
{
// create better exception explanation
JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
}
} | O2 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at(unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpb $0x2, (%rdi)
jne 0x893db
movq %rsi, %r12
movq 0x8(%rbx), %rdi
callq 0x896a4
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x24470
movq %rax, %r14
movq %rbx, %rdi
callq 0x4efc4
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x37c17(%rip), %rsi # 0xc1014
movq %rsp, %rdi
callq 0x89735
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0x130, %esi # imm = 0x130
movq %rbx, %rcx
callq 0x4ee78
xorl %ebp, %ebp
leaq 0x80b24(%rip), %rsi # 0x109f48
leaq -0x3d8d7(%rip), %rdx # 0x4bb54
movq %r14, %rdi
callq 0x24f80
jmp 0x894aa
movq %rax, %r15
cmpl $0x1, %edx
jne 0x89505
movq %r15, %rdi
callq 0x24390
pushq $0x20
popq %rdi
callq 0x24470
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x4d86f
leaq 0x37b8e(%rip), %rsi # 0xc0ff6
leaq 0x37b94(%rip), %rcx # 0xc1003
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x896c5
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0x191, %esi # imm = 0x191
movq %rbx, %rcx
callq 0x4d724
xorl %ebp, %ebp
leaq 0x80a2d(%rip), %rsi # 0x109ec8
leaq -0x3d94e(%rip), %rdx # 0x4bb54
movq %r14, %rdi
callq 0x24f80
movq %rax, %r15
movq %rsp, %rdi
callq 0x25298
jmp 0x894bd
movq %rax, %r15
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x25298
testb %bpl, %bpl
jne 0x894d1
jmp 0x894d9
movq %rax, %r15
movq %r14, %rdi
callq 0x246a0
callq 0x24eb0
jmp 0x89505
movq %rax, %rdi
callq 0x30d89
movq %rax, %r15
movq %rsp, %rdi
callq 0x25298
testb %bpl, %bpl
jne 0x894fd
jmp 0x89505
movq %rax, %r15
movq %r14, %rdi
callq 0x246a0
movq %r15, %rdi
callq 0x25010
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atEm:
push rbp; char
push r15; int
push r14; int
push r12; int
push rbx; char
sub rsp, 40h
mov rbx, rdi
cmp byte ptr [rdi], 2
jnz short loc_893DB
mov r12, rsi
mov rdi, [rbx+8]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE2atEm; 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>>::at(ulong)
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_893DB:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+68h+var_48]
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, r14; this
mov esi, 130h; int
mov rcx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
| 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>::at(
long long a1)
{
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // r14
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v3[4] = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(v3, "cannot use at() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
304,
(long long)v3);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return std::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>>::at(*(_QWORD *)(a1 + 8));
}
| at:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
CMP byte ptr [RDI],0x2
JNZ 0x001893db
MOV R12,RSI
MOV RDI,qword ptr [RBX + 0x8]
LAB_001893c9:
CALL 0x001896a4
LAB_001893ce:
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001893db:
PUSH 0x20
POP RDI
CALL 0x00124470
MOV R14,RAX
MOV RDI,RBX
CALL 0x0014efc4
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_001893f6:
LEA RSI,[0x1c1014]
MOV RDI,RSP
CALL 0x00189735
MOV BPL,0x1
LAB_00189408:
MOV RDX,RSP
MOV RDI,R14
MOV ESI,0x130
MOV RCX,RBX
CALL 0x0014ee78
XOR EBP,EBP
LEA RSI,[0x209f48]
LEA RDX,[0x14bb54]
MOV RDI,R14
CALL 0x00124f80
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::at(unsigned long) */
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>
::at(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,ulong param_1)
{
int8 uVar1;
detail adStack_68 [32];
char *local_48 [4];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
/* try { // try from 001893c9 to 001893cd has its CatchHandler @ 00189435 */
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>>>
::at(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8),param_1);
return;
}
uVar1 = __cxa_allocate_exception(0x20);
local_48[0] = (char *)type_name(this);
/* try { // try from 001893f6 to 00189404 has its CatchHandler @ 001894fa */
detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(adStack_68,"cannot use at() with ",local_48);
/* try { // try from 00189408 to 00189432 has its CatchHandler @ 001894e8 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x130,adStack_68,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
|
|
3,218 | maria_rtree_get_first | eloqsql/storage/maria/ma_rt_index.c | int maria_rtree_get_first(MARIA_HA *info, uint keynr, uint key_length)
{
my_off_t root;
MARIA_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->maria_rtree_recursion_depth= -1;
info->keyread_buff_used= 1;
return maria_rtree_get_req(info, keyinfo, key_length, root, 0);
} | O3 | c | maria_rtree_get_first:
movq (%rdi), %rax
movl %esi, %ecx
movq 0x118(%rax), %rdx
movq (%rdx,%rcx,8), %rdx
cmpq $-0x1, %rdx
je 0x6b34f
imulq $0x118, %rcx, %rsi # imm = 0x118
addq 0x570(%rax), %rsi
movl $0xffffffff, 0x6f0(%rdi) # imm = 0xFFFFFFFF
movb $0x1, 0x685(%rdi)
xorl %ecx, %ecx
jmp 0x6b365
pushq %rbp
movq %rsp, %rbp
callq 0xa1b22
movl $0x89, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbp
retq
| maria_rtree_get_first:
mov rax, [rdi]
mov ecx, esi
mov rdx, [rax+118h]
mov rdx, [rdx+rcx*8]
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz short loc_6B34F
imul rsi, rcx, 118h
add rsi, [rax+570h]
mov dword ptr [rdi+6F0h], 0FFFFFFFFh
mov byte ptr [rdi+685h], 1
xor ecx, ecx
jmp short maria_rtree_get_req
loc_6B34F:
push rbp
mov rbp, rsp
call _my_thread_var
mov dword ptr [rax], 89h
mov eax, 0FFFFFFFFh
pop rbp
retn
| long long maria_rtree_get_first(long long a1, const char *a2)
{
long long v2; // rdx
long long v3; // rsi
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 280LL) + 8LL * (unsigned int)a2);
if ( v2 == -1 )
{
*(_DWORD *)my_thread_var(a1, a2) = 137;
return 0xFFFFFFFFLL;
}
else
{
v3 = *(_QWORD *)(*(_QWORD *)a1 + 1392LL) + 280LL * (unsigned int)a2;
*(_DWORD *)(a1 + 1776) = -1;
*(_BYTE *)(a1 + 1669) = 1;
return maria_rtree_get_req(a1, v3, v2, 0LL);
}
}
| maria_rtree_get_first:
MOV RAX,qword ptr [RDI]
MOV ECX,ESI
MOV RDX,qword ptr [RAX + 0x118]
MOV RDX,qword ptr [RDX + RCX*0x8]
CMP RDX,-0x1
JZ 0x0016b34f
IMUL RSI,RCX,0x118
ADD RSI,qword ptr [RAX + 0x570]
MOV dword ptr [RDI + 0x6f0],0xffffffff
MOV byte ptr [RDI + 0x685],0x1
XOR ECX,ECX
JMP 0x0016b365
LAB_0016b34f:
PUSH RBP
MOV RBP,RSP
CALL 0x001a1b22
MOV dword ptr [RAX],0x89
MOV EAX,0xffffffff
POP RBP
RET
|
int8 maria_rtree_get_first(long *param_1,ulong param_2)
{
long lVar1;
long lVar2;
int8 uVar3;
int4 *puVar4;
lVar1 = *(long *)(*(long *)(*param_1 + 0x118) + (param_2 & 0xffffffff) * 8);
if (lVar1 != -1) {
lVar2 = *(long *)(*param_1 + 0x570);
*(int4 *)(param_1 + 0xde) = 0xffffffff;
*(int1 *)((long)param_1 + 0x685) = 1;
uVar3 = maria_rtree_get_req(param_1,(param_2 & 0xffffffff) * 0x118 + lVar2,lVar1,0);
return uVar3;
}
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x89;
return 0xffffffff;
}
|
|
3,219 | sp_get_polygon_mbr | eloqsql/storage/maria/ma_sp_key.c | static int sp_get_polygon_mbr(uchar *(*wkb), uchar *end, uint n_dims,
uchar byte_order, double *mbr)
{
uint n_linear_rings;
uint n_points;
n_linear_rings = uint4korr((*wkb));
(*wkb) += 4;
for (; n_linear_rings > 0; --n_linear_rings)
{
n_points = uint4korr((*wkb));
(*wkb) += 4;
for (; n_points > 0; --n_points)
{
/* Add next point to mbr */
if (sp_add_point_to_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
}
return 0;
} | O3 | c | sp_get_polygon_mbr:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movl (%rcx), %eax
addq $0x4, %rcx
movq %rcx, (%rdi)
testl %eax, %eax
je 0x72470
addq $-0x8, %rsi
movq (%rdi), %r8
movl (%r8), %ecx
addq $0x4, %r8
movq %r8, (%rdi)
testl %ecx, %ecx
je 0x7246c
movb $0x1, %r8b
xorl %r9d, %r9d
movq (%rdi), %r10
cmpq %rsi, %r10
ja 0x72474
movsd (%r10), %xmm0
addq $0x8, %r10
movq %r10, (%rdi)
movsd (%rdx,%r9), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x72443
movsd %xmm0, (%rdx,%r9)
ucomisd 0x8(%rdx,%r9), %xmm0
jbe 0x72456
orq $0x8, %r9
movsd %xmm0, (%rdx,%r9)
movl $0x10, %r9d
testb $0x1, %r8b
movl $0x0, %r8d
jne 0x7241d
decl %ecx
jne 0x72417
decl %eax
jne 0x72406
xorl %eax, %eax
jmp 0x72479
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbp
retq
nop
| sp_get_polygon_mbr:
push rbp
mov rbp, rsp
mov rcx, [rdi]
mov eax, [rcx]
add rcx, 4
mov [rdi], rcx
test eax, eax
jz short loc_72470
add rsi, 0FFFFFFFFFFFFFFF8h
loc_72406:
mov r8, [rdi]
mov ecx, [r8]
add r8, 4
mov [rdi], r8
test ecx, ecx
jz short loc_7246C
loc_72417:
mov r8b, 1
xor r9d, r9d
loc_7241D:
mov r10, [rdi]
cmp r10, rsi
ja short loc_72474
movsd xmm0, qword ptr [r10]
add r10, 8
mov [rdi], r10
movsd xmm1, qword ptr [rdx+r9]
ucomisd xmm1, xmm0
jbe short loc_72443
movsd qword ptr [rdx+r9], xmm0
loc_72443:
ucomisd xmm0, qword ptr [rdx+r9+8]
jbe short loc_72456
or r9, 8
movsd qword ptr [rdx+r9], xmm0
loc_72456:
mov r9d, 10h
test r8b, 1
mov r8d, 0
jnz short loc_7241D
dec ecx
jnz short loc_72417
loc_7246C:
dec eax
jnz short loc_72406
loc_72470:
xor eax, eax
jmp short loc_72479
loc_72474:
mov eax, 0FFFFFFFFh
loc_72479:
pop rbp
retn
| long long sp_get_polygon_mbr(double **a1, long long a2, long long a3)
{
int v3; // eax
unsigned long long v4; // rsi
int v5; // ecx
char v6; // r8
long long v7; // r9
double *v8; // r10
double v9; // xmm0_8
bool v10; // zf
v3 = *(_DWORD *)*a1;
*a1 = (double *)((char *)*a1 + 4);
if ( v3 )
{
v4 = a2 - 8;
do
{
v5 = *(_DWORD *)*a1;
*a1 = (double *)((char *)*a1 + 4);
if ( v5 )
{
while ( 2 )
{
v6 = 1;
v7 = 0LL;
do
{
v8 = *a1;
if ( (unsigned long long)*a1 > v4 )
return 0xFFFFFFFFLL;
v9 = *v8;
*a1 = v8 + 1;
if ( *(double *)(a3 + v7) > v9 )
*(double *)(a3 + v7) = v9;
if ( v9 > *(double *)(a3 + v7 + 8) )
*(double *)(a3 + (v7 | 8)) = v9;
v7 = 16LL;
v10 = (v6 & 1) == 0;
v6 = 0;
}
while ( !v10 );
if ( --v5 )
continue;
break;
}
}
--v3;
}
while ( v3 );
}
return 0LL;
}
| sp_get_polygon_mbr:
PUSH RBP
MOV RBP,RSP
MOV RCX,qword ptr [RDI]
MOV EAX,dword ptr [RCX]
ADD RCX,0x4
MOV qword ptr [RDI],RCX
TEST EAX,EAX
JZ 0x00172470
ADD RSI,-0x8
LAB_00172406:
MOV R8,qword ptr [RDI]
MOV ECX,dword ptr [R8]
ADD R8,0x4
MOV qword ptr [RDI],R8
TEST ECX,ECX
JZ 0x0017246c
LAB_00172417:
MOV R8B,0x1
XOR R9D,R9D
LAB_0017241d:
MOV R10,qword ptr [RDI]
CMP R10,RSI
JA 0x00172474
MOVSD XMM0,qword ptr [R10]
ADD R10,0x8
MOV qword ptr [RDI],R10
MOVSD XMM1,qword ptr [RDX + R9*0x1]
UCOMISD XMM1,XMM0
JBE 0x00172443
MOVSD qword ptr [RDX + R9*0x1],XMM0
LAB_00172443:
UCOMISD XMM0,qword ptr [RDX + R9*0x1 + 0x8]
JBE 0x00172456
OR R9,0x8
MOVSD qword ptr [RDX + R9*0x1],XMM0
LAB_00172456:
MOV R9D,0x10
TEST R8B,0x1
MOV R8D,0x0
JNZ 0x0017241d
DEC ECX
JNZ 0x00172417
LAB_0017246c:
DEC EAX
JNZ 0x00172406
LAB_00172470:
XOR EAX,EAX
JMP 0x00172479
LAB_00172474:
MOV EAX,0xffffffff
LAB_00172479:
POP RBP
RET
|
int8 sp_get_polygon_mbr(int8 *param_1,long param_2,long param_3)
{
double dVar1;
double *pdVar2;
bool bVar3;
int iVar4;
int iVar5;
bool bVar6;
ulong uVar7;
iVar4 = *(int *)*param_1;
*param_1 = (int *)*param_1 + 1;
if (iVar4 != 0) {
do {
iVar5 = *(int *)*param_1;
*param_1 = (int *)*param_1 + 1;
for (; iVar5 != 0; iVar5 = iVar5 + -1) {
uVar7 = 0;
bVar3 = true;
do {
bVar6 = bVar3;
pdVar2 = (double *)*param_1;
if ((double *)(param_2 + -8) < pdVar2) {
return 0xffffffff;
}
dVar1 = *pdVar2;
*param_1 = pdVar2 + 1;
if (dVar1 < *(double *)(param_3 + uVar7)) {
*(double *)(param_3 + uVar7) = dVar1;
}
pdVar2 = (double *)(param_3 + 8 + uVar7);
if (*pdVar2 <= dVar1 && dVar1 != *pdVar2) {
*(double *)(param_3 + (uVar7 | 8)) = dVar1;
}
uVar7 = 0x10;
bVar3 = false;
} while (bVar6);
}
iVar4 = iVar4 + -1;
} while (iVar4 != 0);
}
return 0;
}
|
|
3,220 | bitmap_copy | eloqsql/mysys/my_bitmap.c | void bitmap_copy(MY_BITMAP *map, const MY_BITMAP *map2)
{
my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end;
DBUG_ASSERT(map->bitmap);
DBUG_ASSERT(map2->bitmap);
DBUG_ASSERT(map->n_bits == map2->n_bits);
end= map->last_word_ptr;
while (to <= end)
*to++ = *from++;
} | O0 | c | bitmap_copy:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xf03a4
jmp 0xf03a6
jmp 0xf03a8
jmp 0xf03aa
jmp 0xf03ac
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0xf03e6
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x18(%rbp)
movl %ecx, (%rax)
jmp 0xf03b8
popq %rbp
retq
nopl (%rax,%rax)
| bitmap_copy:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
jmp short $+2
loc_F03A4:
jmp short $+2
loc_F03A6:
jmp short $+2
loc_F03A8:
jmp short $+2
loc_F03AA:
jmp short $+2
loc_F03AC:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_28], rax
loc_F03B8:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_28]
ja short loc_F03E6
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 4
mov [rbp+var_20], rcx
mov ecx, [rax]
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 4
mov [rbp+var_18], rdx
mov [rax], ecx
jmp short loc_F03B8
loc_F03E6:
pop rbp
retn
| _DWORD * bitmap_copy(_QWORD *a1, int **a2)
{
_DWORD *result; // rax
int *v3; // rax
int v4; // ecx
_DWORD *v5; // rax
unsigned long long v6; // [rsp+0h] [rbp-28h]
int *v7; // [rsp+8h] [rbp-20h]
_DWORD *v8; // [rsp+10h] [rbp-18h]
v8 = (_DWORD *)*a1;
v7 = *a2;
v6 = a1[1];
while ( 1 )
{
result = v8;
if ( (unsigned long long)v8 > v6 )
break;
v3 = v7++;
v4 = *v3;
v5 = v8++;
*v5 = v4;
}
return result;
}
| bitmap_copy:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001f03a4
LAB_001f03a4:
JMP 0x001f03a6
LAB_001f03a6:
JMP 0x001f03a8
LAB_001f03a8:
JMP 0x001f03aa
LAB_001f03aa:
JMP 0x001f03ac
LAB_001f03ac:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_001f03b8:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x28]
JA 0x001f03e6
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x20],RCX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RAX],ECX
JMP 0x001f03b8
LAB_001f03e6:
POP RBP
RET
|
void bitmap_copy(int8 *param_1,int8 *param_2)
{
int4 *puVar1;
int4 *local_28;
int4 *local_20;
puVar1 = (int4 *)param_1[1];
local_28 = (int4 *)*param_2;
local_20 = (int4 *)*param_1;
while (local_20 <= puVar1) {
*local_20 = *local_28;
local_28 = local_28 + 1;
local_20 = local_20 + 1;
}
return;
}
|
|
3,221 | ggml_backend_cpu_device_supports_buft(ggml_backend_device*, ggml_backend_buffer_type*) | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.cpp | static bool ggml_backend_cpu_device_supports_buft(ggml_backend_dev_t dev, ggml_backend_buffer_type_t buft) {
return ggml_backend_buft_is_host(buft) || ggml_backend_cpu_is_extra_buffer_type(buft);
GGML_UNUSED(dev);
} | O3 | cpp | ggml_backend_cpu_device_supports_buft(ggml_backend_device*, ggml_backend_buffer_type*):
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x8680
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x28a81
callq 0x8140
movq 0x64d25(%rip), %rdx # 0x8d770
movq 0x64d26(%rip), %rcx # 0x8d778
cmpq %rcx, %rdx
je 0x28a7f
addq $0x8, %rdx
movq -0x8(%rdx), %rax
testq %rax, %rax
setne %sil
cmpq %rbx, %rax
sete %al
andb %sil, %al
jne 0x28a81
leaq 0x8(%rdx), %rsi
cmpq %rcx, %rdx
movq %rsi, %rdx
jne 0x28a5b
jmp 0x28a81
xorl %eax, %eax
popq %rbx
retq
| _ZL37ggml_backend_cpu_device_supports_buftP19ggml_backend_deviceP24ggml_backend_buffer_type:
push rbx
mov rbx, rsi
mov rdi, rsi
call _ggml_backend_buft_is_host
mov ecx, eax
mov al, 1
test cl, cl
jnz short loc_28A81
call __Z39ggml_backend_cpu_get_extra_buffers_typev; ggml_backend_cpu_get_extra_buffers_type(void)
mov rdx, qword ptr cs:_ZZ39ggml_backend_cpu_get_extra_buffers_typevE5bufts; ggml_backend_cpu_get_extra_buffers_type(void)::bufts
mov rcx, qword ptr cs:_ZZ39ggml_backend_cpu_get_extra_buffers_typevE5bufts+8; ggml_backend_cpu_get_extra_buffers_type(void)::bufts
cmp rdx, rcx
jz short loc_28A7F
add rdx, 8
loc_28A5B:
mov rax, [rdx-8]
test rax, rax
setnz sil
cmp rax, rbx
setz al
and al, sil
jnz short loc_28A81
lea rsi, [rdx+8]
cmp rdx, rcx
mov rdx, rsi
jnz short loc_28A5B
jmp short loc_28A81
loc_28A7F:
xor eax, eax
loc_28A81:
pop rbx
retn
| bool ggml_backend_cpu_device_supports_buft(long long a1, long long a2)
{
char is_host; // cl
bool result; // al
char *v4; // rdx
bool v5; // zf
is_host = ggml_backend_buft_is_host(a2);
result = 1;
if ( !is_host )
{
ggml_backend_cpu_get_extra_buffers_type();
if ( ggml_backend_cpu_get_extra_buffers_type(void)::bufts == *(&ggml_backend_cpu_get_extra_buffers_type(void)::bufts
+ 1) )
{
return 0;
}
else
{
v4 = (char *)ggml_backend_cpu_get_extra_buffers_type(void)::bufts + 8;
do
{
result = *((_QWORD *)v4 - 1) != 0LL && *((_QWORD *)v4 - 1) == a2;
if ( result )
break;
v5 = v4 == *(&ggml_backend_cpu_get_extra_buffers_type(void)::bufts + 1);
v4 += 8;
}
while ( !v5 );
}
}
return result;
}
| ggml_backend_cpu_device_supports_buft:
PUSH RBX
MOV RBX,RSI
MOV RDI,RSI
CALL 0x00108680
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x00128a81
CALL 0x00108140
MOV RDX,qword ptr [0x0018d770]
MOV RCX,qword ptr [0x0018d778]
CMP RDX,RCX
JZ 0x00128a7f
ADD RDX,0x8
LAB_00128a5b:
MOV RAX,qword ptr [RDX + -0x8]
TEST RAX,RAX
SETNZ SIL
CMP RAX,RBX
SETZ AL
AND AL,SIL
JNZ 0x00128a81
LEA RSI,[RDX + 0x8]
CMP RDX,RCX
MOV RDX,RSI
JNZ 0x00128a5b
JMP 0x00128a81
LAB_00128a7f:
XOR EAX,EAX
LAB_00128a81:
POP RBX
RET
|
/* ggml_backend_cpu_device_supports_buft(ggml_backend_device*, ggml_backend_buffer_type*) */
bool ggml_backend_cpu_device_supports_buft
(ggml_backend_device *param_1,ggml_backend_buffer_type *param_2)
{
char cVar1;
bool bVar2;
long *plVar3;
long *plVar4;
cVar1 = ggml_backend_buft_is_host(param_2);
bVar2 = true;
if (cVar1 == '\0') {
ggml_backend_cpu_get_extra_buffers_type();
plVar4 = ggml_backend_cpu_get_extra_buffers_type()::bufts;
if (ggml_backend_cpu_get_extra_buffers_type()::bufts == DAT_0018d778) {
bVar2 = false;
}
else {
do {
plVar3 = plVar4 + 1;
bVar2 = (ggml_backend_buffer_type *)*plVar4 == param_2 &&
(ggml_backend_buffer_type *)*plVar4 != (ggml_backend_buffer_type *)0x0;
if (bVar2) {
return bVar2;
}
plVar4 = plVar3;
} while (plVar3 != DAT_0018d778);
}
}
return bVar2;
}
|
|
3,222 | HUDButton::checkState() | GhostEscape/src/screen/hud_button.cpp | void HUDButton::checkState()
{
if (!is_press_ && !is_hover_){
sprite_normal_->setActive(true);
sprite_hover_->setActive(false);
sprite_press_->setActive(false);
}else if (!is_press_ && is_hover_){
sprite_normal_->setActive(false);
sprite_hover_->setActive(true);
sprite_press_->setActive(false);
}else {
sprite_normal_->setActive(false);
sprite_hover_->setActive(false);
sprite_press_->setActive(true);
}
} | O0 | cpp | HUDButton::checkState():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x71(%rax)
jne 0x174e6
movq -0x10(%rbp), %rax
testb $0x1, 0x70(%rax)
jne 0x174e6
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
movl $0x1, %esi
callq 0x15be0
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
xorl %esi, %esi
callq 0x15be0
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
xorl %esi, %esi
callq 0x15be0
jmp 0x1755e
movq -0x10(%rbp), %rax
testb $0x1, 0x71(%rax)
jne 0x1752c
movq -0x10(%rbp), %rax
testb $0x1, 0x70(%rax)
je 0x1752c
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
xorl %esi, %esi
callq 0x15be0
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movl $0x1, %esi
callq 0x15be0
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
xorl %esi, %esi
callq 0x15be0
jmp 0x1755c
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
xorl %esi, %esi
callq 0x15be0
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
xorl %esi, %esi
callq 0x15be0
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movl $0x1, %esi
callq 0x15be0
jmp 0x1755e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN9HUDButton10checkStateEv:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
test byte ptr [rax+71h], 1
jnz short loc_174E6
mov rax, [rbp+var_10]
test byte ptr [rax+70h], 1
jnz short loc_174E6
mov rax, [rbp+var_10]
mov rdi, [rax+58h]; this
mov esi, 1; bool
call _ZN6Object9setActiveEb; Object::setActive(bool)
mov rax, [rbp+var_10]
mov rdi, [rax+60h]; this
xor esi, esi; bool
call _ZN6Object9setActiveEb; Object::setActive(bool)
mov rax, [rbp+var_10]
mov rdi, [rax+68h]; this
xor esi, esi; bool
call _ZN6Object9setActiveEb; Object::setActive(bool)
jmp short loc_1755E
loc_174E6:
mov rax, [rbp+var_10]
test byte ptr [rax+71h], 1
jnz short loc_1752C
mov rax, [rbp+var_10]
test byte ptr [rax+70h], 1
jz short loc_1752C
mov rax, [rbp+var_10]
mov rdi, [rax+58h]; this
xor esi, esi; bool
call _ZN6Object9setActiveEb; Object::setActive(bool)
mov rax, [rbp+var_10]
mov rdi, [rax+60h]; this
mov esi, 1; bool
call _ZN6Object9setActiveEb; Object::setActive(bool)
mov rax, [rbp+var_10]
mov rdi, [rax+68h]; this
xor esi, esi; bool
call _ZN6Object9setActiveEb; Object::setActive(bool)
jmp short loc_1755C
loc_1752C:
mov rax, [rbp+var_10]
mov rdi, [rax+58h]; this
xor esi, esi; bool
call _ZN6Object9setActiveEb; Object::setActive(bool)
mov rax, [rbp+var_10]
mov rdi, [rax+60h]; this
xor esi, esi; bool
call _ZN6Object9setActiveEb; Object::setActive(bool)
mov rax, [rbp+var_10]
mov rdi, [rax+68h]; this
mov esi, 1; bool
call _ZN6Object9setActiveEb; Object::setActive(bool)
loc_1755C:
jmp short $+2
loc_1755E:
add rsp, 10h
pop rbp
retn
| Object * HUDButton::checkState(Object **this)
{
if ( (*((_BYTE *)this + 113) & 1) != 0 || ((_BYTE)this[14] & 1) != 0 )
{
if ( (*((_BYTE *)this + 113) & 1) != 0 || ((_BYTE)this[14] & 1) == 0 )
{
Object::setActive(this[11], 0);
Object::setActive(this[12], 0);
return Object::setActive(this[13], 1);
}
else
{
Object::setActive(this[11], 0);
Object::setActive(this[12], 1);
return Object::setActive(this[13], 0);
}
}
else
{
Object::setActive(this[11], 1);
Object::setActive(this[12], 0);
return Object::setActive(this[13], 0);
}
}
| checkState:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
TEST byte ptr [RAX + 0x71],0x1
JNZ 0x001174e6
MOV RAX,qword ptr [RBP + -0x10]
TEST byte ptr [RAX + 0x70],0x1
JNZ 0x001174e6
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x58]
MOV ESI,0x1
CALL 0x00115be0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x60]
XOR ESI,ESI
CALL 0x00115be0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x68]
XOR ESI,ESI
CALL 0x00115be0
JMP 0x0011755e
LAB_001174e6:
MOV RAX,qword ptr [RBP + -0x10]
TEST byte ptr [RAX + 0x71],0x1
JNZ 0x0011752c
MOV RAX,qword ptr [RBP + -0x10]
TEST byte ptr [RAX + 0x70],0x1
JZ 0x0011752c
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x58]
XOR ESI,ESI
CALL 0x00115be0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x60]
MOV ESI,0x1
CALL 0x00115be0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x68]
XOR ESI,ESI
CALL 0x00115be0
JMP 0x0011755c
LAB_0011752c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x58]
XOR ESI,ESI
CALL 0x00115be0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x60]
XOR ESI,ESI
CALL 0x00115be0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x68]
MOV ESI,0x1
CALL 0x00115be0
LAB_0011755c:
JMP 0x0011755e
LAB_0011755e:
ADD RSP,0x10
POP RBP
RET
|
/* HUDButton::checkState() */
void __thiscall HUDButton::checkState(HUDButton *this)
{
if ((((byte)this[0x71] & 1) == 0) && (((byte)this[0x70] & 1) == 0)) {
Object::setActive(*(Object **)(this + 0x58),true);
Object::setActive(*(Object **)(this + 0x60),false);
Object::setActive(*(Object **)(this + 0x68),false);
}
else if ((((byte)this[0x71] & 1) == 0) && (((byte)this[0x70] & 1) != 0)) {
Object::setActive(*(Object **)(this + 0x58),false);
Object::setActive(*(Object **)(this + 0x60),true);
Object::setActive(*(Object **)(this + 0x68),false);
}
else {
Object::setActive(*(Object **)(this + 0x58),false);
Object::setActive(*(Object **)(this + 0x60),false);
Object::setActive(*(Object **)(this + 0x68),true);
}
return;
}
|
|
3,223 | get_options | eloqsql/storage/myisam/mi_test3.c | static void get_options(int argc, char **argv)
{
char *pos,*progname;
progname= argv[0];
while (--argc >0 && *(pos = *(++argv)) == '-' ) {
switch(*++pos) {
case 'l':
use_log=1;
break;
case 'f':
forks=atoi(++pos);
break;
case 't':
tests=atoi(++pos);
break;
case 'K': /* Use key cacheing */
key_cacheing=1;
break;
case 'A': /* All flags */
use_log=key_cacheing=1;
break;
case '?':
case 'I':
case 'V':
printf("%s Ver 1.0 for %s at %s\n",progname,SYSTEM_TYPE,MACHINE_TYPE);
puts("By Monty, for your professional use\n");
puts("Test av locking with threads\n");
printf("Usage: %s [-?lKA] [-f#] [-t#]\n",progname);
exit(0);
case '#':
DBUG_PUSH (++pos);
break;
default:
printf("Illegal option: '%c'\n",*pos);
break;
}
}
return;
} | O0 | c | get_options:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jle 0x28b70
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x28b7c
jmp 0x28c91
movq -0x18(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x18(%rbp)
movsbl 0x1(%rax), %eax
addl $-0x23, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x51, %eax
ja 0x28c77
movq -0x30(%rbp), %rax
leaq 0xaf46d(%rip), %rcx # 0xd8018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, 0x3c729a(%rip) # 0x3efe58
jmp 0x28c8c
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movq %rdi, -0x18(%rbp)
callq 0x285c0
movl %eax, 0x20e442(%rip) # 0x23701c
jmp 0x28c8c
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movq %rdi, -0x18(%rbp)
callq 0x285c0
movl %eax, 0x20e422(%rip) # 0x237018
jmp 0x28c8c
movl $0x1, 0x3c724f(%rip) # 0x3efe54
jmp 0x28c8c
movl $0x1, 0x3c7240(%rip) # 0x3efe54
movl $0x1, 0x3c723a(%rip) # 0x3efe58
jmp 0x28c8c
movq -0x20(%rbp), %rsi
leaq 0xaf831(%rip), %rdi # 0xd845c
leaq 0xaf844(%rip), %rdx # 0xd8476
leaq 0xaf843(%rip), %rcx # 0xd847c
movb $0x0, %al
callq 0x28050
leaq 0xaf83c(%rip), %rdi # 0xd8483
callq 0x285a0
leaq 0xaf855(%rip), %rdi # 0xd84a8
callq 0x285a0
movq -0x20(%rbp), %rsi
leaq 0xaf863(%rip), %rdi # 0xd84c6
movb $0x0, %al
callq 0x28050
xorl %edi, %edi
callq 0x28450
jmp 0x28c73
jmp 0x28c75
jmp 0x28c8c
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
leaq 0xaf860(%rip), %rdi # 0xd84e5
movb $0x0, %al
callq 0x28050
jmp 0x28b3a
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| get_options:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
loc_28B3A:
mov ecx, [rbp+var_4]
add ecx, 0FFFFFFFFh
mov [rbp+var_4], ecx
xor eax, eax
cmp ecx, 0
mov [rbp+var_21], al
jle short loc_28B70
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 8
mov [rbp+var_10], rcx
mov rax, [rax+8]
mov [rbp+var_18], rax
movsx eax, byte ptr [rax]
cmp eax, 2Dh ; '-'
setz al
mov [rbp+var_21], al
loc_28B70:
mov al, [rbp+var_21]
test al, 1
jnz short loc_28B7C
jmp loc_28C91
loc_28B7C:
mov rax, [rbp+var_18]
mov rcx, rax
inc rcx
mov [rbp+var_18], rcx
movsx eax, byte ptr [rax+1]
add eax, 0FFFFFFDDh; switch 82 cases
mov ecx, eax
mov [rbp+var_30], rcx
sub eax, 51h
ja def_28BB2; jumptable 0000000000028BB2 default case, cases 36-62,64,66-72,74,76-85,87-101,103-107,109-115
mov rax, [rbp+var_30]
lea rcx, jpt_28BB2
movsxd rax, ds:(jpt_28BB2 - 0D8018h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_28BB4:
mov cs:use_log, 1; jumptable 0000000000028BB2 case 108
jmp loc_28C8C
loc_28BC3:
mov rdi, [rbp+var_18]; jumptable 0000000000028BB2 case 102
add rdi, 1
mov [rbp+var_18], rdi
call _atoi
mov cs:forks, eax
jmp loc_28C8C
loc_28BDF:
mov rdi, [rbp+var_18]; jumptable 0000000000028BB2 case 116
add rdi, 1
mov [rbp+var_18], rdi
call _atoi
mov cs:tests, eax
jmp loc_28C8C
loc_28BFB:
mov cs:key_cacheing, 1; jumptable 0000000000028BB2 case 75
jmp loc_28C8C
loc_28C0A:
mov cs:key_cacheing, 1; jumptable 0000000000028BB2 case 65
mov cs:use_log, 1
jmp short loc_28C8C
loc_28C20:
mov rsi, [rbp+var_20]; jumptable 0000000000028BB2 cases 63,73,86
lea rdi, aSVer10ForSAtS; "%s Ver 1.0 for %s at %s\n"
lea rdx, aLinux; "Linux"
lea rcx, aX8664; "x86_64"
mov al, 0
call _printf
lea rdi, aByMontyForYour; "By Monty, for your professional use\n"
call _puts
lea rdi, aTestAvLockingW; "Test av locking with threads\n"
call _puts
mov rsi, [rbp+var_20]
lea rdi, aUsageSLkaFT; "Usage: %s [-?lKA] [-f#] [-t#]\n"
mov al, 0
call _printf
xor edi, edi
call _exit
loc_28C71:
jmp short $+2; jumptable 0000000000028BB2 case 35
loc_28C73:
jmp short $+2
loc_28C75:
jmp short loc_28C8C
def_28BB2:
mov rax, [rbp+var_18]; jumptable 0000000000028BB2 default case, cases 36-62,64,66-72,74,76-85,87-101,103-107,109-115
movsx esi, byte ptr [rax]
lea rdi, aIllegalOptionC; "Illegal option: '%c'\n"
mov al, 0
call _printf
loc_28C8C:
jmp loc_28B3A
loc_28C91:
add rsp, 30h
pop rbp
retn
| bool get_options(int a1, const char **a2)
{
const char **v2; // rax
bool result; // al
const char *v4; // rax
bool v5; // [rsp+Fh] [rbp-21h]
const char *v6; // [rsp+10h] [rbp-20h]
const char *v7; // [rsp+18h] [rbp-18h]
const char **v8; // [rsp+20h] [rbp-10h]
v8 = a2;
v6 = *a2;
while ( 1 )
{
--a1;
v5 = 0;
if ( a1 > 0 )
{
v2 = v8++;
v7 = v2[1];
v5 = *v7 == 45;
}
result = v5;
if ( !v5 )
return result;
v4 = v7++;
switch ( v4[1] )
{
case '#':
continue;
case '?':
case 'I':
case 'V':
printf("%s Ver 1.0 for %s at %s\n", v6, "Linux", "x86_64");
puts("By Monty, for your professional use\n");
puts("Test av locking with threads\n");
printf("Usage: %s [-?lKA] [-f#] [-t#]\n", v6);
exit(0LL);
case 'A':
key_cacheing = 1;
use_log = 1;
break;
case 'K':
key_cacheing = 1;
break;
case 'f':
forks = atoi(++v7);
break;
case 'l':
use_log = 1;
break;
case 't':
tests = atoi(++v7);
break;
default:
printf("Illegal option: '%c'\n", (unsigned int)*v7);
break;
}
}
}
| get_options:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
LAB_00128b3a:
MOV ECX,dword ptr [RBP + -0x4]
ADD ECX,-0x1
MOV dword ptr [RBP + -0x4],ECX
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x21],AL
JLE 0x00128b70
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x8
MOV qword ptr [RBP + -0x10],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2d
SETZ AL
MOV byte ptr [RBP + -0x21],AL
LAB_00128b70:
MOV AL,byte ptr [RBP + -0x21]
TEST AL,0x1
JNZ 0x00128b7c
JMP 0x00128c91
LAB_00128b7c:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
INC RCX
MOV qword ptr [RBP + -0x18],RCX
MOVSX EAX,byte ptr [RAX + 0x1]
ADD EAX,-0x23
MOV ECX,EAX
MOV qword ptr [RBP + -0x30],RCX
SUB EAX,0x51
JA 0x00128c77
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x1d8018]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_6c:
MOV dword ptr [0x004efe58],0x1
JMP 0x00128c8c
caseD_66:
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x1
MOV qword ptr [RBP + -0x18],RDI
CALL 0x001285c0
MOV dword ptr [0x0033701c],EAX
JMP 0x00128c8c
caseD_74:
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x1
MOV qword ptr [RBP + -0x18],RDI
CALL 0x001285c0
MOV dword ptr [0x00337018],EAX
JMP 0x00128c8c
caseD_4b:
MOV dword ptr [0x004efe54],0x1
JMP 0x00128c8c
caseD_41:
MOV dword ptr [0x004efe54],0x1
MOV dword ptr [0x004efe58],0x1
JMP 0x00128c8c
caseD_3f:
MOV RSI,qword ptr [RBP + -0x20]
LEA RDI,[0x1d845c]
LEA RDX,[0x1d8476]
LEA RCX,[0x1d847c]
MOV AL,0x0
CALL 0x00128050
LEA RDI,[0x1d8483]
CALL 0x001285a0
LEA RDI,[0x1d84a8]
CALL 0x001285a0
MOV RSI,qword ptr [RBP + -0x20]
LEA RDI,[0x1d84c6]
MOV AL,0x0
CALL 0x00128050
XOR EDI,EDI
CALL 0x00128450
caseD_23:
JMP 0x00128c73
LAB_00128c73:
JMP 0x00128c75
LAB_00128c75:
JMP 0x00128c8c
caseD_24:
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ESI,byte ptr [RAX]
LEA RDI,[0x1d84e5]
MOV AL,0x0
CALL 0x00128050
LAB_00128c8c:
JMP 0x00128b3a
LAB_00128c91:
ADD RSP,0x30
POP RBP
RET
|
void get_options(int param_1,int8 *param_2)
{
int8 uVar1;
char *pcVar2;
bool bVar3;
char *local_20;
int8 *local_18;
int local_c;
uVar1 = *param_2;
local_18 = param_2;
local_c = param_1;
while( true ) {
local_c = local_c + -1;
bVar3 = false;
if (0 < local_c) {
local_20 = (char *)local_18[1];
bVar3 = *local_20 == '-';
local_18 = local_18 + 1;
}
if (!bVar3) break;
pcVar2 = local_20 + 1;
switch(local_20[1]) {
case '#':
local_20 = pcVar2;
break;
default:
printf("Illegal option: \'%c\'\n",(ulong)(uint)(int)*pcVar2);
local_20 = pcVar2;
break;
case '?':
case 'I':
case 'V':
printf("%s Ver 1.0 for %s at %s\n",uVar1,"Linux","x86_64");
puts("By Monty, for your professional use\n");
puts("Test av locking with threads\n");
printf("Usage: %s [-?lKA] [-f#] [-t#]\n",uVar1);
/* WARNING: Subroutine does not return */
exit(0);
case 'A':
key_cacheing = 1;
use_log = 1;
local_20 = pcVar2;
break;
case 'K':
key_cacheing = 1;
local_20 = pcVar2;
break;
case 'f':
forks = atoi(local_20 + 2);
local_20 = local_20 + 2;
break;
case 'l':
use_log = 1;
local_20 = pcVar2;
break;
case 't':
tests = atoi(local_20 + 2);
local_20 = local_20 + 2;
}
}
return;
}
|
|
3,224 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>) | llama.cpp/common/json.hpp | basic_json& operator=(basic_json other) noexcept (
std::is_nothrow_move_constructible<value_t>::value&&
std::is_nothrow_move_assignable<value_t>::value&&
std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value&&
std::is_nothrow_move_assignable<json_base_class_t>::value
)
{
// check that passed value is valid
other.assert_invariant();
using std::swap;
swap(m_data.m_type, other.m_data.m_type);
swap(m_data.m_value, other.m_data.m_value);
json_base_class_t::operator=(std::move(other));
set_parents();
assert_invariant();
return *this;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x9524a
movb (%r14), %al
movb (%rbx), %cl
movb %cl, (%r14)
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x9524a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rdi, rsi
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 al, [r14]
mov cl, [rbx]
mov [r14], cl
mov [rbx], al
mov rax, [r14+8]
mov rcx, [rbx+8]
mov [r14+8], rcx
mov [rbx+8], rax
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 rax, r14
add rsp, 8
pop rbx
pop r14
retn
| 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>::operator=(
long long a1,
long long a2)
{
char v2; // al
long long v3; // rax
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 *)a2);
v2 = *(_BYTE *)a1;
*(_BYTE *)a1 = *(_BYTE *)a2;
*(_BYTE *)a2 = v2;
v3 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = *(_QWORD *)(a2 + 8);
*(_QWORD *)(a2 + 8) = v3;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
return a1;
}
| operator=:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,RSI
MOV ESI,0x1
CALL 0x0019524a
MOV AL,byte ptr [R14]
MOV CL,byte ptr [RBX]
MOV byte ptr [R14],CL
MOV byte ptr [RBX],AL
MOV RAX,qword ptr [R14 + 0x8]
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [R14 + 0x8],RCX
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x0019524a
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::TEMPNAMEPLACEHOLDERVALUE(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, 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<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>
::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,basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_2)
{
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
int8 uVar2;
assert_invariant(SUB81(param_2,0));
bVar1 = *this;
*this = *param_2;
*param_2 = bVar1;
uVar2 = *(int8 *)(this + 8);
*(int8 *)(this + 8) = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = uVar2;
assert_invariant(SUB81(this,0));
return this;
}
|
|
3,225 | ftxui::(anonymous namespace)::Split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/component/input.cpp | std::vector<std::string> Split(const std::string& input) {
std::vector<std::string> output;
std::stringstream ss(input);
std::string line;
while (std::getline(ss, line)) {
output.push_back(line);
}
if (input.back() == '\n') {
output.emplace_back("");
}
return output;
} | O2 | cpp | ftxui::(anonymous namespace)::Split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rdi
pushq $0x18
popq %rdx
callq 0xc740
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xc090
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x259f4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x260ee
jmp 0x259ce
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpb $0xa, -0x1(%rax,%rcx)
jne 0x25a11
leaq 0xd1d8(%rip), %rsi # 0x32be1
movq %rbx, %rdi
callq 0x2611a
movq %rsp, %rdi
callq 0xc8c8
leaq 0x20(%rsp), %rdi
callq 0xc360
movq %rbx, %rax
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x25a3c
movq %rax, %r14
jmp 0x25a51
movq %rax, %r14
movq %rsp, %rdi
callq 0xc8c8
leaq 0x20(%rsp), %rdi
callq 0xc360
movq %rbx, %rdi
callq 0x1010a
movq %r14, %rdi
callq 0xc7f0
nop
| _ZN5ftxui12_GLOBAL__N_15SplitERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r12
push rbx
sub rsp, 1A8h
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
and qword ptr [rdi+10h], 0
lea rdi, [rsp+1C8h+var_1A8]
push 18h
pop rdx
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(std::string const&,std::_Ios_Openmode)
lea rax, [rsp+1C8h+var_1B8]
mov [rax-10h], rax
and qword ptr [rax-8], 0
mov byte ptr [rax], 0
lea r15, [rsp+1C8h+var_1A8]
mov r12, rsp
loc_259CE:
mov rdi, r15
mov rsi, r12
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &)
mov rcx, [rax]
mov rcx, [rcx-18h]
test byte ptr [rax+rcx+20h], 5
jnz short loc_259F4
mov rdi, rbx
mov rsi, r12
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
jmp short loc_259CE
loc_259F4:
mov rax, [r14]
mov rcx, [r14+8]
cmp byte ptr [rax+rcx-1], 0Ah
jnz short loc_25A11
lea rsi, asc_32BDF+2; ""
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJRA1_KcEEERS5_DpOT_; std::vector<std::string>::emplace_back<char const(&)[1]>(char const(&)[1] &&)
loc_25A11:
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+1C8h+var_1A8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rax, rbx
add rsp, 1A8h
pop rbx
pop r12
pop r14
pop r15
retn
jmp short loc_25A3C
mov r14, rax
jmp short loc_25A51
loc_25A3C:
mov r14, rax
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+arg_18]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
loc_25A51:
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __Unwind_Resume
| long long ftxui::`anonymous namespace'::Split(long long a1, _QWORD *a2)
{
_QWORD *v2; // rax
long long v3; // rdx
long long v4; // r8
long long v5; // r9
long long v6; // rcx
int *v8; // [rsp+0h] [rbp-1C8h] BYREF
long long v9; // [rsp+8h] [rbp-1C0h]
int v10; // [rsp+10h] [rbp-1B8h] BYREF
_BYTE v11[424]; // [rsp+20h] [rbp-1A8h] BYREF
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v11, a2, 24LL);
v8 = &v10;
v9 = 0LL;
LOBYTE(v10) = 0;
while ( 1 )
{
v2 = (_QWORD *)((long long ( *)(_BYTE *, int **))std::getline<char,std::char_traits<char>,std::allocator<char>>)(
v11,
&v8);
if ( (*((_BYTE *)v2 + *(_QWORD *)(*v2 - 24LL) + 32) & 5) != 0 )
break;
((void ( *)(long long, int **))std::vector<std::string>::push_back)(a1, &v8);
}
v6 = a2[1];
if ( *(_BYTE *)(*a2 + v6 - 1) == 10 )
std::vector<std::string>::emplace_back<char const(&)[1]>(a1, "", v3, v6, v4, v5, v8, v9, v10);
std::string::~string(&v8);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v11);
return a1;
}
| Split:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x1a8
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
AND qword ptr [RDI + 0x10],0x0
LAB_001259a8:
LEA RDI,[RSP + 0x20]
PUSH 0x18
POP RDX
CALL 0x0010c740
LEA RAX,[RSP + 0x10]
MOV qword ptr [RAX + -0x10],RAX
AND qword ptr [RAX + -0x8],0x0
MOV byte ptr [RAX],0x0
LEA R15,[RSP + 0x20]
MOV R12,RSP
LAB_001259ce:
MOV RDI,R15
MOV RSI,R12
CALL 0x0010c090
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
TEST byte ptr [RAX + RCX*0x1 + 0x20],0x5
JNZ 0x001259f4
MOV RDI,RBX
MOV RSI,R12
CALL 0x001260ee
JMP 0x001259ce
LAB_001259f4:
MOV RAX,qword ptr [R14]
MOV RCX,qword ptr [R14 + 0x8]
CMP byte ptr [RAX + RCX*0x1 + -0x1],0xa
JNZ 0x00125a11
LAB_00125a02:
LEA RSI,[0x132be1]
MOV RDI,RBX
CALL 0x0012611a
LAB_00125a11:
MOV RDI,RSP
CALL 0x0010c8c8
LEA RDI,[RSP + 0x20]
CALL 0x0010c360
MOV RAX,RBX
ADD RSP,0x1a8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ftxui::(anonymous namespace)::Split(std::__cxx11::string const&) */
_anonymous_namespace_ * __thiscall
ftxui::(anonymous_namespace)::Split(_anonymous_namespace_ *this,string *param_1)
{
istream *piVar1;
int1 *local_1c8;
int8 local_1c0;
int1 local_1b8 [16];
stringstream local_1a8 [392];
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
/* try { // try from 001259a8 to 001259b4 has its CatchHandler @ 00125a37 */
std::__cxx11::stringstream::stringstream(local_1a8,param_1,0x18);
local_1c8 = local_1b8;
local_1c0 = 0;
local_1b8[0] = 0;
while( true ) {
/* try { // try from 001259ce to 001259f1 has its CatchHandler @ 00125a3c */
piVar1 = std::getline<char,std::char_traits<char>,std::allocator<char>>
((istream *)local_1a8,(string *)&local_1c8);
if (((byte)piVar1[*(long *)(*(long *)piVar1 + -0x18) + 0x20] & 5) != 0) break;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)this,
(string *)&local_1c8);
}
if (*(char *)(*(long *)param_1 + -1 + *(long *)(param_1 + 8)) == '\n') {
/* try { // try from 00125a02 to 00125a10 has its CatchHandler @ 00125a35 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<char_const(&)[1]>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)this,"");
}
std::__cxx11::string::~string((string *)&local_1c8);
std::__cxx11::stringstream::~stringstream(local_1a8);
return this;
}
|
|
3,226 | fromfp16 | bluesky950520[P]quickjs/cutils.h | static inline double fromfp16(uint16_t v) {
double d, s;
int e;
if ((v & 0x7C00) == 0x7C00) {
d = (v & 0x3FF) ? NAN : INFINITY;
} else {
d = (v & 0x3FF) / 1024.;
e = (v & 0x7C00) >> 10;
if (e == 0) {
e = -14;
} else {
d += 1;
e -= 15;
}
d = scalbn(d, e);
}
s = (v & 0x8000) ? -1.0 : 1.0;
return d * s;
} | O0 | c | fromfp16:
subq $0x38, %rsp
movw %di, %ax
movw %ax, 0x36(%rsp)
movzwl 0x36(%rsp), %eax
andl $0x7c00, %eax # imm = 0x7C00
cmpl $0x7c00, %eax # imm = 0x7C00
jne 0x60b66
movzwl 0x36(%rsp), %eax
andl $0x3ff, %eax # imm = 0x3FF
movss 0xace91(%rip), %xmm0 # 0x10d9c0
movss 0xace8d(%rip), %xmm1 # 0x10d9c4
movss %xmm1, 0x14(%rsp)
cmpl $0x0, %eax
movss %xmm0, 0x18(%rsp)
jne 0x60b54
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
movss 0x18(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0x60bdc
movzwl 0x36(%rsp), %eax
andl $0x3ff, %eax # imm = 0x3FF
cvtsi2sd %eax, %xmm0
movsd 0xacd1c(%rip), %xmm1 # 0x10d898
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movzwl 0x36(%rsp), %eax
andl $0x7c00, %eax # imm = 0x7C00
sarl $0xa, %eax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x60ba8
movl $0xfffffff2, 0x1c(%rsp) # imm = 0xFFFFFFF2
jmp 0x60bc7
movsd 0xacc80(%rip), %xmm0 # 0x10d830
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x1c(%rsp), %eax
subl $0xf, %eax
movl %eax, 0x1c(%rsp)
movsd 0x28(%rsp), %xmm0
movl 0x1c(%rsp), %edi
callq 0xe670
movsd %xmm0, 0x28(%rsp)
movzwl 0x36(%rsp), %eax
andl $0x8000, %eax # imm = 0x8000
movsd 0xaccb2(%rip), %xmm0 # 0x10d8a0
movsd 0xacc3a(%rip), %xmm1 # 0x10d830
movsd %xmm1, (%rsp)
cmpl $0x0, %eax
movsd %xmm0, 0x8(%rsp)
jne 0x60c11
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nop
| fromfp16:
sub rsp, 38h
mov ax, di
mov [rsp+38h+var_2], ax
movzx eax, [rsp+38h+var_2]
and eax, 7C00h
cmp eax, 7C00h
jnz short loc_60B66
movzx eax, [rsp+38h+var_2]
and eax, 3FFh
movss xmm0, cs:dword_10D9C0
movss xmm1, cs:dword_10D9C4
movss [rsp+38h+var_24], xmm1
cmp eax, 0
movss [rsp+38h+var_20], xmm0
jnz short loc_60B54
movss xmm0, [rsp+38h+var_24]
movss [rsp+38h+var_20], xmm0
loc_60B54:
movss xmm0, [rsp+38h+var_20]
cvtss2sd xmm0, xmm0
movsd [rsp+38h+var_10], xmm0
jmp short loc_60BDC
loc_60B66:
movzx eax, [rsp+38h+var_2]
and eax, 3FFh
cvtsi2sd xmm0, eax
movsd xmm1, cs:qword_10D898
divsd xmm0, xmm1
movsd [rsp+38h+var_10], xmm0
movzx eax, [rsp+38h+var_2]
and eax, 7C00h
sar eax, 0Ah
mov [rsp+38h+var_1C], eax
cmp [rsp+38h+var_1C], 0
jnz short loc_60BA8
mov [rsp+38h+var_1C], 0FFFFFFF2h
jmp short loc_60BC7
loc_60BA8:
movsd xmm0, cs:qword_10D830
addsd xmm0, [rsp+38h+var_10]
movsd [rsp+38h+var_10], xmm0
mov eax, [rsp+38h+var_1C]
sub eax, 0Fh
mov [rsp+38h+var_1C], eax
loc_60BC7:
movsd xmm0, [rsp+38h+var_10]
mov edi, [rsp+38h+var_1C]
call _scalbn
movsd [rsp+38h+var_10], xmm0
loc_60BDC:
movzx eax, [rsp+38h+var_2]
and eax, 8000h
movsd xmm0, cs:qword_10D8A0
movsd xmm1, cs:qword_10D830
movsd [rsp+38h+var_38], xmm1
cmp eax, 0
movsd [rsp+38h+var_30], xmm0
jnz short loc_60C11
movsd xmm0, [rsp+38h+var_38]
movsd [rsp+38h+var_30], xmm0
loc_60C11:
movsd xmm0, [rsp+38h+var_30]
movsd [rsp+38h+var_18], xmm0
movsd xmm0, [rsp+38h+var_10]
mulsd xmm0, [rsp+38h+var_18]
add rsp, 38h
retn
| double fromfp16(__int16 a1)
{
double v2; // [rsp+8h] [rbp-30h]
float v3; // [rsp+18h] [rbp-20h]
int v4; // [rsp+1Ch] [rbp-1Ch]
unsigned int v5; // [rsp+1Ch] [rbp-1Ch]
double v6; // [rsp+28h] [rbp-10h]
double v7; // [rsp+28h] [rbp-10h]
if ( (a1 & 0x7C00) == 0x7C00 )
{
v3 = NAN;
if ( (a1 & 0x3FF) == 0 )
v3 = INFINITY;
v6 = v3;
}
else
{
v7 = (double)(a1 & 0x3FF) / 1024.0;
v4 = (a1 & 0x7C00) >> 10;
if ( v4 )
{
v7 = v7 + 1.0;
v5 = v4 - 15;
}
else
{
v5 = -14;
}
v6 = scalbn(v5, v7);
}
v2 = -1.0;
if ( (a1 & 0x8000) == 0 )
v2 = 1.0;
return v6 * v2;
}
| fromfp16:
SUB RSP,0x38
MOV AX,DI
MOV word ptr [RSP + 0x36],AX
MOVZX EAX,word ptr [RSP + 0x36]
AND EAX,0x7c00
CMP EAX,0x7c00
JNZ 0x00160b66
MOVZX EAX,word ptr [RSP + 0x36]
AND EAX,0x3ff
MOVSS XMM0,dword ptr [0x0020d9c0]
MOVSS XMM1,dword ptr [0x0020d9c4]
MOVSS dword ptr [RSP + 0x14],XMM1
CMP EAX,0x0
MOVSS dword ptr [RSP + 0x18],XMM0
JNZ 0x00160b54
MOVSS XMM0,dword ptr [RSP + 0x14]
MOVSS dword ptr [RSP + 0x18],XMM0
LAB_00160b54:
MOVSS XMM0,dword ptr [RSP + 0x18]
CVTSS2SD XMM0,XMM0
MOVSD qword ptr [RSP + 0x28],XMM0
JMP 0x00160bdc
LAB_00160b66:
MOVZX EAX,word ptr [RSP + 0x36]
AND EAX,0x3ff
CVTSI2SD XMM0,EAX
MOVSD XMM1,qword ptr [0x0020d898]
DIVSD XMM0,XMM1
MOVSD qword ptr [RSP + 0x28],XMM0
MOVZX EAX,word ptr [RSP + 0x36]
AND EAX,0x7c00
SAR EAX,0xa
MOV dword ptr [RSP + 0x1c],EAX
CMP dword ptr [RSP + 0x1c],0x0
JNZ 0x00160ba8
MOV dword ptr [RSP + 0x1c],0xfffffff2
JMP 0x00160bc7
LAB_00160ba8:
MOVSD XMM0,qword ptr [0x0020d830]
ADDSD XMM0,qword ptr [RSP + 0x28]
MOVSD qword ptr [RSP + 0x28],XMM0
MOV EAX,dword ptr [RSP + 0x1c]
SUB EAX,0xf
MOV dword ptr [RSP + 0x1c],EAX
LAB_00160bc7:
MOVSD XMM0,qword ptr [RSP + 0x28]
MOV EDI,dword ptr [RSP + 0x1c]
CALL 0x0010e670
MOVSD qword ptr [RSP + 0x28],XMM0
LAB_00160bdc:
MOVZX EAX,word ptr [RSP + 0x36]
AND EAX,0x8000
MOVSD XMM0,qword ptr [0x0020d8a0]
MOVSD XMM1,qword ptr [0x0020d830]
MOVSD qword ptr [RSP],XMM1
CMP EAX,0x0
MOVSD qword ptr [RSP + 0x8],XMM0
JNZ 0x00160c11
MOVSD XMM0,qword ptr [RSP]
MOVSD qword ptr [RSP + 0x8],XMM0
LAB_00160c11:
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD qword ptr [RSP + 0x20],XMM0
MOVSD XMM0,qword ptr [RSP + 0x28]
MULSD XMM0,qword ptr [RSP + 0x20]
ADD RSP,0x38
RET
|
double fromfp16(ushort param_1)
{
int8 local_30;
int4 local_20;
int4 local_1c;
int8 local_10;
if ((param_1 & 0x7c00) == 0x7c00) {
local_20 = DAT_0020d9c0;
if ((param_1 & 0x3ff) == 0) {
local_20 = DAT_0020d9c4;
}
local_10 = (double)local_20;
}
else {
local_10 = (double)(param_1 & 0x3ff) / DAT_0020d898;
local_1c = (int)(param_1 & 0x7c00) >> 10;
if (local_1c == 0) {
local_1c = -0xe;
}
else {
local_10 = DAT_0020d830 + local_10;
local_1c = local_1c + -0xf;
}
local_10 = scalbn(local_10,local_1c);
}
local_30 = DAT_0020d8a0;
if ((param_1 & 0x8000) == 0) {
local_30 = DAT_0020d830;
}
return local_10 * local_30;
}
|
|
3,227 | fromfp16 | bluesky950520[P]quickjs/cutils.h | static inline double fromfp16(uint16_t v) {
double d, s;
int e;
if ((v & 0x7C00) == 0x7C00) {
d = (v & 0x3FF) ? NAN : INFINITY;
} else {
d = (v & 0x3FF) / 1024.;
e = (v & 0x7C00) >> 10;
if (e == 0) {
e = -14;
} else {
d += 1;
e -= 15;
}
d = scalbn(d, e);
}
s = (v & 0x8000) ? -1.0 : 1.0;
return d * s;
} | O1 | c | fromfp16:
pushq %rbx
movl %edi, %ebx
movl $0x7c00, %edx # imm = 0x7C00
movl %edi, %eax
andl %edx, %eax
movl %edi, %ecx
andl $0x3ff, %ecx # imm = 0x3FF
cmpl %edx, %eax
jne 0x3d982
xorl %eax, %eax
testl %ecx, %ecx
sete %al
leaq 0x60dd5(%rip), %rcx # 0x9e750
movsd (%rcx,%rax,8), %xmm0
jmp 0x3d9af
cvtsi2sd %ecx, %xmm0
mulsd 0x60ef2(%rip), %xmm0 # 0x9e880
movl %eax, %edi
shrl $0xa, %edi
addl $-0xf, %edi
testl %eax, %eax
je 0x3d9a2
addsd 0x60ec6(%rip), %xmm0 # 0x9e868
movl $0xfffffff2, %eax # imm = 0xFFFFFFF2
cmovel %eax, %edi
callq 0xe670
testw %bx, %bx
jns 0x3d9bc
xorpd 0x60da4(%rip), %xmm0 # 0x9e760
popq %rbx
retq
| fromfp16:
push rbx
mov ebx, edi
mov edx, 7C00h
mov eax, edi
and eax, edx
mov ecx, edi
and ecx, 3FFh
cmp eax, edx
jnz short loc_3D982
xor eax, eax
test ecx, ecx
setz al
lea rcx, dbl_9E750
movsd xmm0, qword ptr [rcx+rax*8]
jmp short loc_3D9AF
loc_3D982:
cvtsi2sd xmm0, ecx
mulsd xmm0, cs:qword_9E880
mov edi, eax
shr edi, 0Ah
add edi, 0FFFFFFF1h
test eax, eax
jz short loc_3D9A2
addsd xmm0, cs:qword_9E868
loc_3D9A2:
mov eax, 0FFFFFFF2h
cmovz edi, eax
call _scalbn
loc_3D9AF:
test bx, bx
jns short loc_3D9BC
xorpd xmm0, cs:xmmword_9E760
loc_3D9BC:
pop rbx
retn
| long long fromfp16(__int16 a1)
{
unsigned int v1; // eax
int v2; // ecx
double v4; // xmm0_8
long long v5; // rdi
v1 = a1 & 0x7C00;
v2 = a1 & 0x3FF;
if ( v1 == 31744 )
return v2 == 0;
v4 = (double)v2 * 0.0009765625;
v5 = (v1 >> 10) - 15;
if ( v1 )
v4 = v4 + 1.0;
else
v5 = 4294967282LL;
return scalbn(v5, v4);
}
| |||
3,228 | fromfp16 | bluesky950520[P]quickjs/cutils.h | static inline double fromfp16(uint16_t v) {
double d, s;
int e;
if ((v & 0x7C00) == 0x7C00) {
d = (v & 0x3FF) ? NAN : INFINITY;
} else {
d = (v & 0x3FF) / 1024.;
e = (v & 0x7C00) >> 10;
if (e == 0) {
e = -14;
} else {
d += 1;
e -= 15;
}
d = scalbn(d, e);
}
s = (v & 0x8000) ? -1.0 : 1.0;
return d * s;
} | O2 | c | fromfp16:
pushq %rbx
movl %edi, %ebx
movl $0x7c00, %edx # imm = 0x7C00
movl %edi, %eax
andl %edx, %eax
movl %edi, %ecx
andl $0x3ff, %ecx # imm = 0x3FF
cmpl %edx, %eax
jne 0x361a4
xorl %eax, %eax
testl %ecx, %ecx
sete %al
leaq 0x4f573(%rip), %rcx # 0x85710
movsd (%rcx,%rax,8), %xmm0
jmp 0x361cf
cvtsi2sd %ecx, %xmm0
mulsd 0x4f690(%rip), %xmm0 # 0x85840
movl %eax, %edi
shrl $0xa, %edi
addl $-0xf, %edi
testl %eax, %eax
je 0x361c4
addsd 0x4f5ec(%rip), %xmm0 # 0x857b0
pushq $-0xe
popq %rax
cmovel %eax, %edi
callq 0xe690
testw %bx, %bx
jns 0x361dc
xorpd 0x4f544(%rip), %xmm0 # 0x85720
popq %rbx
retq
| fromfp16:
push rbx
mov ebx, edi
mov edx, 7C00h
mov eax, edi
and eax, edx
mov ecx, edi
and ecx, 3FFh
cmp eax, edx
jnz short loc_361A4
xor eax, eax
test ecx, ecx
setz al
lea rcx, unk_85710
movsd xmm0, qword ptr [rcx+rax*8]
jmp short loc_361CF
loc_361A4:
cvtsi2sd xmm0, ecx
mulsd xmm0, cs:qword_85840
mov edi, eax
shr edi, 0Ah
add edi, 0FFFFFFF1h
test eax, eax
jz short loc_361C4
addsd xmm0, cs:qword_857B0
loc_361C4:
push 0FFFFFFFFFFFFFFF2h
pop rax
cmovz edi, eax
call _scalbn
loc_361CF:
test bx, bx
jns short loc_361DC
xorpd xmm0, cs:xmmword_85720
loc_361DC:
pop rbx
retn
| long long fromfp16(__int16 a1)
{
unsigned int v1; // eax
int v2; // ecx
double v4; // xmm0_8
long long v5; // rdi
v1 = a1 & 0x7C00;
v2 = a1 & 0x3FF;
if ( v1 == 31744 )
return v2 == 0;
v4 = (double)v2 * 0.0009765625;
v5 = (v1 >> 10) - 15;
if ( v1 )
v4 = v4 + 1.0;
else
v5 = 4294967282LL;
return scalbn(v5, v4);
}
| fromfp16:
PUSH RBX
MOV EBX,EDI
MOV EDX,0x7c00
MOV EAX,EDI
AND EAX,EDX
MOV ECX,EDI
AND ECX,0x3ff
CMP EAX,EDX
JNZ 0x001361a4
XOR EAX,EAX
TEST ECX,ECX
SETZ AL
LEA RCX,[0x185710]
MOVSD XMM0,qword ptr [RCX + RAX*0x8]
JMP 0x001361cf
LAB_001361a4:
CVTSI2SD XMM0,ECX
MULSD XMM0,qword ptr [0x00185840]
MOV EDI,EAX
SHR EDI,0xa
ADD EDI,-0xf
TEST EAX,EAX
JZ 0x001361c4
ADDSD XMM0,qword ptr [0x001857b0]
LAB_001361c4:
PUSH -0xe
POP RAX
CMOVZ EDI,EAX
CALL 0x0010e690
LAB_001361cf:
TEST BX,BX
JNS 0x001361dc
XORPD XMM0,xmmword ptr [0x00185720]
LAB_001361dc:
POP RBX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double fromfp16(uint param_1)
{
uint uVar1;
int __n;
double dVar2;
uVar1 = param_1 & 0x7c00;
if (uVar1 == 0x7c00) {
dVar2 = *(double *)(&DAT_00185710 + (ulong)((param_1 & 0x3ff) == 0) * 8);
}
else {
dVar2 = (double)(param_1 & 0x3ff) * _DAT_00185840;
__n = (uVar1 >> 10) - 0xf;
if (uVar1 == 0) {
__n = -0xe;
}
else {
dVar2 = dVar2 + DAT_001857b0;
}
dVar2 = scalbn(dVar2,__n);
}
if ((short)param_1 < 0) {
dVar2 = (double)((ulong)dVar2 ^ _DAT_00185720);
}
return dVar2;
}
|
|
3,229 | my_casedn_utf8mb3 | eloqsql/strings/ctype-utf8.c | static size_t my_casedn_utf8mb3(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int srcres, dstres;
const char *srcend= src + srclen;
char *dstend= dst + dstlen, *dst0= dst;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(src != dst || cs->casedn_multiply == 1);
while ((src < srcend) &&
(srcres= my_utf8mb3_uni(cs, &wc, (uchar*) src, (uchar*)srcend)) > 0)
{
my_tolower_utf8mb3(uni_plane, &wc);
if ((dstres= my_uni_utf8mb3(cs, wc, (uchar*) dst, (uchar*) dstend)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
return (size_t) (dst - dst0);
} | O0 | c | my_casedn_utf8mb3:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x6bb5a
jmp 0x6bb5c
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0x6bb8c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x6b700
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x6bb95
jmp 0x6bbe8
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6c9d0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x6b730
movl %eax, -0x38(%rbp)
cmpl $0x0, %eax
jg 0x6bbc1
jmp 0x6bbe8
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x38(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x6bb5c
movq -0x20(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| my_casedn_utf8mb3:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_58], rax
jmp short $+2
loc_6BB5A:
jmp short $+2
loc_6BB5C:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_59], al
jnb short loc_6BB8C
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_utf8mb3_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_59], al
loc_6BB8C:
mov al, [rbp+var_59]
test al, 1
jnz short loc_6BB95
jmp short loc_6BBE8
loc_6BB95:
mov rdi, [rbp+var_58]
lea rsi, [rbp+var_30]
call my_tolower_utf8mb3
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_uni_utf8mb3
mov [rbp+var_38], eax
cmp eax, 0
jg short loc_6BBC1
jmp short loc_6BBE8
loc_6BBC1:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_38]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_6BB5C
loc_6BBE8:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_50]
sub rax, rcx
add rsp, 60h
pop rbp
retn
| _BYTE * my_casedn_utf8mb3(long long a1, unsigned long long a2, long long a3, _BYTE *a4, long long a5, long long a6)
{
bool v7; // [rsp+7h] [rbp-59h]
long long v8; // [rsp+8h] [rbp-58h]
unsigned long long v10; // [rsp+18h] [rbp-48h]
unsigned long long v11; // [rsp+20h] [rbp-40h]
int v12; // [rsp+28h] [rbp-38h]
int v13; // [rsp+2Ch] [rbp-34h]
unsigned long long v14[2]; // [rsp+30h] [rbp-30h] BYREF
_BYTE *v15; // [rsp+40h] [rbp-20h]
long long v16; // [rsp+48h] [rbp-18h]
unsigned long long v17; // [rsp+50h] [rbp-10h]
long long v18; // [rsp+58h] [rbp-8h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14[1] = a5;
v11 = a3 + a2;
v10 = (unsigned long long)&a4[a5];
v8 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( v17 < v11 )
{
v13 = my_utf8mb3_uni(v18, (long long)v14, v17, v11, a5, a6);
v7 = v13 > 0;
}
if ( !v7 )
break;
my_tolower_utf8mb3(v8, v14);
v12 = my_uni_utf8mb3(v18, v14[0], v15, v10);
if ( v12 <= 0 )
break;
v17 += v13;
v15 += v12;
}
return (_BYTE *)(v15 - a4);
}
| my_casedn_utf8mb3:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0016bb5a
LAB_0016bb5a:
JMP 0x0016bb5c
LAB_0016bb5c:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x59],AL
JNC 0x0016bb8c
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x0016b700
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x59],AL
LAB_0016bb8c:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x0016bb95
JMP 0x0016bbe8
LAB_0016bb95:
MOV RDI,qword ptr [RBP + -0x58]
LEA RSI,[RBP + -0x30]
CALL 0x0016c9d0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x0016b730
MOV dword ptr [RBP + -0x38],EAX
CMP EAX,0x0
JG 0x0016bbc1
JMP 0x0016bbe8
LAB_0016bbc1:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0016bb5c
LAB_0016bbe8:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long my_casedn_utf8mb3(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
int8 uVar1;
bool bVar2;
int iVar3;
int local_3c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_utf8mb3_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_tolower_utf8mb3(uVar1,&local_38);
iVar3 = my_uni_utf8mb3(local_10,local_38,local_28,param_4 + param_5);
if (iVar3 < 1) break;
local_18 = local_18 + (long)local_3c;
local_28 = local_28 + iVar3;
}
return local_28 - param_4;
}
|
|
3,230 | wserver_header_start | navaro[P]qoraal-tictactoe/src/services/www/wserver_inst.c | int32_t
wserver_header_start(HTTP_USER_T * user, uint32_t method, char* endpoint, WSERVER_CTRL ctrl)
{
static const char head_content_1[] =
"<!DOCTYPE HTML PUBLIC>"
"<head>\r\n"
"<meta content=\"text/html;charset=utf-8\" http-equiv=\"Content-Type\">"
"<meta content=\"utf-8\" http-equiv=\"encoding\">"
"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\r\n"
"<link rel=\"icon\" href=\"data:;base64,=\">"
;
static const char head_content_2[] =
"<link rel=\"stylesheet\" href=\"/css/default.css\">\r\n"
"\r\n</head>\r\n<body style=\"background-color: #F5F5DC;\">\r\n" ;
int32_t res ;
const char * headers = 0;
if (ctrl) {
headers = ctrl (user, method, endpoint, WSERVER_CTRL_METADATA_HEADERS) ;
}
do {
if ((res = httpserver_chunked_response (user, 200, HTTP_SERVER_CONTENT_TYPE_HTML, 0, 0) < HTTP_SERVER_E_OK)) {
break ;
}
if ((res = httpserver_chunked_append_str (user, head_content_1, sizeof(head_content_1) - 1) < HTTP_SERVER_E_OK)) {
break ;
}
if (headers) {
if ((res = httpserver_chunked_append_str (user, headers, strlen(headers)) < HTTP_SERVER_E_OK)) {
break ;
}
}
if ((res = httpserver_chunked_append_str (user, head_content_2, sizeof(head_content_2) - 1) < HTTP_SERVER_E_OK)) {
break ;
}
} while (0) ;
return res ;
} | O3 | c | wserver_header_start:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rcx, %rcx
je 0x12541
movq %rcx, %rax
movq %rbx, %rdi
movl $0x2, %ecx
callq *%rax
movq %rax, %r14
jmp 0x12544
xorl %r14d, %r14d
leaq 0x1524a(%rip), %rdx # 0x27795
movq %rbx, %rdi
movl $0xc8, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1d9c2
testl %eax, %eax
js 0x125ab
leaq 0x14a98(%rip), %rsi # 0x27000
movq %rbx, %rdi
movl $0xf9, %edx
callq 0x1dd14
testl %eax, %eax
js 0x125ab
testq %r14, %r14
je 0x12597
movq %r14, %rdi
callq 0x61a0
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x1dd14
testl %eax, %eax
js 0x125ab
leaq 0x14b62(%rip), %rsi # 0x27100
movq %rbx, %rdi
movl $0x67, %edx
callq 0x1dd14
shrl $0x1f, %eax
popq %rbx
popq %r14
popq %rbp
retq
| wserver_header_start:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
test rcx, rcx
jz short loc_12541
mov rax, rcx
mov rdi, rbx
mov ecx, 2
call rax
mov r14, rax
jmp short loc_12544
loc_12541:
xor r14d, r14d
loc_12544:
lea rdx, aTextHtml; "text/html"
mov rdi, rbx
mov esi, 0C8h
xor ecx, ecx
xor r8d, r8d
call httpserver_chunked_response
test eax, eax
js short loc_125AB
lea rsi, wserver_header_start_head_content_1; "<!DOCTYPE HTML PUBLIC><head>\r\n<meta c"...
mov rdi, rbx
mov edx, 0F9h
call httpserver_chunked_append_str
test eax, eax
js short loc_125AB
test r14, r14
jz short loc_12597
mov rdi, r14
call _strlen
mov rdi, rbx
mov rsi, r14
mov edx, eax
call httpserver_chunked_append_str
test eax, eax
js short loc_125AB
loc_12597:
lea rsi, wserver_header_start_head_content_2; "<link rel=\"stylesheet\" href=\"/css/de"...
mov rdi, rbx
mov edx, 67h ; 'g'
call httpserver_chunked_append_str
loc_125AB:
shr eax, 1Fh
pop rbx
pop r14
pop rbp
retn
| long long wserver_header_start(
long long a1,
long long a2,
long long a3,
long long ( *a4)(long long, long long, long long, long long))
{
long long v4; // r14
int appended; // eax
unsigned int v6; // eax
if ( a4 )
v4 = a4(a1, a2, a3, 2LL);
else
v4 = 0LL;
appended = httpserver_chunked_response(a1, 200LL, aTextHtml, 0LL, 0LL);
if ( appended >= 0 )
{
appended = httpserver_chunked_append_str(a1, wserver_header_start_head_content_1, 249LL);
if ( appended >= 0 )
{
if ( !v4 || (v6 = strlen(v4), appended = httpserver_chunked_append_str(a1, v4, v6), appended >= 0) )
appended = httpserver_chunked_append_str(a1, wserver_header_start_head_content_2, 103LL);
}
}
return (unsigned int)appended >> 31;
}
| wserver_header_start:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
TEST RCX,RCX
JZ 0x00112541
MOV RAX,RCX
MOV RDI,RBX
MOV ECX,0x2
CALL RAX
MOV R14,RAX
JMP 0x00112544
LAB_00112541:
XOR R14D,R14D
LAB_00112544:
LEA RDX,[0x127795]
MOV RDI,RBX
MOV ESI,0xc8
XOR ECX,ECX
XOR R8D,R8D
CALL 0x0011d9c2
TEST EAX,EAX
JS 0x001125ab
LEA RSI,[0x127000]
MOV RDI,RBX
MOV EDX,0xf9
CALL 0x0011dd14
TEST EAX,EAX
JS 0x001125ab
TEST R14,R14
JZ 0x00112597
MOV RDI,R14
CALL 0x001061a0
MOV RDI,RBX
MOV RSI,R14
MOV EDX,EAX
CALL 0x0011dd14
TEST EAX,EAX
JS 0x001125ab
LAB_00112597:
LEA RSI,[0x127100]
MOV RDI,RBX
MOV EDX,0x67
CALL 0x0011dd14
LAB_001125ab:
SHR EAX,0x1f
POP RBX
POP R14
POP RBP
RET
|
uint wserver_header_start(int8 param_1,int8 param_2,int8 param_3,code *param_4)
{
uint uVar1;
char *__s;
size_t sVar2;
if (param_4 == (code *)0x0) {
__s = (char *)0x0;
}
else {
__s = (char *)(*param_4)(param_1,param_2,param_3,2);
}
uVar1 = httpserver_chunked_response(param_1,200,s_text_html_00127795,0,0);
if (-1 < (int)uVar1) {
uVar1 = httpserver_chunked_append_str(param_1,wserver_header_start_head_content_1,0xf9);
if (-1 < (int)uVar1) {
if (__s != (char *)0x0) {
sVar2 = strlen(__s);
uVar1 = httpserver_chunked_append_str(param_1,__s,sVar2 & 0xffffffff);
if ((int)uVar1 < 0) goto LAB_001125ab;
}
uVar1 = httpserver_chunked_append_str(param_1,wserver_header_start_head_content_2,0x67);
}
}
LAB_001125ab:
return uVar1 >> 0x1f;
}
|
|
3,231 | ggml_hash_find | llama.cpp/ggml/src/ggml-impl.h | static size_t ggml_hash_find(const struct ggml_hash_set * hash_set, const struct ggml_tensor * key) {
size_t h = ggml_hash(key) % hash_set->size;
// linear probing
size_t i = h;
while (ggml_bitset_get(hash_set->used, i) && hash_set->keys[i] != key) {
i = (i + 1) % hash_set->size;
if (i == h) {
// visited all hash table entries -> not found
return GGML_HASHSET_FULL;
}
}
return i;
} | O3 | c | ggml_hash_find:
movq %rsi, %rax
shrq $0x4, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %r8
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movq %rax, %r9
shrq $0x5, %r9
movl (%r8,%r9,4), %r9d
btl %eax, %r9d
jae 0x21c5d
movq 0x10(%rdi), %r9
cmpq %rsi, (%r9,%rax,8)
je 0x21c5d
incq %rax
cmpq %rcx, %rax
movl $0x0, %r9d
cmoveq %r9, %rax
cmpq %rdx, %rax
jne 0x21c26
movq $-0x1, %rax
retq
| ggml_hash_find:
mov rax, rsi
shr rax, 4
mov rcx, [rdi]
mov r8, [rdi+8]
xor edx, edx
div rcx
mov rax, rdx
loc_21C26:
mov r9, rax
shr r9, 5
mov r9d, [r8+r9*4]
bt r9d, eax
jnb short locret_21C5D
mov r9, [rdi+10h]
cmp [r9+rax*8], rsi
jz short locret_21C5D
inc rax
cmp rax, rcx
mov r9d, 0
cmovz rax, r9
cmp rax, rdx
jnz short loc_21C26
mov rax, 0FFFFFFFFFFFFFFFFh
locret_21C5D:
retn
| unsigned long long ggml_hash_find(_QWORD *a1, unsigned long long a2)
{
unsigned long long result; // rax
int v3; // r9d
result = (a2 >> 4) % *a1;
while ( 1 )
{
v3 = *(_DWORD *)(a1[1] + 4 * (result >> 5));
if ( !_bittest(&v3, result) || *(_QWORD *)(a1[2] + 8 * result) == a2 )
break;
if ( ++result == *a1 )
result = 0LL;
if ( result == (a2 >> 4) % *a1 )
return -1LL;
}
return result;
}
| ggml_hash_find:
MOV RAX,RSI
SHR RAX,0x4
MOV RCX,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x8]
XOR EDX,EDX
DIV RCX
MOV RAX,RDX
LAB_00121c26:
MOV R9,RAX
SHR R9,0x5
MOV R9D,dword ptr [R8 + R9*0x4]
BT R9D,EAX
JNC 0x00121c5d
MOV R9,qword ptr [RDI + 0x10]
CMP qword ptr [R9 + RAX*0x8],RSI
JZ 0x00121c5d
INC RAX
CMP RAX,RCX
MOV R9D,0x0
CMOVZ RAX,R9
CMP RAX,RDX
JNZ 0x00121c26
MOV RAX,-0x1
LAB_00121c5d:
RET
|
ulong ggml_hash_find(ulong *param_1,ulong param_2)
{
ulong uVar1;
ulong uVar2;
uVar2 = (param_2 >> 4) % *param_1;
uVar1 = uVar2;
while( true ) {
if ((*(uint *)(param_1[1] + (uVar1 >> 5) * 4) >> ((uint)uVar1 & 0x1f) & 1) == 0) {
return uVar1;
}
if (*(ulong *)(param_1[2] + uVar1 * 8) == param_2) break;
uVar1 = uVar1 + 1;
if (uVar1 == *param_1) {
uVar1 = 0;
}
if (uVar1 == uVar2) {
return 0xffffffffffffffff;
}
}
return uVar1;
}
|
|
3,232 | ma_bitmap_unpin_all | eloqsql/storage/maria/ma_bitmap.c | static void _ma_bitmap_unpin_all(MARIA_SHARE *share)
{
MARIA_FILE_BITMAP *bitmap= &share->bitmap;
MARIA_PINNED_PAGE *page_link= ((MARIA_PINNED_PAGE*)
dynamic_array_ptr(&bitmap->pinned_pages, 0));
MARIA_PINNED_PAGE *pinned_page= page_link + bitmap->pinned_pages.elements;
DBUG_ENTER("_ma_bitmap_unpin_all");
DBUG_PRINT("info", ("pinned: %u", bitmap->pinned_pages.elements));
while (pinned_page-- != page_link)
pagecache_unlock_by_link(share->pagecache, pinned_page->link,
pinned_page->unlock, PAGECACHE_UNPIN,
LSN_IMPOSSIBLE, LSN_IMPOSSIBLE, FALSE, TRUE);
bitmap->pinned_pages.elements= 0;
DBUG_VOID_RETURN;
} | O0 | c | ma_bitmap_unpin_all:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa10, %rax # imm = 0xA10
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rax
movq -0x10(%rbp), %rcx
imull $0x0, 0x154(%rcx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x148(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x62cf4
jmp 0x62cf6
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x18, %rcx
movq %rcx, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
je 0x62d49
movq -0x8(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movl $0x3, %ecx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %r8
movl $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x3cda0
jmp 0x62cf6
movq -0x10(%rbp), %rax
movl $0x0, 0x148(%rax)
jmp 0x62d59
addq $0x30, %rsp
popq %rbp
retq
nop
| _ma_bitmap_unpin_all:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
add rax, 0A10h
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax+140h]
mov rcx, [rbp+var_10]
imul ecx, [rcx+154h], 0
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov ecx, [rcx+148h]
imul rcx, 18h
add rax, rcx
mov [rbp+var_20], rax
jmp short $+2
loc_62CF4:
jmp short $+2
loc_62CF6:
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFE8h
mov [rbp+var_20], rcx
cmp rax, [rbp+var_18]
jz short loc_62D49
mov rax, [rbp+var_8]
mov rdi, [rax+600h]
mov rax, [rbp+var_20]
mov rsi, [rax]
mov rax, [rbp+var_20]
mov edx, [rax+8]
mov ecx, 3
xor eax, eax
mov r9d, eax
xor eax, eax
mov r8, r9
mov [rsp+30h+var_30], 0
mov [rsp+30h+var_28], 1
call pagecache_unlock_by_link
jmp short loc_62CF6
loc_62D49:
mov rax, [rbp+var_10]
mov dword ptr [rax+148h], 0
jmp short $+2
loc_62D59:
add rsp, 30h
pop rbp
retn
| long long ma_bitmap_unpin_all(long long a1)
{
long long v1; // rax
long long result; // rax
long long i; // [rsp+10h] [rbp-20h]
long long v4; // [rsp+18h] [rbp-18h]
v4 = *(_QWORD *)(a1 + 2896);
for ( i = 24LL * *(unsigned int *)(a1 + 2904) + v4;
;
pagecache_unlock_by_link(*(_QWORD **)(a1 + 1536), *(_QWORD *)i, *(_DWORD *)(i + 8), 3, 0LL, 0LL, 0, 1) )
{
v1 = i;
i -= 24LL;
if ( v1 == v4 )
break;
}
result = a1 + 2576;
*(_DWORD *)(a1 + 2904) = 0;
return result;
}
| _ma_bitmap_unpin_all:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0xa10
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x140]
MOV RCX,qword ptr [RBP + -0x10]
IMUL ECX,dword ptr [RCX + 0x154],0x0
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x148]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00162cf4
LAB_00162cf4:
JMP 0x00162cf6
LAB_00162cf6:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,-0x18
MOV qword ptr [RBP + -0x20],RCX
CMP RAX,qword ptr [RBP + -0x18]
JZ 0x00162d49
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x600]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0x8]
MOV ECX,0x3
XOR EAX,EAX
MOV R9D,EAX
XOR EAX,EAX
MOV R8,R9
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x1
CALL 0x0013cda0
JMP 0x00162cf6
LAB_00162d49:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x148],0x0
JMP 0x00162d59
LAB_00162d59:
ADD RSP,0x30
POP RBP
RET
|
void _ma_bitmap_unpin_all(long param_1)
{
int8 *puVar1;
int8 *local_28;
puVar1 = *(int8 **)(param_1 + 0xb50);
local_28 = puVar1 + (ulong)*(uint *)(param_1 + 0xb58) * 3;
while (local_28 != puVar1) {
pagecache_unlock_by_link
(*(int8 *)(param_1 + 0x600),local_28[-3],*(int4 *)(local_28 + -2),3,0,0,0,
1);
local_28 = local_28 + -3;
}
*(int4 *)(param_1 + 0xb58) = 0;
return;
}
|
|
3,233 | ma_bitmap_unpin_all | eloqsql/storage/maria/ma_bitmap.c | static void _ma_bitmap_unpin_all(MARIA_SHARE *share)
{
MARIA_FILE_BITMAP *bitmap= &share->bitmap;
MARIA_PINNED_PAGE *page_link= ((MARIA_PINNED_PAGE*)
dynamic_array_ptr(&bitmap->pinned_pages, 0));
MARIA_PINNED_PAGE *pinned_page= page_link + bitmap->pinned_pages.elements;
DBUG_ENTER("_ma_bitmap_unpin_all");
DBUG_PRINT("info", ("pinned: %u", bitmap->pinned_pages.elements));
while (pinned_page-- != page_link)
pagecache_unlock_by_link(share->pagecache, pinned_page->link,
pinned_page->unlock, PAGECACHE_UNPIN,
LSN_IMPOSSIBLE, LSN_IMPOSSIBLE, FALSE, TRUE);
bitmap->pinned_pages.elements= 0;
DBUG_VOID_RETURN;
} | O3 | c | ma_bitmap_unpin_all:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xb58(%rdi), %eax
testq %rax, %rax
je 0x52d43
movq 0xb50(%rbx), %r14
shlq $0x3, %rax
leaq (%rax,%rax,2), %r15
movq 0x600(%rbx), %rdi
movq -0x18(%r14,%r15), %rsi
movl -0x10(%r14,%r15), %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq $0x0
callq 0x3ae31
addq $0x10, %rsp
addq $-0x18, %r15
jne 0x52d14
movl $0x0, 0xb58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| _ma_bitmap_unpin_all:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov eax, [rdi+0B58h]
test rax, rax
jz short loc_52D43
mov r14, [rbx+0B50h]
shl rax, 3
lea r15, [rax+rax*2]
loc_52D14:
mov rdi, [rbx+600h]
mov rsi, [r14+r15-18h]
mov edx, [r14+r15-10h]
mov ecx, 3
xor r8d, r8d
xor r9d, r9d
push 1
push 0
call pagecache_unlock_by_link
add rsp, 10h
add r15, 0FFFFFFFFFFFFFFE8h
jnz short loc_52D14
loc_52D43:
mov dword ptr [rbx+0B58h], 0
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long ma_bitmap_unpin_all(long long a1)
{
long long result; // rax
long long v2; // r14
long long v3; // r15
result = *(unsigned int *)(a1 + 2904);
if ( *(_DWORD *)(a1 + 2904) )
{
v2 = *(_QWORD *)(a1 + 2896);
v3 = 24 * result;
do
{
result = pagecache_unlock_by_link(
*(_QWORD *)(a1 + 1536),
*(_QWORD *)(v2 + v3 - 24),
*(_DWORD *)(v2 + v3 - 16),
3,
0LL,
0LL,
0);
v3 -= 24LL;
}
while ( v3 );
}
*(_DWORD *)(a1 + 2904) = 0;
return result;
}
| _ma_bitmap_unpin_all:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0xb58]
TEST RAX,RAX
JZ 0x00152d43
MOV R14,qword ptr [RBX + 0xb50]
SHL RAX,0x3
LEA R15,[RAX + RAX*0x2]
LAB_00152d14:
MOV RDI,qword ptr [RBX + 0x600]
MOV RSI,qword ptr [R14 + R15*0x1 + -0x18]
MOV EDX,dword ptr [R14 + R15*0x1 + -0x10]
MOV ECX,0x3
XOR R8D,R8D
XOR R9D,R9D
PUSH 0x1
PUSH 0x0
CALL 0x0013ae31
ADD RSP,0x10
ADD R15,-0x18
JNZ 0x00152d14
LAB_00152d43:
MOV dword ptr [RBX + 0xb58],0x0
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void _ma_bitmap_unpin_all(long param_1)
{
long lVar1;
long lVar2;
if ((ulong)*(uint *)(param_1 + 0xb58) != 0) {
lVar1 = *(long *)(param_1 + 0xb50);
lVar2 = (ulong)*(uint *)(param_1 + 0xb58) * 0x18;
do {
pagecache_unlock_by_link
(*(int8 *)(param_1 + 0x600),*(int8 *)(lVar1 + -0x18 + lVar2),
*(int4 *)(lVar1 + -0x10 + lVar2),3,0,0,0,1);
lVar2 = lVar2 + -0x18;
} while (lVar2 != 0);
}
*(int4 *)(param_1 + 0xb58) = 0;
return;
}
|
|
3,234 | minja::Value::Value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/minja.hpp | Value(const std::string & v) : primitive_(v) {} | O3 | cpp | minja::Value::Value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x40, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
callq 0x84b14
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x8fe27
callq 0x33c02
movq %rbx, %rdi
callq 0x1ccc4
movq %rbx, %rdi
callq 0x8d2ea
movq %r14, %rdi
callq 0x1bff0
nop
| _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r14
push rbx
push rax
mov rbx, rdi
add rdi, 40h ; '@'
xorps xmm0, xmm0
movups xmmword ptr [rbx+30h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRKS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_
add rsp, 8
pop rbx
pop r14
retn
mov r14, rax
mov rdi, [rbx+38h]
test rdi, rdi
jz short loc_8FE27
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_8FE27:
mov rdi, rbx
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold_1; minja::Value::Value(std::string const&) [clone]
mov rdi, rbx
call _ZNSt23enable_shared_from_thisIN5minja5ValueEED2Ev; std::enable_shared_from_this<minja::Value>::~enable_shared_from_this()
mov rdi, r14
call __Unwind_Resume
| _QWORD * minja::Value::Value(long long a1, long long a2)
{
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
return ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRKS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_(
(unsigned __int8 *)(a1 + 64),
a2);
}
| Value:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
ADD RDI,0x40
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_0018fe09:
CALL 0x00184b14
LAB_0018fe0e:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::Value::Value(std::__cxx11::string const&) */
void __thiscall minja::Value::Value(Value *this,string *param_1)
{
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
/* try { // try from 0018fe09 to 0018fe0d has its CatchHandler @ 0018fe16 */
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRKS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_
(this + 0x40);
return;
}
|
|
3,235 | mysql_stmt_reset_cont | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_reset_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status)
{
MK_ASYNC_CONT_BODY(
stmt->mysql,
TRUE,
r_my_bool)
} | O3 | c | mysql_stmt_reset_cont:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %r15
cmpb $0x0, 0x15(%r15)
je 0x9d625
movb $0x1, 0x14(%r15)
movl %edx, 0x4(%r15)
leaq 0x38(%r15), %rdi
callq 0x9e613
movb $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x9d688
movl (%r15), %r15d
jmp 0x9d6fe
movl $0x7de, 0x90(%rax) # imm = 0x7DE
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x305f81(%rip), %rax # 0x3a35c0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x39130
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x305f66(%rip), %rax # 0x3a35d0
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x39130
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, (%rbx)
jmp 0x9d6fe
movb $0x0, 0x15(%r15)
js 0x9d695
movb 0x8(%r15), %al
jmp 0x9d6f9
movq 0x38(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x305f0d(%rip), %rax # 0x3a35c0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x39130
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x305ef2(%rip), %rax # 0x3a35d0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x39130
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, %al
movb %al, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mysql_stmt_reset_cont:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+38h]
mov rcx, [rax+480h]
mov r15, [rcx+28h]
cmp byte ptr [r15+15h], 0
jz short loc_9D625
mov byte ptr [r15+14h], 1
mov [r15+4], edx
lea rdi, [r15+38h]
call my_context_continue
mov byte ptr [r15+14h], 0
test eax, eax
jle short loc_9D688
mov r15d, [r15]
jmp loc_9D6FE
loc_9D625:
mov dword ptr [rax+90h], 7DEh
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov byte ptr [rbx], 1
jmp short loc_9D6FE
loc_9D688:
mov byte ptr [r15+15h], 0
js short loc_9D695
mov al, [r15+8]
jmp short loc_9D6F9
loc_9D695:
mov rax, [r14+38h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov al, 1
loc_9D6F9:
mov [rbx], al
xor r15d, r15d
loc_9D6FE:
mov eax, r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mysql_stmt_reset_cont(char *a1, long long a2, unsigned int a3)
{
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
unsigned int v6; // r15d
char v7; // al
v3 = *(_QWORD *)(a2 + 56);
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
if ( *((_BYTE *)v4 + 21) )
{
*((_BYTE *)v4 + 20) = 1;
v4[1] = a3;
v5 = my_context_continue(v4 + 14);
*((_BYTE *)v4 + 20) = 0;
if ( v5 <= 0 )
{
*((_BYTE *)v4 + 21) = 0;
if ( v5 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
v7 = 1;
}
else
{
v7 = *((_BYTE *)v4 + 8);
}
*a1 = v7;
return 0;
}
else
{
return *v4;
}
}
else
{
*(_DWORD *)(v3 + 144) = 2014;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
v6 = 0;
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[14], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
*a1 = 1;
}
return v6;
}
| mysql_stmt_reset_cont:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x38]
MOV RCX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RCX + 0x28]
CMP byte ptr [R15 + 0x15],0x0
JZ 0x0019d625
MOV byte ptr [R15 + 0x14],0x1
MOV dword ptr [R15 + 0x4],EDX
LEA RDI,[R15 + 0x38]
CALL 0x0019e613
MOV byte ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x0019d688
MOV R15D,dword ptr [R15]
JMP 0x0019d6fe
LAB_0019d625:
MOV dword ptr [RAX + 0x90],0x7de
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x4a35c0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00139130
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x4a35d0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00139130
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV byte ptr [RBX],0x1
JMP 0x0019d6fe
LAB_0019d688:
MOV byte ptr [R15 + 0x15],0x0
JS 0x0019d695
MOV AL,byte ptr [R15 + 0x8]
JMP 0x0019d6f9
LAB_0019d695:
MOV RAX,qword ptr [R14 + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x4a35c0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00139130
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x4a35d0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00139130
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV AL,0x1
LAB_0019d6f9:
MOV byte ptr [RBX],AL
XOR R15D,R15D
LAB_0019d6fe:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_stmt_reset_cont(int1 *param_1,long param_2,int4 param_3)
{
int4 *puVar1;
int1 uVar2;
int iVar3;
int4 uVar4;
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
if (*(char *)((long)puVar1 + 0x15) == '\0') {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7de;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
uVar4 = 0;
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),
PTR_s_Commands_out_of_sync__you_can_t_r_004a3640,0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
*param_1 = 1;
}
else {
*(int1 *)(puVar1 + 5) = 1;
puVar1[1] = param_3;
iVar3 = my_context_continue(puVar1 + 0xe);
*(int1 *)(puVar1 + 5) = 0;
if (iVar3 < 1) {
*(int1 *)((long)puVar1 + 0x15) = 0;
if (iVar3 < 0) {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_004a3610,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
uVar2 = 1;
}
else {
uVar2 = *(int1 *)(puVar1 + 2);
}
*param_1 = uVar2;
uVar4 = 0;
}
else {
uVar4 = *puVar1;
}
}
return uVar4;
}
|
|
3,236 | stbi__zexpand(stbi__zbuf*, char*, int) | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes
{
char *q;
unsigned int cur, limit, old_limit;
z->zout = zout;
if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
cur = (unsigned int) (z->zout - z->zout_start);
limit = old_limit = (unsigned) (z->zout_end - z->zout_start);
if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");
while (cur + n > limit) {
if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");
limit *= 2;
}
q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
STBI_NOTUSED(old_limit);
if (q == NULL) return stbi__err("outofmem", "Out of memory");
z->zout_start = q;
z->zout = q + cur;
z->zout_end = q + limit;
return 1;
} | O1 | c | stbi__zexpand(stbi__zbuf*, char*, int):
movq %rsi, 0x18(%rdi)
cmpl $0x0, 0x30(%rdi)
je 0x2e1bb
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
subq %rdi, %r14
addl %r14d, %edx
jb 0x2e1fa
movl 0x28(%rbx), %eax
subl %edi, %eax
cmpl %eax, %edx
jbe 0x2e1ce
testl %eax, %eax
js 0x2e1fa
addl %eax, %eax
jmp 0x2e1af
leaq 0x8ea59(%rip), %rax # 0xbcc1b
movq %rax, %fs:-0x20
xorl %eax, %eax
retq
movl %eax, %r15d
movq %r15, %rsi
callq 0xaa40
testq %rax, %rax
je 0x2e1fa
movq %rax, 0x20(%rbx)
movl %r14d, %ecx
addq %rax, %rcx
movq %rcx, 0x18(%rbx)
addq %rax, %r15
movq %r15, 0x28(%rbx)
movl $0x1, %eax
jmp 0x2e20c
leaq 0x8e5e6(%rip), %rax # 0xbc7e7
movq %rax, %fs:-0x20
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
| _ZL13stbi__zexpandP10stbi__zbufPci:
mov [rdi+18h], rsi
cmp dword ptr [rdi+30h], 0
jz short loc_2E1BB
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov rdi, [rdi+20h]
sub r14, rdi
add edx, r14d
jb short loc_2E1FA
mov eax, [rbx+28h]
sub eax, edi
loc_2E1AF:
cmp edx, eax
jbe short loc_2E1CE
test eax, eax
js short loc_2E1FA
add eax, eax
jmp short loc_2E1AF
loc_2E1BB:
lea rax, aOutputBufferLi; "output buffer limit"
mov fs:0FFFFFFFFFFFFFFE0h, rax
xor eax, eax
retn
loc_2E1CE:
mov r15d, eax
mov rsi, r15
call _realloc
test rax, rax
jz short loc_2E1FA
mov [rbx+20h], rax
mov ecx, r14d
add rcx, rax
mov [rbx+18h], rcx
add r15, rax
mov [rbx+28h], r15
mov eax, 1
jmp short loc_2E20C
loc_2E1FA:
lea rax, aOutofmem; "outofmem"
mov fs:0FFFFFFFFFFFFFFE0h, rax
xor eax, eax
loc_2E20C:
pop rbx
pop r14
pop r15
retn
| long long stbi__zexpand(long long a1, long long a2, int a3)
{
long long v4; // rdi
bool v5; // cf
unsigned int v6; // edx
unsigned int i; // eax
long long v9; // r15
long long v10; // rax
*(_QWORD *)(a1 + 24) = a2;
if ( *(_DWORD *)(a1 + 48) )
{
v4 = *(_QWORD *)(a1 + 32);
v5 = __CFADD__(a2 - v4, a3);
v6 = a2 - v4 + a3;
if ( v5 )
goto LABEL_10;
for ( i = *(_DWORD *)(a1 + 40) - v4; v6 > i; i *= 2 )
{
if ( (i & 0x80000000) != 0 )
goto LABEL_10;
}
v9 = i;
v10 = realloc(v4, i);
if ( !v10 )
{
LABEL_10:
__writefsqword(0xFFFFFFE0, (unsigned long long)"outofmem");
return 0LL;
}
else
{
*(_QWORD *)(a1 + 32) = v10;
*(_QWORD *)(a1 + 24) = v10 + (unsigned int)(a2 - v4);
*(_QWORD *)(a1 + 40) = v10 + v9;
return 1LL;
}
}
else
{
__writefsqword(0xFFFFFFE0, (unsigned long long)"output buffer limit");
return 0LL;
}
}
| |||
3,237 | stbi__zexpand(stbi__zbuf*, char*, int) | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes
{
char *q;
unsigned int cur, limit, old_limit;
z->zout = zout;
if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
cur = (unsigned int) (z->zout - z->zout_start);
limit = old_limit = (unsigned) (z->zout_end - z->zout_start);
if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");
while (cur + n > limit) {
if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");
limit *= 2;
}
q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
STBI_NOTUSED(old_limit);
if (q == NULL) return stbi__err("outofmem", "Out of memory");
z->zout_start = q;
z->zout = q + cur;
z->zout_end = q + limit;
return 1;
} | O2 | c | stbi__zexpand(stbi__zbuf*, char*, int):
movq %rsi, 0x18(%rdi)
cmpl $0x0, 0x30(%rdi)
je 0x1981d
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
subq %rdi, %r14
addl %r14d, %edx
jae 0x19830
leaq 0x7ef1b(%rip), %rax # 0x98727
movq %rax, %fs:-0x20
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7f333(%rip), %rax # 0x98b57
movq %rax, %fs:-0x20
xorl %eax, %eax
retq
movl 0x28(%rbx), %eax
subl %edi, %eax
cmpl %eax, %edx
jbe 0x19841
testl %eax, %eax
js 0x19805
addl %eax, %eax
jmp 0x19835
movl %eax, %r15d
movq %r15, %rsi
callq 0xaa20
testq %rax, %rax
je 0x19805
movq %rax, 0x20(%rbx)
movl %r14d, %ecx
addq %rax, %rcx
movq %rcx, 0x18(%rbx)
addq %rax, %r15
movq %r15, 0x28(%rbx)
pushq $0x1
popq %rax
jmp 0x19817
| _ZL13stbi__zexpandP10stbi__zbufPci:
mov [rdi+18h], rsi
cmp dword ptr [rdi+30h], 0
jz short loc_1981D
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov rdi, [rdi+20h]
sub r14, rdi
add edx, r14d
jnb short loc_19830
loc_19805:
lea rax, aOutofmem; "outofmem"
mov fs:0FFFFFFFFFFFFFFE0h, rax
xor eax, eax
loc_19817:
pop rbx
pop r14
pop r15
retn
loc_1981D:
lea rax, aOutputBufferLi; "output buffer limit"
mov fs:0FFFFFFFFFFFFFFE0h, rax
xor eax, eax
retn
loc_19830:
mov eax, [rbx+28h]
sub eax, edi
loc_19835:
cmp edx, eax
jbe short loc_19841
test eax, eax
js short loc_19805
add eax, eax
jmp short loc_19835
loc_19841:
mov r15d, eax
mov rsi, r15
call _realloc
test rax, rax
jz short loc_19805
mov [rbx+20h], rax
mov ecx, r14d
add rcx, rax
mov [rbx+18h], rcx
add r15, rax
mov [rbx+28h], r15
push 1
pop rax
jmp short loc_19817
| long long stbi__zexpand(long long a1, long long a2, int a3)
{
long long v4; // rdi
bool v5; // cf
unsigned int v6; // edx
unsigned int i; // eax
long long v9; // r15
long long v10; // rax
*(_QWORD *)(a1 + 24) = a2;
if ( *(_DWORD *)(a1 + 48) )
{
v4 = *(_QWORD *)(a1 + 32);
v5 = __CFADD__(a2 - v4, a3);
v6 = a2 - v4 + a3;
if ( v5 )
goto LABEL_3;
for ( i = *(_DWORD *)(a1 + 40) - v4; v6 > i; i *= 2 )
{
if ( (i & 0x80000000) != 0 )
goto LABEL_3;
}
v9 = i;
v10 = realloc(v4, i);
if ( !v10 )
{
LABEL_3:
__writefsqword(0xFFFFFFE0, (unsigned long long)"outofmem");
return 0LL;
}
else
{
*(_QWORD *)(a1 + 32) = v10;
*(_QWORD *)(a1 + 24) = v10 + (unsigned int)(a2 - v4);
*(_QWORD *)(a1 + 40) = v10 + v9;
return 1LL;
}
}
else
{
__writefsqword(0xFFFFFFE0, (unsigned long long)"output buffer limit");
return 0LL;
}
}
| stbi__zexpand:
MOV qword ptr [RDI + 0x18],RSI
CMP dword ptr [RDI + 0x30],0x0
JZ 0x0011981d
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x20]
SUB R14,RDI
ADD EDX,R14D
JNC 0x00119830
LAB_00119805:
LEA RAX,[0x198727]
MOV qword ptr FS:[-0x20],RAX
XOR EAX,EAX
LAB_00119817:
POP RBX
POP R14
POP R15
RET
LAB_0011981d:
LEA RAX,[0x198b57]
MOV qword ptr FS:[-0x20],RAX
XOR EAX,EAX
RET
LAB_00119830:
MOV EAX,dword ptr [RBX + 0x28]
SUB EAX,EDI
LAB_00119835:
CMP EDX,EAX
JBE 0x00119841
TEST EAX,EAX
JS 0x00119805
ADD EAX,EAX
JMP 0x00119835
LAB_00119841:
MOV R15D,EAX
MOV RSI,R15
CALL 0x0010aa20
TEST RAX,RAX
JZ 0x00119805
MOV qword ptr [RBX + 0x20],RAX
MOV ECX,R14D
ADD RCX,RAX
MOV qword ptr [RBX + 0x18],RCX
ADD R15,RAX
MOV qword ptr [RBX + 0x28],R15
PUSH 0x1
POP RAX
JMP 0x00119817
|
/* stbi__zexpand(stbi__zbuf*, char*, int) */
int8 stbi__zexpand(stbi__zbuf *param_1,char *param_2,int param_3)
{
void *__ptr;
uint uVar1;
void *pvVar2;
uint uVar3;
long in_FS_OFFSET;
*(char **)(param_1 + 0x18) = param_2;
if (*(int *)(param_1 + 0x30) == 0) {
*(char **)(in_FS_OFFSET + -0x20) = "output buffer limit";
return 0;
}
__ptr = *(void **)(param_1 + 0x20);
uVar3 = (uint)((long)param_2 - (long)__ptr);
if (!CARRY4(param_3,uVar3)) {
for (uVar1 = *(int *)(param_1 + 0x28) - (int)__ptr; uVar1 < param_3 + uVar3; uVar1 = uVar1 * 2)
{
if ((int)uVar1 < 0) goto LAB_00119805;
}
pvVar2 = realloc(__ptr,(ulong)uVar1);
if (pvVar2 != (void *)0x0) {
*(void **)(param_1 + 0x20) = pvVar2;
*(ulong *)(param_1 + 0x18) = ((long)param_2 - (long)__ptr & 0xffffffffU) + (long)pvVar2;
*(ulong *)(param_1 + 0x28) = (ulong)uVar1 + (long)pvVar2;
return 1;
}
}
LAB_00119805:
*(char **)(in_FS_OFFSET + -0x20) = "outofmem";
return 0;
}
|
|
3,238 | stbi__zexpand(stbi__zbuf*, char*, int) | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes
{
char *q;
unsigned int cur, limit, old_limit;
z->zout = zout;
if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
cur = (unsigned int) (z->zout - z->zout_start);
limit = old_limit = (unsigned) (z->zout_end - z->zout_start);
if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");
while (cur + n > limit) {
if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");
limit *= 2;
}
q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
STBI_NOTUSED(old_limit);
if (q == NULL) return stbi__err("outofmem", "Out of memory");
z->zout_start = q;
z->zout = q + cur;
z->zout_end = q + limit;
return 1;
} | O3 | c | stbi__zexpand(stbi__zbuf*, char*, int):
movq %rsi, 0x18(%rdi)
cmpl $0x0, 0x30(%rdi)
je 0x2d419
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
subq %rdi, %r14
addl %r14d, %edx
jb 0x2d458
movl 0x28(%rbx), %eax
subl %edi, %eax
cmpl %eax, %edx
jbe 0x2d42c
testl %eax, %eax
js 0x2d458
addl %eax, %eax
jmp 0x2d40d
leaq 0x8e807(%rip), %rax # 0xbbc27
movq %rax, %fs:-0x20
xorl %eax, %eax
retq
movl %eax, %r15d
movq %r15, %rsi
callq 0xaa30
testq %rax, %rax
je 0x2d458
movq %rax, 0x20(%rbx)
movl %r14d, %ecx
addq %rax, %rcx
movq %rcx, 0x18(%rbx)
addq %rax, %r15
movq %r15, 0x28(%rbx)
movl $0x1, %eax
jmp 0x2d46a
leaq 0x8e398(%rip), %rax # 0xbb7f7
movq %rax, %fs:-0x20
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
| _ZL13stbi__zexpandP10stbi__zbufPci:
mov [rdi+18h], rsi
cmp dword ptr [rdi+30h], 0
jz short loc_2D419
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov rdi, [rdi+20h]
sub r14, rdi
add edx, r14d
jb short loc_2D458
mov eax, [rbx+28h]
sub eax, edi
loc_2D40D:
cmp edx, eax
jbe short loc_2D42C
test eax, eax
js short loc_2D458
add eax, eax
jmp short loc_2D40D
loc_2D419:
lea rax, aOutputBufferLi; "output buffer limit"
mov fs:0FFFFFFFFFFFFFFE0h, rax
xor eax, eax
retn
loc_2D42C:
mov r15d, eax
mov rsi, r15
call _realloc
test rax, rax
jz short loc_2D458
mov [rbx+20h], rax
mov ecx, r14d
add rcx, rax
mov [rbx+18h], rcx
add r15, rax
mov [rbx+28h], r15
mov eax, 1
jmp short loc_2D46A
loc_2D458:
lea rax, aOutofmem; "outofmem"
mov fs:0FFFFFFFFFFFFFFE0h, rax
xor eax, eax
loc_2D46A:
pop rbx
pop r14
pop r15
retn
| long long stbi__zexpand(long long a1, long long a2, int a3)
{
long long v4; // rdi
bool v5; // cf
unsigned int v6; // edx
unsigned int i; // eax
long long v9; // r15
long long v10; // rax
*(_QWORD *)(a1 + 24) = a2;
if ( *(_DWORD *)(a1 + 48) )
{
v4 = *(_QWORD *)(a1 + 32);
v5 = __CFADD__(a2 - v4, a3);
v6 = a2 - v4 + a3;
if ( v5 )
goto LABEL_10;
for ( i = *(_DWORD *)(a1 + 40) - v4; v6 > i; i *= 2 )
{
if ( (i & 0x80000000) != 0 )
goto LABEL_10;
}
v9 = i;
v10 = realloc(v4, i);
if ( !v10 )
{
LABEL_10:
__writefsqword(0xFFFFFFE0, (unsigned long long)"outofmem");
return 0LL;
}
else
{
*(_QWORD *)(a1 + 32) = v10;
*(_QWORD *)(a1 + 24) = v10 + (unsigned int)(a2 - v4);
*(_QWORD *)(a1 + 40) = v10 + v9;
return 1LL;
}
}
else
{
__writefsqword(0xFFFFFFE0, (unsigned long long)"output buffer limit");
return 0LL;
}
}
| |||
3,239 | b2d | eloqsql/strings/dtoa.c | static double b2d(Bigint *a, int *e)
{
ULong *xa, *xa0, w, y, z;
int k;
U d;
#define d0 word0(&d)
#define d1 word1(&d)
xa0= a->p.x;
xa= xa0 + a->wds;
y= *--xa;
k= hi0bits(y);
*e= 32 - k;
if (k < Ebits)
{
d0= Exp_1 | y >> (Ebits - k);
w= xa > xa0 ? *--xa : 0;
d1= y << ((32-Ebits) + k) | w >> (Ebits - k);
goto ret_d;
}
z= xa > xa0 ? *--xa : 0;
if (k-= Ebits)
{
d0= Exp_1 | y << k | z >> (32 - k);
y= xa > xa0 ? *--xa : 0;
d1= z << k | y >> (32 - k);
}
else
{
d0= Exp_1 | y;
d1= z;
}
ret_d:
#undef d0
#undef d1
return dval(&d);
} | O0 | c | b2d:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x14(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
movl -0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0xd53e0
movl %eax, -0x30(%rbp)
movl $0x20, %ecx
subl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpl $0xb, -0x30(%rbp)
jge 0xd557d
movl -0x28(%rbp), %eax
movl $0xb, %ecx
subl -0x30(%rbp), %ecx
shrl %cl, %eax
orl $0x3ff00000, %eax # imm = 0x3FF00000
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xd554c
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
movl -0x4(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0xd5553
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0xd5553
movl -0x3c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
movl -0x30(%rbp), %ecx
addl $0x15, %ecx
shll %cl, %eax
movl -0x24(%rbp), %edx
movl $0xb, %ecx
subl -0x30(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x38(%rbp)
jmp 0xd5639
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xd559e
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
movl -0x4(%rax), %eax
movl %eax, -0x40(%rbp)
jmp 0xd55a5
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0xd55a5
movl -0x40(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
subl $0xb, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
je 0xd5626
movl -0x28(%rbp), %eax
movl -0x30(%rbp), %ecx
shll %cl, %eax
orl $0x3ff00000, %eax # imm = 0x3FF00000
movl -0x2c(%rbp), %edx
movl $0x20, %ecx
subl -0x30(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xd55fb
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
movl -0x4(%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0xd5602
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0xd5602
movl -0x44(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
shll %cl, %eax
movl -0x28(%rbp), %edx
movl $0x20, %ecx
subl -0x30(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x38(%rbp)
jmp 0xd5637
movl -0x28(%rbp), %eax
orl $0x3ff00000, %eax # imm = 0x3FF00000
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0xd5639
movsd -0x38(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| b2d:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+14h]
shl rcx, 2
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rcx
mov eax, [rax-4]
mov [rbp+var_28], eax
mov edi, [rbp+var_28]
call hi0bits
mov [rbp+var_30], eax
mov ecx, 20h ; ' '
sub ecx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax], ecx
cmp [rbp+var_30], 0Bh
jge short loc_D557D
mov eax, [rbp+var_28]
mov ecx, 0Bh
sub ecx, [rbp+var_30]
shr eax, cl
or eax, 3FF00000h
mov dword ptr [rbp+var_38+4], eax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jbe short loc_D554C
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rcx
mov eax, [rax-4]
mov [rbp+var_3C], eax
jmp short loc_D5553
loc_D554C:
xor eax, eax
mov [rbp+var_3C], eax
jmp short $+2
loc_D5553:
mov eax, [rbp+var_3C]
mov [rbp+var_24], eax
mov eax, [rbp+var_28]
mov ecx, [rbp+var_30]
add ecx, 15h
shl eax, cl
mov edx, [rbp+var_24]
mov ecx, 0Bh
sub ecx, [rbp+var_30]
shr edx, cl
mov ecx, edx
or eax, ecx
mov dword ptr [rbp+var_38], eax
jmp loc_D5639
loc_D557D:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jbe short loc_D559E
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rcx
mov eax, [rax-4]
mov [rbp+var_40], eax
jmp short loc_D55A5
loc_D559E:
xor eax, eax
mov [rbp+var_40], eax
jmp short $+2
loc_D55A5:
mov eax, [rbp+var_40]
mov [rbp+var_2C], eax
mov eax, [rbp+var_30]
sub eax, 0Bh
mov [rbp+var_30], eax
cmp eax, 0
jz short loc_D5626
mov eax, [rbp+var_28]
mov ecx, [rbp+var_30]
shl eax, cl
or eax, 3FF00000h
mov edx, [rbp+var_2C]
mov ecx, 20h ; ' '
sub ecx, [rbp+var_30]
shr edx, cl
mov ecx, edx
or eax, ecx
mov dword ptr [rbp+var_38+4], eax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jbe short loc_D55FB
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rcx
mov eax, [rax-4]
mov [rbp+var_44], eax
jmp short loc_D5602
loc_D55FB:
xor eax, eax
mov [rbp+var_44], eax
jmp short $+2
loc_D5602:
mov eax, [rbp+var_44]
mov [rbp+var_28], eax
mov eax, [rbp+var_2C]
mov ecx, [rbp+var_30]
shl eax, cl
mov edx, [rbp+var_28]
mov ecx, 20h ; ' '
sub ecx, [rbp+var_30]
shr edx, cl
mov ecx, edx
or eax, ecx
mov dword ptr [rbp+var_38], eax
jmp short loc_D5637
loc_D5626:
mov eax, [rbp+var_28]
or eax, 3FF00000h
mov dword ptr [rbp+var_38+4], eax
mov eax, [rbp+var_2C]
mov dword ptr [rbp+var_38], eax
loc_D5637:
jmp short $+2
loc_D5639:
movsd xmm0, [rbp+var_38]
add rsp, 50h
pop rbp
retn
| double b2d(long long a1, _DWORD *a2)
{
int *v2; // rax
unsigned int v4; // [rsp+Ch] [rbp-44h]
unsigned int v5; // [rsp+10h] [rbp-40h]
unsigned int v6; // [rsp+14h] [rbp-3Ch]
long long v7; // [rsp+18h] [rbp-38h]
int v8; // [rsp+20h] [rbp-30h]
int v9; // [rsp+20h] [rbp-30h]
long long v10; // [rsp+24h] [rbp-2Ch]
unsigned long long v11; // [rsp+30h] [rbp-20h]
int *v12; // [rsp+38h] [rbp-18h]
v11 = *(_QWORD *)a1;
v12 = (int *)(4LL * *(int *)(a1 + 20) + *(_QWORD *)a1 - 4);
HIDWORD(v10) = *v12;
v8 = hi0bits(*v12);
*a2 = 32 - v8;
if ( v8 >= 11 )
{
if ( (unsigned long long)v12 <= v11 )
{
v5 = 0;
}
else
{
v2 = v12--;
v5 = *(v2 - 1);
}
LODWORD(v10) = v5;
v9 = v8 - 11;
if ( v9 )
{
HIDWORD(v7) = (v5 >> (32 - v9)) | (HIDWORD(v10) << v9) | 0x3FF00000;
if ( (unsigned long long)v12 <= v11 )
v4 = 0;
else
v4 = *(v12 - 1);
LODWORD(v7) = (v4 >> (32 - v9)) | (v5 << v9);
}
else
{
v7 = v10 | 0x3FF0000000000000LL;
}
}
else
{
HIDWORD(v7) = (HIDWORD(v10) >> (11 - v8)) | 0x3FF00000;
if ( (unsigned long long)v12 <= v11 )
v6 = 0;
else
v6 = *(v12 - 1);
LODWORD(v7) = (v6 >> (11 - v8)) | (HIDWORD(v10) << (v8 + 21));
}
return *(double *)&v7;
}
| b2d:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x14]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV dword ptr [RBP + -0x28],EAX
MOV EDI,dword ptr [RBP + -0x28]
CALL 0x001d53e0
MOV dword ptr [RBP + -0x30],EAX
MOV ECX,0x20
SUB ECX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
CMP dword ptr [RBP + -0x30],0xb
JGE 0x001d557d
MOV EAX,dword ptr [RBP + -0x28]
MOV ECX,0xb
SUB ECX,dword ptr [RBP + -0x30]
SHR EAX,CL
OR EAX,0x3ff00000
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001d554c
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x001d5553
LAB_001d554c:
XOR EAX,EAX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x001d5553
LAB_001d5553:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x30]
ADD ECX,0x15
SHL EAX,CL
MOV EDX,dword ptr [RBP + -0x24]
MOV ECX,0xb
SUB ECX,dword ptr [RBP + -0x30]
SHR EDX,CL
MOV ECX,EDX
OR EAX,ECX
MOV dword ptr [RBP + -0x38],EAX
JMP 0x001d5639
LAB_001d557d:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001d559e
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001d55a5
LAB_001d559e:
XOR EAX,EAX
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001d55a5
LAB_001d55a5:
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x30]
SUB EAX,0xb
MOV dword ptr [RBP + -0x30],EAX
CMP EAX,0x0
JZ 0x001d5626
MOV EAX,dword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x30]
SHL EAX,CL
OR EAX,0x3ff00000
MOV EDX,dword ptr [RBP + -0x2c]
MOV ECX,0x20
SUB ECX,dword ptr [RBP + -0x30]
SHR EDX,CL
MOV ECX,EDX
OR EAX,ECX
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001d55fb
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV dword ptr [RBP + -0x44],EAX
JMP 0x001d5602
LAB_001d55fb:
XOR EAX,EAX
MOV dword ptr [RBP + -0x44],EAX
JMP 0x001d5602
LAB_001d5602:
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,dword ptr [RBP + -0x30]
SHL EAX,CL
MOV EDX,dword ptr [RBP + -0x28]
MOV ECX,0x20
SUB ECX,dword ptr [RBP + -0x30]
SHR EDX,CL
MOV ECX,EDX
OR EAX,ECX
MOV dword ptr [RBP + -0x38],EAX
JMP 0x001d5637
LAB_001d5626:
MOV EAX,dword ptr [RBP + -0x28]
OR EAX,0x3ff00000
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x38],EAX
LAB_001d5637:
JMP 0x001d5639
LAB_001d5639:
MOVSD XMM0,qword ptr [RBP + -0x38]
ADD RSP,0x50
POP RBP
RET
|
int8 b2d(ulong *param_1,int *param_2)
{
uint uVar1;
ulong uVar2;
char cVar3;
int iVar4;
long lVar5;
byte bVar6;
int4 local_4c;
int4 local_48;
int4 local_44;
int4 local_40;
int4 uStack_3c;
int8 local_20;
uVar2 = *param_1;
lVar5 = uVar2 + (long)*(int *)((long)param_1 + 0x14) * 4;
local_20 = lVar5 - 4;
uVar1 = *(uint *)(lVar5 + -4);
iVar4 = hi0bits(uVar1);
*param_2 = 0x20 - iVar4;
if (iVar4 < 0xb) {
cVar3 = (char)iVar4;
uStack_3c = uVar1 >> (0xbU - cVar3 & 0x1f) | 0x3ff00000;
if (uVar2 < local_20) {
local_44 = *(uint *)(lVar5 + -8);
}
else {
local_44 = 0;
}
local_40 = uVar1 << (cVar3 + 0x15U & 0x1f) | local_44 >> (0xbU - cVar3 & 0x1f);
}
else {
if (uVar2 < local_20) {
local_20 = lVar5 - 8;
local_48 = *(uint *)(lVar5 + -8);
}
else {
local_48 = 0;
}
if (iVar4 + -0xb == 0) {
uStack_3c = uVar1 | 0x3ff00000;
local_40 = local_48;
}
else {
bVar6 = (byte)(iVar4 + -0xb);
uStack_3c = uVar1 << (bVar6 & 0x1f) | 0x3ff00000 | local_48 >> (0x20 - bVar6 & 0x1f);
if (uVar2 < local_20) {
local_4c = *(uint *)(local_20 - 4);
}
else {
local_4c = 0;
}
local_40 = local_48 << (bVar6 & 0x1f) | local_4c >> (0x20 - bVar6 & 0x1f);
}
}
return CONCAT44(uStack_3c,local_40);
}
|
|
3,240 | b2d | eloqsql/strings/dtoa.c | static double b2d(Bigint *a, int *e)
{
ULong *xa, *xa0, w, y, z;
int k;
U d;
#define d0 word0(&d)
#define d1 word1(&d)
xa0= a->p.x;
xa= xa0 + a->wds;
y= *--xa;
k= hi0bits(y);
*e= 32 - k;
if (k < Ebits)
{
d0= Exp_1 | y >> (Ebits - k);
w= xa > xa0 ? *--xa : 0;
d1= y << ((32-Ebits) + k) | w >> (Ebits - k);
goto ret_d;
}
z= xa > xa0 ? *--xa : 0;
if (k-= Ebits)
{
d0= Exp_1 | y << k | z >> (32 - k);
y= xa > xa0 ? *--xa : 0;
d1= z << k | y >> (32 - k);
}
else
{
d0= Exp_1 | y;
d1= z;
}
ret_d:
#undef d0
#undef d1
return dval(&d);
} | O3 | c | b2d:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
movslq %esi, %rax
leaq (%rdi,%rax,4), %r13
leaq (%rdi,%rax,4), %r12
addq $-0x4, %r12
movl (%r12), %ebx
movl %ebx, %edi
callq 0x90842
movl $0x20, %ecx
subl %eax, %ecx
movl %ecx, (%r15)
cmpl $0xa, %eax
ja 0x90910
movl $0xb, %edx
subl %eax, %edx
movl %ebx, %esi
movl %edx, %ecx
shrl %cl, %esi
xorl %edi, %edi
cmpq %r14, %r12
jbe 0x90903
movl -0x8(%r13), %edi
leal 0x15(%rax), %ecx
shll %cl, %ebx
movl %edx, %ecx
shrl %cl, %edi
orl %ebx, %edi
jmp 0x90957
xorl %edi, %edi
cmpq %r14, %r12
jbe 0x90922
movl -0x8(%r13), %edi
addq $-0x8, %r13
movq %r13, %r12
movl %eax, %edx
addl $-0xb, %edx
je 0x90955
movl %edx, %ecx
shll %cl, %ebx
movl $0x2b, %esi
subl %eax, %esi
movl %edi, %eax
movl %esi, %ecx
shrl %cl, %eax
xorl %r8d, %r8d
cmpq %r14, %r12
jbe 0x90947
movl -0x4(%r12), %r8d
movl %edx, %ecx
shll %cl, %edi
movl %esi, %ecx
shrl %cl, %r8d
orl %eax, %ebx
orl %r8d, %edi
movl %ebx, %esi
orl $0x3ff00000, %esi # imm = 0x3FF00000
shlq $0x20, %rsi
movl %edi, %eax
orq %rsi, %rax
movq %rax, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| b2d:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov r14, rdi
movsxd rax, esi
lea r13, [rdi+rax*4]
lea r12, [rdi+rax*4]
add r12, 0FFFFFFFFFFFFFFFCh
mov ebx, [r12]
mov edi, ebx
call hi0bits
mov ecx, 20h ; ' '
sub ecx, eax
mov [r15], ecx
cmp eax, 0Ah
ja short loc_90910
mov edx, 0Bh
sub edx, eax
mov esi, ebx
mov ecx, edx
shr esi, cl
xor edi, edi
cmp r12, r14
jbe short loc_90903
mov edi, [r13-8]
loc_90903:
lea ecx, [rax+15h]
shl ebx, cl
mov ecx, edx
shr edi, cl
or edi, ebx
jmp short loc_90957
loc_90910:
xor edi, edi
cmp r12, r14
jbe short loc_90922
mov edi, [r13-8]
add r13, 0FFFFFFFFFFFFFFF8h
mov r12, r13
loc_90922:
mov edx, eax
add edx, 0FFFFFFF5h
jz short loc_90955
mov ecx, edx
shl ebx, cl
mov esi, 2Bh ; '+'
sub esi, eax
mov eax, edi
mov ecx, esi
shr eax, cl
xor r8d, r8d
cmp r12, r14
jbe short loc_90947
mov r8d, [r12-4]
loc_90947:
mov ecx, edx
shl edi, cl
mov ecx, esi
shr r8d, cl
or ebx, eax
or edi, r8d
loc_90955:
mov esi, ebx
loc_90957:
or esi, 3FF00000h
shl rsi, 20h
mov eax, edi
or rax, rsi
movq xmm0, rax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| double b2d(unsigned long long a1, int a2, _DWORD *a3)
{
unsigned long long v5; // r13
unsigned long long v6; // r12
unsigned int v7; // ebx
unsigned int v8; // eax
unsigned int v9; // esi
unsigned int v10; // edi
unsigned int v11; // edi
char v12; // dl
unsigned int v13; // ebx
char v14; // si
unsigned int v15; // eax
unsigned int v16; // r8d
double result; // xmm0_8
v5 = a1 + 4LL * a2;
v6 = v5 - 4;
v7 = *(_DWORD *)(v5 - 4);
v8 = hi0bits(v7);
*a3 = 32 - v8;
if ( v8 > 0xA )
{
v11 = 0;
if ( v6 > a1 )
{
v11 = *(_DWORD *)(v5 - 8);
v6 = v5 - 8;
}
v12 = v8 - 11;
if ( v8 != 11 )
{
v13 = v7 << v12;
v14 = 43 - v8;
v15 = v11 >> (43 - v8);
v16 = 0;
if ( v6 > a1 )
v16 = *(_DWORD *)(v6 - 4);
v7 = v15 | v13;
v11 = (v16 >> v14) | (v11 << v12);
}
v9 = v7;
}
else
{
v9 = v7 >> (11 - v8);
v10 = 0;
if ( v6 > a1 )
v10 = *(_DWORD *)(v5 - 8);
v11 = (v7 << (v8 + 21)) | (v10 >> (11 - v8));
}
*(_QWORD *)&result = ((unsigned long long)(v9 | 0x3FF00000) << 32) | v11;
return result;
}
| b2d:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R14,RDI
MOVSXD RAX,ESI
LEA R13,[RDI + RAX*0x4]
LEA R12,[RDI + RAX*0x4]
ADD R12,-0x4
MOV EBX,dword ptr [R12]
MOV EDI,EBX
CALL 0x00190842
MOV ECX,0x20
SUB ECX,EAX
MOV dword ptr [R15],ECX
CMP EAX,0xa
JA 0x00190910
MOV EDX,0xb
SUB EDX,EAX
MOV ESI,EBX
MOV ECX,EDX
SHR ESI,CL
XOR EDI,EDI
CMP R12,R14
JBE 0x00190903
MOV EDI,dword ptr [R13 + -0x8]
LAB_00190903:
LEA ECX,[RAX + 0x15]
SHL EBX,CL
MOV ECX,EDX
SHR EDI,CL
OR EDI,EBX
JMP 0x00190957
LAB_00190910:
XOR EDI,EDI
CMP R12,R14
JBE 0x00190922
MOV EDI,dword ptr [R13 + -0x8]
ADD R13,-0x8
MOV R12,R13
LAB_00190922:
MOV EDX,EAX
ADD EDX,-0xb
JZ 0x00190955
MOV ECX,EDX
SHL EBX,CL
MOV ESI,0x2b
SUB ESI,EAX
MOV EAX,EDI
MOV ECX,ESI
SHR EAX,CL
XOR R8D,R8D
CMP R12,R14
JBE 0x00190947
MOV R8D,dword ptr [R12 + -0x4]
LAB_00190947:
MOV ECX,EDX
SHL EDI,CL
MOV ECX,ESI
SHR R8D,CL
OR EBX,EAX
OR EDI,R8D
LAB_00190955:
MOV ESI,EBX
LAB_00190957:
OR ESI,0x3ff00000
SHL RSI,0x20
MOV EAX,EDI
OR RAX,RSI
MOVQ XMM0,RAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong b2d(uint *param_1,int param_2,int *param_3)
{
char cVar1;
uint uVar2;
long lVar3;
byte bVar4;
uint uVar5;
uint uVar6;
uint *puVar7;
lVar3 = (long)param_2;
puVar7 = param_1 + lVar3 + -1;
uVar5 = *puVar7;
uVar2 = hi0bits(uVar5);
*param_3 = 0x20 - uVar2;
cVar1 = (char)uVar2;
if (uVar2 < 0xb) {
uVar2 = 0;
if (param_1 < puVar7) {
uVar2 = param_1[lVar3 + -2];
}
uVar6 = uVar2 >> (0xbU - cVar1 & 0x1f) | uVar5 << (cVar1 + 0x15U & 0x1f);
uVar5 = uVar5 >> (0xbU - cVar1 & 0x1f);
}
else {
uVar6 = 0;
if (param_1 < puVar7) {
uVar6 = param_1[lVar3 + -2];
puVar7 = param_1 + lVar3 + -2;
}
if (uVar2 - 0xb != 0) {
bVar4 = (byte)(uVar2 - 0xb);
uVar2 = 0;
if (param_1 < puVar7) {
uVar2 = puVar7[-1];
}
uVar5 = uVar5 << (bVar4 & 0x1f) | uVar6 >> (0x2bU - cVar1 & 0x1f);
uVar6 = uVar6 << (bVar4 & 0x1f) | uVar2 >> (0x2bU - cVar1 & 0x1f);
}
}
return CONCAT44(uVar5,uVar6) | 0x3ff0000000000000;
}
|
|
3,241 | rapidcsv::Document::WriteCsv(std::ostream&) const | Andrewchistyakov[P]flashcards_lyc/src/rapidcsv.h | void WriteCsv(std::ostream& pStream) const
{
for (auto itr = mData.begin(); itr != mData.end(); ++itr)
{
for (auto itc = itr->begin(); itc != itr->end(); ++itc)
{
if (mSeparatorParams.mAutoQuote &&
((itc->find(mSeparatorParams.mSeparator) != std::string::npos) ||
(itc->find(' ') != std::string::npos) ||
(itc->find('\n') != std::string::npos)))
{
// escape quotes in string
std::string str = *itc;
const std::string quoteCharStr = std::string(1, mSeparatorParams.mQuoteChar);
ReplaceString(str, quoteCharStr, quoteCharStr + quoteCharStr);
pStream << quoteCharStr << str << quoteCharStr;
}
else
{
pStream << *itc;
}
if (std::distance(itc, itr->end()) > 1)
{
pStream << mSeparatorParams.mSeparator;
}
}
pStream << (mSeparatorParams.mHasCR ? "\r\n" : "\n");
}
} | O1 | c | rapidcsv::Document::WriteCsv(std::ostream&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x8(%rsp)
movq 0x68(%rdi), %rax
cmpq 0x70(%rdi), %rax
je 0x1f236
movq %rdi, %r14
leaq 0x38(%rsp), %rbx
movq (%rax), %rbp
movq %rax, 0x10(%rsp)
cmpq 0x8(%rax), %rbp
je 0x1f1fc
movq %rbp, %r15
negq %r15
cmpb $0x1, 0x2c(%r14)
jne 0x1f1a5
movsbl 0x28(%r14), %esi
movq %rbp, %rdi
xorl %edx, %edx
callq 0xb540
cmpq $-0x1, %rax
jne 0x1f0b3
movq %rbp, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0xb540
cmpq $-0x1, %rax
jne 0x1f0b3
movq %rbp, %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0xb540
cmpq $-0x1, %rax
je 0x1f1a5
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x11e4e
movsbl 0x2d(%r14), %edx
leaq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x1, %esi
movq %rbx, %rdi
callq 0xb4b0
leaq 0x58(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x1e5eb
leaq 0x18(%rsp), %rdi
movq %rbx, %r12
movq %rbx, %rsi
movq %r13, %rdx
callq 0x1e582
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x1f130
movq 0x68(%rsp), %rsi
incq %rsi
callq 0xb400
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x8(%rsp), %rdi
callq 0xb490
movq %r12, %rbx
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rax, %rdi
callq 0xb490
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq %rax, %rdi
callq 0xb490
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x1f187
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xb400
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1f1b7
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb400
jmp 0x1f1b7
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq 0x8(%rsp), %rdi
callq 0xb490
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
addq %r15, %rax
cmpq $0x21, %rax
jl 0x1f1ea
movb 0x28(%r14), %al
movb %al, 0x18(%rsp)
movl $0x1, %edx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xb490
movq 0x10(%rsp), %rcx
addq $0x20, %rbp
addq $-0x20, %r15
cmpq 0x8(%rcx), %rbp
jne 0x1f065
movzbl 0x2a(%r14), %edx
testq %rdx, %rdx
leaq 0x1e9d5(%rip), %rsi # 0x3dbe0
leaq 0x1e9cd(%rip), %rax # 0x3dbdf
cmovneq %rax, %rsi
incq %rdx
movq 0x8(%rsp), %rdi
callq 0xb490
movq 0x10(%rsp), %rax
addq $0x18, %rax
cmpq 0x70(%r14), %rax
jne 0x1f04d
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1f28c
movq %rax, %rbx
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x1f270
movq 0x68(%rsp), %rsi
incq %rsi
callq 0xb400
jmp 0x1f270
jmp 0x1f26d
movq %rax, %rbx
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x1f28c
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xb400
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1f2a8
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb400
movq %rbx, %rdi
callq 0xb780
| _ZNK8rapidcsv8Document8WriteCsvERSo:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov [rsp+0A8h+var_A0], rsi
mov rax, [rdi+68h]
cmp rax, [rdi+70h]
jz loc_1F236
mov r14, rdi
lea rbx, [rsp+0A8h+var_70]
loc_1F04D:
mov rbp, [rax]
mov [rsp+0A8h+var_98], rax
cmp rbp, [rax+8]
jz loc_1F1FC
mov r15, rbp
neg r15
loc_1F065:
cmp byte ptr [r14+2Ch], 1
jnz loc_1F1A5
movsx esi, byte ptr [r14+28h]
mov rdi, rbp
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_1F0B3
mov rdi, rbp
mov esi, 20h ; ' '
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_1F0B3
mov rdi, rbp
mov esi, 0Ah
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_1F1A5
loc_1F0B3:
lea rax, [rsp+0A8h+var_80]
mov [rsp+0A8h+var_90], rax
mov rsi, [rbp+0]
mov rdx, [rbp+8]
add rdx, rsi
lea rdi, [rsp+0A8h+var_90]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
movsx edx, byte ptr [r14+2Dh]
lea rax, [rsp+0A8h+var_60]
mov [rsp+0A8h+var_70], rax
mov esi, 1
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
lea r13, [rsp+0A8h+var_50]
mov rdi, r13
mov rsi, rbx
mov rdx, rbx
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_SA_; std::operator+<char>(std::string const&,std::string const&)
lea rdi, [rsp+0A8h+var_90]
mov r12, rbx
mov rsi, rbx
mov rdx, r13
call _ZN8rapidcsv8Document13ReplaceStringERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS6_S9_; rapidcsv::Document::ReplaceString(std::string &,std::string const&,std::string const&)
mov rdi, [rsp+0A8h+var_50]; void *
lea rax, [rsp+0A8h+var_40]
cmp rdi, rax
jz short loc_1F130
mov rsi, [rsp+0A8h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F130:
mov rsi, [rsp+0A8h+var_70]
mov rdx, [rsp+0A8h+var_68]
mov rdi, [rsp+0A8h+var_A0]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, r12
mov rsi, [rsp+0A8h+var_90]
mov rdx, [rsp+0A8h+var_88]
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rsp+0A8h+var_70]
mov rdx, [rsp+0A8h+var_68]
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+0A8h+var_70]; void *
lea rax, [rsp+0A8h+var_60]
cmp rdi, rax
jz short loc_1F187
mov rsi, [rsp+0A8h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F187:
mov rdi, [rsp+0A8h+var_90]; void *
lea rax, [rsp+0A8h+var_80]
cmp rdi, rax
jz short loc_1F1B7
mov rsi, [rsp+0A8h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1F1B7
loc_1F1A5:
mov rsi, [rbp+0]
mov rdx, [rbp+8]
mov rdi, [rsp+0A8h+var_A0]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_1F1B7:
mov rcx, [rsp+0A8h+var_98]
mov rax, [rcx+8]
add rax, r15
cmp rax, 21h ; '!'
jl short loc_1F1EA
mov al, [r14+28h]
mov byte ptr [rsp+0A8h+var_90], al
mov edx, 1
mov rdi, [rsp+0A8h+var_A0]
lea rsi, [rsp+0A8h+var_90]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rcx, [rsp+0A8h+var_98]
loc_1F1EA:
add rbp, 20h ; ' '
add r15, 0FFFFFFFFFFFFFFE0h
cmp rbp, [rcx+8]
jnz loc_1F065
loc_1F1FC:
movzx edx, byte ptr [r14+2Ah]
test rdx, rdx
lea rsi, asc_3DBDF+1; "\n"
lea rax, asc_3DBDF; "\r\n"
cmovnz rsi, rax
inc rdx
mov rdi, [rsp+0A8h+var_A0]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, [rsp+0A8h+var_98]
add rax, 18h
cmp rax, [r14+70h]
jnz loc_1F04D
loc_1F236:
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
jmp short loc_1F28C
mov rbx, rax
mov rdi, [rsp+arg_50]; void *
lea rax, [rsp+arg_60]
cmp rdi, rax
jz short loc_1F270
mov rsi, [rsp+arg_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1F270
jmp short $+2
loc_1F26D:
mov rbx, rax
loc_1F270:
mov rdi, [rsp+arg_30]; void *
lea rax, [rsp+arg_40]
cmp rdi, rax
jz short loc_1F28C
mov rsi, [rsp+arg_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F28C:
mov rdi, [rsp+arg_10]; void *
lea rax, [rsp+arg_20]
cmp rdi, rax
jz short loc_1F2A8
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F2A8:
mov rdi, rbx
call __Unwind_Resume
| long long * rapidcsv::Document::WriteCsv(rapidcsv::Document *this, std::ostream *a2)
{
long long *result; // rax
long long v3; // rbp
long long v4; // r15
long long v5; // rdx
long long v6; // rax
long long v7; // rax
long long *v8; // rcx
char *v9; // rsi
long long *v11; // [rsp+10h] [rbp-98h]
void *v12[2]; // [rsp+18h] [rbp-90h] BYREF
_QWORD v13[2]; // [rsp+28h] [rbp-80h] BYREF
void *v14; // [rsp+38h] [rbp-70h] BYREF
long long v15; // [rsp+40h] [rbp-68h]
_QWORD v16[2]; // [rsp+48h] [rbp-60h] BYREF
void *v17[2]; // [rsp+58h] [rbp-50h] BYREF
long long v18; // [rsp+68h] [rbp-40h] BYREF
result = (long long *)*((_QWORD *)this + 13);
if ( result != *((long long **)this + 14) )
{
do
{
v3 = *result;
v11 = result;
if ( *result != result[1] )
{
v4 = -v3;
do
{
if ( *((_BYTE *)this + 44) != 1
|| std::string::find(v3, (unsigned int)*((char *)this + 40), 0LL) == -1
&& std::string::find(v3, 32LL, 0LL) == -1
&& std::string::find(v3, 10LL, 0LL) == -1 )
{
std::__ostream_insert<char,std::char_traits<char>>(a2, *(_QWORD *)v3, *(_QWORD *)(v3 + 8));
}
else
{
v12[0] = v13;
std::string::_M_construct<char *>(v12, *(_BYTE **)v3, *(_QWORD *)v3 + *(_QWORD *)(v3 + 8));
v5 = (unsigned int)*((char *)this + 45);
v14 = v16;
std::string::_M_construct(&v14, 1LL, v5);
std::operator+<char>(v17, (long long)&v14, &v14);
rapidcsv::Document::ReplaceString((long long)v12, &v14, (long long)v17);
if ( v17[0] != &v18 )
operator delete(v17[0], v18 + 1);
v6 = std::__ostream_insert<char,std::char_traits<char>>(a2, v14, v15);
v7 = std::__ostream_insert<char,std::char_traits<char>>(v6, v12[0], v12[1]);
std::__ostream_insert<char,std::char_traits<char>>(v7, v14, v15);
if ( v14 != v16 )
operator delete(v14, v16[0] + 1LL);
if ( v12[0] != v13 )
operator delete(v12[0], v13[0] + 1LL);
}
v8 = v11;
if ( v4 + v11[1] >= 33 )
{
LOBYTE(v12[0]) = *((_BYTE *)this + 40);
std::__ostream_insert<char,std::char_traits<char>>(a2, v12, 1LL);
v8 = v11;
}
v3 += 32LL;
v4 -= 32LL;
}
while ( v3 != v8[1] );
}
v9 = "\n";
if ( *((_BYTE *)this + 42) )
v9 = "\r\n";
std::__ostream_insert<char,std::char_traits<char>>(a2, v9, *((unsigned __int8 *)this + 42) + 1LL);
result = v11 + 3;
}
while ( v11 + 3 != *((long long **)this + 14) );
}
return result;
}
| WriteCsv:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RSP + 0x8],RSI
MOV RAX,qword ptr [RDI + 0x68]
CMP RAX,qword ptr [RDI + 0x70]
JZ 0x0011f236
MOV R14,RDI
LEA RBX,[RSP + 0x38]
LAB_0011f04d:
MOV RBP,qword ptr [RAX]
MOV qword ptr [RSP + 0x10],RAX
CMP RBP,qword ptr [RAX + 0x8]
JZ 0x0011f1fc
MOV R15,RBP
NEG R15
LAB_0011f065:
CMP byte ptr [R14 + 0x2c],0x1
JNZ 0x0011f1a5
MOVSX ESI,byte ptr [R14 + 0x28]
MOV RDI,RBP
XOR EDX,EDX
CALL 0x0010b540
CMP RAX,-0x1
JNZ 0x0011f0b3
MOV RDI,RBP
MOV ESI,0x20
XOR EDX,EDX
CALL 0x0010b540
CMP RAX,-0x1
JNZ 0x0011f0b3
MOV RDI,RBP
MOV ESI,0xa
XOR EDX,EDX
CALL 0x0010b540
CMP RAX,-0x1
JZ 0x0011f1a5
LAB_0011f0b3:
LEA RAX,[RSP + 0x28]
MOV qword ptr [RSP + 0x18],RAX
MOV RSI,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
ADD RDX,RSI
LEA RDI,[RSP + 0x18]
CALL 0x00111e4e
MOVSX EDX,byte ptr [R14 + 0x2d]
LEA RAX,[RSP + 0x48]
MOV qword ptr [RSP + 0x38],RAX
LAB_0011f0e1:
MOV ESI,0x1
MOV RDI,RBX
CALL 0x0010b4b0
LAB_0011f0ee:
LEA R13,[RSP + 0x58]
MOV RDI,R13
MOV RSI,RBX
MOV RDX,RBX
CALL 0x0011e5eb
LAB_0011f101:
LEA RDI,[RSP + 0x18]
MOV R12,RBX
MOV RSI,RBX
MOV RDX,R13
CALL 0x0011e582
MOV RDI,qword ptr [RSP + 0x58]
LEA RAX,[RSP + 0x68]
CMP RDI,RAX
JZ 0x0011f130
MOV RSI,qword ptr [RSP + 0x68]
INC RSI
CALL 0x0010b400
LAB_0011f130:
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
LAB_0011f13a:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0010b490
MOV RBX,R12
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
MOV RDI,RAX
CALL 0x0010b490
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
MOV RDI,RAX
CALL 0x0010b490
LAB_0011f16b:
MOV RDI,qword ptr [RSP + 0x38]
LEA RAX,[RSP + 0x48]
CMP RDI,RAX
JZ 0x0011f187
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x0010b400
LAB_0011f187:
MOV RDI,qword ptr [RSP + 0x18]
LEA RAX,[RSP + 0x28]
CMP RDI,RAX
JZ 0x0011f1b7
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x0010b400
JMP 0x0011f1b7
LAB_0011f1a5:
MOV RSI,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0010b490
LAB_0011f1b7:
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RCX + 0x8]
ADD RAX,R15
CMP RAX,0x21
JL 0x0011f1ea
MOV AL,byte ptr [R14 + 0x28]
MOV byte ptr [RSP + 0x18],AL
MOV EDX,0x1
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x18]
CALL 0x0010b490
MOV RCX,qword ptr [RSP + 0x10]
LAB_0011f1ea:
ADD RBP,0x20
ADD R15,-0x20
CMP RBP,qword ptr [RCX + 0x8]
JNZ 0x0011f065
LAB_0011f1fc:
MOVZX EDX,byte ptr [R14 + 0x2a]
TEST RDX,RDX
LEA RSI,[0x13dbe0]
LEA RAX,[0x13dbdf]
CMOVNZ RSI,RAX
INC RDX
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0010b490
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,0x18
CMP RAX,qword ptr [R14 + 0x70]
JNZ 0x0011f04d
LAB_0011f236:
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* rapidcsv::Document::WriteCsv(std::ostream&) const */
void __thiscall rapidcsv::Document::WriteCsv(Document *this,ostream *param_1)
{
long *plVar1;
long lVar2;
ostream *poVar3;
long *plVar4;
char *pcVar5;
char cVar6;
long lVar7;
long *local_90;
long local_88;
long local_80 [2];
long *local_70;
long local_68;
long local_60 [2];
long *local_50 [2];
long local_40 [2];
plVar1 = *(long **)(this + 0x68);
if (plVar1 != *(long **)(this + 0x70)) {
do {
plVar4 = (long *)*plVar1;
if (plVar4 != (long *)plVar1[1]) {
lVar7 = -(long)plVar4;
do {
if (this[0x2c] == (Document)0x1) {
cVar6 = (char)plVar4;
lVar2 = std::__cxx11::string::find(cVar6,(ulong)(uint)(int)(char)this[0x28]);
if (lVar2 == -1) {
lVar2 = std::__cxx11::string::find(cVar6,0x20);
if (lVar2 == -1) {
lVar2 = std::__cxx11::string::find(cVar6,10);
if (lVar2 == -1) goto LAB_0011f1a5;
}
}
local_90 = local_80;
std::__cxx11::string::_M_construct<char*>(&local_90,*plVar4,plVar4[1] + *plVar4);
local_70 = local_60;
/* try { // try from 0011f0e1 to 0011f0ed has its CatchHandler @ 0011f245 */
std::__cxx11::string::_M_construct((ulong)&local_70,'\x01');
/* try { // try from 0011f0ee to 0011f100 has its CatchHandler @ 0011f26b */
std::operator+((string *)local_50,(string *)&local_70);
/* try { // try from 0011f101 to 0011f113 has its CatchHandler @ 0011f24a */
ReplaceString((string *)&local_90,(string *)&local_70,(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
/* try { // try from 0011f13a to 0011f16a has its CatchHandler @ 0011f26d */
poVar3 = std::__ostream_insert<char,std::char_traits<char>>
(param_1,(char *)local_70,local_68);
poVar3 = std::__ostream_insert<char,std::char_traits<char>>
(poVar3,(char *)local_90,local_88);
std::__ostream_insert<char,std::char_traits<char>>(poVar3,(char *)local_70,local_68);
if (local_70 != local_60) {
operator_delete(local_70,local_60[0] + 1);
}
if (local_90 != local_80) {
operator_delete(local_90,local_80[0] + 1);
}
}
else {
LAB_0011f1a5:
std::__ostream_insert<char,std::char_traits<char>>(param_1,(char *)*plVar4,plVar4[1]);
}
if (0x20 < plVar1[1] + lVar7) {
local_90 = (long *)CONCAT71(local_90._1_7_,this[0x28]);
std::__ostream_insert<char,std::char_traits<char>>(param_1,(char *)&local_90,1);
}
plVar4 = plVar4 + 4;
lVar7 = lVar7 + -0x20;
} while (plVar4 != (long *)plVar1[1]);
}
pcVar5 = "\n";
if ((ulong)(byte)this[0x2a] != 0) {
pcVar5 = "\r\n";
}
std::__ostream_insert<char,std::char_traits<char>>(param_1,pcVar5,(ulong)(byte)this[0x2a] + 1)
;
plVar1 = plVar1 + 3;
} while (plVar1 != *(long **)(this + 0x70));
}
return;
}
|
|
3,242 | native_password_auth_client | eloqsql/libmariadb/plugins/auth/my_auth.c | static int native_password_auth_client(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql)
{
int pkt_len;
uchar *pkt;
if (((MCPVIO_EXT *)vio)->mysql_change_user)
{
/*
in mysql_change_user() the client sends the first packet.
we use the old scramble.
*/
pkt= (uchar*)mysql->scramble_buff;
pkt_len= SCRAMBLE_LENGTH + 1;
}
else
{
/* read the scramble */
if ((pkt_len= vio->read_packet(vio, &pkt)) < 0)
return CR_ERROR;
if (pkt_len != SCRAMBLE_LENGTH + 1)
return CR_SERVER_HANDSHAKE_ERR;
/* save it in MYSQL */
memmove(mysql->scramble_buff, pkt, SCRAMBLE_LENGTH);
mysql->scramble_buff[SCRAMBLE_LENGTH] = 0;
}
if (mysql && mysql->passwd[0])
{
char scrambled[SCRAMBLE_LENGTH + 1];
memset(scrambled, 0, SCRAMBLE_LENGTH + 1);
ma_scramble_41((uchar *)scrambled, (char*)pkt, mysql->passwd);
if (vio->write_packet(vio, (uchar*)scrambled, SCRAMBLE_LENGTH))
return CR_ERROR;
}
else
if (vio->write_packet(vio, 0, 0)) /* no password */
return CR_ERROR;
return CR_OK;
} | O3 | c | native_password_auth_client:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
cmpb $0x0, 0x48(%rdi)
je 0x5c86c
leaq 0x48e(%r14), %rax
movq %rax, -0x48(%rbp)
testq %r14, %r14
jne 0x5c8a5
jmp 0x5c8e7
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq *(%rbx)
testl %eax, %eax
js 0x5c8e2
movl $0x7dc, %r15d # imm = 0x7DC
cmpl $0x15, %eax
jne 0x5c8fe
movq -0x48(%rbp), %rax
movups (%rax), %xmm0
movl 0x10(%rax), %eax
movl %eax, 0x49e(%r14)
movups %xmm0, 0x48e(%r14)
movb $0x0, 0x4a2(%r14)
movq 0x2c0(%r14), %rdx
cmpb $0x0, (%rdx)
je 0x5c8e7
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0xd(%r14)
movq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x61482
movq %rbx, %rdi
movq %r14, %rsi
movl $0x14, %edx
callq *0x8(%rbx)
testl %eax, %eax
je 0x5c8f8
xorl %r15d, %r15d
jmp 0x5c8fe
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *0x8(%rbx)
testl %eax, %eax
jne 0x5c8fe
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x5c91b
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x372b0
| native_password_auth_client:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 38h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
cmp byte ptr [rdi+48h], 0
jz short loc_5C86C
lea rax, [r14+48Eh]
mov [rbp+var_48], rax
test r14, r14
jnz short loc_5C8A5
jmp short loc_5C8E7
loc_5C86C:
lea rsi, [rbp+var_48]
mov rdi, rbx
call qword ptr [rbx]
test eax, eax
js short loc_5C8E2
mov r15d, 7DCh
cmp eax, 15h
jnz short loc_5C8FE
mov rax, [rbp+var_48]
movups xmm0, xmmword ptr [rax]
mov eax, [rax+10h]
mov [r14+49Eh], eax
movups xmmword ptr [r14+48Eh], xmm0
mov byte ptr [r14+4A2h], 0
loc_5C8A5:
mov rdx, [r14+2C0h]
cmp byte ptr [rdx], 0
jz short loc_5C8E7
xorps xmm0, xmm0
lea r14, [rbp+var_40]
movaps xmmword ptr [r14], xmm0
mov qword ptr [r14+0Dh], 0
mov rsi, [rbp+var_48]
mov rdi, r14
call ma_scramble_41
mov rdi, rbx
mov rsi, r14
mov edx, 14h
call qword ptr [rbx+8]
test eax, eax
jz short loc_5C8F8
loc_5C8E2:
xor r15d, r15d
jmp short loc_5C8FE
loc_5C8E7:
xor r15d, r15d
mov rdi, rbx
xor esi, esi
xor edx, edx
call qword ptr [rbx+8]
test eax, eax
jnz short loc_5C8FE
loc_5C8F8:
mov r15d, 0FFFFFFFFh
loc_5C8FE:
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_5C91B
mov eax, r15d
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_5C91B:
call ___stack_chk_fail
| long long native_password_auth_client(long long a1, long long a2)
{
int v2; // eax
unsigned int v3; // r15d
__int128 v4; // xmm0
__int128 *v6; // [rsp+8h] [rbp-48h] BYREF
_BYTE v7[32]; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v8; // [rsp+30h] [rbp-20h]
v8 = __readfsqword(0x28u);
if ( !*(_BYTE *)(a1 + 72) )
{
v2 = (*(long long ( **)(long long, __int128 **))a1)(a1, &v6);
if ( v2 < 0 )
return 0;
v3 = 2012;
if ( v2 != 21 )
return v3;
v4 = *v6;
*(_DWORD *)(a2 + 1182) = *((_DWORD *)v6 + 4);
*(_OWORD *)(a2 + 1166) = v4;
*(_BYTE *)(a2 + 1186) = 0;
LABEL_7:
if ( !**(_BYTE **)(a2 + 704) )
goto LABEL_10;
memset(v7, 0, 21);
ma_scramble_41(v7, v6);
if ( !(*(unsigned int ( **)(long long, _BYTE *, long long))(a1 + 8))(a1, v7, 20LL) )
return (unsigned int)-1;
return 0;
}
v6 = (__int128 *)(a2 + 1166);
if ( a2 )
goto LABEL_7;
LABEL_10:
v3 = 0;
if ( !(*(unsigned int ( **)(long long, _QWORD, _QWORD))(a1 + 8))(a1, 0LL, 0LL) )
return (unsigned int)-1;
return v3;
}
| native_password_auth_client:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
CMP byte ptr [RDI + 0x48],0x0
JZ 0x0015c86c
LEA RAX,[R14 + 0x48e]
MOV qword ptr [RBP + -0x48],RAX
TEST R14,R14
JNZ 0x0015c8a5
JMP 0x0015c8e7
LAB_0015c86c:
LEA RSI,[RBP + -0x48]
MOV RDI,RBX
CALL qword ptr [RBX]
TEST EAX,EAX
JS 0x0015c8e2
MOV R15D,0x7dc
CMP EAX,0x15
JNZ 0x0015c8fe
MOV RAX,qword ptr [RBP + -0x48]
MOVUPS XMM0,xmmword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [R14 + 0x49e],EAX
MOVUPS xmmword ptr [R14 + 0x48e],XMM0
MOV byte ptr [R14 + 0x4a2],0x0
LAB_0015c8a5:
MOV RDX,qword ptr [R14 + 0x2c0]
CMP byte ptr [RDX],0x0
JZ 0x0015c8e7
XORPS XMM0,XMM0
LEA R14,[RBP + -0x40]
MOVAPS xmmword ptr [R14],XMM0
MOV qword ptr [R14 + 0xd],0x0
MOV RSI,qword ptr [RBP + -0x48]
MOV RDI,R14
CALL 0x00161482
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x14
CALL qword ptr [RBX + 0x8]
TEST EAX,EAX
JZ 0x0015c8f8
LAB_0015c8e2:
XOR R15D,R15D
JMP 0x0015c8fe
LAB_0015c8e7:
XOR R15D,R15D
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL qword ptr [RBX + 0x8]
TEST EAX,EAX
JNZ 0x0015c8fe
LAB_0015c8f8:
MOV R15D,0xffffffff
LAB_0015c8fe:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0015c91b
MOV EAX,R15D
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0015c91b:
CALL 0x001372b0
|
int8 native_password_auth_client(int8 *param_1,long param_2)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int iVar5;
int8 uVar6;
long in_FS_OFFSET;
int4 *local_50;
int8 local_48;
int5 uStack_40;
int3 uStack_3b;
int5 uStack_38;
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
if (*(char *)(param_1 + 9) == '\0') {
iVar5 = (*(code *)*param_1)(param_1,&local_50);
if (-1 < iVar5) {
uVar6 = 0x7dc;
if (iVar5 != 0x15) goto LAB_0015c8fe;
uVar1 = *local_50;
uVar2 = local_50[1];
uVar3 = local_50[2];
uVar4 = local_50[3];
*(int4 *)(param_2 + 0x49e) = local_50[4];
*(int4 *)(param_2 + 0x48e) = uVar1;
*(int4 *)(param_2 + 0x492) = uVar2;
*(int4 *)(param_2 + 0x496) = uVar3;
*(int4 *)(param_2 + 0x49a) = uVar4;
*(int1 *)(param_2 + 0x4a2) = 0;
goto LAB_0015c8a5;
}
LAB_0015c8e2:
uVar6 = 0;
goto LAB_0015c8fe;
}
local_50 = (int4 *)(param_2 + 0x48e);
if (param_2 == 0) {
LAB_0015c8e7:
uVar6 = 0;
iVar5 = (*(code *)param_1[1])(param_1,0,0);
if (iVar5 != 0) goto LAB_0015c8fe;
}
else {
LAB_0015c8a5:
if (**(char **)(param_2 + 0x2c0) == '\0') goto LAB_0015c8e7;
local_48 = 0;
uStack_40 = 0;
uStack_3b = 0;
uStack_38 = 0;
ma_scramble_41(&local_48,local_50);
iVar5 = (*(code *)param_1[1])(param_1,&local_48,0x14);
if (iVar5 != 0) goto LAB_0015c8e2;
}
uVar6 = 0xffffffff;
LAB_0015c8fe:
if (*(long *)(in_FS_OFFSET + 0x28) != local_28) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar6;
}
|
|
3,243 | mi_find_writepos | eloqsql/storage/myisam/mi_dynrec.c | static int _mi_find_writepos(MI_INFO *info,
ulong reclength, /* record length */
my_off_t *filepos, /* Return file pos */
ulong *length) /* length of block at filepos */
{
MI_BLOCK_INFO block_info;
ulong tmp;
DBUG_ENTER("_mi_find_writepos");
if (info->s->state.dellink != HA_OFFSET_ERROR &&
!info->append_insert_at_end)
{
/* Deleted blocks exists; Get last used block */
*filepos=info->s->state.dellink;
block_info.second_read=0;
info->rec_cache.seek_not_done=1;
if (!(_mi_get_block_info(&block_info,info->dfile,info->s->state.dellink) &
BLOCK_DELETED))
{
DBUG_PRINT("error",("Delete link crashed"));
my_errno=HA_ERR_WRONG_IN_RECORD;
DBUG_RETURN(-1);
}
info->s->state.dellink=block_info.next_filepos;
info->state->del--;
info->state->empty-= block_info.block_len;
*length= block_info.block_len;
}
else
{
/* No deleted blocks; Allocate a new block */
*filepos=info->state->data_file_length;
if ((tmp= reclength + 3 + MY_TEST(reclength >= (65520 - 3))) <
info->s->base.min_block_length)
tmp= info->s->base.min_block_length;
else
tmp= ((tmp+MI_DYN_ALIGN_SIZE-1) &
(~ (ulong) (MI_DYN_ALIGN_SIZE-1)));
if (info->state->data_file_length >
(info->s->base.max_data_file_length - tmp))
{
my_errno=HA_ERR_RECORD_FILE_FULL;
DBUG_RETURN(-1);
}
if (tmp > MI_MAX_BLOCK_LENGTH)
tmp=MI_MAX_BLOCK_LENGTH;
*length= tmp;
info->state->data_file_length+= tmp;
info->s->state.split++;
info->update|=HA_STATE_WRITE_AT_END;
}
DBUG_RETURN(0);
} | O0 | c | mi_find_writepos:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq %rdx, -0x80(%rbp)
movq %rcx, -0x88(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rax
cmpq $-0x1, 0x58(%rax)
je 0x38ec3
movq -0x70(%rbp), %rax
cmpb $0x0, 0x33a(%rax)
jne 0x38ec3
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rcx
movq -0x80(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x10(%rbp)
movq -0x70(%rbp), %rax
movl $0x1, 0x300(%rax)
movq -0x70(%rbp), %rax
movl 0x1c0(%rax), %esi
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rdx
leaq -0x60(%rbp), %rdi
callq 0x35fb0
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x38e76
jmp 0x38e5d
jmp 0x38e5f
callq 0x8d620
movl $0x7f, (%rax)
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
jmp 0x38fed
movq -0x20(%rbp), %rcx
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x58(%rax)
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rdx
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, (%rax)
jmp 0x38fe4
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rcx
movq -0x80(%rbp), %rax
movq %rcx, (%rax)
movq -0x78(%rbp), %rax
addq $0x3, %rax
movq -0x78(%rbp), %rsi
xorl %ecx, %ecx
movl $0x1, %edx
cmpq $0xffed, %rsi # imm = 0xFFED
cmovael %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x90(%rbp)
movq -0x70(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x160(%rcx), %rax
jae 0x38f27
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x160(%rax), %rax
movq %rax, -0x90(%rbp)
jmp 0x38f41
movq -0x90(%rbp), %rax
addq $0x4, %rax
subq $0x1, %rax
andq $-0x4, %rax
movq %rax, -0x90(%rbp)
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x70(%rbp), %rcx
movq (%rcx), %rcx
movq 0x110(%rcx), %rcx
subq -0x90(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x38f7b
callq 0x8d620
movl $0x87, (%rax)
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
jmp 0x38fed
cmpq $0xfffffc, -0x90(%rbp) # imm = 0xFFFFFC
jbe 0x38f93
movq $0xfffffc, -0x90(%rbp) # imm = 0xFFFFFC
movq -0x90(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, (%rax)
movq -0x90(%rbp), %rcx
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
movq -0x70(%rbp), %rax
movl 0x1d0(%rax), %ecx
orl $0x100, %ecx # imm = 0x100
movl %ecx, 0x1d0(%rax)
jmp 0x38fe6
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x94(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x39017
movl -0x94(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
callq 0x29420
nopl (%rax)
| _mi_find_writepos:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_70], rdi
mov [rbp+var_78], rsi
mov [rbp+var_80], rdx
mov [rbp+var_88], rcx
mov rax, [rbp+var_70]
mov rax, [rax]
cmp qword ptr [rax+58h], 0FFFFFFFFFFFFFFFFh
jz loc_38EC3
mov rax, [rbp+var_70]
cmp byte ptr [rax+33Ah], 0
jnz loc_38EC3
mov rax, [rbp+var_70]
mov rax, [rax]
mov rcx, [rax+58h]
mov rax, [rbp+var_80]
mov [rax], rcx
mov [rbp+var_10], 0
mov rax, [rbp+var_70]
mov dword ptr [rax+300h], 1
mov rax, [rbp+var_70]
mov esi, [rax+1C0h]
mov rax, [rbp+var_70]
mov rax, [rax]
mov rdx, [rax+58h]
lea rdi, [rbp+var_60]
call _mi_get_block_info
and eax, 4
cmp eax, 0
jnz short loc_38E76
jmp short $+2
loc_38E5D:
jmp short $+2
loc_38E5F:
call _my_thread_var
mov dword ptr [rax], 7Fh
mov [rbp+var_64], 0FFFFFFFFh
jmp loc_38FED
loc_38E76:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_70]
mov rax, [rax]
mov [rax+58h], rcx
mov rax, [rbp+var_70]
mov rax, [rax+8]
mov rcx, [rax+8]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+8], rcx
mov rdx, [rbp+var_38]
mov rax, [rbp+var_70]
mov rax, [rax+8]
mov rcx, [rax+10h]
sub rcx, rdx
mov [rax+10h], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_88]
mov [rax], rcx
jmp loc_38FE4
loc_38EC3:
mov rax, [rbp+var_70]
mov rax, [rax+8]
mov rcx, [rax+28h]
mov rax, [rbp+var_80]
mov [rax], rcx
mov rax, [rbp+var_78]
add rax, 3
mov rsi, [rbp+var_78]
xor ecx, ecx
mov edx, 1
cmp rsi, 0FFEDh
cmovnb ecx, edx
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_90], rax
mov rcx, [rbp+var_70]
mov rcx, [rcx]
cmp rax, [rcx+160h]
jnb short loc_38F27
mov rax, [rbp+var_70]
mov rax, [rax]
mov rax, [rax+160h]
mov [rbp+var_90], rax
jmp short loc_38F41
loc_38F27:
mov rax, [rbp+var_90]
add rax, 4
sub rax, 1
and rax, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_90], rax
loc_38F41:
mov rax, [rbp+var_70]
mov rax, [rax+8]
mov rax, [rax+28h]
mov rcx, [rbp+var_70]
mov rcx, [rcx]
mov rcx, [rcx+110h]
sub rcx, [rbp+var_90]
cmp rax, rcx
jbe short loc_38F7B
call _my_thread_var
mov dword ptr [rax], 87h
mov [rbp+var_64], 0FFFFFFFFh
jmp short loc_38FED
loc_38F7B:
cmp [rbp+var_90], 0FFFFFCh
jbe short loc_38F93
mov [rbp+var_90], 0FFFFFCh
loc_38F93:
mov rcx, [rbp+var_90]
mov rax, [rbp+var_88]
mov [rax], rcx
mov rcx, [rbp+var_90]
mov rax, [rbp+var_70]
mov rax, [rax+8]
add rcx, [rax+28h]
mov [rax+28h], rcx
mov rax, [rbp+var_70]
mov rax, [rax]
mov rcx, [rax+50h]
add rcx, 1
mov [rax+50h], rcx
mov rax, [rbp+var_70]
mov ecx, [rax+1D0h]
or ecx, 100h
mov [rax+1D0h], ecx
loc_38FE4:
jmp short $+2
loc_38FE6:
mov [rbp+var_64], 0
loc_38FED:
mov eax, [rbp+var_64]
mov [rbp+var_94], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_39017
mov eax, [rbp+var_94]
add rsp, 0A0h
pop rbp
retn
loc_39017:
call ___stack_chk_fail
| long long mi_find_writepos(_QWORD *a1, const char *a2, _QWORD *a3, unsigned long long *a4)
{
const char *v4; // rsi
unsigned long long v6; // [rsp+10h] [rbp-90h]
unsigned long long v7; // [rsp+10h] [rbp-90h]
char v10[40]; // [rsp+40h] [rbp-60h] BYREF
unsigned long long v11; // [rsp+68h] [rbp-38h]
long long v12; // [rsp+80h] [rbp-20h]
int v13; // [rsp+90h] [rbp-10h]
unsigned long long v14; // [rsp+98h] [rbp-8h]
v14 = __readfsqword(0x28u);
if ( *(_QWORD *)(*a1 + 88LL) == -1LL || *((_BYTE *)a1 + 826) )
{
*a3 = *(_QWORD *)(a1[1] + 40LL);
v6 = (unsigned long long)&a2[((unsigned long long)a2 >= 0xFFED) + 3];
if ( v6 >= *(_QWORD *)(*a1 + 352LL) )
v7 = (v6 + 3) & 0xFFFFFFFFFFFFFFFCLL;
else
v7 = *(_QWORD *)(*a1 + 352LL);
if ( *(_QWORD *)(a1[1] + 40LL) > *(_QWORD *)(*a1 + 272LL) - v7 )
{
*(_DWORD *)my_thread_var(a1, a2) = 135;
return (unsigned int)-1;
}
if ( v7 > 0xFFFFFC )
v7 = 16777212LL;
*a4 = v7;
*(_QWORD *)(a1[1] + 40LL) += v7;
++*(_QWORD *)(*a1 + 80LL);
*((_DWORD *)a1 + 116) |= 0x100u;
return 0;
}
*a3 = *(_QWORD *)(*a1 + 88LL);
v13 = 0;
*((_DWORD *)a1 + 192) = 1;
v4 = (const char *)*((unsigned int *)a1 + 112);
if ( (mi_get_block_info(v10, v4, *(_QWORD *)(*a1 + 88LL)) & 4) != 0 )
{
*(_QWORD *)(*a1 + 88LL) = v12;
--*(_QWORD *)(a1[1] + 8LL);
*(_QWORD *)(a1[1] + 16LL) -= v11;
*a4 = v11;
return 0;
}
*(_DWORD *)my_thread_var(v10, v4) = 127;
return (unsigned int)-1;
}
| _mi_find_writepos:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x78],RSI
MOV qword ptr [RBP + -0x80],RDX
MOV qword ptr [RBP + -0x88],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x58],-0x1
JZ 0x00138ec3
MOV RAX,qword ptr [RBP + -0x70]
CMP byte ptr [RAX + 0x33a],0x0
JNZ 0x00138ec3
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x58]
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x70]
MOV dword ptr [RAX + 0x300],0x1
MOV RAX,qword ptr [RBP + -0x70]
MOV ESI,dword ptr [RAX + 0x1c0]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x58]
LEA RDI,[RBP + -0x60]
CALL 0x00135fb0
AND EAX,0x4
CMP EAX,0x0
JNZ 0x00138e76
JMP 0x00138e5d
LAB_00138e5d:
JMP 0x00138e5f
LAB_00138e5f:
CALL 0x0018d620
MOV dword ptr [RAX],0x7f
MOV dword ptr [RBP + -0x64],0xffffffff
JMP 0x00138fed
LAB_00138e76:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x58],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX + 0x8]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x8],RCX
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,RDX
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RAX],RCX
JMP 0x00138fe4
LAB_00138ec3:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x3
MOV RSI,qword ptr [RBP + -0x78]
XOR ECX,ECX
MOV EDX,0x1
CMP RSI,0xffed
CMOVNC ECX,EDX
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x90],RAX
MOV RCX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RCX]
CMP RAX,qword ptr [RCX + 0x160]
JNC 0x00138f27
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x160]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x00138f41
LAB_00138f27:
MOV RAX,qword ptr [RBP + -0x90]
ADD RAX,0x4
SUB RAX,0x1
AND RAX,-0x4
MOV qword ptr [RBP + -0x90],RAX
LAB_00138f41:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x110]
SUB RCX,qword ptr [RBP + -0x90]
CMP RAX,RCX
JBE 0x00138f7b
CALL 0x0018d620
MOV dword ptr [RAX],0x87
MOV dword ptr [RBP + -0x64],0xffffffff
JMP 0x00138fed
LAB_00138f7b:
CMP qword ptr [RBP + -0x90],0xfffffc
JBE 0x00138f93
MOV qword ptr [RBP + -0x90],0xfffffc
LAB_00138f93:
MOV RCX,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x8]
ADD RCX,qword ptr [RAX + 0x28]
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x50]
ADD RCX,0x1
MOV qword ptr [RAX + 0x50],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,dword ptr [RAX + 0x1d0]
OR ECX,0x100
MOV dword ptr [RAX + 0x1d0],ECX
LAB_00138fe4:
JMP 0x00138fe6
LAB_00138fe6:
MOV dword ptr [RBP + -0x64],0x0
LAB_00138fed:
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0x94],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00139017
MOV EAX,dword ptr [RBP + -0x94]
ADD RSP,0xa0
POP RBP
RET
LAB_00139017:
CALL 0x00129420
|
int4 _mi_find_writepos(long *param_1,ulong param_2,int8 *param_3,ulong *param_4)
{
uint uVar1;
int4 *puVar2;
ulong uVar3;
long in_FS_OFFSET;
ulong local_98;
int4 local_6c;
int1 local_68 [40];
ulong local_40;
int8 local_28;
int4 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if ((*(long *)(*param_1 + 0x58) == -1) || (*(char *)((long)param_1 + 0x33a) != '\0')) {
*param_3 = *(int8 *)(param_1[1] + 0x28);
uVar3 = param_2 + 3 + (long)(int)(uint)(0xffec < param_2);
if (uVar3 < *(ulong *)(*param_1 + 0x160)) {
local_98 = *(ulong *)(*param_1 + 0x160);
}
else {
local_98 = uVar3 + 3 & 0xfffffffffffffffc;
}
if (*(long *)(*param_1 + 0x110) - local_98 < *(ulong *)(param_1[1] + 0x28)) {
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x87;
local_6c = 0xffffffff;
goto LAB_00138fed;
}
if (0xfffffc < local_98) {
local_98 = 0xfffffc;
}
*param_4 = local_98;
*(ulong *)(param_1[1] + 0x28) = local_98 + *(long *)(param_1[1] + 0x28);
*(long *)(*param_1 + 0x50) = *(long *)(*param_1 + 0x50) + 1;
*(uint *)(param_1 + 0x3a) = *(uint *)(param_1 + 0x3a) | 0x100;
}
else {
*param_3 = *(int8 *)(*param_1 + 0x58);
local_18 = 0;
*(int4 *)(param_1 + 0x60) = 1;
uVar1 = _mi_get_block_info(local_68,(int)param_1[0x38],*(int8 *)(*param_1 + 0x58));
if ((uVar1 & 4) == 0) {
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x7f;
local_6c = 0xffffffff;
goto LAB_00138fed;
}
*(int8 *)(*param_1 + 0x58) = local_28;
*(long *)(param_1[1] + 8) = *(long *)(param_1[1] + 8) + -1;
*(ulong *)(param_1[1] + 0x10) = *(long *)(param_1[1] + 0x10) - local_40;
*param_4 = local_40;
}
local_6c = 0;
LAB_00138fed:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_6c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
3,244 | void testing::internal::PrintWithFallback<int>(int const&, std::ostream*) | AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/gtest-printers.h | void PrintWithFallback(const T& value, ::std::ostream* os) {
using Printer = typename FindFirstPrinter<
T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter,
ProtobufPrinter,
#ifdef GTEST_HAS_ABSL
ConvertibleToAbslStringifyPrinter,
#endif // GTEST_HAS_ABSL
internal_stream_operator_without_lexical_name_lookup::StreamPrinter,
ConvertibleToIntegerPrinter, ConvertibleToStringViewPrinter,
RawBytesPrinter, FallbackPrinter>::type;
Printer::PrintValue(value, os);
} | O0 | c | void testing::internal::PrintWithFallback<int>(int const&, std::ostream*):
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11020
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN7testing8internal17PrintWithFallbackIiEEvRKT_PSo:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rdi, [rsp+18h+var_8]
mov rsi, [rsp+18h+var_10]
call _ZN7testing8internal52internal_stream_operator_without_lexical_name_lookup13StreamPrinter10PrintValueIivEEDTcvvlsdefp0_fp_ERKT_PSo
add rsp, 18h
retn
| long long testing::internal::PrintWithFallback<int>(long long a1, long long a2)
{
return testing::internal::internal_stream_operator_without_lexical_name_lookup::StreamPrinter::PrintValue<int,void>(
a1,
a2);
}
| PrintWithFallback<int>:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x00111020
ADD RSP,0x18
RET
|
/* void testing::internal::PrintWithFallback<int>(int const&, std::ostream*) */
void testing::internal::PrintWithFallback<int>(int *param_1,ostream *param_2)
{
((void)((*{parm#2})<<{parm#1}))testing::internal::
internal_stream_operator_without_lexical_name_lookup::StreamPrinter::PrintValue<int,void>
(param_1,param_2);
return;
}
|
|
3,245 | ftxui::(anonymous namespace)::CapturedMouseImpl::~CapturedMouseImpl() | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/component/screen_interactive.cpp | ~CapturedMouseImpl() override { callback_(); } | O3 | cpp | ftxui::(anonymous namespace)::CapturedMouseImpl::~CapturedMouseImpl():
pushq %r14
pushq %rbx
pushq %rax
leaq 0x27d19(%rip), %rax # 0x58478
movq %rax, (%rdi)
cmpq $0x0, 0x18(%rdi)
je 0x30795
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x3078d
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xb140
jmp 0x3079c
movq %rax, %rdi
callq 0x1049a
| _ZN5ftxui12_GLOBAL__N_117CapturedMouseImplD2Ev:
push r14
push rbx
push rax
lea rax, off_58478
mov [rdi], rax
cmp qword ptr [rdi+18h], 0
jz short loc_30795
mov r14, rdi
lea rbx, [rdi+8]
mov rdi, rbx
call qword ptr [r14+20h]
mov rax, [r14+18h]
test rax, rax
jz short loc_3078D
mov rdi, rbx
mov rsi, rbx
mov edx, 3
call rax
loc_3078D:
add rsp, 8
pop rbx
pop r14
retn
loc_30795:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
jmp short $+2
loc_3079C:
mov rdi, rax
call __clang_call_terminate
| void ftxui::`anonymous namespace'::CapturedMouseImpl::~CapturedMouseImpl(
ftxui::_anonymous_namespace_::CapturedMouseImpl *this)
{
void ( *v1)(char *, char *, long long); // rax
*(_QWORD *)this = off_58478;
if ( !*((_QWORD *)this + 3) )
std::__throw_bad_function_call();
(*((void ( **)(char *))this + 4))((char *)this + 8);
v1 = (void ( *)(char *, char *, long long))*((_QWORD *)this + 3);
if ( v1 )
v1((char *)this + 8, (char *)this + 8, 3LL);
}
| ~CapturedMouseImpl:
PUSH R14
PUSH RBX
PUSH RAX
LEA RAX,[0x158478]
MOV qword ptr [RDI],RAX
CMP qword ptr [RDI + 0x18],0x0
JZ 0x00130795
MOV R14,RDI
LEA RBX,[RDI + 0x8]
LAB_00130770:
MOV RDI,RBX
CALL qword ptr [R14 + 0x20]
MOV RAX,qword ptr [R14 + 0x18]
TEST RAX,RAX
JZ 0x0013078d
LAB_00130780:
MOV RDI,RBX
MOV RSI,RBX
MOV EDX,0x3
CALL RAX
LAB_0013078d:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00130795:
CALL 0x0010b140
|
/* ftxui::(anonymous namespace)::CapturedMouseImpl::~CapturedMouseImpl() */
void __thiscall
ftxui::(anonymous_namespace)::CapturedMouseImpl::~CapturedMouseImpl(CapturedMouseImpl *this)
{
CapturedMouseImpl *pCVar1;
*(int ***)this = &PTR__CapturedMouseImpl_00158478;
if (*(long *)(this + 0x18) != 0) {
pCVar1 = this + 8;
/* try { // try from 00130770 to 00130776 has its CatchHandler @ 0013079c */
(**(code **)(this + 0x20))(pCVar1);
if (*(code **)(this + 0x18) != (code *)0x0) {
/* try { // try from 00130780 to 0013078c has its CatchHandler @ 0013079a */
(**(code **)(this + 0x18))(pCVar1,pCVar1,3);
}
return;
}
/* WARNING: Subroutine does not return */
/* try { // try from 00130795 to 00130799 has its CatchHandler @ 0013079c */
std::__throw_bad_function_call();
}
|
|
3,246 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++() | llama.cpp/common/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++():
movq (%rdi), %rax
testq %rax, %rax
je 0xb3c43
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0xb3c34
cmpl $0x1, %eax
jne 0xb3c3b
addq $0x30, 0x8(%rdi)
jmp 0xb3c3f
addq $0x10, 0x10(%rdi)
jmp 0xb3c3f
incq 0x18(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x69135(%rip), %rdi # 0x11cd80
leaq 0x61559(%rip), %rdx # 0x1151ab
leaq 0x6f34f(%rip), %rcx # 0x122fa8
movl $0x33c0, %esi # imm = 0x33C0
xorl %eax, %eax
callq 0x20ed0
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
mov rax, [rdi]
test rax, rax
jz short loc_B3C43
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_B3C34
cmp eax, 1
jnz short loc_B3C3B
add qword ptr [rdi+8], 30h ; '0'
jmp short loc_B3C3F
loc_B3C34:
add qword ptr [rdi+10h], 10h
jmp short loc_B3C3F
loc_B3C3B:
inc qword ptr [rdi+18h]
loc_B3C3F:
mov rax, rdi
retn
loc_B3C43:
push rax
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 33C0h
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(
unsigned __int8 **a1)
{
int v1; // eax
long long v3; // rdx
if ( *a1 )
{
v1 = **a1;
if ( v1 == 2 )
{
a1[2] += 16;
}
else if ( v1 == 1 )
{
a1[1] += 48;
}
else
{
++a1[3];
}
return (long long)a1;
}
else
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
13248LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
return std::operator+<char>("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp", 13248LL, v3);
}
}
| operator++:
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001b3c43
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x001b3c34
CMP EAX,0x1
JNZ 0x001b3c3b
ADD qword ptr [RDI + 0x8],0x30
JMP 0x001b3c3f
LAB_001b3c34:
ADD qword ptr [RDI + 0x10],0x10
JMP 0x001b3c3f
LAB_001b3c3b:
INC qword ptr [RDI + 0x18]
LAB_001b3c3f:
MOV RAX,RDI
RET
LAB_001b3c43:
PUSH RAX
LEA RDI,[0x21cd80]
LEA RDX,[0x2151ab]
LEA RCX,[0x222fa8]
MOV ESI,0x33c0
XOR EAX,EAX
CALL 0x00120ed0
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>::TEMPNAMEPLACEHOLDERVALUE() */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*this)
{
char cVar1;
int8 in_R8;
int8 in_R9;
if (*(char **)this != (char *)0x0) {
cVar1 = **(char **)this;
if (cVar1 == '\x02') {
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 0x10;
}
else if (cVar1 == '\x01') {
*(long *)(this + 8) = *(long *)(this + 8) + 0x30;
}
else {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 1;
}
return this;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x33c0,
"GGML_ASSERT(%s) failed","m_object != nullptr",in_R8,in_R9,0);
}
|
|
3,247 | my_strdup | eloqsql/mysys/my_malloc.c | char *my_strdup(PSI_memory_key key, const char *from, myf my_flags)
{
char *ptr;
size_t length= strlen(from)+1;
DBUG_ENTER("my_strdup");
if ((ptr= (char*) my_malloc(key, length, my_flags)))
memcpy(ptr, from, length);
DBUG_RETURN(ptr);
} | O0 | c | my_strdup:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a350
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf3830
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xf3cff
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2a090
jmp 0xf3d01
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_strdup:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_10]
call _strlen
add rax, 1
mov [rbp+var_28], rax
mov edi, [rbp+var_4]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_18]
call my_malloc
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_F3CFF
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_28]
call _memcpy
loc_F3CFF:
jmp short $+2
loc_F3D01:
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
add rsp, 30h
pop rbp
retn
| long long my_strdup(unsigned int a1, long long a2, int a3)
{
const char *v4; // [rsp+8h] [rbp-28h]
long long v5; // [rsp+10h] [rbp-20h]
v4 = (const char *)(strlen(a2) + 1);
v5 = my_malloc(a1, v4, a3);
if ( v5 )
memcpy(v5, a2, v4);
return v5;
}
| my_strdup:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0012a350
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001f3830
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x001f3cff
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x0012a090
LAB_001f3cff:
JMP 0x001f3d01
LAB_001f3d01:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x30
POP RBP
RET
|
void * my_strdup(int4 param_1,char *param_2,int8 param_3)
{
size_t sVar1;
void *__dest;
sVar1 = strlen(param_2);
__dest = (void *)my_malloc(param_1,sVar1 + 1,param_3);
if (__dest != (void *)0x0) {
memcpy(__dest,param_2,sVar1 + 1);
}
return __dest;
}
|
|
3,248 | js_ecvt | bluesky950520[P]quickjs/quickjs.c | static int js_ecvt(double d, int n_digits,
char dest[minimum_length(JS_ECVT_BUF_SIZE)],
size_t size, int *decpt)
{
if (n_digits == 0) {
/* find the minimum number of digits (XXX: inefficient but simple) */
// TODO(chqrlie) use direct method from quickjs-printf
unsigned int n_digits_min = 1;
unsigned int n_digits_max = 17;
for (;;) {
n_digits = (n_digits_min + n_digits_max) / 2;
js_ecvt1(d, n_digits, dest, size, decpt);
if (n_digits_min == n_digits_max)
return n_digits;
/* dest contents:
0: first digit
1: '.' decimal point (locale specific)
2..n_digits: (n_digits-1) additional digits
n_digits+1: 'e' exponent mark
n_digits+2..: exponent sign, value and null terminator
*/
if (strtod(dest, NULL) == d) {
unsigned int n0 = n_digits;
/* enough digits */
/* strip the trailing zeros */
while (dest[n_digits] == '0')
n_digits--;
if (n_digits == n_digits_min)
return n_digits;
/* done if trailing zeros and not denormal or huge */
if (n_digits < n0 && d > 3e-308 && d < 8e307)
return n_digits;
n_digits_max = n_digits;
} else {
/* need at least one more digit */
n_digits_min = n_digits + 1;
}
}
} else {
#if defined(FE_DOWNWARD) && defined(FE_TONEAREST)
int i;
/* generate 2 extra digits: 99% chances to avoid 2 calls */
js_ecvt1(d, n_digits + 2, dest, size, decpt);
if (dest[n_digits + 1] < '5')
return n_digits; /* truncate the 2 extra digits */
if (dest[n_digits + 1] == '5' && dest[n_digits + 2] == '0') {
/* close to half-way: try rounding toward 0 */
fesetround(FE_DOWNWARD);
js_ecvt1(d, n_digits + 2, dest, size, decpt);
fesetround(FE_TONEAREST);
if (dest[n_digits + 1] < '5')
return n_digits; /* truncate the 2 extra digits */
}
/* round up in the string */
for(i = n_digits;; i--) {
/* ignore the locale specific decimal point */
if (is_digit(dest[i])) {
if (dest[i]++ < '9')
break;
dest[i] = '0';
if (i == 0) {
dest[0] = '1';
(*decpt)++;
break;
}
}
}
return n_digits; /* truncate the 2 extra digits */
#else
/* No disambiguation available, eg: __wasi__ targets */
return js_ecvt1(d, n_digits, dest, size, decpt);
#endif
}
} | O0 | c | js_ecvt:
subq $0x48, %rsp
movsd %xmm0, 0x38(%rsp)
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpl $0x0, 0x34(%rsp)
jne 0x689df
movl $0x1, 0x14(%rsp)
movl $0x11, 0x10(%rsp)
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
shrl %eax
movl %eax, 0x34(%rsp)
movsd 0x38(%rsp), %xmm0
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x68b40
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jne 0x6892b
movl 0x34(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x68b34
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe1a0
ucomisd 0x38(%rsp), %xmm0
jne 0x689cf
jp 0x689cf
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movslq 0x34(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jne 0x68973
movl 0x34(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x68953
movl 0x34(%rsp), %eax
cmpl 0x14(%rsp), %eax
jne 0x6898a
movl 0x34(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x68b34
movl 0x34(%rsp), %eax
cmpl 0xc(%rsp), %eax
jae 0x689c5
movsd 0x38(%rsp), %xmm0
movsd 0xab11e(%rip), %xmm1 # 0x113ac0
ucomisd %xmm1, %xmm0
jbe 0x689c5
movsd 0xab118(%rip), %xmm0 # 0x113ac8
ucomisd 0x38(%rsp), %xmm0
jbe 0x689c5
movl 0x34(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x68b34
movl 0x34(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x689da
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x688e8
movsd 0x38(%rsp), %xmm0
movl 0x34(%rsp), %edi
addl $0x2, %edi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x68b40
movq 0x28(%rsp), %rax
movl 0x34(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x35, %eax
jge 0x68a25
movl 0x34(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x68b34
movq 0x28(%rsp), %rax
movl 0x34(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x35, %eax
jne 0x68aae
movq 0x28(%rsp), %rax
movl 0x34(%rsp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jne 0x68aae
movl $0x400, %edi # imm = 0x400
callq 0xe030
movsd 0x38(%rsp), %xmm0
movl 0x34(%rsp), %edi
addl $0x2, %edi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x68b40
xorl %edi, %edi
callq 0xe030
movq 0x28(%rsp), %rax
movl 0x34(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x35, %eax
jge 0x68aac
movl 0x34(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x68b34
jmp 0x68aae
movl 0x34(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movslq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x2e3e0
cmpl $0x0, %eax
je 0x68b1d
movq 0x28(%rsp), %rcx
movslq 0x8(%rsp), %rdx
movb (%rcx,%rdx), %al
movb %al, %sil
addb $0x1, %sil
movb %sil, (%rcx,%rdx)
movzbl %al, %eax
cmpl $0x39, %eax
jge 0x68af0
jmp 0x68b2c
movq 0x28(%rsp), %rax
movslq 0x8(%rsp), %rcx
movb $0x30, (%rax,%rcx)
cmpl $0x0, 0x8(%rsp)
jne 0x68b1b
movq 0x28(%rsp), %rax
movb $0x31, (%rax)
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x68b2c
jmp 0x68b1d
jmp 0x68b1f
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x68ab6
movl 0x34(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
| js_ecvt:
sub rsp, 48h
movsd [rsp+48h+var_10], xmm0
mov [rsp+48h+var_14], edi
mov [rsp+48h+var_20], rsi
mov [rsp+48h+var_28], rdx
mov [rsp+48h+var_30], rcx
cmp [rsp+48h+var_14], 0
jnz loc_689DF
mov [rsp+48h+var_34], 1
mov [rsp+48h+var_38], 11h
loc_688E8:
mov eax, [rsp+48h+var_34]
add eax, [rsp+48h+var_38]
shr eax, 1
mov [rsp+48h+var_14], eax
movsd xmm0, [rsp+48h+var_10]
mov edi, [rsp+48h+var_14]
mov rsi, [rsp+48h+var_20]
mov rdx, [rsp+48h+var_28]
mov rcx, [rsp+48h+var_30]
call js_ecvt1
mov eax, [rsp+48h+var_34]
cmp eax, [rsp+48h+var_38]
jnz short loc_6892B
mov eax, [rsp+48h+var_14]
mov [rsp+48h+var_4], eax
jmp loc_68B34
loc_6892B:
mov rdi, [rsp+48h+var_20]
xor eax, eax
mov esi, eax
call _strtod
ucomisd xmm0, [rsp+48h+var_10]
jnz loc_689CF
jp loc_689CF
mov eax, [rsp+48h+var_14]
mov [rsp+48h+var_3C], eax
loc_68953:
mov rax, [rsp+48h+var_20]
movsxd rcx, [rsp+48h+var_14]
movzx eax, byte ptr [rax+rcx]
cmp eax, 30h ; '0'
jnz short loc_68973
mov eax, [rsp+48h+var_14]
add eax, 0FFFFFFFFh
mov [rsp+48h+var_14], eax
jmp short loc_68953
loc_68973:
mov eax, [rsp+48h+var_14]
cmp eax, [rsp+48h+var_34]
jnz short loc_6898A
mov eax, [rsp+48h+var_14]
mov [rsp+48h+var_4], eax
jmp loc_68B34
loc_6898A:
mov eax, [rsp+48h+var_14]
cmp eax, [rsp+48h+var_3C]
jnb short loc_689C5
movsd xmm0, [rsp+48h+var_10]
movsd xmm1, cs:qword_113AC0
ucomisd xmm0, xmm1
jbe short loc_689C5
movsd xmm0, cs:qword_113AC8
ucomisd xmm0, [rsp+48h+var_10]
jbe short loc_689C5
mov eax, [rsp+48h+var_14]
mov [rsp+48h+var_4], eax
jmp loc_68B34
loc_689C5:
mov eax, [rsp+48h+var_14]
mov [rsp+48h+var_38], eax
jmp short loc_689DA
loc_689CF:
mov eax, [rsp+48h+var_14]
add eax, 1
mov [rsp+48h+var_34], eax
loc_689DA:
jmp loc_688E8
loc_689DF:
movsd xmm0, [rsp+48h+var_10]
mov edi, [rsp+48h+var_14]
add edi, 2
mov rsi, [rsp+48h+var_20]
mov rdx, [rsp+48h+var_28]
mov rcx, [rsp+48h+var_30]
call js_ecvt1
mov rax, [rsp+48h+var_20]
mov ecx, [rsp+48h+var_14]
add ecx, 1
movsxd rcx, ecx
movzx eax, byte ptr [rax+rcx]
cmp eax, 35h ; '5'
jge short loc_68A25
mov eax, [rsp+48h+var_14]
mov [rsp+48h+var_4], eax
jmp loc_68B34
loc_68A25:
mov rax, [rsp+48h+var_20]
mov ecx, [rsp+48h+var_14]
add ecx, 1
movsxd rcx, ecx
movzx eax, byte ptr [rax+rcx]
cmp eax, 35h ; '5'
jnz short loc_68AAE
mov rax, [rsp+48h+var_20]
mov ecx, [rsp+48h+var_14]
add ecx, 2
movsxd rcx, ecx
movzx eax, byte ptr [rax+rcx]
cmp eax, 30h ; '0'
jnz short loc_68AAE
mov edi, 400h
call _fesetround
movsd xmm0, [rsp+48h+var_10]
mov edi, [rsp+48h+var_14]
add edi, 2
mov rsi, [rsp+48h+var_20]
mov rdx, [rsp+48h+var_28]
mov rcx, [rsp+48h+var_30]
call js_ecvt1
xor edi, edi
call _fesetround
mov rax, [rsp+48h+var_20]
mov ecx, [rsp+48h+var_14]
add ecx, 1
movsxd rcx, ecx
movzx eax, byte ptr [rax+rcx]
cmp eax, 35h ; '5'
jge short loc_68AAC
mov eax, [rsp+48h+var_14]
mov [rsp+48h+var_4], eax
jmp loc_68B34
loc_68AAC:
jmp short $+2
loc_68AAE:
mov eax, [rsp+48h+var_14]
mov [rsp+48h+var_40], eax
loc_68AB6:
mov rax, [rsp+48h+var_20]
movsxd rcx, [rsp+48h+var_40]
movzx edi, byte ptr [rax+rcx]
call is_digit
cmp eax, 0
jz short loc_68B1D
mov rcx, [rsp+48h+var_20]
movsxd rdx, [rsp+48h+var_40]
mov al, [rcx+rdx]
mov sil, al
add sil, 1
mov [rcx+rdx], sil
movzx eax, al
cmp eax, 39h ; '9'
jge short loc_68AF0
jmp short loc_68B2C
loc_68AF0:
mov rax, [rsp+48h+var_20]
movsxd rcx, [rsp+48h+var_40]
mov byte ptr [rax+rcx], 30h ; '0'
cmp [rsp+48h+var_40], 0
jnz short loc_68B1B
mov rax, [rsp+48h+var_20]
mov byte ptr [rax], 31h ; '1'
mov rax, [rsp+48h+var_30]
mov ecx, [rax]
add ecx, 1
mov [rax], ecx
jmp short loc_68B2C
loc_68B1B:
jmp short $+2
loc_68B1D:
jmp short $+2
loc_68B1F:
mov eax, [rsp+48h+var_40]
add eax, 0FFFFFFFFh
mov [rsp+48h+var_40], eax
jmp short loc_68AB6
loc_68B2C:
mov eax, [rsp+48h+var_14]
mov [rsp+48h+var_4], eax
loc_68B34:
mov eax, [rsp+48h+var_4]
add rsp, 48h
retn
| long long js_ecvt(unsigned int a1, _BYTE *a2, long long a3, _DWORD *a4, double a5)
{
unsigned __int8 v5; // al
unsigned int i; // [rsp+8h] [rbp-40h]
int j; // [rsp+10h] [rbp-38h]
int v9; // [rsp+14h] [rbp-34h]
unsigned int v12; // [rsp+34h] [rbp-14h]
if ( a1 )
{
js_ecvt1(a1 + 2, a2, a3, a4, a5);
if ( (unsigned __int8)a2[a1 + 1] >= 0x35u )
{
if ( a2[a1 + 1] == 53
&& a2[a1 + 2] == 48
&& (fesetround(1024LL), js_ecvt1(a1 + 2, a2, a3, a4, a5), fesetround(0LL), (unsigned __int8)a2[a1 + 1] < 0x35u) )
{
return a1;
}
else
{
for ( i = a1; ; --i )
{
if ( is_digit((unsigned __int8)a2[i]) )
{
v5 = a2[i];
a2[i] = v5 + 1;
if ( v5 < 0x39u )
return a1;
a2[i] = 48;
if ( !i )
break;
}
}
*a2 = 49;
++*a4;
return a1;
}
}
else
{
return a1;
}
}
else
{
v9 = 1;
for ( j = 17; ; j = v12 )
{
while ( 1 )
{
v12 = (unsigned int)(j + v9) >> 1;
js_ecvt1(v12, a2, a3, a4, a5);
if ( v9 == j )
return (unsigned int)(j + v9) >> 1;
if ( strtod(a2, 0LL) == a5 )
break;
v9 = v12 + 1;
}
while ( a2[v12] == 48 )
--v12;
if ( v12 == v9 )
return v12;
if ( v12 < (unsigned int)(j + v9) >> 1 && a5 > 3.0e-308 && a5 < 8.0e307 )
break;
}
return v12;
}
}
| js_ecvt:
SUB RSP,0x48
MOVSD qword ptr [RSP + 0x38],XMM0
MOV dword ptr [RSP + 0x34],EDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x18],RCX
CMP dword ptr [RSP + 0x34],0x0
JNZ 0x001689df
MOV dword ptr [RSP + 0x14],0x1
MOV dword ptr [RSP + 0x10],0x11
LAB_001688e8:
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,dword ptr [RSP + 0x10]
SHR EAX,0x1
MOV dword ptr [RSP + 0x34],EAX
MOVSD XMM0,qword ptr [RSP + 0x38]
MOV EDI,dword ptr [RSP + 0x34]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x18]
CALL 0x00168b40
MOV EAX,dword ptr [RSP + 0x14]
CMP EAX,dword ptr [RSP + 0x10]
JNZ 0x0016892b
MOV EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RSP + 0x44],EAX
JMP 0x00168b34
LAB_0016892b:
MOV RDI,qword ptr [RSP + 0x28]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0010e1a0
UCOMISD XMM0,qword ptr [RSP + 0x38]
JNZ 0x001689cf
JP 0x001689cf
MOV EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RSP + 0xc],EAX
LAB_00168953:
MOV RAX,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0x34]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x30
JNZ 0x00168973
MOV EAX,dword ptr [RSP + 0x34]
ADD EAX,-0x1
MOV dword ptr [RSP + 0x34],EAX
JMP 0x00168953
LAB_00168973:
MOV EAX,dword ptr [RSP + 0x34]
CMP EAX,dword ptr [RSP + 0x14]
JNZ 0x0016898a
MOV EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RSP + 0x44],EAX
JMP 0x00168b34
LAB_0016898a:
MOV EAX,dword ptr [RSP + 0x34]
CMP EAX,dword ptr [RSP + 0xc]
JNC 0x001689c5
MOVSD XMM0,qword ptr [RSP + 0x38]
MOVSD XMM1,qword ptr [0x00213ac0]
UCOMISD XMM0,XMM1
JBE 0x001689c5
MOVSD XMM0,qword ptr [0x00213ac8]
UCOMISD XMM0,qword ptr [RSP + 0x38]
JBE 0x001689c5
MOV EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RSP + 0x44],EAX
JMP 0x00168b34
LAB_001689c5:
MOV EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RSP + 0x10],EAX
JMP 0x001689da
LAB_001689cf:
MOV EAX,dword ptr [RSP + 0x34]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
LAB_001689da:
JMP 0x001688e8
LAB_001689df:
MOVSD XMM0,qword ptr [RSP + 0x38]
MOV EDI,dword ptr [RSP + 0x34]
ADD EDI,0x2
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x18]
CALL 0x00168b40
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RSP + 0x34]
ADD ECX,0x1
MOVSXD RCX,ECX
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x35
JGE 0x00168a25
MOV EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RSP + 0x44],EAX
JMP 0x00168b34
LAB_00168a25:
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RSP + 0x34]
ADD ECX,0x1
MOVSXD RCX,ECX
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x35
JNZ 0x00168aae
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RSP + 0x34]
ADD ECX,0x2
MOVSXD RCX,ECX
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x30
JNZ 0x00168aae
MOV EDI,0x400
CALL 0x0010e030
MOVSD XMM0,qword ptr [RSP + 0x38]
MOV EDI,dword ptr [RSP + 0x34]
ADD EDI,0x2
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x18]
CALL 0x00168b40
XOR EDI,EDI
CALL 0x0010e030
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RSP + 0x34]
ADD ECX,0x1
MOVSXD RCX,ECX
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x35
JGE 0x00168aac
MOV EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RSP + 0x44],EAX
JMP 0x00168b34
LAB_00168aac:
JMP 0x00168aae
LAB_00168aae:
MOV EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RSP + 0x8],EAX
LAB_00168ab6:
MOV RAX,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0x8]
MOVZX EDI,byte ptr [RAX + RCX*0x1]
CALL 0x0012e3e0
CMP EAX,0x0
JZ 0x00168b1d
MOV RCX,qword ptr [RSP + 0x28]
MOVSXD RDX,dword ptr [RSP + 0x8]
MOV AL,byte ptr [RCX + RDX*0x1]
MOV SIL,AL
ADD SIL,0x1
MOV byte ptr [RCX + RDX*0x1],SIL
MOVZX EAX,AL
CMP EAX,0x39
JGE 0x00168af0
JMP 0x00168b2c
LAB_00168af0:
MOV RAX,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0x8]
MOV byte ptr [RAX + RCX*0x1],0x30
CMP dword ptr [RSP + 0x8],0x0
JNZ 0x00168b1b
MOV RAX,qword ptr [RSP + 0x28]
MOV byte ptr [RAX],0x31
MOV RAX,qword ptr [RSP + 0x18]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
MOV dword ptr [RAX],ECX
JMP 0x00168b2c
LAB_00168b1b:
JMP 0x00168b1d
LAB_00168b1d:
JMP 0x00168b1f
LAB_00168b1f:
MOV EAX,dword ptr [RSP + 0x8]
ADD EAX,-0x1
MOV dword ptr [RSP + 0x8],EAX
JMP 0x00168ab6
LAB_00168b2c:
MOV EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RSP + 0x44],EAX
LAB_00168b34:
MOV EAX,dword ptr [RSP + 0x44]
ADD RSP,0x48
RET
|
uint js_ecvt(double param_1,uint param_2,char *param_3,int8 param_4,int *param_5)
{
byte bVar1;
uint uVar2;
int iVar3;
double dVar4;
uint local_40;
uint local_38;
uint local_34;
uint local_14;
if (param_2 == 0) {
local_34 = 1;
local_38 = 0x11;
while( true ) {
while( true ) {
uVar2 = local_34 + local_38 >> 1;
js_ecvt1(param_1,uVar2,param_3,param_4,param_5);
if (local_34 == local_38) {
return uVar2;
}
dVar4 = strtod(param_3,(char **)0x0);
if ((dVar4 == param_1) && (local_14 = uVar2, !NAN(dVar4) && !NAN(param_1))) break;
local_34 = uVar2 + 1;
}
for (; param_3[(int)local_14] == '0'; local_14 = local_14 - 1) {
}
if (local_14 == local_34) break;
if (((local_14 < uVar2) && (DAT_00213ac0 < param_1)) && (param_1 < DAT_00213ac8)) {
return local_14;
}
local_38 = local_14;
}
return local_14;
}
js_ecvt1(param_1,param_2 + 2,param_3,param_4,param_5);
if ((byte)param_3[(int)(param_2 + 1)] < 0x35) {
return param_2;
}
local_40 = param_2;
if ((param_3[(int)(param_2 + 1)] == '5') && (param_3[(int)(param_2 + 2)] == '0')) {
fesetround(0x400);
js_ecvt1(param_1,param_2 + 2,param_3,param_4,param_5);
fesetround(0);
if ((byte)param_3[(int)(param_2 + 1)] < 0x35) {
return param_2;
}
}
do {
iVar3 = is_digit(param_3[(int)local_40]);
if (iVar3 != 0) {
bVar1 = param_3[(int)local_40];
param_3[(int)local_40] = bVar1 + 1;
if (bVar1 < 0x39) {
return param_2;
}
param_3[(int)local_40] = '0';
if (local_40 == 0) {
*param_3 = '1';
*param_5 = *param_5 + 1;
return param_2;
}
}
local_40 = local_40 - 1;
} while( true );
}
|
|
3,249 | init_simple_key_cache | eloqsql/mysys/mf_keycache.c | static
int init_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache,
uint key_cache_block_size,
size_t use_mem, uint division_limit,
uint age_threshold, uint changed_blocks_hash_size)
{
size_t blocks, hash_links;
size_t length;
int error;
DBUG_ENTER("init_simple_key_cache");
DBUG_ASSERT(key_cache_block_size >= 512);
KEYCACHE_DEBUG_OPEN;
if (keycache->key_cache_inited && keycache->disk_blocks > 0)
{
DBUG_PRINT("warning",("key cache already in use"));
DBUG_RETURN(0);
}
keycache->blocks_used= keycache->blocks_unused= 0;
keycache->global_blocks_changed= 0;
keycache->global_cache_w_requests= keycache->global_cache_r_requests= 0;
keycache->global_cache_read= keycache->global_cache_write= 0;
keycache->disk_blocks= -1;
if (! keycache->key_cache_inited)
{
keycache->key_cache_inited= 1;
keycache->hash_factor= 1;
/*
Initialize these variables once only.
Their value must survive re-initialization during resizing.
*/
keycache->in_resize= 0;
keycache->resize_in_flush= 0;
keycache->cnt_for_resize_op= 0;
keycache->waiting_for_resize_cnt.last_thread= NULL;
keycache->in_init= 0;
mysql_mutex_init(key_KEY_CACHE_cache_lock,
&keycache->cache_lock, MY_MUTEX_INIT_FAST);
keycache->resize_queue.last_thread= NULL;
}
keycache->key_cache_mem_size= use_mem;
keycache->key_cache_block_size= key_cache_block_size;
DBUG_PRINT("info", ("key_cache_block_size: %u",
key_cache_block_size));
blocks= use_mem / (sizeof(BLOCK_LINK) + 2 * sizeof(HASH_LINK) +
sizeof(HASH_LINK*) * 5/4 + key_cache_block_size);
/* Changed blocks hash needs to be a power of 2 */
changed_blocks_hash_size= my_round_up_to_next_power(MY_MAX(changed_blocks_hash_size,
MIN_CHANGED_BLOCKS_HASH_SIZE));
/* It doesn't make sense to have too few blocks (less than 8) */
if (blocks >= 8)
{
for ( ; ; )
{
/* Set my_hash_entries to the next bigger 2 power */
if ((keycache->hash_entries= next_power((uint)blocks)) < blocks * 5/4)
keycache->hash_entries<<= 1;
hash_links= 2 * blocks;
#if defined(MAX_THREADS)
if (hash_links < MAX_THREADS + blocks - 1)
hash_links= MAX_THREADS + blocks - 1;
#endif
while ((length= (ALIGN_SIZE(blocks * sizeof(BLOCK_LINK)) +
ALIGN_SIZE(hash_links * sizeof(HASH_LINK)) +
ALIGN_SIZE(sizeof(HASH_LINK*) *
keycache->hash_entries) +
sizeof(BLOCK_LINK*)* ((size_t)changed_blocks_hash_size*2))) +
(blocks * keycache->key_cache_block_size) > use_mem && blocks > 8)
blocks--;
keycache->allocated_mem_size= blocks * keycache->key_cache_block_size;
if ((keycache->block_mem= my_large_malloc(&keycache->allocated_mem_size,
MYF(0))))
{
/*
Allocate memory for blocks, hash_links and hash entries;
For each block 2 hash links are allocated
*/
if (my_multi_malloc_large(key_memory_KEY_CACHE, MYF(MY_ZEROFILL),
&keycache->block_root,
(ulonglong) (blocks * sizeof(BLOCK_LINK)),
&keycache->hash_root,
(ulonglong) (sizeof(HASH_LINK*) *
keycache->hash_entries),
&keycache->hash_link_root,
(ulonglong) (hash_links * sizeof(HASH_LINK)),
&keycache->changed_blocks,
(ulonglong) (sizeof(BLOCK_LINK*) *
changed_blocks_hash_size),
&keycache->file_blocks,
(ulonglong) (sizeof(BLOCK_LINK*) *
changed_blocks_hash_size),
NullS))
break;
my_large_free(keycache->block_mem, keycache->allocated_mem_size);
keycache->block_mem= 0;
}
if (blocks < 8)
{
my_errno= ENOMEM;
my_error(EE_OUTOFMEMORY, MYF(ME_FATAL),
blocks * keycache->key_cache_block_size);
goto err;
}
blocks= blocks / 4*3;
}
keycache->blocks_unused= blocks;
keycache->disk_blocks= (int) blocks;
keycache->hash_links= (int)hash_links;
keycache->hash_links_used= 0;
keycache->free_hash_list= NULL;
keycache->blocks_used= keycache->blocks_changed= 0;
keycache->global_blocks_changed= 0;
keycache->blocks_available=0; /* For debugging */
/* The LRU chain is empty after initialization */
keycache->used_last= NULL;
keycache->used_ins= NULL;
keycache->free_block_list= NULL;
keycache->keycache_time= 0;
keycache->warm_blocks= 0;
keycache->min_warm_blocks= (division_limit ?
blocks * division_limit / 100 + 1 :
blocks);
keycache->age_threshold= (age_threshold ?
blocks * age_threshold / 100 :
blocks);
keycache->changed_blocks_hash_size= changed_blocks_hash_size;
keycache->can_be_used= 1;
keycache->waiting_for_hash_link.last_thread= NULL;
keycache->waiting_for_block.last_thread= NULL;
DBUG_PRINT("exit",
("disk_blocks: %d block_root: %p hash_entries: %d\
hash_root: %p hash_links: %d hash_link_root: %p",
keycache->disk_blocks, keycache->block_root,
keycache->hash_entries, keycache->hash_root,
keycache->hash_links, keycache->hash_link_root));
}
else
{
/* key_buffer_size is specified too small. Disable the cache. */
keycache->can_be_used= 0;
}
keycache->blocks= keycache->disk_blocks > 0 ? keycache->disk_blocks : 0;
DBUG_RETURN((int) keycache->disk_blocks);
err:
error= my_errno;
keycache->disk_blocks= 0;
keycache->blocks= 0;
if (keycache->block_mem)
{
my_large_free((uchar*) keycache->block_mem, keycache->allocated_mem_size);
keycache->block_mem= NULL;
}
if (keycache->block_root)
{
my_free(keycache->block_root);
keycache->block_root= NULL;
}
my_errno= error;
keycache->can_be_used= 0;
DBUG_RETURN(0);
} | O3 | c | init_simple_key_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r9d, %ebx
movq %rdx, %r9
movl %esi, %r13d
movq %rdi, %r10
movb (%rdi), %al
testb %al, %al
je 0x53e16
xorl %r14d, %r14d
cmpl $0x0, 0x48(%r10)
jg 0x54282
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r10)
movups %xmm0, 0x138(%r10)
movups %xmm0, 0x148(%r10)
movq $0x0, 0x158(%r10)
movl $0xffffffff, 0x48(%r10) # imm = 0xFFFFFFFF
testb %al, %al
movq %r10, -0x30(%rbp)
movq %r9, -0x50(%rbp)
jne 0x53ee9
movw $0x1, (%r10)
movl $0x1, 0x164(%r10)
xorl %r15d, %r15d
movb %r15b, 0x2(%r10)
movq %r15, 0x70(%r10)
movq %r15, 0x110(%r10)
movb %r15b, 0x168(%r10)
leaq 0x35a69a(%rip), %rax # 0x3ae51c
movl (%rax), %edi
leaq 0xc0(%r10), %r14
leaq 0x2dbfbe(%rip), %rax # 0x32fe50
movq (%rax), %rax
movq %r14, %rsi
movl %ecx, -0x34(%rbp)
movl %r8d, %r12d
callq *0x40(%rax)
movq -0x30(%rbp), %rcx
movq %rax, 0x100(%rcx)
movq -0x30(%rbp), %rax
movq %r14, 0xf8(%rax)
movq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rax)
leaq 0x35b364(%rip), %rsi # 0x3af230
movq %r14, %rdi
callq 0x285a0
movl %r12d, %r8d
movq -0x50(%rbp), %r9
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %r10
movq %r15, 0x108(%r10)
movq %r9, 0x8(%r10)
movl %r13d, 0x18(%r10)
movl %r13d, %esi
addq $0xda, %rsi
movq %r9, %rax
xorl %edx, %edx
divq %rsi
movq %rax, %rdi
cmpl $0x81, %ebx
movl $0x80, %eax
cmovael %ebx, %eax
cmpq $0x8, %rdi
jb 0x5412a
decl %eax
movl %eax, %edx
shrl %edx
orl %eax, %edx
movl %edx, %eax
shrl $0x2, %eax
orl %edx, %eax
movl %eax, %edx
shrl $0x4, %edx
orl %eax, %edx
movl %edx, %eax
shrl $0x8, %eax
orl %edx, %eax
movl %eax, %edx
shrl $0x10, %edx
orl %eax, %edx
incl %edx
movl %edx, -0x38(%rbp)
movl %edx, %edx
movq %rdx, %rax
shlq $0x4, %rax
movq %rax, -0x98(%rbp)
leaq 0x10(%r10), %rax
movq %rax, -0x90(%rbp)
leaq 0xa0(%r10), %rax
movq %rax, -0x48(%rbp)
leaq 0x80(%r10), %rax
movq %rax, -0x70(%rbp)
leaq 0x88(%r10), %rax
movq %rax, -0x68(%rbp)
leaq 0x128(%r10), %rax
movq %rax, -0x60(%rbp)
shlq $0x3, %rdx
movq %rdx, -0x78(%rbp)
leaq 0x130(%r10), %rax
movq %rax, -0x58(%rbp)
movl %r8d, -0x3c(%rbp)
movl %r8d, %r11d
movl %ecx, -0x34(%rbp)
movl %ecx, %r12d
movq %r10, %r8
movq %r11, -0x80(%rbp)
leal -0x1(%rdi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10, %ecx
orl %eax, %ecx
leal 0x2(,%rcx,2), %edx
movq %rdi, %rax
shrq $0x2, %rax
addq %rdi, %rax
cmpq %rdx, %rax
seta %cl
shll %cl, %edx
movl %edx, 0x38(%r8)
movq %rdi, %rax
shlq $0x5, %rax
leaq (%rax,%rax,2), %rax
movq %rax, -0xa0(%rbp)
movl %r13d, %eax
leaq 0x1(%rdi), %r14
movq %r11, %r13
imulq %r14, %r13
movq %r12, %rbx
imulq %r14, %rbx
movq %r14, %rcx
imulq %rax, %rcx
leaq 0xd0(%rax), %rsi
imulq %rdi, %rsi
addq -0x98(%rbp), %rsi
leaq (%rsi,%rdx,8), %rsi
movq $-0x70, %rdx
subq %rax, %rdx
movq %rdi, -0x88(%rbp)
imulq $0x70, %rdi, %r15
addq $0x70, %r15
decq %r14
subq %r11, %r13
subq %r12, %rbx
subq %rax, %rcx
addq $-0x70, %r15
cmpq $0x9, %r14
jb 0x54076
leaq (%rsi,%rdx), %rdi
cmpq %r9, %rsi
movq %rdi, %rsi
ja 0x54054
movq %rcx, 0x10(%r8)
movq -0x90(%rbp), %rdi
xorl %esi, %esi
callq 0x60124
movq -0x30(%rbp), %r8
movq %rax, 0xa8(%r8)
testq %rax, %rax
je 0x5410b
leaq 0x35ae19(%rip), %rax # 0x3aeeb8
movl (%rax), %edi
movl 0x38(%r8), %r9d
shlq $0x3, %r9
subq $0x8, %rsp
movl $0x20, %esi
movq -0x48(%rbp), %rdx
movq %r15, %rcx
movq %r8, %r15
movq -0x70(%rbp), %r8
xorl %eax, %eax
pushq $0x0
movq -0x78(%rbp), %r10
pushq %r10
pushq -0x58(%rbp)
pushq %r10
pushq -0x60(%rbp)
pushq -0xa0(%rbp)
pushq -0x68(%rbp)
callq 0x57b69
addq $0x40, %rsp
testq %rax, %rax
jne 0x541ce
movq 0x10(%r15), %rsi
movq 0xa8(%r15), %rdi
callq 0x605d3
movq $0x0, 0xa8(%r15)
movq %r15, %r8
cmpq $0x7, %r14
jbe 0x54138
shrq $0x2, %r14
leaq (%r14,%r14,2), %rdi
movl 0x18(%r8), %r13d
movq -0x50(%rbp), %r9
movq -0x80(%rbp), %r11
jmp 0x53fb5
movb $0x0, 0x3(%r10)
movl 0x48(%r10), %r14d
jmp 0x54272
callq 0x5be8e
movl $0xc, (%rax)
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
imulq %rax, %r14
xorl %r15d, %r15d
movl $0x1000, %esi # imm = 0x1000
movl $0x5, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x586b7
callq 0x5be8e
movq -0x30(%rbp), %rcx
movl (%rax), %ebx
movl %r15d, 0x48(%rcx)
movl %r15d, 0x160(%rcx)
movq 0xa8(%rcx), %rdi
testq %rdi, %rdi
je 0x5419f
movq 0x10(%rcx), %rsi
callq 0x605d3
movq -0x30(%rbp), %rax
movq $0x0, 0xa8(%rax)
movq -0x48(%rbp), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x541b7
callq 0x5a3fa
movq $0x0, (%r14)
callq 0x5be8e
movl %ebx, (%rax)
movq -0x30(%rbp), %rax
movb $0x0, 0x3(%rax)
xorl %r14d, %r14d
jmp 0x54282
movq %r14, 0x58(%r15)
movl %r14d, 0x48(%r15)
movq -0x88(%rbp), %rax
addl %eax, %eax
movl %eax, 0x40(%r15)
movl $0x0, 0x44(%r15)
xorl %eax, %eax
movq %rax, 0x50(%r15)
movq %rax, 0x138(%r15)
movq %rax, 0x78(%r15)
movq %rax, 0x30(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r15)
movups %xmm0, 0x90(%r15)
movups %xmm0, 0xb0(%r15)
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
movq %r14, %rdx
cmpl $0x0, -0x34(%rbp)
movq %r15, %r10
je 0x5423f
shrq $0x2, %rbx
movq %rbx, %rax
mulq %rcx
shrq $0x2, %rdx
incq %rdx
movq %rdx, 0x20(%r10)
movq %r14, %rdx
cmpl $0x0, -0x3c(%rbp)
je 0x5425a
shrq $0x2, %r13
movq %r13, %rax
mulq %rcx
shrq $0x2, %rdx
movq %rdx, 0x28(%r10)
movl -0x38(%rbp), %eax
movl %eax, 0x3c(%r10)
movb $0x1, 0x3(%r10)
movups %xmm0, 0x118(%r10)
xorl %eax, %eax
testl %r14d, %r14d
cmovgl %r14d, %eax
movl %eax, 0x160(%r10)
movl %r14d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| init_simple_key_cache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov ebx, r9d
mov r9, rdx
mov r13d, esi
mov r10, rdi
mov al, [rdi]
test al, al
jz short loc_53E16
xor r14d, r14d
cmp dword ptr [r10+48h], 0
jg loc_54282
loc_53E16:
xorps xmm0, xmm0
movups xmmword ptr [r10+50h], xmm0
movups xmmword ptr [r10+138h], xmm0
movups xmmword ptr [r10+148h], xmm0
mov qword ptr [r10+158h], 0
mov dword ptr [r10+48h], 0FFFFFFFFh
test al, al
mov [rbp+var_30], r10
mov [rbp+var_50], r9
jnz loc_53EE9
mov word ptr [r10], 1
mov dword ptr [r10+164h], 1
xor r15d, r15d
mov [r10+2], r15b
mov [r10+70h], r15
mov [r10+110h], r15
mov [r10+168h], r15b
lea rax, key_KEY_CACHE_cache_lock
mov edi, [rax]
lea r14, [r10+0C0h]
lea rax, PSI_server
mov rax, [rax]
mov rsi, r14
mov [rbp+var_34], ecx
mov r12d, r8d
call qword ptr [rax+40h]
mov rcx, [rbp+var_30]
mov [rcx+100h], rax
mov rax, [rbp+var_30]
mov [rax+0F8h], r14
mov rax, [rbp+var_30]
xorps xmm0, xmm0
movups xmmword ptr [rax+0E8h], xmm0
lea rsi, my_fast_mutexattr
mov rdi, r14
call _pthread_mutex_init
mov r8d, r12d
mov r9, [rbp+var_50]
mov ecx, [rbp+var_34]
mov r10, [rbp+var_30]
mov [r10+108h], r15
loc_53EE9:
mov [r10+8], r9
mov [r10+18h], r13d
mov esi, r13d
add rsi, 0DAh
mov rax, r9
xor edx, edx
div rsi
mov rdi, rax
cmp ebx, 81h
mov eax, 80h
cmovnb eax, ebx
cmp rdi, 8
jb loc_5412A
dec eax
mov edx, eax
shr edx, 1
or edx, eax
mov eax, edx
shr eax, 2
or eax, edx
mov edx, eax
shr edx, 4
or edx, eax
mov eax, edx
shr eax, 8
or eax, edx
mov edx, eax
shr edx, 10h
or edx, eax
inc edx
mov [rbp+var_38], edx
mov edx, edx
mov rax, rdx
shl rax, 4
mov [rbp+var_98], rax
lea rax, [r10+10h]
mov [rbp+var_90], rax
lea rax, [r10+0A0h]
mov [rbp+var_48], rax
lea rax, [r10+80h]
mov [rbp+var_70], rax
lea rax, [r10+88h]
mov [rbp+var_68], rax
lea rax, [r10+128h]
mov [rbp+var_60], rax
shl rdx, 3
mov [rbp+var_78], rdx
lea rax, [r10+130h]
mov [rbp+var_58], rax
mov [rbp+var_3C], r8d
mov r11d, r8d
mov [rbp+var_34], ecx
mov r12d, ecx
mov r8, r10
mov [rbp+var_80], r11
loc_53FB5:
lea eax, [rdi-1]
mov ecx, eax
shr ecx, 1
or ecx, eax
mov eax, ecx
shr eax, 2
or eax, ecx
mov ecx, eax
shr ecx, 4
or ecx, eax
mov eax, ecx
shr eax, 8
or eax, ecx
mov ecx, eax
shr ecx, 10h
or ecx, eax
lea edx, ds:2[rcx*2]
mov rax, rdi
shr rax, 2
add rax, rdi
cmp rax, rdx
setnbe cl
shl edx, cl
mov [r8+38h], edx
mov rax, rdi
shl rax, 5
lea rax, [rax+rax*2]
mov [rbp+var_A0], rax
mov eax, r13d
lea r14, [rdi+1]
mov r13, r11
imul r13, r14
mov rbx, r12
imul rbx, r14
mov rcx, r14
imul rcx, rax
lea rsi, [rax+0D0h]
imul rsi, rdi
add rsi, [rbp+var_98]
lea rsi, [rsi+rdx*8]
mov rdx, 0FFFFFFFFFFFFFF90h
sub rdx, rax
mov [rbp+var_88], rdi
imul r15, rdi, 70h ; 'p'
add r15, 70h ; 'p'
loc_54054:
dec r14
sub r13, r11
sub rbx, r12
sub rcx, rax
add r15, 0FFFFFFFFFFFFFF90h
cmp r14, 9
jb short loc_54076
lea rdi, [rsi+rdx]
cmp rsi, r9
mov rsi, rdi
ja short loc_54054
loc_54076:
mov [r8+10h], rcx
mov rdi, [rbp+var_90]
xor esi, esi
call my_large_malloc
mov r8, [rbp+var_30]
mov [r8+0A8h], rax
test rax, rax
jz short loc_5410B
lea rax, key_memory_KEY_CACHE
mov edi, [rax]
mov r9d, [r8+38h]
shl r9, 3
sub rsp, 8
mov esi, 20h ; ' '
mov rdx, [rbp+var_48]
mov rcx, r15
mov r15, r8
mov r8, [rbp+var_70]
xor eax, eax
push 0
mov r10, [rbp+var_78]
push r10
push [rbp+var_58]
push r10
push [rbp+var_60]
push [rbp+var_A0]
push [rbp+var_68]
call my_multi_malloc_large
add rsp, 40h
test rax, rax
jnz loc_541CE
mov rsi, [r15+10h]
mov rdi, [r15+0A8h]
call my_large_free
mov qword ptr [r15+0A8h], 0
mov r8, r15
loc_5410B:
cmp r14, 7
jbe short loc_54138
shr r14, 2
lea rdi, [r14+r14*2]
mov r13d, [r8+18h]
mov r9, [rbp+var_50]
mov r11, [rbp+var_80]
jmp loc_53FB5
loc_5412A:
mov byte ptr [r10+3], 0
mov r14d, [r10+48h]
jmp loc_54272
loc_54138:
call _my_thread_var
mov dword ptr [rax], 0Ch
mov rax, [rbp+var_30]
mov eax, [rax+18h]
imul r14, rax
xor r15d, r15d
mov esi, 1000h
mov edi, 5
mov rdx, r14
xor eax, eax
call my_error
call _my_thread_var
mov rcx, [rbp+var_30]
mov ebx, [rax]
mov [rcx+48h], r15d
mov [rcx+160h], r15d
mov rdi, [rcx+0A8h]
test rdi, rdi
jz short loc_5419F
mov rsi, [rcx+10h]
call my_large_free
mov rax, [rbp+var_30]
mov qword ptr [rax+0A8h], 0
loc_5419F:
mov r14, [rbp+var_48]
mov rdi, [r14]
test rdi, rdi
jz short loc_541B7
call my_free
mov qword ptr [r14], 0
loc_541B7:
call _my_thread_var
mov [rax], ebx
mov rax, [rbp+var_30]
mov byte ptr [rax+3], 0
xor r14d, r14d
jmp loc_54282
loc_541CE:
mov [r15+58h], r14
mov [r15+48h], r14d
mov rax, [rbp+var_88]
add eax, eax
mov [r15+40h], eax
mov dword ptr [r15+44h], 0
xor eax, eax
mov [r15+50h], rax
mov [r15+138h], rax
mov [r15+78h], rax
mov [r15+30h], rax
xorps xmm0, xmm0
movups xmmword ptr [r15+60h], xmm0
movups xmmword ptr [r15+90h], xmm0
movups xmmword ptr [r15+0B0h], xmm0
mov rcx, 28F5C28F5C28F5C3h
mov rdx, r14
cmp [rbp+var_34], 0
mov r10, r15
jz short loc_5423F
shr rbx, 2
mov rax, rbx
mul rcx
shr rdx, 2
inc rdx
loc_5423F:
mov [r10+20h], rdx
mov rdx, r14
cmp [rbp+var_3C], 0
jz short loc_5425A
shr r13, 2
mov rax, r13
mul rcx
shr rdx, 2
loc_5425A:
mov [r10+28h], rdx
mov eax, [rbp+var_38]
mov [r10+3Ch], eax
mov byte ptr [r10+3], 1
movups xmmword ptr [r10+118h], xmm0
loc_54272:
xor eax, eax
test r14d, r14d
cmovg eax, r14d
mov [r10+160h], eax
loc_54282:
mov eax, r14d
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long init_simple_key_cache(
char *a1,
unsigned int a2,
unsigned long long a3,
long long a4,
long long a5,
unsigned int a6)
{
unsigned long long v7; // r9
unsigned int v8; // r13d
char *v9; // r10
char v10; // al
unsigned long long v11; // r14
int v12; // r12d
unsigned long long v13; // rdi
int v14; // eax
unsigned int v15; // eax
unsigned int v16; // eax
long long v17; // r11
long long v18; // r12
char *v19; // r8
unsigned long long v20; // rdx
long long v21; // rdx
long long v22; // rax
unsigned long long v23; // r13
unsigned long long v24; // rbx
long long v25; // rcx
unsigned long long v26; // rsi
long long v27; // rdx
int v28; // r15d
bool v29; // cc
char *v30; // rdi
long long v31; // rax
int v32; // ecx
int v33; // r8d
int v34; // r9d
int v35; // ebx
long long v36; // rdi
long long v37; // rdi
unsigned long long v38; // rdx
unsigned long long v39; // rdx
int v40; // eax
long long v42; // [rsp+0h] [rbp-A0h]
char *v43; // [rsp+10h] [rbp-90h]
int v44; // [rsp+18h] [rbp-88h]
long long i; // [rsp+20h] [rbp-80h]
int v46; // [rsp+30h] [rbp-70h]
long long v47; // [rsp+38h] [rbp-68h]
long long v48; // [rsp+40h] [rbp-60h]
long long v49; // [rsp+48h] [rbp-58h]
long long *v51; // [rsp+58h] [rbp-48h]
int v52; // [rsp+64h] [rbp-3Ch]
unsigned int v53; // [rsp+68h] [rbp-38h]
int v54; // [rsp+6Ch] [rbp-34h]
int v55; // [rsp+6Ch] [rbp-34h]
v7 = a3;
v8 = a2;
v9 = a1;
v10 = *a1;
if ( *a1 )
{
LODWORD(v11) = 0;
if ( *((int *)a1 + 18) > 0 )
return (unsigned int)v11;
}
*((_OWORD *)a1 + 5) = 0LL;
*(_OWORD *)(a1 + 312) = 0LL;
*(_OWORD *)(a1 + 328) = 0LL;
*((_QWORD *)a1 + 43) = 0LL;
*((_DWORD *)a1 + 18) = -1;
if ( !v10 )
{
*(_WORD *)a1 = 1;
*((_DWORD *)a1 + 89) = 1;
a1[2] = 0;
*((_QWORD *)a1 + 14) = 0LL;
*((_QWORD *)a1 + 34) = 0LL;
a1[360] = 0;
v54 = a4;
v12 = a5;
*((_QWORD *)a1 + 32) = ((long long ( *)(_QWORD, char *, unsigned long long, long long, long long, unsigned long long))PSI_server[8])(
key_KEY_CACHE_cache_lock,
a1 + 192,
a3,
a4,
a5,
a3);
*((_QWORD *)a1 + 31) = a1 + 192;
*(_OWORD *)(a1 + 232) = 0LL;
pthread_mutex_init(a1 + 192, &my_fast_mutexattr);
LODWORD(a5) = v12;
v7 = a3;
LODWORD(a4) = v54;
v9 = a1;
*((_QWORD *)a1 + 33) = 0LL;
}
*((_QWORD *)v9 + 1) = v7;
*((_DWORD *)v9 + 6) = a2;
v13 = v7 / ((unsigned long long)a2 + 218);
v14 = 128;
if ( a6 >= 0x81 )
v14 = a6;
if ( v13 < 8 )
{
v9[3] = 0;
LODWORD(v11) = *((_DWORD *)v9 + 18);
goto LABEL_28;
}
v15 = (v14 - 1) | ((unsigned int)(v14 - 1) >> 1) | (((v14 - 1) | ((unsigned int)(v14 - 1) >> 1)) >> 2);
v16 = v15 | (v15 >> 4) | ((v15 | (v15 >> 4)) >> 8);
v53 = (v16 | HIWORD(v16)) + 1;
v43 = v9 + 16;
v51 = (long long *)(v9 + 160);
v46 = (_DWORD)v9 + 128;
v47 = (long long)(v9 + 136);
v48 = (long long)(v9 + 296);
v49 = (long long)(v9 + 304);
v52 = a5;
v17 = (unsigned int)a5;
v55 = a4;
v18 = (unsigned int)a4;
v19 = v9;
for ( i = v17; ; v17 = i )
{
v20 = 2
* (((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2)) >> 4) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2)) >> 4)) >> 8) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2)) >> 4) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2)) >> 4)) >> 8)) >> 16))
+ 2;
v21 = (unsigned int)((_DWORD)v20 << (v13 + (v13 >> 2) > v20));
*((_DWORD *)v19 + 14) = v21;
v42 = 96 * v13;
v22 = v8;
v11 = v13 + 1;
v23 = (v13 + 1) * v17;
v24 = (v13 + 1) * v18;
v25 = v22 * (v13 + 1);
v26 = 16LL * v53 + v13 * (v22 + 208) + 8 * v21;
v27 = -112 - v22;
v44 = v13;
v28 = 112 * v13 + 112;
do
{
--v11;
v23 -= v17;
v24 -= v18;
v25 -= v22;
v28 -= 112;
if ( v11 < 9 )
break;
v29 = v26 <= v7;
v26 += v27;
}
while ( !v29 );
*((_QWORD *)v19 + 2) = v25;
v30 = v43;
v31 = my_large_malloc(v43, 0LL, v27);
v19 = a1;
*((_QWORD *)a1 + 21) = v31;
if ( v31 )
break;
LABEL_15:
if ( v11 <= 7 )
{
*(_DWORD *)my_thread_var(v30) = 12;
my_error(5, 4096, *((_DWORD *)a1 + 6) * v11, v32, v33, v34);
v35 = *(_DWORD *)my_thread_var(5LL);
*((_DWORD *)a1 + 18) = 0;
*((_DWORD *)a1 + 88) = 0;
v36 = *((_QWORD *)a1 + 21);
if ( v36 )
{
my_large_free(v36, *((_QWORD *)a1 + 2));
*((_QWORD *)a1 + 21) = 0LL;
}
v37 = *v51;
if ( *v51 )
{
my_free(v37);
*v51 = 0LL;
}
*(_DWORD *)my_thread_var(v37) = v35;
a1[3] = 0;
LODWORD(v11) = 0;
return (unsigned int)v11;
}
v13 = 3 * (v11 >> 2);
v8 = *((_DWORD *)v19 + 6);
v7 = a3;
}
if ( !my_multi_malloc_large(
key_memory_KEY_CACHE,
32,
(_DWORD)v51,
v28,
v46,
8 * *((_DWORD *)a1 + 14),
v47,
v42,
v48,
8LL * v53,
v49,
8LL * v53,
0LL) )
{
v30 = (char *)*((_QWORD *)a1 + 21);
my_large_free(v30, *((_QWORD *)a1 + 2));
*((_QWORD *)a1 + 21) = 0LL;
v19 = a1;
goto LABEL_15;
}
*((_QWORD *)a1 + 11) = v11;
*((_DWORD *)a1 + 18) = v11;
*((_DWORD *)a1 + 16) = 2 * v44;
*((_DWORD *)a1 + 17) = 0;
*((_QWORD *)a1 + 10) = 0LL;
*((_QWORD *)a1 + 39) = 0LL;
*((_QWORD *)a1 + 15) = 0LL;
*((_QWORD *)a1 + 6) = 0LL;
*((_OWORD *)a1 + 6) = 0LL;
*((_OWORD *)a1 + 9) = 0LL;
*((_OWORD *)a1 + 11) = 0LL;
v38 = v11;
v9 = a1;
if ( v55 )
v38 = v24 / 0x64 + 1;
*((_QWORD *)a1 + 4) = v38;
v39 = v11;
if ( v52 )
v39 = v23 / 0x64;
*((_QWORD *)a1 + 5) = v39;
*((_DWORD *)a1 + 15) = v53;
a1[3] = 1;
*(_OWORD *)(a1 + 280) = 0LL;
LABEL_28:
v40 = 0;
if ( (int)v11 > 0 )
v40 = v11;
*((_DWORD *)v9 + 88) = v40;
return (unsigned int)v11;
}
| init_simple_key_cache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV EBX,R9D
MOV R9,RDX
MOV R13D,ESI
MOV R10,RDI
MOV AL,byte ptr [RDI]
TEST AL,AL
JZ 0x00153e16
XOR R14D,R14D
CMP dword ptr [R10 + 0x48],0x0
JG 0x00154282
LAB_00153e16:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R10 + 0x50],XMM0
MOVUPS xmmword ptr [R10 + 0x138],XMM0
MOVUPS xmmword ptr [R10 + 0x148],XMM0
MOV qword ptr [R10 + 0x158],0x0
MOV dword ptr [R10 + 0x48],0xffffffff
TEST AL,AL
MOV qword ptr [RBP + -0x30],R10
MOV qword ptr [RBP + -0x50],R9
JNZ 0x00153ee9
MOV word ptr [R10],0x1
MOV dword ptr [R10 + 0x164],0x1
XOR R15D,R15D
MOV byte ptr [R10 + 0x2],R15B
MOV qword ptr [R10 + 0x70],R15
MOV qword ptr [R10 + 0x110],R15
MOV byte ptr [R10 + 0x168],R15B
LEA RAX,[0x4ae51c]
MOV EDI,dword ptr [RAX]
LEA R14,[R10 + 0xc0]
LEA RAX,[0x42fe50]
MOV RAX,qword ptr [RAX]
MOV RSI,R14
MOV dword ptr [RBP + -0x34],ECX
MOV R12D,R8D
CALL qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RCX + 0x100],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0xf8],R14
MOV RAX,qword ptr [RBP + -0x30]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0xe8],XMM0
LEA RSI,[0x4af230]
MOV RDI,R14
CALL 0x001285a0
MOV R8D,R12D
MOV R9,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x34]
MOV R10,qword ptr [RBP + -0x30]
MOV qword ptr [R10 + 0x108],R15
LAB_00153ee9:
MOV qword ptr [R10 + 0x8],R9
MOV dword ptr [R10 + 0x18],R13D
MOV ESI,R13D
ADD RSI,0xda
MOV RAX,R9
XOR EDX,EDX
DIV RSI
MOV RDI,RAX
CMP EBX,0x81
MOV EAX,0x80
CMOVNC EAX,EBX
CMP RDI,0x8
JC 0x0015412a
DEC EAX
MOV EDX,EAX
SHR EDX,0x1
OR EDX,EAX
MOV EAX,EDX
SHR EAX,0x2
OR EAX,EDX
MOV EDX,EAX
SHR EDX,0x4
OR EDX,EAX
MOV EAX,EDX
SHR EAX,0x8
OR EAX,EDX
MOV EDX,EAX
SHR EDX,0x10
OR EDX,EAX
INC EDX
MOV dword ptr [RBP + -0x38],EDX
MOV EDX,EDX
MOV RAX,RDX
SHL RAX,0x4
MOV qword ptr [RBP + -0x98],RAX
LEA RAX,[R10 + 0x10]
MOV qword ptr [RBP + -0x90],RAX
LEA RAX,[R10 + 0xa0]
MOV qword ptr [RBP + -0x48],RAX
LEA RAX,[R10 + 0x80]
MOV qword ptr [RBP + -0x70],RAX
LEA RAX,[R10 + 0x88]
MOV qword ptr [RBP + -0x68],RAX
LEA RAX,[R10 + 0x128]
MOV qword ptr [RBP + -0x60],RAX
SHL RDX,0x3
MOV qword ptr [RBP + -0x78],RDX
LEA RAX,[R10 + 0x130]
MOV qword ptr [RBP + -0x58],RAX
MOV dword ptr [RBP + -0x3c],R8D
MOV R11D,R8D
MOV dword ptr [RBP + -0x34],ECX
MOV R12D,ECX
MOV R8,R10
MOV qword ptr [RBP + -0x80],R11
LAB_00153fb5:
LEA EAX,[RDI + -0x1]
MOV ECX,EAX
SHR ECX,0x1
OR ECX,EAX
MOV EAX,ECX
SHR EAX,0x2
OR EAX,ECX
MOV ECX,EAX
SHR ECX,0x4
OR ECX,EAX
MOV EAX,ECX
SHR EAX,0x8
OR EAX,ECX
MOV ECX,EAX
SHR ECX,0x10
OR ECX,EAX
LEA EDX,[0x2 + RCX*0x2]
MOV RAX,RDI
SHR RAX,0x2
ADD RAX,RDI
CMP RAX,RDX
SETA CL
SHL EDX,CL
MOV dword ptr [R8 + 0x38],EDX
MOV RAX,RDI
SHL RAX,0x5
LEA RAX,[RAX + RAX*0x2]
MOV qword ptr [RBP + -0xa0],RAX
MOV EAX,R13D
LEA R14,[RDI + 0x1]
MOV R13,R11
IMUL R13,R14
MOV RBX,R12
IMUL RBX,R14
MOV RCX,R14
IMUL RCX,RAX
LEA RSI,[RAX + 0xd0]
IMUL RSI,RDI
ADD RSI,qword ptr [RBP + -0x98]
LEA RSI,[RSI + RDX*0x8]
MOV RDX,-0x70
SUB RDX,RAX
MOV qword ptr [RBP + -0x88],RDI
IMUL R15,RDI,0x70
ADD R15,0x70
LAB_00154054:
DEC R14
SUB R13,R11
SUB RBX,R12
SUB RCX,RAX
ADD R15,-0x70
CMP R14,0x9
JC 0x00154076
LEA RDI,[RSI + RDX*0x1]
CMP RSI,R9
MOV RSI,RDI
JA 0x00154054
LAB_00154076:
MOV qword ptr [R8 + 0x10],RCX
MOV RDI,qword ptr [RBP + -0x90]
XOR ESI,ESI
CALL 0x00160124
MOV R8,qword ptr [RBP + -0x30]
MOV qword ptr [R8 + 0xa8],RAX
TEST RAX,RAX
JZ 0x0015410b
LEA RAX,[0x4aeeb8]
MOV EDI,dword ptr [RAX]
MOV R9D,dword ptr [R8 + 0x38]
SHL R9,0x3
SUB RSP,0x8
MOV ESI,0x20
MOV RDX,qword ptr [RBP + -0x48]
MOV RCX,R15
MOV R15,R8
MOV R8,qword ptr [RBP + -0x70]
XOR EAX,EAX
PUSH 0x0
MOV R10,qword ptr [RBP + -0x78]
PUSH R10
PUSH qword ptr [RBP + -0x58]
PUSH R10
PUSH qword ptr [RBP + -0x60]
PUSH qword ptr [RBP + -0xa0]
PUSH qword ptr [RBP + -0x68]
CALL 0x00157b69
ADD RSP,0x40
TEST RAX,RAX
JNZ 0x001541ce
MOV RSI,qword ptr [R15 + 0x10]
MOV RDI,qword ptr [R15 + 0xa8]
CALL 0x001605d3
MOV qword ptr [R15 + 0xa8],0x0
MOV R8,R15
LAB_0015410b:
CMP R14,0x7
JBE 0x00154138
SHR R14,0x2
LEA RDI,[R14 + R14*0x2]
MOV R13D,dword ptr [R8 + 0x18]
MOV R9,qword ptr [RBP + -0x50]
MOV R11,qword ptr [RBP + -0x80]
JMP 0x00153fb5
LAB_0015412a:
MOV byte ptr [R10 + 0x3],0x0
MOV R14D,dword ptr [R10 + 0x48]
JMP 0x00154272
LAB_00154138:
CALL 0x0015be8e
MOV dword ptr [RAX],0xc
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x18]
IMUL R14,RAX
XOR R15D,R15D
MOV ESI,0x1000
MOV EDI,0x5
MOV RDX,R14
XOR EAX,EAX
CALL 0x001586b7
CALL 0x0015be8e
MOV RCX,qword ptr [RBP + -0x30]
MOV EBX,dword ptr [RAX]
MOV dword ptr [RCX + 0x48],R15D
MOV dword ptr [RCX + 0x160],R15D
MOV RDI,qword ptr [RCX + 0xa8]
TEST RDI,RDI
JZ 0x0015419f
MOV RSI,qword ptr [RCX + 0x10]
CALL 0x001605d3
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0xa8],0x0
LAB_0015419f:
MOV R14,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [R14]
TEST RDI,RDI
JZ 0x001541b7
CALL 0x0015a3fa
MOV qword ptr [R14],0x0
LAB_001541b7:
CALL 0x0015be8e
MOV dword ptr [RAX],EBX
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX + 0x3],0x0
XOR R14D,R14D
JMP 0x00154282
LAB_001541ce:
MOV qword ptr [R15 + 0x58],R14
MOV dword ptr [R15 + 0x48],R14D
MOV RAX,qword ptr [RBP + -0x88]
ADD EAX,EAX
MOV dword ptr [R15 + 0x40],EAX
MOV dword ptr [R15 + 0x44],0x0
XOR EAX,EAX
MOV qword ptr [R15 + 0x50],RAX
MOV qword ptr [R15 + 0x138],RAX
MOV qword ptr [R15 + 0x78],RAX
MOV qword ptr [R15 + 0x30],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + 0x60],XMM0
MOVUPS xmmword ptr [R15 + 0x90],XMM0
MOVUPS xmmword ptr [R15 + 0xb0],XMM0
MOV RCX,0x28f5c28f5c28f5c3
MOV RDX,R14
CMP dword ptr [RBP + -0x34],0x0
MOV R10,R15
JZ 0x0015423f
SHR RBX,0x2
MOV RAX,RBX
MUL RCX
SHR RDX,0x2
INC RDX
LAB_0015423f:
MOV qword ptr [R10 + 0x20],RDX
MOV RDX,R14
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x0015425a
SHR R13,0x2
MOV RAX,R13
MUL RCX
SHR RDX,0x2
LAB_0015425a:
MOV qword ptr [R10 + 0x28],RDX
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [R10 + 0x3c],EAX
MOV byte ptr [R10 + 0x3],0x1
MOVUPS xmmword ptr [R10 + 0x118],XMM0
LAB_00154272:
XOR EAX,EAX
TEST R14D,R14D
CMOVG EAX,R14D
MOV dword ptr [R10 + 0x160],EAX
LAB_00154282:
MOV EAX,R14D
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong init_simple_key_cache
(char *param_1,uint param_2,ulong param_3,uint param_4,uint param_5,uint param_6)
{
pthread_mutex_t *__mutex;
long *plVar1;
int4 uVar2;
bool bVar3;
uint uVar4;
int iVar5;
int8 uVar6;
ulong uVar7;
int4 *puVar8;
long lVar9;
uint uVar10;
long lVar11;
ulong uVar12;
ulong uVar13;
ulong uVar14;
ulong uVar15;
ulong uVar16;
long lVar17;
uVar12 = (ulong)param_2;
if ((*param_1 == '\0') || (uVar16 = 0, *(int *)(param_1 + 0x48) < 1)) {
param_1[0x50] = '\0';
param_1[0x51] = '\0';
param_1[0x52] = '\0';
param_1[0x53] = '\0';
param_1[0x54] = '\0';
param_1[0x55] = '\0';
param_1[0x56] = '\0';
param_1[0x57] = '\0';
param_1[0x58] = '\0';
param_1[0x59] = '\0';
param_1[0x5a] = '\0';
param_1[0x5b] = '\0';
param_1[0x5c] = '\0';
param_1[0x5d] = '\0';
param_1[0x5e] = '\0';
param_1[0x5f] = '\0';
param_1[0x138] = '\0';
param_1[0x139] = '\0';
param_1[0x13a] = '\0';
param_1[0x13b] = '\0';
param_1[0x13c] = '\0';
param_1[0x13d] = '\0';
param_1[0x13e] = '\0';
param_1[0x13f] = '\0';
param_1[0x140] = '\0';
param_1[0x141] = '\0';
param_1[0x142] = '\0';
param_1[0x143] = '\0';
param_1[0x144] = '\0';
param_1[0x145] = '\0';
param_1[0x146] = '\0';
param_1[0x147] = '\0';
param_1[0x148] = '\0';
param_1[0x149] = '\0';
param_1[0x14a] = '\0';
param_1[0x14b] = '\0';
param_1[0x14c] = '\0';
param_1[0x14d] = '\0';
param_1[0x14e] = '\0';
param_1[0x14f] = '\0';
param_1[0x150] = '\0';
param_1[0x151] = '\0';
param_1[0x152] = '\0';
param_1[0x153] = '\0';
param_1[0x154] = '\0';
param_1[0x155] = '\0';
param_1[0x156] = '\0';
param_1[0x157] = '\0';
param_1[0x158] = '\0';
param_1[0x159] = '\0';
param_1[0x15a] = '\0';
param_1[0x15b] = '\0';
param_1[0x15c] = '\0';
param_1[0x15d] = '\0';
param_1[0x15e] = '\0';
param_1[0x15f] = '\0';
param_1[0x48] = -1;
param_1[0x49] = -1;
param_1[0x4a] = -1;
param_1[0x4b] = -1;
if (*param_1 == '\0') {
param_1[0] = '\x01';
param_1[1] = '\0';
param_1[0x164] = '\x01';
param_1[0x165] = '\0';
param_1[0x166] = '\0';
param_1[0x167] = '\0';
param_1[2] = '\0';
param_1[0x70] = '\0';
param_1[0x71] = '\0';
param_1[0x72] = '\0';
param_1[0x73] = '\0';
param_1[0x74] = '\0';
param_1[0x75] = '\0';
param_1[0x76] = '\0';
param_1[0x77] = '\0';
param_1[0x110] = '\0';
param_1[0x111] = '\0';
param_1[0x112] = '\0';
param_1[0x113] = '\0';
param_1[0x114] = '\0';
param_1[0x115] = '\0';
param_1[0x116] = '\0';
param_1[0x117] = '\0';
param_1[0x168] = '\0';
__mutex = (pthread_mutex_t *)(param_1 + 0xc0);
uVar6 = (**(code **)(PSI_server + 0x40))(key_KEY_CACHE_cache_lock,__mutex);
*(int8 *)(param_1 + 0x100) = uVar6;
*(pthread_mutex_t **)(param_1 + 0xf8) = __mutex;
param_1[0xe8] = '\0';
param_1[0xe9] = '\0';
param_1[0xea] = '\0';
param_1[0xeb] = '\0';
param_1[0xec] = '\0';
param_1[0xed] = '\0';
param_1[0xee] = '\0';
param_1[0xef] = '\0';
param_1[0xf0] = '\0';
param_1[0xf1] = '\0';
param_1[0xf2] = '\0';
param_1[0xf3] = '\0';
param_1[0xf4] = '\0';
param_1[0xf5] = '\0';
param_1[0xf6] = '\0';
param_1[0xf7] = '\0';
pthread_mutex_init(__mutex,(pthread_mutexattr_t *)&my_fast_mutexattr);
param_1[0x108] = '\0';
param_1[0x109] = '\0';
param_1[0x10a] = '\0';
param_1[0x10b] = '\0';
param_1[0x10c] = '\0';
param_1[0x10d] = '\0';
param_1[0x10e] = '\0';
param_1[0x10f] = '\0';
}
*(ulong *)(param_1 + 8) = param_3;
*(uint *)(param_1 + 0x18) = param_2;
uVar7 = param_3 / ((ulong)param_2 + 0xda);
uVar10 = 0x80;
if (0x80 < param_6) {
uVar10 = param_6;
}
if (7 < uVar7) {
uVar10 = uVar10 - 1 >> 1 | uVar10 - 1;
uVar10 = uVar10 >> 2 | uVar10;
uVar10 = uVar10 >> 4 | uVar10;
uVar10 = uVar10 >> 8 | uVar10;
uVar10 = (uVar10 >> 0x10 | uVar10) + 1;
plVar1 = (long *)(param_1 + 0xa0);
lVar11 = (ulong)uVar10 << 3;
do {
uVar4 = (int)uVar7 - 1;
uVar4 = uVar4 >> 1 | uVar4;
uVar4 = uVar4 >> 2 | uVar4;
uVar4 = uVar4 >> 4 | uVar4;
uVar4 = uVar4 >> 8 | uVar4;
uVar4 = (uVar4 >> 0x10 | uVar4) * 2 + 2;
uVar4 = uVar4 << ((ulong)uVar4 < (uVar7 >> 2) + uVar7);
*(uint *)(param_1 + 0x38) = uVar4;
uVar16 = uVar7 + 1;
uVar15 = param_5 * uVar16;
uVar13 = param_4 * uVar16;
lVar9 = uVar16 * uVar12;
lVar17 = uVar7 * 0x70 + 0x70;
uVar14 = (uVar12 + 0xd0) * uVar7 + (ulong)uVar10 * 0x10 + (ulong)uVar4 * 8;
do {
uVar16 = uVar16 - 1;
uVar15 = uVar15 - param_5;
uVar13 = uVar13 - param_4;
lVar9 = lVar9 - uVar12;
lVar17 = lVar17 + -0x70;
if (uVar16 < 9) break;
bVar3 = param_3 < uVar14;
uVar14 = uVar14 + (-0x70 - uVar12);
} while (bVar3);
*(long *)(param_1 + 0x10) = lVar9;
lVar9 = my_large_malloc(param_1 + 0x10,0);
*(long *)(param_1 + 0xa8) = lVar9;
if (lVar9 != 0) {
lVar9 = my_multi_malloc_large
(key_memory_KEY_CACHE,0x20,plVar1,lVar17,param_1 + 0x80,
(ulong)*(uint *)(param_1 + 0x38) << 3,param_1 + 0x88,uVar7 * 0x60,
param_1 + 0x128,lVar11,param_1 + 0x130,lVar11,0);
if (lVar9 != 0) {
*(ulong *)(param_1 + 0x58) = uVar16;
*(int *)(param_1 + 0x48) = (int)uVar16;
*(int *)(param_1 + 0x40) = (int)uVar7 * 2;
param_1[0x44] = '\0';
param_1[0x45] = '\0';
param_1[0x46] = '\0';
param_1[0x47] = '\0';
param_1[0x50] = '\0';
param_1[0x51] = '\0';
param_1[0x52] = '\0';
param_1[0x53] = '\0';
param_1[0x54] = '\0';
param_1[0x55] = '\0';
param_1[0x56] = '\0';
param_1[0x57] = '\0';
param_1[0x138] = '\0';
param_1[0x139] = '\0';
param_1[0x13a] = '\0';
param_1[0x13b] = '\0';
param_1[0x13c] = '\0';
param_1[0x13d] = '\0';
param_1[0x13e] = '\0';
param_1[0x13f] = '\0';
param_1[0x78] = '\0';
param_1[0x79] = '\0';
param_1[0x7a] = '\0';
param_1[0x7b] = '\0';
param_1[0x7c] = '\0';
param_1[0x7d] = '\0';
param_1[0x7e] = '\0';
param_1[0x7f] = '\0';
param_1[0x30] = '\0';
param_1[0x31] = '\0';
param_1[0x32] = '\0';
param_1[0x33] = '\0';
param_1[0x34] = '\0';
param_1[0x35] = '\0';
param_1[0x36] = '\0';
param_1[0x37] = '\0';
param_1[0x60] = '\0';
param_1[0x61] = '\0';
param_1[0x62] = '\0';
param_1[99] = '\0';
param_1[100] = '\0';
param_1[0x65] = '\0';
param_1[0x66] = '\0';
param_1[0x67] = '\0';
param_1[0x68] = '\0';
param_1[0x69] = '\0';
param_1[0x6a] = '\0';
param_1[0x6b] = '\0';
param_1[0x6c] = '\0';
param_1[0x6d] = '\0';
param_1[0x6e] = '\0';
param_1[0x6f] = '\0';
param_1[0x90] = '\0';
param_1[0x91] = '\0';
param_1[0x92] = '\0';
param_1[0x93] = '\0';
param_1[0x94] = '\0';
param_1[0x95] = '\0';
param_1[0x96] = '\0';
param_1[0x97] = '\0';
param_1[0x98] = '\0';
param_1[0x99] = '\0';
param_1[0x9a] = '\0';
param_1[0x9b] = '\0';
param_1[0x9c] = '\0';
param_1[0x9d] = '\0';
param_1[0x9e] = '\0';
param_1[0x9f] = '\0';
param_1[0xb0] = '\0';
param_1[0xb1] = '\0';
param_1[0xb2] = '\0';
param_1[0xb3] = '\0';
param_1[0xb4] = '\0';
param_1[0xb5] = '\0';
param_1[0xb6] = '\0';
param_1[0xb7] = '\0';
param_1[0xb8] = '\0';
param_1[0xb9] = '\0';
param_1[0xba] = '\0';
param_1[0xbb] = '\0';
param_1[0xbc] = '\0';
param_1[0xbd] = '\0';
param_1[0xbe] = '\0';
param_1[0xbf] = '\0';
uVar12 = uVar16;
if (param_4 != 0) {
uVar12 = uVar13 / 100 + 1;
}
*(ulong *)(param_1 + 0x20) = uVar12;
uVar12 = uVar16;
if (param_5 != 0) {
uVar12 = uVar15 / 100;
}
*(ulong *)(param_1 + 0x28) = uVar12;
*(uint *)(param_1 + 0x3c) = uVar10;
param_1[3] = '\x01';
param_1[0x118] = '\0';
param_1[0x119] = '\0';
param_1[0x11a] = '\0';
param_1[0x11b] = '\0';
param_1[0x11c] = '\0';
param_1[0x11d] = '\0';
param_1[0x11e] = '\0';
param_1[0x11f] = '\0';
param_1[0x120] = '\0';
param_1[0x121] = '\0';
param_1[0x122] = '\0';
param_1[0x123] = '\0';
param_1[0x124] = '\0';
param_1[0x125] = '\0';
param_1[0x126] = '\0';
param_1[0x127] = '\0';
goto LAB_00154272;
}
my_large_free(*(int8 *)(param_1 + 0xa8),*(int8 *)(param_1 + 0x10));
param_1[0xa8] = '\0';
param_1[0xa9] = '\0';
param_1[0xaa] = '\0';
param_1[0xab] = '\0';
param_1[0xac] = '\0';
param_1[0xad] = '\0';
param_1[0xae] = '\0';
param_1[0xaf] = '\0';
}
if (uVar16 < 8) goto LAB_00154138;
uVar7 = (uVar16 >> 2) * 3;
uVar12 = (ulong)*(uint *)(param_1 + 0x18);
} while( true );
}
param_1[3] = '\0';
uVar16 = (ulong)*(uint *)(param_1 + 0x48);
LAB_00154272:
iVar5 = 0;
if (0 < (int)uVar16) {
iVar5 = (int)uVar16;
}
*(int *)(param_1 + 0x160) = iVar5;
}
LAB_00154282:
return uVar16 & 0xffffffff;
LAB_00154138:
puVar8 = (int4 *)_my_thread_var();
*puVar8 = 0xc;
my_error(5,0x1000,uVar16 * *(uint *)(param_1 + 0x18));
puVar8 = (int4 *)_my_thread_var();
uVar2 = *puVar8;
param_1[0x48] = '\0';
param_1[0x49] = '\0';
param_1[0x4a] = '\0';
param_1[0x4b] = '\0';
param_1[0x160] = '\0';
param_1[0x161] = '\0';
param_1[0x162] = '\0';
param_1[0x163] = '\0';
if (*(long *)(param_1 + 0xa8) != 0) {
my_large_free(*(long *)(param_1 + 0xa8),*(int8 *)(param_1 + 0x10));
param_1[0xa8] = '\0';
param_1[0xa9] = '\0';
param_1[0xaa] = '\0';
param_1[0xab] = '\0';
param_1[0xac] = '\0';
param_1[0xad] = '\0';
param_1[0xae] = '\0';
param_1[0xaf] = '\0';
}
if (*plVar1 != 0) {
my_free();
*plVar1 = 0;
}
puVar8 = (int4 *)_my_thread_var();
*puVar8 = uVar2;
param_1[3] = '\0';
uVar16 = 0;
goto LAB_00154282;
}
|
|
3,250 | typed_array_init | bluesky950520[P]quickjs/quickjs.c | static int typed_array_init(JSContext *ctx, JSValue obj, JSValue buffer,
uint64_t offset, uint64_t len, BOOL track_rab)
{
JSTypedArray *ta;
JSObject *p, *pbuffer;
JSArrayBuffer *abuf;
int size_log2;
p = JS_VALUE_GET_OBJ(obj);
size_log2 = typed_array_size_log2(p->class_id);
ta = js_malloc(ctx, sizeof(*ta));
if (!ta) {
JS_FreeValue(ctx, buffer);
return -1;
}
pbuffer = JS_VALUE_GET_OBJ(buffer);
abuf = pbuffer->u.array_buffer;
ta->obj = p;
ta->buffer = pbuffer;
ta->offset = offset;
ta->length = len << size_log2;
ta->track_rab = track_rab;
list_add_tail(&ta->link, &abuf->array_list);
p->u.typed_array = ta;
p->u.array.count = len;
p->u.array.u.ptr = abuf->data + offset;
return 0;
} | O1 | c | typed_array_init:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rcx, 0x8(%rsp)
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %r13
movq %rdx, 0x10(%rsp)
movzwl 0x6(%rsi), %eax
leaq 0x8ad9a(%rip), %rcx # 0x9d8df
movzbl -0x15(%rax,%rcx), %r12d
pushq $0x30
popq %rsi
callq 0xede6
testq %rax, %rax
je 0x12bab
movl 0x50(%rsp), %edx
movq 0x10(%rsp), %rsi
movq 0x30(%rsi), %rdi
movq %r15, 0x10(%rax)
movq %r14, %r8
movl %r12d, %ecx
shlq %cl, %r8
movq %rsi, 0x18(%rax)
movl %ebx, 0x20(%rax)
movl %r8d, 0x24(%rax)
movl %edx, 0x28(%rax)
leaq 0x18(%rdi), %rcx
movq 0x18(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x18(%rdi)
movq %rax, 0x30(%r15)
movl %r14d, 0x40(%r15)
addq 0x10(%rdi), %rbx
movq %rbx, 0x38(%r15)
xorl %eax, %eax
jmp 0x12bbf
movq 0x18(%r13), %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
callq 0x1d8c6
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| typed_array_init:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, r9
mov rbx, r8
mov [rsp+48h+var_40], rcx
mov rbp, rdx
mov r15, rsi
mov r13, rdi
mov [rsp+48h+var_38], rdx
movzx eax, word ptr [rsi+6]
lea rcx, typed_array_size_log2
movzx r12d, byte ptr [rax+rcx-15h]
push 30h ; '0'
pop rsi
call js_malloc
test rax, rax
jz short loc_12BAB
mov edx, [rsp+48h+arg_0]
mov rsi, [rsp+48h+var_38]
mov rdi, [rsi+30h]
mov [rax+10h], r15
mov r8, r14
mov ecx, r12d
shl r8, cl
mov [rax+18h], rsi
mov [rax+20h], ebx
mov [rax+24h], r8d
mov [rax+28h], edx
lea rcx, [rdi+18h]
mov rdx, [rdi+18h]
mov [rdx+8], rax
mov [rax], rdx
mov [rax+8], rcx
mov [rdi+18h], rax
mov [r15+30h], rax
mov [r15+40h], r14d
add rbx, [rdi+10h]
mov [r15+38h], rbx
xor eax, eax
jmp short loc_12BBF
loc_12BAB:
mov rdi, [r13+18h]
mov rsi, rbp
mov rdx, [rsp+48h+var_40]
call JS_FreeValueRT
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_12BBF:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long typed_array_init(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6, int a7)
{
char v10; // r12
long long v11; // rax
long long v12; // rdi
long long v13; // rdx
v10 = typed_array_size_log2[*(unsigned __int16 *)(a2 + 6) - 21];
v11 = js_malloc(a1, 48LL);
if ( v11 )
{
v12 = *(_QWORD *)(a3 + 48);
*(_QWORD *)(v11 + 16) = a2;
*(_QWORD *)(v11 + 24) = a3;
*(_DWORD *)(v11 + 32) = a5;
*(_DWORD *)(v11 + 36) = a6 << v10;
*(_DWORD *)(v11 + 40) = a7;
v13 = *(_QWORD *)(v12 + 24);
*(_QWORD *)(v13 + 8) = v11;
*(_QWORD *)v11 = v13;
*(_QWORD *)(v11 + 8) = v12 + 24;
*(_QWORD *)(v12 + 24) = v11;
*(_QWORD *)(a2 + 48) = v11;
*(_DWORD *)(a2 + 64) = a6;
*(_QWORD *)(a2 + 56) = *(_QWORD *)(v12 + 16) + a5;
return 0LL;
}
else
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), a3);
return -1LL;
}
}
| |||
3,251 | typed_array_init | bluesky950520[P]quickjs/quickjs.c | static int typed_array_init(JSContext *ctx, JSValue obj, JSValue buffer,
uint64_t offset, uint64_t len, BOOL track_rab)
{
JSTypedArray *ta;
JSObject *p, *pbuffer;
JSArrayBuffer *abuf;
int size_log2;
p = JS_VALUE_GET_OBJ(obj);
size_log2 = typed_array_size_log2(p->class_id);
ta = js_malloc(ctx, sizeof(*ta));
if (!ta) {
JS_FreeValue(ctx, buffer);
return -1;
}
pbuffer = JS_VALUE_GET_OBJ(buffer);
abuf = pbuffer->u.array_buffer;
ta->obj = p;
ta->buffer = pbuffer;
ta->offset = offset;
ta->length = len << size_log2;
ta->track_rab = track_rab;
list_add_tail(&ta->link, &abuf->array_list);
p->u.typed_array = ta;
p->u.array.count = len;
p->u.array.u.ptr = abuf->data + offset;
return 0;
} | O2 | c | typed_array_init:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %rbx
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbp
movzwl 0x6(%rsi), %eax
leaq 0x19f06(%rip), %rcx # 0x8487f
movzbl -0x15(%rax,%rcx), %r13d
pushq $0x30
popq %rsi
callq 0x17214
testq %rax, %rax
je 0x6a9da
movl 0x40(%rsp), %edx
movq 0x30(%r12), %rsi
movq %r15, 0x10(%rax)
movq %r14, %rdi
movl %r13d, %ecx
shlq %cl, %rdi
movq %r12, 0x18(%rax)
movl %ebx, 0x20(%rax)
movl %edi, 0x24(%rax)
movl %edx, 0x28(%rax)
leaq 0x18(%rsi), %rcx
movq 0x18(%rsi), %rdx
movq %rax, 0x8(%rdx)
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x18(%rsi)
movq %rax, 0x30(%r15)
movl %r14d, 0x40(%r15)
addq 0x10(%rsi), %rbx
movq %rbx, 0x38(%r15)
xorl %eax, %eax
jmp 0x6a9ec
movq %rbp, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
callq 0x1801e
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| typed_array_init:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r9
mov rbx, r8
mov [rsp+38h+var_38], rcx
mov r12, rdx
mov r15, rsi
mov rbp, rdi
movzx eax, word ptr [rsi+6]
lea rcx, typed_array_size_log2
movzx r13d, byte ptr [rax+rcx-15h]
push 30h ; '0'
pop rsi
call js_malloc
test rax, rax
jz short loc_6A9DA
mov edx, [rsp+38h+arg_0]
mov rsi, [r12+30h]
mov [rax+10h], r15
mov rdi, r14
mov ecx, r13d
shl rdi, cl
mov [rax+18h], r12
mov [rax+20h], ebx
mov [rax+24h], edi
mov [rax+28h], edx
lea rcx, [rsi+18h]
mov rdx, [rsi+18h]
mov [rdx+8], rax
mov [rax], rdx
mov [rax+8], rcx
mov [rsi+18h], rax
mov [r15+30h], rax
mov [r15+40h], r14d
add rbx, [rsi+10h]
mov [r15+38h], rbx
xor eax, eax
jmp short loc_6A9EC
loc_6A9DA:
mov rdi, rbp
mov rsi, r12
mov rdx, [rsp+38h+var_38]
call JS_FreeValue
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_6A9EC:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long typed_array_init(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6, int a7)
{
char v11; // r13
long long v12; // rax
long long v13; // rsi
long long v14; // rdx
v11 = typed_array_size_log2[*(unsigned __int16 *)(a2 + 6) - 21];
v12 = js_malloc(a1, 48LL);
if ( v12 )
{
v13 = *(_QWORD *)(a3 + 48);
*(_QWORD *)(v12 + 16) = a2;
*(_QWORD *)(v12 + 24) = a3;
*(_DWORD *)(v12 + 32) = a5;
*(_DWORD *)(v12 + 36) = a6 << v11;
*(_DWORD *)(v12 + 40) = a7;
v14 = *(_QWORD *)(v13 + 24);
*(_QWORD *)(v14 + 8) = v12;
*(_QWORD *)v12 = v14;
*(_QWORD *)(v12 + 8) = v13 + 24;
*(_QWORD *)(v13 + 24) = v12;
*(_QWORD *)(a2 + 48) = v12;
*(_DWORD *)(a2 + 64) = a6;
*(_QWORD *)(a2 + 56) = *(_QWORD *)(v13 + 16) + a5;
return 0LL;
}
else
{
JS_FreeValue(a1, a3, a4);
return -1LL;
}
}
| typed_array_init:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R9
MOV RBX,R8
MOV qword ptr [RSP],RCX
MOV R12,RDX
MOV R15,RSI
MOV RBP,RDI
MOVZX EAX,word ptr [RSI + 0x6]
LEA RCX,[0x18487f]
MOVZX R13D,byte ptr [RAX + RCX*0x1 + -0x15]
PUSH 0x30
POP RSI
CALL 0x00117214
TEST RAX,RAX
JZ 0x0016a9da
MOV EDX,dword ptr [RSP + 0x40]
MOV RSI,qword ptr [R12 + 0x30]
MOV qword ptr [RAX + 0x10],R15
MOV RDI,R14
MOV ECX,R13D
SHL RDI,CL
MOV qword ptr [RAX + 0x18],R12
MOV dword ptr [RAX + 0x20],EBX
MOV dword ptr [RAX + 0x24],EDI
MOV dword ptr [RAX + 0x28],EDX
LEA RCX,[RSI + 0x18]
MOV RDX,qword ptr [RSI + 0x18]
MOV qword ptr [RDX + 0x8],RAX
MOV qword ptr [RAX],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RSI + 0x18],RAX
MOV qword ptr [R15 + 0x30],RAX
MOV dword ptr [R15 + 0x40],R14D
ADD RBX,qword ptr [RSI + 0x10]
MOV qword ptr [R15 + 0x38],RBX
XOR EAX,EAX
JMP 0x0016a9ec
LAB_0016a9da:
MOV RDI,RBP
MOV RSI,R12
MOV RDX,qword ptr [RSP]
CALL 0x0011801e
PUSH -0x1
POP RAX
LAB_0016a9ec:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
typed_array_init(int8 param_1,long param_2,long param_3,int8 param_4,long param_5,
long param_6,int4 param_7)
{
byte bVar1;
long lVar2;
long lVar3;
long *plVar4;
int8 uVar5;
bVar1 = "toSorted"[(ulong)*(ushort *)(param_2 + 6) + 6];
plVar4 = (long *)js_malloc(param_1,0x30);
if (plVar4 == (long *)0x0) {
JS_FreeValue(param_1,param_3,param_4);
uVar5 = 0xffffffffffffffff;
}
else {
lVar2 = *(long *)(param_3 + 0x30);
plVar4[2] = param_2;
plVar4[3] = param_3;
*(int *)(plVar4 + 4) = (int)param_5;
*(int *)((long)plVar4 + 0x24) = (int)(param_6 << (bVar1 & 0x3f));
*(int4 *)(plVar4 + 5) = param_7;
lVar3 = *(long *)(lVar2 + 0x18);
*(long **)(lVar3 + 8) = plVar4;
*plVar4 = lVar3;
plVar4[1] = lVar2 + 0x18;
*(long **)(lVar2 + 0x18) = plVar4;
*(long **)(param_2 + 0x30) = plVar4;
*(int *)(param_2 + 0x40) = (int)param_6;
*(long *)(param_2 + 0x38) = param_5 + *(long *)(lVar2 + 0x10);
uVar5 = 0;
}
return uVar5;
}
|
|
3,252 | my_symlink | eloqsql/mysys/my_symlink.c | int my_symlink(const char *content, const char *linkname, myf MyFlags)
{
#ifndef HAVE_READLINK
return 0;
#else
int result;
DBUG_ENTER("my_symlink");
DBUG_PRINT("enter",("content: %s linkname: %s", content, linkname));
result= 0;
if (symlink(content, linkname))
{
result= -1;
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_CANT_SYMLINK, MYF(0), linkname, content, errno);
}
else if ((MyFlags & MY_SYNC_DIR) && my_sync_dir_by_file(linkname, MyFlags))
result= -1;
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
} | O0 | c | my_symlink:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0xf4f36
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a060
cmpl $0x0, %eax
je 0xf4faa
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
callq 0x2a760
movl (%rax), %eax
movl %eax, -0x20(%rbp)
callq 0xf6090
movl -0x20(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0xf4fa8
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2a760
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl (%rax), %r8d
movl $0x19, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0xefb40
jmp 0xf4fd5
movq -0x18(%rbp), %rax
andq $0x8000, %rax # imm = 0x8000
cmpq $0x0, %rax
je 0xf4fd3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf5d30
cmpl $0x0, %eax
je 0xf4fd3
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0xf4fd5
jmp 0xf4fd7
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_symlink:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
jmp short $+2
loc_F4F36:
mov [rbp+var_1C], 0
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call _symlink
cmp eax, 0
jz short loc_F4FAA
mov [rbp+var_1C], 0FFFFFFFFh
call ___errno_location
mov eax, [rax]
mov [rbp+var_20], eax
call _my_thread_var
mov ecx, [rbp+var_20]
mov [rax], ecx
mov rax, [rbp+var_18]
and rax, 10h
cmp rax, 0
jz short loc_F4FA8
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
call ___errno_location
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_28]
mov r8d, [rax]
mov edi, 19h
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_F4FA8:
jmp short loc_F4FD5
loc_F4FAA:
mov rax, [rbp+var_18]
and rax, 8000h
cmp rax, 0
jz short loc_F4FD3
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call my_sync_dir_by_file
cmp eax, 0
jz short loc_F4FD3
mov [rbp+var_1C], 0FFFFFFFFh
loc_F4FD3:
jmp short $+2
loc_F4FD5:
jmp short $+2
loc_F4FD7:
mov eax, [rbp+var_1C]
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
add rsp, 40h
pop rbp
retn
| long long my_symlink(long long a1, const char *a2, long long a3)
{
unsigned int *v3; // rax
int v5; // [rsp+20h] [rbp-20h]
unsigned int v6; // [rsp+24h] [rbp-1Ch]
v6 = 0;
if ( (unsigned int)symlink(a1, a2) )
{
v6 = -1;
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a1, a2) = v5;
if ( (a3 & 0x10) != 0 )
{
v3 = (unsigned int *)__errno_location();
my_error(0x19u, 0LL, a2, a1, *v3);
}
}
else if ( (a3 & 0x8000) != 0 && (unsigned int)my_sync_dir_by_file(a2, a3) )
{
return (unsigned int)-1;
}
return v6;
}
| my_symlink:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x001f4f36
LAB_001f4f36:
MOV dword ptr [RBP + -0x1c],0x0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0012a060
CMP EAX,0x0
JZ 0x001f4faa
MOV dword ptr [RBP + -0x1c],0xffffffff
CALL 0x0012a760
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x20],EAX
CALL 0x001f6090
MOV ECX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x10
CMP RAX,0x0
JZ 0x001f4fa8
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
CALL 0x0012a760
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8D,dword ptr [RAX]
MOV EDI,0x19
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x001efb40
LAB_001f4fa8:
JMP 0x001f4fd5
LAB_001f4faa:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x8000
CMP RAX,0x0
JZ 0x001f4fd3
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001f5d30
CMP EAX,0x0
JZ 0x001f4fd3
MOV dword ptr [RBP + -0x1c],0xffffffff
LAB_001f4fd3:
JMP 0x001f4fd5
LAB_001f4fd5:
JMP 0x001f4fd7
LAB_001f4fd7:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
ADD RSP,0x40
POP RBP
RET
|
int4 my_symlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
int *piVar2;
int4 local_24;
local_24 = 0;
iVar1 = symlink(param_1,param_2);
if (iVar1 == 0) {
if (((param_3 & 0x8000) != 0) && (iVar1 = my_sync_dir_by_file(param_2,param_3), iVar1 != 0)) {
local_24 = 0xffffffff;
}
}
else {
local_24 = 0xffffffff;
piVar2 = __errno_location();
iVar1 = *piVar2;
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar1;
if ((param_3 & 0x10) != 0) {
piVar2 = __errno_location();
my_error(0x19,0,param_2,param_1,*piVar2);
}
}
return local_24;
}
|
|
3,253 | hp_close | eloqsql/storage/heap/hp_close.c | int hp_close(register HP_INFO *info)
{
int error=0;
DBUG_ENTER("hp_close");
info->s->changed=0;
if (info->open_list.data)
heap_open_list=list_delete(heap_open_list,&info->open_list);
if (!--info->s->open_count && info->s->delete_on_close)
hp_free(info->s); /* Table was deleted */
my_free(info);
DBUG_RETURN(error);
} | O0 | c | hp_close:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x0, 0xfc(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2d8(%rax)
je 0x25a59
leaq 0x36ce37(%rip), %rax # 0x392870
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x2c8, %rsi # imm = 0x2C8
callq 0x2b0e0
movq %rax, %rcx
leaq 0x36ce1a(%rip), %rax # 0x392870
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movl 0x10c(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x10c(%rcx)
cmpl $0x0, %eax
jne 0x25a93
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x220(%rax), %eax
cmpl $0x0, %eax
je 0x25a93
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x26480
movq -0x8(%rbp), %rdi
callq 0x2e170
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| hp_close:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], 0
mov rax, [rbp+var_8]
mov rax, [rax]
mov dword ptr [rax+0FCh], 0
mov rax, [rbp+var_8]
cmp qword ptr [rax+2D8h], 0
jz short loc_25A59
lea rax, heap_open_list
mov rdi, [rax]
mov rsi, [rbp+var_8]
add rsi, 2C8h
call list_delete
mov rcx, rax
lea rax, heap_open_list
mov [rax], rcx
loc_25A59:
mov rax, [rbp+var_8]
mov rcx, [rax]
mov eax, [rcx+10Ch]
add eax, 0FFFFFFFFh
mov [rcx+10Ch], eax
cmp eax, 0
jnz short loc_25A93
mov rax, [rbp+var_8]
mov rax, [rax]
movsx eax, byte ptr [rax+220h]
cmp eax, 0
jz short loc_25A93
mov rax, [rbp+var_8]
mov rdi, [rax]
call hp_free
loc_25A93:
mov rdi, [rbp+var_8]
call my_free
mov eax, [rbp+var_C]
mov [rbp+var_10], eax
mov eax, [rbp+var_10]
add rsp, 10h
pop rbp
retn
| long long hp_close(_QWORD *a1)
{
int v1; // eax
*(_DWORD *)(*a1 + 252LL) = 0;
if ( a1[91] )
heap_open_list = list_delete(heap_open_list, a1 + 89);
v1 = *(_DWORD *)(*a1 + 268LL) - 1;
*(_DWORD *)(*a1 + 268LL) = v1;
if ( !v1 && *(_BYTE *)(*a1 + 544LL) )
hp_free(*a1);
my_free(a1);
return 0LL;
}
| hp_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV dword ptr [RAX + 0xfc],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x2d8],0x0
JZ 0x00125a59
LEA RAX,[0x492870]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x2c8
CALL 0x0012b0e0
MOV RCX,RAX
LEA RAX,[0x492870]
MOV qword ptr [RAX],RCX
LAB_00125a59:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
MOV EAX,dword ptr [RCX + 0x10c]
ADD EAX,-0x1
MOV dword ptr [RCX + 0x10c],EAX
CMP EAX,0x0
JNZ 0x00125a93
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOVSX EAX,byte ptr [RAX + 0x220]
CMP EAX,0x0
JZ 0x00125a93
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
CALL 0x00126480
LAB_00125a93:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012e170
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x10]
ADD RSP,0x10
POP RBP
RET
|
int4 hp_close(long *param_1)
{
int iVar1;
*(int4 *)(*param_1 + 0xfc) = 0;
if (param_1[0x5b] != 0) {
heap_open_list = list_delete(heap_open_list,param_1 + 0x59);
}
iVar1 = *(int *)(*param_1 + 0x10c) + -1;
*(int *)(*param_1 + 0x10c) = iVar1;
if ((iVar1 == 0) && (*(char *)(*param_1 + 0x220) != '\0')) {
hp_free(*param_1);
}
my_free(param_1);
return 0;
}
|
|
3,254 | hp_close | eloqsql/storage/heap/hp_close.c | int hp_close(register HP_INFO *info)
{
int error=0;
DBUG_ENTER("hp_close");
info->s->changed=0;
if (info->open_list.data)
heap_open_list=list_delete(heap_open_list,&info->open_list);
if (!--info->s->open_count && info->s->delete_on_close)
hp_free(info->s); /* Table was deleted */
my_free(info);
DBUG_RETURN(error);
} | O3 | c | hp_close:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movl $0x0, 0xfc(%rax)
cmpq $0x0, 0x2d8(%rdi)
je 0x259f3
leaq 0x2c8(%rbx), %rsi
leaq 0x347338(%rip), %r14 # 0x36cd20
movq (%r14), %rdi
callq 0x28a80
movq %rax, (%r14)
movq (%rbx), %rax
decl 0x10c(%rax)
jne 0x25a0f
movq (%rbx), %rdi
cmpb $0x0, 0x220(%rdi)
je 0x25a0f
callq 0x26058
movq %rbx, %rdi
callq 0x29daa
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
| hp_close:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
mov rax, [rdi]
mov dword ptr [rax+0FCh], 0
cmp qword ptr [rdi+2D8h], 0
jz short loc_259F3
lea rsi, [rbx+2C8h]
lea r14, heap_open_list
mov rdi, [r14]
call list_delete
mov [r14], rax
loc_259F3:
mov rax, [rbx]
dec dword ptr [rax+10Ch]
jnz short loc_25A0F
mov rdi, [rbx]
cmp byte ptr [rdi+220h], 0
jz short loc_25A0F
call hp_free
loc_25A0F:
mov rdi, rbx
call my_free
xor eax, eax
pop rbx
pop r14
pop rbp
retn
| long long hp_close(_QWORD *a1)
{
bool v1; // zf
*(_DWORD *)(*a1 + 252LL) = 0;
if ( a1[91] )
heap_open_list = list_delete(heap_open_list, a1 + 89);
v1 = (*(_DWORD *)(*a1 + 268LL))-- == 1;
if ( v1 && *(_BYTE *)(*a1 + 544LL) )
hp_free();
my_free(a1);
return 0LL;
}
| hp_close:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV dword ptr [RAX + 0xfc],0x0
CMP qword ptr [RDI + 0x2d8],0x0
JZ 0x001259f3
LEA RSI,[RBX + 0x2c8]
LEA R14,[0x46cd20]
MOV RDI,qword ptr [R14]
CALL 0x00128a80
MOV qword ptr [R14],RAX
LAB_001259f3:
MOV RAX,qword ptr [RBX]
DEC dword ptr [RAX + 0x10c]
JNZ 0x00125a0f
MOV RDI,qword ptr [RBX]
CMP byte ptr [RDI + 0x220],0x0
JZ 0x00125a0f
CALL 0x00126058
LAB_00125a0f:
MOV RDI,RBX
CALL 0x00129daa
XOR EAX,EAX
POP RBX
POP R14
POP RBP
RET
|
int8 hp_close(long *param_1)
{
int *piVar1;
*(int4 *)(*param_1 + 0xfc) = 0;
if (param_1[0x5b] != 0) {
heap_open_list = list_delete(heap_open_list,param_1 + 0x59);
}
piVar1 = (int *)(*param_1 + 0x10c);
*piVar1 = *piVar1 + -1;
if ((*piVar1 == 0) && (*(char *)(*param_1 + 0x220) != '\0')) {
hp_free();
}
my_free(param_1);
return 0;
}
|
|
3,255 | minja::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Options const&) | llama.cpp/common/minja/minja.hpp | static std::shared_ptr<TemplateNode> parse(const std::string& template_str, const Options & options) {
Parser parser(std::make_shared<std::string>(normalize_newlines(template_str)), options);
auto tokens = parser.tokenize();
TemplateTokenIterator begin = tokens.begin();
auto it = begin;
TemplateTokenIterator end = tokens.end();
return parser.parseTemplate(begin, it, end, /* fully= */ true);
} | O3 | cpp | minja::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Options const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r13
movq %rdi, %r15
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2c6a6
movl $0x30, %edi
callq 0x21250
movq %rax, %r12
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r12)
leaq 0x87341(%rip), %rax # 0x164878
addq $0x10, %rax
movq %rax, (%r12)
leaq 0x10(%r12), %rbp
movq %r12, %rdi
addq $0x20, %rdi
movq %rdi, 0x10(%r12)
movq 0x8(%rsp), %rax
cmpq %r14, %rax
movq %r14, %rcx
movq %r13, %r14
je 0xdd573
movq %rax, (%rbp)
movq 0x18(%rsp), %rax
movq %rax, (%rdi)
movq 0x10(%rsp), %rbx
jmp 0xdd58a
movq 0x10(%rsp), %rbx
leaq 0x1(%rbx), %rdx
movq %rcx, %r13
movq %rcx, %rsi
callq 0x21100
movq %r13, %rcx
leaq 0x30(%rsp), %r13
movq %rbx, 0x18(%r12)
movq %rcx, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %r12, (%r13)
movq %rbp, -0x8(%r13)
leaq 0x48(%rsp), %rdi
movq %rcx, %rbx
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0xde254
movq %r13, %rdi
callq 0x74104
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0xdd5e3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x211a0
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xde31c
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x38(%rsp), %r8
movq %rsi, (%r8)
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
movl $0x1, %r9d
callq 0xe09d0
leaq 0x8(%rsp), %rdi
callq 0xe1cf2
leaq 0x50(%rsp), %rdi
callq 0x74104
movq %r15, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe1cf2
jmp 0xdd65f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x74104
jmp 0xdd695
movq %rbx, %r14
movq %rax, %rbx
movq %r13, %rdi
callq 0x74104
jmp 0xdd67e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xdd695
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x211a0
movq %rbx, %rdi
callq 0x21c10
nop
| _ZN5minja6Parser5parseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7OptionsE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r13, rdx
mov r15, rdi
lea r14, [rsp+0A8h+var_90]
mov [r14-10h], r14
mov rax, [rsi]
mov rdx, [rsi+8]
add rdx, rax
lea rdi, [rsp+0A8h+var_A0]
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)
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
mov r12, rax
mov rax, 100000001h
mov [r12+8], rax
lea rax, _ZTVSt23_Sp_counted_ptr_inplaceINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIvELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<std::string,std::allocator<void>,(__gnu_cxx::_Lock_policy)2>
add rax, 10h
mov [r12], rax
lea rbp, [r12+10h]
mov rdi, r12
add rdi, 20h ; ' '
mov [r12+10h], rdi
mov rax, [rsp+0A8h+var_A0]
cmp rax, r14
mov rcx, r14
mov r14, r13
jz short loc_DD573
mov [rbp+0], rax
mov rax, [rsp+0A8h+var_90]
mov [rdi], rax
mov rbx, [rsp+0A8h+var_98]
jmp short loc_DD58A
loc_DD573:
mov rbx, [rsp+0A8h+var_98]
lea rdx, [rbx+1]
mov r13, rcx
mov rsi, rcx
call _memcpy
mov rcx, r13
loc_DD58A:
lea r13, [rsp+0A8h+var_78]
mov [r12+18h], rbx
mov [rsp+0A8h+var_A0], rcx
mov [rsp+0A8h+var_98], 0
mov byte ptr [rsp+0A8h+var_90], 0
mov [r13+0], r12
mov [r13-8], rbp
lea rdi, [rsp+0A8h+var_60]
mov rbx, rcx
lea rsi, [rsp+0A8h+var_80]
mov rdx, r14
call _ZN5minja6ParserC2ERKSt10shared_ptrINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEERKNS_7OptionsE; minja::Parser::Parser(std::shared_ptr<std::string> const&,minja::Options const&)
mov rdi, r13
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, [rsp+0A8h+var_A0]; void *
cmp rdi, rbx
jz short loc_DD5E3
mov rsi, [rsp+0A8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_DD5E3:
lea rdi, [rsp+0A8h+var_A0]; this
lea rsi, [rsp+0A8h+var_60]
call _ZN5minja6Parser8tokenizeEv; minja::Parser::tokenize(void)
mov rax, [rsp+0A8h+var_A0]
mov rsi, [rsp+0A8h+var_98]
lea rdx, [rsp+0A8h+var_80]
mov [rdx], rax
lea rcx, [rsp+0A8h+var_68]
mov [rcx], rax
lea r8, [rsp+0A8h+var_70]
mov [r8], rsi
lea rsi, [rsp+0A8h+var_60]
mov rdi, r15
mov r9d, 1
call _ZNK5minja6Parser13parseTemplateERKN9__gnu_cxx17__normal_iteratorIPKSt10unique_ptrINS_13TemplateTokenESt14default_deleteIS4_EESt6vectorIS7_SaIS7_EEEERSD_SF_b; minja::Parser::parseTemplate(__gnu_cxx::__normal_iterator<std::unique_ptr<minja::TemplateToken> const*,std::vector<std::unique_ptr<minja::TemplateToken>>> const&,__gnu_cxx::__normal_iterator<std::unique_ptr<minja::TemplateToken> const*,std::vector<std::unique_ptr<minja::TemplateToken>>>&,__gnu_cxx::__normal_iterator<std::unique_ptr<minja::TemplateToken> const*,std::vector<std::unique_ptr<minja::TemplateToken>>> const&,bool)
lea rdi, [rsp+0A8h+var_A0]
call _ZNSt6vectorISt10unique_ptrIN5minja13TemplateTokenESt14default_deleteIS2_EESaIS5_EED2Ev; std::vector<std::unique_ptr<minja::TemplateToken>>::~vector()
lea rdi, [rsp+0A8h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, r15
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZNSt6vectorISt10unique_ptrIN5minja13TemplateTokenESt14default_deleteIS2_EESaIS5_EED2Ev; std::vector<std::unique_ptr<minja::TemplateToken>>::~vector()
jmp short loc_DD65F
mov rbx, rax
loc_DD65F:
lea rdi, [rsp+arg_48]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_DD695
mov r14, rbx
mov rbx, rax
mov rdi, r13
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_DD67E
mov rbx, rax
loc_DD67E:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r14
jz short loc_DD695
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_DD695:
mov rdi, rbx
call __Unwind_Resume
| long long minja::Parser::parse(long long a1, long long a2, long long a3)
{
long long v5; // r12
_QWORD *v6; // rdi
long long v7; // rbx
void *v9; // [rsp+8h] [rbp-A0h] BYREF
long long v10; // [rsp+10h] [rbp-98h]
_QWORD v11[2]; // [rsp+18h] [rbp-90h] BYREF
void *v12; // [rsp+28h] [rbp-80h] BYREF
volatile signed __int32 *v13; // [rsp+30h] [rbp-78h] BYREF
long long v14; // [rsp+38h] [rbp-70h] BYREF
void *v15; // [rsp+40h] [rbp-68h] BYREF
_BYTE v16[8]; // [rsp+48h] [rbp-60h] BYREF
volatile signed __int32 *v17; // [rsp+50h] [rbp-58h] BYREF
v9 = v11;
std::string::_M_construct<char *>((long long)&v9, *(_BYTE **)a2, *(_QWORD *)a2 + *(_QWORD *)(a2 + 8));
v5 = operator new(0x30uLL);
*(_QWORD *)(v5 + 8) = 0x100000001LL;
*(_QWORD *)v5 = &`vtable for'std::_Sp_counted_ptr_inplace<std::string,std::allocator<void>,(__gnu_cxx::_Lock_policy)2>
+ 2;
v6 = (_QWORD *)(v5 + 32);
*(_QWORD *)(v5 + 16) = v5 + 32;
if ( v9 == v11 )
{
v7 = v10;
memcpy(v6, v11, v10 + 1);
}
else
{
*(_QWORD *)(v5 + 16) = v9;
*v6 = v11[0];
v7 = v10;
}
*(_QWORD *)(v5 + 24) = v7;
v9 = v11;
v10 = 0LL;
LOBYTE(v11[0]) = 0;
v13 = (volatile signed __int32 *)v5;
v12 = (void *)(v5 + 16);
minja::Parser::Parser(v16, &v12, a3);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v13);
if ( v9 != v11 )
operator delete(v9, v11[0] + 1LL);
minja::Parser::tokenize((minja::Parser *)&v9);
v12 = v9;
v15 = v9;
v14 = v10;
minja::Parser::parseTemplate(a1, v16, &v12, &v15, &v14, 1LL);
std::vector<std::unique_ptr<minja::TemplateToken>>::~vector(&v9);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v17);
return a1;
}
| parse:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R13,RDX
MOV R15,RDI
LEA R14,[RSP + 0x18]
MOV qword ptr [R14 + -0x10],R14
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
ADD RDX,RAX
LEA RDI,[RSP + 0x8]
MOV RSI,RAX
CALL 0x0012c6a6
LAB_001dd514:
MOV EDI,0x30
CALL 0x00121250
LAB_001dd51e:
MOV R12,RAX
MOV RAX,0x100000001
MOV qword ptr [R12 + 0x8],RAX
LEA RAX,[0x264878]
ADD RAX,0x10
MOV qword ptr [R12],RAX
LEA RBP,[R12 + 0x10]
MOV RDI,R12
ADD RDI,0x20
MOV qword ptr [R12 + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,R14
MOV RCX,R14
MOV R14,R13
JZ 0x001dd573
MOV qword ptr [RBP],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RDI],RAX
MOV RBX,qword ptr [RSP + 0x10]
JMP 0x001dd58a
LAB_001dd573:
MOV RBX,qword ptr [RSP + 0x10]
LEA RDX,[RBX + 0x1]
MOV R13,RCX
MOV RSI,RCX
CALL 0x00121100
MOV RCX,R13
LAB_001dd58a:
LEA R13,[RSP + 0x30]
MOV qword ptr [R12 + 0x18],RBX
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP + 0x10],0x0
MOV byte ptr [RSP + 0x18],0x0
MOV qword ptr [R13],R12
MOV qword ptr [R13 + -0x8],RBP
LAB_001dd5af:
LEA RDI,[RSP + 0x48]
MOV RBX,RCX
LEA RSI,[RSP + 0x28]
MOV RDX,R14
CALL 0x001de254
MOV RDI,R13
CALL 0x00174104
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,RBX
JZ 0x001dd5e3
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001211a0
LAB_001dd5e3:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x48]
CALL 0x001de31c
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],RAX
LEA RCX,[RSP + 0x40]
MOV qword ptr [RCX],RAX
LEA R8,[RSP + 0x38]
MOV qword ptr [R8],RSI
LAB_001dd614:
LEA RSI,[RSP + 0x48]
MOV RDI,R15
MOV R9D,0x1
CALL 0x001e09d0
LAB_001dd627:
LEA RDI,[RSP + 0x8]
CALL 0x001e1cf2
LEA RDI,[RSP + 0x50]
CALL 0x00174104
MOV RAX,R15
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::Parser::parse(std::__cxx11::string const&, minja::Options const&) */
Parser * __thiscall minja::Parser::parse(Parser *this,string *param_1,Options *param_2)
{
int8 *__dest;
int8 *local_a0;
long local_98;
int1 local_90;
int7 uStack_8f;
int8 *local_80;
int8 *local_78;
int8 local_70;
int8 *local_68;
Parser local_60 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_58 [40];
local_a0 = (int8 *)&local_90;
std::__cxx11::string::_M_construct<char*>
(&local_a0,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
/* try { // try from 001dd514 to 001dd51d has its CatchHandler @ 001dd67b */
local_78 = (int8 *)operator_new(0x30);
local_78[1] = 0x100000001;
*local_78 = &PTR___Sp_counted_base_00264888;
local_80 = local_78 + 2;
__dest = local_78 + 4;
local_78[2] = __dest;
if (local_a0 == (int8 *)&local_90) {
memcpy(__dest,&local_90,local_98 + 1);
}
else {
*local_80 = local_a0;
*__dest = CONCAT71(uStack_8f,local_90);
}
local_78[3] = local_98;
local_98 = 0;
local_90 = 0;
/* try { // try from 001dd5af to 001dd5c3 has its CatchHandler @ 001dd66b */
local_a0 = (int8 *)&local_90;
Parser(local_60,(shared_ptr *)&local_80,param_2);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&local_78);
if (local_a0 != (int8 *)&local_90) {
operator_delete(local_a0,CONCAT71(uStack_8f,local_90) + 1);
}
/* try { // try from 001dd5e3 to 001dd5f1 has its CatchHandler @ 001dd65c */
tokenize();
local_80 = local_a0;
local_68 = local_a0;
local_70 = local_98;
/* try { // try from 001dd614 to 001dd626 has its CatchHandler @ 001dd64d */
parseTemplate(this,local_60,(__normal_iterator *)&local_80,SUB81(&local_68,0));
std::
vector<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>,std::allocator<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>>>
::~vector((vector<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>,std::allocator<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>>>
*)&local_a0);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_58);
return this;
}
|
|
3,256 | bool nlohmann::json_abi_v3_11_3::operator!=<bool, 0>(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) | monkey531[P]llama/common/json.hpp | bool operator!=(const_reference lhs, ScalarType rhs) noexcept
{
return lhs != basic_json(rhs);
} | O3 | cpp | bool nlohmann::json_abi_v3_11_3::operator!=<bool, 0>(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):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0x62a7a
movq %r14, %rdi
movl $0x1, %esi
callq 0x5b4ca
movq %rbx, %rdi
movq %r14, %rsi
callq 0xae2f3
movl %eax, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x5b4ca
movq %r14, %rdi
callq 0x60938
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
xorps xmm0, xmm0
mov r14, rsp
movaps xmmword ptr [r14], xmm0
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE4EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_9boolean_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::boolean_t)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_3neERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::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> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov ebx, eax
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 eax, ebx
add rsp, 18h
pop rbx
pop r14
retn
| long long ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_(
unsigned __int8 *a1,
unsigned __int8 a2)
{
unsigned int v2; // eax
unsigned int v3; // ebx
_OWORD v5[2]; // [rsp+0h] [rbp-28h] BYREF
v5[0] = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(unsigned __int8 *)v5,
a2);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v5);
LOBYTE(v2) = nlohmann::json_abi_v3_11_3::operator!=(a1, (unsigned __int8 *)v5, (__m128d)0LL);
v3 = v2;
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 *)v5);
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(v5);
return v3;
}
| _ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
XORPS XMM0,XMM0
MOV R14,RSP
MOVAPS xmmword ptr [R14],XMM0
MOV RDI,R14
CALL 0x00162a7a
MOV RDI,R14
MOV ESI,0x1
CALL 0x0015b4ca
MOV RDI,RBX
MOV RSI,R14
CALL 0x001ae2f3
MOV EBX,EAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x0015b4ca
MOV RDI,R14
CALL 0x00160938
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
int4
_ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_
(basic_json *param_1)
{
int4 uVar1;
int8 local_28;
int8 uStack_20;
local_28 = 0;
uStack_20 = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(&local_28);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_28,0));
uVar1 = nlohmann::json_abi_v3_11_3::operator!=(param_1,(basic_json *)&local_28);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_28,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_28);
return uVar1;
}
|
|
3,257 | qdevtools::QObjectTreeModel::~QObjectTreeModel() | HuaiminNotSleepYet[P]QDevTools/qdevtools.cpp | QObjectTreeModel::~QObjectTreeModel()
{
for (auto conn : std::as_const(connections1_))
disconnect(conn);
for (auto conn : std::as_const(connections2_))
disconnect(conn);
} | O2 | cpp | qdevtools::QObjectTreeModel::~QObjectTreeModel():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1a26b(%rip), %rax # 0x2ae40
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x10beb
movq 0x20(%rax), %r15
jmp 0x10bee
xorl %r15d, %r15d
leaq 0x28(%rbx), %r14
leaq 0x10(%rax), %r13
testq %rax, %rax
cmoveq %rax, %r13
movq %rsp, %r12
cmpq %r13, %r15
je 0x10c2e
leaq 0x28(%r15), %rsi
movq %r12, %rdi
callq 0xf9c0
movq %r12, %rdi
callq 0x10020
movq %r12, %rdi
callq 0xf400
movq %r15, %rdi
callq 0xf710
movq %rax, %r15
jmp 0x10c00
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x10c3d
movq 0x20(%rax), %r15
jmp 0x10c40
xorl %r15d, %r15d
leaq 0x30(%rbx), %r12
leaq 0x10(%rax), %rbp
testq %rax, %rax
cmoveq %rax, %rbp
movq %rsp, %r13
cmpq %rbp, %r15
je 0x10c80
leaq 0x28(%r15), %rsi
movq %r13, %rdi
callq 0xf9c0
movq %r13, %rdi
callq 0x10020
movq %r13, %rdi
callq 0xf400
movq %r15, %rdi
callq 0xf710
movq %rax, %r15
jmp 0x10c52
movq %r12, %rdi
callq 0x166fa
movq %r14, %rdi
callq 0x166fa
leaq 0x10(%rbx), %rdi
callq 0x1678a
movq %rbx, %rdi
callq 0xf200
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10cb2
movq %rax, %rdi
callq 0x109ff
| _ZN9qdevtools16QObjectTreeModelD2Ev:
push rbp; Alternative name is 'qdevtools::QObjectTreeModel::~QObjectTreeModel()'
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
lea rax, _ZTVN9qdevtools16QObjectTreeModelE; `vtable for'qdevtools::QObjectTreeModel
add rax, 10h
mov [rdi], rax
mov rax, [rdi+28h]
test rax, rax
jz short loc_10BEB
mov r15, [rax+20h]
jmp short loc_10BEE
loc_10BEB:
xor r15d, r15d
loc_10BEE:
lea r14, [rbx+28h]
lea r13, [rax+10h]
test rax, rax
cmovz r13, rax
mov r12, rsp
loc_10C00:
cmp r15, r13
jz short loc_10C2E
lea rsi, [r15+28h]; QMetaObject::Connection *
mov rdi, r12; this
call __ZN11QMetaObject10ConnectionC1ERKS0_; QMetaObject::Connection::Connection(QMetaObject::Connection const&)
mov rdi, r12; this
call __ZN7QObject10disconnectERKN11QMetaObject10ConnectionE; QObject::disconnect(QMetaObject::Connection const&)
mov rdi, r12; this
call __ZN11QMetaObject10ConnectionD1Ev; QMetaObject::Connection::~Connection()
mov rdi, r15
call __ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base const*)
mov r15, rax
jmp short loc_10C00
loc_10C2E:
mov rax, [rbx+30h]
test rax, rax
jz short loc_10C3D
mov r15, [rax+20h]
jmp short loc_10C40
loc_10C3D:
xor r15d, r15d
loc_10C40:
lea r12, [rbx+30h]
lea rbp, [rax+10h]
test rax, rax
cmovz rbp, rax
mov r13, rsp
loc_10C52:
cmp r15, rbp
jz short loc_10C80
lea rsi, [r15+28h]; QMetaObject::Connection *
mov rdi, r13; this
call __ZN11QMetaObject10ConnectionC1ERKS0_; QMetaObject::Connection::Connection(QMetaObject::Connection const&)
mov rdi, r13; this
call __ZN7QObject10disconnectERKN11QMetaObject10ConnectionE; QObject::disconnect(QMetaObject::Connection const&)
mov rdi, r13; this
call __ZN11QMetaObject10ConnectionD1Ev; QMetaObject::Connection::~Connection()
mov rdi, r15
call __ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base const*)
mov r15, rax
jmp short loc_10C52
loc_10C80:
mov rdi, r12
call _ZN9QtPrivate30QExplicitlySharedDataPointerV2I8QMapDataISt3mapIP7QObjectN11QMetaObject10ConnectionESt4lessIS4_ESaISt4pairIKS4_S6_EEEEED2Ev; QtPrivate::QExplicitlySharedDataPointerV2<QMapData<std::map<QObject *,QMetaObject::Connection>>>::~QExplicitlySharedDataPointerV2()
mov rdi, r14
call _ZN9QtPrivate30QExplicitlySharedDataPointerV2I8QMapDataISt3mapIP7QObjectN11QMetaObject10ConnectionESt4lessIS4_ESaISt4pairIKS4_S6_EEEEED2Ev; QtPrivate::QExplicitlySharedDataPointerV2<QMapData<std::map<QObject *,QMetaObject::Connection>>>::~QExplicitlySharedDataPointerV2()
lea rdi, [rbx+10h]
call _ZN17QArrayDataPointerIP7QObjectED2Ev; QArrayDataPointer<QObject *>::~QArrayDataPointer()
mov rdi, rbx; this
call __ZN18QAbstractItemModelD2Ev; QAbstractItemModel::~QAbstractItemModel()
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_10CB2:
mov rdi, rax
call __clang_call_terminate
| void qdevtools::QObjectTreeModel::~QObjectTreeModel(qdevtools::QObjectTreeModel *this)
{
long long v1; // rax
long long v2; // rax
long long v3; // r15
long long v4; // r13
long long v5; // rax
long long v6; // r15
long long v7; // rbp
_QWORD v8[7]; // [rsp-8h] [rbp-38h] BYREF
v8[0] = v1;
*(_QWORD *)this = &`vtable for'qdevtools::QObjectTreeModel + 2;
v2 = *((_QWORD *)this + 5);
if ( v2 )
v3 = *(_QWORD *)(v2 + 32);
else
v3 = 0LL;
v4 = v2 + 16;
if ( !v2 )
v4 = 0LL;
while ( v3 != v4 )
{
QMetaObject::Connection::Connection((QMetaObject::Connection *)v8, (const QMetaObject::Connection *)(v3 + 40));
QObject::disconnect((QObject *)v8, (const QMetaObject::Connection *)(v3 + 40));
QMetaObject::Connection::~Connection((QMetaObject::Connection *)v8);
v3 = std::_Rb_tree_increment(v3);
}
v5 = *((_QWORD *)this + 6);
if ( v5 )
v6 = *(_QWORD *)(v5 + 32);
else
v6 = 0LL;
v7 = v5 + 16;
if ( !v5 )
v7 = 0LL;
while ( v6 != v7 )
{
QMetaObject::Connection::Connection((QMetaObject::Connection *)v8, (const QMetaObject::Connection *)(v6 + 40));
QObject::disconnect((QObject *)v8, (const QMetaObject::Connection *)(v6 + 40));
QMetaObject::Connection::~Connection((QMetaObject::Connection *)v8);
v6 = std::_Rb_tree_increment(v6);
}
QtPrivate::QExplicitlySharedDataPointerV2<QMapData<std::map<QObject *,QMetaObject::Connection>>>::~QExplicitlySharedDataPointerV2((char *)this + 48);
QtPrivate::QExplicitlySharedDataPointerV2<QMapData<std::map<QObject *,QMetaObject::Connection>>>::~QExplicitlySharedDataPointerV2((char *)this + 40);
QArrayDataPointer<QObject *>::~QArrayDataPointer((char *)this + 16);
QAbstractItemModel::~QAbstractItemModel(this);
}
| ~QObjectTreeModel:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x12ae40]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RDI + 0x28]
TEST RAX,RAX
JZ 0x00110beb
MOV R15,qword ptr [RAX + 0x20]
JMP 0x00110bee
LAB_00110beb:
XOR R15D,R15D
LAB_00110bee:
LEA R14,[RBX + 0x28]
LEA R13,[RAX + 0x10]
TEST RAX,RAX
CMOVZ R13,RAX
MOV R12,RSP
LAB_00110c00:
CMP R15,R13
JZ 0x00110c2e
LEA RSI,[R15 + 0x28]
LAB_00110c09:
MOV RDI,R12
CALL 0x0010f9c0
MOV RDI,R12
CALL 0x00110020
MOV RDI,R12
CALL 0x0010f400
MOV RDI,R15
CALL 0x0010f710
MOV R15,RAX
JMP 0x00110c00
LAB_00110c2e:
MOV RAX,qword ptr [RBX + 0x30]
TEST RAX,RAX
JZ 0x00110c3d
MOV R15,qword ptr [RAX + 0x20]
JMP 0x00110c40
LAB_00110c3d:
XOR R15D,R15D
LAB_00110c40:
LEA R12,[RBX + 0x30]
LEA RBP,[RAX + 0x10]
TEST RAX,RAX
CMOVZ RBP,RAX
MOV R13,RSP
LAB_00110c52:
CMP R15,RBP
JZ 0x00110c80
LEA RSI,[R15 + 0x28]
LAB_00110c5b:
MOV RDI,R13
CALL 0x0010f9c0
MOV RDI,R13
CALL 0x00110020
MOV RDI,R13
CALL 0x0010f400
MOV RDI,R15
CALL 0x0010f710
MOV R15,RAX
JMP 0x00110c52
LAB_00110c80:
MOV RDI,R12
CALL 0x001166fa
MOV RDI,R14
CALL 0x001166fa
LEA RDI,[RBX + 0x10]
CALL 0x0011678a
MOV RDI,RBX
CALL 0x0010f200
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* qdevtools::QObjectTreeModel::~QObjectTreeModel() */
void __thiscall qdevtools::QObjectTreeModel::~QObjectTreeModel(QObjectTreeModel *this)
{
long lVar1;
_Rb_tree_node_base *p_Var2;
_Rb_tree_node_base *p_Var3;
int1 auStack_38 [8];
*(int ***)this = &PTR_metaObject_0012ae50;
lVar1 = *(long *)(this + 0x28);
if (lVar1 == 0) {
p_Var2 = (_Rb_tree_node_base *)0x0;
}
else {
p_Var2 = *(_Rb_tree_node_base **)(lVar1 + 0x20);
}
p_Var3 = (_Rb_tree_node_base *)(lVar1 + 0x10);
if (lVar1 == 0) {
p_Var3 = (_Rb_tree_node_base *)0x0;
}
for (; p_Var2 != p_Var3; p_Var2 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var2)) {
/* try { // try from 00110c09 to 00110c18 has its CatchHandler @ 00110cb2 */
QMetaObject::Connection::Connection(auStack_38,p_Var2 + 0x28);
QObject::disconnect(auStack_38);
QMetaObject::Connection::~Connection(auStack_38);
}
lVar1 = *(long *)(this + 0x30);
if (lVar1 == 0) {
p_Var2 = (_Rb_tree_node_base *)0x0;
}
else {
p_Var2 = *(_Rb_tree_node_base **)(lVar1 + 0x20);
}
p_Var3 = (_Rb_tree_node_base *)(lVar1 + 0x10);
if (lVar1 == 0) {
p_Var3 = (_Rb_tree_node_base *)0x0;
}
for (; p_Var2 != p_Var3; p_Var2 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var2)) {
/* try { // try from 00110c5b to 00110c6a has its CatchHandler @ 00110cb0 */
QMetaObject::Connection::Connection(auStack_38,p_Var2 + 0x28);
QObject::disconnect(auStack_38);
QMetaObject::Connection::~Connection(auStack_38);
}
QtPrivate::
QExplicitlySharedDataPointerV2<QMapData<std::map<QObject*,QMetaObject::Connection,std::less<QObject*>,std::allocator<std::pair<QObject*const,QMetaObject::Connection>>>>>
::~QExplicitlySharedDataPointerV2
((QExplicitlySharedDataPointerV2<QMapData<std::map<QObject*,QMetaObject::Connection,std::less<QObject*>,std::allocator<std::pair<QObject*const,QMetaObject::Connection>>>>>
*)(this + 0x30));
QtPrivate::
QExplicitlySharedDataPointerV2<QMapData<std::map<QObject*,QMetaObject::Connection,std::less<QObject*>,std::allocator<std::pair<QObject*const,QMetaObject::Connection>>>>>
::~QExplicitlySharedDataPointerV2
((QExplicitlySharedDataPointerV2<QMapData<std::map<QObject*,QMetaObject::Connection,std::less<QObject*>,std::allocator<std::pair<QObject*const,QMetaObject::Connection>>>>>
*)(this + 0x28));
QArrayDataPointer<QObject*>::~QArrayDataPointer((QArrayDataPointer<QObject*> *)(this + 0x10));
QAbstractItemModel::~QAbstractItemModel((QAbstractItemModel *)this);
return;
}
|
|
3,258 | fmt::v10::detail::report_error(void (*)(fmt::v10::detail::buffer<char>&, int, char const*), int, char const*) | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h | FMT_FUNC void report_error(format_func func, int error_code,
const char* message) noexcept {
memory_buffer full_message;
func(full_message, error_code, message);
// Don't use fwrite_fully because the latter may throw.
if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0)
std::fputc('\n', stderr);
} | O0 | c | fmt::v10::detail::report_error(void (*)(fmt::v10::detail::buffer<char>&, int, char const*), int, char const*):
subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movl %esi, 0x24c(%rsp)
movq %rdx, 0x240(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x15de0
movq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xc7960
jmp 0xc683e
leaq 0x27(%rsp), %rdi
callq 0x157f0
movq 0x250(%rsp), %rax
movl 0x24c(%rsp), %esi
movq 0x240(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq *%rax
jmp 0xc6868
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x243d0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x243e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x1096ed(%rip), %rax # 0x1cff80
movq (%rax), %rcx
movl $0x1, %edx
callq 0x15f50
movq %rax, 0x10(%rsp)
jmp 0xc68a7
movq 0x10(%rsp), %rax
cmpq $0x0, %rax
jbe 0xc68ca
movq 0x1096c7(%rip), %rax # 0x1cff80
movq (%rax), %rsi
movl $0xa, %edi
callq 0x15950
jmp 0xc68c8
jmp 0xc68ca
leaq 0x28(%rsp), %rdi
callq 0xc79c0
addq $0x258, %rsp # imm = 0x258
retq
movq %rax, %rdi
callq 0x1f240
nopw %cs:(%rax,%rax)
| _ZN3fmt3v106detail12report_errorEPFvRNS1_6bufferIcEEiPKcEiS6_:
sub rsp, 258h
mov [rsp+258h+var_8], rdi
mov [rsp+258h+var_C], esi
mov [rsp+258h+var_18], rdx
lea rdi, [rsp+258h+var_231]
mov [rsp+258h+var_240], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+258h+var_240]
lea rdi, [rsp+258h+var_230]
call _ZN3fmt3v1019basic_memory_bufferIcLm500ESaIcEEC2ERKS2_; fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>::basic_memory_buffer(std::allocator<char> const&)
jmp short $+2
loc_C683E:
lea rdi, [rsp+258h+var_231]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov rax, [rsp+258h+var_8]
mov esi, [rsp+258h+var_C]
mov rdx, [rsp+258h+var_18]
lea rdi, [rsp+258h+var_230]
call rax
jmp short $+2
loc_C6868:
lea rdi, [rsp+258h+var_230]
mov [rsp+258h+var_258], rdi
call _ZN3fmt3v106detail6bufferIcE4dataEv; fmt::v10::detail::buffer<char>::data(void)
mov rdi, [rsp+258h+var_258]
mov [rsp+258h+var_250], rax
call _ZNK3fmt3v106detail6bufferIcE4sizeEv; fmt::v10::detail::buffer<char>::size(void)
mov rdi, [rsp+258h+var_250]
mov rsi, rax
mov rax, cs:stderr_ptr
mov rcx, [rax]
mov edx, 1
call _fwrite
mov [rsp+258h+var_248], rax
jmp short $+2
loc_C68A7:
mov rax, [rsp+258h+var_248]
cmp rax, 0
jbe short loc_C68CA
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov edi, 0Ah
call _fputc
jmp short $+2
loc_C68C8:
jmp short $+2
loc_C68CA:
lea rdi, [rsp+258h+var_230]
call _ZN3fmt3v1019basic_memory_bufferIcLm500ESaIcEED2Ev; fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>::~basic_memory_buffer()
add rsp, 258h
retn
mov rdi, rax
call __clang_call_terminate
| long long fmt::v10::detail::report_error(
void ( *a1)(_BYTE *, _QWORD, long long),
long long a2,
long long a3)
{
long long v3; // rsi
long long v5; // [rsp+8h] [rbp-250h]
char v6; // [rsp+27h] [rbp-231h] BYREF
_BYTE v7[536]; // [rsp+28h] [rbp-230h] BYREF
long long v8; // [rsp+240h] [rbp-18h]
unsigned int v9; // [rsp+24Ch] [rbp-Ch]
void ( *v10)(_BYTE *, _QWORD, long long); // [rsp+250h] [rbp-8h]
v10 = a1;
v9 = a2;
v8 = a3;
std::allocator<char>::allocator(&v6, a2, a3);
fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>::basic_memory_buffer(v7, &v6);
std::allocator<char>::~allocator(&v6, &v6);
v10(v7, v9, v8);
v5 = fmt::v10::detail::buffer<char>::data((long long)v7);
v3 = fmt::v10::detail::buffer<char>::size((long long)v7);
if ( fwrite(v5, v3, 1LL, stderr) )
fputc(10LL, stderr);
return fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>::~basic_memory_buffer(v7);
}
| report_error:
SUB RSP,0x258
MOV qword ptr [RSP + 0x250],RDI
MOV dword ptr [RSP + 0x24c],ESI
MOV qword ptr [RSP + 0x240],RDX
LEA RDI,[RSP + 0x27]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x00115de0
MOV RSI,qword ptr [RSP + 0x18]
LAB_001c6832:
LEA RDI,[RSP + 0x28]
CALL 0x001c7960
JMP 0x001c683e
LAB_001c683e:
LEA RDI,[RSP + 0x27]
CALL 0x001157f0
MOV RAX,qword ptr [RSP + 0x250]
MOV ESI,dword ptr [RSP + 0x24c]
MOV RDX,qword ptr [RSP + 0x240]
LEA RDI,[RSP + 0x28]
CALL RAX
JMP 0x001c6868
LAB_001c6868:
LEA RDI,[RSP + 0x28]
MOV qword ptr [RSP],RDI
CALL 0x001243d0
MOV RDI,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001243e0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV RAX,qword ptr [0x002cff80]
MOV RCX,qword ptr [RAX]
MOV EDX,0x1
CALL 0x00115f50
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001c68a7
LAB_001c68a7:
MOV RAX,qword ptr [RSP + 0x10]
CMP RAX,0x0
JBE 0x001c68ca
MOV RAX,qword ptr [0x002cff80]
MOV RSI,qword ptr [RAX]
MOV EDI,0xa
CALL 0x00115950
JMP 0x001c68c8
LAB_001c68c8:
JMP 0x001c68ca
LAB_001c68ca:
LEA RDI,[RSP + 0x28]
CALL 0x001c79c0
ADD RSP,0x258
RET
|
/* fmt::v10::detail::report_error(void (*)(fmt::v10::detail::buffer<char>&, int, char const*), int,
char const*) */
void fmt::v10::detail::report_error
(_func_void_buffer_ptr_int_char_ptr *param_1,int param_2,char *param_3)
{
void *__ptr;
size_t sVar1;
allocator<char> local_231;
allocator local_230 [536];
char *local_18;
int local_c;
_func_void_buffer_ptr_int_char_ptr *local_8;
local_18 = param_3;
local_c = param_2;
local_8 = param_1;
std::allocator<char>::allocator();
/* try { // try from 001c6832 to 001c68c5 has its CatchHandler @ 001c68dc */
basic_memory_buffer<char,500ul,std::allocator<char>>::basic_memory_buffer(local_230);
std::allocator<char>::~allocator(&local_231);
(*local_8)((buffer *)local_230,local_c,local_18);
__ptr = (void *)buffer<char>::data((buffer<char> *)local_230);
sVar1 = buffer<char>::size((buffer<char> *)local_230);
sVar1 = fwrite(__ptr,sVar1,1,*(FILE **)PTR_stderr_002cff80);
if (sVar1 != 0) {
fputc(10,*(FILE **)PTR_stderr_002cff80);
}
basic_memory_buffer<char,500ul,std::allocator<char>>::~basic_memory_buffer
((basic_memory_buffer<char,500ul,std::allocator<char>> *)local_230);
return;
}
|
|
3,259 | hi0bits | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static int hi0bits(register ULong x)
{
register int k= 0;
if (!(x & 0xffff0000))
{
k= 16;
x<<= 16;
}
if (!(x & 0xff000000))
{
k+= 8;
x<<= 8;
}
if (!(x & 0xf0000000))
{
k+= 4;
x<<= 4;
}
if (!(x & 0xc0000000))
{
k+= 2;
x<<= 2;
}
if (!(x & 0x80000000))
{
k++;
if (!(x & 0x40000000))
return 32;
}
return k;
} | O0 | c | hi0bits:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0xffff0000, %eax # imm = 0xFFFF0000
cmpl $0x0, %eax
jne 0x4f33b
movl $0x10, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x10, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xff000000, %eax # imm = 0xFF000000
cmpl $0x0, %eax
jne 0x4f35a
movl -0xc(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xf0000000, %eax # imm = 0xF0000000
cmpl $0x0, %eax
jne 0x4f379
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xc0000000, %eax # imm = 0xC0000000
cmpl $0x0, %eax
jne 0x4f398
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
jne 0x4f3c6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0x40000000, %eax # imm = 0x40000000
cmpl $0x0, %eax
jne 0x4f3c4
movl $0x20, -0x4(%rbp)
jmp 0x4f3cc
jmp 0x4f3c6
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| hi0bits:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
mov [rbp+var_C], 0
mov eax, [rbp+var_8]
and eax, 0FFFF0000h
cmp eax, 0
jnz short loc_4F33B
mov [rbp+var_C], 10h
mov eax, [rbp+var_8]
shl eax, 10h
mov [rbp+var_8], eax
loc_4F33B:
mov eax, [rbp+var_8]
and eax, 0FF000000h
cmp eax, 0
jnz short loc_4F35A
mov eax, [rbp+var_C]
add eax, 8
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
shl eax, 8
mov [rbp+var_8], eax
loc_4F35A:
mov eax, [rbp+var_8]
and eax, 0F0000000h
cmp eax, 0
jnz short loc_4F379
mov eax, [rbp+var_C]
add eax, 4
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
shl eax, 4
mov [rbp+var_8], eax
loc_4F379:
mov eax, [rbp+var_8]
and eax, 0C0000000h
cmp eax, 0
jnz short loc_4F398
mov eax, [rbp+var_C]
add eax, 2
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
shl eax, 2
mov [rbp+var_8], eax
loc_4F398:
mov eax, [rbp+var_8]
and eax, 80000000h
cmp eax, 0
jnz short loc_4F3C6
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
and eax, 40000000h
cmp eax, 0
jnz short loc_4F3C4
mov [rbp+var_4], 20h ; ' '
jmp short loc_4F3CC
loc_4F3C4:
jmp short $+2
loc_4F3C6:
mov eax, [rbp+var_C]
mov [rbp+var_4], eax
loc_4F3CC:
mov eax, [rbp+var_4]
pop rbp
retn
| long long hi0bits(int a1)
{
unsigned int v2; // [rsp+0h] [rbp-Ch]
int v3; // [rsp+4h] [rbp-8h]
v3 = a1;
v2 = 0;
if ( (a1 & 0xFFFF0000) == 0 )
{
v2 = 16;
v3 = a1 << 16;
}
if ( (v3 & 0xFF000000) == 0 )
{
v2 += 8;
v3 <<= 8;
}
if ( (v3 & 0xF0000000) == 0 )
{
v2 += 4;
v3 *= 16;
}
if ( (v3 & 0xC0000000) == 0 )
{
v2 += 2;
v3 *= 4;
}
if ( v3 < 0 )
return v2;
++v2;
if ( (v3 & 0x40000000) != 0 )
return v2;
else
return 32;
}
| hi0bits:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0xffff0000
CMP EAX,0x0
JNZ 0x0014f33b
MOV dword ptr [RBP + -0xc],0x10
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x10
MOV dword ptr [RBP + -0x8],EAX
LAB_0014f33b:
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0xff000000
CMP EAX,0x0
JNZ 0x0014f35a
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x8
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x8
MOV dword ptr [RBP + -0x8],EAX
LAB_0014f35a:
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0xf0000000
CMP EAX,0x0
JNZ 0x0014f379
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x4
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x4
MOV dword ptr [RBP + -0x8],EAX
LAB_0014f379:
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0xc0000000
CMP EAX,0x0
JNZ 0x0014f398
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x2
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x2
MOV dword ptr [RBP + -0x8],EAX
LAB_0014f398:
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0x80000000
CMP EAX,0x0
JNZ 0x0014f3c6
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0x40000000
CMP EAX,0x0
JNZ 0x0014f3c4
MOV dword ptr [RBP + -0x4],0x20
JMP 0x0014f3cc
LAB_0014f3c4:
JMP 0x0014f3c6
LAB_0014f3c6:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x4],EAX
LAB_0014f3cc:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int hi0bits(uint param_1)
{
int local_14;
uint local_10;
int local_c;
local_14 = 0;
local_10 = param_1;
if ((param_1 & 0xffff0000) == 0) {
local_14 = 0x10;
local_10 = param_1 << 0x10;
}
if ((local_10 & 0xff000000) == 0) {
local_14 = local_14 + 8;
local_10 = local_10 << 8;
}
if ((local_10 & 0xf0000000) == 0) {
local_14 = local_14 + 4;
local_10 = local_10 << 4;
}
if ((local_10 & 0xc0000000) == 0) {
local_14 = local_14 + 2;
local_10 = local_10 << 2;
}
if (((local_10 & 0x80000000) == 0) && (local_14 = local_14 + 1, (local_10 & 0x40000000) == 0)) {
local_c = 0x20;
}
else {
local_c = local_14;
}
return local_c;
}
|
|
3,260 | my_caseup_8bit | eloqsql/strings/ctype-simple.c | size_t my_caseup_8bit(CHARSET_INFO * cs, const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)))
{
const char *end= src + srclen;
register const uchar *map= cs->to_upper;
DBUG_ASSERT(srclen <= dstlen);
for ( ; src != end ; src++)
*dst++= (char) map[(uchar) *src];
return srclen;
} | O3 | c | my_caseup_8bit:
movq %rdx, %rax
testq %rdx, %rdx
je 0xb508f
pushq %rbp
movq %rsp, %rbp
movq 0x50(%rdi), %rdx
xorl %edi, %edi
movzbl (%rsi,%rdi), %r8d
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx,%rdi)
incq %rdi
cmpq %rdi, %rax
jne 0xb5079
popq %rbp
retq
| my_caseup_8bit:
mov rax, rdx
test rdx, rdx
jz short locret_B508F
push rbp
mov rbp, rsp
mov rdx, [rdi+50h]
xor edi, edi
loc_B5079:
movzx r8d, byte ptr [rsi+rdi]
mov r8b, [rdx+r8]
mov [rcx+rdi], r8b
inc rdi
cmp rax, rdi
jnz short loc_B5079
pop rbp
locret_B508F:
retn
| long long my_caseup_8bit(long long a1, long long a2, long long a3, long long a4)
{
long long result; // rax
long long v5; // rdx
long long v6; // rdi
result = a3;
if ( a3 )
{
v5 = *(_QWORD *)(a1 + 80);
v6 = 0LL;
do
{
*(_BYTE *)(a4 + v6) = *(_BYTE *)(v5 + *(unsigned __int8 *)(a2 + v6));
++v6;
}
while ( result != v6 );
}
return result;
}
| my_caseup_8bit:
MOV RAX,RDX
TEST RDX,RDX
JZ 0x001b508f
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RDI + 0x50]
XOR EDI,EDI
LAB_001b5079:
MOVZX R8D,byte ptr [RSI + RDI*0x1]
MOV R8B,byte ptr [RDX + R8*0x1]
MOV byte ptr [RCX + RDI*0x1],R8B
INC RDI
CMP RAX,RDI
JNZ 0x001b5079
POP RBP
LAB_001b508f:
RET
|
void my_caseup_8bit(long param_1,long param_2,long param_3,long param_4)
{
long lVar1;
long lVar2;
if (param_3 != 0) {
lVar1 = *(long *)(param_1 + 0x50);
lVar2 = 0;
do {
*(int1 *)(param_4 + lVar2) = *(int1 *)(lVar1 + (ulong)*(byte *)(param_2 + lVar2));
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
return;
}
|
|
3,261 | std::hash<evmc::bytes32>::operator()(evmc::bytes32 const&) const | corpus-core[P]colibri-stateless/build_O2/_deps/evmone_external-src/evmc/include/evmc/evmc.hpp | constexpr size_t operator()(const evmc::bytes32& s) const noexcept
{
using namespace evmc;
using namespace fnv;
return static_cast<size_t>(
fnv1a_by64(fnv1a_by64(fnv1a_by64(fnv1a_by64(fnv::offset_basis, load64le(&s.bytes[0])),
load64le(&s.bytes[8])),
load64le(&s.bytes[16])),
load64le(&s.bytes[24])));
} | O2 | cpp | std::hash<evmc::bytes32>::operator()(evmc::bytes32 const&) const:
movabsq $-0x340d631b7bdddcdb, %rax # imm = 0xCBF29CE484222325
xorq (%rsi), %rax
movabsq $0x100000001b3, %rcx # imm = 0x100000001B3
imulq %rcx, %rax
xorq 0x8(%rsi), %rax
imulq %rcx, %rax
xorq 0x10(%rsi), %rax
imulq %rcx, %rax
xorq 0x18(%rsi), %rax
imulq %rcx, %rax
retq
| _ZNKSt4hashIN4evmc7bytes32EEclERKS1_:
mov rax, 0CBF29CE484222325h
xor rax, [rsi]
mov rcx, 100000001B3h
imul rax, rcx
xor rax, [rsi+8]
imul rax, rcx
xor rax, [rsi+10h]
imul rax, rcx
xor rax, [rsi+18h]
imul rax, rcx
retn
| unsigned long long std::hash<evmc::bytes32>::operator()(long long a1, _QWORD *a2)
{
return 0x100000001B3LL
* (a2[3] ^ (0x100000001B3LL
* (a2[2] ^ (0x100000001B3LL * (a2[1] ^ (0x100000001B3LL * (*a2 ^ 0xCBF29CE484222325LL)))))));
}
| operator():
MOV RAX,-0x340d631b7bdddcdb
XOR RAX,qword ptr [RSI]
MOV RCX,0x100000001b3
IMUL RAX,RCX
XOR RAX,qword ptr [RSI + 0x8]
IMUL RAX,RCX
XOR RAX,qword ptr [RSI + 0x10]
IMUL RAX,RCX
XOR RAX,qword ptr [RSI + 0x18]
IMUL RAX,RCX
RET
|
/* std::hash<evmc::bytes32>::TEMPNAMEPLACEHOLDERVALUE(evmc::bytes32 const&) const */
long __thiscall std::hash<evmc::bytes32>::operator()(hash<evmc::bytes32> *this,bytes32 *param_1)
{
return ((((*(ulong *)param_1 ^ 0xcbf29ce484222325) * 0x100000001b3 ^ *(ulong *)(param_1 + 8)) *
0x100000001b3 ^ *(ulong *)(param_1 + 0x10)) * 0x100000001b3 ^ *(ulong *)(param_1 + 0x18))
* 0x100000001b3;
}
|
|
3,262 | fs_validate_filename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | bool fs_validate_filename(const std::string & filename) {
if (!filename.length()) {
// Empty filename invalid
return false;
}
if (filename.length() > 255) {
// Limit at common largest possible filename on Linux filesystems
// to avoid unnecessary further validation
// (On systems with smaller limits it will be caught by the OS)
return false;
}
std::u32string filename_utf32;
try {
#if defined(__clang__)
// disable C++17 deprecation warning for std::codecvt_utf8
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wdeprecated-declarations"
#endif
std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
#if defined(__clang__)
# pragma clang diagnostic pop
#endif
filename_utf32 = converter.from_bytes(filename);
// If the reverse conversion mismatches, it means overlong UTF-8 sequences were used,
// or invalid encodings were encountered. Reject such attempts
std::string filename_reencoded = converter.to_bytes(filename_utf32);
if (filename_reencoded != filename) {
return false;
}
} catch (const std::exception &) {
return false;
}
// Check for forbidden codepoints:
// - Control characters
// - Unicode equivalents of illegal characters
// - UTF-16 surrogate pairs
// - UTF-8 replacement character
// - Byte order mark (BOM)
// - Illegal characters: / \ : * ? " < > |
for (char32_t c : filename_utf32) {
if (c <= 0x1F // Control characters (C0)
|| c == 0x7F // Control characters (DEL)
|| (c >= 0x80 && c <= 0x9F) // Control characters (C1)
|| c == 0xFF0E // Fullwidth Full Stop (period equivalent)
|| c == 0x2215 // Division Slash (forward slash equivalent)
|| c == 0x2216 // Set Minus (backslash equivalent)
|| (c >= 0xD800 && c <= 0xDFFF) // UTF-16 surrogate pairs
|| c == 0xFFFD // Replacement Character (UTF-8)
|| c == 0xFEFF // Byte Order Mark (BOM)
|| c == '/' || c == '\\' || c == ':' || c == '*' // Illegal characters
|| c == '?' || c == '"' || c == '<' || c == '>' || c == '|') {
return false;
}
}
// Reject any leading or trailing ' ', or any trailing '.', these are stripped on Windows and will cause a different filename
// Unicode and other whitespace is not affected, only 0x20 space
if (filename.front() == ' ' || filename.back() == ' ' || filename.back() == '.') {
return false;
}
// Reject any ".." (currently stricter than necessary, it should be fine to just check for == ".." instead)
if (filename.find("..") != std::string::npos) {
return false;
}
// Reject "."
if (filename == ".") {
return false;
}
return true;
} | O2 | cpp | fs_validate_filename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq $-0x100, %rax
addq 0x8(%rdi), %rax
cmpq $-0xff, %rax
jae 0x6cf26
xorl %r14d, %r14d
jmp 0x6cfbb
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
andl $0x0, (%rax)
leaq 0x48(%rsp), %rdi
callq 0x70cdc
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %rbx, %rdx
callq 0x70d3a
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x70d56
movq %r15, %rdi
callq 0x70e00
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %r14, %rdx
callq 0x70e10
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x263ce
movl %eax, %ebp
movq %r14, %rdi
callq 0x20d78
leaq 0x48(%rsp), %rdi
callq 0x70e2c
testb %bpl, %bpl
je 0x6cfcc
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
callq 0x70e00
movl %r14d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq $0x2, %rcx
xorl %edx, %edx
movabsq $0x400000035002101, %rsi # imm = 0x400000035002101
cmpq %rdx, %rcx
je 0x6d07f
movl (%rax,%rdx), %edi
xorl %r14d, %r14d
cmpl $0x20, %edi
jb 0x6cfb1
cmpl $0x7f, %edi
je 0x6cfb1
movl %edi, %r8d
andl $-0x20, %r8d
cmpl $0x80, %r8d
je 0x6cfb1
xorl %r14d, %r14d
leal -0x2215(%rdi), %r8d
cmpl $0x2, %r8d
jb 0x6cfb1
cmpl $0xff0e, %edi # imm = 0xFF0E
je 0x6cfb1
movl %edi, %r8d
andl $0xfffff800, %r8d # imm = 0xFFFFF800
cmpl $0xd800, %r8d # imm = 0xD800
je 0x6cfae
xorl %r14d, %r14d
leal -0x22(%rdi), %r8d
cmpl $0x3a, %r8d
ja 0x6d055
btq %r8, %rsi
jb 0x6cfb1
cmpl $0x7c, %edi
je 0x6cfb1
cmpl $0xfeff, %edi # imm = 0xFEFF
je 0x6cfb1
addq $0x4, %rdx
cmpl $0xfffd, %edi # imm = 0xFFFD
jne 0x6cfe6
jmp 0x6cfb1
movq (%rbx), %rax
cmpb $0x20, (%rax)
je 0x6cfae
movq 0x8(%rbx), %rcx
movzbl -0x1(%rax,%rcx), %eax
xorl %r14d, %r14d
cmpl $0x20, %eax
je 0x6cfb1
cmpl $0x2e, %eax
je 0x6cfb1
leaq 0x38c2b(%rip), %rsi # 0xa5cdb
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x20d30
cmpq $-0x1, %rax
jne 0x6cfb1
leaq 0x38c0e(%rip), %rsi # 0xa5cdc
movq %rbx, %rdi
callq 0x2b25d
movl %eax, %r14d
xorb $0x1, %r14b
jmp 0x6cfb1
jmp 0x6d0e4
movq %rdx, %r14
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x70e2c
jmp 0x6d0fc
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x6d117
movq %rbx, %rdi
callq 0x202c0
callq 0x20ac0
jmp 0x6cfae
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x70e00
movq %rbx, %rdi
callq 0x20b90
| _Z20fs_validate_filenameRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push rbx
sub rsp, 0A8h
mov rax, 0FFFFFFFFFFFFFF00h
add rax, [rdi+8]
cmp rax, 0FFFFFFFFFFFFFF01h
jnb short loc_6CF26
xor r14d, r14d
jmp loc_6CFBB
loc_6CF26:
mov rbx, rdi
lea rax, [rsp+0C8h+var_B0]
mov [rax-10h], rax
and qword ptr [rax-8], 0
and dword ptr [rax], 0
lea rdi, [rsp+0C8h+var_80]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEEC2Ev; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::wstring_convert(void)
lea rdi, [rsp+0C8h+var_A0]
lea rsi, [rsp+0C8h+var_80]
mov rdx, rbx
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEE10from_bytesERKNS_12basic_stringIcSt11char_traitsIcES5_EE; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::from_bytes(std::string const&)
lea r14, [rsp+0C8h+var_C0]
lea r15, [rsp+0C8h+var_A0]
mov rdi, r14
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEaSEOS4_; std::basic_string<char32_t>::operator=(std::basic_string<char32_t>&&)
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEED2Ev; std::basic_string<char32_t>::~basic_string()
lea rdi, [rsp+0C8h+var_A0]
lea rsi, [rsp+0C8h+var_80]
mov rdx, r14
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEE8to_bytesERKNS_12basic_stringIDiSt11char_traitsIDiES4_EE; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::to_bytes(std::basic_string<char32_t> const&)
lea r14, [rsp+0C8h+var_A0]
mov rdi, r14
mov rsi, rbx
call _ZStneIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EESA_; std::operator!=<char>(std::string const&,std::string const&)
mov ebp, eax
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0C8h+var_80]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEED2Ev; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::~wstring_convert()
test bpl, bpl
jz short loc_6CFCC
loc_6CFAE:
xor r14d, r14d
loc_6CFB1:
lea rdi, [rsp+0C8h+var_C0]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEED2Ev; std::basic_string<char32_t>::~basic_string()
loc_6CFBB:
mov eax, r14d
add rsp, 0A8h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_6CFCC:
mov rax, [rsp+0C8h+var_C0]
mov rcx, [rsp+0C8h+var_B8]
shl rcx, 2
xor edx, edx
mov rsi, 400000035002101h
loc_6CFE6:
cmp rcx, rdx
jz loc_6D07F
mov edi, [rax+rdx]
xor r14d, r14d
cmp edi, 20h ; ' '
jb short loc_6CFB1
cmp edi, 7Fh
jz short loc_6CFB1
mov r8d, edi
and r8d, 0FFFFFFE0h
cmp r8d, 80h
jz short loc_6CFB1
xor r14d, r14d
lea r8d, [rdi-2215h]
cmp r8d, 2
jb short loc_6CFB1
cmp edi, 0FF0Eh
jz short loc_6CFB1
mov r8d, edi
and r8d, 0FFFFF800h
cmp r8d, 0D800h
jz loc_6CFAE
xor r14d, r14d
lea r8d, [rdi-22h]
cmp r8d, 3Ah ; ':'
ja short loc_6D055
bt rsi, r8
jb loc_6CFB1
loc_6D055:
cmp edi, 7Ch ; '|'
jz loc_6CFB1
cmp edi, 0FEFFh
jz loc_6CFB1
add rdx, 4
cmp edi, 0FFFDh
jnz loc_6CFE6
jmp loc_6CFB1
loc_6D07F:
mov rax, [rbx]
cmp byte ptr [rax], 20h ; ' '
jz loc_6CFAE
mov rcx, [rbx+8]
movzx eax, byte ptr [rax+rcx-1]
xor r14d, r14d
cmp eax, 20h ; ' '
jz loc_6CFB1
cmp eax, 2Eh ; '.'
jz loc_6CFB1
lea rsi, asc_A5CDB; ".."
xor r14d, r14d
mov rdi, rbx
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcm; std::string::find(char const*,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz loc_6CFB1
lea rsi, asc_A5CDB+1; "."
mov rdi, rbx
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov r14d, eax
xor r14b, 1
jmp loc_6CFB1
jmp short $+2
loc_6D0E4:
mov r14, rdx
mov rbx, rax
lea rdi, [rsp+0C8h+var_80]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEED2Ev; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::~wstring_convert()
jmp short loc_6D0FC
mov r14, rdx
mov rbx, rax
loc_6D0FC:
cmp r14d, 1
jnz short loc_6D117
mov rdi, rbx; void *
call ___cxa_begin_catch
call ___cxa_end_catch
jmp loc_6CFAE
mov rbx, rax
loc_6D117:
lea rdi, [rsp+0C8h+var_C0]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEED2Ev; std::basic_string<char32_t>::~basic_string()
mov rdi, rbx
call __Unwind_Resume
| long long fs_validate_filename(_QWORD *a1)
{
unsigned int v1; // r14d
char v3; // bp
long long v5; // rdx
long long v6; // rsi
unsigned int v7; // edi
unsigned long long v8; // r8
int v9; // eax
unsigned int v10; // eax
int *v11; // [rsp+8h] [rbp-C0h] BYREF
long long v12; // [rsp+10h] [rbp-B8h]
int v13; // [rsp+18h] [rbp-B0h] BYREF
_BYTE v14[32]; // [rsp+28h] [rbp-A0h] BYREF
_BYTE v15[128]; // [rsp+48h] [rbp-80h] BYREF
if ( (unsigned long long)(a1[1] - 256LL) >= 0xFFFFFFFFFFFFFF01LL )
{
v11 = &v13;
v12 = 0LL;
v13 = 0;
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::wstring_convert(v15);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::from_bytes(
v14,
v15,
a1);
std::basic_string<char32_t>::operator=(&v11, v14);
std::basic_string<char32_t>::~basic_string(v14);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::to_bytes(
v14,
v15,
&v11);
v3 = std::operator!=<char>((long long)v14, (long long)a1);
std::string::~string(v14);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::~wstring_convert(v15);
if ( v3 )
goto LABEL_4;
v5 = 0LL;
v6 = 0x400000035002101LL;
while ( v12 != v5 )
{
v7 = v11[v5];
v1 = 0;
if ( v7 >= 0x20 && v7 != 127 && (v7 & 0xFFFFFFE0) != 0x80 )
{
v1 = 0;
if ( v7 - 8725 >= 2 && v7 != 65294 )
{
if ( (v7 & 0xFFFFF800) == 0xD800 )
goto LABEL_4;
v1 = 0;
v8 = v7 - 34;
if ( ((unsigned int)v8 > 0x3A || !_bittest64(&v6, v8)) && v7 != 124 && v7 != 65279 )
{
++v5;
if ( v7 != 65533 )
continue;
}
}
}
goto LABEL_5;
}
if ( *(_BYTE *)*a1 == 32 )
{
LABEL_4:
v1 = 0;
}
else
{
v9 = *(unsigned __int8 *)(*a1 + a1[1] - 1LL);
v1 = 0;
if ( v9 != 32 && v9 != 46 )
{
v1 = 0;
if ( std::string::find(a1, "..", 0LL) == -1 )
{
LOBYTE(v10) = std::operator==<char>((long long)a1);
v1 = v10;
LOBYTE(v1) = v10 ^ 1;
}
}
}
LABEL_5:
std::basic_string<char32_t>::~basic_string(&v11);
}
else
{
return 0;
}
return v1;
}
| fs_validate_filename:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xa8
MOV RAX,-0x100
ADD RAX,qword ptr [RDI + 0x8]
CMP RAX,-0xff
JNC 0x0016cf26
XOR R14D,R14D
JMP 0x0016cfbb
LAB_0016cf26:
MOV RBX,RDI
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
AND qword ptr [RAX + -0x8],0x0
AND dword ptr [RAX],0x0
LAB_0016cf3a:
LEA RDI,[RSP + 0x48]
CALL 0x00170cdc
LAB_0016cf44:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x48]
MOV RDX,RBX
CALL 0x00170d3a
LEA R14,[RSP + 0x8]
LEA R15,[RSP + 0x28]
MOV RDI,R14
MOV RSI,R15
CALL 0x00170d56
MOV RDI,R15
CALL 0x00170e00
LAB_0016cf73:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x48]
MOV RDX,R14
CALL 0x00170e10
LAB_0016cf85:
LEA R14,[RSP + 0x28]
MOV RDI,R14
MOV RSI,RBX
CALL 0x001263ce
MOV EBP,EAX
MOV RDI,R14
CALL 0x00120d78
LEA RDI,[RSP + 0x48]
CALL 0x00170e2c
TEST BPL,BPL
JZ 0x0016cfcc
LAB_0016cfae:
XOR R14D,R14D
LAB_0016cfb1:
LEA RDI,[RSP + 0x8]
CALL 0x00170e00
LAB_0016cfbb:
MOV EAX,R14D
ADD RSP,0xa8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0016cfcc:
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x10]
SHL RCX,0x2
XOR EDX,EDX
MOV RSI,0x400000035002101
LAB_0016cfe6:
CMP RCX,RDX
JZ 0x0016d07f
MOV EDI,dword ptr [RAX + RDX*0x1]
XOR R14D,R14D
CMP EDI,0x20
JC 0x0016cfb1
CMP EDI,0x7f
JZ 0x0016cfb1
MOV R8D,EDI
AND R8D,0xffffffe0
CMP R8D,0x80
JZ 0x0016cfb1
XOR R14D,R14D
LEA R8D,[RDI + -0x2215]
CMP R8D,0x2
JC 0x0016cfb1
CMP EDI,0xff0e
JZ 0x0016cfb1
MOV R8D,EDI
AND R8D,0xfffff800
CMP R8D,0xd800
JZ 0x0016cfae
XOR R14D,R14D
LEA R8D,[RDI + -0x22]
CMP R8D,0x3a
JA 0x0016d055
BT RSI,R8
JC 0x0016cfb1
LAB_0016d055:
CMP EDI,0x7c
JZ 0x0016cfb1
CMP EDI,0xfeff
JZ 0x0016cfb1
ADD RDX,0x4
CMP EDI,0xfffd
JNZ 0x0016cfe6
JMP 0x0016cfb1
LAB_0016d07f:
MOV RAX,qword ptr [RBX]
CMP byte ptr [RAX],0x20
JZ 0x0016cfae
MOV RCX,qword ptr [RBX + 0x8]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + -0x1]
XOR R14D,R14D
CMP EAX,0x20
JZ 0x0016cfb1
CMP EAX,0x2e
JZ 0x0016cfb1
LEA RSI,[0x1a5cdb]
XOR R14D,R14D
MOV RDI,RBX
XOR EDX,EDX
CALL 0x00120d30
CMP RAX,-0x1
JNZ 0x0016cfb1
LEA RSI,[0x1a5cdc]
MOV RDI,RBX
CALL 0x0012b25d
MOV R14D,EAX
XOR R14B,0x1
JMP 0x0016cfb1
|
/* fs_validate_filename(std::__cxx11::string const&) */
ulong fs_validate_filename(string *param_1)
{
char cVar1;
uint uVar2;
bool bVar3;
int7 extraout_var;
long lVar4;
ulong uVar5;
int4 *local_c0;
long local_b8;
int4 local_b0 [4];
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
local_a0 [32];
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
local_80 [96];
if (*(long *)(param_1 + 8) - 0x100U < 0xffffffffffffff01) {
uVar5 = 0;
}
else {
local_c0 = local_b0;
local_b8 = 0;
local_b0[0] = 0;
/* try { // try from 0016cf3a to 0016cf43 has its CatchHandler @ 0016d0f6 */
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::wstring_convert(local_80);
/* try { // try from 0016cf44 to 0016cf55 has its CatchHandler @ 0016d0e4 */
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::from_bytes(local_a0,(string *)local_80);
std::__cxx11::u32string::operator=((u32string *)&local_c0,(u32string *)local_a0);
std::__cxx11::u32string::~u32string((u32string *)local_a0);
/* try { // try from 0016cf73 to 0016cf84 has its CatchHandler @ 0016d0e2 */
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::to_bytes(local_a0,(u32string *)local_80);
bVar3 = std::operator!=((string *)local_a0,param_1);
std::__cxx11::string::~string((string *)local_a0);
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::~wstring_convert(local_80);
if (bVar3) {
LAB_0016cfae:
uVar5 = 0;
}
else {
lVar4 = 0;
while (local_b8 << 2 != lVar4) {
uVar2 = *(uint *)((long)local_c0 + lVar4);
uVar5 = 0;
if ((((uVar2 < 0x20) || (uVar2 == 0x7f)) || ((uVar2 & 0xffffffe0) == 0x80)) ||
((uVar5 = 0, uVar2 - 0x2215 < 2 || (uVar2 == 0xff0e)))) goto LAB_0016cfb1;
if ((uVar2 & 0xfffff800) == 0xd800) goto LAB_0016cfae;
uVar5 = 0;
if (((uVar2 - 0x22 < 0x3b) &&
((0x400000035002101U >> ((ulong)(uVar2 - 0x22) & 0x3f) & 1) != 0)) ||
((uVar2 == 0x7c || ((uVar2 == 0xfeff || (lVar4 = lVar4 + 4, uVar2 == 0xfffd))))))
goto LAB_0016cfb1;
}
if (**(char **)param_1 == ' ') goto LAB_0016cfae;
cVar1 = (*(char **)param_1)[*(long *)(param_1 + 8) + -1];
uVar5 = 0;
if ((cVar1 != ' ') && (cVar1 != '.')) {
uVar5 = 0;
lVar4 = std::__cxx11::string::find((char *)param_1,0x1a5cdb);
if (lVar4 == -1) {
bVar3 = std::operator==(param_1,".");
uVar5 = CONCAT71(extraout_var,bVar3) & 0xffffffff ^ 1;
}
}
}
LAB_0016cfb1:
std::__cxx11::u32string::~u32string((u32string *)&local_c0);
}
return uVar5;
}
|
|
3,263 | my_thread_init_common_mutex | eloqsql/mysys/my_thr_init.c | static void my_thread_init_common_mutex(void)
{
mysql_mutex_init(key_THR_LOCK_open, &THR_LOCK_open, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_lock, &THR_LOCK_lock, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_myisam, &THR_LOCK_myisam, MY_MUTEX_INIT_SLOW);
mysql_mutex_init(key_THR_LOCK_myisam_mmap, &THR_LOCK_myisam_mmap, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_heap, &THR_LOCK_heap, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_net, &THR_LOCK_net, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_charset, &THR_LOCK_charset, MY_MUTEX_INIT_FAST);
#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
mysql_mutex_init(key_LOCK_localtime_r, &LOCK_localtime_r, MY_MUTEX_INIT_SLOW);
#endif
} | O0 | c | my_thread_init_common_mutex:
pushq %rbp
movq %rsp, %rbp
leaq 0x38026d(%rip), %rax # 0x40cb78
movl (%rax), %edi
leaq 0x380c4c(%rip), %rsi # 0x40d560
leaq 0x380f15(%rip), %rdx # 0x40d830
callq 0x8d610
leaq 0x38023d(%rip), %rax # 0x40cb64
movl (%rax), %edi
leaq 0x380c78(%rip), %rsi # 0x40d5a8
leaq 0x380ef9(%rip), %rdx # 0x40d830
callq 0x8d610
leaq 0x38022d(%rip), %rax # 0x40cb70
movl (%rax), %edi
leaq 0x380ca4(%rip), %rsi # 0x40d5f0
xorl %eax, %eax
movl %eax, %edx
callq 0x8d610
leaq 0x380228(%rip), %rax # 0x40cb84
movl (%rax), %edi
leaq 0x380cd3(%rip), %rsi # 0x40d638
leaq 0x380ec4(%rip), %rdx # 0x40d830
callq 0x8d610
leaq 0x3801e8(%rip), %rax # 0x40cb60
movl (%rax), %edi
leaq 0x380cff(%rip), %rsi # 0x40d680
leaq 0x380ea8(%rip), %rdx # 0x40d830
callq 0x8d610
leaq 0x3801e0(%rip), %rax # 0x40cb74
movl (%rax), %edi
leaq 0x380d2b(%rip), %rsi # 0x40d6c8
leaq 0x380e8c(%rip), %rdx # 0x40d830
callq 0x8d610
leaq 0x3801ac(%rip), %rax # 0x40cb5c
movl (%rax), %edi
leaq 0x380d57(%rip), %rsi # 0x40d710
leaq 0x380e70(%rip), %rdx # 0x40d830
callq 0x8d610
popq %rbp
retq
nopw (%rax,%rax)
| my_thread_init_common_mutex:
push rbp
mov rbp, rsp
lea rax, key_THR_LOCK_open
mov edi, [rax]
lea rsi, THR_LOCK_open
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init
lea rax, key_THR_LOCK_lock
mov edi, [rax]
lea rsi, THR_LOCK_lock
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init
lea rax, key_THR_LOCK_myisam
mov edi, [rax]
lea rsi, THR_LOCK_myisam
xor eax, eax
mov edx, eax
call inline_mysql_mutex_init
lea rax, key_THR_LOCK_myisam_mmap
mov edi, [rax]
lea rsi, THR_LOCK_myisam_mmap
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init
lea rax, key_THR_LOCK_heap
mov edi, [rax]
lea rsi, THR_LOCK_heap
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init
lea rax, key_THR_LOCK_net
mov edi, [rax]
lea rsi, THR_LOCK_net
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init
lea rax, key_THR_LOCK_charset
mov edi, [rax]
lea rsi, THR_LOCK_charset
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init
pop rbp
retn
| long long my_thread_init_common_mutex()
{
inline_mysql_mutex_init(key_THR_LOCK_open, &THR_LOCK_open, &my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_lock, &THR_LOCK_lock, &my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_myisam, &THR_LOCK_myisam, 0LL);
inline_mysql_mutex_init(key_THR_LOCK_myisam_mmap, &THR_LOCK_myisam_mmap, &my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_heap, &THR_LOCK_heap, &my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_net, &THR_LOCK_net, &my_fast_mutexattr);
return inline_mysql_mutex_init(key_THR_LOCK_charset, &THR_LOCK_charset, &my_fast_mutexattr);
}
| my_thread_init_common_mutex:
PUSH RBP
MOV RBP,RSP
LEA RAX,[0x50cb78]
MOV EDI,dword ptr [RAX]
LEA RSI,[0x50d560]
LEA RDX,[0x50d830]
CALL 0x0018d610
LEA RAX,[0x50cb64]
MOV EDI,dword ptr [RAX]
LEA RSI,[0x50d5a8]
LEA RDX,[0x50d830]
CALL 0x0018d610
LEA RAX,[0x50cb70]
MOV EDI,dword ptr [RAX]
LEA RSI,[0x50d5f0]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x0018d610
LEA RAX,[0x50cb84]
MOV EDI,dword ptr [RAX]
LEA RSI,[0x50d638]
LEA RDX,[0x50d830]
CALL 0x0018d610
LEA RAX,[0x50cb60]
MOV EDI,dword ptr [RAX]
LEA RSI,[0x50d680]
LEA RDX,[0x50d830]
CALL 0x0018d610
LEA RAX,[0x50cb74]
MOV EDI,dword ptr [RAX]
LEA RSI,[0x50d6c8]
LEA RDX,[0x50d830]
CALL 0x0018d610
LEA RAX,[0x50cb5c]
MOV EDI,dword ptr [RAX]
LEA RSI,[0x50d710]
LEA RDX,[0x50d830]
CALL 0x0018d610
POP RBP
RET
|
void my_thread_init_common_mutex(void)
{
inline_mysql_mutex_init(key_THR_LOCK_open,THR_LOCK_open,&my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_lock,THR_LOCK_lock,&my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_myisam,THR_LOCK_myisam,0);
inline_mysql_mutex_init(key_THR_LOCK_myisam_mmap,THR_LOCK_myisam_mmap,&my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_heap,THR_LOCK_heap,&my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_net,THR_LOCK_net,&my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_charset,THR_LOCK_charset,&my_fast_mutexattr);
return;
}
|
|
3,264 | JS_ThrowError | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_ThrowError(JSContext *ctx, JSErrorEnum error_num,
const char *fmt, va_list ap)
{
JSRuntime *rt = ctx->rt;
JSStackFrame *sf;
BOOL add_backtrace;
/* the backtrace is added later if called from a bytecode function */
sf = rt->current_stack_frame;
add_backtrace = !rt->in_out_of_memory &&
(!sf || (JS_GetFunctionBytecode(sf->cur_func) == NULL));
return JS_ThrowError2(ctx, error_num, fmt, ap, add_backtrace);
} | O0 | c | JS_ThrowError:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x108(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x100(%rax), %ecx
shll $0x18, %ecx
sarl $0x18, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x3(%rsp)
jne 0x2d1c5
movb $0x1, %al
cmpq $0x0, 0x8(%rsp)
movb %al, 0x2(%rsp)
je 0x2d1bd
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x5fcc0
cmpq $0x0, %rax
sete %al
movb %al, 0x2(%rsp)
movb 0x2(%rsp), %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
movzbl %al, %eax
andl $0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0x4(%rsp), %r8d
callq 0x48830
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nopl (%rax)
| JS_ThrowError:
sub rsp, 48h
mov [rsp+48h+var_18], rdi
mov [rsp+48h+var_1C], esi
mov [rsp+48h+var_28], rdx
mov [rsp+48h+var_30], rcx
mov rax, [rsp+48h+var_18]
mov rax, [rax+18h]
mov [rsp+48h+var_38], rax
mov rax, [rsp+48h+var_38]
mov rax, [rax+108h]
mov [rsp+48h+var_40], rax
mov rax, [rsp+48h+var_38]
mov ecx, [rax+100h]
shl ecx, 18h
sar ecx, 18h
xor eax, eax
cmp ecx, 0
mov [rsp+48h+var_45], al
jnz short loc_2D1C5
mov al, 1
cmp [rsp+48h+var_40], 0
mov [rsp+48h+var_46], al
jz short loc_2D1BD
mov rax, [rsp+48h+var_40]
mov rdi, [rax+8]
mov rsi, [rax+10h]
call JS_GetFunctionBytecode
cmp rax, 0
setz al
mov [rsp+48h+var_46], al
loc_2D1BD:
mov al, [rsp+48h+var_46]
mov [rsp+48h+var_45], al
loc_2D1C5:
mov al, [rsp+48h+var_45]
movzx eax, al
and eax, 1
mov [rsp+48h+var_44], eax
mov rdi, [rsp+48h+var_18]
mov esi, [rsp+48h+var_1C]
mov rdx, [rsp+48h+var_28]
mov rcx, [rsp+48h+var_30]
mov r8d, [rsp+48h+var_44]
call JS_ThrowError2
mov [rsp+48h+var_10], rax
mov [rsp+48h+var_8], rdx
mov rax, [rsp+48h+var_10]
mov rdx, [rsp+48h+var_8]
add rsp, 48h
retn
| long long JS_ThrowError(long long a1, unsigned int a2, long long a3, long long a4)
{
bool v5; // [rsp+2h] [rbp-46h]
bool v6; // [rsp+3h] [rbp-45h]
long long v7; // [rsp+8h] [rbp-40h]
long long v8; // [rsp+10h] [rbp-38h]
v8 = *(_QWORD *)(a1 + 24);
v7 = *(_QWORD *)(v8 + 264);
v6 = 0;
if ( !(unsigned __int8)*(_DWORD *)(v8 + 256) )
{
v5 = 1;
if ( v7 )
v5 = JS_GetFunctionBytecode(*(_QWORD *)(v7 + 8), *(_QWORD *)(v7 + 16)) == 0;
v6 = v5;
}
return JS_ThrowError2(a1, a2, a3, a4, v6);
}
| JS_ThrowError:
SUB RSP,0x48
MOV qword ptr [RSP + 0x30],RDI
MOV dword ptr [RSP + 0x2c],ESI
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x18],RCX
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x108]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RAX + 0x100]
SHL ECX,0x18
SAR ECX,0x18
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RSP + 0x3],AL
JNZ 0x0012d1c5
MOV AL,0x1
CMP qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x2],AL
JZ 0x0012d1bd
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RAX + 0x10]
CALL 0x0015fcc0
CMP RAX,0x0
SETZ AL
MOV byte ptr [RSP + 0x2],AL
LAB_0012d1bd:
MOV AL,byte ptr [RSP + 0x2]
MOV byte ptr [RSP + 0x3],AL
LAB_0012d1c5:
MOV AL,byte ptr [RSP + 0x3]
MOVZX EAX,AL
AND EAX,0x1
MOV dword ptr [RSP + 0x4],EAX
MOV RDI,qword ptr [RSP + 0x30]
MOV ESI,dword ptr [RSP + 0x2c]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x18]
MOV R8D,dword ptr [RSP + 0x4]
CALL 0x00148830
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
int1 [16]
JS_ThrowError(long param_1,int4 param_2,int8 param_3,int8 param_4)
{
int1 auVar1 [16];
long lVar2;
int1 local_46;
int1 local_45;
lVar2 = *(long *)(*(long *)(param_1 + 0x18) + 0x108);
local_45 = false;
if ((char)*(int4 *)(*(long *)(param_1 + 0x18) + 0x100) == '\0') {
local_46 = true;
if (lVar2 != 0) {
lVar2 = JS_GetFunctionBytecode(*(int8 *)(lVar2 + 8),*(int8 *)(lVar2 + 0x10));
local_46 = lVar2 == 0;
}
local_45 = local_46;
}
auVar1 = JS_ThrowError2(param_1,param_2,param_3,param_4,local_45);
return auVar1;
}
|
|
3,265 | JS_ThrowError | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_ThrowError(JSContext *ctx, JSErrorEnum error_num,
const char *fmt, va_list ap)
{
JSRuntime *rt = ctx->rt;
JSStackFrame *sf;
BOOL add_backtrace;
/* the backtrace is added later if called from a bytecode function */
sf = rt->current_stack_frame;
add_backtrace = !rt->in_out_of_memory &&
(!sf || (JS_GetFunctionBytecode(sf->cur_func) == NULL));
return JS_ThrowError2(ctx, error_num, fmt, ap, add_backtrace);
} | O1 | c | JS_ThrowError:
movq 0x18(%rdi), %rax
xorl %r8d, %r8d
cmpb $0x0, 0x100(%rax)
jne 0x2fdef
movq 0x108(%rax), %rax
testq %rax, %rax
je 0x224c6
movsd 0x8(%rax), %xmm0
movl 0x10(%rax), %eax
movsd %xmm0, -0x8(%rsp)
movl $0x1, %r8d
cmpl $-0x1, %eax
jne 0x2fdef
movq -0x8(%rsp), %rax
movzwl 0x6(%rax), %r9d
cmpq $0x38, %r9
ja 0x2fdef
movabsq $0x110000000012000, %r10 # imm = 0x110000000012000
btq %r9, %r10
jae 0x2fdef
xorl %r8d, %r8d
cmpq $0x0, 0x30(%rax)
sete %r8b
jmp 0x2fdef
movl $0x1, %r8d
jmp 0x2fdef
| JS_ThrowError:
mov rax, [rdi+18h]
xor r8d, r8d
cmp byte ptr [rax+100h], 0
jnz JS_ThrowError2
mov rax, [rax+108h]
test rax, rax
jz short loc_224C6
movsd xmm0, qword ptr [rax+8]
mov eax, [rax+10h]
movsd [rsp+var_8], xmm0
mov r8d, 1
cmp eax, 0FFFFFFFFh
jnz JS_ThrowError2
mov rax, [rsp+var_8]
movzx r9d, word ptr [rax+6]
cmp r9, 38h ; '8'
ja JS_ThrowError2
mov r10, 110000000012000h
bt r10, r9
jnb JS_ThrowError2
xor r8d, r8d
cmp qword ptr [rax+30h], 0
setz r8b
jmp JS_ThrowError2
loc_224C6:
mov r8d, 1
jmp JS_ThrowError2
| long long JS_ThrowError(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // r8
long long v6; // rax
unsigned long long v7; // r9
long long v8; // r10
long long v10; // [rsp+0h] [rbp-8h]
v4 = *(_QWORD *)(a1 + 24);
v5 = 0LL;
if ( !*(_BYTE *)(v4 + 256) )
{
v6 = *(_QWORD *)(v4 + 264);
if ( !v6 )
return JS_ThrowError2(a1, a2, a3, a4, 1LL);
v10 = *(_QWORD *)(v6 + 8);
v5 = 1LL;
if ( *(_DWORD *)(v6 + 16) == -1 )
{
v7 = *(unsigned __int16 *)(v10 + 6);
if ( v7 <= 0x38 )
{
v8 = 0x110000000012000LL;
if ( _bittest64(&v8, v7) )
return JS_ThrowError2(a1, a2, a3, a4, *(_QWORD *)(v10 + 48) == 0LL);
}
}
}
return JS_ThrowError2(a1, a2, a3, a4, v5);
}
| |||
3,266 | JS_ThrowError | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_ThrowError(JSContext *ctx, JSErrorEnum error_num,
const char *fmt, va_list ap)
{
JSRuntime *rt = ctx->rt;
JSStackFrame *sf;
BOOL add_backtrace;
/* the backtrace is added later if called from a bytecode function */
sf = rt->current_stack_frame;
add_backtrace = !rt->in_out_of_memory &&
(!sf || (JS_GetFunctionBytecode(sf->cur_func) == NULL));
return JS_ThrowError2(ctx, error_num, fmt, ap, add_backtrace);
} | O2 | c | JS_ThrowError:
movq 0x18(%rdi), %rax
xorl %r8d, %r8d
cmpb $0x0, 0x100(%rax)
jne 0x28557
movq 0x108(%rax), %rax
pushq $0x1
popq %r8
testq %rax, %rax
je 0x28557
cmpl $-0x1, 0x10(%rax)
jne 0x28557
movq 0x8(%rax), %rax
movzwl 0x6(%rax), %r9d
cmpq $0x38, %r9
ja 0x28557
movabsq $0x110000000012000, %r10 # imm = 0x110000000012000
btq %r9, %r10
jae 0x28557
xorl %r8d, %r8d
cmpq $0x0, 0x30(%rax)
sete %r8b
jmp 0x28557
| JS_ThrowError:
mov rax, [rdi+18h]
xor r8d, r8d
cmp byte ptr [rax+100h], 0
jnz JS_ThrowError2
mov rax, [rax+108h]
push 1
pop r8
test rax, rax
jz JS_ThrowError2
cmp dword ptr [rax+10h], 0FFFFFFFFh
jnz JS_ThrowError2
mov rax, [rax+8]
movzx r9d, word ptr [rax+6]
cmp r9, 38h ; '8'
ja JS_ThrowError2
mov r10, 110000000012000h
bt r10, r9
jnb JS_ThrowError2
xor r8d, r8d
cmp qword ptr [rax+30h], 0
setz r8b
jmp JS_ThrowError2
| long long JS_ThrowError(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // r8
long long v6; // rax
long long v7; // rax
unsigned long long v8; // r9
long long v9; // r10
v4 = *(_QWORD *)(a1 + 24);
v5 = 0LL;
if ( !*(_BYTE *)(v4 + 256)
&& (v6 = *(_QWORD *)(v4 + 264), v5 = 1LL, v6)
&& *(_DWORD *)(v6 + 16) == -1
&& (v7 = *(_QWORD *)(v6 + 8), v8 = *(unsigned __int16 *)(v7 + 6), v8 <= 0x38)
&& (v9 = 0x110000000012000LL, _bittest64(&v9, v8)) )
{
return JS_ThrowError2(a1, a2, a3, a4, *(_QWORD *)(v7 + 48) == 0LL);
}
else
{
return JS_ThrowError2(a1, a2, a3, a4, v5);
}
}
| JS_ThrowError:
MOV RAX,qword ptr [RDI + 0x18]
XOR R8D,R8D
CMP byte ptr [RAX + 0x100],0x0
JNZ 0x00128557
MOV RAX,qword ptr [RAX + 0x108]
PUSH 0x1
POP R8
TEST RAX,RAX
JZ 0x00128557
CMP dword ptr [RAX + 0x10],-0x1
JNZ 0x00128557
MOV RAX,qword ptr [RAX + 0x8]
MOVZX R9D,word ptr [RAX + 0x6]
CMP R9,0x38
JA 0x00128557
MOV R10,0x110000000012000
BT R10,R9
JNC 0x00128557
XOR R8D,R8D
CMP qword ptr [RAX + 0x30],0x0
SETZ R8B
JMP 0x00128557
|
void JS_ThrowError(long param_1,int4 param_2,char *param_3,__gnuc_va_list param_4)
{
long lVar1;
int8 uVar2;
ulong uVar3;
int1 auVar4 [16];
char acStack_128 [264];
uVar2 = 0;
if (*(char *)(*(long *)(param_1 + 0x18) + 0x100) == '\0') {
lVar1 = *(long *)(*(long *)(param_1 + 0x18) + 0x108);
uVar2 = 1;
if ((lVar1 != 0) && (*(int *)(lVar1 + 0x10) == -1)) {
uVar3 = (ulong)*(ushort *)(*(long *)(lVar1 + 8) + 6);
if ((uVar3 < 0x39) && ((0x110000000012000U >> (uVar3 & 0x3f) & 1) != 0)) {
JS_ThrowError2();
return;
}
}
}
vsnprintf(acStack_128,0x100,param_3,param_4);
auVar4 = JS_MakeError(param_1,param_2,acStack_128,uVar2);
if (auVar4._8_4_ == 6) {
auVar4 = ZEXT816(2) << 0x40;
}
JS_Throw(param_1,auVar4._0_8_,auVar4._8_8_);
return;
}
|
|
3,267 | fmt::v10::detail::dragonbox::cache_accessor<double>::get_cached_power(int) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format-inl.h | static auto get_cached_power(int k) noexcept -> uint128_fallback {
FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
"k is out of range");
static constexpr const uint128_fallback pow10_significands[] = {
#if FMT_USE_FULL_CACHE_DRAGONBOX
{0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
{0x9faacf3df73609b1, 0x77b191618c54e9ad},
{0xc795830d75038c1d, 0xd59df5b9ef6a2418},
{0xf97ae3d0d2446f25, 0x4b0573286b44ad1e},
{0x9becce62836ac577, 0x4ee367f9430aec33},
{0xc2e801fb244576d5, 0x229c41f793cda740},
{0xf3a20279ed56d48a, 0x6b43527578c11110},
{0x9845418c345644d6, 0x830a13896b78aaaa},
{0xbe5691ef416bd60c, 0x23cc986bc656d554},
{0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9},
{0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa},
{0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54},
{0xe858ad248f5c22c9, 0xd1b3400f8f9cff69},
{0x91376c36d99995be, 0x23100809b9c21fa2},
{0xb58547448ffffb2d, 0xabd40a0c2832a78b},
{0xe2e69915b3fff9f9, 0x16c90c8f323f516d},
{0x8dd01fad907ffc3b, 0xae3da7d97f6792e4},
{0xb1442798f49ffb4a, 0x99cd11cfdf41779d},
{0xdd95317f31c7fa1d, 0x40405643d711d584},
{0x8a7d3eef7f1cfc52, 0x482835ea666b2573},
{0xad1c8eab5ee43b66, 0xda3243650005eed0},
{0xd863b256369d4a40, 0x90bed43e40076a83},
{0x873e4f75e2224e68, 0x5a7744a6e804a292},
{0xa90de3535aaae202, 0x711515d0a205cb37},
{0xd3515c2831559a83, 0x0d5a5b44ca873e04},
{0x8412d9991ed58091, 0xe858790afe9486c3},
{0xa5178fff668ae0b6, 0x626e974dbe39a873},
{0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
{0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a},
{0xa139029f6a239f72, 0x1c1fffc1ebc44e81},
{0xc987434744ac874e, 0xa327ffb266b56221},
{0xfbe9141915d7a922, 0x4bf1ff9f0062baa9},
{0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa},
{0xc4ce17b399107c22, 0xcb550fb4384d21d4},
{0xf6019da07f549b2b, 0x7e2a53a146606a49},
{0x99c102844f94e0fb, 0x2eda7444cbfc426e},
{0xc0314325637a1939, 0xfa911155fefb5309},
{0xf03d93eebc589f88, 0x793555ab7eba27cb},
{0x96267c7535b763b5, 0x4bc1558b2f3458df},
{0xbbb01b9283253ca2, 0x9eb1aaedfb016f17},
{0xea9c227723ee8bcb, 0x465e15a979c1cadd},
{0x92a1958a7675175f, 0x0bfacd89ec191eca},
{0xb749faed14125d36, 0xcef980ec671f667c},
{0xe51c79a85916f484, 0x82b7e12780e7401b},
{0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811},
{0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16},
{0xdfbdcece67006ac9, 0x67a791e093e1d49b},
{0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1},
{0xaecc49914078536d, 0x58fae9f773886e19},
{0xda7f5bf590966848, 0xaf39a475506a899f},
{0x888f99797a5e012d, 0x6d8406c952429604},
{0xaab37fd7d8f58178, 0xc8e5087ba6d33b84},
{0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65},
{0x855c3be0a17fcd26, 0x5cf2eea09a550680},
{0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
{0xd0601d8efc57b08b, 0xf13b94daf124da27},
{0x823c12795db6ce57, 0x76c53d08d6b70859},
{0xa2cb1717b52481ed, 0x54768c4b0c64ca6f},
{0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a},
{0xfe5d54150b090b02, 0xd3f93b35435d7c4d},
{0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0},
{0xc6b8e9b0709f109a, 0x359ab6419ca1091c},
{0xf867241c8cc6d4c0, 0xc30163d203c94b63},
{0x9b407691d7fc44f8, 0x79e0de63425dcf1e},
{0xc21094364dfb5636, 0x985915fc12f542e5},
{0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e},
{0x979cf3ca6cec5b5a, 0xa705992ceecf9c43},
{0xbd8430bd08277231, 0x50c6ff782a838354},
{0xece53cec4a314ebd, 0xa4f8bf5635246429},
{0x940f4613ae5ed136, 0x871b7795e136be9a},
{0xb913179899f68584, 0x28e2557b59846e40},
{0xe757dd7ec07426e5, 0x331aeada2fe589d0},
{0x9096ea6f3848984f, 0x3ff0d2c85def7622},
{0xb4bca50b065abe63, 0x0fed077a756b53aa},
{0xe1ebce4dc7f16dfb, 0xd3e8495912c62895},
{0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d},
{0xb080392cc4349dec, 0xbd8d794d96aacfb4},
{0xdca04777f541c567, 0xecf0d7a0fc5583a1},
{0x89e42caaf9491b60, 0xf41686c49db57245},
{0xac5d37d5b79b6239, 0x311c2875c522ced6},
{0xd77485cb25823ac7, 0x7d633293366b828c},
{0x86a8d39ef77164bc, 0xae5dff9c02033198},
{0xa8530886b54dbdeb, 0xd9f57f830283fdfd},
{0xd267caa862a12d66, 0xd072df63c324fd7c},
{0x8380dea93da4bc60, 0x4247cb9e59f71e6e},
{0xa46116538d0deb78, 0x52d9be85f074e609},
{0xcd795be870516656, 0x67902e276c921f8c},
{0x806bd9714632dff6, 0x00ba1cd8a3db53b7},
{0xa086cfcd97bf97f3, 0x80e8a40eccd228a5},
{0xc8a883c0fdaf7df0, 0x6122cd128006b2ce},
{0xfad2a4b13d1b5d6c, 0x796b805720085f82},
{0x9cc3a6eec6311a63, 0xcbe3303674053bb1},
{0xc3f490aa77bd60fc, 0xbedbfc4411068a9d},
{0xf4f1b4d515acb93b, 0xee92fb5515482d45},
{0x991711052d8bf3c5, 0x751bdd152d4d1c4b},
{0xbf5cd54678eef0b6, 0xd262d45a78a0635e},
{0xef340a98172aace4, 0x86fb897116c87c35},
{0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1},
{0xbae0a846d2195712, 0x8974836059cca10a},
{0xe998d258869facd7, 0x2bd1a438703fc94c},
{0x91ff83775423cc06, 0x7b6306a34627ddd0},
{0xb67f6455292cbf08, 0x1a3bc84c17b1d543},
{0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94},
{0x8e938662882af53e, 0x547eb47b7282ee9d},
{0xb23867fb2a35b28d, 0xe99e619a4f23aa44},
{0xdec681f9f4c31f31, 0x6405fa00e2ec94d5},
{0x8b3c113c38f9f37e, 0xde83bc408dd3dd05},
{0xae0b158b4738705e, 0x9624ab50b148d446},
{0xd98ddaee19068c76, 0x3badd624dd9b0958},
{0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7},
{0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d},
{0xd47487cc8470652b, 0x7647c32000696720},
{0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074},
{0xa5fb0a17c777cf09, 0xf468107100525891},
{0xcf79cc9db955c2cc, 0x7182148d4066eeb5},
{0x81ac1fe293d599bf, 0xc6f14cd848405531},
{0xa21727db38cb002f, 0xb8ada00e5a506a7d},
{0xca9cf1d206fdc03b, 0xa6d90811f0e4851d},
{0xfd442e4688bd304a, 0x908f4a166d1da664},
{0x9e4a9cec15763e2e, 0x9a598e4e043287ff},
{0xc5dd44271ad3cdba, 0x40eff1e1853f29fe},
{0xf7549530e188c128, 0xd12bee59e68ef47d},
{0x9a94dd3e8cf578b9, 0x82bb74f8301958cf},
{0xc13a148e3032d6e7, 0xe36a52363c1faf02},
{0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2},
{0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba},
{0xbcb2b812db11a5de, 0x7415d448f6b6f0e8},
{0xebdf661791d60f56, 0x111b495b3464ad22},
{0x936b9fcebb25c995, 0xcab10dd900beec35},
{0xb84687c269ef3bfb, 0x3d5d514f40eea743},
{0xe65829b3046b0afa, 0x0cb4a5a3112a5113},
{0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac},
{0xb3f4e093db73a093, 0x59ed216765690f57},
{0xe0f218b8d25088b8, 0x306869c13ec3532d},
{0x8c974f7383725573, 0x1e414218c73a13fc},
{0xafbd2350644eeacf, 0xe5d1929ef90898fb},
{0xdbac6c247d62a583, 0xdf45f746b74abf3a},
{0x894bc396ce5da772, 0x6b8bba8c328eb784},
{0xab9eb47c81f5114f, 0x066ea92f3f326565},
{0xd686619ba27255a2, 0xc80a537b0efefebe},
{0x8613fd0145877585, 0xbd06742ce95f5f37},
{0xa798fc4196e952e7, 0x2c48113823b73705},
{0xd17f3b51fca3a7a0, 0xf75a15862ca504c6},
{0x82ef85133de648c4, 0x9a984d73dbe722fc},
{0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb},
{0xcc963fee10b7d1b3, 0x318df905079926a9},
{0xffbbcfe994e5c61f, 0xfdf17746497f7053},
{0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634},
{0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1},
{0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1},
{0x9c1661a651213e2d, 0x06bea10ca65c084f},
{0xc31bfa0fe5698db8, 0x486e494fcff30a63},
{0xf3e2f893dec3f126, 0x5a89dba3c3efccfb},
{0x986ddb5c6b3a76b7, 0xf89629465a75e01d},
{0xbe89523386091465, 0xf6bbb397f1135824},
{0xee2ba6c0678b597f, 0x746aa07ded582e2d},
{0x94db483840b717ef, 0xa8c2a44eb4571cdd},
{0xba121a4650e4ddeb, 0x92f34d62616ce414},
{0xe896a0d7e51e1566, 0x77b020baf9c81d18},
{0x915e2486ef32cd60, 0x0ace1474dc1d122f},
{0xb5b5ada8aaff80b8, 0x0d819992132456bb},
{0xe3231912d5bf60e6, 0x10e1fff697ed6c6a},
{0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
{0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3},
{0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf},
{0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c},
{0xad4ab7112eb3929d, 0x86c16c98d2c953c7},
{0xd89d64d57a607744, 0xe871c7bf077ba8b8},
{0x87625f056c7c4a8b, 0x11471cd764ad4973},
{0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0},
{0xd389b47879823479, 0x4aff1d108d4ec2c4},
{0x843610cb4bf160cb, 0xcedf722a585139bb},
{0xa54394fe1eedb8fe, 0xc2974eb4ee658829},
{0xce947a3da6a9273e, 0x733d226229feea33},
{0x811ccc668829b887, 0x0806357d5a3f5260},
{0xa163ff802a3426a8, 0xca07c2dcb0cf26f8},
{0xc9bcff6034c13052, 0xfc89b393dd02f0b6},
{0xfc2c3f3841f17c67, 0xbbac2078d443ace3},
{0x9d9ba7832936edc0, 0xd54b944b84aa4c0e},
{0xc5029163f384a931, 0x0a9e795e65d4df12},
{0xf64335bcf065d37d, 0x4d4617b5ff4a16d6},
{0x99ea0196163fa42e, 0x504bced1bf8e4e46},
{0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7},
{0xf07da27a82c37088, 0x5d767327bb4e5a4d},
{0x964e858c91ba2655, 0x3a6a07f8d510f870},
{0xbbe226efb628afea, 0x890489f70a55368c},
{0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f},
{0x92c8ae6b464fc96f, 0x3b0b8bc90012929e},
{0xb77ada0617e3bbcb, 0x09ce6ebb40173745},
{0xe55990879ddcaabd, 0xcc420a6a101d0516},
{0x8f57fa54c2a9eab6, 0x9fa946824a12232e},
{0xb32df8e9f3546564, 0x47939822dc96abfa},
{0xdff9772470297ebd, 0x59787e2b93bc56f8},
{0x8bfbea76c619ef36, 0x57eb4edb3c55b65b},
{0xaefae51477a06b03, 0xede622920b6b23f2},
{0xdab99e59958885c4, 0xe95fab368e45ecee},
{0x88b402f7fd75539b, 0x11dbcb0218ebb415},
{0xaae103b5fcd2a881, 0xd652bdc29f26a11a},
{0xd59944a37c0752a2, 0x4be76d3346f04960},
{0x857fcae62d8493a5, 0x6f70a4400c562ddc},
{0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953},
{0xd097ad07a71f26b2, 0x7e2000a41346a7a8},
{0x825ecc24c873782f, 0x8ed400668c0c28c9},
{0xa2f67f2dfa90563b, 0x728900802f0f32fb},
{0xcbb41ef979346bca, 0x4f2b40a03ad2ffba},
{0xfea126b7d78186bc, 0xe2f610c84987bfa9},
{0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca},
{0xc6ede63fa05d3143, 0x91503d1c79720dbc},
{0xf8a95fcf88747d94, 0x75a44c6397ce912b},
{0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb},
{0xc24452da229b021b, 0xfbe85badce996169},
{0xf2d56790ab41c2a2, 0xfae27299423fb9c4},
{0x97c560ba6b0919a5, 0xdccd879fc967d41b},
{0xbdb6b8e905cb600f, 0x5400e987bbc1c921},
{0xed246723473e3813, 0x290123e9aab23b69},
{0x9436c0760c86e30b, 0xf9a0b6720aaf6522},
{0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
{0xe7958cb87392c2c2, 0xb60b1d1230b20e05},
{0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3},
{0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4},
{0xe2280b6c20dd5232, 0x25c6da63c38de1b1},
{0x8d590723948a535f, 0x579c487e5a38ad0f},
{0xb0af48ec79ace837, 0x2d835a9df0c6d852},
{0xdcdb1b2798182244, 0xf8e431456cf88e66},
{0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900},
{0xac8b2d36eed2dac5, 0xe272467e3d222f40},
{0xd7adf884aa879177, 0x5b0ed81dcc6abb10},
{0x86ccbb52ea94baea, 0x98e947129fc2b4ea},
{0xa87fea27a539e9a5, 0x3f2398d747b36225},
{0xd29fe4b18e88640e, 0x8eec7f0d19a03aae},
{0x83a3eeeef9153e89, 0x1953cf68300424ad},
{0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8},
{0xcdb02555653131b6, 0x3792f412cb06794e},
{0x808e17555f3ebf11, 0xe2bbd88bbee40bd1},
{0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5},
{0xc8de047564d20a8b, 0xf245825a5a445276},
{0xfb158592be068d2e, 0xeed6e2f0f0d56713},
{0x9ced737bb6c4183d, 0x55464dd69685606c},
{0xc428d05aa4751e4c, 0xaa97e14c3c26b887},
{0xf53304714d9265df, 0xd53dd99f4b3066a9},
{0x993fe2c6d07b7fab, 0xe546a8038efe402a},
{0xbf8fdb78849a5f96, 0xde98520472bdd034},
{0xef73d256a5c0f77c, 0x963e66858f6d4441},
{0x95a8637627989aad, 0xdde7001379a44aa9},
{0xbb127c53b17ec159, 0x5560c018580d5d53},
{0xe9d71b689dde71af, 0xaab8f01e6e10b4a7},
{0x9226712162ab070d, 0xcab3961304ca70e9},
{0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23},
{0xe45c10c42a2b3b05, 0x8cb89a7db77c506b},
{0x8eb98a7a9a5b04e3, 0x77f3608e92adb243},
{0xb267ed1940f1c61c, 0x55f038b237591ed4},
{0xdf01e85f912e37a3, 0x6b6c46dec52f6689},
{0x8b61313bbabce2c6, 0x2323ac4b3b3da016},
{0xae397d8aa96c1b77, 0xabec975e0a0d081b},
{0xd9c7dced53c72255, 0x96e7bd358c904a22},
{0x881cea14545c7575, 0x7e50d64177da2e55},
{0xaa242499697392d2, 0xdde50bd1d5d0b9ea},
{0xd4ad2dbfc3d07787, 0x955e4ec64b44e865},
{0x84ec3c97da624ab4, 0xbd5af13bef0b113f},
{0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f},
{0xcfb11ead453994ba, 0x67de18eda5814af3},
{0x81ceb32c4b43fcf4, 0x80eacf948770ced8},
{0xa2425ff75e14fc31, 0xa1258379a94d028e},
{0xcad2f7f5359a3b3e, 0x096ee45813a04331},
{0xfd87b5f28300ca0d, 0x8bca9d6e188853fd},
{0x9e74d1b791e07e48, 0x775ea264cf55347e},
{0xc612062576589dda, 0x95364afe032a819e},
{0xf79687aed3eec551, 0x3a83ddbd83f52205},
{0x9abe14cd44753b52, 0xc4926a9672793543},
{0xc16d9a0095928a27, 0x75b7053c0f178294},
{0xf1c90080baf72cb1, 0x5324c68b12dd6339},
{0x971da05074da7bee, 0xd3f6fc16ebca5e04},
{0xbce5086492111aea, 0x88f4bb1ca6bcf585},
{0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6},
{0x9392ee8e921d5d07, 0x3aff322e62439fd0},
{0xb877aa3236a4b449, 0x09befeb9fad487c3},
{0xe69594bec44de15b, 0x4c2ebe687989a9b4},
{0x901d7cf73ab0acd9, 0x0f9d37014bf60a11},
{0xb424dc35095cd80f, 0x538484c19ef38c95},
{0xe12e13424bb40e13, 0x2865a5f206b06fba},
{0x8cbccc096f5088cb, 0xf93f87b7442e45d4},
{0xafebff0bcb24aafe, 0xf78f69a51539d749},
{0xdbe6fecebdedd5be, 0xb573440e5a884d1c},
{0x89705f4136b4a597, 0x31680a88f8953031},
{0xabcc77118461cefc, 0xfdc20d2b36ba7c3e},
{0xd6bf94d5e57a42bc, 0x3d32907604691b4d},
{0x8637bd05af6c69b5, 0xa63f9a49c2c1b110},
{0xa7c5ac471b478423, 0x0fcf80dc33721d54},
{0xd1b71758e219652b, 0xd3c36113404ea4a9},
{0x83126e978d4fdf3b, 0x645a1cac083126ea},
{0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4},
{0xcccccccccccccccc, 0xcccccccccccccccd},
{0x8000000000000000, 0x0000000000000000},
{0xa000000000000000, 0x0000000000000000},
{0xc800000000000000, 0x0000000000000000},
{0xfa00000000000000, 0x0000000000000000},
{0x9c40000000000000, 0x0000000000000000},
{0xc350000000000000, 0x0000000000000000},
{0xf424000000000000, 0x0000000000000000},
{0x9896800000000000, 0x0000000000000000},
{0xbebc200000000000, 0x0000000000000000},
{0xee6b280000000000, 0x0000000000000000},
{0x9502f90000000000, 0x0000000000000000},
{0xba43b74000000000, 0x0000000000000000},
{0xe8d4a51000000000, 0x0000000000000000},
{0x9184e72a00000000, 0x0000000000000000},
{0xb5e620f480000000, 0x0000000000000000},
{0xe35fa931a0000000, 0x0000000000000000},
{0x8e1bc9bf04000000, 0x0000000000000000},
{0xb1a2bc2ec5000000, 0x0000000000000000},
{0xde0b6b3a76400000, 0x0000000000000000},
{0x8ac7230489e80000, 0x0000000000000000},
{0xad78ebc5ac620000, 0x0000000000000000},
{0xd8d726b7177a8000, 0x0000000000000000},
{0x878678326eac9000, 0x0000000000000000},
{0xa968163f0a57b400, 0x0000000000000000},
{0xd3c21bcecceda100, 0x0000000000000000},
{0x84595161401484a0, 0x0000000000000000},
{0xa56fa5b99019a5c8, 0x0000000000000000},
{0xcecb8f27f4200f3a, 0x0000000000000000},
{0x813f3978f8940984, 0x4000000000000000},
{0xa18f07d736b90be5, 0x5000000000000000},
{0xc9f2c9cd04674ede, 0xa400000000000000},
{0xfc6f7c4045812296, 0x4d00000000000000},
{0x9dc5ada82b70b59d, 0xf020000000000000},
{0xc5371912364ce305, 0x6c28000000000000},
{0xf684df56c3e01bc6, 0xc732000000000000},
{0x9a130b963a6c115c, 0x3c7f400000000000},
{0xc097ce7bc90715b3, 0x4b9f100000000000},
{0xf0bdc21abb48db20, 0x1e86d40000000000},
{0x96769950b50d88f4, 0x1314448000000000},
{0xbc143fa4e250eb31, 0x17d955a000000000},
{0xeb194f8e1ae525fd, 0x5dcfab0800000000},
{0x92efd1b8d0cf37be, 0x5aa1cae500000000},
{0xb7abc627050305ad, 0xf14a3d9e40000000},
{0xe596b7b0c643c719, 0x6d9ccd05d0000000},
{0x8f7e32ce7bea5c6f, 0xe4820023a2000000},
{0xb35dbf821ae4f38b, 0xdda2802c8a800000},
{0xe0352f62a19e306e, 0xd50b2037ad200000},
{0x8c213d9da502de45, 0x4526f422cc340000},
{0xaf298d050e4395d6, 0x9670b12b7f410000},
{0xdaf3f04651d47b4c, 0x3c0cdd765f114000},
{0x88d8762bf324cd0f, 0xa5880a69fb6ac800},
{0xab0e93b6efee0053, 0x8eea0d047a457a00},
{0xd5d238a4abe98068, 0x72a4904598d6d880},
{0x85a36366eb71f041, 0x47a6da2b7f864750},
{0xa70c3c40a64e6c51, 0x999090b65f67d924},
{0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d},
{0x82818f1281ed449f, 0xbff8f10e7a8921a5},
{0xa321f2d7226895c7, 0xaff72d52192b6a0e},
{0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491},
{0xfee50b7025c36a08, 0x02f236d04753d5b5},
{0x9f4f2726179a2245, 0x01d762422c946591},
{0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6},
{0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3},
{0x9b934c3b330c8577, 0x63cc55f49f88eb30},
{0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc},
{0xf316271c7fc3908a, 0x8bef464e3945ef7b},
{0x97edd871cfda3a56, 0x97758bf0e3cbb5ad},
{0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318},
{0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde},
{0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b},
{0xb975d6b6ee39e436, 0xb3e2fd538e122b45},
{0xe7d34c64a9c85d44, 0x60dbbca87196b617},
{0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce},
{0xb51d13aea4a488dd, 0x6babab6398bdbe42},
{0xe264589a4dcdab14, 0xc696963c7eed2dd2},
{0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3},
{0xb0de65388cc8ada8, 0x3b25a55f43294bcc},
{0xdd15fe86affad912, 0x49ef0eb713f39ebf},
{0x8a2dbf142dfcc7ab, 0x6e3569326c784338},
{0xacb92ed9397bf996, 0x49c2c37f07965405},
{0xd7e77a8f87daf7fb, 0xdc33745ec97be907},
{0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4},
{0xa8acd7c0222311bc, 0xc40832ea0d68ce0d},
{0xd2d80db02aabd62b, 0xf50a3fa490c30191},
{0x83c7088e1aab65db, 0x792667c6da79e0fb},
{0xa4b8cab1a1563f52, 0x577001b891185939},
{0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
{0x80b05e5ac60b6178, 0x544f8158315b05b5},
{0xa0dc75f1778e39d6, 0x696361ae3db1c722},
{0xc913936dd571c84c, 0x03bc3a19cd1e38ea},
{0xfb5878494ace3a5f, 0x04ab48a04065c724},
{0x9d174b2dcec0e47b, 0x62eb0d64283f9c77},
{0xc45d1df942711d9a, 0x3ba5d0bd324f8395},
{0xf5746577930d6500, 0xca8f44ec7ee3647a},
{0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc},
{0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f},
{0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f},
{0x95d04aee3b80ece5, 0xbba1f1d158724a13},
{0xbb445da9ca61281f, 0x2a8a6e45ae8edc98},
{0xea1575143cf97226, 0xf52d09d71a3293be},
{0x924d692ca61be758, 0x593c2626705f9c57},
{0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d},
{0xe498f455c38b997a, 0x0b6dfb9c0f956448},
{0x8edf98b59a373fec, 0x4724bd4189bd5ead},
{0xb2977ee300c50fe7, 0x58edec91ec2cb658},
{0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee},
{0x8b865b215899f46c, 0xbd79e0d20082ee75},
{0xae67f1e9aec07187, 0xecd8590680a3aa12},
{0xda01ee641a708de9, 0xe80e6f4820cc9496},
{0x884134fe908658b2, 0x3109058d147fdcde},
{0xaa51823e34a7eede, 0xbd4b46f0599fd416},
{0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b},
{0x850fadc09923329e, 0x03e2cf6bc604ddb1},
{0xa6539930bf6bff45, 0x84db8346b786151d},
{0xcfe87f7cef46ff16, 0xe612641865679a64},
{0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f},
{0xa26da3999aef7749, 0xe3be5e330f38f09e},
{0xcb090c8001ab551c, 0x5cadf5bfd3072cc6},
{0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7},
{0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb},
{0xc646d63501a1511d, 0xb281e1fd541501b9},
{0xf7d88bc24209a565, 0x1f225a7ca91a4227},
{0x9ae757596946075f, 0x3375788de9b06959},
{0xc1a12d2fc3978937, 0x0052d6b1641c83af},
{0xf209787bb47d6b84, 0xc0678c5dbd23a49b},
{0x9745eb4d50ce6332, 0xf840b7ba963646e1},
{0xbd176620a501fbff, 0xb650e5a93bc3d899},
{0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf},
{0x93ba47c980e98cdf, 0xc66f336c36b10138},
{0xb8a8d9bbe123f017, 0xb80b0047445d4185},
{0xe6d3102ad96cec1d, 0xa60dc059157491e6},
{0x9043ea1ac7e41392, 0x87c89837ad68db30},
{0xb454e4a179dd1877, 0x29babe4598c311fc},
{0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b},
{0x8ce2529e2734bb1d, 0x1899e4a65f58660d},
{0xb01ae745b101e9e4, 0x5ec05dcff72e7f90},
{0xdc21a1171d42645d, 0x76707543f4fa1f74},
{0x899504ae72497eba, 0x6a06494a791c53a9},
{0xabfa45da0edbde69, 0x0487db9d17636893},
{0xd6f8d7509292d603, 0x45a9d2845d3c42b7},
{0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
{0xa7f26836f282b732, 0x8e6cac7768d7141f},
{0xd1ef0244af2364ff, 0x3207d795430cd927},
{0x8335616aed761f1f, 0x7f44e6bd49e807b9},
{0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7},
{0xcd036837130890a1, 0x36dba887c37a8c10},
{0x802221226be55a64, 0xc2494954da2c978a},
{0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d},
{0xc83553c5c8965d3d, 0x6f92829494e5acc8},
{0xfa42a8b73abbf48c, 0xcb772339ba1f17fa},
{0x9c69a97284b578d7, 0xff2a760414536efc},
{0xc38413cf25e2d70d, 0xfef5138519684abb},
{0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a},
{0x98bf2f79d5993802, 0xef2f773ffbd97a62},
{0xbeeefb584aff8603, 0xaafb550ffacfd8fb},
{0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39},
{0x952ab45cfa97a0b2, 0xdd945a747bf26184},
{0xba756174393d88df, 0x94f971119aeef9e5},
{0xe912b9d1478ceb17, 0x7a37cd5601aab85e},
{0x91abb422ccb812ee, 0xac62e055c10ab33b},
{0xb616a12b7fe617aa, 0x577b986b314d600a},
{0xe39c49765fdf9d94, 0xed5a7e85fda0b80c},
{0x8e41ade9fbebc27d, 0x14588f13be847308},
{0xb1d219647ae6b31c, 0x596eb2d8ae258fc9},
{0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc},
{0x8aec23d680043bee, 0x25de7bb9480d5855},
{0xada72ccc20054ae9, 0xaf561aa79a10ae6b},
{0xd910f7ff28069da4, 0x1b2ba1518094da05},
{0x87aa9aff79042286, 0x90fb44d2f05d0843},
{0xa99541bf57452b28, 0x353a1607ac744a54},
{0xd3fa922f2d1675f2, 0x42889b8997915ce9},
{0x847c9b5d7c2e09b7, 0x69956135febada12},
{0xa59bc234db398c25, 0x43fab9837e699096},
{0xcf02b2c21207ef2e, 0x94f967e45e03f4bc},
{0x8161afb94b44f57d, 0x1d1be0eebac278f6},
{0xa1ba1ba79e1632dc, 0x6462d92a69731733},
{0xca28a291859bbf93, 0x7d7b8f7503cfdcff},
{0xfcb2cb35e702af78, 0x5cda735244c3d43f},
{0x9defbf01b061adab, 0x3a0888136afa64a8},
{0xc56baec21c7a1916, 0x088aaa1845b8fdd1},
{0xf6c69a72a3989f5b, 0x8aad549e57273d46},
{0x9a3c2087a63f6399, 0x36ac54e2f678864c},
{0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de},
{0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6},
{0x969eb7c47859e743, 0x9f644ae5a4b1b326},
{0xbc4665b596706114, 0x873d5d9f0dde1fef},
{0xeb57ff22fc0c7959, 0xa90cb506d155a7eb},
{0x9316ff75dd87cbd8, 0x09a7f12442d588f3},
{0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30},
{0xe5d3ef282a242e81, 0x8f1668c8a86da5fb},
{0x8fa475791a569d10, 0xf96e017d694487bd},
{0xb38d92d760ec4455, 0x37c981dcc395a9ad},
{0xe070f78d3927556a, 0x85bbe253f47b1418},
{0x8c469ab843b89562, 0x93956d7478ccec8f},
{0xaf58416654a6babb, 0x387ac8d1970027b3},
{0xdb2e51bfe9d0696a, 0x06997b05fcc0319f},
{0x88fcf317f22241e2, 0x441fece3bdf81f04},
{0xab3c2fddeeaad25a, 0xd527e81cad7626c4},
{0xd60b3bd56a5586f1, 0x8a71e223d8d3b075},
{0x85c7056562757456, 0xf6872d5667844e4a},
{0xa738c6bebb12d16c, 0xb428f8ac016561dc},
{0xd106f86e69d785c7, 0xe13336d701beba53},
{0x82a45b450226b39c, 0xecc0024661173474},
{0xa34d721642b06084, 0x27f002d7f95d0191},
{0xcc20ce9bd35c78a5, 0x31ec038df7b441f5},
{0xff290242c83396ce, 0x7e67047175a15272},
{0x9f79a169bd203e41, 0x0f0062c6e984d387},
{0xc75809c42c684dd1, 0x52c07b78a3e60869},
{0xf92e0c3537826145, 0xa7709a56ccdf8a83},
{0x9bbcc7a142b17ccb, 0x88a66076400bb692},
{0xc2abf989935ddbfe, 0x6acff893d00ea436},
{0xf356f7ebf83552fe, 0x0583f6b8c4124d44},
{0x98165af37b2153de, 0xc3727a337a8b704b},
{0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d},
{0xeda2ee1c7064130c, 0x1162def06f79df74},
{0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9},
{0xb9a74a0637ce2ee1, 0x6d953e2bd7173693},
{0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438},
{0x910ab1d4db9914a0, 0x1d9c9892400a22a3},
{0xb54d5e4a127f59c8, 0x2503beb6d00cab4c},
{0xe2a0b5dc971f303a, 0x2e44ae64840fd61e},
{0x8da471a9de737e24, 0x5ceaecfed289e5d3},
{0xb10d8e1456105dad, 0x7425a83e872c5f48},
{0xdd50f1996b947518, 0xd12f124e28f7771a},
{0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70},
{0xace73cbfdc0bfb7b, 0x636cc64d1001550c},
{0xd8210befd30efa5a, 0x3c47f7e05401aa4f},
{0x8714a775e3e95c78, 0x65acfaec34810a72},
{0xa8d9d1535ce3b396, 0x7f1839a741a14d0e},
{0xd31045a8341ca07c, 0x1ede48111209a051},
{0x83ea2b892091e44d, 0x934aed0aab460433},
{0xa4e4b66b68b65d60, 0xf81da84d56178540},
{0xce1de40642e3f4b9, 0x36251260ab9d668f},
{0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a},
{0xa1075a24e4421730, 0xb24cf65b8612f820},
{0xc94930ae1d529cfc, 0xdee033f26797b628},
{0xfb9b7cd9a4a7443c, 0x169840ef017da3b2},
{0x9d412e0806e88aa5, 0x8e1f289560ee864f},
{0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3},
{0xf5b5d7ec8acb58a2, 0xae10af696774b1dc},
{0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a},
{0xbff610b0cc6edd3f, 0x17fd090a58d32af4},
{0xeff394dcff8a948e, 0xddfc4b4cef07f5b1},
{0x95f83d0a1fb69cd9, 0x4abdaf101564f98f},
{0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2},
{0xea53df5fd18d5513, 0x84c86189216dc5ee},
{0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5},
{0xb7118682dbb66a77, 0x3fbc8c33221dc2a2},
{0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
{0x8f05b1163ba6832d, 0x29cb4d87f2a7400f},
{0xb2c71d5bca9023f8, 0x743e20e9ef511013},
{0xdf78e4b2bd342cf6, 0x914da9246b255417},
{0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f},
{0xae9672aba3d0c320, 0xa184ac2473b529b2},
{0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f},
{0x8865899617fb1871, 0x7e2fa67c7a658893},
{0xaa7eebfb9df9de8d, 0xddbb901b98feeab8},
{0xd51ea6fa85785631, 0x552a74227f3ea566},
{0x8533285c936b35de, 0xd53a88958f872760},
{0xa67ff273b8460356, 0x8a892abaf368f138},
{0xd01fef10a657842c, 0x2d2b7569b0432d86},
{0x8213f56a67f6b29b, 0x9c3b29620e29fc74},
{0xa298f2c501f45f42, 0x8349f3ba91b47b90},
{0xcb3f2f7642717713, 0x241c70a936219a74},
{0xfe0efb53d30dd4d7, 0xed238cd383aa0111},
{0x9ec95d1463e8a506, 0xf4363804324a40ab},
{0xc67bb4597ce2ce48, 0xb143c6053edcd0d6},
{0xf81aa16fdc1b81da, 0xdd94b7868e94050b},
{0x9b10a4e5e9913128, 0xca7cf2b4191c8327},
{0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1},
{0xf24a01a73cf2dccf, 0xbc633b39673c8ced},
{0x976e41088617ca01, 0xd5be0503e085d814},
{0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19},
{0xec9c459d51852ba2, 0xddf8e7d60ed1219f},
{0x93e1ab8252f33b45, 0xcabb90e5c942b504},
{0xb8da1662e7b00a17, 0x3d6a751f3b936244},
{0xe7109bfba19c0c9d, 0x0cc512670a783ad5},
{0x906a617d450187e2, 0x27fb2b80668b24c6},
{0xb484f9dc9641e9da, 0xb1f9f660802dedf7},
{0xe1a63853bbd26451, 0x5e7873f8a0396974},
{0x8d07e33455637eb2, 0xdb0b487b6423e1e9},
{0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63},
{0xdc5c5301c56b75f7, 0x7641a140cc7810fc},
{0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e},
{0xac2820d9623bf429, 0x546345fa9fbdcd45},
{0xd732290fbacaf133, 0xa97c177947ad4096},
{0x867f59a9d4bed6c0, 0x49ed8eabcccc485e},
{0xa81f301449ee8c70, 0x5c68f256bfff5a75},
{0xd226fc195c6a2f8c, 0x73832eec6fff3112},
{0x83585d8fd9c25db7, 0xc831fd53c5ff7eac},
{0xa42e74f3d032f525, 0xba3e7ca8b77f5e56},
{0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec},
{0x80444b5e7aa7cf85, 0x7980d163cf5b81b4},
{0xa0555e361951c366, 0xd7e105bcc3326220},
{0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8},
{0xfa856334878fc150, 0xb14f98f6f0feb952},
{0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4},
{0xc3b8358109e84f07, 0x0a862f80ec4700c9},
{0xf4a642e14c6262c8, 0xcd27bb612758c0fb},
{0x98e7e9cccfbd7dbd, 0x8038d51cb897789d},
{0xbf21e44003acdd2c, 0xe0470a63e6bd56c4},
{0xeeea5d5004981478, 0x1858ccfce06cac75},
{0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
{0xbaa718e68396cffd, 0xd30560258f54e6bb},
{0xe950df20247c83fd, 0x47c6b82ef32a206a},
{0x91d28b7416cdd27e, 0x4cdc331d57fa5442},
{0xb6472e511c81471d, 0xe0133fe4adf8e953},
{0xe3d8f9e563a198e5, 0x58180fddd97723a7},
{0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649},
{0xb201833b35d63f73, 0x2cd2cc6551e513db},
{0xde81e40a034bcf4f, 0xf8077f7ea65e58d2},
{0x8b112e86420f6191, 0xfb04afaf27faf783},
{0xadd57a27d29339f6, 0x79c5db9af1f9b564},
{0xd94ad8b1c7380874, 0x18375281ae7822bd},
{0x87cec76f1c830548, 0x8f2293910d0b15b6},
{0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23},
{0xd433179d9c8cb841, 0x5fa60692a46151ec},
{0x849feec281d7f328, 0xdbc7c41ba6bcd334},
{0xa5c7ea73224deff3, 0x12b9b522906c0801},
{0xcf39e50feae16bef, 0xd768226b34870a01},
{0x81842f29f2cce375, 0xe6a1158300d46641},
{0xa1e53af46f801c53, 0x60495ae3c1097fd1},
{0xca5e89b18b602368, 0x385bb19cb14bdfc5},
{0xfcf62c1dee382c42, 0x46729e03dd9ed7b6},
{0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2},
{0xc5a05277621be293, 0xc7098b7305241886},
{0xf70867153aa2db38, 0xb8cbee4fc66d1ea8},
{0x9a65406d44a5c903, 0x737f74f1dc043329},
{0xc0fe908895cf3b44, 0x505f522e53053ff3},
{0xf13e34aabb430a15, 0x647726b9e7c68ff0},
{0x96c6e0eab509e64d, 0x5eca783430dc19f6},
{0xbc789925624c5fe0, 0xb67d16413d132073},
{0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890},
{0x933e37a534cbaae7, 0x8e91b962f7b6f15a},
{0xb80dc58e81fe95a1, 0x723627bbb5a4adb1},
{0xe61136f2227e3b09, 0xcec3b1aaa30dd91d},
{0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2},
{0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e},
{0xe0accfa875af45a7, 0x93eb1b80a33b8606},
{0x8c6c01c9498d8b88, 0xbc72f130660533c4},
{0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
{0xdb68c2ca82ed2a05, 0xa67398db9f6820e2},
#else
{0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
{0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
{0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
{0x86a8d39ef77164bc, 0xae5dff9c02033198},
{0xd98ddaee19068c76, 0x3badd624dd9b0958},
{0xafbd2350644eeacf, 0xe5d1929ef90898fb},
{0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
{0xe55990879ddcaabd, 0xcc420a6a101d0516},
{0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
{0x95a8637627989aad, 0xdde7001379a44aa9},
{0xf1c90080baf72cb1, 0x5324c68b12dd6339},
{0xc350000000000000, 0x0000000000000000},
{0x9dc5ada82b70b59d, 0xf020000000000000},
{0xfee50b7025c36a08, 0x02f236d04753d5b5},
{0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
{0xa6539930bf6bff45, 0x84db8346b786151d},
{0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
{0xd910f7ff28069da4, 0x1b2ba1518094da05},
{0xaf58416654a6babb, 0x387ac8d1970027b3},
{0x8da471a9de737e24, 0x5ceaecfed289e5d3},
{0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
{0xb8da1662e7b00a17, 0x3d6a751f3b936244},
{0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
{0xf13e34aabb430a15, 0x647726b9e7c68ff0}
#endif
};
#if FMT_USE_FULL_CACHE_DRAGONBOX
return pow10_significands[k - float_info<double>::min_k];
#else
static constexpr const uint64_t powers_of_5_64[] = {
0x0000000000000001, 0x0000000000000005, 0x0000000000000019,
0x000000000000007d, 0x0000000000000271, 0x0000000000000c35,
0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1,
0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd,
0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9,
0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5,
0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631,
0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed,
0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9};
static const int compression_ratio = 27;
// Compute base index.
int cache_index = (k - float_info<double>::min_k) / compression_ratio;
int kb = cache_index * compression_ratio + float_info<double>::min_k;
int offset = k - kb;
// Get base cache.
uint128_fallback base_cache = pow10_significands[cache_index];
if (offset == 0) return base_cache;
// Compute the required amount of bit-shift.
int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset;
FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected");
// Try to recover the real cache.
uint64_t pow5 = powers_of_5_64[offset];
uint128_fallback recovered_cache = umul128(base_cache.high(), pow5);
uint128_fallback middle_low = umul128(base_cache.low(), pow5);
recovered_cache += middle_low.high();
uint64_t high_to_middle = recovered_cache.high() << (64 - alpha);
uint64_t middle_to_low = recovered_cache.low() << (64 - alpha);
recovered_cache =
uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle,
((middle_low.low() >> alpha) | middle_to_low)};
FMT_ASSERT(recovered_cache.low() + 1 != 0, "");
return {recovered_cache.high(), recovered_cache.low() + 1};
#endif
} | O0 | c | fmt::v10::detail::dragonbox::cache_accessor<double>::get_cached_power(int):
subq $0xc8, %rsp
movl %edi, 0xb4(%rsp)
xorl %eax, %eax
cmpl $0xfffffedc, 0xb4(%rsp) # imm = 0xFFFFFEDC
movb %al, 0x3e(%rsp)
jl 0xafe13
cmpl $0x155, 0xb4(%rsp) # imm = 0x155
setle %al
movb %al, 0x3e(%rsp)
movb 0x3e(%rsp), %al
andb $0x1, %al
movb %al, 0xb3(%rsp)
leaq 0xb3(%rsp), %rdi
leaq 0x32da64(%rip), %rsi # 0x3dd893
callq 0xac0e0
movl 0xb4(%rsp), %eax
subl $0xfffffedc, %eax # imm = 0xFFFFFEDC
movl $0x1b, %ecx
cltd
idivl %ecx
movl %eax, 0xac(%rsp)
imull $0x1b, 0xac(%rsp), %eax
addl $0xfffffedc, %eax # imm = 0xFFFFFEDC
movl %eax, 0xa8(%rsp)
movl 0xb4(%rsp), %eax
subl 0xa8(%rsp), %eax
movl %eax, 0xa4(%rsp)
movslq 0xac(%rsp), %rcx
leaq 0x32e829(%rip), %rax # 0x3de6b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x90(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x98(%rsp)
cmpl $0x0, 0xa4(%rsp)
jne 0xafed4
movq 0x90(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0xc0(%rsp)
jmp 0xb00ca
movl 0xa8(%rsp), %edi
addl 0xa4(%rsp), %edi
callq 0xabcd0
movl %eax, 0x38(%rsp)
movl 0xa8(%rsp), %edi
callq 0xabcd0
movl %eax, %ecx
movl 0x38(%rsp), %eax
subl %ecx, %eax
subl 0xa4(%rsp), %eax
movl %eax, 0x8c(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x8c(%rsp)
movb %al, 0x3d(%rsp)
jle 0xaff2c
cmpl $0x40, 0x8c(%rsp)
setl %al
movb %al, 0x3d(%rsp)
movb 0x3d(%rsp), %al
andb $0x1, %al
movb %al, 0x8b(%rsp)
leaq 0x32d9a7(%rip), %rsi # 0x3dd8e7
leaq 0x8b(%rsp), %rdi
callq 0xb04e0
jmp 0xaff4f
movslq 0xa4(%rsp), %rcx
leaq 0x32e8d2(%rip), %rax # 0x3de830
movq (%rax,%rcx,8), %rax
movq %rax, 0x80(%rsp)
leaq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xb04d0
movq %rax, %rdi
movq 0x80(%rsp), %rsi
callq 0xb04f0
movq 0x18(%rsp), %rdi
movq %rax, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
callq 0xb0540
movq %rax, %rdi
movq 0x80(%rsp), %rsi
callq 0xb04f0
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xb04d0
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xb0550
movq 0x20(%rsp), %rdi
callq 0xb04d0
movq 0x20(%rsp), %rdi
movb 0x8c(%rsp), %cl
negb %cl
shlq %cl, %rax
movq %rax, 0x58(%rsp)
callq 0xb0540
movq 0x20(%rsp), %rdi
movb 0x8c(%rsp), %cl
negb %cl
shlq %cl, %rax
movq %rax, 0x50(%rsp)
callq 0xb0540
movq 0x28(%rsp), %rdi
movb 0x8c(%rsp), %cl
shrq %cl, %rax
movq 0x58(%rsp), %rcx
orq %rcx, %rax
movq %rax, 0x30(%rsp)
callq 0xb0540
movq 0x30(%rsp), %rsi
movq %rax, %rdx
movb 0x8c(%rsp), %cl
shrq %cl, %rdx
movq 0x50(%rsp), %rax
orq %rax, %rdx
leaq 0x40(%rsp), %rdi
callq 0xb05a0
jmp 0xb0062
movups 0x40(%rsp), %xmm0
movaps %xmm0, 0x70(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xb0540
subq $-0x1, %rax
setne 0x3f(%rsp)
leaq 0x331f1e(%rip), %rsi # 0x3e1fa9
leaq 0x3f(%rsp), %rdi
callq 0xac150
movq 0x8(%rsp), %rdi
callq 0xb04d0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0xb0540
movq 0x10(%rsp), %rsi
movq %rax, %rdx
incq %rdx
leaq 0xb8(%rsp), %rdi
callq 0xb05a0
jmp 0xb00c8
jmp 0xb00ca
movq 0xb8(%rsp), %rax
movq 0xc0(%rsp), %rdx
addq $0xc8, %rsp
retq
movq %rax, %rdi
callq 0x9cf00
nopw (%rax,%rax)
| _ZN3fmt3v106detail9dragonbox14cache_accessorIdE16get_cached_powerEi:
sub rsp, 0C8h
mov [rsp+0C8h+var_14], edi
xor eax, eax
cmp [rsp+0C8h+var_14], 0FFFFFEDCh
mov [rsp+0C8h+var_8A], al
jl short loc_AFE13
cmp [rsp+0C8h+var_14], 155h
setle al
mov [rsp+0C8h+var_8A], al
loc_AFE13:
mov al, [rsp+0C8h+var_8A]
and al, 1
mov [rsp+0C8h+var_15], al
lea rdi, [rsp+0C8h+var_15]
lea rsi, aKIsOutOfRange; "k is out of range"
call _ZN3fmt3v106detail13ignore_unusedIJbA18_cEEEvDpRKT_; fmt::v10::detail::ignore_unused<bool,char [18]>(bool,char [18] const&)
mov eax, [rsp+0C8h+var_14]
sub eax, 0FFFFFEDCh
mov ecx, 1Bh
cdq
idiv ecx
mov dword ptr [rsp+0C8h+var_20+4], eax
imul eax, dword ptr [rsp+0C8h+var_20+4], 1Bh
add eax, 0FFFFFEDCh
mov dword ptr [rsp+0C8h+var_20], eax
mov eax, [rsp+0C8h+var_14]
sub eax, dword ptr [rsp+0C8h+var_20]
mov [rsp+0C8h+var_24], eax
movsxd rcx, dword ptr [rsp+0C8h+var_20+4]
lea rax, _ZZN3fmt3v106detail9dragonbox14cache_accessorIdE16get_cached_powerEiE18pow10_significands; fmt::v10::detail::dragonbox::cache_accessor<double>::get_cached_power(int)::pow10_significands
shl rcx, 4
add rax, rcx
mov rcx, [rax]
mov [rsp+0C8h+var_38], rcx
mov rax, [rax+8]
mov [rsp+0C8h+var_30], rax
cmp [rsp+0C8h+var_24], 0
jnz short loc_AFED4
mov rax, [rsp+0C8h+var_38]
mov [rsp+0C8h+var_10], rax
mov rax, [rsp+0C8h+var_30]
mov [rsp+0C8h+var_8], rax
jmp loc_B00CA
loc_AFED4:
mov edi, dword ptr [rsp+0C8h+var_20]
add edi, [rsp+0C8h+var_24]; this
call _ZN3fmt3v106detail9dragonbox16floor_log2_pow10Ei; fmt::v10::detail::dragonbox::floor_log2_pow10(int)
mov [rsp+0C8h+var_90], eax
mov edi, dword ptr [rsp+0C8h+var_20]; this
call _ZN3fmt3v106detail9dragonbox16floor_log2_pow10Ei; fmt::v10::detail::dragonbox::floor_log2_pow10(int)
mov ecx, eax
mov eax, [rsp+0C8h+var_90]
sub eax, ecx
sub eax, [rsp+0C8h+var_24]
mov [rsp+0C8h+var_3C], eax
xor eax, eax
cmp [rsp+0C8h+var_3C], 0
mov [rsp+0C8h+var_8B], al
jle short loc_AFF2C
cmp [rsp+0C8h+var_3C], 40h ; '@'
setl al
mov [rsp+0C8h+var_8B], al
loc_AFF2C:
mov al, [rsp+0C8h+var_8B]
and al, 1
mov [rsp+0C8h+var_3D], al
lea rsi, aShiftingErrorD; "shifting error detected"
lea rdi, [rsp+0C8h+var_3D]
call _ZN3fmt3v106detail13ignore_unusedIJbA24_cEEEvDpRKT_; fmt::v10::detail::ignore_unused<bool,char [24]>(bool,char [24] const&)
jmp short $+2
loc_AFF4F:
movsxd rcx, [rsp+0C8h+var_24]
lea rax, _ZZN3fmt3v106detail9dragonbox14cache_accessorIdE16get_cached_powerEiE14powers_of_5_64
mov rax, [rax+rcx*8]
mov [rsp+0C8h+var_48], rax
lea rdi, [rsp+0C8h+var_38]; this
mov [rsp+0C8h+var_B0], rdi
call _ZNK3fmt3v106detail16uint128_fallback4highEv; fmt::v10::detail::uint128_fallback::high(void)
mov rdi, rax; this
mov rsi, [rsp+0C8h+var_48]; unsigned __int64
call _ZN3fmt3v106detail7umul128Emm; fmt::v10::detail::umul128(ulong,ulong)
mov rdi, [rsp+0C8h+var_B0]; this
mov qword ptr [rsp+0C8h+var_58], rax
mov qword ptr [rsp+0C8h+var_58+8], rdx
call _ZNK3fmt3v106detail16uint128_fallback3lowEv; fmt::v10::detail::uint128_fallback::low(void)
mov rdi, rax; this
mov rsi, [rsp+0C8h+var_48]; unsigned __int64
call _ZN3fmt3v106detail7umul128Emm; fmt::v10::detail::umul128(ulong,ulong)
mov [rsp+0C8h+var_68], rax
mov [rsp+0C8h+var_60], rdx
lea rdi, [rsp+0C8h+var_68]; this
mov [rsp+0C8h+var_A0], rdi
call _ZNK3fmt3v106detail16uint128_fallback4highEv; fmt::v10::detail::uint128_fallback::high(void)
mov rsi, rax
lea rdi, [rsp+0C8h+var_58]
mov [rsp+0C8h+var_A8], rdi
call _ZN3fmt3v106detail16uint128_fallbackpLEm; fmt::v10::detail::uint128_fallback::operator+=(ulong)
mov rdi, [rsp+0C8h+var_A8]; this
call _ZNK3fmt3v106detail16uint128_fallback4highEv; fmt::v10::detail::uint128_fallback::high(void)
mov rdi, [rsp+0C8h+var_A8]; this
mov cl, byte ptr [rsp+0C8h+var_3C]
neg cl
shl rax, cl
mov [rsp+0C8h+var_70], rax
call _ZNK3fmt3v106detail16uint128_fallback3lowEv; fmt::v10::detail::uint128_fallback::low(void)
mov rdi, [rsp+0C8h+var_A8]; this
mov cl, byte ptr [rsp+0C8h+var_3C]
neg cl
shl rax, cl
mov [rsp+0C8h+var_78], rax
call _ZNK3fmt3v106detail16uint128_fallback3lowEv; fmt::v10::detail::uint128_fallback::low(void)
mov rdi, [rsp+0C8h+var_A0]; this
mov cl, byte ptr [rsp+0C8h+var_3C]
shr rax, cl
mov rcx, [rsp+0C8h+var_70]
or rax, rcx
mov [rsp+0C8h+var_98], rax
call _ZNK3fmt3v106detail16uint128_fallback3lowEv; fmt::v10::detail::uint128_fallback::low(void)
mov rsi, [rsp+0C8h+var_98]; unsigned __int64
mov rdx, rax
mov cl, byte ptr [rsp+0C8h+var_3C]
shr rdx, cl
mov rax, [rsp+0C8h+var_78]
or rdx, rax; unsigned __int64
lea rdi, [rsp+0C8h+var_88]; this
call _ZN3fmt3v106detail16uint128_fallbackC2Emm; fmt::v10::detail::uint128_fallback::uint128_fallback(ulong,ulong)
jmp short $+2
loc_B0062:
movups xmm0, [rsp+0C8h+var_88]
movaps [rsp+0C8h+var_58], xmm0
lea rdi, [rsp+0C8h+var_58]; this
mov [rsp+0C8h+var_C0], rdi
call _ZNK3fmt3v106detail16uint128_fallback3lowEv; fmt::v10::detail::uint128_fallback::low(void)
sub rax, 0FFFFFFFFFFFFFFFFh
setnz [rsp+0C8h+var_89]
lea rsi, asc_3E1FA8+1; "ࠀ\u0B00"
lea rdi, [rsp+0C8h+var_89]
call _ZN3fmt3v106detail13ignore_unusedIJbA1_cEEEvDpRKT_; fmt::v10::detail::ignore_unused<bool,char [1]>(bool,char [1] const&)
mov rdi, [rsp+0C8h+var_C0]; this
call _ZNK3fmt3v106detail16uint128_fallback4highEv; fmt::v10::detail::uint128_fallback::high(void)
mov rdi, [rsp+0C8h+var_C0]; this
mov [rsp+0C8h+var_B8], rax
call _ZNK3fmt3v106detail16uint128_fallback3lowEv; fmt::v10::detail::uint128_fallback::low(void)
mov rsi, [rsp+0C8h+var_B8]; unsigned __int64
mov rdx, rax
inc rdx; unsigned __int64
lea rdi, [rsp+0C8h+var_10]; this
call _ZN3fmt3v106detail16uint128_fallbackC2Emm; fmt::v10::detail::uint128_fallback::uint128_fallback(ulong,ulong)
jmp short $+2
loc_B00C8:
jmp short $+2
loc_B00CA:
mov rax, [rsp+0C8h+var_10]
mov rdx, [rsp+0C8h+var_8]
add rsp, 0C8h
retn
mov rdi, rax
call __clang_call_terminate
| long long fmt::v10::detail::dragonbox::cache_accessor<double>::get_cached_power(int a1)
{
long long *v1; // rax
fmt::v10::detail *v2; // rax
unsigned long long v3; // rdx
__int128 v4; // rax
fmt::v10::detail *v5; // rax
unsigned long long v6; // rdx
long long v7; // rdx
long long v8; // rax
long long v9; // rax
long long v10; // rax
unsigned long long v11; // rax
unsigned long long v12; // rax
long long v13; // rax
long long v15; // [rsp+10h] [rbp-B8h]
unsigned long long v16; // [rsp+30h] [rbp-98h]
int v17; // [rsp+38h] [rbp-90h]
bool v18; // [rsp+3Dh] [rbp-8Bh]
bool v19; // [rsp+3Eh] [rbp-8Ah]
__int128 v20; // [rsp+40h] [rbp-88h] BYREF
long long v21; // [rsp+50h] [rbp-78h]
long long v22; // [rsp+58h] [rbp-70h]
_QWORD v23[2]; // [rsp+60h] [rbp-68h] BYREF
__int128 v24; // [rsp+70h] [rbp-58h] BYREF
unsigned long long v25; // [rsp+80h] [rbp-48h]
bool v26; // [rsp+8Bh] [rbp-3Dh] BYREF
int v27; // [rsp+8Ch] [rbp-3Ch]
long long v28; // [rsp+90h] [rbp-38h] BYREF
long long v29; // [rsp+98h] [rbp-30h]
signed int v30; // [rsp+A4h] [rbp-24h]
unsigned int v31; // [rsp+A8h] [rbp-20h]
int v32; // [rsp+ACh] [rbp-1Ch]
bool v33; // [rsp+B3h] [rbp-15h]
int v34; // [rsp+B4h] [rbp-14h]
_QWORD v35[2]; // [rsp+B8h] [rbp-10h] BYREF
v34 = a1;
v19 = 0;
if ( a1 >= -292 )
v19 = v34 <= 341;
v33 = v19;
fmt::v10::detail::ignore_unused<bool,char [18]>();
v32 = (v34 + 292) / 27;
v31 = 27 * v32 - 292;
v30 = v34 - v31;
v1 = (long long *)((char *)&fmt::v10::detail::dragonbox::cache_accessor<double>::get_cached_power(int)::pow10_significands
+ 16 * v32);
v28 = *v1;
v29 = v1[1];
if ( v34 == v31 )
{
v35[0] = v28;
v35[1] = v29;
}
else
{
v17 = fmt::v10::detail::dragonbox::floor_log2_pow10((fmt::v10::detail::dragonbox *)(v30 + v31));
v27 = v17 - fmt::v10::detail::dragonbox::floor_log2_pow10((fmt::v10::detail::dragonbox *)v31) - v30;
v18 = 0;
if ( v27 > 0 )
v18 = v27 < 64;
v26 = v18;
fmt::v10::detail::ignore_unused<bool,char [24]>(&v26, "shifting error detected");
v25 = fmt::v10::detail::dragonbox::cache_accessor<double>::get_cached_power(int)::powers_of_5_64[v30];
v2 = (fmt::v10::detail *)fmt::v10::detail::uint128_fallback::high((fmt::v10::detail::uint128_fallback *)&v28);
*(_QWORD *)&v4 = fmt::v10::detail::umul128(v2, v25, v3);
v24 = v4;
v5 = (fmt::v10::detail *)fmt::v10::detail::uint128_fallback::low((fmt::v10::detail::uint128_fallback *)&v28);
v23[0] = fmt::v10::detail::umul128(v5, v25, v6);
v23[1] = v7;
v8 = fmt::v10::detail::uint128_fallback::high((fmt::v10::detail::uint128_fallback *)v23);
fmt::v10::detail::uint128_fallback::operator+=(&v24, v8);
v9 = fmt::v10::detail::uint128_fallback::high((fmt::v10::detail::uint128_fallback *)&v24);
v22 = v9 << -(char)v27;
v10 = fmt::v10::detail::uint128_fallback::low((fmt::v10::detail::uint128_fallback *)&v24);
v21 = v10 << -(char)v27;
v11 = fmt::v10::detail::uint128_fallback::low((fmt::v10::detail::uint128_fallback *)&v24);
v16 = v22 | (v11 >> v27);
v12 = fmt::v10::detail::uint128_fallback::low((fmt::v10::detail::uint128_fallback *)v23);
fmt::v10::detail::uint128_fallback::uint128_fallback(
(fmt::v10::detail::uint128_fallback *)&v20,
v16,
v21 | (v12 >> v27));
v24 = v20;
fmt::v10::detail::uint128_fallback::low((fmt::v10::detail::uint128_fallback *)&v24);
fmt::v10::detail::ignore_unused<bool,char [1]>();
v15 = fmt::v10::detail::uint128_fallback::high((fmt::v10::detail::uint128_fallback *)&v24);
v13 = fmt::v10::detail::uint128_fallback::low((fmt::v10::detail::uint128_fallback *)&v24);
fmt::v10::detail::uint128_fallback::uint128_fallback((fmt::v10::detail::uint128_fallback *)v35, v15, v13 + 1);
}
return v35[0];
}
| get_cached_power:
SUB RSP,0xc8
MOV dword ptr [RSP + 0xb4],EDI
XOR EAX,EAX
CMP dword ptr [RSP + 0xb4],0xfffffedc
MOV byte ptr [RSP + 0x3e],AL
JL 0x001afe13
CMP dword ptr [RSP + 0xb4],0x155
SETLE AL
MOV byte ptr [RSP + 0x3e],AL
LAB_001afe13:
MOV AL,byte ptr [RSP + 0x3e]
AND AL,0x1
MOV byte ptr [RSP + 0xb3],AL
LEA RDI,[RSP + 0xb3]
LEA RSI,[0x4dd893]
CALL 0x001ac0e0
MOV EAX,dword ptr [RSP + 0xb4]
SUB EAX,0xfffffedc
MOV ECX,0x1b
CDQ
IDIV ECX
MOV dword ptr [RSP + 0xac],EAX
IMUL EAX,dword ptr [RSP + 0xac],0x1b
ADD EAX,0xfffffedc
MOV dword ptr [RSP + 0xa8],EAX
MOV EAX,dword ptr [RSP + 0xb4]
SUB EAX,dword ptr [RSP + 0xa8]
MOV dword ptr [RSP + 0xa4],EAX
MOVSXD RCX,dword ptr [RSP + 0xac]
LEA RAX,[0x4de6b0]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0x90],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x98],RAX
CMP dword ptr [RSP + 0xa4],0x0
JNZ 0x001afed4
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0xc0],RAX
JMP 0x001b00ca
LAB_001afed4:
MOV EDI,dword ptr [RSP + 0xa8]
ADD EDI,dword ptr [RSP + 0xa4]
CALL 0x001abcd0
MOV dword ptr [RSP + 0x38],EAX
MOV EDI,dword ptr [RSP + 0xa8]
CALL 0x001abcd0
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x38]
SUB EAX,ECX
SUB EAX,dword ptr [RSP + 0xa4]
MOV dword ptr [RSP + 0x8c],EAX
XOR EAX,EAX
CMP dword ptr [RSP + 0x8c],0x0
MOV byte ptr [RSP + 0x3d],AL
JLE 0x001aff2c
CMP dword ptr [RSP + 0x8c],0x40
SETL AL
MOV byte ptr [RSP + 0x3d],AL
LAB_001aff2c:
MOV AL,byte ptr [RSP + 0x3d]
AND AL,0x1
MOV byte ptr [RSP + 0x8b],AL
LAB_001aff39:
LEA RSI,[0x4dd8e7]
LEA RDI,[RSP + 0x8b]
CALL 0x001b04e0
JMP 0x001aff4f
LAB_001aff4f:
MOVSXD RCX,dword ptr [RSP + 0xa4]
LEA RAX,[0x4de830]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x80],RAX
LEA RDI,[RSP + 0x90]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x001b04d0
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x80]
CALL 0x001b04f0
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x70],RAX
MOV qword ptr [RSP + 0x78],RDX
CALL 0x001b0540
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x80]
CALL 0x001b04f0
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x68],RDX
LEA RDI,[RSP + 0x60]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x001b04d0
MOV RSI,RAX
LEA RDI,[RSP + 0x70]
MOV qword ptr [RSP + 0x20],RDI
CALL 0x001b0550
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x001b04d0
MOV RDI,qword ptr [RSP + 0x20]
MOV CL,byte ptr [RSP + 0x8c]
NEG CL
SHL RAX,CL
MOV qword ptr [RSP + 0x58],RAX
CALL 0x001b0540
MOV RDI,qword ptr [RSP + 0x20]
MOV CL,byte ptr [RSP + 0x8c]
NEG CL
SHL RAX,CL
MOV qword ptr [RSP + 0x50],RAX
CALL 0x001b0540
MOV RDI,qword ptr [RSP + 0x28]
MOV CL,byte ptr [RSP + 0x8c]
SHR RAX,CL
MOV RCX,qword ptr [RSP + 0x58]
OR RAX,RCX
MOV qword ptr [RSP + 0x30],RAX
CALL 0x001b0540
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,RAX
MOV CL,byte ptr [RSP + 0x8c]
SHR RDX,CL
MOV RAX,qword ptr [RSP + 0x50]
OR RDX,RAX
LEA RDI,[RSP + 0x40]
CALL 0x001b05a0
JMP 0x001b0062
LAB_001b0062:
MOVUPS XMM0,xmmword ptr [RSP + 0x40]
MOVAPS xmmword ptr [RSP + 0x70],XMM0
LEA RDI,[RSP + 0x70]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x001b0540
SUB RAX,-0x1
SETNZ byte ptr [RSP + 0x3f]
LEA RSI,[0x4e1fa9]
LEA RDI,[RSP + 0x3f]
CALL 0x001ac150
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001b04d0
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001b0540
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,RAX
INC RDX
LEA RDI,[RSP + 0xb8]
CALL 0x001b05a0
JMP 0x001b00c8
LAB_001b00c8:
JMP 0x001b00ca
LAB_001b00ca:
MOV RAX,qword ptr [RSP + 0xb8]
MOV RDX,qword ptr [RSP + 0xc0]
ADD RSP,0xc8
RET
|
/* fmt::v10::detail::dragonbox::cache_accessor<double>::get_cached_power(int) */
int1 [16] fmt::v10::detail::dragonbox::cache_accessor<double>::get_cached_power(int param_1)
{
int1 auVar1 [16];
int8 uVar2;
int8 uVar3;
int iVar4;
int iVar5;
ulong uVar6;
long lVar7;
ulong uVar8;
bool local_8b;
bool local_8a;
bool local_89;
int8 local_88;
int8 uStack_80;
ulong local_78;
ulong local_70;
uint128_fallback local_68 [16];
int1 local_58 [16];
ulong local_48;
bool local_3d;
int local_3c;
int8 local_38;
int8 local_30;
int local_24;
int local_20;
int local_1c;
bool local_15;
int local_14;
int8 local_10;
int8 local_8;
local_8a = -0x125 < param_1 && param_1 < 0x156;
local_15 = local_8a;
local_14 = param_1;
ignore_unused<bool,char[18]>(&local_15,"k is out of range");
local_1c = (local_14 + 0x124) / 0x1b;
local_20 = local_1c * 0x1b + -0x124;
local_24 = local_14 - local_20;
local_38 = *(int8 *)(get_cached_power(int)::pow10_significands + (long)local_1c * 0x10);
local_30 = *(int8 *)(get_cached_power(int)::pow10_significands + (long)local_1c * 0x10 + 8);
uVar2 = local_38;
uVar3 = local_30;
if (local_24 != 0) {
iVar4 = floor_log2_pow10(local_20 + local_24);
iVar5 = floor_log2_pow10(local_20);
local_3c = (iVar4 - iVar5) - local_24;
local_8b = 0 < local_3c && local_3c < 0x40;
local_3d = local_8b;
/* try { // try from 001aff39 to 001b00c5 has its CatchHandler @ 001b00e2 */
ignore_unused<bool,char[24]>(&local_3d,"shifting error detected");
local_48 = *(ulong *)(get_cached_power(int)::powers_of_5_64 + (long)local_24 * 8);
uVar6 = uint128_fallback::high((uint128_fallback *)&local_38);
local_58 = umul128(uVar6,local_48);
uVar6 = uint128_fallback::low((uint128_fallback *)&local_38);
local_68 = (uint128_fallback [16])umul128(uVar6,local_48);
uVar6 = uint128_fallback::high(local_68);
uint128_fallback::operator+=((uint128_fallback *)local_58,uVar6);
lVar7 = uint128_fallback::high((uint128_fallback *)local_58);
local_70 = lVar7 << (-(byte)local_3c & 0x3f);
lVar7 = uint128_fallback::low((uint128_fallback *)local_58);
local_78 = lVar7 << (-(byte)local_3c & 0x3f);
uVar6 = uint128_fallback::low((uint128_fallback *)local_58);
uVar6 = uVar6 >> ((byte)local_3c & 0x3f) | local_70;
uVar8 = uint128_fallback::low(local_68);
uint128_fallback::uint128_fallback
((uint128_fallback *)&local_88,uVar6,uVar8 >> ((byte)local_3c & 0x3f) | local_78);
local_58._0_8_ = local_88;
local_58._8_8_ = uStack_80;
lVar7 = uint128_fallback::low((uint128_fallback *)local_58);
local_89 = lVar7 != -1;
ignore_unused<bool,char[1]>(&local_89,"");
uVar6 = uint128_fallback::high((uint128_fallback *)local_58);
lVar7 = uint128_fallback::low((uint128_fallback *)local_58);
uint128_fallback::uint128_fallback((uint128_fallback *)&local_10,uVar6,lVar7 + 1);
uVar2 = local_10;
uVar3 = local_8;
}
local_8 = uVar3;
local_10 = uVar2;
auVar1._8_8_ = local_8;
auVar1._0_8_ = local_10;
return auVar1;
}
|
|
3,268 | my_hash_first | eloqsql/mysys/hash.c | uchar* my_hash_first(const HASH *hash, const uchar *key, size_t length,
HASH_SEARCH_STATE *current_record)
{
uchar *res;
DBUG_ASSERT(my_hash_inited(hash));
res= my_hash_first_from_hash_value(hash,
hash->hash_function(hash->charset, key,
length ? length :
hash->key_length),
key, length, current_record);
return res;
} | O3 | c | my_hash_first:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x58(%rdi), %rax
movq 0x68(%rdi), %rdi
movq %rdx, %r12
testq %rdx, %rdx
jne 0x7a148
movq 0x8(%r15), %rdx
xorl %r12d, %r12d
movq %r14, %rsi
callq *%rax
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
movq %r12, %rcx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a17f
| my_hash_first:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rcx
mov r14, rsi
mov r15, rdi
mov rax, [rdi+58h]
mov rdi, [rdi+68h]
mov r12, rdx
test rdx, rdx
jnz short loc_7A148
mov rdx, [r15+8]
xor r12d, r12d
loc_7A148:
mov rsi, r14
call rax
mov rdi, r15
mov esi, eax
mov rdx, r14
mov rcx, r12
mov r8, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp my_hash_first_from_hash_value
| long long my_hash_first(_QWORD *a1, long long a2, long long a3, long long a4)
{
long long ( *v6)(long long, long long, long long); // rax
long long v7; // rdi
long long v8; // r12
unsigned int v9; // eax
v6 = (long long ( *)(long long, long long, long long))a1[11];
v7 = a1[13];
v8 = a3;
if ( !a3 )
{
a3 = a1[1];
v8 = 0LL;
}
v9 = v6(v7, a2, a3);
return my_hash_first_from_hash_value(a1, v9, a2, v8, a4);
}
| my_hash_first:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RCX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr [RDI + 0x58]
MOV RDI,qword ptr [RDI + 0x68]
MOV R12,RDX
TEST RDX,RDX
JNZ 0x0017a148
MOV RDX,qword ptr [R15 + 0x8]
XOR R12D,R12D
LAB_0017a148:
MOV RSI,R14
CALL RAX
MOV RDI,R15
MOV ESI,EAX
MOV RDX,R14
MOV RCX,R12
MOV R8,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x0017a17f
|
void my_hash_first(long param_1,int8 param_2,long param_3,int8 param_4)
{
int4 uVar1;
long lVar2;
lVar2 = param_3;
if (param_3 == 0) {
param_3 = *(long *)(param_1 + 8);
lVar2 = 0;
}
uVar1 = (**(code **)(param_1 + 0x58))(*(int8 *)(param_1 + 0x68),param_2,param_3);
my_hash_first_from_hash_value(param_1,uVar1,param_2,lVar2,param_4);
return;
}
|
|
3,269 | exit_status | eloqsql/unittest/mytap/tap.c | int exit_status()
{
char buff[60];
/*
If there were no plan, we write one last instead.
*/
if (g_test.plan == NO_PLAN)
plan(g_test.last);
if (g_test.plan != g_test.last)
{
diag("%d tests planned but%s %d executed",
g_test.plan, (g_test.plan > g_test.last ? " only" : ""), g_test.last);
return EXIT_FAILURE;
}
if (g_test.failed > 0)
{
diag("Failed %d tests!", g_test.failed);
return EXIT_FAILURE;
}
if (start_time)
{
end_timer(start_time, buff);
printf("Test took %s\n", buff);
fflush(stdout);
}
return EXIT_SUCCESS;
} | O0 | c | exit_status:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
cmpl $0x0, 0xba02b4(%rip) # 0xc7a610
jne 0xda369
movl 0xba02b0(%rip), %edi # 0xc7a614
callq 0xd9cb0
movl 0xba02a1(%rip), %eax # 0xc7a610
cmpl 0xba029f(%rip), %eax # 0xc7a614
je 0xda3ba
movl 0xba0293(%rip), %esi # 0xc7a610
movl 0xba028d(%rip), %ecx # 0xc7a610
movl 0xba028b(%rip), %edi # 0xc7a614
leaq 0x7d914(%rip), %rdx # 0x157ca4
leaq 0x7e06f(%rip), %rax # 0x158406
cmpl %edi, %ecx
cmovgq %rax, %rdx
movl 0xba0271(%rip), %ecx # 0xc7a614
leaq 0x79a2e(%rip), %rdi # 0x153dd8
movb $0x0, %al
callq 0xd9be0
movl $0x1, -0x54(%rbp)
jmp 0xda422
cmpl $0x0, 0xba0257(%rip) # 0xc7a618
jle 0xda3e0
movl 0xba024f(%rip), %esi # 0xc7a618
leaq 0x79a2b(%rip), %rdi # 0x153dfb
movb $0x0, %al
callq 0xd9be0
movl $0x1, -0x54(%rbp)
jmp 0xda422
cmpq $0x0, 0xba02b8(%rip) # 0xc7a6a0
je 0xda41b
movq 0xba02af(%rip), %rdi # 0xc7a6a0
leaq -0x50(%rbp), %rsi
callq 0xda450
leaq -0x50(%rbp), %rsi
leaq 0x79a07(%rip), %rdi # 0x153e0c
movb $0x0, %al
callq 0x2a050
movq 0x1e2bbd(%rip), %rax # 0x2bcfd0
movq (%rax), %rdi
callq 0x2a3e0
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x58(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xda443
movl -0x58(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
callq 0x2a270
nopl (%rax,%rax)
| exit_status:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, fs:28h
mov [rbp+var_8], rax
cmp cs:g_test, 0
jnz short loc_DA369
mov edi, cs:dword_C7A614
call plan
loc_DA369:
mov eax, cs:g_test
cmp eax, cs:dword_C7A614
jz short loc_DA3BA
mov esi, cs:g_test
mov ecx, cs:g_test
mov edi, cs:dword_C7A614
lea rdx, asc_157CA0+4; ""
lea rax, aTableIsReadOnl+0Dh; " only"
cmp ecx, edi
cmovg rdx, rax
mov ecx, cs:dword_C7A614
lea rdi, aDTestsPlannedB; "%d tests planned but%s %d executed"
mov al, 0
call diag
mov [rbp+var_54], 1
jmp short loc_DA422
loc_DA3BA:
cmp cs:dword_C7A618, 0
jle short loc_DA3E0
mov esi, cs:dword_C7A618
lea rdi, aFailedDTests; "Failed %d tests!"
mov al, 0
call diag
mov [rbp+var_54], 1
jmp short loc_DA422
loc_DA3E0:
cmp cs:start_time, 0
jz short loc_DA41B
mov rdi, cs:start_time
lea rsi, [rbp+var_50]
call end_timer
lea rsi, [rbp+var_50]
lea rdi, aTestTookS; "Test took %s\n"
mov al, 0
call _printf
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
loc_DA41B:
mov [rbp+var_54], 0
loc_DA422:
mov eax, [rbp+var_54]
mov [rbp+var_58], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_DA443
mov eax, [rbp+var_58]
add rsp, 60h
pop rbp
retn
loc_DA443:
call ___stack_chk_fail
| long long exit_status(
__m128 a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
long long a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
char *v14; // rdx
char v16; // [rsp+0h] [rbp-60h]
char v18[72]; // [rsp+10h] [rbp-50h] BYREF
unsigned long long v19; // [rsp+58h] [rbp-8h]
v19 = __readfsqword(0x28u);
if ( !g_test )
plan(dword_C7A614);
if ( g_test == dword_C7A614 )
{
if ( dword_C7A618 <= 0 )
{
if ( start_time )
{
end_timer(start_time, v18);
printf("Test took %s\n", v18);
fflush(stdout);
}
return 0;
}
else
{
diag(
(long long)"Failed %d tests!",
(unsigned int)dword_C7A618,
a11,
a12,
a13,
a14,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
v16);
return 1;
}
}
else
{
v14 = "";
if ( g_test > dword_C7A614 )
v14 = " only";
diag(
(long long)"%d tests planned but%s %d executed",
(unsigned int)g_test,
(long long)v14,
(unsigned int)dword_C7A614,
a13,
a14,
a1,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
v16);
return 1;
}
}
| exit_status:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
CMP dword ptr [0x00d7a610],0x0
JNZ 0x001da369
MOV EDI,dword ptr [0x00d7a614]
CALL 0x001d9cb0
LAB_001da369:
MOV EAX,dword ptr [0x00d7a610]
CMP EAX,dword ptr [0x00d7a614]
JZ 0x001da3ba
MOV ESI,dword ptr [0x00d7a610]
MOV ECX,dword ptr [0x00d7a610]
MOV EDI,dword ptr [0x00d7a614]
LEA RDX,[0x257ca4]
LEA RAX,[0x258406]
CMP ECX,EDI
CMOVG RDX,RAX
MOV ECX,dword ptr [0x00d7a614]
LEA RDI,[0x253dd8]
MOV AL,0x0
CALL 0x001d9be0
MOV dword ptr [RBP + -0x54],0x1
JMP 0x001da422
LAB_001da3ba:
CMP dword ptr [0x00d7a618],0x0
JLE 0x001da3e0
MOV ESI,dword ptr [0x00d7a618]
LEA RDI,[0x253dfb]
MOV AL,0x0
CALL 0x001d9be0
MOV dword ptr [RBP + -0x54],0x1
JMP 0x001da422
LAB_001da3e0:
CMP qword ptr [0x00d7a6a0],0x0
JZ 0x001da41b
MOV RDI,qword ptr [0x00d7a6a0]
LEA RSI,[RBP + -0x50]
CALL 0x001da450
LEA RSI,[RBP + -0x50]
LEA RDI,[0x253e0c]
MOV AL,0x0
CALL 0x0012a050
MOV RAX,qword ptr [0x003bcfd0]
MOV RDI,qword ptr [RAX]
CALL 0x0012a3e0
LAB_001da41b:
MOV dword ptr [RBP + -0x54],0x0
LAB_001da422:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x58],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001da443
MOV EAX,dword ptr [RBP + -0x58]
ADD RSP,0x60
POP RBP
RET
LAB_001da443:
CALL 0x0012a270
|
int4 exit_status(void)
{
char *pcVar1;
long in_FS_OFFSET;
int4 local_5c;
int1 local_58 [72];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (g_test == 0) {
plan(DAT_00d7a614);
}
if (g_test == DAT_00d7a614) {
if (DAT_00d7a618 < 1) {
if (start_time != 0) {
end_timer(start_time,local_58);
printf("Test took %s\n",local_58);
fflush(*(FILE **)PTR_stdout_003bcfd0);
}
local_5c = 0;
}
else {
diag("Failed %d tests!",DAT_00d7a618);
local_5c = 1;
}
}
else {
pcVar1 = "";
if (DAT_00d7a614 < g_test) {
pcVar1 = " only";
}
diag("%d tests planned but%s %d executed",g_test,pcVar1,DAT_00d7a614);
local_5c = 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_5c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
3,270 | httplib::detail::gzip_compressor::~gzip_compressor() | nickolajgrishuk[P]metricz-cpp/build_O1/_deps/httplib-src/httplib.h | inline bool gzip_compressor::compress(const char *data, size_t data_length,
bool last, Callback callback) {
assert(is_valid_);
do {
constexpr size_t max_avail_in =
(std::numeric_limits<decltype(strm_.avail_in)>::max)();
strm_.avail_in = static_cast<decltype(strm_.avail_in)>(
(std::min)(data_length, max_avail_in));
strm_.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(data));
data_length -= strm_.avail_in;
data += strm_.avail_in;
auto flush = (last && data_length == 0) ? Z_FINISH : Z_NO_FLUSH;
int ret = Z_OK;
std::array<char, CPPHTTPLIB_COMPRESSION_BUFSIZ> buff{};
do {
strm_.avail_out = static_cast<uInt>(buff.size());
strm_.next_out = reinterpret_cast<Bytef *>(buff.data());
ret = deflate(&strm_, flush);
if (ret == Z_STREAM_ERROR) { return false; }
if (!callback(buff.data(), buff.size() - strm_.avail_out)) {
return false;
}
} while (strm_.avail_out == 0);
assert((flush == Z_FINISH && ret == Z_STREAM_END) ||
(flush == Z_NO_FLUSH && ret == Z_OK));
assert(strm_.avail_in == 0);
} while (data_length > 0);
return true;
} | O1 | c | httplib::detail::gzip_compressor::~gzip_compressor():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4038, %rsp # imm = 0x4038
movl %ecx, 0x4(%rsp)
cmpb $0x1, 0x8(%rdi)
jne 0xa13a
movq %r8, %rbx
movq %rdi, %r15
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rbp
movq %rsi, %rax
movq %rdx, %rcx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbq %rdx, %rsi
movl %esi, 0x18(%r15)
movq %rax, 0x10(%r15)
subq %rsi, %rdx
movq %rdx, 0x18(%rsp)
addq %rax, %rsi
movq %rsi, 0x10(%rsp)
shrq $0x20, %rcx
sete %al
andb 0x4(%rsp), %al
movzbl %al, %eax
movq %rax, 0x8(%rsp)
leal (,%rax,4), %r14d
movl $0x4000, %edx # imm = 0x4000
movq %rbp, %rdi
xorl %esi, %esi
callq 0x82e0
movl $0x4000, 0x30(%r15) # imm = 0x4000
movq %rbp, 0x28(%r15)
movq 0x20(%rsp), %rdi
movl %r14d, %esi
callq 0x8260
movb $0x1, %r12b
cmpl $-0x2, %eax
je 0xa0c6
movl %eax, %r13d
movl 0x30(%r15), %eax
movl $0x4000, %ecx # imm = 0x4000
subq %rax, %rcx
movq %rbp, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
cmpq $0x0, 0x10(%rbx)
je 0xa0f7
movq %rbx, %rdi
leaq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq *0x18(%rbx)
testb %al, %al
je 0xa0c6
cmpl $0x0, 0x30(%r15)
je 0xa059
cmpl 0x8(%rsp), %r13d
jne 0xa0fc
cmpl $0x0, 0x18(%r15)
jne 0xa11b
xorl %r12d, %r12d
testb %r12b, %r12b
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
jne 0xa0de
testq %rdx, %rdx
jne 0xa005
xorb $0x1, %r12b
movl %r12d, %eax
addq $0x4038, %rsp # imm = 0x4038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x81f0
leaq 0x23ded(%rip), %rdi # 0x2def0
leaq 0x23352(%rip), %rsi # 0x2d45c
leaq 0x23d81(%rip), %rcx # 0x2de92
movl $0xc70, %edx # imm = 0xC70
callq 0x8380
leaq 0x23e21(%rip), %rdi # 0x2df43
leaq 0x23333(%rip), %rsi # 0x2d45c
leaq 0x23d62(%rip), %rcx # 0x2de92
movl $0xc71, %edx # imm = 0xC71
callq 0x8380
leaq 0x23d47(%rip), %rdi # 0x2de88
leaq 0x23314(%rip), %rsi # 0x2d45c
leaq 0x23d43(%rip), %rcx # 0x2de92
movl $0xc52, %edx # imm = 0xC52
callq 0x8380
nop
| _ZN7httplib6detail15gzip_compressor8compressEPKcmbSt8functionIFbS3_mEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 4038h
mov [rsp+4068h+var_4064], ecx
cmp byte ptr [rdi+8], 1
jnz loc_A13A
mov rbx, r8
mov r15, rdi
lea rax, [rdi+10h]
mov [rsp+4068h+var_4048], rax
lea rbp, [rsp+4068h+var_4030]
loc_A005:
mov rax, rsi
mov rcx, rdx
mov esi, 0FFFFFFFFh
cmp rdx, rsi
cmovb rsi, rdx
mov [r15+18h], esi
mov [r15+10h], rax
sub rdx, rsi
mov [rsp+4068h+var_4050], rdx
add rsi, rax
mov [rsp+4068h+var_4058], rsi
shr rcx, 20h
setz al
and al, byte ptr [rsp+4068h+var_4064]
movzx eax, al
mov [rsp+4068h+var_4060], rax
lea r14d, ds:0[rax*4]
mov edx, 4000h
mov rdi, rbp
xor esi, esi
call _memset
loc_A059:
mov dword ptr [r15+30h], 4000h
mov [r15+28h], rbp
mov rdi, [rsp+4068h+var_4048]
mov esi, r14d
call _deflate
mov r12b, 1
cmp eax, 0FFFFFFFEh
jz short loc_A0C6
mov r13d, eax
mov eax, [r15+30h]
mov ecx, 4000h
sub rcx, rax
mov [rsp+4068h+var_4038], rbp
mov [rsp+4068h+var_4040], rcx
cmp qword ptr [rbx+10h], 0
jz short loc_A0F7
mov rdi, rbx
lea rsi, [rsp+4068h+var_4038]
lea rdx, [rsp+4068h+var_4040]
call qword ptr [rbx+18h]
test al, al
jz short loc_A0C6
cmp dword ptr [r15+30h], 0
jz short loc_A059
cmp r13d, dword ptr [rsp+4068h+var_4060]
jnz short loc_A0FC
cmp dword ptr [r15+18h], 0
jnz short loc_A11B
xor r12d, r12d
loc_A0C6:
test r12b, r12b
mov rdx, [rsp+4068h+var_4050]
mov rsi, [rsp+4068h+var_4058]
jnz short loc_A0DE
test rdx, rdx
jnz loc_A005
loc_A0DE:
xor r12b, 1
mov eax, r12d
add rsp, 4038h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A0F7:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_A0FC:
lea rdi, aFlushZFinishRe; "(flush == Z_FINISH && ret == Z_STREAM_E"...
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVirtualBoolHtt; "virtual bool httplib::detail::gzip_comp"...
mov edx, 0C70h
call ___assert_fail
loc_A11B:
lea rdi, aStrmAvailIn0; "strm_.avail_in == 0"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVirtualBoolHtt; "virtual bool httplib::detail::gzip_comp"...
mov edx, 0C71h
call ___assert_fail
loc_A13A:
lea rdi, aIsValid; "is_valid_"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVirtualBoolHtt; "virtual bool httplib::detail::gzip_comp"...
mov edx, 0C52h
call ___assert_fail
| long long httplib::detail::gzip_compressor::compress(
long long a1,
long long a2,
unsigned long long a3,
unsigned __int8 a4,
long long a5)
{
unsigned int v5; // r12d
long long v7; // rax
long long v8; // rsi
int v9; // eax
int v10; // r13d
long long v11; // rcx
int v14; // [rsp+8h] [rbp-4060h]
long long v15; // [rsp+10h] [rbp-4058h]
unsigned long long v16; // [rsp+18h] [rbp-4050h]
long long v17; // [rsp+28h] [rbp-4040h] BYREF
_BYTE *v18; // [rsp+30h] [rbp-4038h] BYREF
_BYTE v19[16432]; // [rsp+38h] [rbp-4030h] BYREF
if ( *(_BYTE *)(a1 + 8) != 1 )
__assert_fail(
"is_valid_",
"/workspace/llm4binary/github/2025_star3/nickolajgrishuk[P]metricz-cpp/build_O1/_deps/httplib-src/httplib.h",
3154LL,
"virtual bool httplib::detail::gzip_compressor::compress(const char *, size_t, bool, Callback)");
do
{
v7 = a2;
v8 = 0xFFFFFFFFLL;
if ( a3 < 0xFFFFFFFF )
v8 = a3;
*(_DWORD *)(a1 + 24) = v8;
*(_QWORD *)(a1 + 16) = v7;
v16 = a3 - v8;
v15 = v7 + v8;
v14 = a4 & (HIDWORD(a3) == 0);
memset(v19, 0LL, 0x4000LL);
while ( 1 )
{
*(_DWORD *)(a1 + 48) = 0x4000;
*(_QWORD *)(a1 + 40) = v19;
v9 = deflate(a1 + 16, (unsigned int)(4 * v14));
LOBYTE(v5) = 1;
if ( v9 == -2 )
break;
v10 = v9;
v11 = 0x4000LL - *(unsigned int *)(a1 + 48);
v18 = v19;
v17 = v11;
if ( !*(_QWORD *)(a5 + 16) )
std::__throw_bad_function_call();
if ( !(*(unsigned __int8 ( **)(long long, _BYTE **, long long *))(a5 + 24))(a5, &v18, &v17) )
break;
if ( *(_DWORD *)(a1 + 48) )
{
if ( v10 != v14 )
__assert_fail(
"(flush == Z_FINISH && ret == Z_STREAM_END) || (flush == Z_NO_FLUSH && ret == Z_OK)",
"/workspace/llm4binary/github/2025_star3/nickolajgrishuk[P]metricz-cpp/build_O1/_deps/httplib-src/httplib.h",
3184LL,
"virtual bool httplib::detail::gzip_compressor::compress(const char *, size_t, bool, Callback)");
if ( *(_DWORD *)(a1 + 24) )
__assert_fail(
"strm_.avail_in == 0",
"/workspace/llm4binary/github/2025_star3/nickolajgrishuk[P]metricz-cpp/build_O1/_deps/httplib-src/httplib.h",
3185LL,
"virtual bool httplib::detail::gzip_compressor::compress(const char *, size_t, bool, Callback)");
v5 = 0;
break;
}
}
a3 = v16;
a2 = v15;
}
while ( !(_BYTE)v5 && v16 );
LOBYTE(v5) = v5 ^ 1;
return v5;
}
| compress:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x4038
MOV dword ptr [RSP + 0x4],ECX
CMP byte ptr [RDI + 0x8],0x1
JNZ 0x0010a13a
MOV RBX,R8
MOV R15,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP + 0x20],RAX
LEA RBP,[RSP + 0x38]
LAB_0010a005:
MOV RAX,RSI
MOV RCX,RDX
MOV ESI,0xffffffff
CMP RDX,RSI
CMOVC RSI,RDX
MOV dword ptr [R15 + 0x18],ESI
MOV qword ptr [R15 + 0x10],RAX
SUB RDX,RSI
MOV qword ptr [RSP + 0x18],RDX
ADD RSI,RAX
MOV qword ptr [RSP + 0x10],RSI
SHR RCX,0x20
SETZ AL
AND AL,byte ptr [RSP + 0x4]
MOVZX EAX,AL
MOV qword ptr [RSP + 0x8],RAX
LEA R14D,[RAX*0x4]
MOV EDX,0x4000
MOV RDI,RBP
XOR ESI,ESI
CALL 0x001082e0
LAB_0010a059:
MOV dword ptr [R15 + 0x30],0x4000
MOV qword ptr [R15 + 0x28],RBP
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,R14D
CALL 0x00108260
MOV R12B,0x1
CMP EAX,-0x2
JZ 0x0010a0c6
MOV R13D,EAX
MOV EAX,dword ptr [R15 + 0x30]
MOV ECX,0x4000
SUB RCX,RAX
MOV qword ptr [RSP + 0x30],RBP
MOV qword ptr [RSP + 0x28],RCX
CMP qword ptr [RBX + 0x10],0x0
JZ 0x0010a0f7
MOV RDI,RBX
LEA RSI,[RSP + 0x30]
LEA RDX,[RSP + 0x28]
CALL qword ptr [RBX + 0x18]
TEST AL,AL
JZ 0x0010a0c6
CMP dword ptr [R15 + 0x30],0x0
JZ 0x0010a059
CMP R13D,dword ptr [RSP + 0x8]
JNZ 0x0010a0fc
CMP dword ptr [R15 + 0x18],0x0
JNZ 0x0010a11b
XOR R12D,R12D
LAB_0010a0c6:
TEST R12B,R12B
MOV RDX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
JNZ 0x0010a0de
TEST RDX,RDX
JNZ 0x0010a005
LAB_0010a0de:
XOR R12B,0x1
MOV EAX,R12D
ADD RSP,0x4038
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010a0f7:
CALL 0x001081f0
LAB_0010a0fc:
LEA RDI,[0x12def0]
LEA RSI,[0x12d45c]
LEA RCX,[0x12de92]
MOV EDX,0xc70
CALL 0x00108380
LAB_0010a11b:
LEA RDI,[0x12df43]
LEA RSI,[0x12d45c]
LEA RCX,[0x12de92]
MOV EDX,0xc71
CALL 0x00108380
LAB_0010a13a:
LEA RDI,[0x12de88]
LEA RSI,[0x12d45c]
LEA RCX,[0x12de92]
MOV EDX,0xc52
CALL 0x00108380
|
/* httplib::detail::gzip_compressor::compress(char const*, unsigned long, bool, std::function<bool
(char const*, unsigned long)>) */
ulong __thiscall
httplib::detail::gzip_compressor::compress
(gzip_compressor *this,long param_1,ulong param_2,byte param_3,long param_5)
{
byte bVar1;
char cVar2;
uint uVar3;
ulong uVar4;
ulong uVar5;
ulong unaff_R12;
uint local_4060;
long local_4040;
int1 *local_4038;
int1 local_4030 [16384];
if (this[8] != (gzip_compressor)0x1) {
/* WARNING: Subroutine does not return */
__assert_fail("is_valid_",
"/workspace/llm4binary/github/2025_star3/nickolajgrishuk[P]metricz-cpp/build_O1/_deps/httplib-src/httplib.h"
,0xc52,
"virtual bool httplib::detail::gzip_compressor::compress(const char *, size_t, bool, Callback)"
);
}
do {
uVar5 = 0xffffffff;
if (param_2 < 0xffffffff) {
uVar5 = param_2;
}
*(int *)(this + 0x18) = (int)uVar5;
*(long *)(this + 0x10) = param_1;
uVar4 = param_2 - uVar5;
param_1 = uVar5 + param_1;
bVar1 = param_2 >> 0x20 == 0 & param_3;
memset(local_4030,0,0x4000);
do {
*(int4 *)(this + 0x30) = 0x4000;
*(int1 **)(this + 0x28) = local_4030;
uVar3 = deflate(this + 0x10,bVar1 * '\x04');
unaff_R12 = CONCAT71((int7)(unaff_R12 >> 8),1);
if (uVar3 == 0xfffffffe) goto LAB_0010a0c6;
local_4040 = 0x4000 - (ulong)*(uint *)(this + 0x30);
local_4038 = local_4030;
if (*(long *)(param_5 + 0x10) == 0) {
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
cVar2 = (**(code **)(param_5 + 0x18))(param_5,&local_4038,&local_4040);
if (cVar2 == '\0') goto LAB_0010a0c6;
} while (*(int *)(this + 0x30) == 0);
local_4060 = (uint)bVar1;
if (uVar3 != local_4060) {
/* WARNING: Subroutine does not return */
__assert_fail("(flush == Z_FINISH && ret == Z_STREAM_END) || (flush == Z_NO_FLUSH && ret == Z_OK)"
,
"/workspace/llm4binary/github/2025_star3/nickolajgrishuk[P]metricz-cpp/build_O1/_deps/httplib-src/httplib.h"
,0xc70,
"virtual bool httplib::detail::gzip_compressor::compress(const char *, size_t, bool, Callback)"
);
}
if (*(int *)(this + 0x18) != 0) {
/* WARNING: Subroutine does not return */
__assert_fail("strm_.avail_in == 0",
"/workspace/llm4binary/github/2025_star3/nickolajgrishuk[P]metricz-cpp/build_O1/_deps/httplib-src/httplib.h"
,0xc71,
"virtual bool httplib::detail::gzip_compressor::compress(const char *, size_t, bool, Callback)"
);
}
unaff_R12 = 0;
LAB_0010a0c6:
if (((char)unaff_R12 != '\0') || (param_2 = uVar4, uVar4 == 0)) {
return (unaff_R12 ^ 1) & 0xffffffff;
}
} while( true );
}
|
|
3,271 | mi_enlarge_root | eloqsql/storage/myisam/mi_write.c | int _mi_enlarge_root(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
my_off_t *root)
{
uint t_length,nod_flag;
MI_KEY_PARAM s_temp;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("_mi_enlarge_root");
nod_flag= (*root != HA_OFFSET_ERROR) ? share->base.key_reflength : 0;
_mi_kpointer(info,info->buff+2,*root); /* if nod */
t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,(uchar*) 0,
(uchar*) 0, (uchar*) 0, key,&s_temp);
mi_putint(info->buff,t_length+2+nod_flag,nod_flag);
(*keyinfo->store_key)(keyinfo,info->buff+2+nod_flag,&s_temp);
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);
DBUG_RETURN(0);
} | O0 | c | mi_enlarge_root:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rax
cmpq $-0x1, (%rax)
je 0x50e12
movq -0x78(%rbp), %rax
movl 0x17c(%rax), %eax
movl %eax, -0x84(%rbp)
jmp 0x50e1c
xorl %eax, %eax
movl %eax, -0x84(%rbp)
jmp 0x50e1c
movl -0x84(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rsi
addq $0x2, %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
callq 0x49f30
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rdi
movl -0x30(%rbp), %esi
movq -0x20(%rbp), %r9
xorl %ecx, %ecx
movl %ecx, %r8d
leaq -0x70(%rbp), %r10
movq %r8, %rdx
movq %r8, %rcx
movq %r10, (%rsp)
callq *%rax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %edx
xorl %eax, %eax
movl $0x8000, %ecx # imm = 0x8000
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl -0x2c(%rbp), %ecx
addl $0x2, %ecx
addl -0x30(%rbp), %ecx
movzwl %cx, %ecx
addl %ecx, %eax
movw %ax, -0x7a(%rbp)
movzwl -0x7a(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movb %cl, 0x1(%rax)
movl -0x80(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x100(%rcx), %rsi
addq $0x2, %rsi
movl -0x30(%rbp), %ecx
addq %rcx, %rsi
leaq -0x70(%rbp), %rdx
callq *%rax
movq -0x10(%rbp), %rax
movb $0x1, 0x33c(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x33d(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x3, %edx
callq 0x46590
movq -0x28(%rbp), %rcx
movq %rax, (%rcx)
cmpq $-0x1, %rax
je 0x50f45
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x100(%rax), %r8
movl $0x3, %ecx
callq 0x46260
cmpl $0x0, %eax
je 0x50f50
jmp 0x50f47
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x50f59
jmp 0x50f52
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _mi_enlarge_root:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_78], rax
mov rax, [rbp+var_28]
cmp qword ptr [rax], 0FFFFFFFFFFFFFFFFh
jz short loc_50E12
mov rax, [rbp+var_78]
mov eax, [rax+17Ch]
mov [rbp+var_84], eax
jmp short loc_50E1C
loc_50E12:
xor eax, eax
mov [rbp+var_84], eax
jmp short $+2
loc_50E1C:
mov eax, [rbp+var_84]
mov [rbp+var_30], eax
mov rdi, [rbp+var_10]
mov rax, [rbp+var_10]
mov rsi, [rax+100h]
add rsi, 2
mov rax, [rbp+var_28]
mov rdx, [rax]
call _mi_kpointer
mov rax, [rbp+var_18]
mov rax, [rax+50h]
mov rdi, [rbp+var_18]
mov esi, [rbp+var_30]
mov r9, [rbp+var_20]
xor ecx, ecx
mov r8d, ecx
lea r10, [rbp+var_70]
mov rdx, r8
mov rcx, r8
mov [rsp+90h+var_90], r10
call rax
mov [rbp+var_2C], eax
mov edx, [rbp+var_30]
xor eax, eax
mov ecx, 8000h
cmp edx, 0
cmovnz eax, ecx
mov ecx, [rbp+var_2C]
add ecx, 2
add ecx, [rbp+var_30]
movzx ecx, cx
add eax, ecx
mov [rbp+var_7A], ax
movzx eax, [rbp+var_7A]
mov [rbp+var_80], eax
mov eax, [rbp+var_80]
mov cl, al
mov rax, [rbp+var_10]
mov rax, [rax+100h]
mov [rax+1], cl
mov eax, [rbp+var_80]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov rax, [rax+100h]
mov [rax], cl
mov rax, [rbp+var_18]
mov rax, [rax+58h]
mov rdi, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rsi, [rcx+100h]
add rsi, 2
mov ecx, [rbp+var_30]
add rsi, rcx
lea rdx, [rbp+var_70]
call rax
mov rax, [rbp+var_10]
mov byte ptr [rax+33Ch], 1
mov rax, [rbp+var_10]
mov byte ptr [rax+33Dh], 1
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, 3
call _mi_new
mov rcx, [rbp+var_28]
mov [rcx], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_50F45
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rax, [rbp+var_28]
mov rdx, [rax]
mov rax, [rbp+var_10]
mov r8, [rax+100h]
mov ecx, 3
call _mi_write_keypage
cmp eax, 0
jz short loc_50F50
loc_50F45:
jmp short $+2
loc_50F47:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_50F59
loc_50F50:
jmp short $+2
loc_50F52:
mov [rbp+var_4], 0
loc_50F59:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
| long long mi_enlarge_root(_QWORD *a1, long long a2, long long a3, unsigned long long *a4)
{
__int16 v4; // ax
long long v5; // rax
unsigned int v7; // [rsp+Ch] [rbp-84h]
__int16 v8; // [rsp+16h] [rbp-7Ah]
_BYTE v9[64]; // [rsp+20h] [rbp-70h] BYREF
unsigned int v10; // [rsp+60h] [rbp-30h]
int v11; // [rsp+64h] [rbp-2Ch]
unsigned long long *v12; // [rsp+68h] [rbp-28h]
long long v13; // [rsp+70h] [rbp-20h]
long long v14; // [rsp+78h] [rbp-18h]
_QWORD *v15; // [rsp+80h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
if ( *a4 == -1LL )
v7 = 0;
else
v7 = *(_DWORD *)(*a1 + 380LL);
v10 = v7;
mi_kpointer((long long)v15, (_BYTE *)(v15[32] + 2LL), *v12);
v11 = (*(long long ( **)(long long, _QWORD, _QWORD, _QWORD, _QWORD, long long, _BYTE *))(v14 + 80))(
v14,
v7,
0LL,
0LL,
0LL,
v13,
v9);
v4 = 0;
if ( v10 )
v4 = 0x8000;
v8 = v10 + v11 + 2 + v4;
*(_BYTE *)(v15[32] + 1LL) = v10 + v11 + 2 + v4;
*(_BYTE *)v15[32] = HIBYTE(v8);
(*(void ( **)(long long, long long, _BYTE *))(v14 + 88))(v14, v10 + v15[32] + 2LL, v9);
*((_BYTE *)v15 + 828) = 1;
*((_BYTE *)v15 + 829) = 1;
v5 = mi_new(v15, v14, 3);
*v12 = v5;
if ( v5 == -1 || (unsigned int)mi_write_keypage(v15, v14, *v12, 3, (unsigned __int16 *)v15[32]) )
return (unsigned int)-1;
else
return 0;
}
| _mi_enlarge_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
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 + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX],-0x1
JZ 0x00150e12
MOV RAX,qword ptr [RBP + -0x78]
MOV EAX,dword ptr [RAX + 0x17c]
MOV dword ptr [RBP + -0x84],EAX
JMP 0x00150e1c
LAB_00150e12:
XOR EAX,EAX
MOV dword ptr [RBP + -0x84],EAX
JMP 0x00150e1c
LAB_00150e1c:
MOV EAX,dword ptr [RBP + -0x84]
MOV dword ptr [RBP + -0x30],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x100]
ADD RSI,0x2
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX]
CALL 0x00149f30
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x50]
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x20]
XOR ECX,ECX
MOV R8D,ECX
LEA R10,[RBP + -0x70]
MOV RDX,R8
MOV RCX,R8
MOV qword ptr [RSP],R10
CALL RAX
MOV dword ptr [RBP + -0x2c],EAX
MOV EDX,dword ptr [RBP + -0x30]
XOR EAX,EAX
MOV ECX,0x8000
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV ECX,dword ptr [RBP + -0x2c]
ADD ECX,0x2
ADD ECX,dword ptr [RBP + -0x30]
MOVZX ECX,CX
ADD EAX,ECX
MOV word ptr [RBP + -0x7a],AX
MOVZX EAX,word ptr [RBP + -0x7a]
MOV dword ptr [RBP + -0x80],EAX
MOV EAX,dword ptr [RBP + -0x80]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x80]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x58]
MOV RDI,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX + 0x100]
ADD RSI,0x2
MOV ECX,dword ptr [RBP + -0x30]
ADD RSI,RCX
LEA RDX,[RBP + -0x70]
CALL RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33c],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33d],0x1
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x3
CALL 0x00146590
MOV RCX,qword ptr [RBP + -0x28]
MOV qword ptr [RCX],RAX
CMP RAX,-0x1
JZ 0x00150f45
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV R8,qword ptr [RAX + 0x100]
MOV ECX,0x3
CALL 0x00146260
CMP EAX,0x0
JZ 0x00150f50
LAB_00150f45:
JMP 0x00150f47
LAB_00150f47:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00150f59
LAB_00150f50:
JMP 0x00150f52
LAB_00150f52:
MOV dword ptr [RBP + -0x4],0x0
LAB_00150f59:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
int4 _mi_enlarge_root(long *param_1,long param_2,int8 param_3,long *param_4)
{
short sVar1;
int iVar2;
long lVar3;
uint local_8c;
int1 local_78 [64];
uint local_38;
int4 local_34;
long *local_30;
int8 local_28;
long local_20;
long *local_18;
if (*param_4 == -1) {
local_8c = 0;
}
else {
local_8c = *(uint *)(*param_1 + 0x17c);
}
local_38 = local_8c;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
_mi_kpointer(param_1,param_1[0x20] + 2,*param_4);
local_34 = (**(code **)(local_20 + 0x50))(local_20,local_38,0,0,0,local_28,local_78);
sVar1 = 0;
if (local_38 != 0) {
sVar1 = -0x8000;
}
sVar1 = sVar1 + (short)local_34 + 2 + (short)local_38;
*(char *)(local_18[0x20] + 1) = (char)sVar1;
*(char *)local_18[0x20] = (char)((ushort)sVar1 >> 8);
(**(code **)(local_20 + 0x58))(local_20,local_18[0x20] + 2 + (ulong)local_38,local_78);
*(int1 *)((long)local_18 + 0x33c) = 1;
*(int1 *)((long)local_18 + 0x33d) = 1;
lVar3 = _mi_new(local_18,local_20,3);
*local_30 = lVar3;
if ((lVar3 != -1) &&
(iVar2 = _mi_write_keypage(local_18,local_20,*local_30,3,local_18[0x20]), iVar2 == 0)) {
return 0;
}
return 0xffffffff;
}
|
|
3,272 | MNN::CreateIDSTQuan(flatbuffers::FlatBufferBuilder&, MNN::IDSTQuanT const*, std::__1::function<unsigned long (void*)> const*) | mnn-tts/MNN/schema/current/CaffeOp_generated.h | inline flatbuffers::Offset<IDSTQuan> CreateIDSTQuan(flatbuffers::FlatBufferBuilder &_fbb, const IDSTQuanT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const IDSTQuanT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _buffer = _o->buffer.size() ? _fbb.CreateVector(_o->buffer) : 0;
auto _alpha = _o->alpha.size() ? _fbb.CreateVector(_o->alpha) : 0;
auto _type = _o->type;
auto _useInt32 = _o->useInt32;
auto _quantScale = _o->quantScale;
auto _scaleIn = _o->scaleIn;
auto _scaleOut = _o->scaleOut;
auto _aMax = _o->aMax;
auto _aMin = _o->aMin;
auto _readType = _o->readType;
auto _has_scaleInt = _o->has_scaleInt;
auto _shapeInt32 = _o->shapeInt32;
auto _weightSize = _o->weightSize;
auto _index = _o->index.size() ? _fbb.CreateVector(_o->index) : 0;
return MNN::CreateIDSTQuan(
_fbb,
_buffer,
_alpha,
_type,
_useInt32,
_quantScale,
_scaleIn,
_scaleOut,
_aMax,
_aMin,
_readType,
_has_scaleInt,
_shapeInt32,
_weightSize,
_index);
} | O0 | c | MNN::CreateIDSTQuan(flatbuffers::FlatBufferBuilder&, MNN::IDSTQuanT const*, std::__1::function<unsigned long (void*)> const*):
pushq %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x98(%rsp), %rdi
callq 0x6690
cmpq $0x0, %rax
je 0x1617e
movq 0xa0(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0x147d0
movl %eax, 0x74(%rsp)
jmp 0x1618a
leaq 0x74(%rsp), %rdi
xorl %esi, %esi
callq 0x14820
movq 0x98(%rsp), %rdi
addq $0x18, %rdi
callq 0x14060
cmpq $0x0, %rax
je 0x161c0
movq 0xa0(%rsp), %rdi
movq 0x98(%rsp), %rsi
addq $0x18, %rsi
callq 0x14080
movl %eax, 0x70(%rsp)
jmp 0x161cc
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
callq 0x140d0
movq 0x98(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x6c(%rsp)
movq 0x98(%rsp), %rax
movb 0x34(%rax), %al
andb $0x1, %al
movb %al, 0x6b(%rsp)
movq 0x98(%rsp), %rax
movss 0x38(%rax), %xmm0
movss %xmm0, 0x64(%rsp)
movq 0x98(%rsp), %rax
movss 0x3c(%rax), %xmm0
movss %xmm0, 0x60(%rsp)
movq 0x98(%rsp), %rax
movss 0x40(%rax), %xmm0
movss %xmm0, 0x5c(%rsp)
movq 0x98(%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, 0x58(%rsp)
movq 0x98(%rsp), %rax
movl 0x48(%rax), %eax
movl %eax, 0x54(%rsp)
movq 0x98(%rsp), %rax
movl 0x4c(%rax), %eax
movl %eax, 0x50(%rsp)
movq 0x98(%rsp), %rax
movb 0x50(%rax), %al
andb $0x1, %al
movb %al, 0x4f(%rsp)
movq 0x98(%rsp), %rax
movb 0x51(%rax), %al
andb $0x1, %al
movb %al, 0x4e(%rsp)
movq 0x98(%rsp), %rax
movl 0x54(%rax), %eax
movl %eax, 0x48(%rsp)
movq 0x98(%rsp), %rdi
addq $0x58, %rdi
callq 0x16bf0
cmpq $0x0, %rax
je 0x162b9
movq 0xa0(%rsp), %rdi
movq 0x98(%rsp), %rsi
addq $0x58, %rsi
callq 0x16c10
movl %eax, 0x44(%rsp)
jmp 0x162c5
leaq 0x44(%rsp), %rdi
xorl %esi, %esi
callq 0x16c60
movq 0xa0(%rsp), %rdi
movl 0x74(%rsp), %eax
movl %eax, 0x40(%rsp)
movl 0x70(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x6c(%rsp), %ecx
movb 0x6b(%rsp), %r8b
movss 0x64(%rsp), %xmm0
movss 0x60(%rsp), %xmm1
movss 0x5c(%rsp), %xmm2
movl 0x58(%rsp), %r9d
movl 0x54(%rsp), %r14d
movl 0x50(%rsp), %ebp
movb 0x4f(%rsp), %bl
movb 0x4e(%rsp), %r11b
movl 0x48(%rsp), %r10d
movl 0x44(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x40(%rsp), %esi
movl 0x3c(%rsp), %edx
movl 0x38(%rsp), %eax
andb $0x1, %r8b
andb $0x1, %bl
andb $0x1, %r11b
movzbl %r8b, %r8d
movl %r14d, (%rsp)
movl %ebp, 0x8(%rsp)
movzbl %bl, %ebx
movl %ebx, 0x10(%rsp)
movzbl %r11b, %r11d
movl %r11d, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x16c80
movl %eax, 0xac(%rsp)
movl 0xac(%rsp), %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw (%rax,%rax)
| _ZN3MNN14CreateIDSTQuanERN11flatbuffers17FlatBufferBuilderEPKNS_9IDSTQuanTEPKNSt3__18functionIFmPvEEE:
push rbp
push r14
push rbx
sub rsp, 0B0h
mov [rsp+0C8h+var_28], rdi
mov [rsp+0C8h+var_30], rsi
mov [rsp+0C8h+var_38], rdx
mov rax, [rsp+0C8h+var_28]
mov [rsp+0C8h+var_50], rax
mov rax, [rsp+0C8h+var_30]
mov [rsp+0C8h+var_48], rax
mov rax, [rsp+0C8h+var_38]
mov [rsp+0C8h+var_40], rax
mov rdi, [rsp+0C8h+var_30]
call _ZNKSt3__16vectorIaNS_9allocatorIaEEE4sizeB8nn200100Ev; std::vector<signed char>::size(void)
cmp rax, 0
jz short loc_1617E
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_30]
call _ZN11flatbuffers17FlatBufferBuilder12CreateVectorIaEENS_6OffsetINS_6VectorIT_EEEERKNSt3__16vectorIS4_NS7_9allocatorIS4_EEEE; flatbuffers::FlatBufferBuilder::CreateVector<signed char>(std::vector<signed char> const&)
mov [rsp+0C8h+var_54], eax
jmp short loc_1618A
loc_1617E:
lea rdi, [rsp+0C8h+var_54]
xor esi, esi
call _ZN11flatbuffers6OffsetINS_6VectorIaEEEC2Ej; flatbuffers::Offset<flatbuffers::Vector<signed char>>::Offset(uint)
loc_1618A:
mov rdi, [rsp+0C8h+var_30]
add rdi, 18h
call _ZNKSt3__16vectorIfNS_9allocatorIfEEE4sizeB8nn200100Ev; std::vector<float>::size(void)
cmp rax, 0
jz short loc_161C0
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_30]
add rsi, 18h
call _ZN11flatbuffers17FlatBufferBuilder12CreateVectorIfEENS_6OffsetINS_6VectorIT_EEEERKNSt3__16vectorIS4_NS7_9allocatorIS4_EEEE; flatbuffers::FlatBufferBuilder::CreateVector<float>(std::vector<float> const&)
mov [rsp+0C8h+var_58], eax
jmp short loc_161CC
loc_161C0:
lea rdi, [rsp+0C8h+var_58]
xor esi, esi
call _ZN11flatbuffers6OffsetINS_6VectorIfEEEC2Ej; flatbuffers::Offset<flatbuffers::Vector<float>>::Offset(uint)
loc_161CC:
mov rax, [rsp+0C8h+var_30]
mov eax, [rax+30h]
mov [rsp+0C8h+var_5C], eax
mov rax, [rsp+0C8h+var_30]
mov al, [rax+34h]
and al, 1
mov [rsp+0C8h+var_5D], al
mov rax, [rsp+0C8h+var_30]
movss xmm0, dword ptr [rax+38h]
movss [rsp+0C8h+var_64], xmm0
mov rax, [rsp+0C8h+var_30]
movss xmm0, dword ptr [rax+3Ch]
movss [rsp+0C8h+var_68], xmm0
mov rax, [rsp+0C8h+var_30]
movss xmm0, dword ptr [rax+40h]
movss [rsp+0C8h+var_6C], xmm0
mov rax, [rsp+0C8h+var_30]
mov eax, [rax+44h]
mov [rsp+0C8h+var_70], eax
mov rax, [rsp+0C8h+var_30]
mov eax, [rax+48h]
mov [rsp+0C8h+var_74], eax
mov rax, [rsp+0C8h+var_30]
mov eax, [rax+4Ch]
mov [rsp+0C8h+var_78], eax
mov rax, [rsp+0C8h+var_30]
mov al, [rax+50h]
and al, 1
mov [rsp+0C8h+var_79], al
mov rax, [rsp+0C8h+var_30]
mov al, [rax+51h]
and al, 1
mov [rsp+0C8h+var_7A], al
mov rax, [rsp+0C8h+var_30]
mov eax, [rax+54h]
mov [rsp+0C8h+var_80], eax
mov rdi, [rsp+0C8h+var_30]
add rdi, 58h ; 'X'
call _ZNKSt3__16vectorIjNS_9allocatorIjEEE4sizeB8nn200100Ev; std::vector<uint>::size(void)
cmp rax, 0
jz short loc_162B9
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_30]
add rsi, 58h ; 'X'
call _ZN11flatbuffers17FlatBufferBuilder12CreateVectorIjEENS_6OffsetINS_6VectorIT_EEEERKNSt3__16vectorIS4_NS7_9allocatorIS4_EEEE; flatbuffers::FlatBufferBuilder::CreateVector<uint>(std::vector<uint> const&)
mov [rsp+0C8h+var_84], eax
jmp short loc_162C5
loc_162B9:
lea rdi, [rsp+0C8h+var_84]
xor esi, esi
call _ZN11flatbuffers6OffsetINS_6VectorIjEEEC2Ej; flatbuffers::Offset<flatbuffers::Vector<uint>>::Offset(uint)
loc_162C5:
mov rdi, [rsp+0C8h+var_28]
mov eax, [rsp+0C8h+var_54]
mov [rsp+0C8h+var_88], eax
mov eax, [rsp+0C8h+var_58]
mov [rsp+0C8h+var_8C], eax
mov ecx, [rsp+0C8h+var_5C]
mov r8b, [rsp+0C8h+var_5D]
movss xmm0, [rsp+0C8h+var_64]
movss xmm1, [rsp+0C8h+var_68]
movss xmm2, [rsp+0C8h+var_6C]
mov r9d, [rsp+0C8h+var_70]
mov r14d, [rsp+0C8h+var_74]
mov ebp, [rsp+0C8h+var_78]
mov bl, [rsp+0C8h+var_79]
mov r11b, [rsp+0C8h+var_7A]
mov r10d, [rsp+0C8h+var_80]
mov eax, [rsp+0C8h+var_84]
mov [rsp+0C8h+var_90], eax
mov esi, [rsp+0C8h+var_88]
mov edx, [rsp+0C8h+var_8C]
mov eax, [rsp+0C8h+var_90]
and r8b, 1
and bl, 1
and r11b, 1
movzx r8d, r8b
mov [rsp+0C8h+var_C8], r14d
mov [rsp+0C8h+var_C0], ebp
movzx ebx, bl
mov [rsp+0C8h+var_B8], ebx
movzx r11d, r11b
mov [rsp+0C8h+var_B0], r11d
mov [rsp+0C8h+var_A8], r10d
mov [rsp+0C8h+var_A0], eax
call _ZN3MNN14CreateIDSTQuanERN11flatbuffers17FlatBufferBuilderENS0_6OffsetINS0_6VectorIaEEEENS3_INS4_IfEEEEibfffiiibbjNS3_INS4_IjEEEE; MNN::CreateIDSTQuan(flatbuffers::FlatBufferBuilder &,flatbuffers::Offset<flatbuffers::Vector<signed char>>,flatbuffers::Offset<flatbuffers::Vector<float>>,int,bool,float,float,float,int,int,int,bool,bool,uint,flatbuffers::Offset<flatbuffers::Vector<uint>>)
mov [rsp+0C8h+var_1C], eax
mov eax, [rsp+0C8h+var_1C]
add rsp, 0B0h
pop rbx
pop r14
pop rbp
retn
| long long MNN::CreateIDSTQuan(long long a1, _QWORD *a2, long long a3)
{
int v4; // [rsp+44h] [rbp-84h] BYREF
unsigned int v5; // [rsp+48h] [rbp-80h]
char v6; // [rsp+4Eh] [rbp-7Ah]
char v7; // [rsp+4Fh] [rbp-79h]
int v8; // [rsp+50h] [rbp-78h]
int v9; // [rsp+54h] [rbp-74h]
int v10; // [rsp+58h] [rbp-70h]
int v11; // [rsp+5Ch] [rbp-6Ch]
int v12; // [rsp+60h] [rbp-68h]
int v13; // [rsp+64h] [rbp-64h]
char v14; // [rsp+6Bh] [rbp-5Dh]
int v15; // [rsp+6Ch] [rbp-5Ch]
int v16; // [rsp+70h] [rbp-58h] BYREF
int v17; // [rsp+74h] [rbp-54h] BYREF
long long v18; // [rsp+78h] [rbp-50h]
_QWORD *v19; // [rsp+80h] [rbp-48h]
long long v20; // [rsp+88h] [rbp-40h]
long long v21; // [rsp+90h] [rbp-38h]
_QWORD *v22; // [rsp+98h] [rbp-30h]
long long v23; // [rsp+A0h] [rbp-28h]
v23 = a1;
v22 = a2;
v21 = a3;
v18 = a1;
v19 = a2;
v20 = a3;
if ( std::vector<signed char>::size[abi:nn200100](a2) )
v17 = flatbuffers::FlatBufferBuilder::CreateVector<signed char>(v23, v22);
else
flatbuffers::Offset<flatbuffers::Vector<signed char>>::Offset(&v17, 0);
if ( std::vector<float>::size[abi:nn200100](v22 + 3) )
v16 = flatbuffers::FlatBufferBuilder::CreateVector<float>(v23, v22 + 3);
else
flatbuffers::Offset<flatbuffers::Vector<float>>::Offset(&v16, 0);
v15 = *((_DWORD *)v22 + 12);
v14 = *((_BYTE *)v22 + 52) & 1;
v13 = *((_DWORD *)v22 + 14);
v12 = *((_DWORD *)v22 + 15);
v11 = *((_DWORD *)v22 + 16);
v10 = *((_DWORD *)v22 + 17);
v9 = *((_DWORD *)v22 + 18);
v8 = *((_DWORD *)v22 + 19);
v7 = v22[10] & 1;
v6 = *((_BYTE *)v22 + 81) & 1;
v5 = *((_DWORD *)v22 + 21);
if ( std::vector<unsigned int>::size[abi:nn200100](v22 + 11) )
v4 = flatbuffers::FlatBufferBuilder::CreateVector<unsigned int>(v23, v22 + 11);
else
flatbuffers::Offset<flatbuffers::Vector<unsigned int>>::Offset(&v4, 0LL);
return (unsigned int)MNN::CreateIDSTQuan(v23, v17, v16, v15, v14 & 1, v10, v9, v8, v7 & 1, v6 & 1, v5, v4);
}
| CreateIDSTQuan:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0xb0
MOV qword ptr [RSP + 0xa0],RDI
MOV qword ptr [RSP + 0x98],RSI
MOV qword ptr [RSP + 0x90],RDX
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x88],RAX
MOV RDI,qword ptr [RSP + 0x98]
CALL 0x00106690
CMP RAX,0x0
JZ 0x0011617e
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x98]
CALL 0x001147d0
MOV dword ptr [RSP + 0x74],EAX
JMP 0x0011618a
LAB_0011617e:
LEA RDI,[RSP + 0x74]
XOR ESI,ESI
CALL 0x00114820
LAB_0011618a:
MOV RDI,qword ptr [RSP + 0x98]
ADD RDI,0x18
CALL 0x00114060
CMP RAX,0x0
JZ 0x001161c0
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x98]
ADD RSI,0x18
CALL 0x00114080
MOV dword ptr [RSP + 0x70],EAX
JMP 0x001161cc
LAB_001161c0:
LEA RDI,[RSP + 0x70]
XOR ESI,ESI
CALL 0x001140d0
LAB_001161cc:
MOV RAX,qword ptr [RSP + 0x98]
MOV EAX,dword ptr [RAX + 0x30]
MOV dword ptr [RSP + 0x6c],EAX
MOV RAX,qword ptr [RSP + 0x98]
MOV AL,byte ptr [RAX + 0x34]
AND AL,0x1
MOV byte ptr [RSP + 0x6b],AL
MOV RAX,qword ptr [RSP + 0x98]
MOVSS XMM0,dword ptr [RAX + 0x38]
MOVSS dword ptr [RSP + 0x64],XMM0
MOV RAX,qword ptr [RSP + 0x98]
MOVSS XMM0,dword ptr [RAX + 0x3c]
MOVSS dword ptr [RSP + 0x60],XMM0
MOV RAX,qword ptr [RSP + 0x98]
MOVSS XMM0,dword ptr [RAX + 0x40]
MOVSS dword ptr [RSP + 0x5c],XMM0
MOV RAX,qword ptr [RSP + 0x98]
MOV EAX,dword ptr [RAX + 0x44]
MOV dword ptr [RSP + 0x58],EAX
MOV RAX,qword ptr [RSP + 0x98]
MOV EAX,dword ptr [RAX + 0x48]
MOV dword ptr [RSP + 0x54],EAX
MOV RAX,qword ptr [RSP + 0x98]
MOV EAX,dword ptr [RAX + 0x4c]
MOV dword ptr [RSP + 0x50],EAX
MOV RAX,qword ptr [RSP + 0x98]
MOV AL,byte ptr [RAX + 0x50]
AND AL,0x1
MOV byte ptr [RSP + 0x4f],AL
MOV RAX,qword ptr [RSP + 0x98]
MOV AL,byte ptr [RAX + 0x51]
AND AL,0x1
MOV byte ptr [RSP + 0x4e],AL
MOV RAX,qword ptr [RSP + 0x98]
MOV EAX,dword ptr [RAX + 0x54]
MOV dword ptr [RSP + 0x48],EAX
MOV RDI,qword ptr [RSP + 0x98]
ADD RDI,0x58
CALL 0x00116bf0
CMP RAX,0x0
JZ 0x001162b9
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x98]
ADD RSI,0x58
CALL 0x00116c10
MOV dword ptr [RSP + 0x44],EAX
JMP 0x001162c5
LAB_001162b9:
LEA RDI,[RSP + 0x44]
XOR ESI,ESI
CALL 0x00116c60
LAB_001162c5:
MOV RDI,qword ptr [RSP + 0xa0]
MOV EAX,dword ptr [RSP + 0x74]
MOV dword ptr [RSP + 0x40],EAX
MOV EAX,dword ptr [RSP + 0x70]
MOV dword ptr [RSP + 0x3c],EAX
MOV ECX,dword ptr [RSP + 0x6c]
MOV R8B,byte ptr [RSP + 0x6b]
MOVSS XMM0,dword ptr [RSP + 0x64]
MOVSS XMM1,dword ptr [RSP + 0x60]
MOVSS XMM2,dword ptr [RSP + 0x5c]
MOV R9D,dword ptr [RSP + 0x58]
MOV R14D,dword ptr [RSP + 0x54]
MOV EBP,dword ptr [RSP + 0x50]
MOV BL,byte ptr [RSP + 0x4f]
MOV R11B,byte ptr [RSP + 0x4e]
MOV R10D,dword ptr [RSP + 0x48]
MOV EAX,dword ptr [RSP + 0x44]
MOV dword ptr [RSP + 0x38],EAX
MOV ESI,dword ptr [RSP + 0x40]
MOV EDX,dword ptr [RSP + 0x3c]
MOV EAX,dword ptr [RSP + 0x38]
AND R8B,0x1
AND BL,0x1
AND R11B,0x1
MOVZX R8D,R8B
MOV dword ptr [RSP],R14D
MOV dword ptr [RSP + 0x8],EBP
MOVZX EBX,BL
MOV dword ptr [RSP + 0x10],EBX
MOVZX R11D,R11B
MOV dword ptr [RSP + 0x18],R11D
MOV dword ptr [RSP + 0x20],R10D
MOV dword ptr [RSP + 0x28],EAX
CALL 0x00116c80
MOV dword ptr [RSP + 0xac],EAX
MOV EAX,dword ptr [RSP + 0xac]
ADD RSP,0xb0
POP RBX
POP R14
POP RBP
RET
|
/* MNN::CreateIDSTQuan(flatbuffers::FlatBufferBuilder&, MNN::IDSTQuanT const*,
std::function<unsigned long (void*)> const*) */
int4 MNN::CreateIDSTQuan(FlatBufferBuilder *param_1,IDSTQuanT *param_2,function *param_3)
{
int4 uVar1;
long lVar2;
int4 local_84;
int4 local_80;
byte local_7a;
byte local_79;
int4 local_78;
int4 local_74;
int4 local_70;
int4 local_6c;
int4 local_68;
int4 local_64;
byte local_5d;
int4 local_5c;
int4 local_58;
int4 local_54;
FlatBufferBuilder *local_50;
IDSTQuanT *local_48;
function *local_40;
function *local_38;
vector *local_30;
FlatBufferBuilder *local_28;
local_50 = param_1;
local_48 = param_2;
local_40 = param_3;
local_38 = param_3;
local_30 = (vector *)param_2;
local_28 = param_1;
lVar2 = std::vector<signed_char,std::allocator<signed_char>>::size_abi_nn200100_
((vector<signed_char,std::allocator<signed_char>> *)param_2);
if (lVar2 == 0) {
flatbuffers::Offset<flatbuffers::Vector<signed_char>>::Offset
((Offset<flatbuffers::Vector<signed_char>> *)&local_54,0);
}
else {
local_54 = flatbuffers::FlatBufferBuilder::CreateVector<signed_char>(local_28,local_30);
}
lVar2 = std::vector<float,std::allocator<float>>::size_abi_nn200100_
((vector<float,std::allocator<float>> *)(local_30 + 0x18));
if (lVar2 == 0) {
flatbuffers::Offset<flatbuffers::Vector<float>>::Offset
((Offset<flatbuffers::Vector<float>> *)&local_58,0);
}
else {
local_58 = flatbuffers::FlatBufferBuilder::CreateVector<float>(local_28,local_30 + 0x18);
}
local_5c = *(int4 *)(local_30 + 0x30);
local_5d = (byte)local_30[0x34] & 1;
local_64 = *(int4 *)(local_30 + 0x38);
local_68 = *(int4 *)(local_30 + 0x3c);
local_6c = *(int4 *)(local_30 + 0x40);
local_70 = *(int4 *)(local_30 + 0x44);
local_74 = *(int4 *)(local_30 + 0x48);
local_78 = *(int4 *)(local_30 + 0x4c);
local_79 = (byte)local_30[0x50] & 1;
local_7a = (byte)local_30[0x51] & 1;
local_80 = *(int4 *)(local_30 + 0x54);
lVar2 = std::vector<unsigned_int,std::allocator<unsigned_int>>::size_abi_nn200100_
((vector<unsigned_int,std::allocator<unsigned_int>> *)(local_30 + 0x58));
if (lVar2 == 0) {
flatbuffers::Offset<flatbuffers::Vector<unsigned_int>>::Offset
((Offset<flatbuffers::Vector<unsigned_int>> *)&local_84,0);
}
else {
local_84 = flatbuffers::FlatBufferBuilder::CreateVector<unsigned_int>(local_28,local_30 + 0x58);
}
uVar1 = CreateIDSTQuan(local_64,local_68,local_6c,local_28,local_54,local_58,local_5c,local_5d & 1
,local_70,local_74,local_78,local_79 & 1,local_7a & 1,local_80,local_84);
return uVar1;
}
|
|
3,273 | sanitize_account(PFS_account*) | eloqsql/storage/perfschema/pfs_account.cc | PFS_account *sanitize_account(PFS_account *unsafe)
{
return global_account_container.sanitize(unsafe);
} | O3 | cpp | sanitize_account(PFS_account*):
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorl %ecx, %ecx
leaq 0x387c59(%rip), %rdx # 0x3c9a28
movabsq $-0x7d05f417d05f417d, %rsi # imm = 0x82FA0BE82FA0BE83
movabsq $0x17d05f417d05f5, %rdi # imm = 0x17D05F417D05F5
movq 0xa8(%rdx,%rcx,8), %r9
testq %r9, %r9
je 0x41e1c
movq 0x48(%r9), %r8
cmpq %rax, %r8
ja 0x41e1c
imulq $0xac0, 0x50(%r9), %r9 # imm = 0xAC0
addq %r8, %r9
cmpq %rax, %r9
jbe 0x41e1c
movq %rax, %r9
subq %r8, %r9
imulq %rsi, %r9
rorq $0x6, %r9
cmpq %rdi, %r9
jb 0x41e2a
incq %rcx
cmpq $0x80, %rcx
jne 0x41de3
xorl %eax, %eax
popq %rbp
retq
| _Z16sanitize_accountP11PFS_account:
push rbp
mov rbp, rsp
mov rax, rdi
xor ecx, ecx
lea rdx, global_account_container
mov rsi, 82FA0BE82FA0BE83h
mov rdi, 17D05F417D05F5h
loc_41DE3:
mov r9, [rdx+rcx*8+0A8h]
test r9, r9
jz short loc_41E1C
mov r8, [r9+48h]
cmp r8, rax
ja short loc_41E1C
imul r9, [r9+50h], 0AC0h
add r9, r8
cmp r9, rax
jbe short loc_41E1C
mov r9, rax
sub r9, r8
imul r9, rsi
ror r9, 6
cmp r9, rdi
jb short loc_41E2A
loc_41E1C:
inc rcx
cmp rcx, 80h
jnz short loc_41DE3
xor eax, eax
loc_41E2A:
pop rbp
retn
| PFS_account * sanitize_account(PFS_account *a1)
{
PFS_account *result; // rax
long long v2; // rcx
long long v3; // r9
unsigned long long v4; // r8
result = a1;
v2 = 0LL;
while ( 1 )
{
v3 = global_account_container[v2 + 21];
if ( v3 )
{
v4 = *(_QWORD *)(v3 + 72);
if ( v4 <= (unsigned long long)a1
&& v4 + 2752LL * *(_QWORD *)(v3 + 80) > (unsigned long long)a1
&& __ROR8__(0x82FA0BE82FA0BE83LL * ((_QWORD)a1 - v4), 6) < 0x17D05F417D05F5uLL )
{
break;
}
}
if ( ++v2 == 128 )
return 0LL;
}
return result;
}
| sanitize_account:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDI
XOR ECX,ECX
LEA RDX,[0x4c9a28]
MOV RSI,-0x7d05f417d05f417d
MOV RDI,0x17d05f417d05f5
LAB_00141de3:
MOV R9,qword ptr [RDX + RCX*0x8 + 0xa8]
TEST R9,R9
JZ 0x00141e1c
MOV R8,qword ptr [R9 + 0x48]
CMP R8,RAX
JA 0x00141e1c
IMUL R9,qword ptr [R9 + 0x50],0xac0
ADD R9,R8
CMP R9,RAX
JBE 0x00141e1c
MOV R9,RAX
SUB R9,R8
IMUL R9,RSI
ROR R9,0x6
CMP R9,RDI
JC 0x00141e2a
LAB_00141e1c:
INC RCX
CMP RCX,0x80
JNZ 0x00141de3
XOR EAX,EAX
LAB_00141e2a:
POP RBP
RET
|
/* sanitize_account(PFS_account*) */
PFS_account * sanitize_account(PFS_account *param_1)
{
long lVar1;
PFS_account *pPVar2;
long lVar3;
ulong uVar4;
lVar3 = 0;
while ((((lVar1 = *(long *)(&DAT_004c9ad0 + lVar3 * 8), lVar1 == 0 ||
(pPVar2 = *(PFS_account **)(lVar1 + 0x48), param_1 < pPVar2)) ||
(pPVar2 + *(long *)(lVar1 + 0x50) * 0xac0 <= param_1)) ||
(uVar4 = ((long)param_1 - (long)pPVar2) * -0x7d05f417d05f417d,
0x17d05f417d05f4 < (uVar4 >> 6 | uVar4 << 0x3a)))) {
lVar3 = lVar3 + 1;
if (lVar3 == 0x80) {
return (PFS_account *)0x0;
}
}
return param_1;
}
|
|
3,274 | unlink_block | eloqsql/mysys/mf_keycache.c | static void unlink_block(SIMPLE_KEY_CACHE_CB *keycache, BLOCK_LINK *block)
{
DBUG_ASSERT((block->status & ~BLOCK_CHANGED) == (BLOCK_READ | BLOCK_IN_USE));
DBUG_ASSERT(block->hash_link); /*backptr to block NULL from free_block()*/
DBUG_ASSERT(!block->requests);
DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
DBUG_ASSERT(block->next_used && block->prev_used &&
(block->next_used->prev_used == &block->next_used) &&
(*block->prev_used == block));
if (block->next_used == block)
/* The list contains only one member */
keycache->used_last= keycache->used_ins= NULL;
else
{
block->next_used->prev_used= block->prev_used;
*block->prev_used= block->next_used;
if (keycache->used_last == block)
keycache->used_last= STRUCT_PTR(BLOCK_LINK, next_used, block->prev_used);
if (keycache->used_ins == block)
keycache->used_ins=STRUCT_PTR(BLOCK_LINK, next_used, block->prev_used);
}
block->next_used= NULL;
#ifdef DBUG_ASSERT_EXISTS
/*
This makes it easier to see it's not in a chain during debugging.
And some DBUG_ASSERT() rely on it.
*/
block->prev_used= NULL;
#endif
KEYCACHE_THREAD_TRACE("unlink_block");
#if defined(KEYCACHE_DEBUG)
KEYCACHE_DBUG_ASSERT(keycache->blocks_available != 0);
keycache->blocks_available--;
KEYCACHE_DBUG_PRINT("unlink_block",
("unlinked block %u status=%x #requests=%u #available=%u",
BLOCK_NUMBER(block), block->status,
block->requests, keycache->blocks_available));
#endif
} | O3 | c | unlink_block:
movq (%rsi), %rax
cmpq %rsi, %rax
je 0x9b9c1
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq (%rsi), %rax
movq %rax, (%rcx)
cmpq %rsi, 0xb0(%rdi)
jne 0x9b9aa
movq 0x8(%rsi), %rax
movq %rax, 0xb0(%rdi)
cmpq %rsi, 0xb8(%rdi)
jne 0x9b9be
movq 0x8(%rsi), %rax
movq %rax, 0xb8(%rdi)
popq %rbp
jmp 0x9b9cb
xorps %xmm0, %xmm0
movups %xmm0, 0xb0(%rdi)
movq $0x0, (%rsi)
retq
| unlink_block_0:
mov rax, [rsi]
cmp rax, rsi
jz short loc_9B9C1
push rbp
mov rbp, rsp
mov rcx, [rsi+8]
mov [rax+8], rcx
mov rax, [rsi]
mov [rcx], rax
cmp [rdi+0B0h], rsi
jnz short loc_9B9AA
mov rax, [rsi+8]
mov [rdi+0B0h], rax
loc_9B9AA:
cmp [rdi+0B8h], rsi
jnz short loc_9B9BE
mov rax, [rsi+8]
mov [rdi+0B8h], rax
loc_9B9BE:
pop rbp
jmp short loc_9B9CB
loc_9B9C1:
xorps xmm0, xmm0
movups xmmword ptr [rdi+0B0h], xmm0
loc_9B9CB:
mov qword ptr [rsi], 0
retn
| _QWORD * unlink_block_0(long long a1, _QWORD *a2)
{
_QWORD *result; // rax
_QWORD *v3; // rcx
result = (_QWORD *)*a2;
if ( (_QWORD *)*a2 == a2 )
{
*(_OWORD *)(a1 + 176) = 0LL;
}
else
{
v3 = (_QWORD *)a2[1];
result[1] = v3;
result = (_QWORD *)*a2;
*v3 = *a2;
if ( *(_QWORD **)(a1 + 176) == a2 )
{
result = (_QWORD *)a2[1];
*(_QWORD *)(a1 + 176) = result;
}
if ( *(_QWORD **)(a1 + 184) == a2 )
{
result = (_QWORD *)a2[1];
*(_QWORD *)(a1 + 184) = result;
}
}
*a2 = 0LL;
return result;
}
| unlink_block:
MOV RAX,qword ptr [RSI]
CMP RAX,RSI
JZ 0x0019b9c1
PUSH RBP
MOV RBP,RSP
MOV RCX,qword ptr [RSI + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSI]
MOV qword ptr [RCX],RAX
CMP qword ptr [RDI + 0xb0],RSI
JNZ 0x0019b9aa
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0xb0],RAX
LAB_0019b9aa:
CMP qword ptr [RDI + 0xb8],RSI
JNZ 0x0019b9be
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0xb8],RAX
LAB_0019b9be:
POP RBP
JMP 0x0019b9cb
LAB_0019b9c1:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0xb0],XMM0
LAB_0019b9cb:
MOV qword ptr [RSI],0x0
RET
|
void unlink_block(long param_1,int8 *param_2)
{
int8 *puVar1;
if ((int8 *)*param_2 == param_2) {
*(int8 *)(param_1 + 0xb0) = 0;
*(int8 *)(param_1 + 0xb8) = 0;
}
else {
puVar1 = (int8 *)param_2[1];
((int8 *)*param_2)[1] = puVar1;
*puVar1 = *param_2;
if (*(int8 **)(param_1 + 0xb0) == param_2) {
*(int8 *)(param_1 + 0xb0) = param_2[1];
}
if (*(int8 **)(param_1 + 0xb8) == param_2) {
*(int8 *)(param_1 + 0xb8) = param_2[1];
}
}
*param_2 = 0;
return;
}
|
|
3,275 | ftb_find_relevance_parse | eloqsql/storage/myisam/ft_boolean_search.c | static int ftb_find_relevance_parse(MYSQL_FTPARSER_PARAM *param,
const char *doc, int len)
{
MY_FTB_FIND_PARAM *ftb_param= param->mysql_ftparam;
FT_INFO *ftb= ftb_param->ftb;
uchar *end= (uchar*) doc + len;
FT_WORD w;
while (ft_simple_get_word(ftb->charset, (uchar**) &doc, end, &w, TRUE))
param->mysql_add_word(param, (char*) w.pos, (int)w.len, 0);
return(0);
} | O3 | c | ftb_find_relevance_parse:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %rax
movq %rsi, (%rax)
movq 0x18(%rdi), %rcx
movq (%rcx), %r13
movslq %edx, %r14
addq %rsi, %r14
movq 0x10(%r13), %rdi
leaq -0x48(%rbp), %rcx
movq %rax, %rsi
movq %r14, %rdx
movl $0x1, %r8d
callq 0x76e85
testb %al, %al
je 0x75869
leaq -0x30(%rbp), %r15
leaq -0x48(%rbp), %r12
movq -0x48(%rbp), %rsi
movl -0x38(%rbp), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq *0x8(%rbx)
movq 0x10(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0x76e85
testb %al, %al
jne 0x7583e
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ftb_find_relevance_parse:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
lea rax, [rbp+var_30]
mov [rax], rsi
mov rcx, [rdi+18h]
mov r13, [rcx]
movsxd r14, edx
add r14, rsi
mov rdi, [r13+10h]
lea rcx, [rbp+var_48]
mov rsi, rax
mov rdx, r14
mov r8d, 1
call ft_simple_get_word
test al, al
jz short loc_75869
lea r15, [rbp+var_30]
lea r12, [rbp+var_48]
loc_7583E:
mov rsi, [rbp+var_48]
mov edx, [rbp+var_38]
mov rdi, rbx
xor ecx, ecx
call qword ptr [rbx+8]
mov rdi, [r13+10h]
mov rsi, r15
mov rdx, r14
mov rcx, r12
mov r8d, 1
call ft_simple_get_word
test al, al
jnz short loc_7583E
loc_75869:
xor eax, eax
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ftb_find_relevance_parse(long long a1, long long a2, int a3)
{
long long v3; // r13
long long v4; // r14
_QWORD v6[2]; // [rsp+8h] [rbp-48h] BYREF
unsigned int v7; // [rsp+18h] [rbp-38h]
_QWORD v8[6]; // [rsp+20h] [rbp-30h] BYREF
v8[0] = a2;
v3 = **(_QWORD **)(a1 + 24);
v4 = a2 + a3;
while ( (unsigned __int8)ft_simple_get_word(*(_QWORD *)(v3 + 16), v8, v4, v6, 1LL) )
(*(void ( **)(long long, _QWORD, _QWORD, _QWORD))(a1 + 8))(a1, v6[0], v7, 0LL);
return 0LL;
}
| ftb_find_relevance_parse:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA RAX,[RBP + -0x30]
MOV qword ptr [RAX],RSI
MOV RCX,qword ptr [RDI + 0x18]
MOV R13,qword ptr [RCX]
MOVSXD R14,EDX
ADD R14,RSI
MOV RDI,qword ptr [R13 + 0x10]
LEA RCX,[RBP + -0x48]
MOV RSI,RAX
MOV RDX,R14
MOV R8D,0x1
CALL 0x00176e85
TEST AL,AL
JZ 0x00175869
LEA R15,[RBP + -0x30]
LEA R12,[RBP + -0x48]
LAB_0017583e:
MOV RSI,qword ptr [RBP + -0x48]
MOV EDX,dword ptr [RBP + -0x38]
MOV RDI,RBX
XOR ECX,ECX
CALL qword ptr [RBX + 0x8]
MOV RDI,qword ptr [R13 + 0x10]
MOV RSI,R15
MOV RDX,R14
MOV RCX,R12
MOV R8D,0x1
CALL 0x00176e85
TEST AL,AL
JNZ 0x0017583e
LAB_00175869:
XOR EAX,EAX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 ftb_find_relevance_parse(long param_1,long param_2,int param_3)
{
long lVar1;
char cVar2;
int8 local_50 [2];
int4 local_40;
long local_38;
lVar1 = **(long **)(param_1 + 0x18);
local_38 = param_2;
cVar2 = ft_simple_get_word(*(int8 *)(lVar1 + 0x10),&local_38,param_3 + param_2,local_50,1);
if (cVar2 != '\0') {
do {
(**(code **)(param_1 + 8))(param_1,local_50[0],local_40,0);
cVar2 = ft_simple_get_word(*(int8 *)(lVar1 + 0x10),&local_38,param_3 + param_2,local_50,
1);
} while (cVar2 != '\0');
}
return 0;
}
|
|
3,276 | mysql_list_fields_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_list_fields_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_list_fields,
(parms->mysql, parms->table, parms->wild),
parms->mysql,
MYSQL_RES *,
r_ptr)
} | O0 | c | mysql_list_fields_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x28050
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mysql_list_fields_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov rsi, [rax+8]
mov rax, [rbp+var_10]
mov rdx, [rax+10h]
call mysql_list_fields
mov [rbp+var_18], rax
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+8], rcx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| long long mysql_list_fields_start_internal(long long a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-20h]
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
*(_QWORD *)(v2 + 8) = mysql_list_fields(*(_QWORD *)a1, *(const char **)(a1 + 8), *(const char **)(a1 + 16));
result = v2;
*(_DWORD *)v2 = 0;
return result;
}
| mysql_list_fields_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x10]
CALL 0x00128050
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_list_fields_start_internal(long *param_1)
{
int4 *puVar1;
int8 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_list_fields(*param_1,param_1[1],param_1[2]);
*(int8 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
|
|
3,277 | mysql_list_fields_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_list_fields_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_list_fields,
(parms->mysql, parms->table, parms->wild),
parms->mysql,
MYSQL_RES *,
r_ptr)
} | O3 | c | mysql_list_fields_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %rbx
movq 0x10(%rdi), %rdx
movq %rax, %rdi
callq 0x209f7
movq %rax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_list_fields_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
mov rsi, [rdi+8]
mov rcx, [rax+480h]
mov rbx, [rcx+28h]
mov rdx, [rdi+10h]
mov rdi, rax
call mysql_list_fields
mov [rbx+8], rax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_list_fields_start_internal(long long a1)
{
long long v1; // rbx
long long result; // rax
v1 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
result = mysql_list_fields(*(_QWORD *)a1, *(const char **)(a1 + 8), *(const char **)(a1 + 16));
*(_QWORD *)(v1 + 8) = result;
*(_DWORD *)v1 = 0;
return result;
}
| mysql_list_fields_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RCX + 0x28]
MOV RDX,qword ptr [RDI + 0x10]
MOV RDI,RAX
CALL 0x001209f7
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_list_fields_start_internal(long *param_1)
{
int4 *puVar1;
int8 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_list_fields(*param_1,param_1[1],param_1[2]);
*(int8 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
|
|
3,278 | ma_set_dynamic | eloqsql/libmariadb/libmariadb/ma_array.c | my_bool ma_set_dynamic(DYNAMIC_ARRAY *array, void * element, uint idx)
{
if (idx >= array->elements)
{
if (idx >= array->max_element)
{
uint size;
char *new_ptr;
size=(idx+array->alloc_increment)/array->alloc_increment;
size*= array->alloc_increment;
if (!(new_ptr=(char*) realloc(array->buffer,size*
array->size_of_element)))
return TRUE;
array->buffer=new_ptr;
array->max_element=size;
}
memset((array->buffer+array->elements*array->size_of_element), 0,
(idx - array->elements)*array->size_of_element);
array->elements=idx+1;
}
memcpy(array->buffer+(idx * array->size_of_element),element,
(size_t) array->size_of_element);
return FALSE;
} | O0 | c | ma_set_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x4736b
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x47326
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x10(%rcx)
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
imull -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x13710
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x47311
movb $0x1, -0x1(%rbp)
jmp 0x47398
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x13260
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %edx
callq 0x13370
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_set_dynamic:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp eax, [rcx+8]
jb loc_4736B
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp eax, [rcx+0Ch]
jb short loc_47326
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
add eax, [rcx+10h]
mov rcx, [rbp+var_10]
xor edx, edx
div dword ptr [rcx+10h]
mov [rbp+var_20], eax
mov rax, [rbp+var_10]
mov eax, [rax+10h]
imul eax, [rbp+var_20]
mov [rbp+var_20], eax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov eax, [rbp+var_20]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov esi, eax
call _realloc
mov [rbp+var_28], rax
cmp rax, 0
jnz short loc_47311
mov [rbp+var_1], 1
jmp loc_47398
loc_47311:
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax], rcx
mov ecx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+0Ch], ecx
loc_47326:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
add rdi, rax
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
sub eax, [rcx+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
xor esi, esi
call _memset
mov ecx, [rbp+var_1C]
add ecx, 1
mov rax, [rbp+var_10]
mov [rax+8], ecx
loc_4736B:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
add rdi, rax
mov rsi, [rbp+var_18]
mov rax, [rbp+var_10]
mov eax, [rax+14h]
mov edx, eax
call _memcpy
mov [rbp+var_1], 0
loc_47398:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char ma_set_dynamic(long long a1, long long a2, unsigned int a3)
{
long long v4; // [rsp+8h] [rbp-28h]
unsigned int v5; // [rsp+10h] [rbp-20h]
if ( a3 < *(_DWORD *)(a1 + 8) )
goto LABEL_7;
if ( a3 < *(_DWORD *)(a1 + 12) )
{
LABEL_6:
memset(
(unsigned int)(*(_DWORD *)(a1 + 20) * *(_DWORD *)(a1 + 8)) + *(_QWORD *)a1,
0LL,
*(_DWORD *)(a1 + 20) * (a3 - *(_DWORD *)(a1 + 8)));
*(_DWORD *)(a1 + 8) = a3 + 1;
LABEL_7:
memcpy(*(_DWORD *)(a1 + 20) * a3 + *(_QWORD *)a1, a2, *(unsigned int *)(a1 + 20));
return 0;
}
v5 = (*(_DWORD *)(a1 + 16) + a3) / *(_DWORD *)(a1 + 16) * *(_DWORD *)(a1 + 16);
v4 = realloc(*(_QWORD *)a1, *(_DWORD *)(a1 + 20) * v5);
if ( v4 )
{
*(_QWORD *)a1 = v4;
*(_DWORD *)(a1 + 12) = v5;
goto LABEL_6;
}
return 1;
}
| ma_set_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x8]
JC 0x0014736b
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0xc]
JC 0x00147326
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV dword ptr [RCX + 0x10]
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x10]
IMUL EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV ESI,EAX
CALL 0x00113710
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JNZ 0x00147311
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00147398
LAB_00147311:
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xc],ECX
LAB_00147326:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
ADD RDI,RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
SUB EAX,dword ptr [RCX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
XOR ESI,ESI
CALL 0x00113260
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x8],ECX
LAB_0014736b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
MOV EDX,EAX
CALL 0x00113370
MOV byte ptr [RBP + -0x1],0x0
LAB_00147398:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 ma_set_dynamic(long *param_1,void *param_2,uint param_3)
{
int iVar1;
void *pvVar2;
if (*(uint *)(param_1 + 1) <= param_3) {
if (*(uint *)((long)param_1 + 0xc) <= param_3) {
iVar1 = (int)param_1[2] * ((param_3 + (int)param_1[2]) / *(uint *)(param_1 + 2));
pvVar2 = realloc((void *)*param_1,(ulong)(uint)(iVar1 * *(int *)((long)param_1 + 0x14)));
if (pvVar2 == (void *)0x0) {
return 1;
}
*param_1 = (long)pvVar2;
*(int *)((long)param_1 + 0xc) = iVar1;
}
memset((void *)(*param_1 + (ulong)(uint)((int)param_1[1] * *(int *)((long)param_1 + 0x14))),0,
(ulong)((param_3 - (int)param_1[1]) * *(int *)((long)param_1 + 0x14)));
*(uint *)(param_1 + 1) = param_3 + 1;
}
memcpy((void *)(*param_1 + (ulong)(param_3 * *(int *)((long)param_1 + 0x14))),param_2,
(ulong)*(uint *)((long)param_1 + 0x14));
return 0;
}
|
|
3,279 | ma_set_dynamic | eloqsql/libmariadb/libmariadb/ma_array.c | my_bool ma_set_dynamic(DYNAMIC_ARRAY *array, void * element, uint idx)
{
if (idx >= array->elements)
{
if (idx >= array->max_element)
{
uint size;
char *new_ptr;
size=(idx+array->alloc_increment)/array->alloc_increment;
size*= array->alloc_increment;
if (!(new_ptr=(char*) realloc(array->buffer,size*
array->size_of_element)))
return TRUE;
array->buffer=new_ptr;
array->max_element=size;
}
memset((array->buffer+array->elements*array->size_of_element), 0,
(idx - array->elements)*array->size_of_element);
array->elements=idx+1;
}
memcpy(array->buffer+(idx * array->size_of_element),element,
(size_t) array->size_of_element);
return FALSE;
} | O3 | c | ma_set_dynamic:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %eax
cmpl %edx, %eax
ja 0x32764
movq (%r15), %rcx
cmpl %r14d, 0xc(%r15)
ja 0x32741
movl 0x10(%r15), %esi
movl %esi, %r12d
addl %r14d, %r12d
movl %r12d, %eax
xorl %edx, %edx
divl %esi
subl %edx, %r12d
movl 0x14(%r15), %esi
imull %r12d, %esi
movq %rcx, %rdi
callq 0x13740
testq %rax, %rax
je 0x32785
movq %rax, %rcx
movq %rax, (%r15)
movl %r12d, 0xc(%r15)
movl 0x8(%r15), %eax
movl 0x14(%r15), %esi
movl %r14d, %edx
subl %eax, %edx
imull %esi, %edx
movl %esi, %edi
imull %eax, %edi
addq %rcx, %rdi
xorl %esi, %esi
callq 0x13270
leal 0x1(%r14), %eax
movl %eax, 0x8(%r15)
movl 0x14(%r15), %edx
imull %edx, %r14d
addq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x133a0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x3277c
| ma_set_dynamic:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14d, edx
mov rbx, rsi
mov r15, rdi
mov eax, [rdi+8]
cmp eax, edx
ja short loc_32764
mov rcx, [r15]
cmp [r15+0Ch], r14d
ja short loc_32741
mov esi, [r15+10h]
mov r12d, esi
add r12d, r14d
mov eax, r12d
xor edx, edx
div esi
sub r12d, edx
mov esi, [r15+14h]
imul esi, r12d
mov rdi, rcx
call _realloc
test rax, rax
jz short loc_32785
mov rcx, rax
mov [r15], rax
mov [r15+0Ch], r12d
mov eax, [r15+8]
loc_32741:
mov esi, [r15+14h]
mov edx, r14d
sub edx, eax
imul edx, esi
mov edi, esi
imul edi, eax
add rdi, rcx
xor esi, esi
call _memset
lea eax, [r14+1]
mov [r15+8], eax
loc_32764:
mov edx, [r15+14h]
imul r14d, edx
add r14, [r15]
mov rdi, r14
mov rsi, rbx
call _memcpy
xor eax, eax
loc_3277C:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_32785:
mov al, 1
jmp short loc_3277C
| long long ma_set_dynamic(long long *a1, long long a2, unsigned int a3)
{
unsigned int v4; // eax
long long v5; // rcx
unsigned int v6; // r12d
long long v7; // rax
v4 = *((_DWORD *)a1 + 2);
if ( v4 > a3 )
goto LABEL_6;
v5 = *a1;
if ( *((_DWORD *)a1 + 3) > a3 )
{
LABEL_5:
memset(v5 + v4 * *((_DWORD *)a1 + 5), 0LL, *((_DWORD *)a1 + 5) * (a3 - v4));
*((_DWORD *)a1 + 2) = a3 + 1;
LABEL_6:
memcpy(*a1 + *((_DWORD *)a1 + 5) * a3, a2, *((unsigned int *)a1 + 5));
return 0LL;
}
v6 = a3 + *((_DWORD *)a1 + 4) - (a3 + *((_DWORD *)a1 + 4)) % *((_DWORD *)a1 + 4);
v7 = realloc(*a1, v6 * *((_DWORD *)a1 + 5));
if ( v7 )
{
v5 = v7;
*a1 = v7;
*((_DWORD *)a1 + 3) = v6;
v4 = *((_DWORD *)a1 + 2);
goto LABEL_5;
}
return 1LL;
}
| ma_set_dynamic:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14D,EDX
MOV RBX,RSI
MOV R15,RDI
MOV EAX,dword ptr [RDI + 0x8]
CMP EAX,EDX
JA 0x00132764
MOV RCX,qword ptr [R15]
CMP dword ptr [R15 + 0xc],R14D
JA 0x00132741
MOV ESI,dword ptr [R15 + 0x10]
MOV R12D,ESI
ADD R12D,R14D
MOV EAX,R12D
XOR EDX,EDX
DIV ESI
SUB R12D,EDX
MOV ESI,dword ptr [R15 + 0x14]
IMUL ESI,R12D
MOV RDI,RCX
CALL 0x00113740
TEST RAX,RAX
JZ 0x00132785
MOV RCX,RAX
MOV qword ptr [R15],RAX
MOV dword ptr [R15 + 0xc],R12D
MOV EAX,dword ptr [R15 + 0x8]
LAB_00132741:
MOV ESI,dword ptr [R15 + 0x14]
MOV EDX,R14D
SUB EDX,EAX
IMUL EDX,ESI
MOV EDI,ESI
IMUL EDI,EAX
ADD RDI,RCX
XOR ESI,ESI
CALL 0x00113270
LEA EAX,[R14 + 0x1]
MOV dword ptr [R15 + 0x8],EAX
LAB_00132764:
MOV EDX,dword ptr [R15 + 0x14]
IMUL R14D,EDX
ADD R14,qword ptr [R15]
MOV RDI,R14
MOV RSI,RBX
CALL 0x001133a0
XOR EAX,EAX
LAB_0013277c:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00132785:
MOV AL,0x1
JMP 0x0013277c
|
int8 ma_set_dynamic(long *param_1,void *param_2,uint param_3)
{
void *__ptr;
uint uVar1;
int iVar2;
uVar1 = *(uint *)(param_1 + 1);
if (uVar1 <= param_3) {
__ptr = (void *)*param_1;
if (*(uint *)((long)param_1 + 0xc) <= param_3) {
uVar1 = *(uint *)(param_1 + 2) + param_3;
iVar2 = uVar1 - uVar1 % *(uint *)(param_1 + 2);
__ptr = realloc(__ptr,(ulong)(uint)(*(int *)((long)param_1 + 0x14) * iVar2));
if (__ptr == (void *)0x0) {
return 1;
}
*param_1 = (long)__ptr;
*(int *)((long)param_1 + 0xc) = iVar2;
uVar1 = *(uint *)(param_1 + 1);
}
memset((void *)((ulong)(*(int *)((long)param_1 + 0x14) * uVar1) + (long)__ptr),0,
(ulong)((param_3 - uVar1) * *(int *)((long)param_1 + 0x14)));
*(uint *)(param_1 + 1) = param_3 + 1;
}
memcpy((void *)((ulong)(param_3 * *(uint *)((long)param_1 + 0x14)) + *param_1),param_2,
(ulong)*(uint *)((long)param_1 + 0x14));
return 0;
}
|
|
3,280 | line_add | corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/pairing.c | static void line_add(vec384fp6 line, POINTonE2 *T, const POINTonE2 *R,
const POINTonE2_affine *Q)
{
vec384x Z1Z1, U2, S2, H, HH, I, J, V;
#if 1
# define r line[1]
#else
vec384x r;
#endif
/*
* https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-madd-2007-bl
* with XYZ3 being |T|, XYZ1 - |R|, XY2 - |Q|, i.e. Q is affine
*/
sqr_fp2(Z1Z1, R->Z); /* Z1Z1 = Z1^2 */
mul_fp2(U2, Q->X, Z1Z1); /* U2 = X2*Z1Z1 */
mul_fp2(S2, Q->Y, R->Z);
mul_fp2(S2, S2, Z1Z1); /* S2 = Y2*Z1*Z1Z1 */
sub_fp2(H, U2, R->X); /* H = U2-X1 */
sqr_fp2(HH, H); /* HH = H^2 */
add_fp2(I, HH, HH);
add_fp2(I, I, I); /* I = 4*HH */
mul_fp2(J, H, I); /* J = H*I */
sub_fp2(r, S2, R->Y);
add_fp2(r, r, r); /* r = 2*(S2-Y1) */
mul_fp2(V, R->X, I); /* V = X1*I */
sqr_fp2(T->X, r);
sub_fp2(T->X, T->X, J);
sub_fp2(T->X, T->X, V);
sub_fp2(T->X, T->X, V); /* X3 = r^2-J-2*V */
mul_fp2(J, J, R->Y);
sub_fp2(T->Y, V, T->X);
mul_fp2(T->Y, T->Y, r);
sub_fp2(T->Y, T->Y, J);
sub_fp2(T->Y, T->Y, J); /* Y3 = r*(V-X3)-2*Y1*J */
add_fp2(T->Z, R->Z, H);
sqr_fp2(T->Z, T->Z);
sub_fp2(T->Z, T->Z, Z1Z1);
sub_fp2(T->Z, T->Z, HH); /* Z3 = (Z1+H)^2-Z1Z1-HH */
/*
* line evaluation
*/
mul_fp2(I, r, Q->X);
mul_fp2(J, Q->Y, T->Z);
sub_fp2(I, I, J);
add_fp2(line[0], I, I); /* 2*(r*X2 - Y2*Z3) */
#ifdef r
# undef r
#else
vec_copy(line[1], r, sizeof(r));
#endif
vec_copy(line[2], T->Z, sizeof(T->Z));
} | O2 | c | line_add:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movq %rcx, %r13
movq %rcx, -0x40(%rbp)
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
movl $0xc0, %eax
leaq (%rdx,%rax), %r12
leaq -0x2f0(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r12, -0x38(%rbp)
callq 0x5ad98
leaq -0x290(%rbp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x5ad73
leaq 0x60(%r13), %rsi
movq %rsi, -0x48(%rbp)
leaq -0x230(%rbp), %r13
movq %r13, %rdi
movq %r12, %rdx
callq 0x5ad73
movq %r13, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x5ad73
leaq -0x1d0(%rbp), %r13
movq %r13, %rdi
leaq -0x290(%rbp), %rsi
movq %r14, %rdx
callq 0x5acd4
leaq -0x170(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x5ad98
leaq -0x110(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x5acb9
movq %r15, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x5acb9
leaq -0xb0(%rbp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x5ad73
movq -0x30(%rbp), %rax
leaq 0x60(%rax), %r13
leaq 0x60(%r14), %r15
movq %r13, %rdi
leaq -0x230(%rbp), %rsi
movq %r15, %rdx
callq 0x5acd4
movq %r13, %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x5acb9
leaq -0x350(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
leaq -0x110(%rbp), %rdx
callq 0x5ad73
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5ad98
movq %rbx, %rdi
movq %rbx, %rsi
leaq -0xb0(%rbp), %rdx
callq 0x5acd4
movq %rbx, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x5acd4
movq %rbx, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x5acd4
leaq -0xb0(%rbp), %rdi
movq %rdi, %rsi
movq %r15, %rdx
callq 0x5ad73
leaq 0x60(%rbx), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x5acd4
movq %r14, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x5ad73
movq %r14, %rdi
movq %r14, %rsi
leaq -0xb0(%rbp), %rdx
callq 0x5acd4
movq %r14, %rdi
movq %r14, %rsi
leaq -0xb0(%rbp), %rdx
movq %rdx, %r12
callq 0x5acd4
movl $0xc0, %r15d
addq %r15, %rbx
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
leaq -0x1d0(%rbp), %rdx
callq 0x5acb9
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x5ad98
movq %rbx, %rdi
movq %rbx, %rsi
leaq -0x2f0(%rbp), %rdx
callq 0x5acd4
movq %rbx, %rdi
movq %rbx, %rsi
leaq -0x170(%rbp), %rdx
callq 0x5acd4
leaq -0x110(%rbp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq -0x40(%rbp), %rdx
callq 0x5ad73
movq %r12, %r13
movq %r12, %rdi
movq -0x48(%rbp), %rsi
movq %rbx, %rdx
callq 0x5ad73
movq %r14, %rdi
movq %r14, %rsi
movq %r14, %r12
movq %r13, %rdx
callq 0x5acd4
movq -0x30(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x5acb9
addq %r15, %r14
pushq $0x60
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51055
addq $0x328, %rsp # imm = 0x328
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| line_add:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 328h
mov r13, rcx
mov [rbp+var_40], rcx
mov r14, rdx
mov rbx, rsi
mov [rbp+var_30], rdi
mov eax, 0C0h
lea r12, [rdx+rax]
lea r15, [rbp+var_2F0]
mov rdi, r15
mov rsi, r12
mov [rbp+var_38], r12
call sqr_fp2
lea rdi, [rbp+var_290]
mov rsi, r13
mov rdx, r15
call mul_fp2
lea rsi, [r13+60h]
mov [rbp+var_48], rsi
lea r13, [rbp+var_230]
mov rdi, r13
mov rdx, r12
call mul_fp2
mov rdi, r13
mov rsi, r13
mov rdx, r15
call mul_fp2
lea r13, [rbp+var_1D0]
mov rdi, r13
lea rsi, [rbp+var_290]
mov rdx, r14
call _sub_fp2
lea r12, [rbp+var_170]
mov rdi, r12
mov rsi, r13
call sqr_fp2
lea r15, [rbp+var_110]
mov rdi, r15
mov rsi, r12
mov rdx, r12
call add_fp2
mov rdi, r15
mov rsi, r15
mov rdx, r15
call add_fp2
lea rdi, [rbp+var_B0]
mov rsi, r13
mov rdx, r15
call mul_fp2
mov rax, [rbp+var_30]
lea r13, [rax+60h]
lea r15, [r14+60h]
mov rdi, r13
lea rsi, [rbp+var_230]
mov rdx, r15
call _sub_fp2
mov rdi, r13
mov rsi, r13
mov rdx, r13
call add_fp2
lea r12, [rbp+var_350]
mov rdi, r12
mov rsi, r14
lea rdx, [rbp+var_110]
call mul_fp2
mov rdi, rbx
mov rsi, r13
call sqr_fp2
mov rdi, rbx
mov rsi, rbx
lea rdx, [rbp+var_B0]
call _sub_fp2
mov rdi, rbx
mov rsi, rbx
mov rdx, r12
call _sub_fp2
mov rdi, rbx
mov rsi, rbx
mov rdx, r12
call _sub_fp2
lea rdi, [rbp+var_B0]
mov rsi, rdi
mov rdx, r15
call mul_fp2
lea r14, [rbx+60h]
mov rdi, r14
mov rsi, r12
mov rdx, rbx
call _sub_fp2
mov rdi, r14
mov rsi, r14
mov rdx, r13
call mul_fp2
mov rdi, r14
mov rsi, r14
lea rdx, [rbp+var_B0]
call _sub_fp2
mov rdi, r14
mov rsi, r14
lea rdx, [rbp+var_B0]
mov r12, rdx
call _sub_fp2
mov r15d, 0C0h
add rbx, r15
mov rdi, rbx
mov rsi, [rbp+var_38]
lea rdx, [rbp+var_1D0]
call add_fp2
mov rdi, rbx
mov rsi, rbx
call sqr_fp2
mov rdi, rbx
mov rsi, rbx
lea rdx, [rbp+var_2F0]
call _sub_fp2
mov rdi, rbx
mov rsi, rbx
lea rdx, [rbp+var_170]
call _sub_fp2
lea r14, [rbp+var_110]
mov rdi, r14
mov rsi, r13
mov rdx, [rbp+var_40]
call mul_fp2
mov r13, r12
mov rdi, r12
mov rsi, [rbp+var_48]
mov rdx, rbx
call mul_fp2
mov rdi, r14
mov rsi, r14
mov r12, r14
mov rdx, r13
call _sub_fp2
mov r14, [rbp+var_30]
mov rdi, r14
mov rsi, r12
mov rdx, r12
call add_fp2
add r14, r15
push 60h ; '`'
pop rdx
mov rdi, r14
mov rsi, rbx
call vec_copy
add rsp, 328h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long line_add(long long a1, long long a2, long long a3, long long a4)
{
long long v7; // r12
long long v8; // r13
long long v9; // rbx
long long v10; // r14
_BYTE v12[96]; // [rsp+0h] [rbp-350h] BYREF
_BYTE v13[96]; // [rsp+60h] [rbp-2F0h] BYREF
_BYTE v14[96]; // [rsp+C0h] [rbp-290h] BYREF
_BYTE v15[96]; // [rsp+120h] [rbp-230h] BYREF
_BYTE v16[96]; // [rsp+180h] [rbp-1D0h] BYREF
_BYTE v17[96]; // [rsp+1E0h] [rbp-170h] BYREF
_BYTE v18[96]; // [rsp+240h] [rbp-110h] BYREF
_BYTE v19[104]; // [rsp+2A0h] [rbp-B0h] BYREF
long long v20; // [rsp+308h] [rbp-48h]
long long v21; // [rsp+310h] [rbp-40h]
long long v22; // [rsp+318h] [rbp-38h]
long long v23; // [rsp+320h] [rbp-30h]
v21 = a4;
v23 = a1;
v7 = a3 + 192;
v22 = a3 + 192;
sqr_fp2((long long)v13, a3 + 192);
mul_fp2((long long)v14, a4, (long long)v13);
v20 = a4 + 96;
mul_fp2((long long)v15, a4 + 96, v7);
mul_fp2((long long)v15, (long long)v15, (long long)v13);
sub_fp2((long long)v16, (long long)v14, a3);
sqr_fp2((long long)v17, (long long)v16);
add_fp2((long long)v18, (long long)v17, (long long)v17);
add_fp2((long long)v18, (long long)v18, (long long)v18);
mul_fp2((long long)v19, (long long)v16, (long long)v18);
v8 = v23 + 96;
sub_fp2(v23 + 96, (long long)v15, a3 + 96);
add_fp2(v8, v8, v8);
mul_fp2((long long)v12, a3, (long long)v18);
sqr_fp2(a2, v8);
sub_fp2(a2, a2, (long long)v19);
sub_fp2(a2, a2, (long long)v12);
sub_fp2(a2, a2, (long long)v12);
mul_fp2((long long)v19, (long long)v19, a3 + 96);
sub_fp2(a2 + 96, (long long)v12, a2);
mul_fp2(a2 + 96, a2 + 96, v8);
sub_fp2(a2 + 96, a2 + 96, (long long)v19);
sub_fp2(a2 + 96, a2 + 96, (long long)v19);
v9 = a2 + 192;
add_fp2(a2 + 192, v22, (long long)v16);
sqr_fp2(v9, v9);
sub_fp2(v9, v9, (long long)v13);
sub_fp2(v9, v9, (long long)v17);
mul_fp2((long long)v18, v8, v21);
mul_fp2((long long)v19, v20, a2 + 192);
sub_fp2((long long)v18, (long long)v18, (long long)v19);
v10 = v23;
add_fp2(v23, (long long)v18, (long long)v18);
return vec_copy(v10 + 192, a2 + 192, 0x60uLL);
}
| line_add:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x328
MOV R13,RCX
MOV qword ptr [RBP + -0x40],RCX
MOV R14,RDX
MOV RBX,RSI
MOV qword ptr [RBP + -0x30],RDI
MOV EAX,0xc0
LEA R12,[RDX + RAX*0x1]
LEA R15,[RBP + -0x2f0]
MOV RDI,R15
MOV RSI,R12
MOV qword ptr [RBP + -0x38],R12
CALL 0x0015ad98
LEA RDI,[RBP + -0x290]
MOV RSI,R13
MOV RDX,R15
CALL 0x0015ad73
LEA RSI,[R13 + 0x60]
MOV qword ptr [RBP + -0x48],RSI
LEA R13,[RBP + -0x230]
MOV RDI,R13
MOV RDX,R12
CALL 0x0015ad73
MOV RDI,R13
MOV RSI,R13
MOV RDX,R15
CALL 0x0015ad73
LEA R13,[RBP + -0x1d0]
MOV RDI,R13
LEA RSI,[RBP + -0x290]
MOV RDX,R14
CALL 0x0015acd4
LEA R12,[RBP + -0x170]
MOV RDI,R12
MOV RSI,R13
CALL 0x0015ad98
LEA R15,[RBP + -0x110]
MOV RDI,R15
MOV RSI,R12
MOV RDX,R12
CALL 0x0015acb9
MOV RDI,R15
MOV RSI,R15
MOV RDX,R15
CALL 0x0015acb9
LEA RDI,[RBP + -0xb0]
MOV RSI,R13
MOV RDX,R15
CALL 0x0015ad73
MOV RAX,qword ptr [RBP + -0x30]
LEA R13,[RAX + 0x60]
LEA R15,[R14 + 0x60]
MOV RDI,R13
LEA RSI,[RBP + -0x230]
MOV RDX,R15
CALL 0x0015acd4
MOV RDI,R13
MOV RSI,R13
MOV RDX,R13
CALL 0x0015acb9
LEA R12,[RBP + -0x350]
MOV RDI,R12
MOV RSI,R14
LEA RDX,[RBP + -0x110]
CALL 0x0015ad73
MOV RDI,RBX
MOV RSI,R13
CALL 0x0015ad98
MOV RDI,RBX
MOV RSI,RBX
LEA RDX,[RBP + -0xb0]
CALL 0x0015acd4
MOV RDI,RBX
MOV RSI,RBX
MOV RDX,R12
CALL 0x0015acd4
MOV RDI,RBX
MOV RSI,RBX
MOV RDX,R12
CALL 0x0015acd4
LEA RDI,[RBP + -0xb0]
MOV RSI,RDI
MOV RDX,R15
CALL 0x0015ad73
LEA R14,[RBX + 0x60]
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBX
CALL 0x0015acd4
MOV RDI,R14
MOV RSI,R14
MOV RDX,R13
CALL 0x0015ad73
MOV RDI,R14
MOV RSI,R14
LEA RDX,[RBP + -0xb0]
CALL 0x0015acd4
MOV RDI,R14
MOV RSI,R14
LEA RDX,[RBP + -0xb0]
MOV R12,RDX
CALL 0x0015acd4
MOV R15D,0xc0
ADD RBX,R15
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x38]
LEA RDX,[RBP + -0x1d0]
CALL 0x0015acb9
MOV RDI,RBX
MOV RSI,RBX
CALL 0x0015ad98
MOV RDI,RBX
MOV RSI,RBX
LEA RDX,[RBP + -0x2f0]
CALL 0x0015acd4
MOV RDI,RBX
MOV RSI,RBX
LEA RDX,[RBP + -0x170]
CALL 0x0015acd4
LEA R14,[RBP + -0x110]
MOV RDI,R14
MOV RSI,R13
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x0015ad73
MOV R13,R12
MOV RDI,R12
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,RBX
CALL 0x0015ad73
MOV RDI,R14
MOV RSI,R14
MOV R12,R14
MOV RDX,R13
CALL 0x0015acd4
MOV R14,qword ptr [RBP + -0x30]
MOV RDI,R14
MOV RSI,R12
MOV RDX,R12
CALL 0x0015acb9
ADD R14,R15
PUSH 0x60
POP RDX
MOV RDI,R14
MOV RSI,RBX
CALL 0x00151055
ADD RSP,0x328
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void line_add(long param_1,long param_2,long param_3,long param_4)
{
long lVar1;
long lVar2;
int1 local_358 [96];
int1 local_2f8 [96];
int1 local_298 [96];
int1 local_238 [96];
int1 local_1d8 [96];
int1 local_178 [96];
int1 local_118 [96];
int1 local_b8 [104];
long local_50;
long local_48;
long local_40;
long local_38;
lVar2 = param_3 + 0xc0;
local_48 = param_4;
local_40 = lVar2;
local_38 = param_1;
sqr_fp2(local_2f8,lVar2);
mul_fp2(local_298,param_4,local_2f8);
local_50 = param_4 + 0x60;
mul_fp2(local_238,local_50,lVar2);
mul_fp2(local_238,local_238,local_2f8);
sub_fp2(local_1d8,local_298,param_3);
sqr_fp2(local_178,local_1d8);
add_fp2(local_118,local_178,local_178);
add_fp2(local_118,local_118,local_118);
mul_fp2(local_b8,local_1d8,local_118);
lVar2 = local_38 + 0x60;
sub_fp2(lVar2,local_238,param_3 + 0x60);
add_fp2(lVar2,lVar2,lVar2);
mul_fp2(local_358,param_3,local_118);
sqr_fp2(param_2,lVar2);
sub_fp2(param_2,param_2,local_b8);
sub_fp2(param_2,param_2,local_358);
sub_fp2(param_2,param_2,local_358);
mul_fp2(local_b8,local_b8,param_3 + 0x60);
lVar1 = param_2 + 0x60;
sub_fp2(lVar1,local_358,param_2);
mul_fp2(lVar1,lVar1,lVar2);
sub_fp2(lVar1,lVar1,local_b8);
sub_fp2(lVar1,lVar1);
param_2 = param_2 + 0xc0;
add_fp2(param_2,local_40,local_1d8);
sqr_fp2(param_2,param_2);
sub_fp2(param_2,param_2,local_2f8);
sub_fp2(param_2,param_2,local_178);
mul_fp2(local_118,lVar2,local_48);
mul_fp2(local_b8,local_50,param_2);
sub_fp2(local_118,local_118,local_b8);
lVar2 = local_38;
add_fp2(local_38,local_118,local_118);
vec_copy(lVar2 + 0xc0,param_2,0x60);
return;
}
|
|
3,281 | OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::FaceHasLimitSurface(int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surfaceFactory.cpp | bool
SurfaceFactory::FaceHasLimitSurface(Index faceIndex) const {
if (!faceHasLimitSimple(faceIndex, getFaceSize(faceIndex))) {
return false;
}
if (_testNeighborhoodForLimit) {
if (!isFaceNeighborhoodRegular(faceIndex, 0, 0)) {
return faceHasLimitNeighborhood(faceIndex);
}
}
return true;
} | O3 | cpp | OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::FaceHasLimitSurface(int) const:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x18(%rax)
addl $0xffff0000, %eax # imm = 0xFFFF0000
cmpl $0xffff0003, %eax # imm = 0xFFFF0003
jb 0x9f848
movq (%r14), %rax
movq %r14, %rdi
movl %ebx, %esi
callq *0x10(%rax)
testb %al, %al
je 0x9f851
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %bpl
testb $0x4, 0x28(%r14)
je 0x9f84a
movq (%r14), %rax
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq *0x48(%rax)
testb %al, %al
jne 0x9f84a
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x3a060
| _ZNK10OpenSubdiv6v3_6_03Bfr14SurfaceFactory19FaceHasLimitSurfaceEi:
push rbp
push r14
push rbx
mov ebx, esi
mov r14, rdi
mov rax, [rdi]
call qword ptr [rax+18h]
add eax, 0FFFF0000h
cmp eax, 0FFFF0003h
jb short loc_9F848
mov rax, [r14]
mov rdi, r14
mov esi, ebx
call qword ptr [rax+10h]
test al, al
jz short loc_9F851
loc_9F848:
xor ebp, ebp
loc_9F84A:
mov eax, ebp
pop rbx
pop r14
pop rbp
retn
loc_9F851:
mov bpl, 1
test byte ptr [r14+28h], 4
jz short loc_9F84A
mov rax, [r14]
mov rdi, r14
mov esi, ebx
xor edx, edx
call qword ptr [rax+48h]
test al, al
jnz short loc_9F84A
mov rdi, r14; this
mov esi, ebx; int
pop rbx
pop r14
pop rbp
jmp __ZNK10OpenSubdiv6v3_6_03Bfr14SurfaceFactory24faceHasLimitNeighborhoodEi; OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::faceHasLimitNeighborhood(int)
| long long OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::FaceHasLimitSurface(
OpenSubdiv::v3_6_0::Bfr::SurfaceFactory *this,
unsigned int a2)
{
unsigned int v2; // ebp
if ( (*(unsigned int ( **)(OpenSubdiv::v3_6_0::Bfr::SurfaceFactory *))(*(_QWORD *)this + 24LL))(this)
- 0x10000 < 0xFFFF0003
|| (*(unsigned __int8 ( **)(OpenSubdiv::v3_6_0::Bfr::SurfaceFactory *, _QWORD))(*(_QWORD *)this + 16LL))(
this,
a2) )
{
return 0;
}
LOBYTE(v2) = 1;
if ( (*((_BYTE *)this + 40) & 4) == 0
|| (*(unsigned __int8 ( **)(OpenSubdiv::v3_6_0::Bfr::SurfaceFactory *, _QWORD, _QWORD))(*(_QWORD *)this + 72LL))(
this,
a2,
0LL) )
{
return v2;
}
return OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::faceHasLimitNeighborhood(this, a2);
}
| FaceHasLimitSurface:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBX,ESI
MOV R14,RDI
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
ADD EAX,0xffff0000
CMP EAX,0xffff0003
JC 0x0019f848
MOV RAX,qword ptr [R14]
MOV RDI,R14
MOV ESI,EBX
CALL qword ptr [RAX + 0x10]
TEST AL,AL
JZ 0x0019f851
LAB_0019f848:
XOR EBP,EBP
LAB_0019f84a:
MOV EAX,EBP
POP RBX
POP R14
POP RBP
RET
LAB_0019f851:
MOV BPL,0x1
TEST byte ptr [R14 + 0x28],0x4
JZ 0x0019f84a
MOV RAX,qword ptr [R14]
MOV RDI,R14
MOV ESI,EBX
XOR EDX,EDX
CALL qword ptr [RAX + 0x48]
TEST AL,AL
JNZ 0x0019f84a
MOV RDI,R14
MOV ESI,EBX
POP RBX
POP R14
POP RBP
JMP 0x0013a060
|
/* OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::FaceHasLimitSurface(int) const */
ulong __thiscall
OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::FaceHasLimitSurface(SurfaceFactory *this,int param_1)
{
char cVar1;
int iVar2;
ulong uVar3;
int8 unaff_RBP;
iVar2 = (**(code **)(*(long *)this + 0x18))();
if (0xffff0002 < iVar2 - 0x10000U) {
cVar1 = (**(code **)(*(long *)this + 0x10))(this,param_1);
if (cVar1 == '\0') {
uVar3 = CONCAT71((int7)((ulong)unaff_RBP >> 8),1);
if (((byte)this[0x28] & 4) != 0) {
cVar1 = (**(code **)(*(long *)this + 0x48))(this,param_1,0);
if (cVar1 == '\0') {
uVar3 = faceHasLimitNeighborhood(this,param_1);
return uVar3;
}
}
goto LAB_0019f84a;
}
}
uVar3 = 0;
LAB_0019f84a:
return uVar3 & 0xffffffff;
}
|
|
3,282 | js_map_mark | bluesky950520[P]quickjs/quickjs.c | static void js_map_mark(JSRuntime *rt, JSValue val, JS_MarkFunc *mark_func)
{
JSObject *p = JS_VALUE_GET_OBJ(val);
JSMapState *s;
struct list_head *el;
JSMapRecord *mr;
s = p->u.map_state;
if (s) {
list_for_each(el, &s->records) {
mr = list_entry(el, JSMapRecord, link);
if (!s->is_weak)
JS_MarkValue(rt, mr->key, mark_func);
JS_MarkValue(rt, mr->value, mark_func);
}
}
} | O1 | c | js_map_mark:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rsi), %r15
testq %r15, %r15
je 0x3af6c
leaq 0x8(%r15), %r12
movq 0x10(%r15), %r13
cmpq %r12, %r13
je 0x3af6c
movq %rcx, %rbx
movq %rdi, %r14
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
cmpl $0x0, (%r15)
jne 0x3af44
movsd 0x20(%r13), %xmm0
movl 0x28(%r13), %eax
movsd %xmm0, (%rsp)
andl $-0x2, %eax
cmpl %ebp, %eax
jne 0x3af44
movq (%rsp), %rsi
movq %r14, %rdi
callq *%rbx
movsd 0x30(%r13), %xmm0
movl 0x38(%r13), %eax
movsd %xmm0, (%rsp)
andl $-0x2, %eax
cmpl %ebp, %eax
jne 0x3af63
movq (%rsp), %rsi
movq %r14, %rdi
callq *%rbx
movq 0x8(%r13), %r13
cmpq %r12, %r13
jne 0x3af1f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_map_mark:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, [rsi+30h]
test r15, r15
jz short loc_3AF6C
lea r12, [r15+8]
mov r13, [r15+10h]
cmp r13, r12
jz short loc_3AF6C
mov rbx, rcx
mov r14, rdi
mov ebp, 0FFFFFFFEh
loc_3AF1F:
cmp dword ptr [r15], 0
jnz short loc_3AF44
movsd xmm0, qword ptr [r13+20h]
mov eax, [r13+28h]
movsd [rsp+38h+var_38], xmm0
and eax, 0FFFFFFFEh
cmp eax, ebp
jnz short loc_3AF44
mov rsi, [rsp+38h+var_38]
mov rdi, r14
call rbx
loc_3AF44:
movsd xmm0, qword ptr [r13+30h]
mov eax, [r13+38h]
movsd [rsp+38h+var_38], xmm0
and eax, 0FFFFFFFEh
cmp eax, ebp
jnz short loc_3AF63
mov rsi, [rsp+38h+var_38]
mov rdi, r14
call rbx
loc_3AF63:
mov r13, [r13+8]
cmp r13, r12
jnz short loc_3AF1F
loc_3AF6C:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_map_mark(long long a1, long long a2, long long a3, void ( *a4)(long long, _QWORD))
{
long long v4; // r15
long long i; // r13
long long result; // rax
v4 = *(_QWORD *)(a2 + 48);
if ( v4 )
{
for ( i = *(_QWORD *)(v4 + 16); i != v4 + 8; i = *(_QWORD *)(i + 8) )
{
if ( !*(_DWORD *)v4 && (*(_DWORD *)(i + 40) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(i + 32));
result = *(_DWORD *)(i + 56) & 0xFFFFFFFE;
if ( (_DWORD)result == -2 )
result = ((long long ( *)(long long, _QWORD))a4)(a1, *(_QWORD *)(i + 48));
}
}
return result;
}
| |||
3,283 | js_map_mark | bluesky950520[P]quickjs/quickjs.c | static void js_map_mark(JSRuntime *rt, JSValue val, JS_MarkFunc *mark_func)
{
JSObject *p = JS_VALUE_GET_OBJ(val);
JSMapState *s;
struct list_head *el;
JSMapRecord *mr;
s = p->u.map_state;
if (s) {
list_for_each(el, &s->records) {
mr = list_entry(el, JSMapRecord, link);
if (!s->is_weak)
JS_MarkValue(rt, mr->key, mark_func);
JS_MarkValue(rt, mr->value, mark_func);
}
}
} | O3 | c | js_map_mark:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rsi), %r15
testq %r15, %r15
je 0x3c507
leaq 0x8(%r15), %r12
movq 0x10(%r15), %r13
cmpq %r12, %r13
je 0x3c507
movq %rcx, %rbx
movq %rdi, %r14
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
cmpl $0x0, (%r15)
jne 0x3c4ea
movl 0x28(%r13), %eax
andl $-0x2, %eax
cmpl %ebp, %eax
jne 0x3c4ea
movq 0x20(%r13), %rsi
movq %r14, %rdi
callq *%rbx
movl 0x38(%r13), %eax
andl $-0x2, %eax
cmpl %ebp, %eax
jne 0x3c4fe
movq 0x30(%r13), %rsi
movq %r14, %rdi
callq *%rbx
movq 0x8(%r13), %r13
cmpq %r12, %r13
jne 0x3c4d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_map_mark:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, [rsi+30h]
test r15, r15
jz short loc_3C507
lea r12, [r15+8]
mov r13, [r15+10h]
cmp r13, r12
jz short loc_3C507
mov rbx, rcx
mov r14, rdi
mov ebp, 0FFFFFFFEh
loc_3C4D0:
cmp dword ptr [r15], 0
jnz short loc_3C4EA
mov eax, [r13+28h]
and eax, 0FFFFFFFEh
cmp eax, ebp
jnz short loc_3C4EA
mov rsi, [r13+20h]
mov rdi, r14
call rbx
loc_3C4EA:
mov eax, [r13+38h]
and eax, 0FFFFFFFEh
cmp eax, ebp
jnz short loc_3C4FE
mov rsi, [r13+30h]
mov rdi, r14
call rbx
loc_3C4FE:
mov r13, [r13+8]
cmp r13, r12
jnz short loc_3C4D0
loc_3C507:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_map_mark(long long a1, long long a2, long long a3, void ( *a4)(long long, _QWORD))
{
long long v4; // r15
long long i; // r13
long long result; // rax
v4 = *(_QWORD *)(a2 + 48);
if ( v4 )
{
for ( i = *(_QWORD *)(v4 + 16); i != v4 + 8; i = *(_QWORD *)(i + 8) )
{
if ( !*(_DWORD *)v4 && (*(_DWORD *)(i + 40) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(i + 32));
result = *(_DWORD *)(i + 56) & 0xFFFFFFFE;
if ( (_DWORD)result == -2 )
result = ((long long ( *)(long long, _QWORD))a4)(a1, *(_QWORD *)(i + 48));
}
}
return result;
}
| js_map_mark:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,qword ptr [RSI + 0x30]
TEST R15,R15
JZ 0x0013c507
LEA R12,[R15 + 0x8]
MOV R13,qword ptr [R15 + 0x10]
CMP R13,R12
JZ 0x0013c507
MOV RBX,RCX
MOV R14,RDI
MOV EBP,0xfffffffe
LAB_0013c4d0:
CMP dword ptr [R15],0x0
JNZ 0x0013c4ea
MOV EAX,dword ptr [R13 + 0x28]
AND EAX,0xfffffffe
CMP EAX,EBP
JNZ 0x0013c4ea
MOV RSI,qword ptr [R13 + 0x20]
MOV RDI,R14
CALL RBX
LAB_0013c4ea:
MOV EAX,dword ptr [R13 + 0x38]
AND EAX,0xfffffffe
CMP EAX,EBP
JNZ 0x0013c4fe
MOV RSI,qword ptr [R13 + 0x30]
MOV RDI,R14
CALL RBX
LAB_0013c4fe:
MOV R13,qword ptr [R13 + 0x8]
CMP R13,R12
JNZ 0x0013c4d0
LAB_0013c507:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void js_map_mark(int8 param_1,long param_2,int8 param_3,code *param_4)
{
int *piVar1;
int *piVar2;
piVar1 = *(int **)(param_2 + 0x30);
if (piVar1 != (int *)0x0) {
for (piVar2 = *(int **)(piVar1 + 4); piVar2 != piVar1 + 2; piVar2 = *(int **)(piVar2 + 2)) {
if ((*piVar1 == 0) && ((piVar2[10] & 0xfffffffeU) == 0xfffffffe)) {
(*param_4)(param_1,*(int8 *)(piVar2 + 8));
}
if ((piVar2[0xe] & 0xfffffffeU) == 0xfffffffe) {
(*param_4)(param_1,*(int8 *)(piVar2 + 0xc));
}
}
}
return;
}
|
|
3,284 | tree_search_key | eloqsql/mysys/tree.c | void *tree_search_key(TREE *tree, const void *key,
TREE_ELEMENT **parents, TREE_ELEMENT ***last_pos,
enum ha_rkey_function flag, void *custom_arg)
{
int cmp;
TREE_ELEMENT *element= tree->root;
TREE_ELEMENT **last_left_step_parent= NULL, **last_right_step_parent= NULL;
TREE_ELEMENT **last_equal_element= NULL;
/*
TODO: support for HA_READ_KEY_OR_PREV, HA_READ_PREFIX flags if needed.
*/
*parents = &null_element;
while (element != &null_element)
{
*++parents= element;
if ((cmp= (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element),
key)) == 0)
{
switch (flag) {
case HA_READ_KEY_EXACT:
case HA_READ_KEY_OR_NEXT:
case HA_READ_BEFORE_KEY:
case HA_READ_KEY_OR_PREV:
last_equal_element= parents;
cmp= 1;
break;
case HA_READ_AFTER_KEY:
cmp= -1;
break;
case HA_READ_PREFIX_LAST:
case HA_READ_PREFIX_LAST_OR_PREV:
last_equal_element= parents;
cmp= -1;
break;
default:
return NULL;
}
}
if (cmp < 0) /* element < key */
{
last_right_step_parent= parents;
element= element->right;
}
else
{
last_left_step_parent= parents;
element= element->left;
}
}
switch (flag) {
case HA_READ_KEY_EXACT:
case HA_READ_PREFIX_LAST:
*last_pos= last_equal_element;
break;
case HA_READ_KEY_OR_NEXT:
*last_pos= last_equal_element ? last_equal_element : last_left_step_parent;
break;
case HA_READ_AFTER_KEY:
*last_pos= last_left_step_parent;
break;
case HA_READ_PREFIX_LAST_OR_PREV:
*last_pos= last_equal_element ? last_equal_element : last_right_step_parent;
break;
case HA_READ_BEFORE_KEY:
*last_pos= last_right_step_parent;
break;
case HA_READ_KEY_OR_PREV:
*last_pos= last_equal_element ? last_equal_element : last_right_step_parent;
break;
default:
return NULL;
}
return *last_pos ? ELEMENT_KEY(tree, **last_pos) : NULL;
} | O0 | c | tree_search_key:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x20(%rbp), %rax
leaq 0x1c9abf(%rip), %rcx # 0x2cda40
movq %rcx, (%rax)
leaq 0x1c9ab5(%rip), %rax # 0x2cda40
cmpq %rax, -0x48(%rbp)
je 0x1040a9
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x20(%rbp)
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x228(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x208(%rax)
je 0x103fe7
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x208(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
jmp 0x103ff3
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
jne 0x104075
movl -0x2c(%rbp), %eax
movl %eax, -0x7c(%rbp)
subl $0x3, %eax
jb 0x10403b
jmp 0x10401a
movl -0x7c(%rbp), %eax
subl $0x3, %eax
je 0x10404c
jmp 0x104024
movl -0x7c(%rbp), %eax
subl $0x4, %eax
je 0x10403b
jmp 0x10402e
movl -0x7c(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0x104055
jmp 0x104066
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0x104073
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
jmp 0x104073
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
jmp 0x104073
movq $0x0, -0x8(%rbp)
jmp 0x10420a
jmp 0x104075
cmpl $0x0, -0x3c(%rbp)
jge 0x104091
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x1040a4
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x103f84
movl -0x2c(%rbp), %eax
movq %rax, -0x88(%rbp)
subq $0x7, %rax
ja 0x10418e
movq -0x88(%rbp), %rax
leaq 0x61e05(%rip), %rcx # 0x165ed0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x60(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x104198
cmpq $0x0, -0x60(%rbp)
je 0x1040f8
movq -0x60(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x104103
movq -0x50(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x104198
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x104198
cmpq $0x0, -0x60(%rbp)
je 0x104137
movq -0x60(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x104142
movq -0x58(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x104198
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x104198
cmpq $0x0, -0x60(%rbp)
je 0x104173
movq -0x60(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0x10417e
movq -0x58(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x104198
movq $0x0, -0x8(%rbp)
jmp 0x10420a
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1041f4
movq -0x10(%rbp), %rax
cmpl $0x0, 0x208(%rax)
je 0x1041cf
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x208(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0xa8(%rbp)
jmp 0x1041e4
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xb0(%rbp)
jmp 0x1041ff
xorl %eax, %eax
movq %rax, -0xb0(%rbp)
jmp 0x1041ff
movq -0xb0(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| tree_search_key:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_2C], r8d
mov [rbp+var_38], r9
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_48], rax
mov [rbp+var_50], 0
mov [rbp+var_58], 0
mov [rbp+var_60], 0
mov rax, [rbp+var_20]
lea rcx, null_element
mov [rax], rcx
loc_103F84:
lea rax, null_element
cmp [rbp+var_48], rax
jz loc_1040A9
mov rcx, [rbp+var_48]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 8
mov [rbp+var_20], rdx
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov rax, [rax+228h]
mov [rbp+var_70], rax
mov rax, [rbp+var_38]
mov [rbp+var_68], rax
mov rax, [rbp+var_10]
cmp dword ptr [rax+208h], 0
jz short loc_103FE7
mov rax, [rbp+var_48]
mov rcx, [rbp+var_10]
mov ecx, [rcx+208h]
add rax, rcx
mov [rbp+var_78], rax
jmp short loc_103FF3
loc_103FE7:
mov rax, [rbp+var_48]
mov rax, [rax+18h]
mov [rbp+var_78], rax
loc_103FF3:
mov rax, [rbp+var_70]
mov rdi, [rbp+var_68]
mov rsi, [rbp+var_78]
mov rdx, [rbp+var_18]
call rax
mov [rbp+var_3C], eax
cmp eax, 0
jnz short loc_104075
mov eax, [rbp+var_2C]
mov [rbp+var_7C], eax
sub eax, 3
jb short loc_10403B
jmp short $+2
loc_10401A:
mov eax, [rbp+var_7C]
sub eax, 3
jz short loc_10404C
jmp short $+2
loc_104024:
mov eax, [rbp+var_7C]
sub eax, 4
jz short loc_10403B
jmp short $+2
loc_10402E:
mov eax, [rbp+var_7C]
add eax, 0FFFFFFFAh
sub eax, 2
jb short loc_104055
jmp short loc_104066
loc_10403B:
mov rax, [rbp+var_20]
mov [rbp+var_60], rax
mov [rbp+var_3C], 1
jmp short loc_104073
loc_10404C:
mov [rbp+var_3C], 0FFFFFFFFh
jmp short loc_104073
loc_104055:
mov rax, [rbp+var_20]
mov [rbp+var_60], rax
mov [rbp+var_3C], 0FFFFFFFFh
jmp short loc_104073
loc_104066:
mov [rbp+var_8], 0
jmp loc_10420A
loc_104073:
jmp short $+2
loc_104075:
cmp [rbp+var_3C], 0
jge short loc_104091
mov rax, [rbp+var_20]
mov [rbp+var_58], rax
mov rax, [rbp+var_48]
mov rax, [rax+8]
mov [rbp+var_48], rax
jmp short loc_1040A4
loc_104091:
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
mov rax, [rbp+var_48]
mov rax, [rax]
mov [rbp+var_48], rax
loc_1040A4:
jmp loc_103F84
loc_1040A9:
mov eax, [rbp+var_2C]
mov [rbp+var_88], rax
sub rax, 7; switch 8 cases
ja def_1040D2; jumptable 00000000001040D2 default case, case 5
mov rax, [rbp+var_88]
lea rcx, jpt_1040D2
movsxd rax, ds:(jpt_1040D2 - 165ED0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_1040D4:
mov rcx, [rbp+var_60]; jumptable 00000000001040D2 cases 0,6
mov rax, [rbp+var_28]
mov [rax], rcx
jmp loc_104198
loc_1040E4:
cmp [rbp+var_60], 0; jumptable 00000000001040D2 case 1
jz short loc_1040F8
mov rax, [rbp+var_60]
mov [rbp+var_90], rax
jmp short loc_104103
loc_1040F8:
mov rax, [rbp+var_50]
mov [rbp+var_90], rax
loc_104103:
mov rcx, [rbp+var_90]
mov rax, [rbp+var_28]
mov [rax], rcx
jmp loc_104198
loc_104116:
mov rcx, [rbp+var_50]; jumptable 00000000001040D2 case 3
mov rax, [rbp+var_28]
mov [rax], rcx
jmp short loc_104198
loc_104123:
cmp [rbp+var_60], 0; jumptable 00000000001040D2 case 7
jz short loc_104137
mov rax, [rbp+var_60]
mov [rbp+var_98], rax
jmp short loc_104142
loc_104137:
mov rax, [rbp+var_58]
mov [rbp+var_98], rax
loc_104142:
mov rcx, [rbp+var_98]
mov rax, [rbp+var_28]
mov [rax], rcx
jmp short loc_104198
loc_104152:
mov rcx, [rbp+var_58]; jumptable 00000000001040D2 case 4
mov rax, [rbp+var_28]
mov [rax], rcx
jmp short loc_104198
loc_10415F:
cmp [rbp+var_60], 0; jumptable 00000000001040D2 case 2
jz short loc_104173
mov rax, [rbp+var_60]
mov [rbp+var_A0], rax
jmp short loc_10417E
loc_104173:
mov rax, [rbp+var_58]
mov [rbp+var_A0], rax
loc_10417E:
mov rcx, [rbp+var_A0]
mov rax, [rbp+var_28]
mov [rax], rcx
jmp short loc_104198
def_1040D2:
mov [rbp+var_8], 0; jumptable 00000000001040D2 default case, case 5
jmp short loc_10420A
loc_104198:
mov rax, [rbp+var_28]
cmp qword ptr [rax], 0
jz short loc_1041F4
mov rax, [rbp+var_10]
cmp dword ptr [rax+208h], 0
jz short loc_1041CF
mov rax, [rbp+var_28]
mov rax, [rax]
mov rax, [rax]
mov rcx, [rbp+var_10]
mov ecx, [rcx+208h]
add rax, rcx
mov [rbp+var_A8], rax
jmp short loc_1041E4
loc_1041CF:
mov rax, [rbp+var_28]
mov rax, [rax]
mov rax, [rax]
mov rax, [rax+18h]
mov [rbp+var_A8], rax
loc_1041E4:
mov rax, [rbp+var_A8]
mov [rbp+var_B0], rax
jmp short loc_1041FF
loc_1041F4:
xor eax, eax
mov [rbp+var_B0], rax
jmp short $+2
loc_1041FF:
mov rax, [rbp+var_B0]
mov [rbp+var_8], rax
loc_10420A:
mov rax, [rbp+var_8]
add rsp, 0B0h
pop rbp
retn
| long long tree_search_key(long long ***a1, long long a2, _QWORD *a3, long long a4, unsigned int a5, long long a6)
{
_QWORD *v6; // rax
int v7; // eax
long long v9; // [rsp+0h] [rbp-B0h]
long long v10; // [rsp+8h] [rbp-A8h]
_QWORD *v11; // [rsp+10h] [rbp-A0h]
_QWORD *v12; // [rsp+18h] [rbp-98h]
_QWORD *v13; // [rsp+20h] [rbp-90h]
long long *v14; // [rsp+40h] [rbp-70h]
_QWORD *v15; // [rsp+50h] [rbp-60h]
_QWORD *v16; // [rsp+58h] [rbp-58h]
_QWORD *v17; // [rsp+60h] [rbp-50h]
long long **v18; // [rsp+68h] [rbp-48h]
int v19; // [rsp+74h] [rbp-3Ch]
_QWORD *v23; // [rsp+90h] [rbp-20h]
long long v24; // [rsp+A8h] [rbp-8h]
v23 = a3;
v18 = *a1;
v17 = 0LL;
v16 = 0LL;
v15 = 0LL;
*a3 = &null_element;
while ( v18 != (long long **)&null_element )
{
v6 = v23++;
v6[1] = v18;
v14 = (long long *)a1[69];
if ( *((_DWORD *)a1 + 130) )
v7 = ((long long ( *)(long long, char *, long long))v14)(a6, (char *)v18 + *((unsigned int *)a1 + 130), a2);
else
v7 = ((long long ( *)(long long, long long *, long long))v14)(a6, v18[3], a2);
v19 = v7;
if ( !v7 )
{
if ( a5 < 3 )
goto LABEL_12;
if ( a5 == 3 )
{
v19 = -1;
goto LABEL_15;
}
if ( a5 == 4 )
{
LABEL_12:
v15 = v23;
v19 = 1;
}
else
{
if ( a5 - 6 >= 2 )
return 0LL;
v15 = v23;
v19 = -1;
}
}
LABEL_15:
if ( v19 >= 0 )
{
v17 = v23;
v18 = (long long **)*v18;
}
else
{
v16 = v23;
v18 = (long long **)v18[1];
}
}
switch ( a5 )
{
case 0u:
case 6u:
*(_QWORD *)a4 = v15;
goto LABEL_35;
case 1u:
if ( v15 )
v13 = v15;
else
v13 = v17;
*(_QWORD *)a4 = v13;
goto LABEL_35;
case 2u:
if ( v15 )
v11 = v15;
else
v11 = v16;
*(_QWORD *)a4 = v11;
goto LABEL_35;
case 3u:
*(_QWORD *)a4 = v17;
goto LABEL_35;
case 4u:
*(_QWORD *)a4 = v16;
goto LABEL_35;
case 7u:
if ( v15 )
v12 = v15;
else
v12 = v16;
*(_QWORD *)a4 = v12;
LABEL_35:
if ( *(_QWORD *)a4 )
{
if ( *((_DWORD *)a1 + 130) )
v10 = *((unsigned int *)a1 + 130) + **(_QWORD **)a4;
else
v10 = *(_QWORD *)(**(_QWORD **)a4 + 24LL);
v9 = v10;
}
else
{
v9 = 0LL;
}
v24 = v9;
break;
default:
v24 = 0LL;
break;
}
return v24;
}
| |||
3,285 | tree_search_key | eloqsql/mysys/tree.c | void *tree_search_key(TREE *tree, const void *key,
TREE_ELEMENT **parents, TREE_ELEMENT ***last_pos,
enum ha_rkey_function flag, void *custom_arg)
{
int cmp;
TREE_ELEMENT *element= tree->root;
TREE_ELEMENT **last_left_step_parent= NULL, **last_right_step_parent= NULL;
TREE_ELEMENT **last_equal_element= NULL;
/*
TODO: support for HA_READ_KEY_OR_PREV, HA_READ_PREFIX flags if needed.
*/
*parents = &null_element;
while (element != &null_element)
{
*++parents= element;
if ((cmp= (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element),
key)) == 0)
{
switch (flag) {
case HA_READ_KEY_EXACT:
case HA_READ_KEY_OR_NEXT:
case HA_READ_BEFORE_KEY:
case HA_READ_KEY_OR_PREV:
last_equal_element= parents;
cmp= 1;
break;
case HA_READ_AFTER_KEY:
cmp= -1;
break;
case HA_READ_PREFIX_LAST:
case HA_READ_PREFIX_LAST_OR_PREV:
last_equal_element= parents;
cmp= -1;
break;
default:
return NULL;
}
}
if (cmp < 0) /* element < key */
{
last_right_step_parent= parents;
element= element->right;
}
else
{
last_left_step_parent= parents;
element= element->left;
}
}
switch (flag) {
case HA_READ_KEY_EXACT:
case HA_READ_PREFIX_LAST:
*last_pos= last_equal_element;
break;
case HA_READ_KEY_OR_NEXT:
*last_pos= last_equal_element ? last_equal_element : last_left_step_parent;
break;
case HA_READ_AFTER_KEY:
*last_pos= last_left_step_parent;
break;
case HA_READ_PREFIX_LAST_OR_PREV:
*last_pos= last_equal_element ? last_equal_element : last_right_step_parent;
break;
case HA_READ_BEFORE_KEY:
*last_pos= last_right_step_parent;
break;
case HA_READ_KEY_OR_PREV:
*last_pos= last_equal_element ? last_equal_element : last_right_step_parent;
break;
default:
return NULL;
}
return *last_pos ? ELEMENT_KEY(tree, **last_pos) : NULL;
} | O3 | c | tree_search_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, -0x50(%rbp)
movl %r8d, -0x2c(%rbp)
movq %rcx, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdi, %r8
movq (%rdi), %r14
leaq 0x2e481d(%rip), %rax # 0x390a40
movq %rax, (%rdx)
cmpq %rax, %r14
je 0xac2f0
movq %rdx, %r13
addq $0x8, %r13
xorl %edx, %edx
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %r14, (%r13)
movl 0x208(%r8), %esi
testq %rsi, %rsi
movq %rdx, -0x38(%rbp)
je 0xac257
addq %r14, %rsi
jmp 0xac25b
movq 0x18(%r14), %rsi
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq %r8, %rbx
callq *0x228(%r8)
testl %eax, %eax
je 0xac27a
movq -0x38(%rbp), %rcx
movq %rbx, %r8
jmp 0xac2c4
movl -0x2c(%rbp), %ecx
cmpl $0x7, %ecx
ja 0xac34d
movq %rbx, %r8
movl $0x1, %eax
movl $0x17, %edx
btl %ecx, %edx
movq %r13, %rcx
jb 0xac2c4
movl -0x2c(%rbp), %eax
movl $0xc0, %ecx
btl %eax, %ecx
jae 0xac2b2
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %r13, %rcx
jmp 0xac2c4
cmpl $0x3, %eax
jne 0xac34d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq -0x38(%rbp), %rcx
movl %eax, %edx
shrl $0x1f, %edx
testl %eax, %eax
cmovnsq %r13, %r12
cmovsq %r13, %r15
movq (%r14,%rdx,8), %r14
addq $0x8, %r13
movq %rcx, %rdx
leaq 0x2e475b(%rip), %rax # 0x390a40
cmpq %rax, %r14
jne 0xac23e
jmp 0xac2f8
xorl %r12d, %r12d
xorl %r15d, %r15d
xorl %ecx, %ecx
xorl %eax, %eax
movl -0x2c(%rbp), %edx
cmpl $0x7, %edx
ja 0xac355
movl %edx, %edx
leaq 0x3ef91(%rip), %rsi # 0xeb29c
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movq %rcx, %r12
jmp 0xac32c
testq %rcx, %rcx
cmovneq %rcx, %r15
movq %r15, %r12
jmp 0xac32c
testq %rcx, %rcx
cmovneq %rcx, %r12
movq -0x40(%rbp), %rax
movq %r12, (%rax)
testq %r12, %r12
je 0xac34d
movl 0x208(%r8), %ecx
movq (%r12), %rax
testq %rcx, %rcx
je 0xac351
addq %rcx, %rax
jmp 0xac355
xorl %eax, %eax
jmp 0xac355
movq 0x18(%rax), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| tree_search_key:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_50], r9
mov [rbp+var_2C], r8d
mov [rbp+var_40], rcx
mov [rbp+var_48], rsi
mov r8, rdi
mov r14, [rdi]
lea rax, null_element
mov [rdx], rax
cmp r14, rax
jz loc_AC2F0
mov r13, rdx
add r13, 8
xor edx, edx
xor r15d, r15d
xor r12d, r12d
loc_AC23E:
mov [r13+0], r14
mov esi, [r8+208h]
test rsi, rsi
mov [rbp+var_38], rdx
jz short loc_AC257
add rsi, r14
jmp short loc_AC25B
loc_AC257:
mov rsi, [r14+18h]
loc_AC25B:
mov rdi, [rbp+var_50]
mov rdx, [rbp+var_48]
mov rbx, r8
call qword ptr [r8+228h]
test eax, eax
jz short loc_AC27A
mov rcx, [rbp+var_38]
mov r8, rbx
jmp short loc_AC2C4
loc_AC27A:
mov ecx, [rbp+var_2C]
cmp ecx, 7
ja loc_AC34D
mov r8, rbx
mov eax, 1
mov edx, 17h
bt edx, ecx
mov rcx, r13
jb short loc_AC2C4
mov eax, [rbp+var_2C]
mov ecx, 0C0h
bt ecx, eax
jnb short loc_AC2B2
mov eax, 0FFFFFFFFh
mov rcx, r13
jmp short loc_AC2C4
loc_AC2B2:
cmp eax, 3
jnz loc_AC34D
mov eax, 0FFFFFFFFh
mov rcx, [rbp+var_38]
loc_AC2C4:
mov edx, eax
shr edx, 1Fh
test eax, eax
cmovns r12, r13
cmovs r15, r13
mov r14, [r14+rdx*8]
add r13, 8
mov rdx, rcx
lea rax, null_element
cmp r14, rax
jnz loc_AC23E
jmp short loc_AC2F8
loc_AC2F0:
xor r12d, r12d
xor r15d, r15d
xor ecx, ecx
loc_AC2F8:
xor eax, eax
mov edx, [rbp+var_2C]
cmp edx, 7; switch 8 cases
ja short def_AC312; jumptable 00000000000AC312 default case, case 5
mov edx, edx
lea rsi, jpt_AC312
movsxd rdx, ds:(jpt_AC312 - 0EB29Ch)[rsi+rdx*4]
add rdx, rsi
jmp rdx; switch jump
loc_AC314:
mov r12, rcx; jumptable 00000000000AC312 cases 0,6
jmp short loc_AC32C; jumptable 00000000000AC312 case 3
loc_AC319:
test rcx, rcx; jumptable 00000000000AC312 cases 2,7
cmovnz r15, rcx
loc_AC320:
mov r12, r15; jumptable 00000000000AC312 case 4
jmp short loc_AC32C; jumptable 00000000000AC312 case 3
loc_AC325:
test rcx, rcx; jumptable 00000000000AC312 case 1
cmovnz r12, rcx
loc_AC32C:
mov rax, [rbp+var_40]; jumptable 00000000000AC312 case 3
mov [rax], r12
test r12, r12
jz short loc_AC34D
mov ecx, [r8+208h]
mov rax, [r12]
test rcx, rcx
jz short loc_AC351
add rax, rcx
jmp short def_AC312; jumptable 00000000000AC312 default case, case 5
loc_AC34D:
xor eax, eax
jmp short def_AC312; jumptable 00000000000AC312 default case, case 5
loc_AC351:
mov rax, [rax+18h]
def_AC312:
add rsp, 28h; jumptable 00000000000AC312 default case, case 5
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long tree_search_key(_QWORD *a1, long long a2, _QWORD *a3, long long **a4, unsigned int a5, long long a6)
{
_QWORD *v6; // r8
long long v7; // r14
_QWORD *v8; // r13
_QWORD *v9; // rdx
long long *v10; // r15
long long *v11; // r12
long long v12; // rsi
_QWORD *v13; // rbx
int v14; // eax
_QWORD *v15; // rcx
int v16; // edx
int v17; // ecx
long long result; // rax
long long v19; // rax
_QWORD *v23; // [rsp+18h] [rbp-38h]
v6 = a1;
v7 = *a1;
*a3 = &null_element;
if ( (_UNKNOWN *)v7 != &null_element )
{
v8 = a3 + 1;
v9 = 0LL;
v10 = 0LL;
v11 = 0LL;
while ( 1 )
{
*v8 = v7;
v23 = v9;
if ( *((_DWORD *)v6 + 130) )
v12 = v7 + *((unsigned int *)v6 + 130);
else
v12 = *(_QWORD *)(v7 + 24);
v13 = v6;
v14 = ((long long ( *)(long long, long long, long long))v6[69])(a6, v12, a2);
if ( v14 )
{
v15 = v23;
v6 = v13;
}
else
{
if ( a5 > 7 )
return 0LL;
v6 = v13;
v14 = 1;
v16 = 23;
v15 = v8;
if ( !_bittest(&v16, a5) )
{
v17 = 192;
if ( _bittest(&v17, a5) )
{
v14 = -1;
v15 = v8;
}
else
{
if ( a5 != 3 )
return 0LL;
v14 = -1;
v15 = v23;
}
}
}
if ( v14 < 0 )
v10 = v8;
else
v11 = v8;
v7 = *(_QWORD *)(v7 + 8LL * ((unsigned int)v14 >> 31));
++v8;
v9 = v15;
if ( (_UNKNOWN *)v7 == &null_element )
goto LABEL_20;
}
}
v11 = 0LL;
v10 = 0LL;
v15 = 0LL;
LABEL_20:
result = 0LL;
switch ( a5 )
{
case 0u:
case 6u:
v11 = v15;
goto LABEL_27;
case 1u:
if ( v15 )
v11 = v15;
goto LABEL_27;
case 2u:
case 7u:
if ( v15 )
v10 = v15;
goto LABEL_24;
case 3u:
goto LABEL_27;
case 4u:
LABEL_24:
v11 = v10;
LABEL_27:
*a4 = v11;
if ( !v11 )
return 0LL;
v19 = *v11;
if ( *((_DWORD *)v6 + 130) )
result = *((unsigned int *)v6 + 130) + v19;
else
result = *(_QWORD *)(v19 + 24);
break;
default:
return result;
}
return result;
}
| tree_search_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x50],R9
MOV dword ptr [RBP + -0x2c],R8D
MOV qword ptr [RBP + -0x40],RCX
MOV qword ptr [RBP + -0x48],RSI
MOV R8,RDI
MOV R14,qword ptr [RDI]
LEA RAX,[0x490a40]
MOV qword ptr [RDX],RAX
CMP R14,RAX
JZ 0x001ac2f0
MOV R13,RDX
ADD R13,0x8
XOR EDX,EDX
XOR R15D,R15D
XOR R12D,R12D
LAB_001ac23e:
MOV qword ptr [R13],R14
MOV ESI,dword ptr [R8 + 0x208]
TEST RSI,RSI
MOV qword ptr [RBP + -0x38],RDX
JZ 0x001ac257
ADD RSI,R14
JMP 0x001ac25b
LAB_001ac257:
MOV RSI,qword ptr [R14 + 0x18]
LAB_001ac25b:
MOV RDI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x48]
MOV RBX,R8
CALL qword ptr [R8 + 0x228]
TEST EAX,EAX
JZ 0x001ac27a
MOV RCX,qword ptr [RBP + -0x38]
MOV R8,RBX
JMP 0x001ac2c4
LAB_001ac27a:
MOV ECX,dword ptr [RBP + -0x2c]
CMP ECX,0x7
JA 0x001ac34d
MOV R8,RBX
MOV EAX,0x1
MOV EDX,0x17
BT EDX,ECX
MOV RCX,R13
JC 0x001ac2c4
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,0xc0
BT ECX,EAX
JNC 0x001ac2b2
MOV EAX,0xffffffff
MOV RCX,R13
JMP 0x001ac2c4
LAB_001ac2b2:
CMP EAX,0x3
JNZ 0x001ac34d
MOV EAX,0xffffffff
MOV RCX,qword ptr [RBP + -0x38]
LAB_001ac2c4:
MOV EDX,EAX
SHR EDX,0x1f
TEST EAX,EAX
CMOVNS R12,R13
CMOVS R15,R13
MOV R14,qword ptr [R14 + RDX*0x8]
ADD R13,0x8
MOV RDX,RCX
LEA RAX,[0x490a40]
CMP R14,RAX
JNZ 0x001ac23e
JMP 0x001ac2f8
LAB_001ac2f0:
XOR R12D,R12D
XOR R15D,R15D
XOR ECX,ECX
LAB_001ac2f8:
XOR EAX,EAX
MOV EDX,dword ptr [RBP + -0x2c]
CMP EDX,0x7
JA 0x001ac355
MOV EDX,EDX
LEA RSI,[0x1eb29c]
MOVSXD RDX,dword ptr [RSI + RDX*0x4]
ADD RDX,RSI
switchD:
JMP RDX
caseD_0:
MOV R12,RCX
JMP 0x001ac32c
caseD_2:
TEST RCX,RCX
CMOVNZ R15,RCX
caseD_4:
MOV R12,R15
JMP 0x001ac32c
caseD_1:
TEST RCX,RCX
CMOVNZ R12,RCX
caseD_3:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],R12
TEST R12,R12
JZ 0x001ac34d
MOV ECX,dword ptr [R8 + 0x208]
MOV RAX,qword ptr [R12]
TEST RCX,RCX
JZ 0x001ac351
ADD RAX,RCX
JMP 0x001ac355
LAB_001ac34d:
XOR EAX,EAX
JMP 0x001ac355
LAB_001ac351:
MOV RAX,qword ptr [RAX + 0x18]
caseD_5:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long tree_search_key(long *param_1,int8 param_2,int8 *param_3,int8 *param_4,
uint param_5,int8 param_6)
{
uint uVar1;
long lVar2;
long *plVar3;
long *plVar4;
int1 *puVar5;
long *plVar6;
long *plVar7;
int1 *puVar8;
long *plVar9;
puVar8 = (int1 *)*param_1;
*param_3 = null_element;
if (puVar8 == null_element) {
plVar6 = (long *)0x0;
plVar9 = (long *)0x0;
plVar3 = (long *)0x0;
}
else {
plVar7 = param_3 + 1;
plVar9 = (long *)0x0;
plVar6 = (long *)0x0;
plVar4 = (long *)0x0;
do {
*plVar7 = (long)puVar8;
if ((ulong)*(uint *)(param_1 + 0x41) == 0) {
puVar5 = *(int1 **)(puVar8 + 0x18);
}
else {
puVar5 = puVar8 + *(uint *)(param_1 + 0x41);
}
uVar1 = (*(code *)param_1[0x45])(param_6,puVar5,param_2);
plVar3 = plVar4;
if (uVar1 == 0) {
if (7 < param_5) goto LAB_001ac34d;
uVar1 = 1;
plVar3 = plVar7;
if ((0x17U >> (param_5 & 0x1f) & 1) == 0) {
if ((0xc0U >> (param_5 & 0x1f) & 1) == 0) {
if (param_5 != 3) goto LAB_001ac34d;
uVar1 = 0xffffffff;
plVar3 = plVar4;
}
else {
uVar1 = 0xffffffff;
}
}
}
plVar4 = plVar7;
if ((int)uVar1 < 0) {
plVar9 = plVar7;
plVar4 = plVar6;
}
plVar6 = plVar4;
puVar8 = *(int1 **)(puVar8 + (ulong)(uVar1 >> 0x1f) * 8);
plVar7 = plVar7 + 1;
plVar4 = plVar3;
} while (puVar8 != null_element);
}
lVar2 = 0;
switch(param_5) {
case 0:
case 6:
plVar6 = plVar3;
break;
case 1:
if (plVar3 != (long *)0x0) {
plVar6 = plVar3;
}
break;
case 2:
case 7:
if (plVar3 != (long *)0x0) {
plVar9 = plVar3;
}
case 4:
plVar6 = plVar9;
break;
case 3:
break;
default:
goto switchD_001ac312_caseD_5;
}
*param_4 = plVar6;
if (plVar6 == (long *)0x0) {
LAB_001ac34d:
lVar2 = 0;
}
else if ((ulong)*(uint *)(param_1 + 0x41) == 0) {
lVar2 = *(long *)(*plVar6 + 0x18);
}
else {
lVar2 = *plVar6 + (ulong)*(uint *)(param_1 + 0x41);
}
switchD_001ac312_caseD_5:
return lVar2;
}
|
|
3,286 | fmt::v10::appender fmt::v10::detail::write<char, fmt::v10::appender, unsigned long long, 0>(fmt::v10::appender, unsigned long long) | AlayaLite/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h | inline auto do_count_digits(uint64_t n) -> int {
// This has comparable performance to the version by Kendall Willets
// (https://github.com/fmtlib/format-benchmark/blob/master/digits10)
// but uses smaller tables.
// Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).
static constexpr uint8_t bsr2log10[] = {
1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5,
6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10,
10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};
auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63];
static constexpr const uint64_t zero_or_powers_of_10[] = {
0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),
10000000000000000000ULL};
return t - (n < zero_or_powers_of_10[t]);
} | O3 | c | fmt::v10::appender fmt::v10::detail::write<char, fmt::v10::appender, unsigned long long, 0>(fmt::v10::appender, unsigned long long):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
orq $0x1, %rax
bsrq %rax, %rax
leaq 0x3f7d8(%rip), %rcx # 0x820d0
movzbl (%rcx,%rax), %edx
leaq 0x3f80d(%rip), %rax # 0x82110
cmpq (%rax,%rdx,8), %rsi
movq %rdi, %rbx
sbbq $0x0, %rdx
movq 0x10(%rdi), %rax
movq %rdx, %rcx
addq %rax, %rcx
cmpq %rcx, 0x18(%rdi)
jb 0x42935
movq %rcx, 0x10(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x42935
addq %rax, %rdi
callq 0x42861
jmp 0x42960
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movl $0x0, 0x10(%r14)
movq %r14, %rdi
callq 0x42861
movq %r14, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x426d4
movq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| _ZN3fmt3v106detail5writeIcNS0_8appenderEyTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_:
push r14
push rbx
sub rsp, 18h
mov rax, rsi
or rax, 1
bsr rax, rax
lea rcx, _ZZN3fmt3v106detail15do_count_digitsEmE9bsr2log10; fmt::v10::detail::do_count_digits(ulong)::bsr2log10
movzx edx, byte ptr [rcx+rax]
lea rax, _ZZN3fmt3v106detail15do_count_digitsEmE20zero_or_powers_of_10
cmp rsi, [rax+rdx*8]
mov rbx, rdi
sbb rdx, 0
mov rax, [rdi+10h]
mov rcx, rdx
add rcx, rax
cmp [rdi+18h], rcx
jb short loc_42935
mov [rbx+10h], rcx
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_42935
add rdi, rax
call _ZN3fmt3v106detail14format_decimalIcmEENS1_21format_decimal_resultIPT_EES5_T0_i; fmt::v10::detail::format_decimal<char,ulong>(char *,ulong,int)
jmp short loc_42960
loc_42935:
xorps xmm0, xmm0
mov r14, rsp
movaps xmmword ptr [r14], xmm0
mov dword ptr [r14+10h], 0
mov rdi, r14
call _ZN3fmt3v106detail14format_decimalIcmEENS1_21format_decimal_resultIPT_EES5_T0_i; fmt::v10::detail::format_decimal<char,ulong>(char *,ulong,int)
mov rdi, r14
mov rsi, rdx
mov rdx, rbx
call _ZN3fmt3v106detail17copy_str_noinlineIcPcNS0_8appenderEEET1_T0_S6_S5_; fmt::v10::detail::copy_str_noinline<char,char *,fmt::v10::appender>(char *,char *,fmt::v10::appender)
mov rbx, rax
loc_42960:
mov rax, rbx
add rsp, 18h
pop rbx
pop r14
retn
| long long ZN3fmt3v106detail5writeIcNS0_8appenderEyTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_(
_QWORD *a1,
unsigned long long a2)
{
unsigned long long v2; // rax
long long v3; // rbx
long long v4; // rdx
long long v5; // rax
long long v6; // rdi
long long v7; // rdx
__int128 v9; // [rsp+0h] [rbp-28h] BYREF
int v10; // [rsp+10h] [rbp-18h]
_BitScanReverse64(&v2, a2 | 1);
v3 = (long long)a1;
v4 = (__PAIR128__(fmt::v10::detail::do_count_digits(unsigned long)::bsr2log10[v2], a2)
- (unsigned long long)fmt::v10::detail::do_count_digits(unsigned long)::zero_or_powers_of_10[fmt::v10::detail::do_count_digits(unsigned long)::bsr2log10[v2]]) >> 64;
v5 = a1[2];
if ( a1[3] >= (unsigned long long)(v5 + v4) && (a1[2] = v5 + v4, (v6 = a1[1]) != 0) )
{
fmt::v10::detail::format_decimal<char,unsigned long>(v5 + v6, a2, v4);
}
else
{
v9 = 0LL;
v10 = 0;
fmt::v10::detail::format_decimal<char,unsigned long>((long long)&v9, a2, v4);
return fmt::v10::detail::copy_str_noinline<char,char *,fmt::v10::appender>((long long)&v9, v7, v3);
}
return v3;
}
| _ZN3fmt3v106detail5writeIcNS0_8appenderEyTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RAX,RSI
OR RAX,0x1
BSR RAX,RAX
LEA RCX,[0x1820d0]
MOVZX EDX,byte ptr [RCX + RAX*0x1]
LEA RAX,[0x182110]
CMP RSI,qword ptr [RAX + RDX*0x8]
MOV RBX,RDI
SBB RDX,0x0
MOV RAX,qword ptr [RDI + 0x10]
MOV RCX,RDX
ADD RCX,RAX
CMP qword ptr [RDI + 0x18],RCX
JC 0x00142935
MOV qword ptr [RBX + 0x10],RCX
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x00142935
ADD RDI,RAX
CALL 0x00142861
JMP 0x00142960
LAB_00142935:
XORPS XMM0,XMM0
MOV R14,RSP
MOVAPS xmmword ptr [R14],XMM0
MOV dword ptr [R14 + 0x10],0x0
MOV RDI,R14
CALL 0x00142861
MOV RDI,R14
MOV RSI,RDX
MOV RDX,RBX
CALL 0x001426d4
MOV RBX,RAX
LAB_00142960:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
long _ZN3fmt3v106detail5writeIcNS0_8appenderEyTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_
(long param_1,ulong param_2)
{
long lVar1;
ulong uVar2;
int iVar3;
long lVar4;
int8 extraout_RDX;
char acStack_28 [24];
lVar1 = 0x3f;
if ((param_2 | 1) != 0) {
for (; (param_2 | 1) >> lVar1 == 0; lVar1 = lVar1 + -1) {
}
}
lVar4 = (ulong)(byte)fmt::v10::detail::do_count_digits(unsigned_long)::bsr2log10[lVar1] -
(ulong)(param_2 <
*(ulong *)(fmt::v10::detail::do_count_digits(unsigned_long)::zero_or_powers_of_10 +
(ulong)(byte)fmt::v10::detail::do_count_digits(unsigned_long)::bsr2log10
[lVar1] * 8));
lVar1 = *(long *)(param_1 + 0x10);
uVar2 = lVar4 + lVar1;
iVar3 = (int)lVar4;
if (uVar2 <= *(ulong *)(param_1 + 0x18)) {
*(ulong *)(param_1 + 0x10) = uVar2;
if (*(long *)(param_1 + 8) != 0) {
fmt::v10::detail::format_decimal<char,unsigned_long>
((char *)(*(long *)(param_1 + 8) + lVar1),param_2,iVar3);
return param_1;
}
}
acStack_28[0] = '\0';
acStack_28[1] = '\0';
acStack_28[2] = '\0';
acStack_28[3] = '\0';
acStack_28[4] = '\0';
acStack_28[5] = '\0';
acStack_28[6] = '\0';
acStack_28[7] = '\0';
acStack_28[8] = '\0';
acStack_28[9] = '\0';
acStack_28[10] = '\0';
acStack_28[0xb] = '\0';
acStack_28[0xc] = '\0';
acStack_28[0xd] = '\0';
acStack_28[0xe] = '\0';
acStack_28[0xf] = '\0';
acStack_28[0x10] = '\0';
acStack_28[0x11] = '\0';
acStack_28[0x12] = '\0';
acStack_28[0x13] = '\0';
fmt::v10::detail::format_decimal<char,unsigned_long>(acStack_28,param_2,iVar3);
lVar1 = fmt::v10::detail::copy_str_noinline<char,char*,fmt::v10::appender>
(acStack_28,extraout_RDX,param_1);
return lVar1;
}
|
|
3,287 | my_error_register | eloqsql/mysys/my_error.c | int my_error_register(const char** (*get_errmsgs)(int error), uint first,
uint last)
{
struct my_err_head *meh_p;
struct my_err_head **search_meh_pp;
/* Allocate a new header structure. */
if (! (meh_p= (struct my_err_head*) my_malloc(key_memory_my_err_head,
sizeof(struct my_err_head),
MYF(MY_WME))))
return 1;
meh_p->get_errmsgs= get_errmsgs;
meh_p->meh_first= first;
meh_p->meh_last= last;
/* Search for the right position in the list. */
for (search_meh_pp= &my_errmsgs_list;
*search_meh_pp;
search_meh_pp= &(*search_meh_pp)->meh_next)
{
if ((*search_meh_pp)->meh_last > first)
break;
}
/* Error numbers must be unique. No overlapping is allowed. */
if (*search_meh_pp && ((*search_meh_pp)->meh_first <= last))
{
my_free(meh_p);
return 1;
}
/* Insert header into the chain. */
meh_p->meh_next= *search_meh_pp;
*search_meh_pp= meh_p;
return 0;
} | O3 | c | my_error_register:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
leaq 0x368a56(%rip), %rax # 0x3d04f0
movl (%rax), %edi
movl $0x18, %esi
movl $0x10, %edx
callq 0x6b029
movl $0x1, %ebx
testq %rax, %rax
je 0x67af1
movq %r12, 0x8(%rax)
movl %r15d, 0x10(%rax)
movl %r14d, 0x14(%rax)
leaq 0x2e5db0(%rip), %rcx # 0x34d878
movq %rcx, %rdx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x67adf
cmpl %r15d, 0x14(%rcx)
jbe 0x67ac8
cmpl %r14d, 0x10(%rcx)
jbe 0x67ae9
movq %rcx, (%rax)
movq %rax, (%rdx)
xorl %ebx, %ebx
jmp 0x67af1
movq %rax, %rdi
callq 0x6b256
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_error_register:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14d, edx
mov r15d, esi
mov r12, rdi
lea rax, key_memory_my_err_head
mov edi, [rax]
mov esi, 18h
mov edx, 10h
call my_malloc
mov ebx, 1
test rax, rax
jz short loc_67AF1
mov [rax+8], r12
mov [rax+10h], r15d
mov [rax+14h], r14d
lea rcx, my_errmsgs_list
loc_67AC8:
mov rdx, rcx
mov rcx, [rcx]
test rcx, rcx
jz short loc_67ADF
cmp [rcx+14h], r15d
jbe short loc_67AC8
cmp [rcx+10h], r14d
jbe short loc_67AE9
loc_67ADF:
mov [rax], rcx
mov [rdx], rax
xor ebx, ebx
jmp short loc_67AF1
loc_67AE9:
mov rdi, rax
call my_free
loc_67AF1:
mov eax, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long my_error_register(long long a1, unsigned int a2, unsigned int a3)
{
long long v4; // rax
unsigned int v5; // ebx
long long **v6; // rcx
_QWORD *v7; // rdx
v4 = my_malloc(key_memory_my_err_head, 24LL);
v5 = 1;
if ( v4 )
{
*(_QWORD *)(v4 + 8) = a1;
*(_DWORD *)(v4 + 16) = a2;
*(_DWORD *)(v4 + 20) = a3;
v6 = &my_errmsgs_list;
do
{
v7 = v6;
v6 = (long long **)*v6;
if ( !v6 )
goto LABEL_6;
}
while ( *((_DWORD *)v6 + 5) <= a2 );
if ( *((_DWORD *)v6 + 4) > a3 )
{
LABEL_6:
*(_QWORD *)v4 = v6;
*v7 = v4;
return 0;
}
my_free(v4);
}
return v5;
}
| my_error_register:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14D,EDX
MOV R15D,ESI
MOV R12,RDI
LEA RAX,[0x4d04f0]
MOV EDI,dword ptr [RAX]
MOV ESI,0x18
MOV EDX,0x10
CALL 0x0016b029
MOV EBX,0x1
TEST RAX,RAX
JZ 0x00167af1
MOV qword ptr [RAX + 0x8],R12
MOV dword ptr [RAX + 0x10],R15D
MOV dword ptr [RAX + 0x14],R14D
LEA RCX,[0x44d878]
LAB_00167ac8:
MOV RDX,RCX
MOV RCX,qword ptr [RCX]
TEST RCX,RCX
JZ 0x00167adf
CMP dword ptr [RCX + 0x14],R15D
JBE 0x00167ac8
CMP dword ptr [RCX + 0x10],R14D
JBE 0x00167ae9
LAB_00167adf:
MOV qword ptr [RAX],RCX
MOV qword ptr [RDX],RAX
XOR EBX,EBX
JMP 0x00167af1
LAB_00167ae9:
MOV RDI,RAX
CALL 0x0016b256
LAB_00167af1:
MOV EAX,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 my_error_register(long param_1,uint param_2,uint param_3)
{
int **ppuVar1;
long *plVar2;
int **ppuVar3;
int8 uVar4;
plVar2 = (long *)my_malloc(key_memory_my_err_head,0x18,0x10);
uVar4 = 1;
if (plVar2 != (long *)0x0) {
plVar2[1] = param_1;
*(uint *)(plVar2 + 2) = param_2;
*(uint *)((long)plVar2 + 0x14) = param_3;
ppuVar1 = &my_errmsgs_list;
do {
ppuVar3 = ppuVar1;
ppuVar1 = (int **)*ppuVar3;
if (ppuVar1 == (int **)0x0) goto LAB_00167adf;
} while (*(uint *)((long)ppuVar1 + 0x14) <= param_2);
if (param_3 < *(uint *)(ppuVar1 + 2)) {
LAB_00167adf:
*plVar2 = (long)ppuVar1;
*ppuVar3 = (int *)plVar2;
uVar4 = 0;
}
else {
my_free(plVar2);
}
}
return uVar4;
}
|
|
3,288 | Item_param::set_param_tiny(unsigned char**, unsigned long) | eloqsql/sql/sql_prepare.cc | void Item_param::set_param_tiny(uchar **pos, ulong len)
{
#ifndef EMBEDDED_LIBRARY
if (len < 1)
return;
#endif
int8 value= (int8) **pos;
set_int(unsigned_flag ? (longlong) ((uint8) value) :
(longlong) value, 4);
*pos+= 1;
} | O3 | cpp | Item_param::set_param_tiny(unsigned char**, unsigned long):
testq %rdx, %rdx
je 0x76eecf
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rax
movsbq (%rax), %rax
movzbl %al, %esi
cmpb $0x0, 0xe(%rdi)
cmoveq %rax, %rsi
movl $0x4, %edx
callq 0x91f218
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| _ZN10Item_param14set_param_tinyEPPhm:
test rdx, rdx
jz short locret_76EECF
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rsi
mov rax, [rsi]
movsx rax, byte ptr [rax]
movzx esi, al
cmp byte ptr [rdi+0Eh], 0
cmovz rsi, rax; __int64
mov edx, 4; unsigned int
call _ZN10Item_param7set_intExj; Item_param::set_int(long long,uint)
inc qword ptr [rbx]
add rsp, 8
pop rbx
pop rbp
locret_76EECF:
retn
| long long Item_param::set_param_tiny(Item_param *this, char **a2, long long a3)
{
long long result; // rax
long long v5; // rax
long long v6; // rsi
if ( a3 )
{
v5 = **a2;
v6 = (unsigned __int8)v5;
if ( !*((_BYTE *)this + 14) )
v6 = v5;
result = Item_param::set_int(this, v6, 4u);
++*a2;
}
return result;
}
| operator<<:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV AL,byte ptr [RSI]
MOV byte ptr [RBP + -0x9],AL
MOV RCX,qword ptr [RDI]
MOV RCX,qword ptr [RCX + -0x18]
CMP qword ptr [RDI + RCX*0x1 + 0x10],0x0
JZ 0x0076eeca
LEA RSI,[RBP + -0x9]
PUSH 0x1
POP RDX
MOV RDI,RBX
CALL 0x0071cc00
JMP 0x0076eed5
LAB_0076eeca:
MOVSX ESI,AL
MOV RDI,RBX
CALL 0x0071be20
LAB_0076eed5:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* ib::logger& ib::logger::TEMPNAMEPLACEHOLDERVALUE(char const&) */
logger * __thiscall ib::logger::operator<<(logger *this,char *param_1)
{
char local_11;
if (*(long *)(this + *(long *)(*(long *)this + -0x18) + 0x10) == 0) {
std::ostream::put((char)this);
}
else {
std::__ostream_insert<char,std::char_traits<char>>((ostream *)this,&local_11,1);
}
return this;
}
|
|
3,289 | vsort_log | davidesantangelo[P]vsort/vsort_logger.c | void vsort_log(vsort_log_level_t level, const char *format, va_list args)
{
if (level == VSORT_LOG_NONE || level > current_log_level)
return;
// Get current time
time_t now;
char time_str[20];
time(&now);
struct tm *tm_info = localtime(&now);
strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", tm_info);
// Print log header with timestamp and level
fprintf(stderr, "[%s] [%s] ", time_str, log_level_names[level]);
// Print message
vfprintf(stderr, format, args);
fprintf(stderr, "\n");
} | O3 | c | vsort_log:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edi, %r15d
leal -0x1(%r15), %eax
cmpl 0x3a69(%rip), %eax # 0x6190
jb 0x2737
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x1130
movq %r12, %rdi
callq 0x1050
leaq 0x1276(%rip), %rdx # 0x39cf
leaq 0x10(%rsp), %r12
movl $0x14, %esi
movq %r12, %rdi
movq %rax, %rcx
callq 0x1150
movq 0x3883(%rip), %r13 # 0x5ff8
movq (%r13), %rdi
movl %r15d, %eax
leaq 0x1289(%rip), %rdx # 0x3a0c
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
leaq 0x1250(%rip), %rsi # 0x39e1
movq %r12, %rdx
xorl %eax, %eax
callq 0x1110
movq (%r13), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1180
movq (%r13), %rsi
movl $0xa, %edi
callq 0x10e0
jmp 0x2729
| vsort_log:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 30h
mov r15d, edi
lea eax, [r15-1]
cmp eax, cs:current_log_level
jb short loc_2737
loc_2729:
add rsp, 30h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_2737:
mov rbx, rdx
mov r14, rsi
lea r12, [rsp+58h+var_50]
mov rdi, r12
call _time
mov rdi, r12
call _localtime
lea rdx, aYMDHMS; "%Y-%m-%d %H:%M:%S"
lea r12, [rsp+58h+var_48]
mov esi, 14h
mov rdi, r12
mov rcx, rax
call _strftime
mov r13, cs:stderr_ptr
mov rdi, [r13+0]
mov eax, r15d
lea rdx, log_level_names_rel
movsxd rcx, dword ptr [rdx+rax*4]
add rcx, rdx
lea rsi, aSS; "[%s] [%s] "
mov rdx, r12
xor eax, eax
call _fprintf
mov rdi, [r13+0]
mov rsi, r14
mov rdx, rbx
call _vfprintf
mov rsi, [r13+0]
mov edi, 0Ah
call _fputc
jmp loc_2729
| long long vsort_log(unsigned int a1, long long a2, long long a3)
{
long long result; // rax
long long v5; // rax
char v6; // [rsp+8h] [rbp-50h] BYREF
char v7[72]; // [rsp+10h] [rbp-48h] BYREF
result = a1 - 1;
if ( (unsigned int)result < current_log_level )
{
time(&v6);
v5 = localtime(&v6);
strftime(v7, 20LL, "%Y-%m-%d %H:%M:%S", v5);
fprintf(stderr, "[%s] [%s] ", v7, (const char *)&log_level_names_rel + *((int *)&log_level_names_rel + a1));
vfprintf(stderr, a2, a3);
return fputc(10LL, stderr);
}
return result;
}
| vsort_log:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV R15D,EDI
LEA EAX,[R15 + -0x1]
CMP EAX,dword ptr [0x00106190]
JC 0x00102737
LAB_00102729:
ADD RSP,0x30
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00102737:
MOV RBX,RDX
MOV R14,RSI
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x00101130
MOV RDI,R12
CALL 0x00101050
LEA RDX,[0x1039cf]
LEA R12,[RSP + 0x10]
MOV ESI,0x14
MOV RDI,R12
MOV RCX,RAX
CALL 0x00101150
MOV R13,qword ptr [0x00105ff8]
MOV RDI,qword ptr [R13]
MOV EAX,R15D
LEA RDX,[0x103a0c]
MOVSXD RCX,dword ptr [RDX + RAX*0x4]
ADD RCX,RDX
LEA RSI,[0x1039e1]
MOV RDX,R12
XOR EAX,EAX
CALL 0x00101110
MOV RDI,qword ptr [R13]
MOV RSI,R14
MOV RDX,RBX
CALL 0x00101180
MOV RSI,qword ptr [R13]
MOV EDI,0xa
CALL 0x001010e0
JMP 0x00102729
|
void vsort_log(uint param_1,char *param_2,__gnuc_va_list param_3)
{
int *puVar1;
tm *__tp;
time_t local_50;
char local_48 [32];
if (param_1 - 1 < current_log_level) {
time(&local_50);
__tp = localtime(&local_50);
strftime(local_48,0x14,"%Y-%m-%d %H:%M:%S",__tp);
puVar1 = PTR_stderr_00105ff8;
fprintf(*(FILE **)PTR_stderr_00105ff8,"[%s] [%s] ",local_48,
log_level_names_rel + *(int *)(log_level_names_rel + (ulong)param_1 * 4));
vfprintf(*(FILE **)puVar1,param_2,param_3);
fputc(10,*(FILE **)puVar1);
}
return;
}
|
|
3,290 | my_thread_init | eloqsql/mysys/my_thr_init.c | my_bool my_thread_init(void)
{
struct st_my_thread_var *tmp;
my_bool error=0;
if (!my_thread_global_init_done)
return 1; /* cannot proceed with uninitialized library */
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_init(): pthread_self: %p\n", pthread_self());
#endif
if (my_thread_var)
{
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_init() called more than once in thread 0x%lx\n",
(long) pthread_self());
#endif
goto end;
}
#ifdef _MSC_VER
install_sigabrt_handler();
#endif
if (!(tmp= (struct st_my_thread_var *) calloc(1, sizeof(*tmp))))
{
error= 1;
goto end;
}
set_mysys_var(tmp);
tmp->pthread_self= pthread_self();
my_thread_init_thr_mutex(tmp);
tmp->stack_ends_here= (char*)&tmp +
STACK_DIRECTION * (long)my_thread_stack_size;
mysql_mutex_lock(&THR_LOCK_threads);
tmp->id= tmp->dbug_id= ++thread_id;
++THR_thread_count;
mysql_mutex_unlock(&THR_LOCK_threads);
tmp->init= 1;
#ifndef DBUG_OFF
/* Generate unique name for thread */
(void) my_thread_name();
#endif
end:
return error;
} | O0 | c | my_thread_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x0, -0x11(%rbp)
cmpb $0x0, 0xb93aed(%rip) # 0xc92670
jne 0xfeb8e
movb $0x1, -0x1(%rbp)
jmp 0xfec77
callq 0xfea30
cmpq $0x0, %rax
je 0xfeb9e
jmp 0xfec71
movl $0x1, %edi
movl $0xf0, %esi
callq 0x2a690
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xfebc0
movb $0x1, -0x11(%rbp)
jmp 0xfec71
movq -0x10(%rbp), %rdi
callq 0xfeee0
callq 0x2a540
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x10(%rbp), %rdi
callq 0xfea80
leaq 0x1cea64(%rip), %rax # 0x2cd650
movq (%rax), %rax
shlq $0x0, %rax
leaq -0x10(%rbp), %rcx
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xb8(%rax)
leaq 0xb9399c(%rip), %rdi # 0xc925a8
leaq 0x617b7(%rip), %rsi # 0x1603ca
movl $0x12e, %edx # imm = 0x12E
callq 0xfed90
movq 0xb93a54(%rip), %rcx # 0xc92678
addq $0x1, %rcx
movq %rcx, 0xb93a49(%rip) # 0xc92678
movq -0x10(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0xd0(%rax)
leaq 0xb9375c(%rip), %rax # 0xc923a8
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xb93750(%rip), %rax # 0xc923a8
movl %ecx, (%rax)
leaq 0xb93947(%rip), %rdi # 0xc925a8
callq 0xfee80
movq -0x10(%rbp), %rax
movb $0x1, 0xe8(%rax)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
| my_thread_init:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_11], 0
cmp cs:my_thread_global_init_done, 0
jnz short loc_FEB8E
mov [rbp+var_1], 1
jmp loc_FEC77
loc_FEB8E:
call _my_thread_var
cmp rax, 0
jz short loc_FEB9E
jmp loc_FEC71
loc_FEB9E:
mov edi, 1
mov esi, 0F0h
call _calloc
mov [rbp+var_10], rax
cmp rax, 0
jnz short loc_FEBC0
mov [rbp+var_11], 1
jmp loc_FEC71
loc_FEBC0:
mov rdi, [rbp+var_10]
call set_mysys_var
call _pthread_self
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+0C8h], rcx
mov rdi, [rbp+var_10]
call my_thread_init_thr_mutex
lea rax, my_thread_stack_size
mov rax, [rax]
shl rax, 0
lea rcx, [rbp+var_10]
add rcx, rax
mov rax, [rbp+var_10]
mov [rax+0B8h], rcx
lea rdi, THR_LOCK_threads
lea rsi, aWorkspaceLlm4b_42; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 12Eh
call inline_mysql_mutex_lock_27
mov rcx, cs:thread_id
add rcx, 1
mov cs:thread_id, rcx
mov rax, [rbp+var_10]
mov [rax+0D8h], rcx
mov rax, [rbp+var_10]
mov [rax+0D0h], rcx
lea rax, THR_thread_count
mov ecx, [rax]
add ecx, 1
lea rax, THR_thread_count
mov [rax], ecx
lea rdi, THR_LOCK_threads
call inline_mysql_mutex_unlock_28
mov rax, [rbp+var_10]
mov byte ptr [rax+0E8h], 1
loc_FEC71:
mov al, [rbp+var_11]
mov [rbp+var_1], al
loc_FEC77:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char my_thread_init(long long a1, const char *a2)
{
long long v2; // rcx
char v4; // [rsp+Fh] [rbp-11h]
long long v5; // [rsp+10h] [rbp-10h] BYREF
v4 = 0;
if ( !my_thread_global_init_done )
return 1;
if ( !my_thread_var(a1, a2) )
{
v5 = calloc(1LL, 240LL);
if ( v5 )
{
set_mysys_var(v5);
*(_QWORD *)(v5 + 200) = pthread_self();
my_thread_init_thr_mutex(v5);
*(_QWORD *)(v5 + 184) = (char *)&v5 + (_QWORD)my_thread_stack_size;
inline_mysql_mutex_lock_27(
&THR_LOCK_threads,
"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",
302LL);
v2 = thread_id + 1;
thread_id = v2;
*(_QWORD *)(v5 + 216) = v2;
*(_QWORD *)(v5 + 208) = v2;
++THR_thread_count;
inline_mysql_mutex_unlock_28(&THR_LOCK_threads);
*(_BYTE *)(v5 + 232) = 1;
}
else
{
return 1;
}
}
return v4;
}
| my_thread_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV byte ptr [RBP + -0x11],0x0
CMP byte ptr [0x00d92670],0x0
JNZ 0x001feb8e
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001fec77
LAB_001feb8e:
CALL 0x001fea30
CMP RAX,0x0
JZ 0x001feb9e
JMP 0x001fec71
LAB_001feb9e:
MOV EDI,0x1
MOV ESI,0xf0
CALL 0x0012a690
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JNZ 0x001febc0
MOV byte ptr [RBP + -0x11],0x1
JMP 0x001fec71
LAB_001febc0:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001feee0
CALL 0x0012a540
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xc8],RCX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001fea80
LEA RAX,[0x3cd650]
MOV RAX,qword ptr [RAX]
SHL RAX,0x0
LEA RCX,[RBP + -0x10]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xb8],RCX
LEA RDI,[0xd925a8]
LEA RSI,[0x2603ca]
MOV EDX,0x12e
CALL 0x001fed90
MOV RCX,qword ptr [0x00d92678]
ADD RCX,0x1
MOV qword ptr [0x00d92678],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xd8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xd0],RCX
LEA RAX,[0xd923a8]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0xd923a8]
MOV dword ptr [RAX],ECX
LEA RDI,[0xd925a8]
CALL 0x001fee80
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xe8],0x1
LAB_001fec71:
MOV AL,byte ptr [RBP + -0x11]
MOV byte ptr [RBP + -0x1],AL
LAB_001fec77:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 my_thread_init(void)
{
long lVar1;
pthread_t pVar2;
int1 local_19;
void *local_18;
int1 local_9;
local_19 = 0;
if (my_thread_global_init_done == '\0') {
local_9 = 1;
}
else {
lVar1 = _my_thread_var();
if (lVar1 == 0) {
local_18 = calloc(1,0xf0);
if (local_18 == (void *)0x0) {
local_19 = 1;
}
else {
set_mysys_var(local_18);
pVar2 = pthread_self();
*(pthread_t *)((long)local_18 + 200) = pVar2;
my_thread_init_thr_mutex(local_18);
*(long *)((long)local_18 + 0xb8) = (long)&local_18 + my_thread_stack_size;
inline_mysql_mutex_lock
(THR_LOCK_threads,"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",
0x12e);
lVar1 = thread_id + 1;
thread_id = lVar1;
*(long *)((long)local_18 + 0xd8) = lVar1;
*(long *)((long)local_18 + 0xd0) = lVar1;
THR_thread_count = THR_thread_count + 1;
inline_mysql_mutex_unlock(THR_LOCK_threads);
*(int1 *)((long)local_18 + 0xe8) = 1;
}
}
local_9 = local_19;
}
return local_9;
}
|
|
3,291 | nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get() | 7CodeWizard[P]stablediffusion/thirdparty/json.hpp | char_int_type get()
{
++position.chars_read_total;
++position.chars_read_current_line;
if (next_unget)
{
// just reset the next_unget variable and work with current
next_unget = false;
}
else
{
current = ia.get_character();
}
if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
{
token_string.push_back(std::char_traits<char_type>::to_char_type(current));
}
if (current == '\n')
{
++position.lines_read;
position.chars_read_current_line = 0;
}
return current;
} | O0 | cpp | nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get():
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
testb $0x1, 0x18(%rax)
je 0xd496c
movq 0x10(%rsp), %rax
movb $0x0, 0x18(%rax)
jmp 0xd4980
movq 0x10(%rsp), %rdi
callq 0xd4ab0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x10(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, 0xc(%rsp)
callq 0xd3350
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xd49a6
jmp 0xd49d1
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, (%rsp)
addq $0x14, %rdi
callq 0xd4b20
movq (%rsp), %rdi
movb %al, 0x1f(%rsp)
leaq 0x1f(%rsp), %rsi
callq 0x9fbd0
movq 0x10(%rsp), %rax
cmpl $0xa, 0x14(%rax)
jne 0xd49f5
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq $0x0, 0x28(%rax)
movq 0x10(%rsp), %rax
movl 0x14(%rax), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEE3getEv:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_18], rax
mov rcx, [rax+20h]
add rcx, 1
mov [rax+20h], rcx
mov rcx, [rax+28h]
add rcx, 1
mov [rax+28h], rcx
test byte ptr [rax+18h], 1
jz short loc_D496C
mov rax, [rsp+28h+var_18]
mov byte ptr [rax+18h], 0
jmp short loc_D4980
loc_D496C:
mov rdi, [rsp+28h+var_18]
call _ZN8nlohmann16json_abi_v3_11_26detail22iterator_input_adapterIPKcE13get_characterEv; nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>::get_character(void)
mov ecx, eax
mov rax, [rsp+28h+var_18]
mov [rax+14h], ecx
loc_D4980:
mov rax, [rsp+28h+var_18]
mov eax, [rax+14h]
mov [rsp+28h+var_1C], eax
call _ZNSt11char_traitsIcE3eofEv; std::char_traits<char>::eof(void)
mov ecx, eax
mov eax, [rsp+28h+var_1C]
cmp eax, ecx
setnz al
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_D49A6
jmp short loc_D49D1
loc_D49A6:
mov rdi, [rsp+28h+var_18]
mov rax, rdi
add rax, 38h ; '8'
mov [rsp+28h+var_28], rax
add rdi, 14h
call _ZNSt11char_traitsIcE12to_char_typeERKi; std::char_traits<char>::to_char_type(int const&)
mov rdi, [rsp+28h+var_28]
mov [rsp+28h+var_9], al
lea rsi, [rsp+28h+var_9]
call _ZNSt6vectorIcSaIcEE9push_backEOc; std::vector<char>::push_back(char &&)
loc_D49D1:
mov rax, [rsp+28h+var_18]
cmp dword ptr [rax+14h], 0Ah
jnz short loc_D49F5
mov rax, [rsp+28h+var_18]
mov rcx, [rax+30h]
add rcx, 1
mov [rax+30h], rcx
mov qword ptr [rax+28h], 0
loc_D49F5:
mov rax, [rsp+28h+var_18]
mov eax, [rax+14h]
add rsp, 28h
retn
| long long nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get(
long long a1)
{
int v2; // [rsp+Ch] [rbp-1Ch]
char v3; // [rsp+1Fh] [rbp-9h] BYREF
long long v4; // [rsp+20h] [rbp-8h]
v4 = a1;
++*(_QWORD *)(a1 + 32);
++*(_QWORD *)(a1 + 40);
if ( (*(_BYTE *)(a1 + 24) & 1) != 0 )
*(_BYTE *)(a1 + 24) = 0;
else
*(_DWORD *)(a1 + 20) = nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>::get_character(a1);
v2 = *(_DWORD *)(a1 + 20);
if ( v2 != (unsigned int)std::char_traits<char>::eof() )
{
v3 = std::char_traits<char>::to_char_type(a1 + 20);
std::vector<char>::push_back(a1 + 56, (long long)&v3);
}
if ( *(_DWORD *)(a1 + 20) == 10 )
{
++*(_QWORD *)(a1 + 48);
*(_QWORD *)(a1 + 40) = 0LL;
}
return *(unsigned int *)(a1 + 20);
}
| get:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV RCX,qword ptr [RAX + 0x20]
ADD RCX,0x1
MOV qword ptr [RAX + 0x20],RCX
MOV RCX,qword ptr [RAX + 0x28]
ADD RCX,0x1
MOV qword ptr [RAX + 0x28],RCX
TEST byte ptr [RAX + 0x18],0x1
JZ 0x001d496c
MOV RAX,qword ptr [RSP + 0x10]
MOV byte ptr [RAX + 0x18],0x0
JMP 0x001d4980
LAB_001d496c:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001d4ab0
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RAX + 0x14],ECX
LAB_001d4980:
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RSP + 0xc],EAX
CALL 0x001d3350
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0xc]
CMP EAX,ECX
SETNZ AL
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x001d49a6
JMP 0x001d49d1
LAB_001d49a6:
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,RDI
ADD RAX,0x38
MOV qword ptr [RSP],RAX
ADD RDI,0x14
CALL 0x001d4b20
MOV RDI,qword ptr [RSP]
MOV byte ptr [RSP + 0x1f],AL
LEA RSI,[RSP + 0x1f]
CALL 0x0019fbd0
LAB_001d49d1:
MOV RAX,qword ptr [RSP + 0x10]
CMP dword ptr [RAX + 0x14],0xa
JNZ 0x001d49f5
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RAX + 0x30]
ADD RCX,0x1
MOV qword ptr [RAX + 0x30],RCX
MOV qword ptr [RAX + 0x28],0x0
LAB_001d49f5:
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX + 0x14]
ADD RSP,0x28
RET
|
/* nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> > >, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*> >::get() */
int4 __thiscall
nlohmann::json_abi_v3_11_2::detail::
lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
::get(lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
*this)
{
int iVar1;
int4 uVar2;
int iVar3;
char local_9;
lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
*local_8;
*(long *)(this + 0x20) = *(long *)(this + 0x20) + 1;
*(long *)(this + 0x28) = *(long *)(this + 0x28) + 1;
local_8 = this;
if (((byte)this[0x18] & 1) == 0) {
uVar2 = iterator_input_adapter<char_const*>::get_character
((iterator_input_adapter<char_const*> *)this);
*(int4 *)(this + 0x14) = uVar2;
}
else {
this[0x18] = (lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
)0x0;
}
iVar1 = *(int *)(this + 0x14);
iVar3 = std::char_traits<char>::eof();
if (iVar1 != iVar3) {
local_9 = std::char_traits<char>::to_char_type((int *)(this + 0x14));
std::vector<char,std::allocator<char>>::push_back
((vector<char,std::allocator<char>> *)(this + 0x38),&local_9);
}
if (*(int *)(this + 0x14) == 10) {
*(long *)(this + 0x30) = *(long *)(this + 0x30) + 1;
*(int8 *)(this + 0x28) = 0;
}
return *(int4 *)(this + 0x14);
}
|
|
3,292 | nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get() | 7CodeWizard[P]stablediffusion/thirdparty/json.hpp | char_int_type get()
{
++position.chars_read_total;
++position.chars_read_current_line;
if (next_unget)
{
// just reset the next_unget variable and work with current
next_unget = false;
}
else
{
current = ia.get_character();
}
if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
{
token_string.push_back(std::char_traits<char_type>::to_char_type(current));
}
if (current == '\n')
{
++position.lines_read;
position.chars_read_current_line = 0;
}
return current;
} | O2 | cpp | nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get():
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movdqu 0x20(%rdi), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x20(%rdi)
cmpb $0x1, 0x18(%rdi)
jne 0x4ec81
movb $0x0, 0x18(%rbx)
movl 0x14(%rbx), %eax
jmp 0x4ec96
movq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
je 0x4ecc9
movzbl (%rcx), %eax
incq %rcx
movq %rcx, (%rbx)
movl %eax, 0x14(%rbx)
cmpl $-0x1, %eax
je 0x4ecc5
leaq 0x38(%rbx), %rdi
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
callq 0x3ed36
movl 0x14(%rbx), %eax
cmpl $0xa, %eax
jne 0x4ecbf
incq 0x30(%rbx)
andq $0x0, 0x28(%rbx)
pushq $0xa
popq %rax
addq $0x10, %rsp
popq %rbx
retq
pushq $-0x1
jmp 0x4ecbe
pushq $-0x1
popq %rax
jmp 0x4ec93
| _ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEE3getEv:
push rbx
sub rsp, 10h
mov rbx, rdi
movdqu xmm0, xmmword ptr [rdi+20h]
pcmpeqd xmm1, xmm1
psubq xmm0, xmm1
movdqu xmmword ptr [rdi+20h], xmm0
cmp byte ptr [rdi+18h], 1
jnz short loc_4EC81
mov byte ptr [rbx+18h], 0
mov eax, [rbx+14h]
jmp short loc_4EC96
loc_4EC81:
mov rcx, [rbx]
cmp rcx, [rbx+8]
jz short loc_4ECC9
movzx eax, byte ptr [rcx]
inc rcx
mov [rbx], rcx
loc_4EC93:
mov [rbx+14h], eax
loc_4EC96:
cmp eax, 0FFFFFFFFh
jz short loc_4ECC5
lea rdi, [rbx+38h]
lea rsi, [rsp+18h+var_9]
mov [rsi], al
call _ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
mov eax, [rbx+14h]
cmp eax, 0Ah
jnz short loc_4ECBF
inc qword ptr [rbx+30h]
and qword ptr [rbx+28h], 0
push 0Ah
loc_4ECBE:
pop rax
loc_4ECBF:
add rsp, 10h
pop rbx
retn
loc_4ECC5:
push 0FFFFFFFFFFFFFFFFh
jmp short loc_4ECBE
loc_4ECC9:
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_4EC93
| long long nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get(
__m128i *a1)
{
int v1; // eax
unsigned __int8 *v2; // rcx
long long result; // rax
_BYTE v5[9]; // [rsp+Fh] [rbp-9h] BYREF
a1[2] = _mm_sub_epi64(_mm_loadu_si128(a1 + 2), (__m128i)-1LL);
if ( a1[1].m128i_i8[8] == 1 )
{
a1[1].m128i_i8[8] = 0;
v1 = a1[1].m128i_i32[1];
}
else
{
v2 = (unsigned __int8 *)a1->m128i_i64[0];
if ( a1->m128i_i64[0] == a1->m128i_i64[1] )
{
v1 = -1;
}
else
{
v1 = *v2;
a1->m128i_i64[0] = (long long)(v2 + 1);
}
a1[1].m128i_i32[1] = v1;
}
if ( v1 == -1 )
return -1LL;
v5[0] = v1;
std::vector<char>::emplace_back<char>((long long)&a1[3].m128i_i64[1], v5);
result = a1[1].m128i_u32[1];
if ( (_DWORD)result != 10 )
return result;
++a1[3].m128i_i64[0];
a1[2].m128i_i64[1] = 0LL;
return 10LL;
}
| get:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOVDQU XMM0,xmmword ptr [RDI + 0x20]
PCMPEQD XMM1,XMM1
PSUBQ XMM0,XMM1
MOVDQU xmmword ptr [RDI + 0x20],XMM0
CMP byte ptr [RDI + 0x18],0x1
JNZ 0x0014ec81
MOV byte ptr [RBX + 0x18],0x0
MOV EAX,dword ptr [RBX + 0x14]
JMP 0x0014ec96
LAB_0014ec81:
MOV RCX,qword ptr [RBX]
CMP RCX,qword ptr [RBX + 0x8]
JZ 0x0014ecc9
MOVZX EAX,byte ptr [RCX]
INC RCX
MOV qword ptr [RBX],RCX
LAB_0014ec93:
MOV dword ptr [RBX + 0x14],EAX
LAB_0014ec96:
CMP EAX,-0x1
JZ 0x0014ecc5
LEA RDI,[RBX + 0x38]
LEA RSI,[RSP + 0xf]
MOV byte ptr [RSI],AL
CALL 0x0013ed36
MOV EAX,dword ptr [RBX + 0x14]
CMP EAX,0xa
JNZ 0x0014ecbf
INC qword ptr [RBX + 0x30]
AND qword ptr [RBX + 0x28],0x0
PUSH 0xa
LAB_0014ecbe:
POP RAX
LAB_0014ecbf:
ADD RSP,0x10
POP RBX
RET
LAB_0014ecc5:
PUSH -0x1
JMP 0x0014ecbe
LAB_0014ecc9:
PUSH -0x1
POP RAX
JMP 0x0014ec93
|
/* nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> > >, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*> >::get() */
ulong __thiscall
nlohmann::json_abi_v3_11_2::detail::
lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
::get(lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
*this)
{
byte *pbVar1;
uint uVar2;
ulong uStack_20;
char local_9;
*(long *)(this + 0x20) = *(long *)(this + 0x20) + 1;
*(long *)(this + 0x28) = *(long *)(this + 0x28) + 1;
if (this[0x18] ==
(lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
)0x1) {
this[0x18] = (lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
)0x0;
uVar2 = *(uint *)(this + 0x14);
}
else {
pbVar1 = *(byte **)this;
if (pbVar1 == *(byte **)(this + 8)) {
uVar2 = 0xffffffff;
}
else {
uVar2 = (uint)*pbVar1;
*(byte **)this = pbVar1 + 1;
}
*(uint *)(this + 0x14) = uVar2;
}
if (uVar2 == 0xffffffff) {
uStack_20 = 0xffffffffffffffff;
}
else {
local_9 = (char)uVar2;
std::vector<char,std::allocator<char>>::emplace_back<char>
((vector<char,std::allocator<char>> *)(this + 0x38),&local_9);
uStack_20 = (ulong)*(uint *)(this + 0x14);
if (*(uint *)(this + 0x14) == 10) {
*(long *)(this + 0x30) = *(long *)(this + 0x30) + 1;
*(int8 *)(this + 0x28) = 0;
uStack_20 = 10;
}
}
return uStack_20;
}
|
|
3,293 | nlohmann::json_abi_v3_11_3::detail::other_error nlohmann::json_abi_v3_11_3::detail::other_error::create<std::nullptr_t, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t) | monkey531[P]llama/common/json.hpp | static other_error create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::other_error nlohmann::json_abi_v3_11_3::detail::other_error::create<std::nullptr_t, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t):
subq $0xd8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xd0(%rsp)
movl %esi, 0xcc(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5a080
movq 0x18(%rsp), %rdx
leaq 0x16bcb0(%rip), %rsi # 0x20e70e
leaq 0x58(%rsp), %rdi
callq 0x62ae0
jmp 0xa2a6a
movl 0xcc(%rsp), %edx
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xa45a0
jmp 0xa2a82
xorl %eax, %eax
movl %eax, %esi
leaq 0x20(%rsp), %rdi
callq 0xa4640
jmp 0xa2a92
movq 0xc0(%rsp), %rcx
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xa44e0
jmp 0xa2ab3
leaq 0x20(%rsp), %rdi
callq 0x5a4d8
leaq 0x78(%rsp), %rdi
callq 0x5a4d8
leaq 0x58(%rsp), %rdi
callq 0x5a4d8
leaq 0x57(%rsp), %rdi
callq 0x5a4b0
movl 0xcc(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x591b0
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movq %rax, %rdx
callq 0xa46c0
jmp 0xa2b06
leaq 0x98(%rsp), %rdi
callq 0x5a4d8
movq 0x10(%rsp), %rax
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xa2b7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xa2b72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xa2b68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x5a4d8
leaq 0x78(%rsp), %rdi
callq 0x5a4d8
leaq 0x58(%rsp), %rdi
callq 0x5a4d8
leaq 0x57(%rsp), %rdi
callq 0x5a4b0
jmp 0xa2ba3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x5a4d8
movq 0x48(%rsp), %rdi
callq 0x59b90
nopl (%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail11other_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_:
sub rsp, 0D8h
mov [rsp+0D8h+var_D0], rdi; int
mov rax, rdi
mov qword ptr [rsp+0D8h+var_C8], rax; int
mov [rsp+0D8h+var_8], rdi
mov [rsp+0D8h+var_C], esi
mov qword ptr [rsp+0D8h+var_18], rdx
mov [rsp+0D8h+var_20], rcx
lea rdi, [rsp+0D8h+var_81]
mov qword ptr [rsp+0D8h+var_C0], rdi; int
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, qword ptr [rsp+0D8h+var_C0]
lea rsi, aOtherError; "other_error"
lea rdi, [rsp+0D8h+var_81+1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_A2A6A:
mov edx, [rsp+0D8h+var_C]
lea rdi, [rsp+0D8h+var_60]; int
lea rsi, [rsp+0D8h+var_81+1]
call _ZN8nlohmann16json_abi_v3_11_36detail9exception4nameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi; nlohmann::json_abi_v3_11_3::detail::exception::name(std::string const&,int)
jmp short $+2
loc_A2A82:
xor eax, eax
mov esi, eax
lea rdi, [rsp+0D8h+var_B8]
call _ZN8nlohmann16json_abi_v3_11_36detail9exception11diagnosticsB5cxx11EDn; nlohmann::json_abi_v3_11_3::detail::exception::diagnostics(decltype(nullptr))
jmp short $+2
loc_A2A92:
mov rcx, qword ptr [rsp+0D8h+var_18]; int
lea rdi, [rsp+0D8h+var_40]; int
lea rsi, [rsp+0D8h+var_60]; int
lea rdx, [rsp+0D8h+var_B8]; int
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJS8_S8_RKS8_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,std::string,std::string const&>(std::string,std::string,std::string const&)
jmp short $+2
loc_A2AB3:
lea rdi, [rsp+0D8h+var_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+0D8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+0D8h+var_81+1]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+0D8h+var_81]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov eax, [rsp+0D8h+var_C]
mov [rsp+0D8h+var_D4], eax
lea rdi, [rsp+0D8h+var_40]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, [rsp+0D8h+var_D0]; this
mov esi, [rsp+0D8h+var_D4]; int
mov rdx, rax; char *
call _ZN8nlohmann16json_abi_v3_11_36detail11other_errorC2EiPKc; nlohmann::json_abi_v3_11_3::detail::other_error::other_error(int,char const*)
jmp short $+2
loc_A2B06:
lea rdi, [rsp+0D8h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, qword ptr [rsp+0D8h+var_C8]
add rsp, 0D8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
jmp short loc_A2B7C
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
jmp short loc_A2B72
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
jmp short loc_A2B68
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
lea rdi, [rsp+arg_18]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_A2B68:
lea rdi, [rsp+arg_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_A2B72:
lea rdi, [rsp+arg_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_A2B7C:
lea rdi, [rsp+arg_4F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_A2BA3
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
lea rdi, [rsp+arg_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_A2BA3:
mov rdi, [rsp+arg_40]
call __Unwind_Resume
| long long ZN8nlohmann16json_abi_v3_11_36detail11other_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_(
long long a1,
long long a2,
long long a3,
long long a4)
{
int v4; // edx
int v5; // ecx
int v6; // r8d
int v7; // r9d
int v8; // r8d
int v9; // r9d
const char *v10; // rax
int v12; // [rsp+0h] [rbp-D8h]
int v13; // [rsp+0h] [rbp-D8h]
void *v14; // [rsp+0h] [rbp-D8h]
int v15; // [rsp+4h] [rbp-D4h]
int v16; // [rsp+8h] [rbp-D0h]
int v17; // [rsp+8h] [rbp-D0h]
nlohmann::json_abi_v3_11_3::detail::other_error *v18; // [rsp+8h] [rbp-D0h]
int v19; // [rsp+10h] [rbp-C8h]
int v20; // [rsp+10h] [rbp-C8h]
int v21[2]; // [rsp+10h] [rbp-C8h]
int v22; // [rsp+18h] [rbp-C0h]
int v23; // [rsp+18h] [rbp-C0h]
long long v24; // [rsp+20h] [rbp-B8h] BYREF
int v25; // [rsp+28h] [rbp-B0h]
int v26[8]; // [rsp+57h] [rbp-81h] BYREF
int v27[8]; // [rsp+78h] [rbp-60h] BYREF
int v28[8]; // [rsp+98h] [rbp-40h] BYREF
long long v29; // [rsp+B8h] [rbp-20h]
int v30[3]; // [rsp+C0h] [rbp-18h]
int v31; // [rsp+CCh] [rbp-Ch]
long long v32; // [rsp+D0h] [rbp-8h]
v32 = a1;
v31 = a2;
*(_QWORD *)v30 = a3;
v29 = a4;
std::allocator<char>::allocator(v26, a2);
std::string::basic_string<std::allocator<char>>((long long)v26 + 1, (long long)"other_error", (long long)v26);
nlohmann::json_abi_v3_11_3::detail::exception::name((int)v27, v12, a1, a1, (int)v26, v24, v25);
nlohmann::json_abi_v3_11_3::detail::exception::diagnostics[abi:cxx11](
(unsigned int)&v24,
0,
v4,
v5,
v6,
v7,
v13,
v16,
v19,
v22,
v24,
v25);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,std::string,std::string const&>(
(int)v28,
(int)v27,
(int)&v24,
v30[0],
v8,
v9,
v14,
v17,
v20,
v23,
v24);
std::string::~string(&v24);
std::string::~string(v27);
std::string::~string((char *)v26 + 1);
std::allocator<char>::~allocator(v26);
v15 = v31;
v10 = (const char *)std::string::c_str(v28);
nlohmann::json_abi_v3_11_3::detail::other_error::other_error(v18, v15, v10);
std::string::~string(v28);
return *(_QWORD *)v21;
}
| _ZN8nlohmann16json_abi_v3_11_36detail11other_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_:
SUB RSP,0xd8
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0xd0],RDI
MOV dword ptr [RSP + 0xcc],ESI
MOV qword ptr [RSP + 0xc0],RDX
MOV qword ptr [RSP + 0xb8],RCX
LEA RDI,[RSP + 0x57]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x0015a080
MOV RDX,qword ptr [RSP + 0x18]
LAB_001a2a57:
LEA RSI,[0x30e70e]
LEA RDI,[RSP + 0x58]
CALL 0x00162ae0
JMP 0x001a2a6a
LAB_001a2a6a:
MOV EDX,dword ptr [RSP + 0xcc]
LAB_001a2a71:
LEA RDI,[RSP + 0x78]
LEA RSI,[RSP + 0x58]
CALL 0x001a45a0
JMP 0x001a2a82
LAB_001a2a82:
XOR EAX,EAX
MOV ESI,EAX
LEA RDI,[RSP + 0x20]
CALL 0x001a4640
JMP 0x001a2a92
LAB_001a2a92:
MOV RCX,qword ptr [RSP + 0xc0]
LAB_001a2a9a:
LEA RDI,[RSP + 0x98]
LEA RSI,[RSP + 0x78]
LEA RDX,[RSP + 0x20]
CALL 0x001a44e0
JMP 0x001a2ab3
LAB_001a2ab3:
LEA RDI,[RSP + 0x20]
CALL 0x0015a4d8
LEA RDI,[RSP + 0x78]
CALL 0x0015a4d8
LEA RDI,[RSP + 0x58]
CALL 0x0015a4d8
LEA RDI,[RSP + 0x57]
CALL 0x0015a4b0
MOV EAX,dword ptr [RSP + 0xcc]
MOV dword ptr [RSP + 0x4],EAX
LEA RDI,[RSP + 0x98]
CALL 0x001591b0
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RSP + 0x4]
MOV RDX,RAX
LAB_001a2aff:
CALL 0x001a46c0
LAB_001a2b04:
JMP 0x001a2b06
LAB_001a2b06:
LEA RDI,[RSP + 0x98]
CALL 0x0015a4d8
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0xd8
RET
|
other_error *
_ZN8nlohmann16json_abi_v3_11_36detail11other_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
(other_error *param_1,int param_2,string *param_3,int8 param_4)
{
int iVar1;
char *pcVar2;
exception local_b8 [55];
allocator local_81;
string local_80 [32];
exception local_60 [32];
detail local_40 [32];
int8 local_20;
string *local_18;
int local_c;
other_error *local_8;
local_20 = param_4;
local_18 = param_3;
local_c = param_2;
local_8 = param_1;
std::allocator<char>::allocator();
/* try { // try from 001a2a57 to 001a2a67 has its CatchHandler @ 001a2b20 */
std::__cxx11::string::string<std::allocator<char>>(local_80,"other_error",&local_81);
/* try { // try from 001a2a71 to 001a2a7f has its CatchHandler @ 001a2b30 */
nlohmann::json_abi_v3_11_3::detail::exception::name(local_60,local_80,local_c);
/* try { // try from 001a2a82 to 001a2a8f has its CatchHandler @ 001a2b40 */
nlohmann::json_abi_v3_11_3::detail::exception::diagnostics_abi_cxx11_
(local_b8,(_func_decltype_nullptr *)0x0);
/* try { // try from 001a2a9a to 001a2ab0 has its CatchHandler @ 001a2b50 */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,std::__cxx11::string,std::__cxx11::string,std::__cxx11::string_const&>
(local_40,(string *)local_60,(string *)local_b8,local_18);
std::__cxx11::string::~string((string *)local_b8);
std::__cxx11::string::~string((string *)local_60);
std::__cxx11::string::~string(local_80);
std::allocator<char>::~allocator((allocator<char> *)&local_81);
iVar1 = local_c;
pcVar2 = (char *)std::__cxx11::string::c_str();
/* try { // try from 001a2aff to 001a2b03 has its CatchHandler @ 001a2b88 */
nlohmann::json_abi_v3_11_3::detail::other_error::other_error(param_1,iVar1,pcVar2);
std::__cxx11::string::~string((string *)local_40);
return param_1;
}
|
|
3,294 | get_current_logfile | eloqsql/storage/maria/ma_loghandler.c | static TRANSLOG_FILE *get_current_logfile()
{
TRANSLOG_FILE *file;
DBUG_ENTER("get_current_logfile");
mysql_rwlock_rdlock(&log_descriptor.open_files_lock);
DBUG_PRINT("info", ("max_file: %lu min_file: %lu open_files: %lu",
(ulong) log_descriptor.max_file,
(ulong) log_descriptor.min_file,
(ulong) log_descriptor.open_files.elements));
DBUG_ASSERT(log_descriptor.max_file - log_descriptor.min_file + 1 ==
log_descriptor.open_files.elements);
file= *dynamic_element(&log_descriptor.open_files, 0, TRANSLOG_FILE **);
mysql_rwlock_unlock(&log_descriptor.open_files_lock);
DBUG_RETURN(file);
} | O0 | c | get_current_logfile:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x43dfd1(%rip), %rdi # 0x478c70
addq $0x258, %rdi # imm = 0x258
leaq 0x1169d5(%rip), %rsi # 0x151682
movl $0x43f, %edx # imm = 0x43F
callq 0x368d0
jmp 0x3acb9
jmp 0x3acbb
jmp 0x3acbd
movq 0x43e1d4(%rip), %rax # 0x478e98
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0x43df9e(%rip), %rdi # 0x478c70
addq $0x258, %rdi # imm = 0x258
callq 0x35760
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
| get_current_logfile:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rdi, log_descriptor
add rdi, 258h
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 43Fh
call inline_mysql_rwlock_rdlock
jmp short $+2
loc_3ACB9:
jmp short $+2
loc_3ACBB:
jmp short $+2
loc_3ACBD:
mov rax, cs:qword_478E98
mov rax, [rax]
mov [rbp+var_8], rax
lea rdi, log_descriptor
add rdi, 258h
call inline_mysql_rwlock_unlock
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
add rsp, 10h
pop rbp
retn
| long long get_current_logfile()
{
long long v1; // [rsp+8h] [rbp-8h]
inline_mysql_rwlock_rdlock(
(long long)&log_descriptor[75],
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x43Fu);
v1 = *(_QWORD *)qword_478E98;
inline_mysql_rwlock_unlock((long long)&log_descriptor[75]);
return v1;
}
| get_current_logfile:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RDI,[0x578c70]
ADD RDI,0x258
LEA RSI,[0x251682]
MOV EDX,0x43f
CALL 0x001368d0
JMP 0x0013acb9
LAB_0013acb9:
JMP 0x0013acbb
LAB_0013acbb:
JMP 0x0013acbd
LAB_0013acbd:
MOV RAX,qword ptr [0x00578e98]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
LEA RDI,[0x578c70]
ADD RDI,0x258
CALL 0x00135760
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RSP,0x10
POP RBP
RET
|
int8 get_current_logfile(void)
{
int8 uVar1;
inline_mysql_rwlock_rdlock
(&DAT_00578ec8,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x43f);
uVar1 = *DAT_00578e98;
inline_mysql_rwlock_unlock(&DAT_00578ec8);
return uVar1;
}
|
|
3,295 | get_current_logfile | eloqsql/storage/maria/ma_loghandler.c | static TRANSLOG_FILE *get_current_logfile()
{
TRANSLOG_FILE *file;
DBUG_ENTER("get_current_logfile");
mysql_rwlock_rdlock(&log_descriptor.open_files_lock);
DBUG_PRINT("info", ("max_file: %lu min_file: %lu open_files: %lu",
(ulong) log_descriptor.max_file,
(ulong) log_descriptor.min_file,
(ulong) log_descriptor.open_files.elements));
DBUG_ASSERT(log_descriptor.max_file - log_descriptor.min_file + 1 ==
log_descriptor.open_files.elements);
file= *dynamic_element(&log_descriptor.open_files, 0, TRANSLOG_FILE **);
mysql_rwlock_unlock(&log_descriptor.open_files_lock);
DBUG_RETURN(file);
} | O3 | c | get_current_logfile:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0x3c494a(%rip) # 0x3fe1d8
jne 0x398c8
leaq 0x3c48b1(%rip), %rdi # 0x3fe148
callq 0xa43bc
movq 0x3c4875(%rip), %rax # 0x3fe118
movq (%rax), %rbx
movq 0x3c492b(%rip), %rdi # 0x3fe1d8
testq %rdi, %rdi
jne 0x398cf
leaq 0x3c488f(%rip), %rdi # 0x3fe148
callq 0xa44ea
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2c2da
jmp 0x3989c
leaq 0x34c73a(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x168(%rax)
jmp 0x398b2
nopl (%rax)
| get_current_logfile:
push rbp
mov rbp, rsp
push rbx
push rax
cmp cs:qword_3FE1D8, 0
jnz short loc_398C8
lea rdi, unk_3FE148
call my_rw_rdlock
loc_3989C:
mov rax, cs:qword_3FE118
mov rbx, [rax]
mov rdi, cs:qword_3FE1D8
test rdi, rdi
jnz short loc_398CF
loc_398B2:
lea rdi, unk_3FE148
call my_rw_unlock
mov rax, rbx
add rsp, 8
pop rbx
pop rbp
retn
loc_398C8:
call get_current_logfile_cold_1
jmp short loc_3989C
loc_398CF:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+168h]
jmp short loc_398B2
| long long get_current_logfile(long long a1)
{
long long v1; // rbx
if ( qword_3FE1D8 )
get_current_logfile_cold_1(a1);
else
my_rw_rdlock(&unk_3FE148);
v1 = *(_QWORD *)qword_3FE118;
if ( qword_3FE1D8 )
((void ( *)(long long))PSI_server[45])(qword_3FE1D8);
my_rw_unlock(&unk_3FE148);
return v1;
}
| get_current_logfile:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
CMP qword ptr [0x004fe1d8],0x0
JNZ 0x001398c8
LEA RDI,[0x4fe148]
CALL 0x001a43bc
LAB_0013989c:
MOV RAX,qword ptr [0x004fe118]
MOV RBX,qword ptr [RAX]
MOV RDI,qword ptr [0x004fe1d8]
TEST RDI,RDI
JNZ 0x001398cf
LAB_001398b2:
LEA RDI,[0x4fe148]
CALL 0x001a44ea
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001398c8:
CALL 0x0012c2da
JMP 0x0013989c
LAB_001398cf:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x001398b2
|
int8 get_current_logfile(void)
{
int8 uVar1;
if (DAT_004fe1d8 == 0) {
my_rw_rdlock(&DAT_004fe148);
}
else {
get_current_logfile_cold_1();
}
uVar1 = *DAT_004fe118;
if (DAT_004fe1d8 != 0) {
(**(code **)(PSI_server + 0x168))();
}
my_rw_unlock(&DAT_004fe148);
return uVar1;
}
|
|
3,296 | ftxui::CheckboxOption::Simple() | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/component/component_options.cpp | CheckboxOption CheckboxOption::Simple() {
auto option = CheckboxOption();
option.transform = [](const EntryState& s) {
#if defined(FTXUI_MICROSOFT_TERMINAL_FALLBACK)
// Microsoft terminal do not use fonts able to render properly the default
// radiobox glyph.
auto prefix = text(s.state ? "[X] " : "[ ] "); // NOLINT
#else
auto prefix = text(s.state ? "▣ " : "☐ "); // NOLINT
#endif
auto t = text(s.label);
if (s.active) {
t |= bold;
}
if (s.focused) {
t |= inverted;
}
return hbox({prefix, t});
};
return option;
} | O1 | cpp | ftxui::CheckboxOption::Simple():
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x70(%rdi)
leaq 0xb1a0(%rip), %rsi # 0x40099
callq 0x371d0
xorl %eax, %eax
movb %al, 0x28(%rbx)
movb %al, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
leaq 0x2384(%rip), %rax # 0x372a0
movq %rax, 0x70(%rbx)
leaq 0x237b(%rip), %rax # 0x372a2
movq %rax, 0x68(%rbx)
movaps %xmm0, (%rsp)
leaq 0x1298(%rip), %rcx # 0x361ce
movq %rcx, 0x18(%rsp)
leaq 0x15d4(%rip), %rdx # 0x36516
movq %rdx, 0x10(%rsp)
movups %xmm0, 0x38(%rbx)
movq 0x48(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %rdx, 0x48(%rbx)
movq 0x50(%rbx), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x50(%rbx)
testq %rax, %rax
je 0x34f77
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x106a9
| _ZN5ftxui14CheckboxOption6SimpleEv:
push rbx
sub rsp, 20h
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+60h], xmm0
movups xmmword ptr [rdi+50h], xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+70h], 0
lea rsi, aCheckbox; "Checkbox"
call _ZN5ftxui14ConstStringRefC2EPKc; ftxui::ConstStringRef::ConstStringRef(char const*)
xor eax, eax
mov [rbx+28h], al
mov [rbx+30h], al
xorps xmm0, xmm0
movups xmmword ptr [rbx+38h], xmm0
movups xmmword ptr [rbx+48h], xmm0
movups xmmword ptr [rbx+58h], xmm0
lea rax, _ZNSt17_Function_handlerIFvvEN5ftxui14CheckboxOption9on_changeMUlvE_EE9_M_invokeERKSt9_Any_data
mov [rbx+70h], rax
lea rax, _ZNSt17_Function_handlerIFvvEN5ftxui14CheckboxOption9on_changeMUlvE_EE10_M_managerERSt9_Any_dataRKS6_St18_Manager_operation
mov [rbx+68h], rax
movaps [rsp+28h+var_28], xmm0
lea rcx, _ZNSt17_Function_handlerIFSt10shared_ptrIN5ftxui4NodeEERKNS1_10EntryStateEEZNS1_14CheckboxOption6SimpleEvE3$_0E9_M_invokeERKSt9_Any_dataS6_; std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::CheckboxOption::Simple(void)::$_0>::_M_invoke(std::_Any_data const&,ftxui::EntryState const&)
mov [rsp+28h+var_10], rcx
lea rdx, _ZNSt17_Function_handlerIFSt10shared_ptrIN5ftxui4NodeEERKNS1_10EntryStateEEZNS1_14CheckboxOption6SimpleEvE3$_0E10_M_managerERSt9_Any_dataRKSB_St18_Manager_operation; std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::CheckboxOption::Simple(void)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsp+28h+var_18], rdx
movups xmmword ptr [rbx+38h], xmm0
mov rax, [rbx+48h]
mov [rsp+28h+var_18], rax
mov [rbx+48h], rdx
mov rdx, [rbx+50h]
mov [rsp+28h+var_10], rdx
mov [rbx+50h], rcx
test rax, rax
jz short loc_34F77
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_34F77:
mov rax, rbx
add rsp, 20h
pop rbx
retn
mov rdi, rax
call __clang_call_terminate
| ftxui::CheckboxOption * ftxui::CheckboxOption::Simple(ftxui::CheckboxOption *this)
{
long long ( *v1)(); // rax
__int128 v3; // [rsp+0h] [rbp-28h] BYREF
long long ( *v4)(); // [rsp+10h] [rbp-18h]
long long ( *v5)(); // [rsp+18h] [rbp-10h]
*((_OWORD *)this + 6) = 0LL;
*((_OWORD *)this + 5) = 0LL;
*((_OWORD *)this + 4) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 1) = 0LL;
*(_OWORD *)this = 0LL;
*((_QWORD *)this + 14) = 0LL;
ftxui::ConstStringRef::ConstStringRef(this, "Checkbox");
*((_BYTE *)this + 40) = 0;
*((_BYTE *)this + 48) = 0;
*(_OWORD *)((char *)this + 56) = 0LL;
*(_OWORD *)((char *)this + 72) = 0LL;
*(_OWORD *)((char *)this + 88) = 0LL;
*((_QWORD *)this + 14) = ZNSt17_Function_handlerIFvvEN5ftxui14CheckboxOption9on_changeMUlvE_EE9_M_invokeERKSt9_Any_data;
*((_QWORD *)this + 13) = ZNSt17_Function_handlerIFvvEN5ftxui14CheckboxOption9on_changeMUlvE_EE10_M_managerERSt9_Any_dataRKS6_St18_Manager_operation;
v3 = 0LL;
v5 = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::CheckboxOption::Simple(void)::$_0>::_M_invoke;
v4 = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::CheckboxOption::Simple(void)::$_0>::_M_manager;
*(_OWORD *)((char *)this + 56) = 0LL;
v4 = (long long ( *)())*((_QWORD *)this + 9);
v1 = v4;
*((_QWORD *)this + 9) = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::CheckboxOption::Simple(void)::$_0>::_M_manager;
v5 = (long long ( *)())*((_QWORD *)this + 10);
*((_QWORD *)this + 10) = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::CheckboxOption::Simple(void)::$_0>::_M_invoke;
if ( v1 )
((void ( *)(__int128 *, __int128 *, long long))v1)(&v3, &v3, 3LL);
return this;
}
| Simple:
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x60],XMM0
MOVUPS xmmword ptr [RDI + 0x50],XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x70],0x0
LEA RSI,[0x140099]
CALL 0x001371d0
XOR EAX,EAX
MOV byte ptr [RBX + 0x28],AL
MOV byte ptr [RBX + 0x30],AL
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x38],XMM0
MOVUPS xmmword ptr [RBX + 0x48],XMM0
MOVUPS xmmword ptr [RBX + 0x58],XMM0
LEA RAX,[0x1372a0]
MOV qword ptr [RBX + 0x70],RAX
LEA RAX,[0x1372a2]
MOV qword ptr [RBX + 0x68],RAX
MOVAPS xmmword ptr [RSP],XMM0
LEA RCX,[0x1361ce]
MOV qword ptr [RSP + 0x18],RCX
LEA RDX,[0x136516]
MOV qword ptr [RSP + 0x10],RDX
MOVUPS xmmword ptr [RBX + 0x38],XMM0
MOV RAX,qword ptr [RBX + 0x48]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RBX + 0x48],RDX
MOV RDX,qword ptr [RBX + 0x50]
MOV qword ptr [RSP + 0x18],RDX
MOV qword ptr [RBX + 0x50],RCX
TEST RAX,RAX
JZ 0x00134f77
LAB_00134f6a:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_00134f77:
MOV RAX,RBX
ADD RSP,0x20
POP RBX
RET
|
/* ftxui::CheckboxOption::Simple() */
CheckboxOption * __thiscall ftxui::CheckboxOption::Simple(CheckboxOption *this)
{
int8 local_28;
int8 uStack_20;
code *local_18;
int8 local_10;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x70) = 0;
ConstStringRef::ConstStringRef((ConstStringRef *)this,"Checkbox");
this[0x28] = (CheckboxOption)0x0;
this[0x30] = (CheckboxOption)0x0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
*(code **)(this + 0x70) =
std::_Function_handler<void(),ftxui::CheckboxOption::on_change::{lambda()#1}>::_M_invoke;
*(code **)(this + 0x68) =
std::_Function_handler<void(),ftxui::CheckboxOption::on_change::{lambda()#1}>::_M_manager;
local_28 = 0;
uStack_20 = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
local_18 = *(code **)(this + 0x48);
*(code **)(this + 0x48) =
std::
_Function_handler<std::shared_ptr<ftxui::Node>(ftxui::EntryState_const&),ftxui::CheckboxOption::Simple()::$_0>
::_M_manager;
local_10 = *(int8 *)(this + 0x50);
*(code **)(this + 0x50) =
std::
_Function_handler<std::shared_ptr<ftxui::Node>(ftxui::EntryState_const&),ftxui::CheckboxOption::Simple()::$_0>
::_M_invoke;
if (local_18 != (code *)0x0) {
/* try { // try from 00134f6a to 00134f76 has its CatchHandler @ 00134f80 */
(*local_18)(&local_28,&local_28,3);
}
return this;
}
|
|
3,297 | common_log::resume() | monkey531[P]llama/common/log.cpp | void resume() {
std::lock_guard<std::mutex> lock(mtx);
if (running) {
return;
}
running = true;
thrd = std::thread([this]() {
while (true) {
{
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [this]() { return head != tail; });
cur = entries[head];
head = (head + 1) % entries.size();
}
if (cur.is_end) {
break;
}
cur.print(); // stdout and stderr
if (file) {
cur.print(file);
}
}
});
} | O1 | cpp | common_log::resume():
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x189b0
testl %eax, %eax
jne 0x80039
cmpb $0x0, 0x6a(%rbx)
jne 0x80029
movb $0x1, 0x6a(%rbx)
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x80864
cmpq $0x0, 0x28(%rbx)
jne 0x80040
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
callq 0x18520
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
callq 0x18470
callq 0x18180
movq %rax, %r14
movq %rbx, %rdi
callq 0x18520
movq %r14, %rdi
callq 0x18ba0
| _ZN10common_log6resumeEv:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
call _pthread_mutex_lock
test eax, eax
jnz short loc_80039
cmp byte ptr [rbx+6Ah], 0
jnz short loc_80029
mov byte ptr [rbx+6Ah], 1
lea rsi, [rsp+28h+var_18]
mov [rsi], rbx
lea rdi, [rsp+28h+var_20]
call _ZNSt6threadC2IZN10common_log6resumeEvEUlvE_JEvEEOT_DpOT0_
cmp qword ptr [rbx+28h], 0
jnz short loc_80040
mov rax, [rsp+28h+var_20]
mov [rbx+28h], rax
loc_80029:
mov rdi, rbx
call _pthread_mutex_unlock
add rsp, 18h
pop rbx
pop r14
retn
loc_80039:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
loc_80040:
call __ZSt9terminatev; std::terminate(void)
mov r14, rax
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, r14
call __Unwind_Resume
| long long common_log::resume(common_log *this)
{
int v1; // eax
_QWORD v3[4]; // [rsp+8h] [rbp-20h] BYREF
v1 = pthread_mutex_lock();
if ( v1 )
std::__throw_system_error(v1);
if ( !*((_BYTE *)this + 106) )
{
*((_BYTE *)this + 106) = 1;
v3[1] = this;
ZNSt6threadC2IZN10common_log6resumeEvEUlvE_JEvEEOT_DpOT0_(v3);
if ( *((_QWORD *)this + 5) )
std::terminate();
*((_QWORD *)this + 5) = v3[0];
}
return pthread_mutex_unlock(this);
}
| resume:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
CALL 0x001189b0
TEST EAX,EAX
JNZ 0x00180039
CMP byte ptr [RBX + 0x6a],0x0
JNZ 0x00180029
MOV byte ptr [RBX + 0x6a],0x1
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],RBX
LAB_0018000f:
LEA RDI,[RSP + 0x8]
CALL 0x00180864
LAB_00180019:
CMP qword ptr [RBX + 0x28],0x0
JNZ 0x00180040
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x28],RAX
LAB_00180029:
MOV RDI,RBX
CALL 0x00118520
ADD RSP,0x18
POP RBX
POP R14
RET
LAB_00180039:
MOV EDI,EAX
CALL 0x00118470
LAB_00180040:
CALL 0x00118180
|
/* common_log::resume() */
void __thiscall common_log::resume(common_log *this)
{
int iVar1;
int8 local_20;
common_log *local_18;
iVar1 = pthread_mutex_lock((pthread_mutex_t *)this);
if (iVar1 != 0) {
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar1);
}
if (this[0x6a] == (common_log)0x0) {
this[0x6a] = (common_log)0x1;
/* try { // try from 0018000f to 00180018 has its CatchHandler @ 00180045 */
local_18 = this;
std::thread::thread<common_log::resume()::_lambda()_1_,,void>
((thread *)&local_20,(_lambda___1_ *)&local_18);
if (*(long *)(this + 0x28) != 0) {
/* WARNING: Subroutine does not return */
std::terminate();
}
*(int8 *)(this + 0x28) = local_20;
}
pthread_mutex_unlock((pthread_mutex_t *)this);
return;
}
|
|
3,298 | ma_bitmap_create_missing_into_pagecache | eloqsql/storage/maria/ma_bitmap.c | static my_bool
_ma_bitmap_create_missing_into_pagecache(MARIA_SHARE *share,
MARIA_FILE_BITMAP *bitmap,
pgcache_page_no_t from,
pgcache_page_no_t to,
uchar *zeroes)
{
pgcache_page_no_t i;
/*
We do not use my_chsize() because there can be a race between when it
reads the physical size and when it writes (assume data_file_length is 10,
physical length is 8 and two data pages are in cache, and here we do a
my_chsize: my_chsize sees physical length is 8, then the two data pages go
to disk then my_chsize writes from page 8 and so overwrites the two data
pages, wrongly).
We instead rely on the filesystem filling gaps with zeroes.
*/
for (i= from; i <= to; i+= bitmap->pages_covered)
{
/**
No need to keep them pinned, they are new so flushable.
@todo but we may want to keep them pinned, as an optimization: if they
are not pinned they may go to disk before the data pages go (so, the
physical pages would be in non-ascending "sparse" order on disk), or the
filesystem may fill gaps with zeroes physically which is a waste of
time.
*/
if (pagecache_write(share->pagecache,
&bitmap->file, i, 0,
zeroes, PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_LEFT_UNLOCKED,
PAGECACHE_PIN_LEFT_UNPINNED,
PAGECACHE_WRITE_DELAY, 0, LSN_IMPOSSIBLE))
goto err;
}
/*
Data pages after data_file_length are full of zeroes but that is allowed
as they are marked empty in the bitmap.
*/
return FALSE;
err:
_ma_set_fatal_error_with_share(share, my_errno);
return TRUE;
} | O3 | c | ma_bitmap_create_missing_into_pagecache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
xorl %r14d, %r14d
cmpq %rcx, %rdx
ja 0x420da
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
leaq 0x40(%rsi), %r15
movq -0x30(%rbp), %rax
movq 0x600(%rax), %rdi
movl 0x80(%rdi), %eax
movl %eax, 0x30(%rsp)
movl %r14d, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movl %r14d, 0x10(%rsp)
movl %r14d, (%rsp)
movl $0x1, 0x8(%rsp)
movq %r15, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
movq -0x38(%rbp), %r8
movl $0x1, %r9d
callq 0x33a9e
testb %al, %al
jne 0x420c7
addq 0x138(%rbx), %r13
cmpq %r12, %r13
jbe 0x42068
xorl %r14d, %r14d
jmp 0x420da
callq 0xa1b22
movl (%rax), %esi
movq -0x30(%rbp), %rdi
callq 0x36a82
movb $0x1, %r14b
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_bitmap_create_missing_into_pagecache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_38], r8
mov [rbp+var_30], rdi
xor r14d, r14d
cmp rdx, rcx
ja short loc_420DA
mov r12, rcx
mov r13, rdx
mov rbx, rsi
lea r15, [rsi+40h]
loc_42068:
mov rax, [rbp+var_30]
mov rdi, [rax+600h]
mov eax, [rdi+80h]
mov [rsp+70h+var_40], eax
mov [rsp+70h+var_48], r14d
xorps xmm0, xmm0
movups [rsp+70h+var_58], xmm0
mov [rsp+70h+var_60], r14d
mov [rsp+70h+var_70], r14d
mov [rsp+70h+var_68], 1
mov rsi, r15
mov rdx, r13
xor ecx, ecx
mov r8, [rbp+var_38]
mov r9d, 1
call pagecache_write_part
test al, al
jnz short loc_420C7
add r13, [rbx+138h]
cmp r13, r12
jbe short loc_42068
xor r14d, r14d
jmp short loc_420DA
loc_420C7:
call _my_thread_var
mov esi, [rax]
mov rdi, [rbp+var_30]
call _ma_set_fatal_error_with_share
mov r14b, 1
loc_420DA:
mov eax, r14d
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_bitmap_create_missing_into_pagecache(
long long a1,
long long a2,
unsigned long long a3,
unsigned long long a4,
char *a5)
{
unsigned int v5; // r14d
unsigned long long v7; // r13
char *v8; // r15
__m128i *v9; // rdi
long long v10; // rdx
long long v11; // rcx
long long v12; // r8
int *v13; // rax
long long v14; // rdx
long long v15; // rcx
long long v16; // r8
int v17; // r9d
v5 = 0;
if ( a3 <= a4 )
{
v7 = a3;
v8 = (char *)(a2 + 64);
while ( 1 )
{
v9 = *(__m128i **)(a1 + 1536);
if ( (unsigned __int8)pagecache_write_part(v9, v8, v7, 0, a5, 1, 0, 1u, 0, 0LL, 0LL, 0, v9[8].m128i_u32[0]) )
break;
v7 += *(_QWORD *)(a2 + 312);
if ( v7 > a4 )
return 0;
}
v13 = (int *)my_thread_var(v9, v8, v10, v11, v12);
ma_set_fatal_error_with_share(a1, *v13, v14, v15, v16, v17);
LOBYTE(v5) = 1;
}
return v5;
}
| _ma_bitmap_create_missing_into_pagecache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],R8
MOV qword ptr [RBP + -0x30],RDI
XOR R14D,R14D
CMP RDX,RCX
JA 0x001420da
MOV R12,RCX
MOV R13,RDX
MOV RBX,RSI
LEA R15,[RSI + 0x40]
LAB_00142068:
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x600]
MOV EAX,dword ptr [RDI + 0x80]
MOV dword ptr [RSP + 0x30],EAX
MOV dword ptr [RSP + 0x28],R14D
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV dword ptr [RSP + 0x10],R14D
MOV dword ptr [RSP],R14D
MOV dword ptr [RSP + 0x8],0x1
MOV RSI,R15
MOV RDX,R13
XOR ECX,ECX
MOV R8,qword ptr [RBP + -0x38]
MOV R9D,0x1
CALL 0x00133a9e
TEST AL,AL
JNZ 0x001420c7
ADD R13,qword ptr [RBX + 0x138]
CMP R13,R12
JBE 0x00142068
XOR R14D,R14D
JMP 0x001420da
LAB_001420c7:
CALL 0x001a1b22
MOV ESI,dword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00136a82
MOV R14B,0x1
LAB_001420da:
MOV EAX,R14D
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
_ma_bitmap_create_missing_into_pagecache
(long param_1,long param_2,ulong param_3,ulong param_4,int8 param_5)
{
char cVar1;
int4 *puVar2;
if (param_3 <= param_4) {
do {
cVar1 = pagecache_write_part
(*(long *)(param_1 + 0x600),param_2 + 0x40,param_3,0,param_5,1,0,1,0,0,0,0,
*(int4 *)(*(long *)(param_1 + 0x600) + 0x80));
if (cVar1 != '\0') {
puVar2 = (int4 *)_my_thread_var();
_ma_set_fatal_error_with_share(param_1,*puVar2);
return 1;
}
param_3 = param_3 + *(long *)(param_2 + 0x138);
} while (param_3 <= param_4);
}
return 0;
}
|
|
3,299 | is_let | bluesky950520[P]quickjs/quickjs.c | static int is_let(JSParseState *s, int decl_mask)
{
int res = FALSE;
if (token_is_pseudo_keyword(s, JS_ATOM_let)) {
JSParsePos pos;
js_parse_get_pos(s, &pos);
for (;;) {
if (next_token(s)) {
res = -1;
break;
}
if (s->token.val == '[') {
/* let [ is a syntax restriction:
it never introduces an ExpressionStatement */
res = TRUE;
break;
}
if (s->token.val == '{' ||
(s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved) ||
s->token.val == TOK_LET ||
s->token.val == TOK_YIELD ||
s->token.val == TOK_AWAIT) {
/* Check for possible ASI if not scanning for Declaration */
/* XXX: should also check that `{` introduces a BindingPattern,
but Firefox does not and rejects eval("let=1;let\n{if(1)2;}") */
if (s->last_line_num == s->token.line_num || (decl_mask & DECL_MASK_OTHER)) {
res = TRUE;
break;
}
break;
}
break;
}
if (js_parse_seek_token(s, &pos)) {
res = -1;
}
}
return res;
} | O2 | c | is_let:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x27
popq %rsi
callq 0x556da
testl %eax, %eax
je 0x5fb9c
movsd 0x24(%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movlhps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movaps %xmm1, (%rsp)
movq 0x30(%rbx), %rax
movq %rax, 0x18(%rsp)
movups 0x80(%rbx), %xmm0
movaps %xmm0, 0x20(%rsp)
movl 0x58(%rbx), %eax
movl %eax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x535fe
testl %eax, %eax
je 0x5fba0
pushq $-0x1
popq %r14
jmp 0x5fbe5
xorl %eax, %eax
jmp 0x5fbfb
movl 0x20(%rbx), %eax
leal 0x2f(%rax), %ecx
cmpl $0x7, %ecx
jbe 0x5fbc5
cmpl $0x7b, %eax
je 0x5fbcf
cmpl $0x5b, %eax
je 0x5fc04
xorl %r14d, %r14d
cmpl $-0x7d, %eax
jne 0x5fbe5
cmpl $0x0, 0x40(%rbx)
jne 0x5fbe5
jmp 0x5fbcf
movl $0xc1, %edx
btl %ecx, %edx
jae 0x5fbab
movl 0x8(%rbx), %eax
cmpl 0x24(%rbx), %eax
sete %al
andl $0x4, %ebp
shrl $0x2, %ebp
orb %al, %bpl
movzbl %bpl, %r14d
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x55688
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl %r14d, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x1
jmp 0x5fb98
| is_let:
push rbp
push r14
push rbx
sub rsp, 30h
mov ebp, esi
mov rbx, rdi
push 27h ; '''
pop rsi
call token_is_pseudo_keyword
test eax, eax
jz short loc_5FB9C
movsd xmm0, qword ptr [rbx+24h]
movsd xmm1, qword ptr [rbx+8]
movlhps xmm1, xmm0
movaps [rsp+48h+var_48], xmm1
mov rax, [rbx+30h]
mov [rsp+48h+var_30], rax
movups xmm0, xmmword ptr [rbx+80h]
movaps [rsp+48h+var_28], xmm0
mov eax, [rbx+58h]
mov [rsp+48h+var_38], eax
mov rdi, rbx
call next_token
test eax, eax
jz short loc_5FBA0
push 0FFFFFFFFFFFFFFFFh
loc_5FB98:
pop r14
jmp short loc_5FBE5
loc_5FB9C:
xor eax, eax
jmp short loc_5FBFB
loc_5FBA0:
mov eax, [rbx+20h]
lea ecx, [rax+2Fh]
cmp ecx, 7
jbe short loc_5FBC5
loc_5FBAB:
cmp eax, 7Bh ; '{'
jz short loc_5FBCF
cmp eax, 5Bh ; '['
jz short loc_5FC04
xor r14d, r14d
cmp eax, 0FFFFFF83h
jnz short loc_5FBE5
cmp dword ptr [rbx+40h], 0
jnz short loc_5FBE5
jmp short loc_5FBCF
loc_5FBC5:
mov edx, 0C1h
bt edx, ecx
jnb short loc_5FBAB
loc_5FBCF:
mov eax, [rbx+8]
cmp eax, [rbx+24h]
setz al
and ebp, 4
shr ebp, 2
or bpl, al
movzx r14d, bpl
loc_5FBE5:
mov rsi, rsp
mov rdi, rbx
call js_parse_seek_token
mov ecx, eax
xor eax, eax
neg ecx
sbb eax, eax
or eax, r14d
loc_5FBFB:
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_5FC04:
push 1
jmp short loc_5FB98
| long long is_let(
long long a1,
char a2,
double a3,
double a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // rdx
long long v11; // rcx
long long v12; // r8
long long v13; // r9
__m128 v14; // xmm4
__m128 v15; // xmm5
__m128 v16; // xmm1
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
__m128 v21; // xmm4
__m128 v22; // xmm5
int v23; // r14d
int v25; // eax
int v26; // [rsp-8h] [rbp-50h]
__m128 v27; // [rsp+0h] [rbp-48h] BYREF
int v28; // [rsp+10h] [rbp-38h]
long long v29; // [rsp+18h] [rbp-30h]
__m128 v30; // [rsp+20h] [rbp-28h]
if ( !token_is_pseudo_keyword((_DWORD *)a1, 39) )
return 0LL;
v16 = _mm_movelh_ps((__m128)*(unsigned long long *)(a1 + 8), (__m128)*(unsigned long long *)(a1 + 36));
v27 = v16;
v29 = *(_QWORD *)(a1 + 48);
v30 = *(__m128 *)(a1 + 128);
v28 = *(_DWORD *)(a1 + 88);
if ( !(unsigned int)next_token(a1, 39LL, v10, v30, v16, a5, a6, v14, v15, a9, a10, v11, v12, v13) )
{
v25 = *(_DWORD *)(a1 + 32);
v18 = (unsigned int)(v25 + 47);
if ( (unsigned int)v18 > 7 || (v17 = 193LL, !_bittest((const int *)&v17, v18)) )
{
if ( v25 != 123 )
{
if ( v25 == 91 )
{
v26 = 1;
goto LABEL_4;
}
v23 = 0;
if ( v25 != -125 || *(_DWORD *)(a1 + 64) )
return v23 | (unsigned int)-((unsigned int)js_parse_seek_token(
a1,
(long long)&v27,
v17,
v18,
v19,
v20,
*(double *)v30.m128_u64,
v16,
a5,
a6,
v21,
v22,
a9,
a10) != 0);
}
}
v23 = (*(_DWORD *)(a1 + 8) == *(_DWORD *)(a1 + 36)) | ((unsigned __int8)(a2 & 4) >> 2);
return v23 | (unsigned int)-((unsigned int)js_parse_seek_token(
a1,
(long long)&v27,
v17,
v18,
v19,
v20,
*(double *)v30.m128_u64,
v16,
a5,
a6,
v21,
v22,
a9,
a10) != 0);
}
v26 = -1;
LABEL_4:
v23 = v26;
return v23 | (unsigned int)-((unsigned int)js_parse_seek_token(
a1,
(long long)&v27,
v17,
v18,
v19,
v20,
*(double *)v30.m128_u64,
v16,
a5,
a6,
v21,
v22,
a9,
a10) != 0);
}
| is_let:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV EBP,ESI
MOV RBX,RDI
PUSH 0x27
POP RSI
CALL 0x001556da
TEST EAX,EAX
JZ 0x0015fb9c
MOVSD XMM0,qword ptr [RBX + 0x24]
MOVSD XMM1,qword ptr [RBX + 0x8]
MOVLHPS XMM1,XMM0
MOVAPS xmmword ptr [RSP],XMM1
MOV RAX,qword ptr [RBX + 0x30]
MOV qword ptr [RSP + 0x18],RAX
MOVUPS XMM0,xmmword ptr [RBX + 0x80]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV EAX,dword ptr [RBX + 0x58]
MOV dword ptr [RSP + 0x10],EAX
MOV RDI,RBX
CALL 0x001535fe
TEST EAX,EAX
JZ 0x0015fba0
PUSH -0x1
LAB_0015fb98:
POP R14
JMP 0x0015fbe5
LAB_0015fb9c:
XOR EAX,EAX
JMP 0x0015fbfb
LAB_0015fba0:
MOV EAX,dword ptr [RBX + 0x20]
LEA ECX,[RAX + 0x2f]
CMP ECX,0x7
JBE 0x0015fbc5
LAB_0015fbab:
CMP EAX,0x7b
JZ 0x0015fbcf
CMP EAX,0x5b
JZ 0x0015fc04
XOR R14D,R14D
CMP EAX,-0x7d
JNZ 0x0015fbe5
CMP dword ptr [RBX + 0x40],0x0
JNZ 0x0015fbe5
JMP 0x0015fbcf
LAB_0015fbc5:
MOV EDX,0xc1
BT EDX,ECX
JNC 0x0015fbab
LAB_0015fbcf:
MOV EAX,dword ptr [RBX + 0x8]
CMP EAX,dword ptr [RBX + 0x24]
SETZ AL
AND EBP,0x4
SHR EBP,0x2
OR BPL,AL
MOVZX R14D,BPL
LAB_0015fbe5:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00155688
MOV ECX,EAX
XOR EAX,EAX
NEG ECX
SBB EAX,EAX
OR EAX,R14D
LAB_0015fbfb:
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0015fc04:
PUSH 0x1
JMP 0x0015fb98
|
uint is_let(long param_1,uint param_2)
{
int iVar1;
uint uVar2;
int8 local_48;
int8 uStack_40;
int4 local_38;
int8 local_30;
int4 local_28;
int4 uStack_24;
int4 uStack_20;
int4 uStack_1c;
iVar1 = token_is_pseudo_keyword(param_1,0x27);
if (iVar1 == 0) {
return 0;
}
uStack_40 = *(int8 *)(param_1 + 0x24);
local_48 = *(int8 *)(param_1 + 8);
local_30 = *(int8 *)(param_1 + 0x30);
local_28 = *(int4 *)(param_1 + 0x80);
uStack_24 = *(int4 *)(param_1 + 0x84);
uStack_20 = *(int4 *)(param_1 + 0x88);
uStack_1c = *(int4 *)(param_1 + 0x8c);
local_38 = *(int4 *)(param_1 + 0x58);
iVar1 = next_token(param_1);
if (iVar1 != 0) {
uVar2 = 0xffffffff;
goto LAB_0015fbe5;
}
iVar1 = *(int *)(param_1 + 0x20);
if (((7 < iVar1 + 0x2fU) || ((0xc1U >> (iVar1 + 0x2fU & 0x1f) & 1) == 0)) && (iVar1 != 0x7b)) {
if (iVar1 == 0x5b) {
uVar2 = 1;
goto LAB_0015fbe5;
}
uVar2 = 0;
if ((iVar1 != -0x7d) || (*(int *)(param_1 + 0x40) != 0)) goto LAB_0015fbe5;
}
uVar2 = (uint)(byte)((byte)((param_2 & 4) >> 2) |
*(int *)(param_1 + 8) == *(int *)(param_1 + 0x24));
LAB_0015fbe5:
iVar1 = js_parse_seek_token(param_1,&local_48);
return -(uint)(iVar1 != 0) | uVar2;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.