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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
54,700 | mp_print_str | bluesky950520[P]quickjs/libbf.c | void mp_print_str(const char *str, const limb_t *tab, limb_t n)
{
slimb_t i;
printf("%s= 0x", str);
for(i = n - 1; i >= 0; i--) {
if (i != (n - 1))
printf("_");
printf(FMT_LIMB, tab[i]);
}
printf("\n");
} | O2 | c | mp_print_str:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x19ad6(%rip), %rdi # 0x8d2c0
xorl %eax, %eax
callq 0xe2c0
leaq (%r14,%rbx,8), %r15
addq $-0x8, %r15
decq %rbx
leaq 0x19ac4(%rip), %r14 # 0x8d2c7
pushq $0x5f
popq %rbp
xorl %r12d, %r12d
movq %rbx, %rax
addq %r12, %rax
js 0x73834
movq %r12, %r13
subq $0x1, %r13
jb 0x73821
movl %ebp, %edi
callq 0xe080
movq (%r15,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0xe2c0
movq %r13, %r12
jmp 0x73809
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe080
| mp_print_str:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov rsi, rdi
lea rdi, aS0x; "%s= 0x"
xor eax, eax
call _printf
lea r15, [r14+rbx*8]
add r15, 0FFFFFFFFFFFFFFF8h
dec rbx
lea r14, a016lx; "%016lx"
push 5Fh ; '_'
pop rbp
xor r12d, r12d
loc_73809:
mov rax, rbx
add rax, r12
js short loc_73834
mov r13, r12
sub r13, 1
jb short loc_73821
mov edi, ebp
call _putchar
loc_73821:
mov rsi, [r15+r12*8]
mov rdi, r14
xor eax, eax
call _printf
mov r12, r13
jmp short loc_73809
loc_73834:
push 0Ah
pop rdi
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _putchar
| long long mp_print_str(const char *a1, long long a2, long long a3)
{
long long v4; // r15
long long v5; // rbx
long long i; // r12
printf("%s= 0x", a1);
v4 = a2 + 8 * a3 - 8;
v5 = a3 - 1;
for ( i = 0LL; i + v5 >= 0; --i )
{
if ( i )
putchar(95LL);
printf("%016lx", *(_QWORD *)(v4 + 8 * i));
}
return putchar(10LL);
}
| mp_print_str:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV RSI,RDI
LEA RDI,[0x18d2c0]
XOR EAX,EAX
CALL 0x0010e2c0
LEA R15,[R14 + RBX*0x8]
ADD R15,-0x8
DEC RBX
LEA R14,[0x18d2c7]
PUSH 0x5f
POP RBP
XOR R12D,R12D
LAB_00173809:
MOV RAX,RBX
ADD RAX,R12
JS 0x00173834
MOV R13,R12
SUB R13,0x1
JC 0x00173821
MOV EDI,EBP
CALL 0x0010e080
LAB_00173821:
MOV RSI,qword ptr [R15 + R12*0x8]
MOV RDI,R14
XOR EAX,EAX
CALL 0x0010e2c0
MOV R12,R13
JMP 0x00173809
LAB_00173834:
PUSH 0xa
POP RDI
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0010e080
|
void mp_print_str(int8 param_1,long param_2,long param_3)
{
long lVar1;
printf("%s= 0x",param_1);
lVar1 = 0;
while (-1 < param_3 + -1 + lVar1) {
if (lVar1 != 0) {
putchar(0x5f);
}
printf("%016lx",*(int8 *)(param_2 + param_3 * 8 + -8 + lVar1 * 8));
lVar1 = lVar1 + -1;
}
putchar(10);
return;
}
| |
54,701 | OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::initializeFaceValuesFromVertexFaceSiblings() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/fvarLevel.cpp | void
FVarLevel::initializeFaceValuesFromVertexFaceSiblings() {
//
// Iterate through all face-values first and initialize them with the first value
// associated with each face-vertex. Then make a second sparse pass through the
// vertex-faces to offset those with multiple values. This turns out to be much
// more efficient than a single iteration through the vertex-faces since the first
// pass is much more memory coherent.
//
ConstIndexArray fvIndices = _level.getFaceVertices();
for (int i = 0; i < fvIndices.size(); ++i) {
_faceVertValues[i] = getVertexValueOffset(fvIndices[i]);
}
//
// Now use the vert-face-siblings to populate the face-vert-values:
//
for (int vIndex = 0; vIndex < _level.getNumVertices(); ++vIndex) {
if (getNumVertexValues(vIndex) > 1) {
ConstIndexArray vFaces = _level.getVertexFaces(vIndex);
ConstLocalIndexArray vInFace = _level.getVertexFaceLocalIndices(vIndex);
ConstSiblingArray vSiblings = getVertexFaceSiblings(vIndex);
for (int j = 0; j < vFaces.size(); ++j) {
if (vSiblings[j]) {
int fvOffset = _level.getOffsetOfFaceVertices(vFaces[j]);
_faceVertValues[fvOffset + vInFace[j]] += vSiblings[j];
}
}
}
}
} | O0 | cpp | OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::initializeFaceValuesFromVertexFaceSiblings():
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq (%rax), %rdi
callq 0xcb210
movl %edx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0xb4(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xcc250
movl %eax, %ecx
movl -0xb4(%rbp), %eax
cmpl %ecx, %eax
jge 0xdcc05
movl -0x2c(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0xcabf0
movq -0xb0(%rbp), %rdi
movl (%rax), %esi
xorl %edx, %edx
callq 0xd7880
movq -0xb0(%rbp), %rdi
movl %eax, -0xb8(%rbp)
addq $0x18, %rdi
movslq -0x2c(%rbp), %rsi
callq 0xc7140
movl -0xb8(%rbp), %ecx
movl %ecx, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xdcb9e
movl $0x0, -0x30(%rbp)
movq -0xb0(%rbp), %rax
movl -0x30(%rbp), %ecx
movl %ecx, -0xbc(%rbp)
movq (%rax), %rdi
callq 0xc8fe0
movl %eax, %ecx
movl -0xbc(%rbp), %eax
cmpl %ecx, %eax
jge 0xdcdfc
movq -0xb0(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0xd2670
cmpl $0x1, %eax
jle 0xdcdec
movq -0xb0(%rbp), %rax
movq (%rax), %rdi
movl -0x30(%rbp), %esi
callq 0xd7810
movq %rax, %rcx
movq -0xb0(%rbp), %rax
movl %edx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movl -0x48(%rbp), %ecx
movl %ecx, -0x38(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq (%rax), %rdi
movl -0x30(%rbp), %esi
callq 0xc7650
movq -0xb0(%rbp), %rdi
movl %edx, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x30(%rbp), %esi
callq 0xd2000
movl %edx, -0x98(%rbp)
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0x88(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
movl %eax, -0xc0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcc250
movl %eax, %ecx
movl -0xc0(%rbp), %eax
cmpl %ecx, %eax
jge 0xdcdea
movl -0xa4(%rbp), %esi
leaq -0x80(%rbp), %rdi
callq 0xcafa0
cmpw $0x0, (%rax)
je 0xdcdd4
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
movl -0xa4(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0xcabf0
movq -0xd8(%rbp), %rdi
movl (%rax), %esi
callq 0xd5380
movl %eax, -0xa8(%rbp)
movl -0xa4(%rbp), %esi
leaq -0x80(%rbp), %rdi
callq 0xcafa0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
movzwl (%rcx), %ecx
movl %ecx, -0xc4(%rbp)
addq $0x18, %rax
movq %rax, -0xd0(%rbp)
movl -0xa8(%rbp), %eax
movl %eax, -0xc8(%rbp)
movl -0xa4(%rbp), %esi
leaq -0x60(%rbp), %rdi
callq 0xcafa0
movq -0xd0(%rbp), %rdi
movq %rax, %rcx
movl -0xc8(%rbp), %eax
movzwl (%rcx), %ecx
addl %ecx, %eax
movslq %eax, %rsi
callq 0xc7140
movl -0xc4(%rbp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0xdcdd6
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0xdccf3
jmp 0xdcdec
jmp 0xdcdee
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xdcc0c
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN10OpenSubdiv6v3_6_03Vtr8internal9FVarLevel42initializeFaceValuesFromVertexFaceSiblingsEv:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_B0], rax
mov rdi, [rax]; this
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level15getFaceVerticesEv; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(void)
mov [rbp+var_20], edx
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov eax, [rbp+var_20]
mov [rbp+var_10], eax
mov [rbp+var_2C], 0
loc_DCB9E:
mov eax, [rbp+var_2C]
mov [rbp+var_B4], eax
lea rdi, [rbp+var_18]
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiE4sizeEv; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::size(void)
mov ecx, eax
mov eax, [rbp+var_B4]
cmp eax, ecx
jge short loc_DCC05
mov esi, [rbp+var_2C]
lea rdi, [rbp+var_18]
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](int)
mov rdi, [rbp+var_B0]; this
mov esi, [rax]; int
xor edx, edx; unsigned __int16
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal9FVarLevel20getVertexValueOffsetEit; OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::getVertexValueOffset(int,ushort)
mov rdi, [rbp+var_B0]
mov [rbp+var_B8], eax
add rdi, 18h
movsxd rsi, [rbp+var_2C]
call __ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ecx, [rbp+var_B8]
mov [rax], ecx
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp short loc_DCB9E
loc_DCC05:
mov [rbp+var_30], 0
loc_DCC0C:
mov rax, [rbp+var_B0]
mov ecx, [rbp+var_30]
mov [rbp+var_BC], ecx
mov rdi, [rax]; this
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level14getNumVerticesEv; OpenSubdiv::v3_6_0::Vtr::internal::Level::getNumVertices(void)
mov ecx, eax
mov eax, [rbp+var_BC]
cmp eax, ecx
jge loc_DCDFC
mov rdi, [rbp+var_B0]; this
mov esi, [rbp+var_30]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal9FVarLevel18getNumVertexValuesEi; OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::getNumVertexValues(int)
cmp eax, 1
jle loc_DCDEC
mov rax, [rbp+var_B0]
mov rdi, [rax]; this
mov esi, [rbp+var_30]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level14getVertexFacesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaces(int)
mov rcx, rax
mov rax, [rbp+var_B0]
mov [rbp+var_48], edx
mov [rbp+var_50], rcx
mov ecx, [rbp+var_48]
mov [rbp+var_38], ecx
mov rcx, [rbp+var_50]
mov [rbp+var_40], rcx
mov rdi, [rax]; this
mov esi, [rbp+var_30]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level25getVertexFaceLocalIndicesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaceLocalIndices(int)
mov rdi, [rbp+var_B0]; this
mov [rbp+var_68], edx
mov [rbp+var_70], rax
mov eax, [rbp+var_68]
mov [rbp+var_58], eax
mov rax, [rbp+var_70]
mov [rbp+var_60], rax
mov esi, [rbp+var_30]; int
call __ZN10OpenSubdiv6v3_6_03Vtr8internal9FVarLevel21getVertexFaceSiblingsEi; OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::getVertexFaceSiblings(int)
mov [rbp+var_98], edx
mov [rbp+var_A0], rax
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
mov eax, [rbp+var_98]
mov dword ptr [rbp+var_88], eax
mov rax, [rbp+var_90]
mov [rbp+var_80], rax
mov rax, [rbp+var_88]
mov [rbp+var_78], rax
mov [rbp+var_A4], 0
loc_DCCF3:
mov eax, [rbp+var_A4]
mov [rbp+var_C0], eax
lea rdi, [rbp+var_40]
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiE4sizeEv; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::size(void)
mov ecx, eax
mov eax, [rbp+var_C0]
cmp eax, ecx
jge loc_DCDEA
mov esi, [rbp+var_A4]
lea rdi, [rbp+var_80]
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayItEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<ushort>::operator[](int)
cmp word ptr [rax], 0
jz loc_DCDD4
mov rax, [rbp+var_B0]
mov rax, [rax]
mov [rbp+var_D8], rax
mov esi, [rbp+var_A4]
lea rdi, [rbp+var_40]
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](int)
mov rdi, [rbp+var_D8]; this
mov esi, [rax]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level23getOffsetOfFaceVerticesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getOffsetOfFaceVertices(int)
mov [rbp+var_A8], eax
mov esi, [rbp+var_A4]
lea rdi, [rbp+var_80]
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayItEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<ushort>::operator[](int)
mov rcx, rax
mov rax, [rbp+var_B0]
movzx ecx, word ptr [rcx]
mov [rbp+var_C4], ecx
add rax, 18h
mov [rbp+var_D0], rax
mov eax, [rbp+var_A8]
mov [rbp+var_C8], eax
mov esi, [rbp+var_A4]
lea rdi, [rbp+var_60]
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayItEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<ushort>::operator[](int)
mov rdi, [rbp+var_D0]
mov rcx, rax
mov eax, [rbp+var_C8]
movzx ecx, word ptr [rcx]
add eax, ecx
movsxd rsi, eax
call __ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ecx, [rbp+var_C4]
add ecx, [rax]
mov [rax], ecx
loc_DCDD4:
jmp short $+2
loc_DCDD6:
mov eax, [rbp+var_A4]
add eax, 1
mov [rbp+var_A4], eax
jmp loc_DCCF3
loc_DCDEA:
jmp short $+2
loc_DCDEC:
jmp short $+2
loc_DCDEE:
mov eax, [rbp+var_30]
add eax, 1
mov [rbp+var_30], eax
jmp loc_DCC0C
loc_DCDFC:
add rsp, 0E0h
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::initializeFaceValuesFromVertexFaceSiblings(
OpenSubdiv::v3_6_0::Vtr::internal::Level **this)
{
long long FaceVertices; // rax
int v2; // edx
int *v3; // rax
int NumVertices; // ecx
long long result; // rax
long long VertexFaces; // rax
int v7; // edx
long long VertexFaceLocalIndices; // rax
int v9; // edx
long long VertexFaceSiblings; // rax
int v11; // edx
int *v12; // rax
unsigned __int16 *v13; // rax
_DWORD *v14; // rax
OpenSubdiv::v3_6_0::Vtr::internal::Level *v15; // [rsp+8h] [rbp-D8h]
int v16; // [rsp+1Ch] [rbp-C4h]
int v17; // [rsp+24h] [rbp-BCh]
int VertexValueOffset; // [rsp+28h] [rbp-B8h]
int OffsetOfFaceVertices; // [rsp+38h] [rbp-A8h]
unsigned int k; // [rsp+3Ch] [rbp-A4h]
long long v21; // [rsp+58h] [rbp-88h]
_QWORD v22[3]; // [rsp+60h] [rbp-80h] BYREF
int v23; // [rsp+78h] [rbp-68h]
long long v24; // [rsp+80h] [rbp-60h] BYREF
int v25; // [rsp+88h] [rbp-58h]
long long v26; // [rsp+90h] [rbp-50h]
int v27; // [rsp+98h] [rbp-48h]
long long v28; // [rsp+A0h] [rbp-40h] BYREF
int v29; // [rsp+A8h] [rbp-38h]
int j; // [rsp+B0h] [rbp-30h]
int i; // [rsp+B4h] [rbp-2Ch]
long long v32; // [rsp+B8h] [rbp-28h]
int v33; // [rsp+C0h] [rbp-20h]
long long v34; // [rsp+C8h] [rbp-18h] BYREF
int v35; // [rsp+D0h] [rbp-10h]
OpenSubdiv::v3_6_0::Vtr::internal::Level **v36; // [rsp+D8h] [rbp-8h]
v36 = this;
FaceVertices = OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(*this);
v33 = v2;
v32 = FaceVertices;
v34 = FaceVertices;
v35 = v2;
for ( i = 0; i < (int)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::size(&v34); ++i )
{
v3 = (int *)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](&v34, (unsigned int)i);
VertexValueOffset = OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::getVertexValueOffset(
(OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel *)this,
*v3,
0);
*(_DWORD *)std::vector<int>::operator[](this + 3, i) = VertexValueOffset;
}
for ( j = 0; ; ++j )
{
v17 = j;
NumVertices = OpenSubdiv::v3_6_0::Vtr::internal::Level::getNumVertices(*this);
result = (unsigned int)v17;
if ( v17 >= NumVertices )
break;
if ( (int)OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::getNumVertexValues(
(OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel *)this,
j) > 1 )
{
VertexFaces = OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaces(*this, j);
v27 = v7;
v26 = VertexFaces;
v29 = v7;
v28 = VertexFaces;
VertexFaceLocalIndices = OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaceLocalIndices(*this, j);
v23 = v9;
v22[2] = VertexFaceLocalIndices;
v25 = v9;
v24 = VertexFaceLocalIndices;
VertexFaceSiblings = OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::getVertexFaceSiblings(
(OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel *)this,
j);
LODWORD(v21) = v11;
v22[0] = VertexFaceSiblings;
v22[1] = v21;
for ( k = 0; (int)k < (int)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::size(&v28); ++k )
{
if ( *(_WORD *)OpenSubdiv::v3_6_0::Vtr::ConstArray<unsigned short>::operator[](v22, k) )
{
v15 = *this;
v12 = (int *)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](&v28, k);
OffsetOfFaceVertices = OpenSubdiv::v3_6_0::Vtr::internal::Level::getOffsetOfFaceVertices(v15, *v12);
v16 = *(unsigned __int16 *)OpenSubdiv::v3_6_0::Vtr::ConstArray<unsigned short>::operator[](v22, k);
v13 = (unsigned __int16 *)OpenSubdiv::v3_6_0::Vtr::ConstArray<unsigned short>::operator[](&v24, k);
v14 = (_DWORD *)std::vector<int>::operator[](this + 3, *v13 + OffsetOfFaceVertices);
*v14 += v16;
}
}
}
}
return result;
}
| initializeFaceValuesFromVertexFaceSiblings:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0xb0],RAX
MOV RDI,qword ptr [RAX]
CALL 0x001cb210
MOV dword ptr [RBP + -0x20],EDX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x10],EAX
MOV dword ptr [RBP + -0x2c],0x0
LAB_001dcb9e:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0xb4],EAX
LEA RDI,[RBP + -0x18]
CALL 0x001cc250
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0xb4]
CMP EAX,ECX
JGE 0x001dcc05
MOV ESI,dword ptr [RBP + -0x2c]
LEA RDI,[RBP + -0x18]
CALL 0x001cabf0
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,dword ptr [RAX]
XOR EDX,EDX
CALL 0x001d7880
MOV RDI,qword ptr [RBP + -0xb0]
MOV dword ptr [RBP + -0xb8],EAX
ADD RDI,0x18
MOVSXD RSI,dword ptr [RBP + -0x2c]
CALL 0x001c7140
MOV ECX,dword ptr [RBP + -0xb8]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001dcb9e
LAB_001dcc05:
MOV dword ptr [RBP + -0x30],0x0
LAB_001dcc0c:
MOV RAX,qword ptr [RBP + -0xb0]
MOV ECX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0xbc],ECX
MOV RDI,qword ptr [RAX]
CALL 0x001c8fe0
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0xbc]
CMP EAX,ECX
JGE 0x001dcdfc
MOV RDI,qword ptr [RBP + -0xb0]
MOV ESI,dword ptr [RBP + -0x30]
CALL 0x001d2670
CMP EAX,0x1
JLE 0x001dcdec
MOV RAX,qword ptr [RBP + -0xb0]
MOV RDI,qword ptr [RAX]
MOV ESI,dword ptr [RBP + -0x30]
CALL 0x001d7810
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0xb0]
MOV dword ptr [RBP + -0x48],EDX
MOV qword ptr [RBP + -0x50],RCX
MOV ECX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x38],ECX
MOV RCX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x40],RCX
MOV RDI,qword ptr [RAX]
MOV ESI,dword ptr [RBP + -0x30]
CALL 0x001c7650
MOV RDI,qword ptr [RBP + -0xb0]
MOV dword ptr [RBP + -0x68],EDX
MOV qword ptr [RBP + -0x70],RAX
MOV EAX,dword ptr [RBP + -0x68]
MOV dword ptr [RBP + -0x58],EAX
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x60],RAX
MOV ESI,dword ptr [RBP + -0x30]
CALL 0x001d2000
MOV dword ptr [RBP + -0x98],EDX
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
MOV EAX,dword ptr [RBP + -0x98]
MOV dword ptr [RBP + -0x88],EAX
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x78],RAX
MOV dword ptr [RBP + -0xa4],0x0
LAB_001dccf3:
MOV EAX,dword ptr [RBP + -0xa4]
MOV dword ptr [RBP + -0xc0],EAX
LEA RDI,[RBP + -0x40]
CALL 0x001cc250
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0xc0]
CMP EAX,ECX
JGE 0x001dcdea
MOV ESI,dword ptr [RBP + -0xa4]
LEA RDI,[RBP + -0x80]
CALL 0x001cafa0
CMP word ptr [RAX],0x0
JZ 0x001dcdd4
MOV RAX,qword ptr [RBP + -0xb0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xd8],RAX
MOV ESI,dword ptr [RBP + -0xa4]
LEA RDI,[RBP + -0x40]
CALL 0x001cabf0
MOV RDI,qword ptr [RBP + -0xd8]
MOV ESI,dword ptr [RAX]
CALL 0x001d5380
MOV dword ptr [RBP + -0xa8],EAX
MOV ESI,dword ptr [RBP + -0xa4]
LEA RDI,[RBP + -0x80]
CALL 0x001cafa0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0xb0]
MOVZX ECX,word ptr [RCX]
MOV dword ptr [RBP + -0xc4],ECX
ADD RAX,0x18
MOV qword ptr [RBP + -0xd0],RAX
MOV EAX,dword ptr [RBP + -0xa8]
MOV dword ptr [RBP + -0xc8],EAX
MOV ESI,dword ptr [RBP + -0xa4]
LEA RDI,[RBP + -0x60]
CALL 0x001cafa0
MOV RDI,qword ptr [RBP + -0xd0]
MOV RCX,RAX
MOV EAX,dword ptr [RBP + -0xc8]
MOVZX ECX,word ptr [RCX]
ADD EAX,ECX
MOVSXD RSI,EAX
CALL 0x001c7140
MOV ECX,dword ptr [RBP + -0xc4]
ADD ECX,dword ptr [RAX]
MOV dword ptr [RAX],ECX
LAB_001dcdd4:
JMP 0x001dcdd6
LAB_001dcdd6:
MOV EAX,dword ptr [RBP + -0xa4]
ADD EAX,0x1
MOV dword ptr [RBP + -0xa4],EAX
JMP 0x001dccf3
LAB_001dcdea:
JMP 0x001dcdec
LAB_001dcdec:
JMP 0x001dcdee
LAB_001dcdee:
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001dcc0c
LAB_001dcdfc:
ADD RSP,0xe0
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::initializeFaceValuesFromVertexFaceSiblings() */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::initializeFaceValuesFromVertexFaceSiblings
(FVarLevel *this)
{
ushort uVar1;
Level *this_00;
int iVar2;
int4 uVar3;
int iVar4;
int *piVar5;
int4 *puVar6;
short *psVar7;
ushort *puVar8;
int1 auVar9 [12];
int local_ac;
int4 uStack_8c;
int8 local_88;
int8 local_80;
int1 local_78 [12];
int1 local_68 [12];
int1 local_58 [12];
int1 local_48 [12];
int local_38;
int local_34;
int1 local_30 [12];
ConstArray<int> local_20 [16];
FVarLevel *local_10;
local_10 = this;
local_30 = Level::getFaceVertices(*(Level **)this);
local_34 = 0;
local_20._0_12_ = local_30;
while( true ) {
iVar4 = local_34;
iVar2 = ConstArray<int>::size(local_20);
if (iVar2 <= iVar4) break;
piVar5 = (int *)ConstArray<int>::operator[](local_20,local_34);
uVar3 = getVertexValueOffset(this,*piVar5,0);
puVar6 = (int4 *)
std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)(this + 0x18),(long)local_34);
*puVar6 = uVar3;
local_34 = local_34 + 1;
}
local_38 = 0;
while( true ) {
iVar4 = local_38;
iVar2 = Level::getNumVertices(*(Level **)this);
if (iVar2 <= iVar4) break;
iVar4 = getNumVertexValues(this,local_38);
if (1 < iVar4) {
auVar9 = Level::getVertexFaces(*(Level **)this,local_38);
local_58 = auVar9;
local_48 = auVar9;
auVar9 = Level::getVertexFaceLocalIndices(*(Level **)this,local_38);
local_78 = auVar9;
local_68 = auVar9;
auVar9 = getVertexFaceSiblings(this,local_38);
local_88 = auVar9._0_8_;
local_80 = CONCAT44(uStack_8c,auVar9._8_4_);
local_ac = 0;
while( true ) {
iVar4 = ConstArray<int>::size((ConstArray<int> *)local_48);
if (iVar4 <= local_ac) break;
psVar7 = (short *)ConstArray<unsigned_short>::operator[]
((ConstArray<unsigned_short> *)&local_88,local_ac);
if (*psVar7 != 0) {
this_00 = *(Level **)this;
piVar5 = (int *)ConstArray<int>::operator[]((ConstArray<int> *)local_48,local_ac);
iVar4 = Level::getOffsetOfFaceVertices(this_00,*piVar5);
puVar8 = (ushort *)
ConstArray<unsigned_short>::operator[]
((ConstArray<unsigned_short> *)&local_88,local_ac);
uVar1 = *puVar8;
puVar8 = (ushort *)
ConstArray<unsigned_short>::operator[]
((ConstArray<unsigned_short> *)local_68,local_ac);
piVar5 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)(this + 0x18),
(long)(int)(iVar4 + (uint)*puVar8));
*piVar5 = (uint)uVar1 + *piVar5;
}
local_ac = local_ac + 1;
}
}
local_38 = local_38 + 1;
}
return;
}
| |
54,702 | OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::initializeFaceValuesFromVertexFaceSiblings() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/fvarLevel.cpp | void
FVarLevel::initializeFaceValuesFromVertexFaceSiblings() {
//
// Iterate through all face-values first and initialize them with the first value
// associated with each face-vertex. Then make a second sparse pass through the
// vertex-faces to offset those with multiple values. This turns out to be much
// more efficient than a single iteration through the vertex-faces since the first
// pass is much more memory coherent.
//
ConstIndexArray fvIndices = _level.getFaceVertices();
for (int i = 0; i < fvIndices.size(); ++i) {
_faceVertValues[i] = getVertexValueOffset(fvIndices[i]);
}
//
// Now use the vert-face-siblings to populate the face-vert-values:
//
for (int vIndex = 0; vIndex < _level.getNumVertices(); ++vIndex) {
if (getNumVertexValues(vIndex) > 1) {
ConstIndexArray vFaces = _level.getVertexFaces(vIndex);
ConstLocalIndexArray vInFace = _level.getVertexFaceLocalIndices(vIndex);
ConstSiblingArray vSiblings = getVertexFaceSiblings(vIndex);
for (int j = 0; j < vFaces.size(); ++j) {
if (vSiblings[j]) {
int fvOffset = _level.getOffsetOfFaceVertices(vFaces[j]);
_faceVertValues[fvOffset + vInFace[j]] += vSiblings[j];
}
}
}
}
} | O2 | cpp | OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::initializeFaceValuesFromVertexFaceSiblings():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x18(%rbx), %rax
movq 0x30(%rdi), %rcx
movq 0x38(%rdi), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movq 0x60(%rbx), %rsi
xorl %r8d, %r8d
testl %edx, %edx
cmovlel %r8d, %edx
cmpq %r8, %rdx
je 0x57df3
movslq (%rcx,%r8,4), %r9
movl (%rsi,%r9,4), %r9d
movl %r9d, (%rax,%r8,4)
incq %r8
jmp 0x57ddd
xorl %ebp, %ebp
xorl %r14d, %r14d
movslq 0x8(%rdi), %rax
cmpq %rax, %r14
jge 0x57e75
movq 0x48(%rbx), %rax
cmpw $0x2, (%rax,%r14,2)
jb 0x57e70
movl %r14d, %esi
callq 0x55df0
movq %rax, %r15
movl %edx, %r12d
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x507c0
movq %rax, %r13
movq %rbx, %rdi
movl %r14d, %esi
callq 0x54000
movq (%rbx), %rdi
movq 0x18(%rbx), %rcx
testl %r12d, %r12d
cmovlel %ebp, %r12d
xorl %edx, %edx
cmpq %rdx, %r12
je 0x57e70
movzwl (%rax,%rdx,2), %esi
testl %esi, %esi
je 0x57e6b
movslq (%r15,%rdx,4), %r8
movq 0x18(%rdi), %r9
movslq 0x4(%r9,%r8,8), %r8
movzwl (%r13,%rdx,2), %r9d
addq %r8, %r9
addl %esi, (%rcx,%r9,4)
incq %rdx
jmp 0x57e44
incq %r14
jmp 0x57df8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN10OpenSubdiv6v3_6_03Vtr8internal9FVarLevel42initializeFaceValuesFromVertexFaceSiblingsEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi]; this
mov rax, [rbx+18h]
mov rcx, [rdi+30h]
mov rdx, [rdi+38h]
sub rdx, rcx
shr rdx, 2
mov rsi, [rbx+60h]
xor r8d, r8d
test edx, edx
cmovle edx, r8d
loc_57DDD:
cmp rdx, r8
jz short loc_57DF3
movsxd r9, dword ptr [rcx+r8*4]
mov r9d, [rsi+r9*4]
mov [rax+r8*4], r9d
inc r8
jmp short loc_57DDD
loc_57DF3:
xor ebp, ebp
xor r14d, r14d
loc_57DF8:
movsxd rax, dword ptr [rdi+8]
cmp r14, rax
jge short loc_57E75
mov rax, [rbx+48h]
cmp word ptr [rax+r14*2], 2
jb short loc_57E70
mov esi, r14d; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level14getVertexFacesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaces(int)
mov r15, rax
mov r12d, edx
mov rdi, [rbx]; this
mov esi, r14d; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level25getVertexFaceLocalIndicesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaceLocalIndices(int)
mov r13, rax
mov rdi, rbx; this
mov esi, r14d; int
call __ZN10OpenSubdiv6v3_6_03Vtr8internal9FVarLevel21getVertexFaceSiblingsEi; OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::getVertexFaceSiblings(int)
mov rdi, [rbx]
mov rcx, [rbx+18h]
test r12d, r12d
cmovle r12d, ebp
xor edx, edx
loc_57E44:
cmp r12, rdx
jz short loc_57E70
movzx esi, word ptr [rax+rdx*2]
test esi, esi
jz short loc_57E6B
movsxd r8, dword ptr [r15+rdx*4]
mov r9, [rdi+18h]
movsxd r8, dword ptr [r9+r8*8+4]
movzx r9d, word ptr [r13+rdx*2+0]
add r9, r8
add [rcx+r9*4], esi
loc_57E6B:
inc rdx
jmp short loc_57E44
loc_57E70:
inc r14
jmp short loc_57DF8
loc_57E75:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::initializeFaceValuesFromVertexFaceSiblings(
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel *this)
{
long long v2; // rdi
long long v3; // rax
long long v4; // rcx
unsigned long long v5; // rdx
long long v6; // rsi
long long v7; // r8
long long i; // r14
long long result; // rax
long long VertexFaces; // r15
unsigned int v11; // edx
long long v12; // r12
long long VertexFaceLocalIndices; // r13
long long VertexFaceSiblings; // rax
long long v15; // rcx
long long j; // rdx
unsigned long long v17; // r9
v2 = *(_QWORD *)this;
v3 = *((_QWORD *)this + 3);
v4 = *(_QWORD *)(v2 + 48);
v5 = (unsigned long long)(*(_QWORD *)(v2 + 56) - v4) >> 2;
v6 = *((_QWORD *)this + 12);
v7 = 0LL;
if ( (int)v5 <= 0 )
v5 = 0LL;
while ( v5 != v7 )
{
*(_DWORD *)(v3 + 4 * v7) = *(_DWORD *)(v6 + 4LL * *(int *)(v4 + 4 * v7));
++v7;
}
for ( i = 0LL; ; ++i )
{
result = *(int *)(v2 + 8);
if ( i >= result )
break;
if ( *(_WORD *)(*((_QWORD *)this + 9) + 2 * i) >= 2u )
{
VertexFaces = OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaces(
(OpenSubdiv::v3_6_0::Vtr::internal::Level *)v2,
i);
v12 = v11;
VertexFaceLocalIndices = OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaceLocalIndices(
*(OpenSubdiv::v3_6_0::Vtr::internal::Level **)this,
i);
VertexFaceSiblings = OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::getVertexFaceSiblings(this, i);
v2 = *(_QWORD *)this;
v15 = *((_QWORD *)this + 3);
if ( (int)v12 <= 0 )
v12 = 0LL;
for ( j = 0LL; v12 != j; ++j )
{
if ( *(_WORD *)(VertexFaceSiblings + 2 * j) )
{
v17 = *(int *)(*(_QWORD *)(v2 + 24) + 8LL * *(int *)(VertexFaces + 4 * j) + 4)
+ (unsigned long long)*(unsigned __int16 *)(VertexFaceLocalIndices + 2 * j);
*(_DWORD *)(v15 + 4 * v17) += *(unsigned __int16 *)(VertexFaceSiblings + 2 * j);
}
}
}
}
return result;
}
| initializeFaceValuesFromVertexFaceSiblings:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RBX + 0x18]
MOV RCX,qword ptr [RDI + 0x30]
MOV RDX,qword ptr [RDI + 0x38]
SUB RDX,RCX
SHR RDX,0x2
MOV RSI,qword ptr [RBX + 0x60]
XOR R8D,R8D
TEST EDX,EDX
CMOVLE EDX,R8D
LAB_00157ddd:
CMP RDX,R8
JZ 0x00157df3
MOVSXD R9,dword ptr [RCX + R8*0x4]
MOV R9D,dword ptr [RSI + R9*0x4]
MOV dword ptr [RAX + R8*0x4],R9D
INC R8
JMP 0x00157ddd
LAB_00157df3:
XOR EBP,EBP
XOR R14D,R14D
LAB_00157df8:
MOVSXD RAX,dword ptr [RDI + 0x8]
CMP R14,RAX
JGE 0x00157e75
MOV RAX,qword ptr [RBX + 0x48]
CMP word ptr [RAX + R14*0x2],0x2
JC 0x00157e70
MOV ESI,R14D
CALL 0x00155df0
MOV R15,RAX
MOV R12D,EDX
MOV RDI,qword ptr [RBX]
MOV ESI,R14D
CALL 0x001507c0
MOV R13,RAX
MOV RDI,RBX
MOV ESI,R14D
CALL 0x00154000
MOV RDI,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x18]
TEST R12D,R12D
CMOVLE R12D,EBP
XOR EDX,EDX
LAB_00157e44:
CMP R12,RDX
JZ 0x00157e70
MOVZX ESI,word ptr [RAX + RDX*0x2]
TEST ESI,ESI
JZ 0x00157e6b
MOVSXD R8,dword ptr [R15 + RDX*0x4]
MOV R9,qword ptr [RDI + 0x18]
MOVSXD R8,dword ptr [R9 + R8*0x8 + 0x4]
MOVZX R9D,word ptr [R13 + RDX*0x2]
ADD R9,R8
ADD dword ptr [RCX + R9*0x4],ESI
LAB_00157e6b:
INC RDX
JMP 0x00157e44
LAB_00157e70:
INC R14
JMP 0x00157df8
LAB_00157e75:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::initializeFaceValuesFromVertexFaceSiblings() */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::initializeFaceValuesFromVertexFaceSiblings
(FVarLevel *this)
{
int *piVar1;
ushort uVar2;
long lVar3;
long lVar4;
long lVar5;
ulong uVar6;
ulong uVar7;
Level *this_00;
ulong uVar8;
int iVar9;
long lVar10;
int1 auVar11 [12];
this_00 = *(Level **)this;
lVar10 = *(long *)(this + 0x18);
lVar3 = *(long *)(this_00 + 0x30);
uVar6 = (ulong)(*(long *)(this_00 + 0x38) - lVar3) >> 2;
lVar4 = *(long *)(this + 0x60);
uVar8 = 0;
uVar7 = uVar6 & 0xffffffff;
if ((int)uVar6 < 1) {
uVar7 = uVar8;
}
for (; uVar7 != uVar8; uVar8 = uVar8 + 1) {
*(int4 *)(lVar10 + uVar8 * 4) =
*(int4 *)(lVar4 + (long)*(int *)(lVar3 + uVar8 * 4) * 4);
}
for (lVar10 = 0; lVar10 < *(int *)(this_00 + 8); lVar10 = lVar10 + 1) {
if (1 < *(ushort *)(*(long *)(this + 0x48) + lVar10 * 2)) {
iVar9 = (int)lVar10;
auVar11 = Level::getVertexFaces(this_00,iVar9);
uVar7 = (ulong)auVar11._8_4_;
lVar4 = Level::getVertexFaceLocalIndices(*(Level **)this,iVar9);
lVar5 = getVertexFaceSiblings(this,iVar9);
this_00 = *(Level **)this;
lVar3 = *(long *)(this + 0x18);
if ((int)auVar11._8_4_ < 1) {
uVar7 = 0;
}
for (uVar6 = 0; uVar7 != uVar6; uVar6 = uVar6 + 1) {
uVar2 = *(ushort *)(lVar5 + uVar6 * 2);
if (uVar2 != 0) {
piVar1 = (int *)(lVar3 + ((ulong)*(ushort *)(lVar4 + uVar6 * 2) +
(long)*(int *)(*(long *)(this_00 + 0x18) + 4 +
(long)*(int *)(auVar11._0_8_ + uVar6 * 4) * 8)) * 4
);
*piVar1 = *piVar1 + (uint)uVar2;
}
}
}
}
return;
}
| |
54,703 | thr_abort_locks_for_thread | eloqsql/mysys/thr_lock.c | my_bool thr_abort_locks_for_thread(THR_LOCK *lock, my_thread_id thread_id)
{
THR_LOCK_DATA *data;
my_bool found= FALSE;
DBUG_ENTER("thr_abort_locks_for_thread");
mysql_mutex_lock(&lock->mutex);
for (data= lock->read_wait.data; data ; data= data->next)
{
if (data->owner->thread_id == thread_id) /* purecov: tested */
{
DBUG_PRINT("info",("Aborting read-wait lock"));
data->type= TL_UNLOCK; /* Mark killed */
/* It's safe to signal the cond first: we're still holding the mutex. */
found= TRUE;
mysql_cond_signal(data->cond);
data->cond= 0; /* Removed from list */
if (((*data->prev)= data->next))
data->next->prev= data->prev;
else
lock->read_wait.last= data->prev;
}
}
for (data= lock->write_wait.data; data ; data= data->next)
{
if (data->owner->thread_id == thread_id) /* purecov: tested */
{
DBUG_PRINT("info",("Aborting write-wait lock"));
data->type= TL_UNLOCK;
found= TRUE;
mysql_cond_signal(data->cond);
data->cond= 0;
if (((*data->prev)= data->next))
data->next->prev= data->prev;
else
lock->write_wait.last= data->prev;
}
}
wake_up_waiters(lock);
mysql_mutex_unlock(&lock->mutex);
DBUG_RETURN(found);
} | O0 | c | thr_abort_locks_for_thread:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
leaq 0x5b835(%rip), %rsi # 0x154688
movl $0x545, %edx # imm = 0x545
callq 0xf7900
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xf8f05
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xf8ef2
jmp 0xf8e87
jmp 0xf8e89
movq -0x18(%rbp), %rax
movl $0x0, 0x40(%rax)
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xf8dd0
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xf8ee0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xf8ef0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
jmp 0xf8ef2
jmp 0xf8ef4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xf8e69
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xf8fb3
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xf8fa0
jmp 0xf8f32
jmp 0xf8f34
movq -0x18(%rbp), %rax
movl $0x0, 0x40(%rax)
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xf8dd0
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xf8f8b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xf8f9e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
jmp 0xf8fa0
jmp 0xf8fa2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xf8f14
movq -0x8(%rbp), %rdi
callq 0xf7cc0
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0xf7970
movb -0x19(%rbp), %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| thr_abort_locks_for_thread:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_19], 0
mov rdi, [rbp+var_8]
add rdi, 18h
lea rsi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 545h
call inline_mysql_mutex_lock_27
mov rax, [rbp+var_8]
mov rax, [rax+60h]
mov [rbp+var_18], rax
loc_F8E69:
cmp [rbp+var_18], 0
jz loc_F8F05
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+8]
cmp rax, [rbp+var_10]
jnz short loc_F8EF2
jmp short $+2
loc_F8E87:
jmp short $+2
loc_F8E89:
mov rax, [rbp+var_18]
mov dword ptr [rax+40h], 0
mov [rbp+var_19], 1
mov rax, [rbp+var_18]
mov rdi, [rax+20h]
call inline_mysql_cond_signal_4
mov rax, [rbp+var_18]
mov qword ptr [rax+20h], 0
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rcx, [rbp+var_18]
mov rcx, [rcx+10h]
mov [rcx], rax
cmp rax, 0
jz short loc_F8EE0
mov rax, [rbp+var_18]
mov rcx, [rax+10h]
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rax+10h], rcx
jmp short loc_F8EF0
loc_F8EE0:
mov rax, [rbp+var_18]
mov rcx, [rax+10h]
mov rax, [rbp+var_8]
mov [rax+68h], rcx
loc_F8EF0:
jmp short $+2
loc_F8EF2:
jmp short $+2
loc_F8EF4:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_18], rax
jmp loc_F8E69
loc_F8F05:
mov rax, [rbp+var_8]
mov rax, [rax+80h]
mov [rbp+var_18], rax
loc_F8F14:
cmp [rbp+var_18], 0
jz loc_F8FB3
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+8]
cmp rax, [rbp+var_10]
jnz short loc_F8FA0
jmp short $+2
loc_F8F32:
jmp short $+2
loc_F8F34:
mov rax, [rbp+var_18]
mov dword ptr [rax+40h], 0
mov [rbp+var_19], 1
mov rax, [rbp+var_18]
mov rdi, [rax+20h]
call inline_mysql_cond_signal_4
mov rax, [rbp+var_18]
mov qword ptr [rax+20h], 0
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rcx, [rbp+var_18]
mov rcx, [rcx+10h]
mov [rcx], rax
cmp rax, 0
jz short loc_F8F8B
mov rax, [rbp+var_18]
mov rcx, [rax+10h]
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rax+10h], rcx
jmp short loc_F8F9E
loc_F8F8B:
mov rax, [rbp+var_18]
mov rcx, [rax+10h]
mov rax, [rbp+var_8]
mov [rax+88h], rcx
loc_F8F9E:
jmp short $+2
loc_F8FA0:
jmp short $+2
loc_F8FA2:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_18], rax
jmp loc_F8F14
loc_F8FB3:
mov rdi, [rbp+var_8]
call wake_up_waiters
mov rdi, [rbp+var_8]
add rdi, 18h
call inline_mysql_mutex_unlock_28
mov al, [rbp+var_19]
mov [rbp+var_1A], al
mov al, [rbp+var_1A]
add rsp, 20h
pop rbp
retn
| char thr_abort_locks_for_thread(_QWORD *a1, long long a2)
{
long long v2; // rax
long long v3; // rax
char v5; // [rsp+7h] [rbp-19h]
long long i; // [rsp+8h] [rbp-18h]
long long j; // [rsp+8h] [rbp-18h]
v5 = 0;
inline_mysql_mutex_lock_27(
(long long)(a1 + 3),
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",
0x545u);
for ( i = a1[12]; i; i = *(_QWORD *)(i + 8) )
{
if ( *(_QWORD *)(*(_QWORD *)i + 8LL) == a2 )
{
*(_DWORD *)(i + 64) = 0;
v5 = 1;
inline_mysql_cond_signal_4(*(_QWORD *)(i + 32));
*(_QWORD *)(i + 32) = 0LL;
v2 = *(_QWORD *)(i + 8);
**(_QWORD **)(i + 16) = v2;
if ( v2 )
*(_QWORD *)(*(_QWORD *)(i + 8) + 16LL) = *(_QWORD *)(i + 16);
else
a1[13] = *(_QWORD *)(i + 16);
}
}
for ( j = a1[16]; j; j = *(_QWORD *)(j + 8) )
{
if ( *(_QWORD *)(*(_QWORD *)j + 8LL) == a2 )
{
*(_DWORD *)(j + 64) = 0;
v5 = 1;
inline_mysql_cond_signal_4(*(_QWORD *)(j + 32));
*(_QWORD *)(j + 32) = 0LL;
v3 = *(_QWORD *)(j + 8);
**(_QWORD **)(j + 16) = v3;
if ( v3 )
*(_QWORD *)(*(_QWORD *)(j + 8) + 16LL) = *(_QWORD *)(j + 16);
else
a1[17] = *(_QWORD *)(j + 16);
}
}
wake_up_waiters((long long)a1);
inline_mysql_mutex_unlock_28((long long)(a1 + 3));
return v5;
}
| thr_abort_locks_for_thread:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x19],0x0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x18
LEA RSI,[0x254688]
MOV EDX,0x545
CALL 0x001f7900
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x60]
MOV qword ptr [RBP + -0x18],RAX
LAB_001f8e69:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001f8f05
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x001f8ef2
JMP 0x001f8e87
LAB_001f8e87:
JMP 0x001f8e89
LAB_001f8e89:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x40],0x0
MOV byte ptr [RBP + -0x19],0x1
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x20]
CALL 0x001f8dd0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x20],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001f8ee0
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001f8ef0
LAB_001f8ee0:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x68],RCX
LAB_001f8ef0:
JMP 0x001f8ef2
LAB_001f8ef2:
JMP 0x001f8ef4
LAB_001f8ef4:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001f8e69
LAB_001f8f05:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RBP + -0x18],RAX
LAB_001f8f14:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001f8fb3
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x001f8fa0
JMP 0x001f8f32
LAB_001f8f32:
JMP 0x001f8f34
LAB_001f8f34:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x40],0x0
MOV byte ptr [RBP + -0x19],0x1
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x20]
CALL 0x001f8dd0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x20],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001f8f8b
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001f8f9e
LAB_001f8f8b:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x88],RCX
LAB_001f8f9e:
JMP 0x001f8fa0
LAB_001f8fa0:
JMP 0x001f8fa2
LAB_001f8fa2:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001f8f14
LAB_001f8fb3:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001f7cc0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x18
CALL 0x001f7970
MOV AL,byte ptr [RBP + -0x19]
MOV byte ptr [RBP + -0x1a],AL
MOV AL,byte ptr [RBP + -0x1a]
ADD RSP,0x20
POP RBP
RET
|
int1 thr_abort_locks_for_thread(long param_1,long param_2)
{
long lVar1;
int1 local_21;
long *local_20;
local_21 = 0;
inline_mysql_mutex_lock
(param_1 + 0x18,"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x545);
for (local_20 = *(long **)(param_1 + 0x60); local_20 != (long *)0x0;
local_20 = (long *)local_20[1]) {
if (*(long *)(*local_20 + 8) == param_2) {
*(int4 *)(local_20 + 8) = 0;
local_21 = 1;
inline_mysql_cond_signal(local_20[4]);
local_20[4] = 0;
lVar1 = local_20[1];
*(long *)local_20[2] = lVar1;
if (lVar1 == 0) {
*(long *)(param_1 + 0x68) = local_20[2];
}
else {
*(long *)(local_20[1] + 0x10) = local_20[2];
}
}
}
for (local_20 = *(long **)(param_1 + 0x80); local_20 != (long *)0x0;
local_20 = (long *)local_20[1]) {
if (*(long *)(*local_20 + 8) == param_2) {
*(int4 *)(local_20 + 8) = 0;
local_21 = 1;
inline_mysql_cond_signal(local_20[4]);
local_20[4] = 0;
lVar1 = local_20[1];
*(long *)local_20[2] = lVar1;
if (lVar1 == 0) {
*(long *)(param_1 + 0x88) = local_20[2];
}
else {
*(long *)(local_20[1] + 0x10) = local_20[2];
}
}
}
wake_up_waiters(param_1);
inline_mysql_mutex_unlock(param_1 + 0x18);
return local_21;
}
| |
54,704 | my_utf16_uni | eloqsql/strings/ctype-ucs2.c | int
my_utf16_uni(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
return my_mb_wc_utf16_quick(pwc, s, e);
} | O3 | c | my_utf16_uni:
pushq %rbp
movq %rsp, %rbp
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x455c0
movzbl (%rdx), %edi
movl %edi, %r9d
andl $-0x4, %r9d
xorl %eax, %eax
cmpl $0xdc, %r9d
je 0x455c0
cmpl $0xd8, %r9d
jne 0x455ad
leaq 0x4(%rdx), %r9
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rcx, %r9
ja 0x455c0
movzbl (%r8), %ecx
movl %ecx, %r8d
andl $-0x4, %r8d
movl $0x0, %eax
cmpl $0xdc, %r8d
jne 0x455c0
shll $0x12, %edi
shll $0x8, %ecx
orl %edi, %ecx
movzbl 0x1(%rdx), %eax
shll $0xa, %eax
movzbl 0x3(%rdx), %edx
andl $0xc0300, %ecx # imm = 0xC0300
orl %edx, %ecx
addl %eax, %ecx
addl $0x10000, %ecx # imm = 0x10000
movl $0x4, %eax
jmp 0x455bb
shll $0x8, %edi
movzbl 0x1(%rdx), %ecx
orl %edi, %ecx
movl $0x2, %eax
movl %ecx, %ecx
movq %rcx, (%rsi)
popq %rbp
retq
| my_utf16_uni:
push rbp
mov rbp, rsp
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja loc_455C0
movzx edi, byte ptr [rdx]
mov r9d, edi
and r9d, 0FFFFFFFCh
xor eax, eax
cmp r9d, 0DCh
jz short loc_455C0
cmp r9d, 0D8h
jnz short loc_455AD
lea r9, [rdx+4]
mov eax, 0FFFFFF98h
cmp r9, rcx
ja short loc_455C0
movzx ecx, byte ptr [r8]
mov r8d, ecx
and r8d, 0FFFFFFFCh
mov eax, 0
cmp r8d, 0DCh
jnz short loc_455C0
shl edi, 12h
shl ecx, 8
or ecx, edi
movzx eax, byte ptr [rdx+1]
shl eax, 0Ah
movzx edx, byte ptr [rdx+3]
and ecx, 0C0300h
or ecx, edx
add ecx, eax
add ecx, 10000h
mov eax, 4
jmp short loc_455BB
loc_455AD:
shl edi, 8
movzx ecx, byte ptr [rdx+1]
or ecx, edi
mov eax, 2
loc_455BB:
mov ecx, ecx
mov [rsi], rcx
loc_455C0:
pop rbp
retn
| long long my_utf16_uni(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
_BYTE *v4; // r8
long long result; // rax
int v6; // edi
int v7; // r9d
unsigned int v8; // ecx
v4 = a3 + 2;
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = *a3;
v7 = v6 & 0xFC;
result = 0LL;
if ( v7 != 220 )
{
if ( v7 != 216 )
{
v8 = (v6 << 8) | a3[1];
result = 2LL;
goto LABEL_8;
}
result = 4294967192LL;
if ( (unsigned long long)(a3 + 4) <= a4 )
{
result = 0LL;
if ( (*v4 & 0xFC) == 0xDC )
{
v8 = (a3[1] << 10) + (a3[3] | ((v6 << 18) | ((unsigned __int8)*v4 << 8)) & 0xC0300) + 0x10000;
result = 4LL;
LABEL_8:
*a2 = v8;
}
}
}
}
return result;
}
| my_utf16_uni:
PUSH RBP
MOV RBP,RSP
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001455c0
MOVZX EDI,byte ptr [RDX]
MOV R9D,EDI
AND R9D,0xfffffffc
XOR EAX,EAX
CMP R9D,0xdc
JZ 0x001455c0
CMP R9D,0xd8
JNZ 0x001455ad
LEA R9,[RDX + 0x4]
MOV EAX,0xffffff98
CMP R9,RCX
JA 0x001455c0
MOVZX ECX,byte ptr [R8]
MOV R8D,ECX
AND R8D,0xfffffffc
MOV EAX,0x0
CMP R8D,0xdc
JNZ 0x001455c0
SHL EDI,0x12
SHL ECX,0x8
OR ECX,EDI
MOVZX EAX,byte ptr [RDX + 0x1]
SHL EAX,0xa
MOVZX EDX,byte ptr [RDX + 0x3]
AND ECX,0xc0300
OR ECX,EDX
ADD ECX,EAX
ADD ECX,0x10000
MOV EAX,0x4
JMP 0x001455bb
LAB_001455ad:
SHL EDI,0x8
MOVZX ECX,byte ptr [RDX + 0x1]
OR ECX,EDI
MOV EAX,0x2
LAB_001455bb:
MOV ECX,ECX
MOV qword ptr [RSI],RCX
LAB_001455c0:
POP RBP
RET
|
int8 my_utf16_uni(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
byte bVar2;
int8 uVar3;
uint uVar4;
uVar3 = 0xffffff9a;
if (param_3 + 2 <= param_4) {
bVar1 = *param_3;
uVar3 = 0;
if ((bVar1 & 0xfc) != 0xdc) {
if ((bVar1 & 0xfc) == 0xd8) {
if (param_4 < param_3 + 4) {
return 0xffffff98;
}
bVar2 = param_3[2];
if ((bVar2 & 0xfc) != 0xdc) {
return 0;
}
uVar4 = (((uint)bVar2 << 8 | (uint)bVar1 << 0x12) & 0xc0300 | (uint)param_3[3]) +
(uint)param_3[1] * 0x400 + 0x10000;
uVar3 = 4;
}
else {
uVar4 = (uint)CONCAT11(bVar1,param_3[1]);
uVar3 = 2;
}
*param_2 = (ulong)uVar4;
}
}
return uVar3;
}
| |
54,705 | inline_mysql_file_pwrite | eloqsql/include/mysql/psi/mysql_file.h | static inline size_t
inline_mysql_file_pwrite(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, const uchar *buffer, size_t count, my_off_t offset, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_written;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_WRITE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_pwrite(file, buffer, count, offset, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_written= (result == 0) ? count : 0;
else
bytes_written= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_written);
return result;
}
#endif
result= my_pwrite(file, buffer, count, offset, flags);
return result;
} | O0 | c | inline_mysql_file_pwrite:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x20ec0c(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0x7, %edx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xb15bf
leaq 0x20ebc2(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0xf4860
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xb156a
cmpq $0x0, -0x38(%rbp)
jne 0xb154f
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0xb155a
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0xb155a
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0xb1597
cmpq $-0x1, -0x38(%rbp)
je 0xb157e
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0xb1589
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0xb1589
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x20eb1a(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq *%rax
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb15e3
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0xf4860
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
| inline_mysql_file_pwrite_1:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_88]
mov edx, 7
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_B15BF
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8, [rbp+arg_0]
call my_pwrite
mov [rbp+var_38], rax
mov rax, [rbp+arg_0]
and rax, 6
cmp rax, 0
jz short loc_B156A
cmp [rbp+var_38], 0
jnz short loc_B154F
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
jmp short loc_B155A
loc_B154F:
xor eax, eax
mov [rbp+var_98], rax
jmp short $+2
loc_B155A:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
jmp short loc_B1597
loc_B156A:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_B157E
mov rax, [rbp+var_38]
mov [rbp+var_A0], rax
jmp short loc_B1589
loc_B157E:
xor eax, eax
mov [rbp+var_A0], rax
jmp short $+2
loc_B1589:
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
loc_B1597:
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_90]
call rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
jmp short loc_B15E3
loc_B15BF:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8, [rbp+arg_0]
call my_pwrite
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_B15E3:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
| long long inline_mysql_file_pwrite_1(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
long long a5,
long long a6,
long long a7)
{
long long v8; // [rsp+0h] [rbp-A0h]
long long v9; // [rsp+8h] [rbp-98h]
_BYTE v10[72]; // [rsp+18h] [rbp-88h] BYREF
long long v11; // [rsp+60h] [rbp-40h]
long long v12; // [rsp+68h] [rbp-38h]
long long v13; // [rsp+70h] [rbp-30h]
long long v14; // [rsp+78h] [rbp-28h]
long long v15; // [rsp+80h] [rbp-20h]
unsigned int v16; // [rsp+88h] [rbp-18h]
unsigned int v17; // [rsp+8Ch] [rbp-14h]
long long v18; // [rsp+90h] [rbp-10h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v13 = a6;
v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v10, a3, 7LL);
if ( v11 )
{
((void ( *)(long long, long long, long long, _QWORD))PSI_server[66])(v11, v14, v18, v17);
v12 = my_pwrite(v16, v15, v14, v13);
if ( (a7 & 6) != 0 )
{
if ( v12 )
v9 = 0LL;
else
v9 = v14;
((void ( *)(long long, long long))PSI_server[67])(v11, v9);
}
else
{
if ( v12 == -1 )
v8 = 0LL;
else
v8 = v12;
((void ( *)(long long, long long))PSI_server[67])(v11, v8);
}
return v12;
}
else
{
return my_pwrite(v16, v15, v14, v13);
}
}
| inline_mysql_file_pwrite:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x7
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001b15bf
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x001f4860
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + 0x10]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001b156a
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001b154f
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001b155a
LAB_001b154f:
XOR EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001b155a
LAB_001b155a:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x001b1597
LAB_001b156a:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001b157e
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001b1589
LAB_001b157e:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001b1589
LAB_001b1589:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
LAB_001b1597:
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x90]
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001b15e3
LAB_001b15bf:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x001f4860
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001b15e3:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
long inline_mysql_file_pwrite
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
long param_5,int8 param_6,ulong param_7)
{
long local_a8;
long local_a0;
long local_98;
int1 local_90 [72];
long local_48;
long local_40;
int8 local_38;
long local_30;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
long local_10;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_48 = (**(code **)(PSI_server + 0x158))(local_90,param_3,7);
if (local_48 == 0) {
local_10 = my_pwrite(local_20,local_28,local_30,local_38,param_7);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,local_30,local_18,local_1c);
local_40 = my_pwrite(local_20,local_28,local_30,local_38,param_7);
if ((param_7 & 6) == 0) {
local_a8 = local_40;
if (local_40 == -1) {
local_a8 = 0;
}
local_98 = local_a8;
}
else {
if (local_40 == 0) {
local_a0 = local_30;
}
else {
local_a0 = 0;
}
local_98 = local_a0;
}
(**(code **)(PSI_server + 0x218))(local_48,local_98);
local_10 = local_40;
}
return local_10;
}
| |
54,706 | my_base64_add | eloqsql/mysys/base64.c | static inline my_bool
my_base64_add(MY_BASE64_DECODER *decoder)
{
int res;
decoder->c <<= 6;
if ((res= from_base64_table[(uchar) *decoder->src++]) < 0)
return (decoder->error= TRUE);
decoder->c+= (uint) res;
return FALSE;
} | O0 | c | my_base64_add:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
shll $0x6, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1a563e(%rip), %rax # 0x1cd4f0
movsbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0x27ecf
movq -0x10(%rbp), %rax
movl $0x1, 0x14(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x27ee0
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| my_base64_add:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov ecx, [rax+10h]
shl ecx, 6
mov [rax+10h], ecx
mov rcx, [rbp+var_10]
mov rax, [rcx]
mov rdx, rax
add rdx, 1
mov [rcx], rdx
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, from_base64_table
movsx eax, byte ptr [rax+rcx]
mov [rbp+var_14], eax
cmp eax, 0
jge short loc_27ECF
mov rax, [rbp+var_10]
mov dword ptr [rax+14h], 1
mov [rbp+var_1], 1
jmp short loc_27EE0
loc_27ECF:
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
add ecx, [rax+10h]
mov [rax+10h], ecx
mov [rbp+var_1], 0
loc_27EE0:
mov al, [rbp+var_1]
pop rbp
retn
| char my_base64_add(long long a1)
{
unsigned __int8 *v1; // rax
int v3; // [rsp+0h] [rbp-14h]
*(_DWORD *)(a1 + 16) <<= 6;
v1 = (unsigned __int8 *)(*(_QWORD *)a1)++;
v3 = from_base64_table[*v1];
if ( v3 >= 0 )
{
*(_DWORD *)(a1 + 16) += v3;
return 0;
}
else
{
*(_DWORD *)(a1 + 20) = 1;
return 1;
}
}
| my_base64_add:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x10]
SHL ECX,0x6
MOV dword ptr [RAX + 0x10],ECX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RCX]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RCX],RDX
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x2cd4f0]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JGE 0x00127ecf
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x14],0x1
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00127ee0
LAB_00127ecf:
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
ADD ECX,dword ptr [RAX + 0x10]
MOV dword ptr [RAX + 0x10],ECX
MOV byte ptr [RBP + -0x1],0x0
LAB_00127ee0:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
bool my_base64_add(int8 *param_1)
{
byte *pbVar1;
int iVar2;
bool local_9;
*(int *)(param_1 + 2) = *(int *)(param_1 + 2) << 6;
pbVar1 = (byte *)*param_1;
*param_1 = pbVar1 + 1;
iVar2 = (int)(char)from_base64_table[*pbVar1];
if (-1 < iVar2) {
*(int *)(param_1 + 2) = iVar2 + *(int *)(param_1 + 2);
}
else {
*(int4 *)((long)param_1 + 0x14) = 1;
}
local_9 = -1 >= iVar2;
return local_9;
}
| |
54,707 | ma_ft_store | eloqsql/storage/maria/ma_ft_update.c | static int _ma_ft_store(MARIA_HA *info, uint keynr, uchar *keybuf,
FT_WORD *wlist, my_off_t filepos)
{
DBUG_ENTER("_ma_ft_store");
for (; wlist->pos; wlist++)
{
MARIA_KEY key;
_ma_ft_make_key(info, &key, keynr, keybuf, wlist, filepos);
if (_ma_ck_write(info, &key))
DBUG_RETURN(1);
}
DBUG_RETURN(0);
} | O0 | c | ma_ft_store:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8e19d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x50(%rbp), %rsi
callq 0x8df30
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x838a0
cmpb $0x0, %al
je 0x8e18d
jmp 0x8e184
movl $0x1, -0x4(%rbp)
jmp 0x8e1a6
jmp 0x8e18f
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
jmp 0x8e14b
jmp 0x8e19f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
| _ma_ft_store:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
loc_8E14B:
mov rax, [rbp+var_28]
cmp qword ptr [rax], 0
jz short loc_8E19D
mov rdi, [rbp+var_10]
mov edx, [rbp+var_14]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
mov r9, [rbp+var_30]
lea rsi, [rbp+var_50]
call _ma_ft_make_key
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_50]
call _ma_ck_write
cmp al, 0
jz short loc_8E18D
jmp short $+2
loc_8E184:
mov [rbp+var_4], 1
jmp short loc_8E1A6
loc_8E18D:
jmp short $+2
loc_8E18F:
mov rax, [rbp+var_28]
add rax, 18h
mov [rbp+var_28], rax
jmp short loc_8E14B
loc_8E19D:
jmp short $+2
loc_8E19F:
mov [rbp+var_4], 0
loc_8E1A6:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long ma_ft_store(_DWORD *a1, unsigned int a2, _BYTE *a3, _QWORD *a4, long long a5)
{
_BYTE v6[32]; // [rsp+0h] [rbp-50h] BYREF
long long v7; // [rsp+20h] [rbp-30h]
_QWORD *v8; // [rsp+28h] [rbp-28h]
_BYTE *v9; // [rsp+30h] [rbp-20h]
unsigned int v10; // [rsp+3Ch] [rbp-14h]
_DWORD *v11; // [rsp+40h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v7 = a5;
while ( *v8 )
{
ma_ft_make_key(v11, (long long)v6, v10, v9, (long long)v8, v7);
if ( ma_ck_write((long long)v11, (long long)v6) )
return 1;
v8 += 3;
}
return 0;
}
| _ma_ft_store:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
LAB_0018e14b:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX],0x0
JZ 0x0018e19d
MOV RDI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x30]
LEA RSI,[RBP + -0x50]
CALL 0x0018df30
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x50]
CALL 0x001838a0
CMP AL,0x0
JZ 0x0018e18d
JMP 0x0018e184
LAB_0018e184:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0018e1a6
LAB_0018e18d:
JMP 0x0018e18f
LAB_0018e18f:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x18
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0018e14b
LAB_0018e19d:
JMP 0x0018e19f
LAB_0018e19f:
MOV dword ptr [RBP + -0x4],0x0
LAB_0018e1a6:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
_ma_ft_store(int8 param_1,int4 param_2,int8 param_3,long *param_4,
int8 param_5)
{
char cVar1;
int1 local_58 [32];
int8 local_38;
long *local_30;
int8 local_28;
int4 local_1c;
int8 local_18;
local_38 = param_5;
local_30 = param_4;
local_28 = param_3;
local_1c = param_2;
local_18 = param_1;
while( true ) {
if (*local_30 == 0) {
return 0;
}
_ma_ft_make_key(local_18,local_58,local_1c,local_28,local_30,local_38);
cVar1 = _ma_ck_write(local_18,local_58);
if (cVar1 != '\0') break;
local_30 = local_30 + 3;
}
return 1;
}
| |
54,708 | llama_grammar_accept_str(llama_grammar&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/src/llama-grammar.cpp | void llama_grammar_accept_str(struct llama_grammar & grammar, const std::string & piece) {
// Note terminating 0 in decoded string
const auto decoded = decode_utf8(piece, grammar.partial_utf8);
const auto & code_points = decoded.first;
for (auto it = code_points.begin(), end = code_points.end() - 1; it != end; ++it) {
llama_grammar_accept(&grammar, *it);
}
grammar.partial_utf8 = decoded.second;
GGML_ASSERT(!grammar.stacks.empty());
} | O1 | cpp | llama_grammar_accept_str(llama_grammar&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x38(%rdi), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xa8120
movq (%r15), %rbx
movq 0x8(%r15), %r15
addq $-0x4, %r15
cmpq %r15, %rbx
je 0xa86c7
movq %rbx, %r12
movl (%r12), %esi
movq %r14, %rdi
callq 0x66510
addq $0x4, %r12
cmpq %r15, %r12
jne 0xa86b2
movq 0x20(%rsp), %rax
movq %rax, 0x38(%r14)
movq 0x20(%r14), %rax
cmpq 0x28(%r14), %rax
je 0xa8706
testq %rbx, %rbx
je 0xa86fa
movq 0x18(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x69220
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x70f5c(%rip), %rdi # 0x119669
leaq 0x6bcb0(%rip), %rdx # 0x1143c4
leaq 0x71073(%rip), %rcx # 0x11978e
movl $0x4c0, %esi # imm = 0x4C0
xorl %eax, %eax
callq 0x6bfd0
jmp 0xa8729
movq %rax, %r14
testq %rbx, %rbx
je 0xa8741
movq 0x18(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x69220
movq %r14, %rdi
callq 0x6c640
| _Z24llama_grammar_accept_strR13llama_grammarRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r12
push rbx; char
sub rsp, 28h
mov r14, rdi
mov rdx, [rdi+38h]; int
lea r15, [rsp+48h+var_40]
mov rdi, r15; int
call _ZL11decode_utf8RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE18llama_partial_utf8; decode_utf8(std::string const&,llama_partial_utf8)
mov rbx, [r15]
mov r15, [r15+8]
add r15, 0FFFFFFFFFFFFFFFCh
cmp rbx, r15
jz short loc_A86C7
mov r12, rbx
loc_A86B2:
mov esi, [r12]; int
mov rdi, r14; int
call __Z20llama_grammar_acceptP13llama_grammarj; llama_grammar_accept(llama_grammar *,uint)
add r12, 4
cmp r12, r15
jnz short loc_A86B2
loc_A86C7:
mov rax, [rsp+48h+var_28]
mov [r14+38h], rax
mov rax, [r14+20h]
cmp rax, [r14+28h]
jz short loc_A8706
test rbx, rbx
jz short loc_A86FA
mov rsi, [rsp+48h+var_30]
sub rsi, rbx; unsigned __int64
mov rdi, rbx; void *
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
jmp __ZdlPvm; operator delete(void *,ulong)
loc_A86FA:
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
loc_A8706:
lea rdi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGrammarStacksE; "!grammar.stacks.empty()"
mov esi, 4C0h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_A8729:
mov r14, rax
test rbx, rbx
jz short loc_A8741
mov rsi, [rsp+48h+var_30]
sub rsi, rbx; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_A8741:
mov rdi, r14
call __Unwind_Resume
| void llama_grammar_accept_str(_QWORD *a1, long long a2)
{
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
void *v6; // rbx
int *v7; // r15
int *v8; // r12
long long v9; // rax
long long v10; // r14
int v11; // [rsp+0h] [rbp-48h]
void *v12; // [rsp+8h] [rbp-40h] BYREF
long long v13; // [rsp+10h] [rbp-38h]
long long v14; // [rsp+18h] [rbp-30h]
long long v15; // [rsp+20h] [rbp-28h]
char v16; // [rsp+28h] [rbp-20h]
decode_utf8((long long)&v12, a2, a1[7]);
v6 = v12;
v7 = (int *)(v13 - 4);
if ( v12 != (void *)(v13 - 4) )
{
v8 = (int *)v12;
do
llama_grammar_accept((int)a1, *v8++, v2, v3, v4, v5, v11, v12, v13, v14, v15, v16);
while ( v8 != v7 );
}
a1[7] = v15;
if ( a1[4] == a1[5] )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/src/llama-grammar.cpp",
1216LL,
"GGML_ASSERT(%s) failed",
"!grammar.stacks.empty()");
v10 = v9;
if ( v6 )
operator delete(v6, v14 - (_QWORD)v6);
_Unwind_Resume(v10);
}
if ( v6 )
operator delete(v6, v14 - (_QWORD)v6);
}
| llama_grammar_accept_str:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDI
MOV RDX,qword ptr [RDI + 0x38]
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x001a8120
MOV RBX,qword ptr [R15]
MOV R15,qword ptr [R15 + 0x8]
ADD R15,-0x4
CMP RBX,R15
JZ 0x001a86c7
MOV R12,RBX
LAB_001a86b2:
MOV ESI,dword ptr [R12]
LAB_001a86b6:
MOV RDI,R14
CALL 0x00166510
ADD R12,0x4
CMP R12,R15
JNZ 0x001a86b2
LAB_001a86c7:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [R14 + 0x38],RAX
MOV RAX,qword ptr [R14 + 0x20]
CMP RAX,qword ptr [R14 + 0x28]
JZ 0x001a8706
TEST RBX,RBX
JZ 0x001a86fa
MOV RSI,qword ptr [RSP + 0x18]
SUB RSI,RBX
MOV RDI,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
JMP 0x00169220
LAB_001a86fa:
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
LAB_001a8706:
LEA RDI,[0x219669]
LEA RDX,[0x2143c4]
LEA RCX,[0x21978e]
MOV ESI,0x4c0
XOR EAX,EAX
CALL 0x0016bfd0
|
/* llama_grammar_accept_str(llama_grammar&, std::__cxx11::string const&) */
void llama_grammar_accept_str(llama_grammar *param_1,string *param_2)
{
uint *puVar1;
uint *local_40;
long local_38;
long local_30;
int8 local_28;
decode_utf8(&local_40,param_2,*(int8 *)(param_1 + 0x38));
for (puVar1 = local_40; puVar1 != (uint *)(local_38 + -4); puVar1 = puVar1 + 1) {
/* try { // try from 001a86b6 to 001a86bd has its CatchHandler @ 001a8729 */
llama_grammar_accept(param_1,*puVar1);
}
*(int8 *)(param_1 + 0x38) = local_28;
if (*(long *)(param_1 + 0x20) != *(long *)(param_1 + 0x28)) {
if (local_40 != (uint *)0x0) {
operator_delete(local_40,local_30 - (long)local_40);
return;
}
return;
}
/* try { // try from 001a8706 to 001a8726 has its CatchHandler @ 001a8727 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/src/llama-grammar.cpp",0x4c0
,"GGML_ASSERT(%s) failed","!grammar.stacks.empty()");
}
| |
54,709 | ggml_compute_forward_silu | monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c | static void ggml_compute_forward_silu(
const struct ggml_compute_params * params,
struct ggml_tensor * dst) {
const struct ggml_tensor * src0 = dst->src[0];
switch (src0->type) {
case GGML_TYPE_F32:
{
ggml_compute_forward_silu_f32(params, dst);
} break;
default:
{
GGML_ABORT("fatal error");
}
}
} | O0 | c | ggml_compute_forward_silu:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl (%rax), %eax
testl %eax, %eax
jne 0x3c8ab
jmp 0x3c89a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3d730
jmp 0x3c8c5
leaq 0x752a8(%rip), %rdi # 0xb1b5a
movl $0x1a21, %esi # imm = 0x1A21
leaq 0x75409(%rip), %rdx # 0xb1cc7
movb $0x0, %al
callq 0xd030
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| ggml_compute_forward_silu:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rax, [rsp+18h+var_10]
mov rax, [rax+98h]
mov [rsp+18h+var_18], rax
mov rax, [rsp+18h+var_18]
mov eax, [rax]
test eax, eax
jnz short loc_3C8AB
jmp short $+2
loc_3C89A:
mov rdi, [rsp+18h+var_8]
mov rsi, [rsp+18h+var_10]
call ggml_compute_forward_silu_f32
jmp short loc_3C8C5
loc_3C8AB:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1A21h
lea rdx, aFatalError; "fatal error"
mov al, 0
call _ggml_abort
loc_3C8C5:
add rsp, 18h
retn
| double ggml_compute_forward_silu(long long a1, long long a2)
{
double result; // xmm0_8
if ( **(_DWORD **)(a2 + 152) )
return ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c",
6689LL,
"fatal error");
ggml_compute_forward_silu_f32(a1, a2);
return result;
}
| ggml_compute_forward_silu:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNZ 0x0013c8ab
JMP 0x0013c89a
LAB_0013c89a:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0013d730
JMP 0x0013c8c5
LAB_0013c8ab:
LEA RDI,[0x1b1b5a]
MOV ESI,0x1a21
LEA RDX,[0x1b1cc7]
MOV AL,0x0
CALL 0x0010d030
LAB_0013c8c5:
ADD RSP,0x18
RET
|
void ggml_compute_forward_silu(int8 param_1,long param_2)
{
if (**(int **)(param_2 + 0x98) == 0) {
ggml_compute_forward_silu_f32(param_1,param_2);
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c"
,0x1a21,"fatal error");
}
| |
54,710 | mysql_options4 | eloqsql/sql-common/client.c | int STDCALL
mysql_options4(MYSQL *mysql,enum mysql_option option,
const void *arg1, const void *arg2)
{
DBUG_ENTER("mysql_option");
DBUG_PRINT("enter",("option: %d",(int) option));
switch (option)
{
case MYSQL_OPT_CONNECT_ATTR_ADD:
{
LEX_STRING *elt;
char *key, *value;
size_t key_len= arg1 ? strlen(arg1) : 0,
value_len= arg2 ? strlen(arg2) : 0;
size_t attr_storage_length= key_len + value_len;
/* we can't have a zero length key */
if (!key_len)
{
set_mysql_error(mysql, CR_INVALID_PARAMETER_NO, unknown_sqlstate);
DBUG_RETURN(1);
}
/* calculate the total storage length of the attribute */
attr_storage_length+= get_length_store_length(key_len);
attr_storage_length+= get_length_store_length(value_len);
ENSURE_EXTENSIONS_PRESENT(&mysql->options);
/*
Throw and error if the maximum combined length of the attribute value
will be greater than the maximum that we can safely transmit.
*/
if (attr_storage_length +
mysql->options.extension->connection_attributes_length >
MAX_CONNECTION_ATTR_STORAGE_LENGTH)
{
set_mysql_error(mysql, CR_INVALID_PARAMETER_NO, unknown_sqlstate);
DBUG_RETURN(1);
}
if (!my_hash_inited(&mysql->options.extension->connection_attributes))
{
if (my_hash_init(key_memory_mysql_options,
&mysql->options.extension->connection_attributes,
&my_charset_bin, 0, 0, 0, (my_hash_get_key)
get_attr_key, my_free, HASH_UNIQUE))
{
set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
DBUG_RETURN(1);
}
}
if (!my_multi_malloc(key_memory_mysql_options, MYF(MY_WME),
&elt, 2 * sizeof(LEX_STRING),
&key, key_len + 1,
&value, value_len + 1,
NULL))
{
set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
DBUG_RETURN(1);
}
elt[0].str= key; elt[0].length= key_len;
elt[1].str= value; elt[1].length= value_len;
if (key_len)
memcpy(key, arg1, key_len);
key[key_len]= 0;
if (value_len)
memcpy(value, arg2, value_len);
value[value_len]= 0;
if (my_hash_insert(&mysql->options.extension->connection_attributes,
(uchar *) elt))
{
/* can't insert the value */
my_free(elt);
set_mysql_error(mysql, CR_DUPLICATE_CONNECTION_ATTR,
unknown_sqlstate);
DBUG_RETURN(1);
}
mysql->options.extension->connection_attributes_length+=
attr_storage_length;
break;
}
default:
DBUG_RETURN(1);
}
DBUG_RETURN(0);
} | O0 | c | mysql_options4:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
jmp 0xbe1a3c
movl -0x14(%rbp), %eax
subl $0x21, %eax
jne 0xbe1d3f
jmp 0xbe1a4a
cmpq $0x0, -0x20(%rbp)
je 0xbe1a60
movq -0x20(%rbp), %rdi
callq 0x7585f0
movq %rax, -0x60(%rbp)
jmp 0xbe1a68
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0xbe1a68
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xbe1a86
movq -0x28(%rbp), %rdi
callq 0x7585f0
movq %rax, -0x68(%rbp)
jmp 0xbe1a8e
xorl %eax, %eax
movq %rax, -0x68(%rbp)
jmp 0xbe1a8e
movq -0x68(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xbe1aca
movq -0x10(%rbp), %rdi
movq 0xf04f2c(%rip), %rdx # 0x1ae69e0
movl $0x7f2, %esi # imm = 0x7F2
callq 0xbdb3b0
movl $0x1, -0x4(%rbp)
jmp 0xbe1d53
movq -0x48(%rbp), %rdi
callq 0xbe1990
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0xbe1990
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x488(%rax)
jne 0xbe1b1d
movl 0x111afd0(%rip), %edi # 0x1cfcad0
movl $0xa0, %esi
movl $0x30, %edx
callq 0x12c71a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x488(%rax)
jmp 0xbe1b1f
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x488(%rcx), %rcx
addq 0x98(%rcx), %rax
cmpq $0x10000, %rax # imm = 0x10000
jbe 0xbe1b5e
movq -0x10(%rbp), %rdi
movq 0xf04e98(%rip), %rdx # 0x1ae69e0
movl $0x7f2, %esi # imm = 0x7F2
callq 0xbdb3b0
movl $0x1, -0x4(%rbp)
jmp 0xbe1d53
movq -0x10(%rbp), %rax
movq 0x488(%rax), %rax
cmpq $0x0, 0x38(%rax)
jne 0xbe1bf7
movl 0x111af56(%rip), %edi # 0x1cfcad0
movq -0x10(%rbp), %rax
movq 0x488(%rax), %rsi
addq $0x28, %rsi
xorl %edx, %edx
leaq 0xf2f88e(%rip), %rcx # 0x1b11420
xorl %eax, %eax
movl %eax, %r9d
leaq -0x1ae(%rip), %r10 # 0xbe19f0
leaq 0x6e597b(%rip), %rax # 0x12c7520
movq %r9, %r8
movq $0x0, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
callq 0x12a9c60
cmpb $0x0, %al
je 0xbe1bf5
movq -0x10(%rbp), %rdi
movq 0xf04e01(%rip), %rdx # 0x1ae69e0
movl $0x7d8, %esi # imm = 0x7D8
callq 0xbdb3b0
movl $0x1, -0x4(%rbp)
jmp 0xbe1d53
jmp 0xbe1bf7
movl 0x111aed3(%rip), %edi # 0x1cfcad0
movq -0x48(%rbp), %r9
addq $0x1, %r9
movq -0x50(%rbp), %rax
addq $0x1, %rax
movl $0x10, %esi
leaq -0x30(%rbp), %rdx
movl $0x20, %ecx
leaq -0x38(%rbp), %r8
leaq -0x40(%rbp), %r10
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, %al
callq 0x12bb660
cmpq $0x0, %rax
jne 0xbe1c66
movq -0x10(%rbp), %rdi
movq 0xf04d90(%rip), %rdx # 0x1ae69e0
movl $0x7d8, %esi # imm = 0x7D8
callq 0xbdb3b0
movl $0x1, -0x4(%rbp)
jmp 0xbe1d53
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpq $0x0, -0x48(%rbp)
je 0xbe1cad
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x759350
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, -0x50(%rbp)
je 0xbe1cd1
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x759350
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x488(%rax), %rdi
addq $0x28, %rdi
movq -0x30(%rbp), %rsi
callq 0x12aa280
cmpb $0x0, %al
je 0xbe1d20
movq -0x30(%rbp), %rdi
callq 0x12c7520
movq -0x10(%rbp), %rdi
movq 0xf04cd3(%rip), %rdx # 0x1ae69e0
movl $0x80c, %esi # imm = 0x80C
callq 0xbdb3b0
movl $0x1, -0x4(%rbp)
jmp 0xbe1d53
movq -0x58(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x488(%rax), %rax
addq 0x98(%rax), %rcx
movq %rcx, 0x98(%rax)
jmp 0xbe1d4a
jmp 0xbe1d41
movl $0x1, -0x4(%rbp)
jmp 0xbe1d53
jmp 0xbe1d4c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nop
| mysql_options4:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
jmp short $+2
loc_BE1A3C:
mov eax, [rbp+var_14]
sub eax, 21h ; '!'
jnz loc_BE1D3F
jmp short $+2
loc_BE1A4A:
cmp [rbp+var_20], 0
jz short loc_BE1A60
mov rdi, [rbp+var_20]
call _strlen
mov [rbp+var_60], rax
jmp short loc_BE1A68
loc_BE1A60:
xor eax, eax
mov [rbp+var_60], rax
jmp short $+2
loc_BE1A68:
mov rax, [rbp+var_60]
mov [rbp+var_48], rax
cmp [rbp+var_28], 0
jz short loc_BE1A86
mov rdi, [rbp+var_28]
call _strlen
mov [rbp+var_68], rax
jmp short loc_BE1A8E
loc_BE1A86:
xor eax, eax
mov [rbp+var_68], rax
jmp short $+2
loc_BE1A8E:
mov rax, [rbp+var_68]
mov [rbp+var_50], rax
mov rax, [rbp+var_48]
add rax, [rbp+var_50]
mov [rbp+var_58], rax
cmp [rbp+var_48], 0
jnz short loc_BE1ACA
mov rdi, [rbp+var_10]
mov rdx, cs:unknown_sqlstate
mov esi, 7F2h
call set_mysql_error
mov [rbp+var_4], 1
jmp loc_BE1D53
loc_BE1ACA:
mov rdi, [rbp+var_48]
call get_length_store_length
add rax, [rbp+var_58]
mov [rbp+var_58], rax
mov rdi, [rbp+var_50]
call get_length_store_length
add rax, [rbp+var_58]
mov [rbp+var_58], rax
mov rax, [rbp+var_10]
cmp qword ptr [rax+488h], 0
jnz short loc_BE1B1D
mov edi, cs:key_memory_mysql_options
mov esi, 0A0h
mov edx, 30h ; '0'
call my_malloc
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+488h], rcx
loc_BE1B1D:
jmp short $+2
loc_BE1B1F:
mov rax, [rbp+var_58]
mov rcx, [rbp+var_10]
mov rcx, [rcx+488h]
add rax, [rcx+98h]
cmp rax, 10000h
jbe short loc_BE1B5E
mov rdi, [rbp+var_10]
mov rdx, cs:unknown_sqlstate
mov esi, 7F2h
call set_mysql_error
mov [rbp+var_4], 1
jmp loc_BE1D53
loc_BE1B5E:
mov rax, [rbp+var_10]
mov rax, [rax+488h]
cmp qword ptr [rax+38h], 0
jnz loc_BE1BF7
mov edi, cs:key_memory_mysql_options
mov rax, [rbp+var_10]
mov rsi, [rax+488h]
add rsi, 28h ; '('
xor edx, edx
lea rcx, my_charset_bin
xor eax, eax
mov r9d, eax
lea r10, get_attr_key
lea rax, my_free
mov r8, r9
mov [rsp+90h+var_90], 0
mov [rsp+90h+var_88], r10
mov [rsp+90h+var_80], 0
mov [rsp+90h+var_78], rax
mov [rsp+90h+var_70], 1
call my_hash_init2
cmp al, 0
jz short loc_BE1BF5
mov rdi, [rbp+var_10]
mov rdx, cs:unknown_sqlstate
mov esi, 7D8h
call set_mysql_error
mov [rbp+var_4], 1
jmp loc_BE1D53
loc_BE1BF5:
jmp short $+2
loc_BE1BF7:
mov edi, cs:key_memory_mysql_options
mov r9, [rbp+var_48]
add r9, 1
mov rax, [rbp+var_50]
add rax, 1
mov esi, 10h
lea rdx, [rbp+var_30]
mov ecx, 20h ; ' '
lea r8, [rbp+var_38]
lea r10, [rbp+var_40]
xor r11d, r11d
mov [rsp+90h+var_90], r10
mov [rsp+90h+var_88], rax
mov [rsp+90h+var_80], 0
mov al, 0
call my_multi_malloc
cmp rax, 0
jnz short loc_BE1C66
mov rdi, [rbp+var_10]
mov rdx, cs:unknown_sqlstate
mov esi, 7D8h
call set_mysql_error
mov [rbp+var_4], 1
jmp loc_BE1D53
loc_BE1C66:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_30]
mov [rax], rcx
mov rcx, [rbp+var_48]
mov rax, [rbp+var_30]
mov [rax+8], rcx
mov rcx, [rbp+var_40]
mov rax, [rbp+var_30]
mov [rax+10h], rcx
mov rcx, [rbp+var_50]
mov rax, [rbp+var_30]
mov [rax+18h], rcx
cmp [rbp+var_48], 0
jz short loc_BE1CAD
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_48]
call _memcpy
loc_BE1CAD:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_48]
mov byte ptr [rax+rcx], 0
cmp [rbp+var_50], 0
jz short loc_BE1CD1
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_50]
call _memcpy
loc_BE1CD1:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_50]
mov byte ptr [rax+rcx], 0
mov rax, [rbp+var_10]
mov rdi, [rax+488h]
add rdi, 28h ; '('
mov rsi, [rbp+var_30]
call my_hash_insert
cmp al, 0
jz short loc_BE1D20
mov rdi, [rbp+var_30]
call my_free
mov rdi, [rbp+var_10]
mov rdx, cs:unknown_sqlstate
mov esi, 80Ch
call set_mysql_error
mov [rbp+var_4], 1
jmp short loc_BE1D53
loc_BE1D20:
mov rcx, [rbp+var_58]
mov rax, [rbp+var_10]
mov rax, [rax+488h]
add rcx, [rax+98h]
mov [rax+98h], rcx
jmp short loc_BE1D4A
loc_BE1D3F:
jmp short $+2
loc_BE1D41:
mov [rbp+var_4], 1
jmp short loc_BE1D53
loc_BE1D4A:
jmp short $+2
loc_BE1D4C:
mov [rbp+var_4], 0
loc_BE1D53:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
| long long mysql_options4(long long a1, int a2, long long a3, long long a4)
{
long long v5; // [rsp+28h] [rbp-68h]
long long v6; // [rsp+30h] [rbp-60h]
long long v7; // [rsp+38h] [rbp-58h]
long long v8; // [rsp+38h] [rbp-58h]
long long v9; // [rsp+50h] [rbp-40h] BYREF
long long v10; // [rsp+58h] [rbp-38h] BYREF
_QWORD *v11; // [rsp+60h] [rbp-30h] BYREF
long long v12; // [rsp+68h] [rbp-28h]
long long v13; // [rsp+70h] [rbp-20h]
int v14; // [rsp+7Ch] [rbp-14h]
long long v15; // [rsp+80h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
if ( a2 == 33 )
{
if ( v13 )
v6 = strlen(v13);
else
v6 = 0LL;
if ( v12 )
v5 = strlen(v12);
else
v5 = 0LL;
if ( !v6 )
goto LABEL_9;
v7 = v5 + v6 + get_length_store_length(v6);
v8 = v7 + get_length_store_length(v5);
if ( !*(_QWORD *)(v15 + 1160) )
*(_QWORD *)(v15 + 1160) = my_malloc((unsigned int)key_memory_mysql_options, 160LL, 48LL);
if ( (unsigned long long)(*(_QWORD *)(*(_QWORD *)(v15 + 1160) + 152LL) + v8) <= 0x10000 )
{
if ( *(_QWORD *)(*(_QWORD *)(v15 + 1160) + 56LL)
|| !(unsigned __int8)my_hash_init2(
key_memory_mysql_options,
*(_DWORD *)(v15 + 1160) + 40,
0,
(unsigned int)&my_charset_bin,
0,
0,
0LL,
(long long)get_attr_key,
0LL,
(long long)my_free,
1) )
{
if ( my_multi_malloc(
key_memory_mysql_options,
16,
(unsigned int)&v11,
32,
(unsigned int)&v10,
(int)v6 + 1,
&v9,
v5 + 1,
0LL) )
{
*v11 = v10;
v11[1] = v6;
v11[2] = v9;
v11[3] = v5;
memcpy(v10, v13, v6);
*(_BYTE *)(v10 + v6) = 0;
if ( v5 )
memcpy(v9, v12, v5);
*(_BYTE *)(v9 + v5) = 0;
if ( (unsigned __int8)my_hash_insert(*(_QWORD *)(v15 + 1160) + 40LL, v11) )
{
my_free(v11);
set_mysql_error(v15, 2060, (long long)unknown_sqlstate);
return 1;
}
else
{
*(_QWORD *)(*(_QWORD *)(v15 + 1160) + 152LL) += v8;
return 0;
}
}
else
{
set_mysql_error(v15, 2008, (long long)unknown_sqlstate);
return 1;
}
}
else
{
set_mysql_error(v15, 2008, (long long)unknown_sqlstate);
return 1;
}
}
else
{
LABEL_9:
set_mysql_error(v15, 2034, (long long)unknown_sqlstate);
return 1;
}
}
else
{
return 1;
}
}
| wait_for_prior_commit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RDI
ADD RDI,0x90
MOV ESI,0x2
CALL 0x00993940
CMP RAX,0x0
JZ 0x00be1a61
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0098ec40
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00be1a8b
LAB_00be1a61:
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0xa0],0x0
JZ 0x00be1a7e
MOV EDI,0x7ac
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x013bf0d0
LAB_00be1a7e:
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0xa0]
MOV dword ptr [RBP + -0x4],EAX
LAB_00be1a8b:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
/* wait_for_commit::wait_for_prior_commit(THD*) */
int4 __thiscall wait_for_commit::wait_for_prior_commit(wait_for_commit *this,THD *param_1)
{
long lVar1;
int4 local_c;
lVar1 = std::atomic<wait_for_commit*>::load((atomic<wait_for_commit*> *)(this + 0x90),2);
if (lVar1 == 0) {
if (*(int *)(this + 0xa0) != 0) {
my_error(0x7ac,0);
}
local_c = *(int4 *)(this + 0xa0);
}
else {
local_c = wait_for_prior_commit2(this,param_1);
}
return local_c;
}
| |
54,711 | google::protobuf::io::CodedInputStream::ReadStringFallback(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/coded_stream.cc | bool CodedInputStream::ReadStringFallback(std::string* buffer, int size) {
if (!buffer->empty()) {
buffer->clear();
}
int closest_limit = std::min(current_limit_, total_bytes_limit_);
if (closest_limit != INT_MAX) {
int bytes_to_limit = closest_limit - CurrentPosition();
if (bytes_to_limit > 0 && size > 0 && size <= bytes_to_limit) {
buffer->reserve(size);
}
}
int current_buffer_size;
while ((current_buffer_size = BufferSize()) < size) {
// Some STL implementations "helpfully" crash on buffer->append(NULL, 0).
if (current_buffer_size != 0) {
// Note: string1.append(string2) is O(string2.size()) (as opposed to
// O(string1.size() + string2.size()), which would be bad).
buffer->append(reinterpret_cast<const char*>(buffer_),
current_buffer_size);
}
size -= current_buffer_size;
Advance(current_buffer_size);
if (!Refresh()) return false;
}
buffer->append(reinterpret_cast<const char*>(buffer_), size);
Advance(size);
return true;
} | O3 | cpp | google::protobuf::io::CodedInputStream::ReadStringFallback(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x79643
movq $0x0, 0x8(%r14)
movq (%r14), %rax
movb $0x0, (%rax)
movl 0x28(%rbx), %eax
movl 0x30(%rbx), %ecx
cmpl %eax, %ecx
cmovll %ecx, %eax
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
je 0x7967b
movl 0x8(%rbx), %ecx
subl (%rbx), %ecx
subl 0x18(%rbx), %eax
addl 0x2c(%rbx), %eax
addl %ecx, %eax
cmpl %r15d, %eax
jl 0x7967b
testl %r15d, %r15d
jle 0x7967b
testl %eax, %eax
jle 0x7967b
movl %r15d, %esi
movq %r14, %rdi
callq 0x2d120
movl %r15d, %ebp
movq (%rbx), %rsi
movq 0x8(%rbx), %r13
subq %rsi, %r13
movl %r15d, %r12d
subl %r13d, %r12d
jle 0x796ba
movl %ebp, %r15d
testl %r13d, %r13d
je 0x796ac
movslq %r13d, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x2c280
addq %r15, (%rbx)
movl %r12d, %r15d
movq %rbx, %rdi
callq 0x793f6
testb %al, %al
jne 0x7967b
jmp 0x796cb
movslq %ebp, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x2c280
addq %r15, (%rbx)
cmpl %r13d, %ebp
setle %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN6google8protobuf2io16CodedInputStream18ReadStringFallbackEPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15d, edx
mov r14, rsi
mov rbx, rdi
cmp qword ptr [rsi+8], 0
jz short loc_79643
mov qword ptr [r14+8], 0
mov rax, [r14]
mov byte ptr [rax], 0
loc_79643:
mov eax, [rbx+28h]
mov ecx, [rbx+30h]
cmp ecx, eax
cmovl eax, ecx
cmp eax, 7FFFFFFFh
jz short loc_7967B
mov ecx, [rbx+8]
sub ecx, [rbx]
sub eax, [rbx+18h]
add eax, [rbx+2Ch]
add eax, ecx
cmp eax, r15d
jl short loc_7967B
test r15d, r15d
jle short loc_7967B
test eax, eax
jle short loc_7967B
mov esi, r15d
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
loc_7967B:
mov ebp, r15d
mov rsi, [rbx]
mov r13, [rbx+8]
sub r13, rsi
mov r12d, r15d
sub r12d, r13d
jle short loc_796BA
mov r15d, ebp
test r13d, r13d
jz short loc_796AC
movsxd r15, r13d
mov rdi, r14
mov rdx, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
add [rbx], r15
mov r15d, r12d
loc_796AC:
mov rdi, rbx; this
call _ZN6google8protobuf2io16CodedInputStream7RefreshEv; google::protobuf::io::CodedInputStream::Refresh(void)
test al, al
jnz short loc_7967B
jmp short loc_796CB
loc_796BA:
movsxd r15, ebp
mov rdi, r14
mov rdx, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
add [rbx], r15
loc_796CB:
cmp ebp, r13d
setle al
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| bool google::protobuf::io::CodedInputStream::ReadStringFallback(
google::protobuf::io::CodedInputStream *this,
long long a2,
int a3)
{
int v3; // r15d
int v5; // eax
int v6; // eax
int v7; // ebp
long long v8; // rsi
long long v9; // r13
v3 = a3;
if ( *(_QWORD *)(a2 + 8) )
{
*(_QWORD *)(a2 + 8) = 0LL;
**(_BYTE **)a2 = 0;
}
v5 = *((_DWORD *)this + 10);
if ( *((_DWORD *)this + 12) < v5 )
v5 = *((_DWORD *)this + 12);
if ( v5 != 0x7FFFFFFF )
{
v6 = *((_DWORD *)this + 2) - *(_DWORD *)this + *((_DWORD *)this + 11) + v5 - *((_DWORD *)this + 6);
if ( v6 >= a3 && a3 > 0 && v6 > 0 )
std::string::reserve(a2, (unsigned int)a3);
}
while ( 1 )
{
v7 = v3;
v8 = *(_QWORD *)this;
v9 = *((_QWORD *)this + 1) - *(_QWORD *)this;
if ( v3 <= (int)v9 )
break;
if ( (_DWORD)v9 )
{
std::string::append(a2, v8, (int)v9);
*(_QWORD *)this += (int)v9;
v3 -= v9;
}
if ( !(unsigned __int8)google::protobuf::io::CodedInputStream::Refresh(this) )
return v7 <= (int)v9;
}
std::string::append(a2, v8, v3);
*(_QWORD *)this += v3;
return v7 <= (int)v9;
}
| ReadStringFallback:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15D,EDX
MOV R14,RSI
MOV RBX,RDI
CMP qword ptr [RSI + 0x8],0x0
JZ 0x00179643
MOV qword ptr [R14 + 0x8],0x0
MOV RAX,qword ptr [R14]
MOV byte ptr [RAX],0x0
LAB_00179643:
MOV EAX,dword ptr [RBX + 0x28]
MOV ECX,dword ptr [RBX + 0x30]
CMP ECX,EAX
CMOVL EAX,ECX
CMP EAX,0x7fffffff
JZ 0x0017967b
MOV ECX,dword ptr [RBX + 0x8]
SUB ECX,dword ptr [RBX]
SUB EAX,dword ptr [RBX + 0x18]
ADD EAX,dword ptr [RBX + 0x2c]
ADD EAX,ECX
CMP EAX,R15D
JL 0x0017967b
TEST R15D,R15D
JLE 0x0017967b
TEST EAX,EAX
JLE 0x0017967b
MOV ESI,R15D
MOV RDI,R14
CALL 0x0012d120
LAB_0017967b:
MOV EBP,R15D
MOV RSI,qword ptr [RBX]
MOV R13,qword ptr [RBX + 0x8]
SUB R13,RSI
MOV R12D,R15D
SUB R12D,R13D
JLE 0x001796ba
MOV R15D,EBP
TEST R13D,R13D
JZ 0x001796ac
MOVSXD R15,R13D
MOV RDI,R14
MOV RDX,R15
CALL 0x0012c280
ADD qword ptr [RBX],R15
MOV R15D,R12D
LAB_001796ac:
MOV RDI,RBX
CALL 0x001793f6
TEST AL,AL
JNZ 0x0017967b
JMP 0x001796cb
LAB_001796ba:
MOVSXD R15,EBP
MOV RDI,R14
MOV RDX,R15
CALL 0x0012c280
ADD qword ptr [RBX],R15
LAB_001796cb:
CMP EBP,R13D
SETLE AL
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::io::CodedInputStream::ReadStringFallback(std::__cxx11::string*, int) */
bool __thiscall
google::protobuf::io::CodedInputStream::ReadStringFallback
(CodedInputStream *this,string *param_1,int param_2)
{
char *pcVar1;
char cVar2;
int iVar3;
int iVar4;
if (*(long *)(param_1 + 8) != 0) {
*(int8 *)(param_1 + 8) = 0;
**(int1 **)param_1 = 0;
}
iVar3 = *(int *)(this + 0x28);
if (*(int *)(this + 0x30) < *(int *)(this + 0x28)) {
iVar3 = *(int *)(this + 0x30);
}
if ((((iVar3 != 0x7fffffff) &&
(iVar3 = (iVar3 - *(int *)(this + 0x18)) + *(int *)(this + 0x2c) +
(*(int *)(this + 8) - *(int *)this), param_2 <= iVar3)) && (0 < param_2)) &&
(0 < iVar3)) {
std::__cxx11::string::reserve(param_1,(ulong)(uint)param_2);
}
do {
iVar4 = param_2;
pcVar1 = *(char **)this;
iVar3 = (int)*(int8 *)(this + 8) - (int)pcVar1;
if (iVar4 - iVar3 == 0 || iVar4 < iVar3) {
std::__cxx11::string::append(param_1,pcVar1,(long)iVar4);
*(long *)this = *(long *)this + (long)iVar4;
break;
}
param_2 = iVar4;
if (iVar3 != 0) {
std::__cxx11::string::append(param_1,pcVar1,(long)iVar3);
*(long *)this = *(long *)this + (long)iVar3;
param_2 = iVar4 - iVar3;
}
cVar2 = Refresh(this);
} while (cVar2 != '\0');
return iVar4 <= iVar3;
}
| |
54,712 | sp_get_linestring_mbr | eloqsql/storage/maria/ma_sp_key.c | static int sp_get_linestring_mbr(uchar *(*wkb), uchar *end, uint n_dims,
uchar byte_order, double *mbr)
{
uint n_points;
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;
} | O0 | c | sp_get_linestring_mbr:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x2c(%rbp)
jbe 0x8a591
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x1d(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x8a660
cmpl $0x0, %eax
je 0x8a584
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8a598
jmp 0x8a586
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x8a556
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| sp_get_linestring_mbr:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, cl
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_1D], al
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_2C], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_8A556:
cmp [rbp+var_2C], 0
jbe short loc_8A591
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_1D]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_add_point_to_mbr
cmp eax, 0
jz short loc_8A584
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_8A598
loc_8A584:
jmp short $+2
loc_8A586:
mov eax, [rbp+var_2C]
add eax, 0FFFFFFFFh
mov [rbp+var_2C], eax
jmp short loc_8A556
loc_8A591:
mov [rbp+var_4], 0
loc_8A598:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long sp_get_linestring_mbr(_DWORD **a1, long long a2, unsigned int a3, unsigned __int8 a4, long long a5)
{
int i; // [rsp+4h] [rbp-2Ch]
for ( i = *(*a1)++; i; --i )
{
if ( (unsigned int)sp_add_point_to_mbr(a1, a2, a3, a4, a5) )
return (unsigned int)-1;
}
return 0;
}
| sp_get_linestring_mbr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,CL
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV byte ptr [RBP + -0x1d],AL
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_0018a556:
CMP dword ptr [RBP + -0x2c],0x0
JBE 0x0018a591
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x1d]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x0018a660
CMP EAX,0x0
JZ 0x0018a584
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0018a598
LAB_0018a584:
JMP 0x0018a586
LAB_0018a586:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0018a556
LAB_0018a591:
MOV dword ptr [RBP + -0x4],0x0
LAB_0018a598:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4
sp_get_linestring_mbr
(long *param_1,int8 param_2,int4 param_3,int1 param_4,int8 param_5
)
{
int iVar1;
int local_34;
local_34 = *(int *)*param_1;
*param_1 = *param_1 + 4;
while( true ) {
if (local_34 == 0) {
return 0;
}
iVar1 = sp_add_point_to_mbr(param_1,param_2,param_3,param_4,param_5);
if (iVar1 != 0) break;
local_34 = local_34 + -1;
}
return 0xffffffff;
}
| |
54,713 | PFS_account::aggregate_statements(PFS_user*, PFS_host*) | eloqsql/storage/perfschema/pfs_account.cc | void PFS_account::aggregate_statements(PFS_user *safe_user, PFS_host *safe_host)
{
if (read_instr_class_statements_stats() == NULL)
return;
if (likely(safe_user != NULL && safe_host != NULL))
{
/*
Aggregate EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME
- EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME
in parallel.
*/
aggregate_all_statements(write_instr_class_statements_stats(),
safe_user->write_instr_class_statements_stats(),
safe_host->write_instr_class_statements_stats());
return;
}
if (safe_user != NULL)
{
/*
Aggregate EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME
- EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME
in parallel.
*/
aggregate_all_statements(write_instr_class_statements_stats(),
safe_user->write_instr_class_statements_stats(),
global_instr_class_statements_array);
return;
}
if (safe_host != NULL)
{
/*
Aggregate EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME
*/
aggregate_all_statements(write_instr_class_statements_stats(),
safe_host->write_instr_class_statements_stats());
return;
}
/*
Aggregate EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME
*/
aggregate_all_statements(write_instr_class_statements_stats(),
global_instr_class_statements_array);
return;
} | O3 | cpp | PFS_account::aggregate_statements(PFS_user*, PFS_host*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rbx
testq %rbx, %rbx
setne %al
andb 0x2(%rdi), %al
cmpb $0x1, %al
jne 0x41a72
movq %rdx, %r14
movq %rsi, %r15
testq %rsi, %rsi
je 0x41a7d
testq %r14, %r14
je 0x41a7d
testb $0x1, 0x2(%r15)
jne 0x41a41
movq %r15, %rdi
callq 0x42b46
movb $0x1, 0x2(%r15)
movq 0x18(%r15), %r15
cmpb $0x0, 0x2(%r14)
jne 0x41a59
movq %r14, %rdi
callq 0x42b46
movb $0x1, 0x2(%r14)
movq 0x18(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x34226
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testq %r15, %r15
je 0x41aa9
testb $0x1, 0x2(%r15)
jne 0x41a96
movq %r15, %rdi
callq 0x42b46
movb $0x1, 0x2(%r15)
movq 0x18(%r15), %rsi
leaq 0x38d8a7(%rip), %rax # 0x3cf348
movq (%rax), %rdx
movq %rbx, %rdi
jmp 0x41a63
testq %r14, %r14
je 0x41ac8
testb $0x1, 0x2(%r14)
jne 0x41ac2
movq %r14, %rdi
callq 0x42b46
movb $0x1, 0x2(%r14)
movq 0x18(%r14), %rsi
jmp 0x41ad2
leaq 0x38d879(%rip), %rax # 0x3cf348
movq (%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x341ca
| _ZN11PFS_account20aggregate_statementsEP8PFS_userP8PFS_host:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, [rdi+18h]
test rbx, rbx
setnz al
and al, [rdi+2]
cmp al, 1
jnz short loc_41A72
mov r14, rdx
mov r15, rsi
test rsi, rsi
jz short loc_41A7D
test r14, r14
jz short loc_41A7D
test byte ptr [r15+2], 1
jnz short loc_41A41
mov rdi, r15; this
call _ZN20PFS_connection_slice22reset_statements_statsEv; PFS_connection_slice::reset_statements_stats(void)
mov byte ptr [r15+2], 1
loc_41A41:
mov r15, [r15+18h]
cmp byte ptr [r14+2], 0
jnz short loc_41A59
mov rdi, r14; this
call _ZN20PFS_connection_slice22reset_statements_statsEv; PFS_connection_slice::reset_statements_stats(void)
mov byte ptr [r14+2], 1
loc_41A59:
mov rdx, [r14+18h]
mov rdi, rbx
mov rsi, r15
loc_41A63:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _Z24aggregate_all_statementsP18PFS_statement_statS0_S0_; aggregate_all_statements(PFS_statement_stat *,PFS_statement_stat *,PFS_statement_stat *)
loc_41A72:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_41A7D:
test r15, r15
jz short loc_41AA9
test byte ptr [r15+2], 1
jnz short loc_41A96
mov rdi, r15; this
call _ZN20PFS_connection_slice22reset_statements_statsEv; PFS_connection_slice::reset_statements_stats(void)
mov byte ptr [r15+2], 1
loc_41A96:
mov rsi, [r15+18h]
lea rax, global_instr_class_statements_array
mov rdx, [rax]
mov rdi, rbx
jmp short loc_41A63
loc_41AA9:
test r14, r14
jz short loc_41AC8
test byte ptr [r14+2], 1
jnz short loc_41AC2
mov rdi, r14; this
call _ZN20PFS_connection_slice22reset_statements_statsEv; PFS_connection_slice::reset_statements_stats(void)
mov byte ptr [r14+2], 1
loc_41AC2:
mov rsi, [r14+18h]
jmp short loc_41AD2
loc_41AC8:
lea rax, global_instr_class_statements_array
mov rsi, [rax]
loc_41AD2:
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _Z24aggregate_all_statementsP18PFS_statement_statS0_; aggregate_all_statements(PFS_statement_stat *,PFS_statement_stat *)
| char PFS_account::aggregate_statements(PFS_account *this, PFS_user *a2, PFS_host *a3)
{
_QWORD *v3; // rbx
char result; // al
long long v6; // r15
long long v7; // rsi
v3 = (_QWORD *)*((_QWORD *)this + 3);
result = *((_BYTE *)this + 2) & (v3 != 0LL);
if ( result == 1 )
{
if ( a2 && a3 )
{
if ( (*((_BYTE *)a2 + 2) & 1) == 0 )
{
PFS_connection_slice::reset_statements_stats(a2);
*((_BYTE *)a2 + 2) = 1;
}
v6 = *((_QWORD *)a2 + 3);
if ( !*((_BYTE *)a3 + 2) )
{
PFS_connection_slice::reset_statements_stats(a3);
*((_BYTE *)a3 + 2) = 1;
}
return aggregate_all_statements(v3, v6, *((_QWORD *)a3 + 3));
}
else if ( a2 )
{
if ( (*((_BYTE *)a2 + 2) & 1) == 0 )
{
PFS_connection_slice::reset_statements_stats(a2);
*((_BYTE *)a2 + 2) = 1;
}
return aggregate_all_statements(v3, *((_QWORD *)a2 + 3), global_instr_class_statements_array);
}
else
{
if ( a3 )
{
if ( (*((_BYTE *)a3 + 2) & 1) == 0 )
{
PFS_connection_slice::reset_statements_stats(a3);
*((_BYTE *)a3 + 2) = 1;
}
v7 = *((_QWORD *)a3 + 3);
}
else
{
v7 = global_instr_class_statements_array;
}
return aggregate_all_statements(v3, v7);
}
}
return result;
}
| aggregate_statements:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,qword ptr [RDI + 0x18]
TEST RBX,RBX
SETNZ AL
AND AL,byte ptr [RDI + 0x2]
CMP AL,0x1
JNZ 0x00141a72
MOV R14,RDX
MOV R15,RSI
TEST RSI,RSI
JZ 0x00141a7d
TEST R14,R14
JZ 0x00141a7d
TEST byte ptr [R15 + 0x2],0x1
JNZ 0x00141a41
MOV RDI,R15
CALL 0x00142b46
MOV byte ptr [R15 + 0x2],0x1
LAB_00141a41:
MOV R15,qword ptr [R15 + 0x18]
CMP byte ptr [R14 + 0x2],0x0
JNZ 0x00141a59
MOV RDI,R14
CALL 0x00142b46
MOV byte ptr [R14 + 0x2],0x1
LAB_00141a59:
MOV RDX,qword ptr [R14 + 0x18]
MOV RDI,RBX
MOV RSI,R15
LAB_00141a63:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00134226
LAB_00141a72:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00141a7d:
TEST R15,R15
JZ 0x00141aa9
TEST byte ptr [R15 + 0x2],0x1
JNZ 0x00141a96
MOV RDI,R15
CALL 0x00142b46
MOV byte ptr [R15 + 0x2],0x1
LAB_00141a96:
MOV RSI,qword ptr [R15 + 0x18]
LEA RAX,[0x4cf348]
MOV RDX,qword ptr [RAX]
MOV RDI,RBX
JMP 0x00141a63
LAB_00141aa9:
TEST R14,R14
JZ 0x00141ac8
TEST byte ptr [R14 + 0x2],0x1
JNZ 0x00141ac2
MOV RDI,R14
CALL 0x00142b46
MOV byte ptr [R14 + 0x2],0x1
LAB_00141ac2:
MOV RSI,qword ptr [R14 + 0x18]
JMP 0x00141ad2
LAB_00141ac8:
LEA RAX,[0x4cf348]
MOV RSI,qword ptr [RAX]
LAB_00141ad2:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001341ca
|
/* PFS_account::aggregate_statements(PFS_user*, PFS_host*) */
void __thiscall
PFS_account::aggregate_statements(PFS_account *this,PFS_user *param_1,PFS_host *param_2)
{
PFS_statement_stat *pPVar1;
PFS_statement_stat *pPVar2;
PFS_statement_stat *pPVar3;
pPVar1 = *(PFS_statement_stat **)(this + 0x18);
if ((pPVar1 != (PFS_statement_stat *)0x0 & (byte)this[2]) != 1) {
return;
}
if ((param_1 == (PFS_user *)0x0) || (param_2 == (PFS_host *)0x0)) {
if (param_1 == (PFS_user *)0x0) {
pPVar3 = global_instr_class_statements_array;
if (param_2 != (PFS_host *)0x0) {
if (((byte)param_2[2] & 1) == 0) {
PFS_connection_slice::reset_statements_stats((PFS_connection_slice *)param_2);
param_2[2] = (PFS_host)0x1;
}
pPVar3 = *(PFS_statement_stat **)(param_2 + 0x18);
}
aggregate_all_statements(pPVar1,pPVar3);
return;
}
if (((byte)param_1[2] & 1) == 0) {
PFS_connection_slice::reset_statements_stats((PFS_connection_slice *)param_1);
param_1[2] = (PFS_user)0x1;
}
pPVar3 = *(PFS_statement_stat **)(param_1 + 0x18);
pPVar2 = global_instr_class_statements_array;
}
else {
if (((byte)param_1[2] & 1) == 0) {
PFS_connection_slice::reset_statements_stats((PFS_connection_slice *)param_1);
param_1[2] = (PFS_user)0x1;
}
pPVar3 = *(PFS_statement_stat **)(param_1 + 0x18);
if (param_2[2] == (PFS_host)0x0) {
PFS_connection_slice::reset_statements_stats((PFS_connection_slice *)param_2);
param_2[2] = (PFS_host)0x1;
}
pPVar2 = *(PFS_statement_stat **)(param_2 + 0x18);
}
aggregate_all_statements(pPVar1,pPVar3,pPVar2);
return;
}
| |
54,714 | ma_hashtbl_insert | eloqsql/libmariadb/libmariadb/ma_hashtbl.c | my_bool ma_hashtbl_insert(MA_HASHTBL *info,const uchar *record)
{
int flag;
uint halfbuff,hash_nr,first_index,idx;
uchar *ptr_to_rec= NULL,*ptr_to_rec2= NULL;
MA_HASHTBL_LINK *data,*empty,*gpos= NULL,*gpos2 = NULL,*pos;
LINT_INIT(gpos); LINT_INIT(gpos2);
LINT_INIT(ptr_to_rec); LINT_INIT(ptr_to_rec2);
flag=0;
if (!(empty=(MA_HASHTBL_LINK*) ma_alloc_dynamic(&info->array)))
return(TRUE); /* No more memory */
info->current_record= NO_RECORD;
data=dynamic_element(&info->array,0,MA_HASHTBL_LINK*);
halfbuff= info->blength >> 1;
idx=first_index=info->records-halfbuff;
if (idx != info->records) /* If some records */
{
do
{
pos=data+idx;
hash_nr=rec_hashnr(info,pos->data);
if (flag == 0) /* First loop; Check if ok */
if (hash_mask(hash_nr,info->blength,info->records) != first_index)
break;
if (!(hash_nr & halfbuff))
{ /* Key will not move */
if (!(flag & LOWFIND))
{
if (flag & HIGHFIND)
{
flag=LOWFIND | HIGHFIND;
/* key shall be moved to the current empty position */
gpos=empty;
ptr_to_rec=pos->data;
empty=pos; /* This place is now free */
}
else
{
flag=LOWFIND | LOWUSED; /* key isn't changed */
gpos=pos;
ptr_to_rec=pos->data;
}
}
else
{
if (!(flag & LOWUSED))
{
/* Change link of previous LOW-key */
gpos->data=ptr_to_rec;
gpos->next=(uint) (pos-data);
flag= (flag & HIGHFIND) | (LOWFIND | LOWUSED);
}
gpos=pos;
ptr_to_rec=pos->data;
}
}
else
{ /* key will be moved */
if (!(flag & HIGHFIND))
{
flag= (flag & LOWFIND) | HIGHFIND;
/* key shall be moved to the last (empty) position */
gpos2 = empty; empty=pos;
ptr_to_rec2=pos->data;
}
else
{
if (!(flag & HIGHUSED))
{
/* Change link of previous hash-key and save */
gpos2->data=ptr_to_rec2;
gpos2->next=(uint) (pos-data);
flag= (flag & LOWFIND) | (HIGHFIND | HIGHUSED);
}
gpos2=pos;
ptr_to_rec2=pos->data;
}
}
}
while ((idx=pos->next) != NO_RECORD);
if ((flag & (LOWFIND | LOWUSED)) == LOWFIND)
{
gpos->data=ptr_to_rec;
gpos->next=NO_RECORD;
}
if ((flag & (HIGHFIND | HIGHUSED)) == HIGHFIND)
{
gpos2->data=ptr_to_rec2;
gpos2->next=NO_RECORD;
}
}
/* Check if we are at the empty position */
idx=hash_mask(rec_hashnr(info,record),info->blength,info->records+1);
pos=data+idx;
if (pos == empty)
{
pos->data=(uchar*) record;
pos->next=NO_RECORD;
}
else
{
/* Check if more records in same hash-nr family */
empty[0]=pos[0];
gpos=data+hash_rec_mask(info,pos,info->blength,info->records+1);
if (pos == gpos)
{
pos->data=(uchar*) record;
pos->next=(uint) (empty - data);
}
else
{
pos->data=(uchar*) record;
pos->next=NO_RECORD;
movelink(data,(uint) (pos-data),(uint) (gpos-data),(uint) (empty-data));
}
}
if (++info->records == info->blength)
info->blength+= info->blength;
return(0);
} | O3 | c | ma_hashtbl_insert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x19af2
testq %rax, %rax
je 0x1ac8b
movq %rax, %r13
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
movq 0x18(%rbx), %rcx
movl 0xc(%rbx), %edx
cmpl $0x2, %edx
movq %rbx, -0x70(%rbp)
movq %rcx, -0x68(%rbp)
movq %r14, -0x40(%rbp)
jb 0x1ac9a
movl 0x8(%rbx), %ebx
shrl %edx
subl %edx, %ebx
xorl %r12d, %r12d
movl %ebx, -0x74(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x58(%rbp)
movl %edx, %r14d
movq %r13, -0x30(%rbp)
movl %ebx, %r15d
shlq $0x4, %r15
movq 0x8(%rcx,%r15), %rdi
movq -0x70(%rbp), %r13
movq 0x30(%r13), %rax
testq %rax, %rax
je 0x1ab46
leaq -0x34(%rbp), %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rdi
movl -0x34(%rbp), %esi
jmp 0x1ab54
movl 0x4(%r13), %esi
movl %esi, -0x34(%rbp)
movl (%r13), %eax
addq %rax, %rdi
callq *0x40(%r13)
testl %r12d, %r12d
jne 0x1ab7c
movl 0xc(%r13), %ecx
leal -0x1(%rcx), %edx
andl %eax, %edx
shrl %ecx
decl %ecx
andl %eax, %ecx
cmpl 0x8(%r13), %edx
cmovbl %edx, %ecx
cmpl -0x74(%rbp), %ecx
jne 0x1ac92
movq -0x68(%rbp), %rcx
addq %rcx, %r15
movl %r14d, %edx
testl %r14d, %eax
je 0x1abb1
testb $0x4, %r12b
jne 0x1abe6
andl $0x1, %r12d
orl $0x4, %r12d
movq 0x8(%r15), %rax
movq %rax, -0x60(%rbp)
movq %r15, %r13
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x1ac40
testb $0x1, %r12b
jne 0x1ac14
andl $0x4, %r12d
movl %r12d, %eax
shrl %eax
addl $0x3, %eax
testl %r12d, %r12d
movq 0x8(%r15), %rsi
movq %rsi, -0x50(%rbp)
movq %r15, %r13
movq -0x30(%rbp), %rsi
cmoveq %rsi, %r13
cmoveq %r15, %rsi
movl %eax, %r12d
movq %rsi, -0x48(%rbp)
jmp 0x1ac40
testb $0x8, %r12b
jne 0x1ac02
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rsi
movq %rax, 0x8(%rsi)
movl %ebx, (%rsi)
andl $0x1, %r12d
orl $0xc, %r12d
movq 0x8(%r15), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %r13
movq %r15, -0x58(%rbp)
jmp 0x1ac40
testb $0x2, %r12b
jne 0x1ac30
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
movq %rax, 0x8(%rsi)
movl %ebx, (%rsi)
andl $0x4, %r12d
orl $0x3, %r12d
movq 0x8(%r15), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %r13
movq %r15, -0x48(%rbp)
movl (%r15), %ebx
cmpl $-0x1, %ebx
jne 0x1ab16
movl %r12d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x1ac69
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rax, 0x8(%rcx)
movl $0xffffffff, (%rcx) # imm = 0xFFFFFFFF
andl $0xc, %r12d
cmpl $0x4, %r12d
movq -0x40(%rbp), %r14
jne 0x1ac9a
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rax, 0x8(%rcx)
movl $0xffffffff, (%rcx) # imm = 0xFFFFFFFF
jmp 0x1ac9a
movb $0x1, %al
jmp 0x1ad7f
movq -0x30(%rbp), %r13
movq -0x40(%rbp), %r14
movq -0x70(%rbp), %r15
movq 0x30(%r15), %rax
testq %rax, %rax
je 0x1acbe
leaq -0x78(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rdi
movl (%r12), %esi
jmp 0x1accb
movl 0x4(%r15), %esi
movl %esi, -0x78(%rbp)
movl (%r15), %edi
addq %r14, %rdi
callq *0x40(%r15)
movl 0x8(%r15), %ecx
movl 0xc(%r15), %ebx
incl %ecx
leal -0x1(%rbx), %edx
andl %eax, %edx
shrl %ebx
decl %ebx
andl %eax, %ebx
cmpl %ecx, %edx
cmovbl %edx, %ebx
movq %rbx, %r14
shlq $0x4, %r14
addq -0x68(%rbp), %r14
cmpq %r13, %r14
je 0x1ad31
movups (%r14), %xmm0
movups %xmm0, (%r13)
movl 0x8(%r15), %ecx
movl 0xc(%r15), %edx
incl %ecx
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x1a9ac
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%r14)
cmpl %eax, %ebx
jne 0x1ad42
subq -0x68(%rbp), %r13
shrq $0x4, %r13
movl %r13d, (%r14)
jmp 0x1ad67
movq -0x40(%rbp), %rax
movq %rax, 0x8(%r14)
movl $0xffffffff, (%r14) # imm = 0xFFFFFFFF
jmp 0x1ad67
movl $0xffffffff, (%r14) # imm = 0xFFFFFFFF
movq -0x68(%rbp), %rdx
subq %rdx, %r13
shrq $0x4, %r13
movl %eax, %ecx
shlq $0x4, %rcx
movl (%rdx,%rcx), %eax
cmpl %ebx, %eax
jne 0x1ad54
addq %rcx, %rdx
movl %r13d, (%rdx)
movq -0x70(%rbp), %rcx
movl 0x8(%rcx), %eax
incl %eax
movl %eax, 0x8(%rcx)
cmpl 0xc(%rcx), %eax
jne 0x1ad7d
addl %eax, %eax
movl %eax, 0xc(%rcx)
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_hashtbl_insert:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r14, rsi
mov rbx, rdi
add rdi, 18h
call ma_alloc_dynamic
test rax, rax
jz loc_1AC8B
mov r13, rax
mov dword ptr [rbx+10h], 0FFFFFFFFh
mov rcx, [rbx+18h]
mov edx, [rbx+0Ch]
cmp edx, 2
mov [rbp+var_70], rbx
mov [rbp+var_68], rcx
mov [rbp+var_40], r14
jb loc_1AC9A
mov ebx, [rbx+8]
shr edx, 1
sub ebx, edx
xor r12d, r12d
mov [rbp+var_74], ebx
mov [rbp+var_50], 0
mov [rbp+var_60], 0
mov [rbp+var_48], 0
mov [rbp+var_58], 0
loc_1AB16:
mov r14d, edx
mov [rbp+var_30], r13
mov r15d, ebx
shl r15, 4
mov rdi, [rcx+r15+8]
mov r13, [rbp+var_70]
mov rax, [r13+30h]
test rax, rax
jz short loc_1AB46
lea rsi, [rbp+var_34]
xor edx, edx
call rax
mov rdi, rax
mov esi, [rbp+var_34]
jmp short loc_1AB54
loc_1AB46:
mov esi, [r13+4]
mov [rbp+var_34], esi
mov eax, [r13+0]
add rdi, rax
loc_1AB54:
call qword ptr [r13+40h]
test r12d, r12d
jnz short loc_1AB7C
mov ecx, [r13+0Ch]
lea edx, [rcx-1]
and edx, eax
shr ecx, 1
dec ecx
and ecx, eax
cmp edx, [r13+8]
cmovb ecx, edx
cmp ecx, [rbp+var_74]
jnz loc_1AC92
loc_1AB7C:
mov rcx, [rbp+var_68]
add r15, rcx
mov edx, r14d
test eax, r14d
jz short loc_1ABB1
test r12b, 4
jnz short loc_1ABE6
and r12d, 1
or r12d, 4
mov rax, [r15+8]
mov [rbp+var_60], rax
mov r13, r15
mov rax, [rbp+var_30]
mov [rbp+var_58], rax
jmp loc_1AC40
loc_1ABB1:
test r12b, 1
jnz short loc_1AC14
and r12d, 4
mov eax, r12d
shr eax, 1
add eax, 3
test r12d, r12d
mov rsi, [r15+8]
mov [rbp+var_50], rsi
mov r13, r15
mov rsi, [rbp+var_30]
cmovz r13, rsi
cmovz rsi, r15
mov r12d, eax
mov [rbp+var_48], rsi
jmp short loc_1AC40
loc_1ABE6:
test r12b, 8
jnz short loc_1AC02
mov rax, [rbp+var_60]
mov rsi, [rbp+var_58]
mov [rsi+8], rax
mov [rsi], ebx
and r12d, 1
or r12d, 0Ch
loc_1AC02:
mov rax, [r15+8]
mov [rbp+var_60], rax
mov r13, [rbp+var_30]
mov [rbp+var_58], r15
jmp short loc_1AC40
loc_1AC14:
test r12b, 2
jnz short loc_1AC30
mov rax, [rbp+var_50]
mov rsi, [rbp+var_48]
mov [rsi+8], rax
mov [rsi], ebx
and r12d, 4
or r12d, 3
loc_1AC30:
mov rax, [r15+8]
mov [rbp+var_50], rax
mov r13, [rbp+var_30]
mov [rbp+var_48], r15
loc_1AC40:
mov ebx, [r15]
cmp ebx, 0FFFFFFFFh
jnz loc_1AB16
mov eax, r12d
and eax, 3
cmp eax, 1
jnz short loc_1AC69
mov rax, [rbp+var_50]
mov rcx, [rbp+var_48]
mov [rcx+8], rax
mov dword ptr [rcx], 0FFFFFFFFh
loc_1AC69:
and r12d, 0Ch
cmp r12d, 4
mov r14, [rbp+var_40]
jnz short loc_1AC9A
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov [rcx+8], rax
mov dword ptr [rcx], 0FFFFFFFFh
jmp short loc_1AC9A
loc_1AC8B:
mov al, 1
jmp loc_1AD7F
loc_1AC92:
mov r13, [rbp+var_30]
mov r14, [rbp+var_40]
loc_1AC9A:
mov r15, [rbp+var_70]
mov rax, [r15+30h]
test rax, rax
jz short loc_1ACBE
lea r12, [rbp+var_78]
mov rdi, r14
mov rsi, r12
xor edx, edx
call rax
mov rdi, rax
mov esi, [r12]
jmp short loc_1ACCB
loc_1ACBE:
mov esi, [r15+4]
mov [rbp+var_78], esi
mov edi, [r15]
add rdi, r14
loc_1ACCB:
call qword ptr [r15+40h]
mov ecx, [r15+8]
mov ebx, [r15+0Ch]
inc ecx
lea edx, [rbx-1]
and edx, eax
shr ebx, 1
dec ebx
and ebx, eax
cmp edx, ecx
cmovb ebx, edx
mov r14, rbx
shl r14, 4
add r14, [rbp+var_68]
cmp r14, r13
jz short loc_1AD31
movups xmm0, xmmword ptr [r14]
movups xmmword ptr [r13+0], xmm0
mov ecx, [r15+8]
mov edx, [r15+0Ch]
inc ecx
mov rsi, [r14+8]
mov rdi, r15
call hash_rec_mask
mov rcx, [rbp+var_40]
mov [r14+8], rcx
cmp ebx, eax
jnz short loc_1AD42
sub r13, [rbp+var_68]
shr r13, 4
mov [r14], r13d
jmp short loc_1AD67
loc_1AD31:
mov rax, [rbp+var_40]
mov [r14+8], rax
mov dword ptr [r14], 0FFFFFFFFh
jmp short loc_1AD67
loc_1AD42:
mov dword ptr [r14], 0FFFFFFFFh
mov rdx, [rbp+var_68]
sub r13, rdx
shr r13, 4
loc_1AD54:
mov ecx, eax
shl rcx, 4
mov eax, [rdx+rcx]
cmp eax, ebx
jnz short loc_1AD54
add rdx, rcx
mov [rdx], r13d
loc_1AD67:
mov rcx, [rbp+var_70]
mov eax, [rcx+8]
inc eax
mov [rcx+8], eax
cmp eax, [rcx+0Ch]
jnz short loc_1AD7D
add eax, eax
mov [rcx+0Ch], eax
loc_1AD7D:
xor eax, eax
loc_1AD7F:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_hashtbl_insert(unsigned int *a1, long long a2)
{
long long v2; // r14
long long v3; // rax
_OWORD *v4; // r13
long long v5; // rcx
unsigned int v6; // edx
unsigned int v7; // edx
unsigned int v8; // ebx
int v9; // r12d
unsigned int v10; // r14d
long long v11; // r15
long long v12; // rdi
long long ( *v13)(long long, unsigned int *, _QWORD); // rax
long long v14; // rdi
long long v15; // rsi
int v16; // eax
unsigned int v17; // ecx
unsigned int v18; // edx
int v19; // ecx
long long v20; // r15
unsigned int v21; // r12d
unsigned int *v22; // rsi
unsigned int *v23; // rsi
unsigned int *v24; // rsi
unsigned int *v25; // rcx
unsigned int *v26; // rcx
long long ( **v28)(long long, long long); // r15
long long ( *v29)(long long, unsigned int *, _QWORD); // rax
long long v30; // rdi
long long v31; // rsi
int v32; // eax
unsigned int v33; // ebx
unsigned int v34; // edx
long long v35; // rbx
long long v36; // r14
unsigned int v37; // eax
unsigned long long v38; // r13
long long v39; // rcx
unsigned int *v40; // rcx
int v41; // eax
unsigned int v42; // [rsp+8h] [rbp-78h] BYREF
unsigned int v43; // [rsp+Ch] [rbp-74h]
unsigned int *v44; // [rsp+10h] [rbp-70h]
long long v45; // [rsp+18h] [rbp-68h]
long long v46; // [rsp+20h] [rbp-60h]
unsigned int *v47; // [rsp+28h] [rbp-58h]
long long v48; // [rsp+30h] [rbp-50h]
unsigned int *v49; // [rsp+38h] [rbp-48h]
long long v50; // [rsp+40h] [rbp-40h]
unsigned int v51; // [rsp+4Ch] [rbp-34h] BYREF
_OWORD *v52; // [rsp+50h] [rbp-30h]
v2 = a2;
v3 = ma_alloc_dynamic((long long)(a1 + 6));
if ( !v3 )
return 1LL;
v4 = (_OWORD *)v3;
a1[4] = -1;
v5 = *((_QWORD *)a1 + 3);
v6 = a1[3];
v44 = a1;
v45 = v5;
v50 = a2;
if ( v6 >= 2 )
{
v7 = v6 >> 1;
v8 = a1[2] - v7;
v9 = 0;
v43 = v8;
v48 = 0LL;
v46 = 0LL;
v49 = 0LL;
v47 = 0LL;
do
{
v10 = v7;
v52 = v4;
v11 = 16LL * v8;
v12 = *(_QWORD *)(v5 + v11 + 8);
v13 = (long long ( *)(long long, unsigned int *, _QWORD))*((_QWORD *)v44 + 6);
if ( v13 )
{
v14 = v13(v12, &v51, 0LL);
v15 = v51;
}
else
{
v15 = v44[1];
v51 = v44[1];
v14 = *v44 + v12;
}
v16 = (*((long long ( **)(long long, long long))v44 + 8))(v14, v15);
if ( !v9 )
{
v17 = v44[3];
v18 = v16 & (v17 - 1);
v19 = v16 & ((v17 >> 1) - 1);
if ( v18 < v44[2] )
v19 = v18;
if ( v19 != v43 )
{
v4 = v52;
v2 = v50;
goto LABEL_31;
}
}
v5 = v45;
v20 = v45 + v11;
v7 = v10;
if ( (v10 & v16) != 0 )
{
if ( (v9 & 4) != 0 )
{
if ( (v9 & 8) == 0 )
{
v23 = v47;
*((_QWORD *)v47 + 1) = v46;
*v23 = v8;
v9 = v9 & 1 | 0xC;
}
v46 = *(_QWORD *)(v20 + 8);
v4 = v52;
v47 = (unsigned int *)v20;
}
else
{
v9 = v9 & 1 | 4;
v46 = *(_QWORD *)(v20 + 8);
v4 = (_OWORD *)v20;
v47 = (unsigned int *)v52;
}
}
else if ( (v9 & 1) != 0 )
{
if ( (v9 & 2) == 0 )
{
v24 = v49;
*((_QWORD *)v49 + 1) = v48;
*v24 = v8;
v9 = v9 & 4 | 3;
}
v48 = *(_QWORD *)(v20 + 8);
v4 = v52;
v49 = (unsigned int *)v20;
}
else
{
v21 = v9 & 4;
v48 = *(_QWORD *)(v20 + 8);
v4 = (_OWORD *)v20;
v22 = (unsigned int *)v52;
if ( !v21 )
{
v4 = v52;
v22 = (unsigned int *)v20;
}
v9 = (v21 >> 1) + 3;
v49 = v22;
}
v8 = *(_DWORD *)v20;
}
while ( *(_DWORD *)v20 != -1 );
if ( (v9 & 3) == 1 )
{
v25 = v49;
*((_QWORD *)v49 + 1) = v48;
*v25 = -1;
}
v2 = v50;
if ( (v9 & 0xC) == 4 )
{
v26 = v47;
*((_QWORD *)v47 + 1) = v46;
*v26 = -1;
}
}
LABEL_31:
v28 = (long long ( **)(long long, long long))v44;
v29 = (long long ( *)(long long, unsigned int *, _QWORD))*((_QWORD *)v44 + 6);
if ( v29 )
{
v30 = v29(v2, &v42, 0LL);
v31 = v42;
}
else
{
v31 = v44[1];
v42 = v44[1];
v30 = v2 + *v44;
}
v32 = v28[8](v30, v31);
v33 = *((_DWORD *)v28 + 3);
v34 = v32 & (v33 - 1);
v35 = v32 & ((v33 >> 1) - 1);
if ( v34 < *((_DWORD *)v28 + 2) + 1 )
v35 = v34;
v36 = v45 + 16 * v35;
if ( (_OWORD *)v36 == v4 )
{
*(_QWORD *)(v36 + 8) = v50;
*(_DWORD *)v36 = -1;
}
else
{
*v4 = *(_OWORD *)v36;
v37 = hash_rec_mask((unsigned int *)v28, *(_QWORD *)(v36 + 8), *((_DWORD *)v28 + 3), *((_DWORD *)v28 + 2) + 1);
*(_QWORD *)(v36 + 8) = v50;
if ( (_DWORD)v35 == v37 )
{
*(_DWORD *)v36 = ((unsigned long long)v4 - v45) >> 4;
}
else
{
*(_DWORD *)v36 = -1;
v38 = ((unsigned long long)v4 - v45) >> 4;
do
{
v39 = 16LL * v37;
v37 = *(_DWORD *)(v45 + v39);
}
while ( v37 != (_DWORD)v35 );
*(_DWORD *)(v39 + v45) = v38;
}
}
v40 = v44;
v41 = v44[2] + 1;
v44[2] = v41;
if ( v41 == v40[3] )
v40[3] = 2 * v41;
return 0LL;
}
| ma_hashtbl_insert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,RSI
MOV RBX,RDI
ADD RDI,0x18
CALL 0x00119af2
TEST RAX,RAX
JZ 0x0011ac8b
MOV R13,RAX
MOV dword ptr [RBX + 0x10],0xffffffff
MOV RCX,qword ptr [RBX + 0x18]
MOV EDX,dword ptr [RBX + 0xc]
CMP EDX,0x2
MOV qword ptr [RBP + -0x70],RBX
MOV qword ptr [RBP + -0x68],RCX
MOV qword ptr [RBP + -0x40],R14
JC 0x0011ac9a
MOV EBX,dword ptr [RBX + 0x8]
SHR EDX,0x1
SUB EBX,EDX
XOR R12D,R12D
MOV dword ptr [RBP + -0x74],EBX
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x60],0x0
MOV qword ptr [RBP + -0x48],0x0
MOV qword ptr [RBP + -0x58],0x0
LAB_0011ab16:
MOV R14D,EDX
MOV qword ptr [RBP + -0x30],R13
MOV R15D,EBX
SHL R15,0x4
MOV RDI,qword ptr [RCX + R15*0x1 + 0x8]
MOV R13,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [R13 + 0x30]
TEST RAX,RAX
JZ 0x0011ab46
LEA RSI,[RBP + -0x34]
XOR EDX,EDX
CALL RAX
MOV RDI,RAX
MOV ESI,dword ptr [RBP + -0x34]
JMP 0x0011ab54
LAB_0011ab46:
MOV ESI,dword ptr [R13 + 0x4]
MOV dword ptr [RBP + -0x34],ESI
MOV EAX,dword ptr [R13]
ADD RDI,RAX
LAB_0011ab54:
CALL qword ptr [R13 + 0x40]
TEST R12D,R12D
JNZ 0x0011ab7c
MOV ECX,dword ptr [R13 + 0xc]
LEA EDX,[RCX + -0x1]
AND EDX,EAX
SHR ECX,0x1
DEC ECX
AND ECX,EAX
CMP EDX,dword ptr [R13 + 0x8]
CMOVC ECX,EDX
CMP ECX,dword ptr [RBP + -0x74]
JNZ 0x0011ac92
LAB_0011ab7c:
MOV RCX,qword ptr [RBP + -0x68]
ADD R15,RCX
MOV EDX,R14D
TEST EAX,R14D
JZ 0x0011abb1
TEST R12B,0x4
JNZ 0x0011abe6
AND R12D,0x1
OR R12D,0x4
MOV RAX,qword ptr [R15 + 0x8]
MOV qword ptr [RBP + -0x60],RAX
MOV R13,R15
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0011ac40
LAB_0011abb1:
TEST R12B,0x1
JNZ 0x0011ac14
AND R12D,0x4
MOV EAX,R12D
SHR EAX,0x1
ADD EAX,0x3
TEST R12D,R12D
MOV RSI,qword ptr [R15 + 0x8]
MOV qword ptr [RBP + -0x50],RSI
MOV R13,R15
MOV RSI,qword ptr [RBP + -0x30]
CMOVZ R13,RSI
CMOVZ RSI,R15
MOV R12D,EAX
MOV qword ptr [RBP + -0x48],RSI
JMP 0x0011ac40
LAB_0011abe6:
TEST R12B,0x8
JNZ 0x0011ac02
MOV RAX,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x58]
MOV qword ptr [RSI + 0x8],RAX
MOV dword ptr [RSI],EBX
AND R12D,0x1
OR R12D,0xc
LAB_0011ac02:
MOV RAX,qword ptr [R15 + 0x8]
MOV qword ptr [RBP + -0x60],RAX
MOV R13,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x58],R15
JMP 0x0011ac40
LAB_0011ac14:
TEST R12B,0x2
JNZ 0x0011ac30
MOV RAX,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x48]
MOV qword ptr [RSI + 0x8],RAX
MOV dword ptr [RSI],EBX
AND R12D,0x4
OR R12D,0x3
LAB_0011ac30:
MOV RAX,qword ptr [R15 + 0x8]
MOV qword ptr [RBP + -0x50],RAX
MOV R13,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],R15
LAB_0011ac40:
MOV EBX,dword ptr [R15]
CMP EBX,-0x1
JNZ 0x0011ab16
MOV EAX,R12D
AND EAX,0x3
CMP EAX,0x1
JNZ 0x0011ac69
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RCX + 0x8],RAX
MOV dword ptr [RCX],0xffffffff
LAB_0011ac69:
AND R12D,0xc
CMP R12D,0x4
MOV R14,qword ptr [RBP + -0x40]
JNZ 0x0011ac9a
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV qword ptr [RCX + 0x8],RAX
MOV dword ptr [RCX],0xffffffff
JMP 0x0011ac9a
LAB_0011ac8b:
MOV AL,0x1
JMP 0x0011ad7f
LAB_0011ac92:
MOV R13,qword ptr [RBP + -0x30]
MOV R14,qword ptr [RBP + -0x40]
LAB_0011ac9a:
MOV R15,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [R15 + 0x30]
TEST RAX,RAX
JZ 0x0011acbe
LEA R12,[RBP + -0x78]
MOV RDI,R14
MOV RSI,R12
XOR EDX,EDX
CALL RAX
MOV RDI,RAX
MOV ESI,dword ptr [R12]
JMP 0x0011accb
LAB_0011acbe:
MOV ESI,dword ptr [R15 + 0x4]
MOV dword ptr [RBP + -0x78],ESI
MOV EDI,dword ptr [R15]
ADD RDI,R14
LAB_0011accb:
CALL qword ptr [R15 + 0x40]
MOV ECX,dword ptr [R15 + 0x8]
MOV EBX,dword ptr [R15 + 0xc]
INC ECX
LEA EDX,[RBX + -0x1]
AND EDX,EAX
SHR EBX,0x1
DEC EBX
AND EBX,EAX
CMP EDX,ECX
CMOVC EBX,EDX
MOV R14,RBX
SHL R14,0x4
ADD R14,qword ptr [RBP + -0x68]
CMP R14,R13
JZ 0x0011ad31
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [R13],XMM0
MOV ECX,dword ptr [R15 + 0x8]
MOV EDX,dword ptr [R15 + 0xc]
INC ECX
MOV RSI,qword ptr [R14 + 0x8]
MOV RDI,R15
CALL 0x0011a9ac
MOV RCX,qword ptr [RBP + -0x40]
MOV qword ptr [R14 + 0x8],RCX
CMP EBX,EAX
JNZ 0x0011ad42
SUB R13,qword ptr [RBP + -0x68]
SHR R13,0x4
MOV dword ptr [R14],R13D
JMP 0x0011ad67
LAB_0011ad31:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [R14 + 0x8],RAX
MOV dword ptr [R14],0xffffffff
JMP 0x0011ad67
LAB_0011ad42:
MOV dword ptr [R14],0xffffffff
MOV RDX,qword ptr [RBP + -0x68]
SUB R13,RDX
SHR R13,0x4
LAB_0011ad54:
MOV ECX,EAX
SHL RCX,0x4
MOV EAX,dword ptr [RDX + RCX*0x1]
CMP EAX,EBX
JNZ 0x0011ad54
ADD RDX,RCX
MOV dword ptr [RDX],R13D
LAB_0011ad67:
MOV RCX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RCX + 0x8]
INC EAX
MOV dword ptr [RCX + 0x8],EAX
CMP EAX,dword ptr [RCX + 0xc]
JNZ 0x0011ad7d
ADD EAX,EAX
MOV dword ptr [RCX + 0xc],EAX
LAB_0011ad7d:
XOR EAX,EAX
LAB_0011ad7f:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 ma_hashtbl_insert(uint *param_1,long param_2)
{
uint uVar1;
uint uVar2;
uint *puVar3;
long lVar4;
int8 uVar5;
ulong uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
uint uVar10;
uint *puVar11;
uint *puVar12;
uint local_80;
uint local_7c;
uint *local_78;
long local_70;
int8 local_68;
uint *local_60;
int8 local_58;
uint *local_50;
long local_48;
uint local_3c;
uint *local_38;
puVar3 = (uint *)ma_alloc_dynamic(param_1 + 6);
if (puVar3 == (uint *)0x0) {
uVar5 = 1;
}
else {
param_1[4] = 0xffffffff;
local_70 = *(long *)(param_1 + 6);
local_78 = param_1;
local_48 = param_2;
if (1 < param_1[3]) {
uVar7 = param_1[3] >> 1;
uVar9 = param_1[2] - uVar7;
uVar10 = 0;
local_58 = 0;
local_68 = 0;
local_50 = (uint *)0x0;
local_60 = (uint *)0x0;
local_7c = uVar9;
do {
puVar12 = local_78;
lVar4 = *(long *)(local_70 + 8 + (ulong)uVar9 * 0x10);
local_38 = puVar3;
if (*(code **)(local_78 + 0xc) == (code *)0x0) {
local_3c = local_78[1];
lVar4 = lVar4 + (ulong)*local_78;
}
else {
lVar4 = (**(code **)(local_78 + 0xc))(lVar4,&local_3c,0);
}
uVar2 = (**(code **)(puVar12 + 0x10))(lVar4,local_3c);
if (uVar10 == 0) {
uVar8 = puVar12[3] - 1 & uVar2;
uVar1 = (puVar12[3] >> 1) - 1 & uVar2;
if (uVar8 < puVar12[2]) {
uVar1 = uVar8;
}
puVar3 = local_38;
if (uVar1 != local_7c) goto LAB_0011ac9a;
}
puVar12 = (uint *)((ulong)uVar9 * 0x10 + local_70);
puVar3 = puVar12;
if ((uVar2 & uVar7) == 0) {
if ((uVar10 & 1) == 0) {
uVar9 = uVar10 & 4;
uVar10 = (uVar9 >> 1) + 3;
local_58 = *(int8 *)(puVar12 + 2);
local_50 = local_38;
if (uVar9 == 0) {
puVar3 = local_38;
local_50 = puVar12;
}
}
else {
if ((uVar10 & 2) == 0) {
*(int8 *)(local_50 + 2) = local_58;
*local_50 = uVar9;
uVar10 = uVar10 & 4 | 3;
}
local_58 = *(int8 *)(puVar12 + 2);
puVar3 = local_38;
local_50 = puVar12;
}
}
else if ((uVar10 & 4) == 0) {
uVar10 = uVar10 & 1 | 4;
local_68 = *(int8 *)(puVar12 + 2);
local_60 = local_38;
}
else {
if ((uVar10 & 8) == 0) {
*(int8 *)(local_60 + 2) = local_68;
*local_60 = uVar9;
uVar10 = uVar10 & 1 | 0xc;
}
local_68 = *(int8 *)(puVar12 + 2);
puVar3 = local_38;
local_60 = puVar12;
}
uVar9 = *puVar12;
} while (uVar9 != 0xffffffff);
if ((uVar10 & 3) == 1) {
*(int8 *)(local_50 + 2) = local_58;
*local_50 = 0xffffffff;
}
if ((uVar10 & 0xc) == 4) {
*(int8 *)(local_60 + 2) = local_68;
*local_60 = 0xffffffff;
}
}
LAB_0011ac9a:
puVar12 = local_78;
if (*(code **)(local_78 + 0xc) == (code *)0x0) {
local_80 = local_78[1];
lVar4 = (ulong)*local_78 + local_48;
}
else {
lVar4 = (**(code **)(local_78 + 0xc))(local_48,&local_80,0);
}
uVar9 = (**(code **)(puVar12 + 0x10))(lVar4,local_80);
uVar10 = puVar12[3] - 1 & uVar9;
uVar9 = (puVar12[3] >> 1) - 1 & uVar9;
if (uVar10 < puVar12[2] + 1) {
uVar9 = uVar10;
}
puVar11 = (uint *)((ulong)uVar9 * 0x10 + local_70);
if (puVar11 == puVar3) {
*(long *)(puVar11 + 2) = local_48;
*puVar11 = 0xffffffff;
}
else {
uVar10 = puVar11[1];
uVar7 = puVar11[2];
uVar2 = puVar11[3];
*puVar3 = *puVar11;
puVar3[1] = uVar10;
puVar3[2] = uVar7;
puVar3[3] = uVar2;
uVar10 = hash_rec_mask(puVar12,*(int8 *)(puVar11 + 2),puVar12[3],puVar12[2] + 1);
*(long *)(puVar11 + 2) = local_48;
if (uVar9 == uVar10) {
*puVar11 = (uint)((ulong)((long)puVar3 - local_70) >> 4);
}
else {
*puVar11 = 0xffffffff;
do {
uVar6 = (ulong)uVar10;
uVar10 = *(uint *)(local_70 + uVar6 * 0x10);
} while (uVar10 != uVar9);
*(int *)(local_70 + uVar6 * 0x10) = (int)((ulong)((long)puVar3 - local_70) >> 4);
}
}
uVar9 = local_78[2] + 1;
local_78[2] = uVar9;
if (uVar9 == local_78[3]) {
local_78[3] = uVar9 * 2;
}
uVar5 = 0;
}
return uVar5;
}
| |
54,715 | fn_ext | eloqsql/mysys/mf_fn_ext.c | char *fn_ext(const char *name)
{
register const char *pos, *gpos;
DBUG_ENTER("fn_ext");
DBUG_PRINT("mfunkt",("name: '%s'",name));
#if defined(FN_DEVCHAR) || defined(BASKSLASH_MBTAIL)
{
char buff[FN_REFLEN];
size_t res_length;
gpos= name+ dirname_part(buff,(char*) name, &res_length);
}
#else
if (!(gpos= strrchr(name, FN_LIBCHAR)))
gpos= name;
#endif
pos= strchr(gpos, FN_EXTCHAR);
DBUG_RETURN((char*) (pos ? pos : strend(gpos)));
} | O0 | c | fn_ext:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x82cce
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x38980
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x82cee
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2e, %esi
callq 0x38500
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x82d11
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x82d1e
movq -0x18(%rbp), %rdi
callq 0xd57e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
| fn_ext:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
jmp short $+2
loc_82CCE:
mov rdi, [rbp+var_8]
mov esi, 2Fh ; '/'
call _strrchr
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_82CEE
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
loc_82CEE:
mov rdi, [rbp+var_18]
mov esi, 2Eh ; '.'
call _strchr
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jz short loc_82D11
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
jmp short loc_82D1E
loc_82D11:
mov rdi, [rbp+var_18]
call strend
mov [rbp+var_20], rax
loc_82D1E:
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
| long long fn_ext(long long a1)
{
long long v3; // [rsp+18h] [rbp-18h]
long long v4; // [rsp+20h] [rbp-10h]
v3 = strrchr(a1, 47LL);
if ( !v3 )
v3 = a1;
v4 = strchr(v3, 46LL);
if ( v4 )
return v4;
else
return strend(v3);
}
| fn_ext:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
JMP 0x00182cce
LAB_00182cce:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x2f
CALL 0x00138980
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00182cee
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
LAB_00182cee:
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,0x2e
CALL 0x00138500
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00182d11
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00182d1e
LAB_00182d11:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001d57e0
MOV qword ptr [RBP + -0x20],RAX
LAB_00182d1e:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
char * fn_ext(char *param_1)
{
int8 local_28;
int8 local_20;
local_20 = strrchr(param_1,0x2f);
if (local_20 == (char *)0x0) {
local_20 = param_1;
}
local_28 = strchr(local_20,0x2e);
if (local_28 == (char *)0x0) {
local_28 = (char *)strend(local_20);
}
return local_28;
}
| |
54,716 | httplib::ThreadPool::worker::operator()() | hkr04[P]cpp-mcp/common/httplib.h | void operator()() {
for (;;) {
std::function<void()> fn;
{
std::unique_lock<std::mutex> lock(pool_.mutex_);
pool_.cond_.wait(
lock, [&] { return !pool_.jobs_.empty() || pool_.shutdown_; });
if (pool_.shutdown_ && pool_.jobs_.empty()) { break; }
fn = pool_.jobs_.front();
pool_.jobs_.pop_front();
}
assert(true == static_cast<bool>(fn));
fn();
}
#if defined(CPPHTTPLIB_OPENSSL_SUPPORT) && !defined(OPENSSL_IS_BORINGSSL) && \
!defined(LIBRESSL_VERSION_NUMBER)
OPENSSL_thread_stop();
#endif
} | O0 | c | httplib::ThreadPool::worker::operator()():
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2b690
movq 0x8(%rsp), %rax
movq (%rax), %rsi
addq $0x78, %rsi
leaq 0x30(%rsp), %rdi
callq 0x99520
jmp 0xa8ba5
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $0x48, %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
leaq 0x30(%rsp), %rsi
callq 0xa8cc0
jmp 0xa8bc7
movq 0x8(%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x38(%rax)
je 0xa8c23
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
callq 0xa8d10
testb $0x1, %al
jne 0xa8bec
jmp 0xa8c23
movl $0x2, 0x14(%rsp)
jmp 0xa8c5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xa8c9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x996e0
jmp 0xa8c9f
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
callq 0xa8d30
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0xa8d60
jmp 0xa8c43
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
callq 0xa8db0
movl $0x0, 0x14(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x996e0
movl 0x14(%rsp), %eax
testl %eax, %eax
jne 0xa8c84
jmp 0xa8c70
leaq 0x40(%rsp), %rdi
callq 0x6ef90
jmp 0xa8c7c
movl $0x0, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2b760
movl 0x14(%rsp), %eax
testl %eax, %eax
je 0xa8c9a
jmp 0xa8c98
jmp 0xa8cab
jmp 0xa8b83
leaq 0x40(%rsp), %rdi
callq 0x2b760
jmp 0xa8cb0
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xce40
nopw (%rax,%rax)
| _ZN7httplib10ThreadPool6workerclEv:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov rax, [rsp+68h+var_8]
mov [rsp+68h+var_60], rax
loc_A8B83:
lea rdi, [rsp+68h+var_28]
call _ZNSt8functionIFvvEEC2Ev; std::function<void ()(void)>::function(void)
mov rax, [rsp+68h+var_60]
mov rsi, [rax]
add rsi, 78h ; 'x'
lea rdi, [rsp+68h+var_38]
call _ZNSt11unique_lockISt5mutexEC2ERS0_; std::unique_lock<std::mutex>::unique_lock(std::mutex&)
jmp short $+2
loc_A8BA5:
mov rax, [rsp+68h+var_60]
mov rdi, [rax]
add rdi, 48h ; 'H'
mov [rsp+68h+var_50], rax
mov rdx, [rsp+68h+var_50]
lea rsi, [rsp+68h+var_38]
call _ZNSt18condition_variable4waitIZN7httplib10ThreadPool6workerclEvEUlvE_EEvRSt11unique_lockISt5mutexET_; std::condition_variable::wait<httplib::ThreadPool::worker::operator()(void)::{lambda(void)#1}>(std::unique_lock<std::mutex> &,httplib::ThreadPool::worker::operator()(void)::{lambda(void)#1})
jmp short $+2
loc_A8BC7:
mov rax, [rsp+68h+var_60]
mov rax, [rax]
test byte ptr [rax+38h], 1
jz short loc_A8C23
mov rax, [rsp+68h+var_60]
mov rdi, [rax]
add rdi, 20h ; ' '
call _ZNKSt7__cxx114listISt8functionIFvvEESaIS3_EE5emptyEv; std::list<std::function<void ()(void)>>::empty(void)
test al, 1
jnz short loc_A8BEC
jmp short loc_A8C23
loc_A8BEC:
mov [rsp+68h+var_54], 2
jmp short loc_A8C5C
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
jmp loc_A8C9F
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_28]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
jmp short loc_A8C9F
loc_A8C23:
mov rax, [rsp+68h+var_60]
mov rdi, [rax]
add rdi, 20h ; ' '
call _ZNSt7__cxx114listISt8functionIFvvEESaIS3_EE5frontEv; std::list<std::function<void ()(void)>>::front(void)
mov rsi, rax
lea rdi, [rsp+68h+var_28]
call _ZNSt8functionIFvvEEaSERKS1_; std::function<void ()(void)>::operator=(std::function<void ()(void)> const&)
jmp short $+2
loc_A8C43:
mov rax, [rsp+68h+var_60]
mov rdi, [rax]
add rdi, 20h ; ' '
call _ZNSt7__cxx114listISt8functionIFvvEESaIS3_EE9pop_frontEv; std::list<std::function<void ()(void)>>::pop_front(void)
mov [rsp+68h+var_54], 0
loc_A8C5C:
lea rdi, [rsp+68h+var_38]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
mov eax, [rsp+68h+var_54]
test eax, eax
jnz short loc_A8C84
jmp short $+2
loc_A8C70:
lea rdi, [rsp+68h+var_28]
call _ZNKSt8functionIFvvEEclEv; std::function<void ()(void)>::operator()(void)
jmp short $+2
loc_A8C7C:
mov [rsp+68h+var_54], 0
loc_A8C84:
lea rdi, [rsp+68h+var_28]
call _ZNSt8functionIFvvEED2Ev; std::function<void ()(void)>::~function()
mov eax, [rsp+68h+var_54]
test eax, eax
jz short loc_A8C9A
jmp short $+2
loc_A8C98:
jmp short loc_A8CAB
loc_A8C9A:
jmp loc_A8B83
loc_A8C9F:
lea rdi, [rsp+arg_38]
call _ZNSt8functionIFvvEED2Ev; std::function<void ()(void)>::~function()
jmp short loc_A8CB0
loc_A8CAB:
add rsp, 68h
retn
loc_A8CB0:
mov rdi, [rsp+arg_20]
call __Unwind_Resume
| long long httplib::ThreadPool::worker::operator()(long long (*a1)(void))
{
long long v1; // rax
long long result; // rax
unsigned int v3; // [rsp+14h] [rbp-54h]
_BYTE v4[16]; // [rsp+30h] [rbp-38h] BYREF
long long (*v5[5])(void); // [rsp+40h] [rbp-28h] BYREF
v5[4] = a1;
do
{
std::function<void ()(void)>::function((std::_Function_base *)v5);
std::unique_lock<std::mutex>::unique_lock((long long)v4, *(_QWORD *)a1 + 120LL);
std::condition_variable::wait<httplib::ThreadPool::worker::operator()(void)::{lambda(void)#1}>(
*(_QWORD *)a1 + 72LL,
v4,
a1);
if ( (*(_BYTE *)(*(_QWORD *)a1 + 56LL) & 1) != 0
&& (std::list<std::function<void ()(void)>>::empty(*(_QWORD *)a1 + 32LL) & 1) != 0 )
{
v3 = 2;
}
else
{
v1 = std::list<std::function<void ()(void)>>::front(*(_QWORD *)a1 + 32LL);
std::function<void ()(void)>::operator=(v5, v1);
std::list<std::function<void ()(void)>>::pop_front(*(_QWORD *)a1 + 32LL);
v3 = 0;
}
std::unique_lock<std::mutex>::~unique_lock((long long)v4);
if ( !v3 )
{
std::function<void ()(void)>::operator()(v5);
v3 = 0;
}
std::function<void ()(void)>::~function((std::_Function_base *)v5);
result = v3;
}
while ( !v3 );
return result;
}
| operator():
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDI
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x8],RAX
LAB_001a8b83:
LEA RDI,[RSP + 0x40]
CALL 0x0012b690
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX]
ADD RSI,0x78
LAB_001a8b99:
LEA RDI,[RSP + 0x30]
CALL 0x00199520
JMP 0x001a8ba5
LAB_001a8ba5:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
ADD RDI,0x48
MOV qword ptr [RSP + 0x18],RAX
MOV RDX,qword ptr [RSP + 0x18]
LAB_001a8bbb:
LEA RSI,[RSP + 0x30]
CALL 0x001a8cc0
JMP 0x001a8bc7
LAB_001a8bc7:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX]
TEST byte ptr [RAX + 0x38],0x1
JZ 0x001a8c23
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
ADD RDI,0x20
CALL 0x001a8d10
TEST AL,0x1
JNZ 0x001a8bec
JMP 0x001a8c23
LAB_001a8bec:
MOV dword ptr [RSP + 0x14],0x2
JMP 0x001a8c5c
LAB_001a8c23:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
ADD RDI,0x20
CALL 0x001a8d30
MOV RSI,RAX
LEA RDI,[RSP + 0x40]
CALL 0x001a8d60
JMP 0x001a8c43
LAB_001a8c43:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
ADD RDI,0x20
CALL 0x001a8db0
MOV dword ptr [RSP + 0x14],0x0
LAB_001a8c5c:
LEA RDI,[RSP + 0x30]
CALL 0x001996e0
MOV EAX,dword ptr [RSP + 0x14]
TEST EAX,EAX
JNZ 0x001a8c84
JMP 0x001a8c70
LAB_001a8c70:
LEA RDI,[RSP + 0x40]
CALL 0x0016ef90
LAB_001a8c7a:
JMP 0x001a8c7c
LAB_001a8c7c:
MOV dword ptr [RSP + 0x14],0x0
LAB_001a8c84:
LEA RDI,[RSP + 0x40]
CALL 0x0012b760
MOV EAX,dword ptr [RSP + 0x14]
TEST EAX,EAX
JZ 0x001a8c9a
JMP 0x001a8c98
LAB_001a8c98:
JMP 0x001a8cab
LAB_001a8c9a:
JMP 0x001a8b83
LAB_001a8cab:
ADD RSP,0x68
RET
|
/* httplib::ThreadPool::worker::TEMPNAMEPLACEHOLDERVALUE() */
void __thiscall httplib::ThreadPool::worker::operator()(worker *this)
{
bool bVar1;
ulong uVar2;
function *pfVar3;
unique_lock<std::mutex> local_38 [16];
function<void()> local_28 [32];
worker *local_8;
local_8 = this;
do {
std::function<void()>::function(local_28);
/* try { // try from 001a8b99 to 001a8ba2 has its CatchHandler @ 001a8bf6 */
std::unique_lock<std::mutex>::unique_lock(local_38,(mutex *)(*(long *)this + 0x78));
/* try { // try from 001a8bbb to 001a8c40 has its CatchHandler @ 001a8c09 */
std::condition_variable::operator()((condition_variable *)(*(long *)this + 0x48),local_38,this);
if (((*(byte *)(*(long *)this + 0x38) & 1) == 0) ||
(uVar2 = std::__cxx11::list<std::function<void()>,std::allocator<std::function<void()>>>::
empty((list<std::function<void()>,std::allocator<std::function<void()>>> *)
(*(long *)this + 0x20)), (uVar2 & 1) == 0)) {
pfVar3 = (function *)
std::__cxx11::list<std::function<void()>,std::allocator<std::function<void()>>>::
front((list<std::function<void()>,std::allocator<std::function<void()>>> *)
(*(long *)this + 0x20));
std::function<void()>::operator=(local_28,pfVar3);
std::__cxx11::list<std::function<void()>,std::allocator<std::function<void()>>>::pop_front
((list<std::function<void()>,std::allocator<std::function<void()>>> *)
(*(long *)this + 0x20));
bVar1 = false;
}
else {
bVar1 = true;
}
std::unique_lock<std::mutex>::~unique_lock(local_38);
if (!bVar1) {
/* try { // try from 001a8c70 to 001a8c79 has its CatchHandler @ 001a8bf6 */
std::function<void()>::operator()(local_28);
bVar1 = false;
}
std::function<void()>::~function(local_28);
} while (!bVar1);
return;
}
| |
54,717 | my_message_stderr | eloqsql/mysys/my_mess.c | void my_message_stderr(uint error __attribute__((unused)),
const char *str, myf MyFlags)
{
DBUG_ENTER("my_message_stderr");
DBUG_PRINT("enter",("message: %s",str));
(void) fflush(stdout);
if (MyFlags & (ME_NOTE | ME_ERROR_LOG_ONLY))
DBUG_VOID_RETURN;
if (MyFlags & ME_BELL)
(void) fputc('\007', stderr);
if (my_progname)
{
(void)fputs(my_progname,stderr); (void)fputs(": ",stderr);
}
(void)fputs(str,stderr);
(void)fputc('\n',stderr);
(void)fflush(stderr);
DBUG_VOID_RETURN;
} | O0 | c | my_message_stderr:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x2e365
movq 0x1acc54(%rip), %rax # 0x1dafc0
movq (%rax), %rdi
callq 0x24300
movq -0x18(%rbp), %rax
andq $0x480, %rax # imm = 0x480
cmpq $0x0, %rax
je 0x2e38b
jmp 0x2e386
jmp 0x2e421
movq -0x18(%rbp), %rax
andq $0x4, %rax
cmpq $0x0, %rax
je 0x2e3ad
movq 0x1acc40(%rip), %rax # 0x1dafe0
movq (%rax), %rsi
movl $0x7, %edi
callq 0x24360
leaq 0x36458c(%rip), %rax # 0x392940
cmpq $0x0, (%rax)
je 0x2e3e9
leaq 0x36457f(%rip), %rax # 0x392940
movq (%rax), %rdi
movq 0x1acc15(%rip), %rax # 0x1dafe0
movq (%rax), %rsi
callq 0x242d0
movq 0x1acc06(%rip), %rax # 0x1dafe0
movq (%rax), %rsi
leaq 0x5746a(%rip), %rdi # 0x8584e
callq 0x242d0
movq -0x10(%rbp), %rdi
movq 0x1acbec(%rip), %rax # 0x1dafe0
movq (%rax), %rsi
callq 0x242d0
movq 0x1acbdd(%rip), %rax # 0x1dafe0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x24360
movq 0x1acbc9(%rip), %rax # 0x1dafe0
movq (%rax), %rdi
callq 0x24300
jmp 0x2e421
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| my_message_stderr:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
jmp short $+2
loc_2E365:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, [rbp+var_18]
and rax, 480h
cmp rax, 0
jz short loc_2E38B
jmp short $+2
loc_2E386:
jmp loc_2E421
loc_2E38B:
mov rax, [rbp+var_18]
and rax, 4
cmp rax, 0
jz short loc_2E3AD
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov edi, 7
call _fputc
loc_2E3AD:
lea rax, my_progname
cmp qword ptr [rax], 0
jz short loc_2E3E9
lea rax, my_progname
mov rdi, [rax]
mov rax, cs:stderr_ptr
mov rsi, [rax]
call _fputs
mov rax, cs:stderr_ptr
mov rsi, [rax]
lea rdi, aWarning+8; ": "
call _fputs
loc_2E3E9:
mov rdi, [rbp+var_10]
mov rax, cs:stderr_ptr
mov rsi, [rax]
call _fputs
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov edi, 0Ah
call _fputc
mov rax, cs:stderr_ptr
mov rdi, [rax]
call _fflush
jmp short $+2
loc_2E421:
add rsp, 20h
pop rbp
retn
| long long my_message_stderr(long long a1, long long a2, __int16 a3)
{
long long result; // rax
fflush(stdout);
result = a3 & 0x480;
if ( (a3 & 0x480) == 0 )
{
if ( (a3 & 4) != 0 )
fputc(7LL, stderr);
if ( my_progname )
{
fputs(my_progname, stderr);
fputs(": ", stderr);
}
fputs(a2, stderr);
fputc(10LL, stderr);
return fflush(stderr);
}
return result;
}
| my_message_stderr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x0012e365
LAB_0012e365:
MOV RAX,qword ptr [0x002dafc0]
MOV RDI,qword ptr [RAX]
CALL 0x00124300
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x480
CMP RAX,0x0
JZ 0x0012e38b
JMP 0x0012e386
LAB_0012e386:
JMP 0x0012e421
LAB_0012e38b:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x4
CMP RAX,0x0
JZ 0x0012e3ad
MOV RAX,qword ptr [0x002dafe0]
MOV RSI,qword ptr [RAX]
MOV EDI,0x7
CALL 0x00124360
LAB_0012e3ad:
LEA RAX,[0x492940]
CMP qword ptr [RAX],0x0
JZ 0x0012e3e9
LEA RAX,[0x492940]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [0x002dafe0]
MOV RSI,qword ptr [RAX]
CALL 0x001242d0
MOV RAX,qword ptr [0x002dafe0]
MOV RSI,qword ptr [RAX]
LEA RDI,[0x18584e]
CALL 0x001242d0
LAB_0012e3e9:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [0x002dafe0]
MOV RSI,qword ptr [RAX]
CALL 0x001242d0
MOV RAX,qword ptr [0x002dafe0]
MOV RSI,qword ptr [RAX]
MOV EDI,0xa
CALL 0x00124360
MOV RAX,qword ptr [0x002dafe0]
MOV RDI,qword ptr [RAX]
CALL 0x00124300
JMP 0x0012e421
LAB_0012e421:
ADD RSP,0x20
POP RBP
RET
|
void my_message_stderr(int8 param_1,char *param_2,ulong param_3)
{
fflush(*(FILE **)PTR_stdout_002dafc0);
if ((param_3 & 0x480) == 0) {
if ((param_3 & 4) != 0) {
fputc(7,*(FILE **)PTR_stderr_002dafe0);
}
if (my_progname != (char *)0x0) {
fputs(my_progname,*(FILE **)PTR_stderr_002dafe0);
fputs(": ",*(FILE **)PTR_stderr_002dafe0);
}
fputs(param_2,*(FILE **)PTR_stderr_002dafe0);
fputc(10,*(FILE **)PTR_stderr_002dafe0);
fflush(*(FILE **)PTR_stderr_002dafe0);
}
return;
}
| |
54,718 | common_batch_add(llama_batch&, int, int, std::vector<int, std::allocator<int>> const&, bool) | llama.cpp/common/common.cpp | void common_batch_add(
struct llama_batch & batch,
llama_token id,
llama_pos pos,
const std::vector<llama_seq_id> & seq_ids,
bool logits) {
GGML_ASSERT(batch.seq_id[batch.n_tokens] && "llama_batch size exceeded");
batch.token [batch.n_tokens] = id;
batch.pos [batch.n_tokens] = pos;
batch.n_seq_id[batch.n_tokens] = seq_ids.size();
for (size_t i = 0; i < seq_ids.size(); ++i) {
batch.seq_id[batch.n_tokens][i] = seq_ids[i];
}
batch.logits [batch.n_tokens] = logits;
batch.n_tokens++;
} | O3 | cpp | common_batch_add(llama_batch&, int, int, std::vector<int, std::allocator<int>> const&, bool):
pushq %rax
movq 0x28(%rdi), %rax
movslq (%rdi), %r9
cmpq $0x0, (%rax,%r9,8)
je 0xafed9
movq 0x8(%rdi), %r10
movl %esi, (%r10,%r9,4)
movq 0x18(%rdi), %rsi
movslq (%rdi), %r9
movl %edx, (%rsi,%r9,4)
movq (%rcx), %rdx
movq 0x8(%rcx), %rsi
movq %rsi, %rcx
subq %rdx, %rcx
sarq $0x2, %rcx
movq 0x20(%rdi), %r9
movslq (%rdi), %r10
movl %ecx, (%r9,%r10,4)
cmpq %rdx, %rsi
je 0xafeca
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movl (%rdx,%rsi,4), %r9d
movslq (%rdi), %r10
movq (%rax,%r10,8), %r10
movl %r9d, (%r10,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0xafeb3
movq 0x30(%rdi), %rax
movslq (%rdi), %rcx
movb %r8b, (%rax,%rcx)
incl (%rdi)
popq %rax
retq
leaq 0x20d31(%rip), %rdi # 0xd0c11
leaq 0x181a9(%rip), %rdx # 0xc8090
leaq 0x21303(%rip), %rcx # 0xd11f1
movl $0x478, %esi # imm = 0x478
xorl %eax, %eax
callq 0x1ca40
| _Z16common_batch_addR11llama_batchiiRKSt6vectorIiSaIiEEb:
push rax
mov rax, [rdi+28h]
movsxd r9, dword ptr [rdi]
cmp qword ptr [rax+r9*8], 0
jz short loc_AFED9
mov r10, [rdi+8]
mov [r10+r9*4], esi
mov rsi, [rdi+18h]
movsxd r9, dword ptr [rdi]
mov [rsi+r9*4], edx
mov rdx, [rcx]
mov rsi, [rcx+8]
mov rcx, rsi
sub rcx, rdx
sar rcx, 2
mov r9, [rdi+20h]
movsxd r10, dword ptr [rdi]
mov [r9+r10*4], ecx
cmp rsi, rdx
jz short loc_AFECA
cmp rcx, 1
adc rcx, 0
xor esi, esi
loc_AFEB3:
mov r9d, [rdx+rsi*4]
movsxd r10, dword ptr [rdi]
mov r10, [rax+r10*8]
mov [r10+rsi*4], r9d
inc rsi
cmp rcx, rsi
jnz short loc_AFEB3
loc_AFECA:
mov rax, [rdi+30h]
movsxd rcx, dword ptr [rdi]
mov [rax+rcx], r8b
inc dword ptr [rdi]
pop rax
retn
loc_AFED9:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aBatchSeqIdBatc; "batch.seq_id[batch.n_tokens] && \"llama"...
mov esi, 478h
xor eax, eax
call _ggml_abort
| long long common_batch_add(int *a1, int a2, int a3, long long *a4, char a5)
{
long long v5; // rax
long long v6; // rax
long long v7; // r9
long long v8; // rdx
long long v9; // rsi
long long v10; // rcx
long long v11; // rcx
long long v12; // rsi
long long v14; // [rsp-8h] [rbp-8h]
v14 = v5;
v6 = *((_QWORD *)a1 + 5);
v7 = *a1;
if ( *(_QWORD *)(v6 + 8 * v7) )
{
*(_DWORD *)(*((_QWORD *)a1 + 1) + 4 * v7) = a2;
*(_DWORD *)(*((_QWORD *)a1 + 3) + 4LL * *a1) = a3;
v8 = *a4;
v9 = a4[1];
v10 = (v9 - *a4) >> 2;
*(_DWORD *)(*((_QWORD *)a1 + 4) + 4LL * *a1) = v10;
if ( v9 != v8 )
{
v11 = (v10 == 0) + v10;
v12 = 0LL;
do
{
*(_DWORD *)(*(_QWORD *)(v6 + 8LL * *a1) + 4 * v12) = *(_DWORD *)(v8 + 4 * v12);
++v12;
}
while ( v11 != v12 );
}
*(_BYTE *)(*((_QWORD *)a1 + 6) + (*a1)++) = a5;
return v14;
}
else
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",
1144LL,
"GGML_ASSERT(%s) failed",
"batch.seq_id[batch.n_tokens] && \"llama_batch size exceeded\"");
return common_lcp();
}
}
| common_batch_add:
PUSH RAX
MOV RAX,qword ptr [RDI + 0x28]
MOVSXD R9,dword ptr [RDI]
CMP qword ptr [RAX + R9*0x8],0x0
JZ 0x001afed9
MOV R10,qword ptr [RDI + 0x8]
MOV dword ptr [R10 + R9*0x4],ESI
MOV RSI,qword ptr [RDI + 0x18]
MOVSXD R9,dword ptr [RDI]
MOV dword ptr [RSI + R9*0x4],EDX
MOV RDX,qword ptr [RCX]
MOV RSI,qword ptr [RCX + 0x8]
MOV RCX,RSI
SUB RCX,RDX
SAR RCX,0x2
MOV R9,qword ptr [RDI + 0x20]
MOVSXD R10,dword ptr [RDI]
MOV dword ptr [R9 + R10*0x4],ECX
CMP RSI,RDX
JZ 0x001afeca
CMP RCX,0x1
ADC RCX,0x0
XOR ESI,ESI
LAB_001afeb3:
MOV R9D,dword ptr [RDX + RSI*0x4]
MOVSXD R10,dword ptr [RDI]
MOV R10,qword ptr [RAX + R10*0x8]
MOV dword ptr [R10 + RSI*0x4],R9D
INC RSI
CMP RCX,RSI
JNZ 0x001afeb3
LAB_001afeca:
MOV RAX,qword ptr [RDI + 0x30]
MOVSXD RCX,dword ptr [RDI]
MOV byte ptr [RAX + RCX*0x1],R8B
INC dword ptr [RDI]
POP RAX
RET
LAB_001afed9:
LEA RDI,[0x1d0c11]
LEA RDX,[0x1c8090]
LEA RCX,[0x1d11f1]
MOV ESI,0x478
XOR EAX,EAX
CALL 0x0011ca40
|
/* common_batch_add(llama_batch&, int, int, std::vector<int, std::allocator<int> > const&, bool) */
int8
common_batch_add(llama_batch *param_1,int param_2,int param_3,vector *param_4,bool param_5)
{
long lVar1;
long lVar2;
int8 in_RAX;
long lVar3;
long lVar4;
lVar1 = *(long *)(param_1 + 0x28);
if (*(long *)(lVar1 + (long)*(int *)param_1 * 8) != 0) {
*(int *)(*(long *)(param_1 + 8) + (long)*(int *)param_1 * 4) = param_2;
*(int *)(*(long *)(param_1 + 0x18) + (long)*(int *)param_1 * 4) = param_3;
lVar2 = *(long *)param_4;
lVar4 = *(long *)(param_4 + 8);
lVar3 = lVar4 - lVar2 >> 2;
*(int *)(*(long *)(param_1 + 0x20) + (long)*(int *)param_1 * 4) = (int)lVar3;
if (lVar4 != lVar2) {
lVar4 = 0;
do {
*(int4 *)(*(long *)(lVar1 + (long)*(int *)param_1 * 8) + lVar4 * 4) =
*(int4 *)(lVar2 + lVar4 * 4);
lVar4 = lVar4 + 1;
} while (lVar3 + (ulong)(lVar3 == 0) != lVar4);
}
*(bool *)(*(long *)(param_1 + 0x30) + (long)*(int *)param_1) = param_5;
*(int *)param_1 = *(int *)param_1 + 1;
return in_RAX;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",0x478,
"GGML_ASSERT(%s) failed",
"batch.seq_id[batch.n_tokens] && \"llama_batch size exceeded\"");
}
| |
54,719 | mi_store_bin_pack_key | eloqsql/storage/myisam/mi_search.c | void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo __attribute__((unused)),
register uchar *key_pos,
register MI_KEY_PARAM *s_temp)
{
store_key_length_inc(key_pos,s_temp->ref_length);
memcpy((char*) key_pos,(char*) s_temp->key+s_temp->ref_length,
(size_t) s_temp->totlength-s_temp->ref_length);
if (s_temp->next_key_pos)
{
key_pos+=(uint) (s_temp->totlength-s_temp->ref_length);
store_key_length_inc(key_pos,s_temp->n_ref_length);
if (s_temp->prev_length) /* If we must extend key */
{
memcpy(key_pos,s_temp->prev_key,s_temp->prev_length);
}
}
} | O0 | c | mi_store_bin_pack_key:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xff, (%rax)
jae 0xc3a0b
movq -0x18(%rbp), %rax
movl (%rax), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0xc3a42
movq -0x10(%rbp), %rax
movb $-0x1, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
addq %rax, %rsi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edx
movq -0x18(%rbp), %rax
movl (%rax), %eax
subq %rax, %rdx
callq 0x2a090
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xc3b1e
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
subl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xff, 0x8(%rax)
jae 0xc3ac0
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0xc3af8
movq -0x10(%rbp), %rax
movb $-0x1, (%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x20(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0xc3b1c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %edx
callq 0x2a090
jmp 0xc3b1e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| _mi_store_bin_pack_key:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_18]
cmp dword ptr [rax], 0FFh
jnb short loc_C3A0B
mov rax, [rbp+var_18]
mov eax, [rax]
mov cl, al
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
jmp short loc_C3A42
loc_C3A0B:
mov rax, [rbp+var_10]
mov byte ptr [rax], 0FFh
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov eax, [rbp+var_1C]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_10]
add rax, 3
mov [rbp+var_10], rax
loc_C3A42:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rsi, [rax+20h]
mov rax, [rbp+var_18]
mov eax, [rax]
add rsi, rax
mov rax, [rbp+var_18]
mov eax, [rax+10h]
mov edx, eax
mov rax, [rbp+var_18]
mov eax, [rax]
sub rdx, rax
call _memcpy
mov rax, [rbp+var_18]
cmp qword ptr [rax+30h], 0
jz loc_C3B1E
mov rax, [rbp+var_18]
mov ecx, [rax+10h]
mov rax, [rbp+var_18]
sub ecx, [rax]
mov rax, [rbp+var_10]
mov ecx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov rax, [rbp+var_18]
cmp dword ptr [rax+8], 0FFh
jnb short loc_C3AC0
mov rax, [rbp+var_18]
mov eax, [rax+8]
mov cl, al
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
jmp short loc_C3AF8
loc_C3AC0:
mov rax, [rbp+var_10]
mov byte ptr [rax], 0FFh
mov rax, [rbp+var_18]
mov eax, [rax+8]
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov eax, [rbp+var_20]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_10]
add rax, 3
mov [rbp+var_10], rax
loc_C3AF8:
mov rax, [rbp+var_18]
cmp dword ptr [rax+18h], 0
jz short loc_C3B1C
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rsi, [rax+28h]
mov rax, [rbp+var_18]
mov eax, [rax+18h]
mov edx, eax
call _memcpy
loc_C3B1C:
jmp short $+2
loc_C3B1E:
add rsp, 20h
pop rbp
retn
| long long mi_store_bin_pack_key(long long a1, _BYTE *a2, unsigned int *a3)
{
long long result; // rax
_BYTE *v4; // rax
unsigned int v5; // [rsp+0h] [rbp-20h]
int v6; // [rsp+4h] [rbp-1Ch]
_BYTE *v8; // [rsp+10h] [rbp-10h]
_BYTE *v9; // [rsp+10h] [rbp-10h]
_BYTE *v10; // [rsp+10h] [rbp-10h]
if ( *a3 >= 0xFF )
{
*a2 = -1;
v6 = *a3;
a2[2] = *a3;
a2[1] = BYTE1(v6);
v8 = a2 + 3;
}
else
{
v8 = a2 + 1;
*a2 = *a3;
}
memcpy(v8, *a3 + *((_QWORD *)a3 + 4), a3[4] - (unsigned long long)*a3);
result = (long long)a3;
if ( *((_QWORD *)a3 + 6) )
{
v9 = &v8[a3[4] - *a3];
if ( a3[2] >= 0xFF )
{
*v9 = -1;
v5 = a3[2];
v9[2] = v5;
v9[1] = BYTE1(v5);
v10 = v9 + 3;
}
else
{
v4 = v9;
v10 = v9 + 1;
*v4 = a3[2];
}
result = (long long)a3;
if ( a3[6] )
return memcpy(v10, *((_QWORD *)a3 + 5), a3[6]);
}
return result;
}
| _mi_store_bin_pack_key:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0xff
JNC 0x001c3a0b
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
JMP 0x001c3a42
LAB_001c3a0b:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0xff
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV EAX,dword ptr [RBP + -0x1c]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x3
MOV qword ptr [RBP + -0x10],RAX
LAB_001c3a42:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
ADD RSI,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x10]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
SUB RDX,RAX
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x30],0x0
JZ 0x001c3b1e
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x18]
SUB ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x8],0xff
JNC 0x001c3ac0
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x8]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
JMP 0x001c3af8
LAB_001c3ac0:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0xff
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV EAX,dword ptr [RBP + -0x20]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x3
MOV qword ptr [RBP + -0x10],RAX
LAB_001c3af8:
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x18],0x0
JZ 0x001c3b1c
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x18]
MOV EDX,EAX
CALL 0x0012a090
LAB_001c3b1c:
JMP 0x001c3b1e
LAB_001c3b1e:
ADD RSP,0x20
POP RBP
RET
|
void _mi_store_bin_pack_key(int8 param_1,int1 *param_2,uint *param_3)
{
uint uVar1;
int1 *puVar2;
int1 *local_18;
if (*param_3 < 0xff) {
local_18 = param_2 + 1;
*param_2 = (char)*param_3;
}
else {
*param_2 = 0xff;
uVar1 = *param_3;
param_2[2] = (char)uVar1;
param_2[1] = (char)(uVar1 >> 8);
local_18 = param_2 + 3;
}
memcpy(local_18,(void *)(*(long *)(param_3 + 8) + (ulong)*param_3),
(ulong)param_3[4] - (ulong)*param_3);
if (*(long *)(param_3 + 0xc) != 0) {
puVar2 = local_18 + (param_3[4] - *param_3);
if (param_3[2] < 0xff) {
local_18 = puVar2 + 1;
*puVar2 = (char)param_3[2];
}
else {
*puVar2 = 0xff;
uVar1 = param_3[2];
puVar2[2] = (char)uVar1;
puVar2[1] = (char)(uVar1 >> 8);
local_18 = puVar2 + 3;
}
if (param_3[6] != 0) {
memcpy(local_18,*(void **)(param_3 + 10),(ulong)param_3[6]);
}
}
return;
}
| |
54,720 | curl_perform_with_retry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void*, int, int) | llama.cpp/common/arg.cpp | static bool curl_perform_with_retry(const std::string & url, CURL * curl, int max_attempts, int retry_delay_seconds) {
int remaining_attempts = max_attempts;
while (remaining_attempts > 0) {
LOG_INF("%s: Trying to download from %s (attempt %d of %d)...\n", __func__ , url.c_str(), max_attempts - remaining_attempts + 1, max_attempts);
CURLcode res = curl_easy_perform(curl);
if (res == CURLE_OK) {
return true;
}
int exponential_backoff_delay = std::pow(retry_delay_seconds, max_attempts - remaining_attempts) * 1000;
LOG_WRN("%s: curl_easy_perform() failed: %s, retrying after %d milliseconds...\n", __func__, curl_easy_strerror(res), exponential_backoff_delay);
remaining_attempts--;
std::this_thread::sleep_for(std::chrono::milliseconds(exponential_backoff_delay));
}
LOG_ERR("%s: curl_easy_perform() failed after %d attempts\n", __func__, max_attempts);
return false;
} | O3 | cpp | curl_perform_with_retry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void*, int, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movl $0x3, %r14d
leaq 0x10112c(%rip), %r12 # 0x190d60
leaq 0xb2db3(%rip), %rbx # 0x1429ee
leaq 0x18(%rsp), %rbp
cmpl $0x0, (%r12)
js 0x8fc7d
callq 0x1323e3
movq 0x8(%rsp), %rcx
movq (%rcx), %r8
movl $0x4, %r9d
subl %r14d, %r9d
movl $0x3, (%rsp)
movq %rax, %rdi
movl $0x2, %esi
leaq 0xb2d45(%rip), %rdx # 0x1429b8
movq %rbx, %rcx
xorl %eax, %eax
callq 0x132480
movq 0x10(%rsp), %rdi
callq 0x23fb0
movl %eax, %r15d
testl %eax, %eax
je 0x8fd7f
movl $0x3, %edi
subl %r14d, %edi
movsd 0xa88c6(%rip), %xmm0 # 0x138568
callq 0x24740
mulsd 0xa7a71(%rip), %xmm0 # 0x137720
cvttsd2si %xmm0, %r13d
cmpl $0x0, (%r12)
js 0x8fcf7
callq 0x1323e3
movq %r12, %rbx
movq %rax, %r12
movl %r15d, %edi
callq 0x23980
movq %r12, %rdi
movq %rbx, %r12
leaq 0xb2d13(%rip), %rbx # 0x1429ee
movl $0x3, %esi
leaq 0xb2d1f(%rip), %rdx # 0x142a06
movq %rbx, %rcx
movq %rax, %r8
movl %r13d, %r9d
xorl %eax, %eax
callq 0x132480
testl %r13d, %r13d
jle 0x8fd3f
movl %r13d, %eax
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
shrq $0x26, %rcx
imulq $-0x3e8, %rcx, %rdx # imm = 0xFC18
addq %rax, %rdx
imulq $0xf4240, %rdx, %rax # imm = 0xF4240
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq %rbp, %rdi
movq %rbp, %rsi
callq 0x24870
cmpl $-0x1, %eax
jne 0x8fd3f
callq 0x24730
cmpl $0x4, (%rax)
je 0x8fd25
leal -0x1(%r14), %eax
cmpl $0x1, %r14d
movl %eax, %r14d
ja 0x8fc40
cmpl $0x0, (%r12)
js 0x8fd7f
callq 0x1323e3
leaq 0xb2cea(%rip), %rdx # 0x142a4d
leaq 0xb2c84(%rip), %rcx # 0x1429ee
movq %rax, %rdi
movl $0x4, %esi
movl $0x3, %r8d
xorl %eax, %eax
callq 0x132480
testl %r15d, %r15d
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZL23curl_perform_with_retryRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPvii:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_48], rsi
mov [rsp+58h+var_50], rdi
mov r14d, 3
lea r12, common_log_verbosity_thold
lea rbx, aCurlPerformWit; "curl_perform_with_retry"
lea rbp, [rsp+58h+var_40]
loc_8FC40:
cmp dword ptr [r12], 0
js short loc_8FC7D
call _Z15common_log_mainv; common_log_main(void)
mov rcx, [rsp+58h+var_50]
mov r8, [rcx]
mov r9d, 4
sub r9d, r14d
mov [rsp+58h+var_58], 3
mov rdi, rax
mov esi, 2
lea rdx, aSTryingToDownl_0; "%s: Trying to download from %s (attempt"...
mov rcx, rbx
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_8FC7D:
mov rdi, [rsp+58h+var_48]
call _curl_easy_perform
mov r15d, eax
test eax, eax
jz loc_8FD7F
mov edi, 3
sub edi, r14d
movsd xmm0, cs:qword_138568
call _ldexp
mulsd xmm0, cs:qword_137720
cvttsd2si r13d, xmm0
cmp dword ptr [r12], 0
js short loc_8FCF7
call _Z15common_log_mainv; common_log_main(void)
mov rbx, r12
mov r12, rax
mov edi, r15d
call _curl_easy_strerror
mov rdi, r12
mov r12, rbx
lea rbx, aCurlPerformWit; "curl_perform_with_retry"
mov esi, 3
lea rdx, aSCurlEasyPerfo; "%s: curl_easy_perform() failed: %s, ret"...
mov rcx, rbx
mov r8, rax
mov r9d, r13d
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_8FCF7:
test r13d, r13d
jle short loc_8FD3F
mov eax, r13d
imul rcx, rax, 10624DD3h
shr rcx, 26h
imul rdx, rcx, 0FFFFFFFFFFFFFC18h
add rdx, rax
imul rax, rdx, 0F4240h
mov [rsp+58h+var_40], rcx
mov [rsp+58h+var_38], rax
loc_8FD25:
mov rdi, rbp
mov rsi, rbp
call _nanosleep
cmp eax, 0FFFFFFFFh
jnz short loc_8FD3F
call ___errno_location
cmp dword ptr [rax], 4
jz short loc_8FD25
loc_8FD3F:
lea eax, [r14-1]
cmp r14d, 1
mov r14d, eax
ja loc_8FC40
cmp dword ptr [r12], 0
js short loc_8FD7F
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSCurlEasyPerfo_0; "%s: curl_easy_perform() failed after %d"...
lea rcx, aCurlPerformWit; "curl_perform_with_retry"
mov rdi, rax
mov esi, 4
mov r8d, 3
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_8FD7F:
test r15d, r15d
setz al
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| bool curl_perform_with_retry(_QWORD *a1, long long a2)
{
unsigned int v2; // r14d
int *v3; // r12
int v4; // eax
unsigned int v5; // r15d
int v6; // r13d
int *v7; // rbx
int v8; // r12d
int v9; // eax
int v10; // edi
int v12; // eax
int v13; // r9d
_QWORD v16[8]; // [rsp+18h] [rbp-40h] BYREF
v2 = 3;
v3 = (int *)&common_log_verbosity_thold;
while ( 1 )
{
if ( *v3 >= 0 )
{
v4 = common_log_main();
common_log_add(
v4,
2,
(unsigned int)"%s: Trying to download from %s (attempt %d of %d)...\n",
(unsigned int)"curl_perform_with_retry",
*a1,
4 - v2);
}
v5 = curl_easy_perform(a2);
if ( !v5 )
break;
v6 = (int)(ldexp(1.0, 3 - v2) * 1000.0);
if ( *v3 >= 0 )
{
v7 = v3;
v8 = common_log_main();
v9 = curl_easy_strerror(v5);
v10 = v8;
v3 = v7;
common_log_add(
v10,
3,
(unsigned int)"%s: curl_easy_perform() failed: %s, retrying after %d milliseconds...\n",
(unsigned int)"curl_perform_with_retry",
v9,
v6);
}
if ( v6 > 0 )
{
v16[0] = (unsigned int)v6 / 0x3E8uLL;
v16[1] = 1000000 * ((unsigned int)v6 % 0x3E8uLL);
while ( (unsigned int)nanosleep(v16, v16) == -1 && *(_DWORD *)__errno_location(v16) == 4 )
;
}
if ( v2-- <= 1 )
{
if ( *v3 >= 0 )
{
v12 = common_log_main();
common_log_add(
v12,
4,
(unsigned int)"%s: curl_easy_perform() failed after %d attempts\n",
(unsigned int)"curl_perform_with_retry",
3,
v13);
}
return v5 == 0;
}
}
return v5 == 0;
}
| curl_perform_with_retry:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x8],RDI
MOV R14D,0x3
LEA R12,[0x290d60]
LEA RBX,[0x2429ee]
LEA RBP,[RSP + 0x18]
LAB_0018fc40:
CMP dword ptr [R12],0x0
JS 0x0018fc7d
CALL 0x002323e3
MOV RCX,qword ptr [RSP + 0x8]
MOV R8,qword ptr [RCX]
MOV R9D,0x4
SUB R9D,R14D
MOV dword ptr [RSP],0x3
MOV RDI,RAX
MOV ESI,0x2
LEA RDX,[0x2429b8]
MOV RCX,RBX
XOR EAX,EAX
CALL 0x00232480
LAB_0018fc7d:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00123fb0
MOV R15D,EAX
TEST EAX,EAX
JZ 0x0018fd7f
MOV EDI,0x3
SUB EDI,R14D
MOVSD XMM0,qword ptr [0x00238568]
CALL 0x00124740
MULSD XMM0,qword ptr [0x00237720]
CVTTSD2SI R13D,XMM0
CMP dword ptr [R12],0x0
JS 0x0018fcf7
CALL 0x002323e3
MOV RBX,R12
MOV R12,RAX
MOV EDI,R15D
CALL 0x00123980
MOV RDI,R12
MOV R12,RBX
LEA RBX,[0x2429ee]
MOV ESI,0x3
LEA RDX,[0x242a06]
MOV RCX,RBX
MOV R8,RAX
MOV R9D,R13D
XOR EAX,EAX
CALL 0x00232480
LAB_0018fcf7:
TEST R13D,R13D
JLE 0x0018fd3f
MOV EAX,R13D
IMUL RCX,RAX,0x10624dd3
SHR RCX,0x26
IMUL RDX,RCX,-0x3e8
ADD RDX,RAX
IMUL RAX,RDX,0xf4240
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x20],RAX
LAB_0018fd25:
MOV RDI,RBP
MOV RSI,RBP
CALL 0x00124870
CMP EAX,-0x1
JNZ 0x0018fd3f
CALL 0x00124730
CMP dword ptr [RAX],0x4
JZ 0x0018fd25
LAB_0018fd3f:
LEA EAX,[R14 + -0x1]
CMP R14D,0x1
MOV R14D,EAX
JA 0x0018fc40
CMP dword ptr [R12],0x0
JS 0x0018fd7f
CALL 0x002323e3
LEA RDX,[0x242a4d]
LEA RCX,[0x2429ee]
MOV RDI,RAX
MOV ESI,0x4
MOV R8D,0x3
XOR EAX,EAX
CALL 0x00232480
LAB_0018fd7f:
TEST R15D,R15D
SETZ AL
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* curl_perform_with_retry(std::__cxx11::string const&, void*, int, int) */
bool curl_perform_with_retry(string *param_1,void *param_2,int param_3,int param_4)
{
bool bVar1;
int iVar2;
int iVar3;
int8 uVar4;
int8 uVar5;
int *piVar6;
uint uVar7;
uint uVar8;
double dVar9;
timespec local_40;
uVar8 = 3;
do {
if (-1 < common_log_verbosity_thold) {
uVar4 = common_log_main();
common_log_add(uVar4,2,"%s: Trying to download from %s (attempt %d of %d)...\n",
"curl_perform_with_retry",*(int8 *)param_1,4 - uVar8,3);
}
iVar2 = curl_easy_perform(param_2);
if (iVar2 == 0) goto LAB_0018fd7f;
dVar9 = ldexp(DAT_00238568,3 - uVar8);
uVar7 = (uint)(dVar9 * _DAT_00237720);
if (-1 < common_log_verbosity_thold) {
uVar4 = common_log_main();
uVar5 = curl_easy_strerror(iVar2);
common_log_add(uVar4,3,
"%s: curl_easy_perform() failed: %s, retrying after %d milliseconds...\n",
"curl_perform_with_retry",uVar5,uVar7);
}
if (0 < (int)uVar7) {
local_40.tv_sec = (ulong)uVar7 / 1000;
local_40.tv_nsec = ((ulong)uVar7 % 1000) * 1000000;
do {
iVar3 = nanosleep(&local_40,&local_40);
if (iVar3 != -1) break;
piVar6 = __errno_location();
} while (*piVar6 == 4);
}
bVar1 = 1 < uVar8;
uVar8 = uVar8 - 1;
} while (bVar1);
if (-1 < common_log_verbosity_thold) {
uVar4 = common_log_main();
common_log_add(uVar4,4,"%s: curl_easy_perform() failed after %d attempts\n",
"curl_perform_with_retry",3);
}
LAB_0018fd7f:
return iVar2 == 0;
}
| |
54,721 | JS_IsExtensible | bluesky950520[P]quickjs/quickjs.c | int JS_IsExtensible(JSContext *ctx, JSValue obj)
{
JSObject *p;
if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
return FALSE;
p = JS_VALUE_GET_OBJ(obj);
if (unlikely(p->class_id == JS_CLASS_PROXY))
return js_proxy_isExtensible(ctx, obj);
else
return p->extensible;
} | O0 | c | JS_IsExtensible:
subq $0x28, %rsp
movq %rsi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $-0x1, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2f819
movl $0x0, 0x24(%rsp)
jmp 0x2f86b
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x30, %eax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2f85b
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x2f880
movl %eax, 0x24(%rsp)
jmp 0x2f86b
movq (%rsp), %rax
movb 0x5(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_IsExtensible:
sub rsp, 28h
mov [rsp+28h+var_18], rsi
mov [rsp+28h+var_10], rdx
mov [rsp+28h+var_20], rdi
mov rax, [rsp+28h+var_10]
cmp eax, 0FFFFFFFFh
setnz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_2F819
mov [rsp+28h+var_4], 0
jmp short loc_2F86B
loc_2F819:
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_28], rax
mov rax, [rsp+28h+var_28]
movzx eax, word ptr [rax+6]
cmp eax, 30h ; '0'
setz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_2F85B
mov rdi, [rsp+28h+var_20]
mov rsi, [rsp+28h+var_18]
mov rdx, [rsp+28h+var_10]
call js_proxy_isExtensible
mov [rsp+28h+var_4], eax
jmp short loc_2F86B
loc_2F85B:
mov rax, [rsp+28h+var_28]
mov al, [rax+5]
and al, 1
movzx eax, al
mov [rsp+28h+var_4], eax
loc_2F86B:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| long long JS_IsExtensible(long long a1, long long a2, long long a3)
{
if ( (_DWORD)a3 == -1 )
{
if ( *(_WORD *)(a2 + 6) == 48 )
return (unsigned int)js_proxy_isExtensible(a1, a2, a3);
else
return *(_BYTE *)(a2 + 5) & 1;
}
else
{
return 0;
}
}
| JS_IsExtensible:
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x18],RDX
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr [RSP + 0x18]
CMP EAX,-0x1
SETNZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0012f819
MOV dword ptr [RSP + 0x24],0x0
JMP 0x0012f86b
LAB_0012f819:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0x30
SETZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0012f85b
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x0012f880
MOV dword ptr [RSP + 0x24],EAX
JMP 0x0012f86b
LAB_0012f85b:
MOV RAX,qword ptr [RSP]
MOV AL,byte ptr [RAX + 0x5]
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + 0x24],EAX
LAB_0012f86b:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
uint JS_IsExtensible(int8 param_1,long param_2,int8 param_3)
{
int4 local_4;
if ((int)param_3 == -1) {
if (*(short *)(param_2 + 6) == 0x30) {
local_4 = js_proxy_isExtensible(param_1,param_2,param_3);
}
else {
local_4 = (uint)(*(byte *)(param_2 + 5) & 1);
}
}
else {
local_4 = 0;
}
return local_4;
}
| |
54,722 | JS_IsExtensible | bluesky950520[P]quickjs/quickjs.c | int JS_IsExtensible(JSContext *ctx, JSValue obj)
{
JSObject *p;
if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
return FALSE;
p = JS_VALUE_GET_OBJ(obj);
if (unlikely(p->class_id == JS_CLASS_PROXY))
return js_proxy_isExtensible(ctx, obj);
else
return p->extensible;
} | O1 | c | JS_IsExtensible:
movq %rsi, -0x8(%rsp)
cmpl $-0x1, %edx
jne 0xf690
movq -0x8(%rsp), %rax
cmpw $0x30, 0x6(%rax)
je 0xf693
movzbl 0x5(%rax), %eax
andl $0x1, %eax
retq
xorl %eax, %eax
retq
movq -0x8(%rsp), %rsi
jmp 0x232ce
| JS_IsExtensible:
mov [rsp+var_8], rsi
cmp edx, 0FFFFFFFFh
jnz short loc_F690
mov rax, [rsp+var_8]
cmp word ptr [rax+6], 30h ; '0'
jz short loc_F693
movzx eax, byte ptr [rax+5]
and eax, 1
retn
loc_F690:
xor eax, eax
retn
loc_F693:
mov rsi, [rsp+var_8]
jmp js_proxy_isExtensible
| long long JS_IsExtensible(long long a1, long long a2, int a3)
{
if ( a3 != -1 )
return 0LL;
if ( *(_WORD *)(a2 + 6) == 48 )
return js_proxy_isExtensible(a1, a2);
return *(_BYTE *)(a2 + 5) & 1;
}
| JS_IsExtensible:
MOV qword ptr [RSP + -0x8],RSI
CMP EDX,-0x1
JNZ 0x0010f690
MOV RAX,qword ptr [RSP + -0x8]
CMP word ptr [RAX + 0x6],0x30
JZ 0x0010f693
MOVZX EAX,byte ptr [RAX + 0x5]
AND EAX,0x1
RET
LAB_0010f690:
XOR EAX,EAX
RET
LAB_0010f693:
MOV RSI,qword ptr [RSP + -0x8]
JMP 0x001232ce
|
ulong JS_IsExtensible(int8 param_1,long param_2,int param_3)
{
ulong uVar1;
if (param_3 != -1) {
return 0;
}
if (*(short *)(param_2 + 6) != 0x30) {
return (ulong)(*(byte *)(param_2 + 5) & 1);
}
uVar1 = js_proxy_isExtensible(param_1,param_2);
return uVar1;
}
| |
54,723 | JS_IsExtensible | bluesky950520[P]quickjs/quickjs.c | int JS_IsExtensible(JSContext *ctx, JSValue obj)
{
JSObject *p;
if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
return FALSE;
p = JS_VALUE_GET_OBJ(obj);
if (unlikely(p->class_id == JS_CLASS_PROXY))
return js_proxy_isExtensible(ctx, obj);
else
return p->extensible;
} | O2 | c | JS_IsExtensible:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rcx
cmpl $-0x1, %ecx
jne 0x1d2be
movq %rsi, %rdx
cmpw $0x30, 0x6(%rsi)
je 0x1d2c2
movzbl 0x5(%rdx), %ebp
andl $0x1, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x1d2b1
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
pushq $0x62
popq %r8
callq 0x35185
pushq $-0x1
popq %r15
testq %rax, %rax
je 0x1d357
movq %rax, %r14
movq 0x10(%rsp), %rdx
cmpl $0x3, %edx
jne 0x1d2fc
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x1d28e
movl %eax, %ebp
jmp 0x1d2b1
movq 0x8(%rsp), %rsi
movq 0x10(%r14), %rcx
movq 0x18(%r14), %r8
movq %r14, (%rsp)
pushq $0x1
popq %r9
movq %rbx, %rdi
callq 0x1c212
cmpl $0x6, %edx
je 0x1d357
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c27e
movl %eax, %ebp
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x1d28e
testl %eax, %eax
js 0x1d357
cmpl %eax, %ebp
je 0x1d2b1
leaq 0x683c1(%rip), %rsi # 0x8570e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1bad1
movl %r15d, %ebp
jmp 0x1d2b1
| JS_IsExtensible:
push rbp
push r15
push r14
push rbx
sub rsp, 18h
mov rcx, rdx
cmp ecx, 0FFFFFFFFh
jnz short loc_1D2BE
mov rdx, rsi
cmp word ptr [rsi+6], 30h ; '0'
jz short loc_1D2C2
movzx ebp, byte ptr [rdx+5]
and ebp, 1
loc_1D2B1:
mov eax, ebp
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_1D2BE:
xor ebp, ebp
jmp short loc_1D2B1
loc_1D2C2:
mov rbx, rdi
lea rsi, [rsp+38h+var_30]
push 62h ; 'b'
pop r8
call get_proxy_method
push 0FFFFFFFFFFFFFFFFh
pop r15
test rax, rax
jz short loc_1D357
mov r14, rax
mov rdx, [rsp+38h+var_28]
cmp edx, 3
jnz short loc_1D2FC
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call JS_IsExtensible
mov ebp, eax
jmp short loc_1D2B1
loc_1D2FC:
mov rsi, [rsp+38h+var_30]
mov rcx, [r14+10h]
mov r8, [r14+18h]
mov [rsp+38h+var_38], r14
push 1
pop r9
mov rdi, rbx
call JS_CallFree
cmp edx, 6
jz short loc_1D357
mov rdi, rbx
mov rsi, rax
call JS_ToBoolFree
mov ebp, eax
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call JS_IsExtensible
test eax, eax
js short loc_1D357
cmp ebp, eax
jz loc_1D2B1
lea rsi, aProxyInconsist_0; "proxy: inconsistent isExtensible"
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
loc_1D357:
mov ebp, r15d
jmp loc_1D2B1
| long long JS_IsExtensible(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
unsigned int v11; // ebp
_QWORD *proxy_method; // rax
_QWORD *v14; // r14
long long v15; // rax
long long v16; // rdx
int IsExtensible; // eax
long long v18; // rdx
long long v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
char v24; // [rsp+0h] [rbp-38h]
long long v25; // [rsp+8h] [rbp-30h] BYREF
long long v26; // [rsp+10h] [rbp-28h]
if ( (_DWORD)a3 == -1 )
{
if ( *(_WORD *)(a2 + 6) == 48 )
{
proxy_method = (_QWORD *)get_proxy_method(a1, &v25, a2, a3, 98LL);
if ( proxy_method )
{
v14 = proxy_method;
if ( (_DWORD)v26 == 3 )
return (unsigned int)JS_IsExtensible(a1, *proxy_method, proxy_method[1]);
v15 = JS_CallFree(a1, v25, v26, proxy_method[2], proxy_method[3], 1, (long long)proxy_method);
if ( (_DWORD)v16 != 6 )
{
v11 = JS_ToBoolFree(a1, v15, v16);
IsExtensible = JS_IsExtensible(a1, *v14, v14[1]);
if ( IsExtensible >= 0 )
{
if ( v11 == IsExtensible )
return v11;
JS_ThrowTypeError(
a1,
(long long)"proxy: inconsistent isExtensible",
v18,
v19,
v20,
v21,
a4,
a5,
a6,
a7,
v22,
v23,
a10,
a11,
v24);
}
}
}
return (unsigned int)-1;
}
return *(_BYTE *)(a2 + 5) & 1;
}
else
{
return 0;
}
}
| JS_IsExtensible:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RCX,RDX
CMP ECX,-0x1
JNZ 0x0011d2be
MOV RDX,RSI
CMP word ptr [RSI + 0x6],0x30
JZ 0x0011d2c2
MOVZX EBP,byte ptr [RDX + 0x5]
AND EBP,0x1
LAB_0011d2b1:
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0011d2be:
XOR EBP,EBP
JMP 0x0011d2b1
LAB_0011d2c2:
MOV RBX,RDI
LEA RSI,[RSP + 0x8]
PUSH 0x62
POP R8
CALL 0x00135185
PUSH -0x1
POP R15
TEST RAX,RAX
JZ 0x0011d357
MOV R14,RAX
MOV RDX,qword ptr [RSP + 0x10]
CMP EDX,0x3
JNZ 0x0011d2fc
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x0011d28e
MOV EBP,EAX
JMP 0x0011d2b1
LAB_0011d2fc:
MOV RSI,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [R14 + 0x10]
MOV R8,qword ptr [R14 + 0x18]
MOV qword ptr [RSP],R14
PUSH 0x1
POP R9
MOV RDI,RBX
CALL 0x0011c212
CMP EDX,0x6
JZ 0x0011d357
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011c27e
MOV EBP,EAX
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x0011d28e
TEST EAX,EAX
JS 0x0011d357
CMP EBP,EAX
JZ 0x0011d2b1
LEA RSI,[0x18570e]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0011bad1
LAB_0011d357:
MOV EBP,R15D
JMP 0x0011d2b1
|
uint JS_IsExtensible(int8 param_1,long param_2,int8 param_3)
{
uint uVar1;
int8 *puVar2;
uint uVar3;
int1 auVar4 [12];
int8 local_30;
int8 local_28;
if ((int)param_3 == -1) {
if (*(short *)(param_2 + 6) == 0x30) {
puVar2 = (int8 *)get_proxy_method(param_1,&local_30,param_2,param_3,0x62);
if (puVar2 != (int8 *)0x0) {
if ((int)local_28 == 3) {
uVar3 = JS_IsExtensible(param_1,*puVar2,puVar2[1]);
return uVar3;
}
auVar4 = JS_CallFree(param_1,local_30,local_28,puVar2[2],puVar2[3],1,puVar2);
if (auVar4._8_4_ != 6) {
uVar3 = JS_ToBoolFree(param_1,auVar4._0_8_);
uVar1 = JS_IsExtensible(param_1,*puVar2,puVar2[1]);
if (-1 < (int)uVar1) {
if (uVar3 == uVar1) {
return uVar3;
}
JS_ThrowTypeError(param_1,"proxy: inconsistent isExtensible");
}
}
}
uVar3 = 0xffffffff;
}
else {
uVar3 = *(byte *)(param_2 + 5) & 1;
}
}
else {
uVar3 = 0;
}
return uVar3;
}
| |
54,724 | JS_IsExtensible | bluesky950520[P]quickjs/quickjs.c | int JS_IsExtensible(JSContext *ctx, JSValue obj)
{
JSObject *p;
if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
return FALSE;
p = JS_VALUE_GET_OBJ(obj);
if (unlikely(p->class_id == JS_CLASS_PROXY))
return js_proxy_isExtensible(ctx, obj);
else
return p->extensible;
} | O3 | c | JS_IsExtensible:
cmpl $-0x1, %edx
jne 0xf6be
cmpw $0x30, 0x6(%rsi)
je 0xf6c1
movzbl 0x5(%rsi), %eax
andl $0x1, %eax
retq
xorl %eax, %eax
retq
| JS_IsExtensible:
cmp edx, 0FFFFFFFFh
jnz short loc_F6BE
cmp word ptr [rsi+6], 30h ; '0'
jz short js_proxy_isExtensible
movzx eax, byte ptr [rsi+5]
and eax, 1
retn
loc_F6BE:
xor eax, eax
retn
| long long JS_IsExtensible(long long a1, long long a2, int a3)
{
if ( a3 != -1 )
return 0LL;
if ( *(_WORD *)(a2 + 6) == 48 )
return js_proxy_isExtensible();
return *(_BYTE *)(a2 + 5) & 1;
}
| JS_IsExtensible:
CMP EDX,-0x1
JNZ 0x0010f6be
CMP word ptr [RSI + 0x6],0x30
JZ 0x0010f6c1
MOVZX EAX,byte ptr [RSI + 0x5]
AND EAX,0x1
RET
LAB_0010f6be:
XOR EAX,EAX
RET
|
uint JS_IsExtensible(int8 param_1,long param_2,long param_3)
{
uint uVar1;
uint uVar2;
long *plVar3;
int1 auVar4 [12];
int8 uStack_30;
int8 uStack_28;
if ((int)param_3 != -1) {
return 0;
}
if (*(short *)(param_2 + 6) != 0x30) {
return *(byte *)(param_2 + 5) & 1;
}
do {
plVar3 = (long *)get_proxy_method(param_1,&uStack_30,param_2,param_3,0x62);
if (plVar3 == (long *)0x0) {
return 0xffffffff;
}
if ((int)uStack_28 != 3) {
auVar4 = JS_CallFree(param_1,uStack_30,uStack_28,plVar3[2],plVar3[3],1,plVar3);
if (auVar4._8_4_ == 6) {
return 0xffffffff;
}
uVar1 = JS_ToBoolFree(param_1,auVar4._0_8_);
if ((int)plVar3[1] == -1) {
if (*(short *)(*plVar3 + 6) == 0x30) {
uVar2 = js_proxy_isExtensible(param_1);
if ((int)uVar2 < 0) {
return 0xffffffff;
}
}
else {
uVar2 = *(byte *)(*plVar3 + 5) & 1;
}
}
else {
uVar2 = 0;
}
if (uVar1 != uVar2) {
JS_ThrowTypeError(param_1,"proxy: inconsistent isExtensible");
return 0xffffffff;
}
return uVar1;
}
param_3 = plVar3[1];
if ((int)param_3 != -1) {
return 0;
}
param_2 = *plVar3;
} while (*(short *)(param_2 + 6) == 0x30);
return *(byte *)(param_2 + 5) & 1;
}
| |
54,725 | minja::Value::call(std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&) const | monkey531[P]llama/common/minja.hpp | Value call(const std::shared_ptr<Context> & context, ArgumentsValue & args) const {
if (!callable_) throw std::runtime_error("Value is not callable: " + dump());
return (*callable_)(context, args);
} | O3 | cpp | minja::Value::call(std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq 0x30(%rsi), %rsi
testq %rsi, %rsi
je 0x964e1
cmpq $0x0, 0x10(%rsi)
je 0x9653c
movq %rdi, %rbx
callq *0x18(%rsi)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x1b4f0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x891ce
leaq 0x5c4e7(%rip), %rsi # 0xf29ee
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x7b895
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c030
xorl %ebp, %ebp
movq 0x97abb(%rip), %rsi # 0x12dfe8
movq 0x97a24(%rip), %rdx # 0x12df58
movq %rbx, %rdi
callq 0x1c150
callq 0x1b360
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9655f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1ba20
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9657a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1ba20
testb %bpl, %bpl
jne 0x965a4
jmp 0x965ac
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x965a4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1ba20
jmp 0x965a4
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b770
movq %r14, %rdi
callq 0x1c1e0
| _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rsi
mov rsi, [rsi+30h]
test rsi, rsi
jz short loc_964E1
cmp qword ptr [rsi+10h], 0
jz short loc_9653C
mov rbx, rdi
call qword ptr [rsi+18h]
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_964E1:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotCall; "Value is not callable: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_9653C:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9655F
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9655F:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9657A
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9657A:
test bpl, bpl
jnz short loc_965A4
jmp short loc_965AC
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_965A4
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_965A4
mov r14, rax
loc_965A4:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_965AC:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::call(long long a1, long long a2)
{
long long v3; // rsi
void *exception; // rbx
_BYTE v6[16]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v7[16]; // [rsp+20h] [rbp-38h] BYREF
v3 = *(_QWORD *)(a2 + 48);
if ( !v3 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v6, a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v7, (long long)"Value is not callable: ", (long long)v6);
std::runtime_error::runtime_error(exception);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !*(_QWORD *)(v3 + 16) )
std::__throw_bad_function_call();
(*(void (**)(void))(v3 + 24))();
return a1;
}
| call:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
MOV RSI,qword ptr [RSI + 0x30]
TEST RSI,RSI
JZ 0x001964e1
CMP qword ptr [RSI + 0x10],0x0
JZ 0x0019653c
MOV RBX,RDI
CALL qword ptr [RSI + 0x18]
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001964e1:
MOV EDI,0x10
CALL 0x0011b4f0
MOV RBX,RAX
LAB_001964ee:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001891ce
LAB_00196500:
LEA RSI,[0x1f29ee]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x0017b895
MOV BPL,0x1
LAB_00196517:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x0011c030
XOR EBP,EBP
MOV RSI,qword ptr [0x0022dfe8]
MOV RDX,qword ptr [0x0022df58]
MOV RDI,RBX
CALL 0x0011c150
LAB_0019653c:
CALL 0x0011b360
|
/* minja::Value::call(std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&) const */
shared_ptr * minja::Value::call(shared_ptr *param_1,ArgumentsValue *param_2)
{
long lVar1;
runtime_error *this;
int1 auStack_58 [32];
string local_38 [32];
lVar1 = *(long *)(param_2 + 0x30);
if (lVar1 == 0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001964ee to 001964ff has its CatchHandler @ 001965a1 */
dump_abi_cxx11_((int)auStack_58,SUB81(param_2,0));
/* try { // try from 00196500 to 00196513 has its CatchHandler @ 00196581 */
std::operator+((char *)local_38,(string *)"Value is not callable: ");
/* try { // try from 00196517 to 0019653b has its CatchHandler @ 00196541 */
std::runtime_error::runtime_error(this,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0022dfe8,PTR__runtime_error_0022df58);
}
if (*(long *)(lVar1 + 0x10) != 0) {
(**(code **)(lVar1 + 0x18))();
return param_1;
}
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
| |
54,726 | hashcmp | eloqsql/mysys/hash.c | static int hashcmp(const HASH *hash, HASH_LINK *pos, const uchar *key,
size_t length)
{
size_t rec_keylength;
uchar *rec_key= (uchar*) my_hash_key(hash, pos->data, &rec_keylength, 1);
return ((length && length != rec_keylength) ||
my_strnncoll(hash->charset, (uchar*) rec_key, rec_keylength,
(uchar*) key, rec_keylength));
} | O3 | c | hashcmp:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r14
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x2fda0
leaq -0x28(%rbp), %r12
movq %rsi, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq *%rax
movq %rax, %rsi
movq (%r12), %rdx
jmp 0x2fdab
movq 0x8(%r14), %rdx
movq %rdx, -0x28(%rbp)
addq (%r14), %rsi
testq %r15, %r15
sete %al
cmpq %r15, %rdx
sete %cl
orb %al, %cl
movl $0x1, %eax
cmpb $0x1, %cl
jne 0x2fde3
movq 0x68(%r14), %rdi
movq 0xc0(%rdi), %rax
movq %rbx, %rcx
movq %rdx, %r8
xorl %r9d, %r9d
callq *0x8(%rax)
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| hashcmp:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov r15, rcx
mov rbx, rdx
mov r14, rdi
mov rax, [rdi+50h]
test rax, rax
jz short loc_2FDA0
lea r12, [rbp+var_28]
mov rdi, rsi
mov rsi, r12
mov edx, 1
call rax
mov rsi, rax
mov rdx, [r12]
jmp short loc_2FDAB
loc_2FDA0:
mov rdx, [r14+8]
mov [rbp+var_28], rdx
add rsi, [r14]
loc_2FDAB:
test r15, r15
setz al
cmp rdx, r15
setz cl
or cl, al
mov eax, 1
cmp cl, 1
jnz short loc_2FDE3
mov rdi, [r14+68h]
mov rax, [rdi+0C0h]
mov rcx, rbx
mov r8, rdx
xor r9d, r9d
call qword ptr [rax+8]
mov ecx, eax
xor eax, eax
test ecx, ecx
setnz al
loc_2FDE3:
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| _BOOL8 hashcmp(_QWORD *a1, long long a2, long long a3, long long a4)
{
long long ( *v6)(long long, _QWORD *, long long); // rax
long long v7; // rsi
long long v8; // rdx
_BOOL8 result; // rax
_QWORD v10[5]; // [rsp+8h] [rbp-28h] BYREF
v6 = (long long ( *)(long long, _QWORD *, long long))a1[10];
if ( v6 )
{
v7 = v6(a2, v10, 1LL);
v8 = v10[0];
}
else
{
v8 = a1[1];
v10[0] = v8;
v7 = *a1 + a2;
}
result = 1LL;
if ( a4 == 0 || v8 == a4 )
return (*(unsigned int ( **)(_QWORD, long long, long long, long long, long long, _QWORD))(*(_QWORD *)(a1[13] + 192LL)
+ 8LL))(
a1[13],
v7,
v8,
a3,
v8,
0LL) != 0;
return result;
}
| hashcmp:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R15,RCX
MOV RBX,RDX
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x50]
TEST RAX,RAX
JZ 0x0012fda0
LEA R12,[RBP + -0x28]
MOV RDI,RSI
MOV RSI,R12
MOV EDX,0x1
CALL RAX
MOV RSI,RAX
MOV RDX,qword ptr [R12]
JMP 0x0012fdab
LAB_0012fda0:
MOV RDX,qword ptr [R14 + 0x8]
MOV qword ptr [RBP + -0x28],RDX
ADD RSI,qword ptr [R14]
LAB_0012fdab:
TEST R15,R15
SETZ AL
CMP RDX,R15
SETZ CL
OR CL,AL
MOV EAX,0x1
CMP CL,0x1
JNZ 0x0012fde3
MOV RDI,qword ptr [R14 + 0x68]
MOV RAX,qword ptr [RDI + 0xc0]
MOV RCX,RBX
MOV R8,RDX
XOR R9D,R9D
CALL qword ptr [RAX + 0x8]
MOV ECX,EAX
XOR EAX,EAX
TEST ECX,ECX
SETNZ AL
LAB_0012fde3:
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
bool hashcmp(long *param_1,long param_2,int8 param_3,long param_4)
{
int iVar1;
bool bVar2;
long local_30;
if ((code *)param_1[10] == (code *)0x0) {
local_30 = param_1[1];
param_2 = param_2 + *param_1;
}
else {
param_2 = (*(code *)param_1[10])(param_2,&local_30,1);
}
bVar2 = true;
if (local_30 == param_4 || param_4 == 0) {
iVar1 = (**(code **)(*(long *)(param_1[0xd] + 0xc0) + 8))
(param_1[0xd],param_2,local_30,param_3,local_30,0);
bVar2 = iVar1 != 0;
}
return bVar2;
}
| |
54,727 | stbi__grow_buffer_unsafe | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h | static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
{
do {
unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
if (b == 0xff) {
int c = stbi__get8(j->s);
while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
if (c != 0) {
j->marker = (unsigned char) c;
j->nomore = 1;
return;
}
}
j->code_buffer |= b << (24 - j->code_bits);
j->code_bits += 8;
} while (j->code_bits <= 24);
} | O0 | c | stbi__grow_buffer_unsafe:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x482c(%rax)
je 0x7af60
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0x7af72
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6a1b0
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0xff, -0xc(%rbp)
jne 0x7afd7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6a1b0
movzbl %al, %eax
movl %eax, -0x10(%rbp)
cmpl $0xff, -0x10(%rbp)
jne 0x7afb0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6a1b0
movzbl %al, %eax
movl %eax, -0x10(%rbp)
jmp 0x7af93
cmpl $0x0, -0x10(%rbp)
je 0x7afd5
movl -0x10(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4828(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x482c(%rax)
jmp 0x7b021
jmp 0x7afd7
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rdx
movl $0x18, %ecx
subl 0x4824(%rdx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
orl 0x4820(%rax), %ecx
movl %ecx, 0x4820(%rax)
movq -0x8(%rbp), %rax
movl 0x4824(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x4824(%rax)
movq -0x8(%rbp), %rax
cmpl $0x18, 0x4824(%rax)
jle 0x7af4c
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| stbi__grow_buffer_unsafe:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
loc_7AF4C:
mov rax, [rbp+var_8]
cmp dword ptr [rax+482Ch], 0
jz short loc_7AF60
xor eax, eax
mov [rbp+var_14], eax
jmp short loc_7AF72
loc_7AF60:
mov rax, [rbp+var_8]
mov rdi, [rax]
call stbi__get8
movzx eax, al
mov [rbp+var_14], eax
loc_7AF72:
mov eax, [rbp+var_14]
mov [rbp+var_C], eax
cmp [rbp+var_C], 0FFh
jnz short loc_7AFD7
mov rax, [rbp+var_8]
mov rdi, [rax]
call stbi__get8
movzx eax, al
mov [rbp+var_10], eax
loc_7AF93:
cmp [rbp+var_10], 0FFh
jnz short loc_7AFB0
mov rax, [rbp+var_8]
mov rdi, [rax]
call stbi__get8
movzx eax, al
mov [rbp+var_10], eax
jmp short loc_7AF93
loc_7AFB0:
cmp [rbp+var_10], 0
jz short loc_7AFD5
mov eax, [rbp+var_10]
mov cl, al
mov rax, [rbp+var_8]
mov [rax+4828h], cl
mov rax, [rbp+var_8]
mov dword ptr [rax+482Ch], 1
jmp short loc_7B021
loc_7AFD5:
jmp short $+2
loc_7AFD7:
mov eax, [rbp+var_C]
mov rdx, [rbp+var_8]
mov ecx, 18h
sub ecx, [rdx+4824h]
shl eax, cl
mov ecx, eax
mov rax, [rbp+var_8]
or ecx, [rax+4820h]
mov [rax+4820h], ecx
mov rax, [rbp+var_8]
mov ecx, [rax+4824h]
add ecx, 8
mov [rax+4824h], ecx
mov rax, [rbp+var_8]
cmp dword ptr [rax+4824h], 18h
jle loc_7AF4C
loc_7B021:
add rsp, 20h
pop rbp
retn
| long long stbi__grow_buffer_unsafe(long long a1)
{
long long result; // rax
int v2; // [rsp+Ch] [rbp-14h]
int v3; // [rsp+10h] [rbp-10h]
while ( 1 )
{
v2 = *(_DWORD *)(a1 + 18476) ? 0 : (unsigned __int8)stbi__get8(*(_QWORD *)a1);
if ( v2 == 255 )
{
do
v3 = (unsigned __int8)stbi__get8(*(_QWORD *)a1);
while ( v3 == 255 );
if ( v3 )
break;
}
*(_DWORD *)(a1 + 18464) |= v2 << (24 - *(_BYTE *)(a1 + 18468));
*(_DWORD *)(a1 + 18468) += 8;
result = a1;
if ( *(int *)(a1 + 18468) > 24 )
return result;
}
*(_BYTE *)(a1 + 18472) = v3;
result = a1;
*(_DWORD *)(a1 + 18476) = 1;
return result;
}
| stbi__grow_buffer_unsafe:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
LAB_0017af4c:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x482c],0x0
JZ 0x0017af60
XOR EAX,EAX
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0017af72
LAB_0017af60:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
CALL 0x0016a1b0
MOVZX EAX,AL
MOV dword ptr [RBP + -0x14],EAX
LAB_0017af72:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0xc],EAX
CMP dword ptr [RBP + -0xc],0xff
JNZ 0x0017afd7
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
CALL 0x0016a1b0
MOVZX EAX,AL
MOV dword ptr [RBP + -0x10],EAX
LAB_0017af93:
CMP dword ptr [RBP + -0x10],0xff
JNZ 0x0017afb0
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
CALL 0x0016a1b0
MOVZX EAX,AL
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0017af93
LAB_0017afb0:
CMP dword ptr [RBP + -0x10],0x0
JZ 0x0017afd5
MOV EAX,dword ptr [RBP + -0x10]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x4828],CL
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x482c],0x1
JMP 0x0017b021
LAB_0017afd5:
JMP 0x0017afd7
LAB_0017afd7:
MOV EAX,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x8]
MOV ECX,0x18
SUB ECX,dword ptr [RDX + 0x4824]
SHL EAX,CL
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
OR ECX,dword ptr [RAX + 0x4820]
MOV dword ptr [RAX + 0x4820],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x4824]
ADD ECX,0x8
MOV dword ptr [RAX + 0x4824],ECX
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x4824],0x18
JLE 0x0017af4c
LAB_0017b021:
ADD RSP,0x20
POP RBP
RET
|
void stbi__grow_buffer_unsafe(int8 *param_1)
{
byte bVar1;
char cVar2;
uint local_1c;
do {
if (*(int *)((long)param_1 + 0x482c) == 0) {
bVar1 = stbi__get8(*param_1);
local_1c = (uint)bVar1;
}
else {
local_1c = 0;
}
if (local_1c == 0xff) {
cVar2 = stbi__get8(*param_1);
while (cVar2 == -1) {
cVar2 = stbi__get8(*param_1);
}
if (cVar2 != '\0') {
*(char *)(param_1 + 0x905) = cVar2;
*(int4 *)((long)param_1 + 0x482c) = 1;
return;
}
}
*(uint *)(param_1 + 0x904) =
local_1c << (0x18U - (char)*(int4 *)((long)param_1 + 0x4824) & 0x1f) |
*(uint *)(param_1 + 0x904);
*(int *)((long)param_1 + 0x4824) = *(int *)((long)param_1 + 0x4824) + 8;
if (0x18 < *(int *)((long)param_1 + 0x4824)) {
return;
}
} while( true );
}
| |
54,728 | stbi__grow_buffer_unsafe | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h | static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
{
do {
unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
if (b == 0xff) {
int c = stbi__get8(j->s);
while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
if (c != 0) {
j->marker = (unsigned char) c;
j->nomore = 1;
return;
}
}
j->code_buffer |= b << (24 - j->code_bits);
j->code_bits += 8;
} while (j->code_bits <= 24);
} | O1 | c | stbi__grow_buffer_unsafe:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
cmpl $0x0, 0x482c(%rbx)
jne 0x38a8f
movq (%rbx), %rdi
callq 0x35662
movzbl %al, %ebp
cmpl $0xff, %ebp
jne 0x38aaa
movq (%rbx), %rdi
callq 0x35662
cmpb $-0x1, %al
je 0x38a97
movzbl %al, %ecx
testl %ecx, %ecx
jne 0x38acc
movl 0x4824(%rbx), %eax
movb $0x18, %cl
subb %al, %cl
shll %cl, %ebp
orl %ebp, 0x4820(%rbx)
leal 0x8(%rax), %ecx
movl %ecx, 0x4824(%rbx)
cmpl $0x11, %eax
jl 0x38a79
jmp 0x38adc
movb %al, 0x4828(%rbx)
movl $0x1, 0x482c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| stbi__grow_buffer_unsafe:
push rbp
push rbx
push rax
mov rbx, rdi
loc_38A79:
xor ebp, ebp
cmp dword ptr [rbx+482Ch], 0
jnz short loc_38A8F
mov rdi, [rbx]
call stbi__get8
movzx ebp, al
loc_38A8F:
cmp ebp, 0FFh
jnz short loc_38AAA
loc_38A97:
mov rdi, [rbx]
call stbi__get8
cmp al, 0FFh
jz short loc_38A97
movzx ecx, al
test ecx, ecx
jnz short loc_38ACC
loc_38AAA:
mov eax, [rbx+4824h]
mov cl, 18h
sub cl, al
shl ebp, cl
or [rbx+4820h], ebp
lea ecx, [rax+8]
mov [rbx+4824h], ecx
cmp eax, 11h
jl short loc_38A79
jmp short loc_38ADC
loc_38ACC:
mov [rbx+4828h], al
mov dword ptr [rbx+482Ch], 1
loc_38ADC:
add rsp, 8
pop rbx
pop rbp
retn
| char stbi__grow_buffer_unsafe(long long a1)
{
int v1; // ebp
int v2; // eax
while ( 1 )
{
v1 = 0;
if ( !*(_DWORD *)(a1 + 18476) )
v1 = (unsigned __int8)stbi__get8(*(_QWORD *)a1);
if ( v1 == 255 )
{
do
LOBYTE(v2) = stbi__get8(*(_QWORD *)a1);
while ( (_BYTE)v2 == 0xFF );
if ( (_BYTE)v2 )
break;
}
v2 = *(_DWORD *)(a1 + 18468);
*(_DWORD *)(a1 + 18464) |= v1 << (24 - v2);
*(_DWORD *)(a1 + 18468) = v2 + 8;
if ( v2 >= 17 )
return v2;
}
*(_BYTE *)(a1 + 18472) = v2;
*(_DWORD *)(a1 + 18476) = 1;
return v2;
}
| stbi__grow_buffer_unsafe:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
LAB_00138a79:
XOR EBP,EBP
CMP dword ptr [RBX + 0x482c],0x0
JNZ 0x00138a8f
MOV RDI,qword ptr [RBX]
CALL 0x00135662
MOVZX EBP,AL
LAB_00138a8f:
CMP EBP,0xff
JNZ 0x00138aaa
LAB_00138a97:
MOV RDI,qword ptr [RBX]
CALL 0x00135662
CMP AL,0xff
JZ 0x00138a97
MOVZX ECX,AL
TEST ECX,ECX
JNZ 0x00138acc
LAB_00138aaa:
MOV EAX,dword ptr [RBX + 0x4824]
MOV CL,0x18
SUB CL,AL
SHL EBP,CL
OR dword ptr [RBX + 0x4820],EBP
LEA ECX,[RAX + 0x8]
MOV dword ptr [RBX + 0x4824],ECX
CMP EAX,0x11
JL 0x00138a79
JMP 0x00138adc
LAB_00138acc:
MOV byte ptr [RBX + 0x4828],AL
MOV dword ptr [RBX + 0x482c],0x1
LAB_00138adc:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void stbi__grow_buffer_unsafe(int8 *param_1)
{
int iVar1;
byte bVar2;
char cVar3;
uint uVar4;
do {
uVar4 = 0;
if (*(int *)((long)param_1 + 0x482c) == 0) {
bVar2 = stbi__get8(*param_1);
uVar4 = (uint)bVar2;
}
if (uVar4 == 0xff) {
do {
cVar3 = stbi__get8(*param_1);
} while (cVar3 == -1);
if (cVar3 != '\0') {
*(char *)(param_1 + 0x905) = cVar3;
*(int4 *)((long)param_1 + 0x482c) = 1;
return;
}
}
iVar1 = *(int *)((long)param_1 + 0x4824);
*(uint *)(param_1 + 0x904) = *(uint *)(param_1 + 0x904) | uVar4 << (0x18U - (char)iVar1 & 0x1f);
*(int *)((long)param_1 + 0x4824) = iVar1 + 8;
if (0x10 < iVar1) {
return;
}
} while( true );
}
| |
54,729 | unicode_general_category | bluesky950520[P]quickjs/libunicode.c | int unicode_general_category(CharRange *cr, const char *gc_name)
{
int gc_idx;
uint32_t gc_mask;
gc_idx = unicode_find_name(unicode_gc_name_table, gc_name);
if (gc_idx < 0)
return -2;
if (gc_idx <= UNICODE_GC_Co) {
gc_mask = (uint64_t)1 << gc_idx;
} else {
gc_mask = unicode_gc_mask_table[gc_idx - UNICODE_GC_LC];
}
return unicode_general_category1(cr, gc_mask);
} | O1 | c | unicode_general_category:
pushq %rbx
movq %rdi, %rbx
leaq 0xbdd1(%rip), %rdi # 0xa4d20
callq 0x987bd
testl %eax, %eax
js 0x98f69
cmpl $0x1d, %eax
jg 0x98f70
movl $0x1, %esi
movl %eax, %ecx
shlq %cl, %rsi
jmp 0x98f7d
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
popq %rbx
retq
addl $-0x1e, %eax
leaq 0x128a6(%rip), %rcx # 0xab820
movl (%rcx,%rax,4), %esi
movq %rbx, %rdi
popq %rbx
jmp 0x98f83
| unicode_general_category:
push rbx
mov rbx, rdi
lea rdi, unicode_gc_name_table; "Cn,Unassigned"
call unicode_find_name
test eax, eax
js short loc_98F69
cmp eax, 1Dh
jg short loc_98F70
mov esi, 1
mov ecx, eax
shl rsi, cl
jmp short loc_98F7D
loc_98F69:
mov eax, 0FFFFFFFEh
pop rbx
retn
loc_98F70:
add eax, 0FFFFFFE2h
lea rcx, unicode_gc_mask_table
mov esi, [rcx+rax*4]
loc_98F7D:
mov rdi, rbx
pop rbx
jmp short $+2
| long long unicode_general_category(long long a1, long long a2)
{
int name; // eax
long long v3; // rsi
name = unicode_find_name("Cn,Unassigned", a2);
if ( name < 0 )
return 4294967294LL;
if ( name > 29 )
v3 = unicode_gc_mask_table[name - 30];
else
v3 = 1LL << name;
return unicode_general_category1(a1, v3);
}
| unicode_general_category:
PUSH RBX
MOV RBX,RDI
LEA RDI,[0x1a4d20]
CALL 0x001987bd
TEST EAX,EAX
JS 0x00198f69
CMP EAX,0x1d
JG 0x00198f70
MOV ESI,0x1
MOV ECX,EAX
SHL RSI,CL
JMP 0x00198f7d
LAB_00198f69:
MOV EAX,0xfffffffe
POP RBX
RET
LAB_00198f70:
ADD EAX,-0x1e
LEA RCX,[0x1ab820]
MOV ESI,dword ptr [RCX + RAX*0x4]
LAB_00198f7d:
MOV RDI,RBX
POP RBX
JMP 0x00198f83
|
int8 unicode_general_category(int8 param_1)
{
int iVar1;
int8 uVar2;
ulong uVar3;
iVar1 = unicode_find_name("Cn,Unassigned");
if (-1 < iVar1) {
if (iVar1 < 0x1e) {
uVar3 = 1L << ((byte)iVar1 & 0x3f);
}
else {
uVar3 = (ulong)*(uint *)(unicode_gc_mask_table + (ulong)(iVar1 - 0x1e) * 4);
}
uVar2 = unicode_general_category1(param_1,uVar3);
return uVar2;
}
return 0xfffffffe;
}
| |
54,730 | unicode_general_category | bluesky950520[P]quickjs/libunicode.c | int unicode_general_category(CharRange *cr, const char *gc_name)
{
int gc_idx;
uint32_t gc_mask;
gc_idx = unicode_find_name(unicode_gc_name_table, gc_name);
if (gc_idx < 0)
return -2;
if (gc_idx <= UNICODE_GC_Co) {
gc_mask = (uint64_t)1 << gc_idx;
} else {
gc_mask = unicode_gc_mask_table[gc_idx - UNICODE_GC_LC];
}
return unicode_general_category1(cr, gc_mask);
} | O3 | c | unicode_general_category:
pushq %rbx
movq %rdi, %rbx
leaq 0xc417(%rip), %rdi # 0xa7cd0
callq 0x9b118
testl %eax, %eax
js 0x9b8d3
cmpl $0x1d, %eax
ja 0x9b8da
movl $0x1, %esi
movl %eax, %ecx
shlq %cl, %rsi
jmp 0x9b8e7
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
popq %rbx
retq
addl $-0x1e, %eax
leaq 0x12eec(%rip), %rcx # 0xae7d0
movl (%rcx,%rax,4), %esi
movq %rbx, %rdi
popq %rbx
jmp 0x9b8ed
| unicode_general_category:
push rbx
mov rbx, rdi
lea rdi, unicode_gc_name_table; "Cn,Unassigned"
call unicode_find_name
test eax, eax
js short loc_9B8D3
cmp eax, 1Dh
ja short loc_9B8DA
mov esi, 1
mov ecx, eax
shl rsi, cl
jmp short loc_9B8E7
loc_9B8D3:
mov eax, 0FFFFFFFEh
pop rbx
retn
loc_9B8DA:
add eax, 0FFFFFFE2h
lea rcx, unicode_gc_mask_table
mov esi, [rcx+rax*4]
loc_9B8E7:
mov rdi, rbx
pop rbx
jmp short $+2
| long long unicode_general_category(long long a1, long long a2)
{
int name; // eax
long long v3; // rsi
name = unicode_find_name("Cn,Unassigned", a2);
if ( name < 0 )
return 4294967294LL;
if ( (unsigned int)name > 0x1D )
v3 = unicode_gc_mask_table[name - 30];
else
v3 = 1LL << name;
return unicode_general_category1(a1, v3);
}
| unicode_general_category:
PUSH RBX
MOV RBX,RDI
LEA RDI,[0x1a7cd0]
CALL 0x0019b118
TEST EAX,EAX
JS 0x0019b8d3
CMP EAX,0x1d
JA 0x0019b8da
MOV ESI,0x1
MOV ECX,EAX
SHL RSI,CL
JMP 0x0019b8e7
LAB_0019b8d3:
MOV EAX,0xfffffffe
POP RBX
RET
LAB_0019b8da:
ADD EAX,-0x1e
LEA RCX,[0x1ae7d0]
MOV ESI,dword ptr [RCX + RAX*0x4]
LAB_0019b8e7:
MOV RDI,RBX
POP RBX
JMP 0x0019b8ed
|
int8 unicode_general_category(int8 param_1)
{
uint uVar1;
int8 uVar2;
ulong uVar3;
uVar1 = unicode_find_name("Cn,Unassigned");
if (-1 < (int)uVar1) {
if (uVar1 < 0x1e) {
uVar3 = 1L << ((byte)uVar1 & 0x3f);
}
else {
uVar3 = (ulong)*(uint *)(unicode_gc_mask_table + (ulong)(uVar1 - 0x1e) * 4);
}
uVar2 = unicode_general_category1(param_1,uVar3);
return uVar2;
}
return 0xfffffffe;
}
| |
54,731 | Catch::RunContext::~RunContext() | AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.cpp | RunContext::~RunContext() {
m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
} | O3 | cpp | Catch::RunContext::~RunContext():
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0xcf073(%rip), %rax # 0x12d690
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x110(%rdi), %r14
movq 0xc8(%rdi), %rdi
movq 0xd8(%rbx), %r15
movq (%rdi), %rax
callq *0x48(%rax)
cltq
xorl %ecx, %ecx
cmpq %rax, %r15
setae %cl
leaq 0xd0(%rbx), %rdx
leaq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x58f78
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *0x88(%rax)
leaq 0x1c8(%rbx), %rdi
callq 0x5c81a
movq 0x1b0(%rbx), %rdi
testq %rdi, %rdi
je 0x5e68d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x198(%rbx), %rdi
testq %rdi, %rdi
je 0x5e6a8
movq 0x1a8(%rbx), %rsi
subq %rdi, %rsi
callq 0x17150
leaq 0x180(%rbx), %rdi
callq 0x78630
leaq 0x130(%rbx), %rdi
callq 0x7868e
leaq 0x118(%rbx), %rdi
callq 0x76fec
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0x5e6de
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x87248
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x1f2c3
| _ZN5Catch10RunContextD2Ev:
push r15; Alternative name is 'Catch::RunContext::~RunContext()'
push r14
push rbx
sub rsp, 60h
mov rbx, rdi
lea rax, _ZTVN5Catch10RunContextE; `vtable for'Catch::RunContext
add rax, 10h
mov [rdi], rax
mov r14, [rdi+110h]
mov rdi, [rdi+0C8h]
mov r15, [rbx+0D8h]
mov rax, [rdi]
call qword ptr [rax+48h]
cdqe
xor ecx, ecx
cmp r15, rax
setnb cl
lea rdx, [rbx+0D0h]
lea rsi, [rbx+8]
lea rdi, [rsp+78h+var_70]
call _ZN5Catch12TestRunStatsC2ERKNS_11TestRunInfoERKNS_6TotalsEb; Catch::TestRunStats::TestRunStats(Catch::TestRunInfo const&,Catch::Totals const&,bool)
mov rax, [r14]
lea rsi, [rsp+78h+var_70]
mov rdi, r14
call qword ptr [rax+88h]
lea rdi, [rbx+1C8h]; this
call _ZN5Catch21FatalConditionHandlerD2Ev; Catch::FatalConditionHandler::~FatalConditionHandler()
mov rdi, [rbx+1B0h]
test rdi, rdi
jz short loc_5E68D
mov rax, [rdi]
call qword ptr [rax+8]
loc_5E68D:
mov rdi, [rbx+198h]; void *
test rdi, rdi
jz short loc_5E6A8
mov rsi, [rbx+1A8h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5E6A8:
lea rdi, [rbx+180h]
call _ZNSt6vectorIN5Catch14SectionEndInfoESaIS1_EED2Ev; std::vector<Catch::SectionEndInfo>::~vector()
lea rdi, [rbx+130h]
call _ZNSt6vectorIN5Catch13ScopedMessageESaIS1_EED2Ev; std::vector<Catch::ScopedMessage>::~vector()
lea rdi, [rbx+118h]
call _ZNSt6vectorIN5Catch11MessageInfoESaIS1_EED2Ev; std::vector<Catch::MessageInfo>::~vector()
mov rdi, [rbx+110h]
test rdi, rdi
jz short loc_5E6DE
mov rax, [rdi]
call qword ptr [rax+8]
loc_5E6DE:
add rbx, 30h ; '0'
mov rdi, rbx
call _ZN5Catch8OptionalINS_15AssertionResultEE5resetEv; Catch::Optional<Catch::AssertionResult>::reset(void)
add rsp, 60h
pop rbx
pop r14
pop r15
retn
mov rdi, rax
call __clang_call_terminate
| void Catch::RunContext::~RunContext(Catch::RunContext *this)
{
long long v2; // r14
unsigned long long v3; // r15
int v4; // eax
long long v5; // rdi
void *v6; // rdi
long long v7; // rdi
_BYTE v8[112]; // [rsp+8h] [rbp-70h] BYREF
*(_QWORD *)this = &`vtable for'Catch::RunContext + 2;
v2 = *((_QWORD *)this + 34);
v3 = *((_QWORD *)this + 27);
v4 = (*(long long ( **)(_QWORD))(**((_QWORD **)this + 25) + 72LL))(*((_QWORD *)this + 25));
Catch::TestRunStats::TestRunStats((long long)v8, (Catch::RunContext *)((char *)this + 8), (_OWORD *)this + 13, v3 >= v4);
(*(void ( **)(long long, _BYTE *))(*(_QWORD *)v2 + 136LL))(v2, v8);
Catch::FatalConditionHandler::~FatalConditionHandler((Catch::RunContext *)((char *)this + 456));
v5 = *((_QWORD *)this + 54);
if ( v5 )
(*(void ( **)(long long))(*(_QWORD *)v5 + 8LL))(v5);
v6 = (void *)*((_QWORD *)this + 51);
if ( v6 )
operator delete(v6, *((_QWORD *)this + 53) - (_QWORD)v6);
std::vector<Catch::SectionEndInfo>::~vector((char *)this + 384);
std::vector<Catch::ScopedMessage>::~vector((char *)this + 304);
std::vector<Catch::MessageInfo>::~vector((char *)this + 280);
v7 = *((_QWORD *)this + 34);
if ( v7 )
(*(void ( **)(long long))(*(_QWORD *)v7 + 8LL))(v7);
Catch::Optional<Catch::AssertionResult>::reset((char *)this + 48);
}
| ~RunContext:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV RBX,RDI
LEA RAX,[0x22d690]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV R14,qword ptr [RDI + 0x110]
MOV RDI,qword ptr [RDI + 0xc8]
MOV R15,qword ptr [RBX + 0xd8]
MOV RAX,qword ptr [RDI]
LAB_0015e63c:
CALL qword ptr [RAX + 0x48]
CDQE
XOR ECX,ECX
CMP R15,RAX
SETNC CL
LEA RDX,[RBX + 0xd0]
LEA RSI,[RBX + 0x8]
LEA RDI,[RSP + 0x8]
CALL 0x00158f78
MOV RAX,qword ptr [R14]
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL qword ptr [RAX + 0x88]
LAB_0015e66f:
LEA RDI,[RBX + 0x1c8]
CALL 0x0015c81a
MOV RDI,qword ptr [RBX + 0x1b0]
TEST RDI,RDI
JZ 0x0015e68d
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0015e68d:
MOV RDI,qword ptr [RBX + 0x198]
TEST RDI,RDI
JZ 0x0015e6a8
MOV RSI,qword ptr [RBX + 0x1a8]
SUB RSI,RDI
CALL 0x00117150
LAB_0015e6a8:
LEA RDI,[RBX + 0x180]
CALL 0x00178630
LEA RDI,[RBX + 0x130]
CALL 0x0017868e
LEA RDI,[RBX + 0x118]
CALL 0x00176fec
MOV RDI,qword ptr [RBX + 0x110]
TEST RDI,RDI
JZ 0x0015e6de
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0015e6de:
ADD RBX,0x30
MOV RDI,RBX
CALL 0x00187248
ADD RSP,0x60
POP RBX
POP R14
POP R15
RET
|
/* Catch::RunContext::~RunContext() */
void __thiscall Catch::RunContext::~RunContext(RunContext *this)
{
long *plVar1;
ulong uVar2;
void *pvVar3;
int iVar4;
TestRunStats local_70 [88];
*(int ***)this = &PTR__RunContext_0022d6a0;
plVar1 = *(long **)(this + 0x110);
uVar2 = *(ulong *)(this + 0xd8);
/* try { // try from 0015e63c to 0015e66e has its CatchHandler @ 0015e6f4 */
iVar4 = (**(code **)(**(long **)(this + 200) + 0x48))();
TestRunStats::TestRunStats
(local_70,(TestRunInfo *)(this + 8),(Totals *)(this + 0xd0),(ulong)(long)iVar4 <= uVar2)
;
(**(code **)(*plVar1 + 0x88))(plVar1,local_70);
FatalConditionHandler::~FatalConditionHandler((FatalConditionHandler *)(this + 0x1c8));
if (*(long **)(this + 0x1b0) != (long *)0x0) {
(**(code **)(**(long **)(this + 0x1b0) + 8))();
}
pvVar3 = *(void **)(this + 0x198);
if (pvVar3 != (void *)0x0) {
operator_delete(pvVar3,*(long *)(this + 0x1a8) - (long)pvVar3);
}
std::vector<Catch::SectionEndInfo,std::allocator<Catch::SectionEndInfo>>::~vector
((vector<Catch::SectionEndInfo,std::allocator<Catch::SectionEndInfo>> *)(this + 0x180));
std::vector<Catch::ScopedMessage,std::allocator<Catch::ScopedMessage>>::~vector
((vector<Catch::ScopedMessage,std::allocator<Catch::ScopedMessage>> *)(this + 0x130));
std::vector<Catch::MessageInfo,std::allocator<Catch::MessageInfo>>::~vector
((vector<Catch::MessageInfo,std::allocator<Catch::MessageInfo>> *)(this + 0x118));
if (*(long **)(this + 0x110) != (long *)0x0) {
(**(code **)(**(long **)(this + 0x110) + 8))();
}
Optional<Catch::AssertionResult>::reset((Optional<Catch::AssertionResult> *)(this + 0x30));
return;
}
| |
54,732 | 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;
} | O0 | c | native_password_auth_client:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, 0x48(%rax)
je 0x3f40e
movq -0x38(%rbp), %rax
addq $0x48e, %rax # imm = 0x48E
movq %rax, -0x48(%rbp)
movl $0x15, -0x3c(%rbp)
jmp 0x3f46a
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
jge 0x3f433
movl $0x0, -0x24(%rbp)
jmp 0x3f4fe
cmpl $0x15, -0x3c(%rbp)
je 0x3f445
movl $0x7dc, -0x24(%rbp) # imm = 0x7DC
jmp 0x3f4fe
movq -0x38(%rbp), %rax
addq $0x48e, %rax # imm = 0x48E
movq -0x48(%rbp), %rcx
movups (%rcx), %xmm0
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movups %xmm0, (%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x4a2(%rax)
cmpq $0x0, -0x38(%rbp)
je 0x3f4d3
movq -0x38(%rbp), %rax
movq 0x2c0(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3f4d3
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x15, %edx
callq 0x13250
leaq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x2c0(%rax), %rdx
callq 0x47ed0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x14, %edx
callq *%rax
cmpl $0x0, %eax
je 0x3f4d1
movl $0x0, -0x24(%rbp)
jmp 0x3f4fe
jmp 0x3f4f7
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
xorl %edx, %edx
callq *%rax
cmpl $0x0, %eax
je 0x3f4f5
movl $0x0, -0x24(%rbp)
jmp 0x3f4fe
jmp 0x3f4f7
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3f51f
movl -0x4c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
callq 0x134b0
nopw %cs:(%rax,%rax)
| native_password_auth_client:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_30], rdi
mov [rbp+var_38], rsi
mov rax, [rbp+var_30]
cmp byte ptr [rax+48h], 0
jz short loc_3F40E
mov rax, [rbp+var_38]
add rax, 48Eh
mov [rbp+var_48], rax
mov [rbp+var_3C], 15h
jmp short loc_3F46A
loc_3F40E:
mov rax, [rbp+var_30]
mov rax, [rax]
mov rdi, [rbp+var_30]
lea rsi, [rbp+var_48]
call rax
mov [rbp+var_3C], eax
cmp eax, 0
jge short loc_3F433
mov [rbp+var_24], 0
jmp loc_3F4FE
loc_3F433:
cmp [rbp+var_3C], 15h
jz short loc_3F445
mov [rbp+var_24], 7DCh
jmp loc_3F4FE
loc_3F445:
mov rax, [rbp+var_38]
add rax, 48Eh
mov rcx, [rbp+var_48]
movups xmm0, xmmword ptr [rcx]
mov ecx, [rcx+10h]
mov [rax+10h], ecx
movups xmmword ptr [rax], xmm0
mov rax, [rbp+var_38]
mov byte ptr [rax+4A2h], 0
loc_3F46A:
cmp [rbp+var_38], 0
jz short loc_3F4D3
mov rax, [rbp+var_38]
mov rax, [rax+2C0h]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_3F4D3
lea rdi, [rbp+var_20]
xor esi, esi
mov edx, 15h
call _memset
lea rdi, [rbp+var_20]
mov rsi, [rbp+var_48]
mov rax, [rbp+var_38]
mov rdx, [rax+2C0h]
call ma_scramble_41
mov rax, [rbp+var_30]
mov rax, [rax+8]
mov rdi, [rbp+var_30]
lea rsi, [rbp+var_20]
mov edx, 14h
call rax
cmp eax, 0
jz short loc_3F4D1
mov [rbp+var_24], 0
jmp short loc_3F4FE
loc_3F4D1:
jmp short loc_3F4F7
loc_3F4D3:
mov rax, [rbp+var_30]
mov rax, [rax+8]
mov rdi, [rbp+var_30]
xor ecx, ecx
mov esi, ecx
xor edx, edx
call rax
cmp eax, 0
jz short loc_3F4F5
mov [rbp+var_24], 0
jmp short loc_3F4FE
loc_3F4F5:
jmp short $+2
loc_3F4F7:
mov [rbp+var_24], 0FFFFFFFFh
loc_3F4FE:
mov eax, [rbp+var_24]
mov [rbp+var_4C], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3F51F
mov eax, [rbp+var_4C]
add rsp, 50h
pop rbp
retn
loc_3F51F:
call ___stack_chk_fail
| long long native_password_auth_client(long long a1, long long a2)
{
_OWORD *v2; // rax
__int128 v3; // xmm0
__int128 *v5; // [rsp+8h] [rbp-48h] BYREF
int v6; // [rsp+14h] [rbp-3Ch]
long long v7; // [rsp+18h] [rbp-38h]
long long v8; // [rsp+20h] [rbp-30h]
_BYTE v10[24]; // [rsp+30h] [rbp-20h] BYREF
unsigned long long v11; // [rsp+48h] [rbp-8h]
v11 = __readfsqword(0x28u);
v8 = a1;
v7 = a2;
if ( *(_BYTE *)(a1 + 72) )
{
v5 = (__int128 *)(v7 + 1166);
v6 = 21;
LABEL_8:
if ( v7 && **(_BYTE **)(v7 + 704) )
{
memset(v10, 0LL, 21LL);
ma_scramble_41(v10, v5, *(_QWORD *)(v7 + 704));
if ( (*(unsigned int ( **)(long long, _BYTE *, long long))(v8 + 8))(v8, v10, 20LL) )
return 0;
}
else if ( (*(unsigned int ( **)(long long, _QWORD, _QWORD))(v8 + 8))(v8, 0LL, 0LL) )
{
return 0;
}
return (unsigned int)-1;
}
v6 = (*(long long ( **)(long long, __int128 **))v8)(v8, &v5);
if ( v6 >= 0 )
{
if ( v6 == 21 )
{
v2 = (_OWORD *)(v7 + 1166);
v3 = *v5;
*(_DWORD *)(v7 + 1182) = *((_DWORD *)v5 + 4);
*v2 = v3;
*(_BYTE *)(v7 + 1186) = 0;
goto LABEL_8;
}
return 2012;
}
else
{
return 0;
}
}
| native_password_auth_client:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x30],RDI
MOV qword ptr [RBP + -0x38],RSI
MOV RAX,qword ptr [RBP + -0x30]
CMP byte ptr [RAX + 0x48],0x0
JZ 0x0013f40e
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x48e
MOV qword ptr [RBP + -0x48],RAX
MOV dword ptr [RBP + -0x3c],0x15
JMP 0x0013f46a
LAB_0013f40e:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[RBP + -0x48]
CALL RAX
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JGE 0x0013f433
MOV dword ptr [RBP + -0x24],0x0
JMP 0x0013f4fe
LAB_0013f433:
CMP dword ptr [RBP + -0x3c],0x15
JZ 0x0013f445
MOV dword ptr [RBP + -0x24],0x7dc
JMP 0x0013f4fe
LAB_0013f445:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x48e
MOV RCX,qword ptr [RBP + -0x48]
MOVUPS XMM0,xmmword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x10]
MOV dword ptr [RAX + 0x10],ECX
MOVUPS xmmword ptr [RAX],XMM0
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x4a2],0x0
LAB_0013f46a:
CMP qword ptr [RBP + -0x38],0x0
JZ 0x0013f4d3
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x2c0]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0013f4d3
LEA RDI,[RBP + -0x20]
XOR ESI,ESI
MOV EDX,0x15
CALL 0x00113250
LEA RDI,[RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RAX + 0x2c0]
CALL 0x00147ed0
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[RBP + -0x20]
MOV EDX,0x14
CALL RAX
CMP EAX,0x0
JZ 0x0013f4d1
MOV dword ptr [RBP + -0x24],0x0
JMP 0x0013f4fe
LAB_0013f4d1:
JMP 0x0013f4f7
LAB_0013f4d3:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x30]
XOR ECX,ECX
MOV ESI,ECX
XOR EDX,EDX
CALL RAX
CMP EAX,0x0
JZ 0x0013f4f5
MOV dword ptr [RBP + -0x24],0x0
JMP 0x0013f4fe
LAB_0013f4f5:
JMP 0x0013f4f7
LAB_0013f4f7:
MOV dword ptr [RBP + -0x24],0xffffffff
LAB_0013f4fe:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013f51f
MOV EAX,dword ptr [RBP + -0x4c]
ADD RSP,0x50
POP RBP
RET
LAB_0013f51f:
CALL 0x001134b0
|
int4 native_password_auth_client(int8 *param_1,long param_2)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int iVar5;
long in_FS_OFFSET;
int4 *local_50;
int4 local_2c;
int1 local_28 [24];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (*(char *)(param_1 + 9) == '\0') {
iVar5 = (*(code *)*param_1)(param_1);
if (iVar5 < 0) {
local_2c = 0;
goto LAB_0013f4fe;
}
if (iVar5 != 0x15) {
local_2c = 0x7dc;
goto LAB_0013f4fe;
}
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;
}
else {
local_50 = (int4 *)(param_2 + 0x48e);
}
if ((param_2 == 0) || (**(char **)(param_2 + 0x2c0) == '\0')) {
iVar5 = (*(code *)param_1[1])(param_1,0,0);
if (iVar5 != 0) {
local_2c = 0;
goto LAB_0013f4fe;
}
}
else {
memset(local_28,0,0x15);
ma_scramble_41(local_28,local_50,*(int8 *)(param_2 + 0x2c0));
iVar5 = (*(code *)param_1[1])(param_1,local_28,0x14);
if (iVar5 != 0) {
local_2c = 0;
goto LAB_0013f4fe;
}
}
local_2c = 0xffffffff;
LAB_0013f4fe:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_2c;
}
| |
54,733 | fill_uint16 | eloqsql/strings/ctype.c | static int fill_uint16(uint16 *a,uint size,const char *str, size_t len)
{
uint i= 0;
const char *s, *b, *e=str+len;
for (s=str ; s < e ; i++)
{
for ( ; (s < e) && strchr(" \t\r\n",s[0]); s++) ;
b=s;
for ( ; (s < e) && !strchr(" \t\r\n",s[0]); s++) ;
if (s == b || i > size)
break;
a[i]= (uint16) strtol(b,NULL,16);
}
return 0;
} | O0 | c | fill_uint16:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xccee8
jmp 0xcce12
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x41(%rbp)
jae 0xcce3e
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
leaq 0x105d8(%rip), %rdi # 0xdd407
callq 0x28110
cmpq $0x0, %rax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xcce47
jmp 0xcce57
jmp 0xcce49
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xcce12
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x42(%rbp)
jae 0xcce8d
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
leaq 0x1058b(%rip), %rdi # 0xdd407
callq 0x28110
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0xcce96
jmp 0xccea6
jmp 0xcce98
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xcce5f
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0xcceb8
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jbe 0xcceba
jmp 0xccee8
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x28690
movw %ax, %dx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xcce02
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
| fill_uint16:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_24], 0
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
loc_CCE02:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_40]
jnb loc_CCEE8
jmp short $+2
loc_CCE12:
mov rcx, [rbp+var_30]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_41], al
jnb short loc_CCE3E
mov rax, [rbp+var_30]
movsx esi, byte ptr [rax]
lea rdi, asc_DD407; " \t\r\n"
call _strchr
cmp rax, 0
setnz al
mov [rbp+var_41], al
loc_CCE3E:
mov al, [rbp+var_41]
test al, 1
jnz short loc_CCE47
jmp short loc_CCE57
loc_CCE47:
jmp short $+2
loc_CCE49:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_CCE12
loc_CCE57:
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
loc_CCE5F:
mov rcx, [rbp+var_30]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_42], al
jnb short loc_CCE8D
mov rax, [rbp+var_30]
movsx esi, byte ptr [rax]
lea rdi, asc_DD407; " \t\r\n"
call _strchr
cmp rax, 0
setnz al
xor al, 0FFh
mov [rbp+var_42], al
loc_CCE8D:
mov al, [rbp+var_42]
test al, 1
jnz short loc_CCE96
jmp short loc_CCEA6
loc_CCE96:
jmp short $+2
loc_CCE98:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_CCE5F
loc_CCEA6:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jz short loc_CCEB8
mov eax, [rbp+var_24]
cmp eax, [rbp+var_C]
jbe short loc_CCEBA
loc_CCEB8:
jmp short loc_CCEE8
loc_CCEBA:
mov rdi, [rbp+var_38]
xor eax, eax
mov esi, eax
mov edx, 10h
call ___isoc23_strtol
mov dx, ax
mov rax, [rbp+var_8]
mov ecx, [rbp+var_24]
mov [rax+rcx*2], dx
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp loc_CCE02
loc_CCEE8:
xor eax, eax
add rsp, 50h
pop rbp
retn
| long long fill_uint16(long long a1, unsigned int a2, char *a3, long long a4)
{
char v5; // [rsp+Eh] [rbp-42h]
bool v6; // [rsp+Fh] [rbp-41h]
unsigned long long v7; // [rsp+10h] [rbp-40h]
char *v8; // [rsp+18h] [rbp-38h]
char *v9; // [rsp+20h] [rbp-30h]
unsigned int v10; // [rsp+2Ch] [rbp-24h]
v10 = 0;
v7 = (unsigned long long)&a3[a4];
v9 = a3;
while ( (unsigned long long)v9 < v7 )
{
while ( 1 )
{
v6 = 0;
if ( (unsigned long long)v9 < v7 )
v6 = strchr(" \t\r\n", (unsigned int)*v9) != 0;
if ( !v6 )
break;
++v9;
}
v8 = v9;
while ( 1 )
{
v5 = 0;
if ( (unsigned long long)v9 < v7 )
v5 = ~(strchr(" \t\r\n", (unsigned int)*v9) != 0);
if ( (v5 & 1) == 0 )
break;
++v9;
}
if ( v9 == v8 || v10 > a2 )
break;
*(_WORD *)(a1 + 2LL * v10++) = __isoc23_strtol(v8, 0LL, 16LL);
}
return 0LL;
}
| fill_uint16:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
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 dword ptr [RBP + -0x24],0x0
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
LAB_001cce02:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001ccee8
JMP 0x001cce12
LAB_001cce12:
MOV RCX,qword ptr [RBP + -0x30]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x41],AL
JNC 0x001cce3e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX ESI,byte ptr [RAX]
LEA RDI,[0x1dd407]
CALL 0x00128110
CMP RAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_001cce3e:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x001cce47
JMP 0x001cce57
LAB_001cce47:
JMP 0x001cce49
LAB_001cce49:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001cce12
LAB_001cce57:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
LAB_001cce5f:
MOV RCX,qword ptr [RBP + -0x30]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x42],AL
JNC 0x001cce8d
MOV RAX,qword ptr [RBP + -0x30]
MOVSX ESI,byte ptr [RAX]
LEA RDI,[0x1dd407]
CALL 0x00128110
CMP RAX,0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x42],AL
LAB_001cce8d:
MOV AL,byte ptr [RBP + -0x42]
TEST AL,0x1
JNZ 0x001cce96
JMP 0x001ccea6
LAB_001cce96:
JMP 0x001cce98
LAB_001cce98:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001cce5f
LAB_001ccea6:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x001cceb8
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0xc]
JBE 0x001cceba
LAB_001cceb8:
JMP 0x001ccee8
LAB_001cceba:
MOV RDI,qword ptr [RBP + -0x38]
XOR EAX,EAX
MOV ESI,EAX
MOV EDX,0x10
CALL 0x00128690
MOV DX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x24]
MOV word ptr [RAX + RCX*0x2],DX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001cce02
LAB_001ccee8:
XOR EAX,EAX
ADD RSP,0x50
POP RBP
RET
|
int8 fill_uint16(long param_1,uint param_2,char *param_3,long param_4)
{
char *pcVar1;
int2 uVar2;
char *pcVar3;
char *pcVar4;
bool bVar5;
char *local_38;
uint local_2c;
local_2c = 0;
pcVar3 = param_3 + param_4;
local_38 = param_3;
while( true ) {
if (pcVar3 <= local_38) {
return 0;
}
while( true ) {
pcVar1 = local_38;
bVar5 = false;
if (local_38 < pcVar3) {
pcVar4 = strchr(" \t\r\n",(int)*local_38);
bVar5 = pcVar4 != (char *)0x0;
}
if (!bVar5) break;
local_38 = local_38 + 1;
}
while( true ) {
bVar5 = false;
if (local_38 < pcVar3) {
pcVar4 = strchr(" \t\r\n",(int)*local_38);
bVar5 = pcVar4 == (char *)0x0;
}
if (!bVar5) break;
local_38 = local_38 + 1;
}
if (local_38 == pcVar1) break;
if (param_2 < local_2c) {
return 0;
}
uVar2 = __isoc23_strtol(pcVar1,0,0x10);
*(int2 *)(param_1 + (ulong)local_2c * 2) = uVar2;
local_2c = local_2c + 1;
}
return 0;
}
| |
54,734 | ftparser_alloc_param | eloqsql/storage/myisam/ft_parser.c | MYSQL_FTPARSER_PARAM* ftparser_alloc_param(MI_INFO *info)
{
if (!info->ftparser_param)
{
/*
. info->ftparser_param can not be zero after the initialization,
because it always includes built-in fulltext parser. And built-in
parser can be called even if the table has no fulltext indexes and
no varchar/text fields.
ftb_find_relevance... parser (ftb_find_relevance_parse,
ftb_find_relevance_add_word) calls ftb_check_phrase... parser
(ftb_check_phrase_internal, ftb_phrase_add_word). Thus MAX_PARAM_NR=2.
*/
info->ftparser_param= (MYSQL_FTPARSER_PARAM *)
my_malloc(mi_key_memory_FTPARSER_PARAM,
MAX_PARAM_NR * sizeof(MYSQL_FTPARSER_PARAM) * info->s->ftkeys,
MYF(MY_WME | MY_ZEROFILL));
init_alloc_root(mi_key_memory_ft_memroot, &info->ft_memroot,
FTPARSER_MEMROOT_ALLOC_SIZE, 0, MYF(0));
}
return info->ftparser_param;
} | O3 | c | ftparser_alloc_param:
movq 0xd0(%rdi), %rax
testq %rax, %rax
je 0x7a190
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb8fb14(%rip), %rax # 0xc09cb4
movl (%rax), %edi
movq (%rbx), %rax
movl 0x34c(%rax), %esi
shlq $0x7, %rsi
movl $0x30, %edx
callq 0xa5de1
movq %rax, 0xd0(%rbx)
leaq 0xb8faf1(%rip), %rax # 0xc09cb8
movl (%rax), %edi
leaq 0x90(%rbx), %rsi
movl $0x10000, %edx # imm = 0x10000
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xa2b74
movq 0xd0(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| ftparser_alloc_param:
mov rax, [rdi+0D0h]
test rax, rax
jz short loc_7A190
retn
loc_7A190:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
lea rax, mi_key_memory_FTPARSER_PARAM
mov edi, [rax]
mov rax, [rbx]
mov esi, [rax+34Ch]
shl rsi, 7
mov edx, 30h ; '0'
call my_malloc
mov [rbx+0D0h], rax
lea rax, mi_key_memory_ft_memroot
mov edi, [rax]
lea rsi, [rbx+90h]
mov edx, 10000h
xor ecx, ecx
xor r8d, r8d
call init_alloc_root
mov rax, [rbx+0D0h]
add rsp, 8
pop rbx
pop rbp
retn
| long long ftparser_alloc_param(_QWORD *a1)
{
long long result; // rax
result = a1[26];
if ( !result )
{
a1[26] = my_malloc(mi_key_memory_FTPARSER_PARAM, (unsigned long long)*(unsigned int *)(*a1 + 844LL) << 7, 48LL);
init_alloc_root(mi_key_memory_ft_memroot, a1 + 18, 0x10000LL, 0LL, 0LL);
return a1[26];
}
return result;
}
| ftparser_alloc_param:
MOV RAX,qword ptr [RDI + 0xd0]
TEST RAX,RAX
JZ 0x0017a190
RET
LAB_0017a190:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0xd09cb4]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBX]
MOV ESI,dword ptr [RAX + 0x34c]
SHL RSI,0x7
MOV EDX,0x30
CALL 0x001a5de1
MOV qword ptr [RBX + 0xd0],RAX
LEA RAX,[0xd09cb8]
MOV EDI,dword ptr [RAX]
LEA RSI,[RBX + 0x90]
MOV EDX,0x10000
XOR ECX,ECX
XOR R8D,R8D
CALL 0x001a2b74
MOV RAX,qword ptr [RBX + 0xd0]
ADD RSP,0x8
POP RBX
POP RBP
RET
|
long ftparser_alloc_param(long *param_1)
{
long lVar1;
int8 in_R9;
long lVar2;
lVar2 = param_1[0x1a];
if (lVar2 != 0) {
return lVar2;
}
lVar1 = my_malloc(mi_key_memory_FTPARSER_PARAM,(ulong)*(uint *)(*param_1 + 0x34c) << 7,0x30);
param_1[0x1a] = lVar1;
init_alloc_root(mi_key_memory_ft_memroot,param_1 + 0x12,0x10000,0,0,in_R9,lVar2);
return param_1[0x1a];
}
| |
54,735 | cleanup_dirname | eloqsql/mysys/mf_pack.c | size_t cleanup_dirname(register char *to, const char *from)
{
reg5 size_t length;
reg2 char * pos;
reg3 char * from_ptr;
reg4 char * start;
char parent[5], /* for "FN_PARENTDIR" */
buff[FN_REFLEN + 1],*end_parentdir;
#ifdef BACKSLASH_MBTAIL
CHARSET_INFO *fs= fs_character_set();
#endif
DBUG_ENTER("cleanup_dirname");
DBUG_PRINT("enter",("from: '%s'",from));
start=buff;
from_ptr=(char *) from;
#ifdef FN_DEVCHAR
if ((pos=strrchr(from_ptr,FN_DEVCHAR)) != 0)
{ /* Skip device part */
length=(size_t) (pos-from_ptr)+1;
start=strnmov(buff,from_ptr,length); from_ptr+=length;
}
#endif
parent[0]=FN_LIBCHAR;
length=(size_t) (strmov(parent+1,FN_PARENTDIR)-parent);
for (pos=start ; (*pos= *from_ptr++) != 0 ; pos++)
{
#ifdef BACKSLASH_MBTAIL
uint l;
if (my_ci_use_mb(fs) && (l= my_ismbchar(fs, from_ptr - 1, from_ptr + 2)))
{
for (l-- ; l ; *++pos= *from_ptr++, l--);
start= pos + 1; /* Don't look inside multi-byte char */
continue;
}
#endif
if (*pos == '/')
*pos = FN_LIBCHAR;
if (*pos == FN_LIBCHAR)
{
if ((size_t) (pos-start) > length && memcmp(pos-length,parent,length) == 0)
{ /* If .../../; skip prev */
pos-=length;
if (pos != start)
{ /* not /../ */
pos--;
if (*pos == FN_HOMELIB && (pos == start || pos[-1] == FN_LIBCHAR))
{
if (!home_dir)
{
pos+=length+1; /* Don't unpack ~/.. */
continue;
}
pos=strmov(buff,home_dir)-1; /* Unpacks ~/.. */
if (*pos == FN_LIBCHAR)
pos--; /* home ended with '/' */
}
if (*pos == FN_CURLIB && (pos == start || pos[-1] == FN_LIBCHAR))
{
if (my_getwd(curr_dir,FN_REFLEN,MYF(0)))
{
pos+=length+1; /* Don't unpack ./.. */
continue;
}
pos=strmov(buff,curr_dir)-1; /* Unpacks ./.. */
if (*pos == FN_LIBCHAR)
pos--; /* home ended with '/' */
}
end_parentdir=pos;
while (pos >= start && *pos != FN_LIBCHAR) /* remove prev dir */
pos--;
if (pos[1] == FN_HOMELIB ||
(pos >= start && memcmp(pos, parent, length) == 0))
{ /* Don't remove ~user/ */
pos=strmov(end_parentdir+1,parent);
*pos=FN_LIBCHAR;
continue;
}
}
}
else if ((size_t) (pos-start) == length-1 &&
!memcmp(start,parent+1,length-1))
start=pos; /* Starts with "../" */
else if (pos-start > 0 && pos[-1] == FN_LIBCHAR)
{
#ifdef FN_NETWORK_DRIVES
if (pos-start != 1)
#endif
pos--; /* Remove dupplicate '/' */
}
else if (pos-start > 1 && pos[-1] == FN_CURLIB && pos[-2] == FN_LIBCHAR)
pos-=2; /* Skip /./ */
}
}
(void) strmov(to,buff);
DBUG_PRINT("exit",("to: '%s'",to));
DBUG_RETURN((size_t) (pos-buff));
} | O3 | c | cleanup_dirname:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %r14
movq %rdi, -0x248(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0x35(%rbp), %r15
movb $0x2f, (%r15)
movw $0x2e2e, 0x1(%r15) # imm = 0x2E2E
movb $0x0, 0x3(%r15)
leaq -0x240(%rbp), %r12
movq %r12, %r13
movzbl (%r14), %eax
movb %al, (%r12)
cmpl $0x2f, %eax
je 0x2acc2
testl %eax, %eax
jne 0x2ae7a
jmp 0x2ae85
movb $0x2f, (%r12)
movq %r12, %rax
subq %r13, %rax
cmpq $0x4, %rax
jb 0x2ad99
movzwl -0x3(%r12), %ecx
xorw -0x35(%rbp), %cx
movb -0x1(%r12), %dl
xorb -0x33(%rbp), %dl
movzbl %dl, %edx
orw %cx, %dx
jne 0x2adb6
leaq -0x3(%r12), %rax
cmpq %r13, %rax
je 0x2adfd
leaq -0x4(%r12), %rbx
movb -0x4(%r12), %al
cmpb $0x7e, %al
jne 0x2ad5c
cmpq %r13, %rbx
je 0x2ad22
cmpb $0x2f, -0x5(%r12)
jne 0x2ae21
leaq 0x33af4f(%rip), %rax # 0x365c78
movq (%rax), %rsi
testq %rsi, %rsi
je 0x2ae7a
leaq -0x240(%rbp), %rdi
callq 0x242e0
leaq -0x1(%rax), %rbx
leaq -0x2(%rax), %rcx
xorl %edx, %edx
cmpb $0x2f, -0x1(%rax)
sete %dl
notq %rdx
cmoveq %rcx, %rbx
movb (%rax,%rdx), %al
cmpb $0x2e, %al
jne 0x2ae21
cmpq %r13, %rbx
leaq 0x33af22(%rip), %r12 # 0x365c90
je 0x2ad7a
cmpb $0x2f, -0x1(%rbx)
jne 0x2ae21
movl $0x200, %esi # imm = 0x200
movq %r12, %rdi
xorl %edx, %edx
callq 0x2b1a8
testl %eax, %eax
je 0x2ae02
addq $0x4, %rbx
movq %rbx, %r12
jmp 0x2ae7a
cmpq $0x2, %rax
jne 0x2adb6
movzwl (%r13), %eax
cmpw -0x34(%rbp), %ax
je 0x2adf8
movb -0x1(%r12), %cl
cmpb $0x2f, %cl
je 0x2adc9
jmp 0x2addb
testq %rax, %rax
jle 0x2ae7a
movb -0x1(%r12), %cl
cmpb $0x2f, %cl
jne 0x2add1
decq %r12
jmp 0x2ae7a
cmpq $0x1, %rax
je 0x2ae7a
cmpb $0x2e, %cl
jne 0x2ae7a
leaq -0x2(%r12), %rax
cmpb $0x2f, -0x2(%r12)
cmoveq %rax, %r12
jmp 0x2ae7a
movq %r12, %r13
jmp 0x2ae7a
movq %rax, %r12
jmp 0x2ae7a
leaq -0x240(%rbp), %rdi
movq %r12, %rsi
callq 0x242e0
leaq -0x1(%rax), %rbx
leaq -0x2(%rax), %rcx
cmpb $0x2f, -0x1(%rax)
cmoveq %rcx, %rbx
movq %rbx, %r12
cmpq %r13, %rbx
jb 0x2ae3b
movq %rbx, %r12
cmpb $0x2f, (%r12)
je 0x2ae45
decq %r12
cmpq %r13, %r12
jae 0x2ae2c
cmpb $0x7e, 0x1(%r12)
je 0x2ae66
jmp 0x2ae7a
cmpb $0x7e, 0x1(%r12)
je 0x2ae66
movzwl (%r12), %eax
xorw -0x35(%rbp), %ax
movb 0x2(%r12), %cl
xorb -0x33(%rbp), %cl
movzbl %cl, %ecx
orw %ax, %cx
jne 0x2ae7a
incq %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x242e0
movq %rax, %r12
movb $0x2f, (%rax)
incq %r14
incq %r12
jmp 0x2aca8
leaq -0x240(%rbp), %rbx
movq -0x248(%rbp), %rdi
movq %rbx, %rsi
callq 0x24290
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x2aec2
subq %rbx, %r12
movq %r12, %rax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24320
| cleanup_dirname:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 228h
mov r14, rsi
mov [rbp+var_248], rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r15, [rbp+var_35]
mov byte ptr [r15], 2Fh ; '/'
mov word ptr [r15+1], 2E2Eh
mov byte ptr [r15+3], 0
lea r12, [rbp+var_240]
mov r13, r12
loc_2ACA8:
movzx eax, byte ptr [r14]
mov [r12], al
cmp eax, 2Fh ; '/'
jz short loc_2ACC2
test eax, eax
jnz loc_2AE7A
jmp loc_2AE85
loc_2ACC2:
mov byte ptr [r12], 2Fh ; '/'
mov rax, r12
sub rax, r13
cmp rax, 4
jb loc_2AD99
movzx ecx, word ptr [r12-3]
xor cx, [rbp+var_35]
mov dl, [r12-1]
xor dl, [rbp+var_33]
movzx edx, dl
or dx, cx
jnz loc_2ADB6
lea rax, [r12-3]
cmp rax, r13
jz loc_2ADFD
lea rbx, [r12-4]
mov al, [r12-4]
cmp al, 7Eh ; '~'
jnz short loc_2AD5C
cmp rbx, r13
jz short loc_2AD22
cmp byte ptr [r12-5], 2Fh ; '/'
jnz loc_2AE21
loc_2AD22:
lea rax, home_dir
mov rsi, [rax]
test rsi, rsi
jz loc_2AE7A
lea rdi, [rbp+var_240]
call _stpcpy
lea rbx, [rax-1]
lea rcx, [rax-2]
xor edx, edx
cmp byte ptr [rax-1], 2Fh ; '/'
setz dl
not rdx
cmovz rbx, rcx
mov al, [rax+rdx]
loc_2AD5C:
cmp al, 2Eh ; '.'
jnz loc_2AE21
cmp rbx, r13
lea r12, curr_dir
jz short loc_2AD7A
cmp byte ptr [rbx-1], 2Fh ; '/'
jnz loc_2AE21
loc_2AD7A:
mov esi, 200h
mov rdi, r12
xor edx, edx
call my_getwd
test eax, eax
jz short loc_2AE02
add rbx, 4
mov r12, rbx
jmp loc_2AE7A
loc_2AD99:
cmp rax, 2
jnz short loc_2ADB6
movzx eax, word ptr [r13+0]
cmp ax, [rbp+var_35+1]
jz short loc_2ADF8
mov cl, [r12-1]
cmp cl, 2Fh ; '/'
jz short loc_2ADC9
jmp short loc_2ADDB
loc_2ADB6:
test rax, rax
jle loc_2AE7A
mov cl, [r12-1]
cmp cl, 2Fh ; '/'
jnz short loc_2ADD1
loc_2ADC9:
dec r12
jmp loc_2AE7A
loc_2ADD1:
cmp rax, 1
jz loc_2AE7A
loc_2ADDB:
cmp cl, 2Eh ; '.'
jnz loc_2AE7A
lea rax, [r12-2]
cmp byte ptr [r12-2], 2Fh ; '/'
cmovz r12, rax
jmp loc_2AE7A
loc_2ADF8:
mov r13, r12
jmp short loc_2AE7A
loc_2ADFD:
mov r12, rax
jmp short loc_2AE7A
loc_2AE02:
lea rdi, [rbp+var_240]
mov rsi, r12
call _stpcpy
lea rbx, [rax-1]
lea rcx, [rax-2]
cmp byte ptr [rax-1], 2Fh ; '/'
cmovz rbx, rcx
loc_2AE21:
mov r12, rbx
cmp rbx, r13
jb short loc_2AE3B
mov r12, rbx
loc_2AE2C:
cmp byte ptr [r12], 2Fh ; '/'
jz short loc_2AE45
dec r12
cmp r12, r13
jnb short loc_2AE2C
loc_2AE3B:
cmp byte ptr [r12+1], 7Eh ; '~'
jz short loc_2AE66
jmp short loc_2AE7A
loc_2AE45:
cmp byte ptr [r12+1], 7Eh ; '~'
jz short loc_2AE66
movzx eax, word ptr [r12]
xor ax, [rbp+var_35]
mov cl, [r12+2]
xor cl, [rbp+var_33]
movzx ecx, cl
or cx, ax
jnz short loc_2AE7A
loc_2AE66:
inc rbx
mov rdi, rbx
mov rsi, r15
call _stpcpy
mov r12, rax
mov byte ptr [rax], 2Fh ; '/'
loc_2AE7A:
inc r14
inc r12
jmp loc_2ACA8
loc_2AE85:
lea rbx, [rbp+var_240]
mov rdi, [rbp+var_248]
mov rsi, rbx
call _strcpy
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_2AEC2
sub r12, rbx
mov rax, r12
add rsp, 228h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2AEC2:
call ___stack_chk_fail
| long long cleanup_dirname(long long a1, unsigned __int8 *a2)
{
_BYTE *v3; // r12
_WORD *v4; // r13
int v5; // eax
long long v6; // rax
_BYTE *v7; // rbx
char v8; // al
long long v9; // rax
char v10; // cl
long long v11; // rax
long long v13; // [rsp+8h] [rbp-248h]
_BYTE v14[523]; // [rsp+10h] [rbp-240h] BYREF
char v15[5]; // [rsp+21Bh] [rbp-35h] BYREF
unsigned long long v16; // [rsp+220h] [rbp-30h]
v13 = a1;
v16 = __readfsqword(0x28u);
strcpy(v15, "/..");
v3 = v14;
v4 = v14;
while ( 1 )
{
v5 = *a2;
*v3 = v5;
if ( v5 != 47 )
break;
*v3 = 47;
v6 = v3 - (_BYTE *)v4;
if ( (unsigned long long)(v3 - (_BYTE *)v4) < 4 )
{
if ( v6 == 2 )
{
if ( *v4 == *(_WORD *)&v15[1] )
{
v4 = v3;
goto LABEL_45;
}
v10 = *(v3 - 1);
if ( v10 == 47 )
goto LABEL_26;
LABEL_28:
if ( v10 == 46 && *(v3 - 2) == 47 )
v3 -= 2;
goto LABEL_45;
}
}
else if ( !((unsigned __int16)(*(_WORD *)v15 ^ *(_WORD *)(v3 - 3)) | (unsigned __int8)(v15[2] ^ *(v3 - 1))) )
{
if ( v3 - 3 == (_BYTE *)v4 )
{
v3 -= 3;
goto LABEL_45;
}
v7 = v3 - 4;
v8 = *(v3 - 4);
if ( v8 == 126 )
{
if ( v7 == (_BYTE *)v4 || *(v3 - 5) == 47 )
{
if ( !home_dir )
goto LABEL_45;
v9 = stpcpy(v14);
v7 = (_BYTE *)(v9 - 1);
if ( *(_BYTE *)(v9 - 1) == 47 )
v7 = (_BYTE *)(v9 - 2);
v8 = *(_BYTE *)(v9 + ~(unsigned long long)(*(_BYTE *)(v9 - 1) == 47));
goto LABEL_15;
}
}
else
{
LABEL_15:
if ( v8 == 46 && (v7 == (_BYTE *)v4 || *(v7 - 1) == 47) )
{
if ( (unsigned int)my_getwd(&curr_dir, 512LL, 0LL) )
{
v3 = v7 + 4;
goto LABEL_45;
}
v11 = stpcpy(v14);
v7 = (_BYTE *)(v11 - 1);
if ( *(_BYTE *)(v11 - 1) == 47 )
v7 = (_BYTE *)(v11 - 2);
}
}
v3 = v7;
if ( v7 < (_BYTE *)v4 )
{
LABEL_40:
if ( v3[1] == 126 )
goto LABEL_44;
}
else
{
v3 = v7;
while ( *v3 != 47 )
{
if ( --v3 < (_BYTE *)v4 )
goto LABEL_40;
}
if ( v3[1] == 126 || !((unsigned __int16)(*(_WORD *)v15 ^ *(_WORD *)v3) | (unsigned __int8)(v15[2] ^ v3[2])) )
{
LABEL_44:
v3 = (_BYTE *)stpcpy(v7 + 1);
*v3 = 47;
goto LABEL_45;
}
}
goto LABEL_45;
}
if ( v6 <= 0 )
goto LABEL_45;
v10 = *(v3 - 1);
if ( v10 == 47 )
{
LABEL_26:
--v3;
goto LABEL_45;
}
if ( v6 != 1 )
goto LABEL_28;
LABEL_45:
++a2;
++v3;
}
if ( v5 )
goto LABEL_45;
strcpy(v13, v14);
return v3 - v14;
}
| cleanup_dirname:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x228
MOV R14,RSI
MOV qword ptr [RBP + -0x248],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R15,[RBP + -0x35]
MOV byte ptr [R15],0x2f
MOV word ptr [R15 + 0x1],0x2e2e
MOV byte ptr [R15 + 0x3],0x0
LEA R12,[RBP + -0x240]
MOV R13,R12
LAB_0012aca8:
MOVZX EAX,byte ptr [R14]
MOV byte ptr [R12],AL
CMP EAX,0x2f
JZ 0x0012acc2
TEST EAX,EAX
JNZ 0x0012ae7a
JMP 0x0012ae85
LAB_0012acc2:
MOV byte ptr [R12],0x2f
MOV RAX,R12
SUB RAX,R13
CMP RAX,0x4
JC 0x0012ad99
MOVZX ECX,word ptr [R12 + -0x3]
XOR CX,word ptr [RBP + -0x35]
MOV DL,byte ptr [R12 + -0x1]
XOR DL,byte ptr [RBP + -0x33]
MOVZX EDX,DL
OR DX,CX
JNZ 0x0012adb6
LEA RAX,[R12 + -0x3]
CMP RAX,R13
JZ 0x0012adfd
LEA RBX,[R12 + -0x4]
MOV AL,byte ptr [R12 + -0x4]
CMP AL,0x7e
JNZ 0x0012ad5c
CMP RBX,R13
JZ 0x0012ad22
CMP byte ptr [R12 + -0x5],0x2f
JNZ 0x0012ae21
LAB_0012ad22:
LEA RAX,[0x465c78]
MOV RSI,qword ptr [RAX]
TEST RSI,RSI
JZ 0x0012ae7a
LEA RDI,[RBP + -0x240]
CALL 0x001242e0
LEA RBX,[RAX + -0x1]
LEA RCX,[RAX + -0x2]
XOR EDX,EDX
CMP byte ptr [RAX + -0x1],0x2f
SETZ DL
NOT RDX
CMOVZ RBX,RCX
MOV AL,byte ptr [RAX + RDX*0x1]
LAB_0012ad5c:
CMP AL,0x2e
JNZ 0x0012ae21
CMP RBX,R13
LEA R12,[0x465c90]
JZ 0x0012ad7a
CMP byte ptr [RBX + -0x1],0x2f
JNZ 0x0012ae21
LAB_0012ad7a:
MOV ESI,0x200
MOV RDI,R12
XOR EDX,EDX
CALL 0x0012b1a8
TEST EAX,EAX
JZ 0x0012ae02
ADD RBX,0x4
MOV R12,RBX
JMP 0x0012ae7a
LAB_0012ad99:
CMP RAX,0x2
JNZ 0x0012adb6
MOVZX EAX,word ptr [R13]
CMP AX,word ptr [RBP + -0x34]
JZ 0x0012adf8
MOV CL,byte ptr [R12 + -0x1]
CMP CL,0x2f
JZ 0x0012adc9
JMP 0x0012addb
LAB_0012adb6:
TEST RAX,RAX
JLE 0x0012ae7a
MOV CL,byte ptr [R12 + -0x1]
CMP CL,0x2f
JNZ 0x0012add1
LAB_0012adc9:
DEC R12
JMP 0x0012ae7a
LAB_0012add1:
CMP RAX,0x1
JZ 0x0012ae7a
LAB_0012addb:
CMP CL,0x2e
JNZ 0x0012ae7a
LEA RAX,[R12 + -0x2]
CMP byte ptr [R12 + -0x2],0x2f
CMOVZ R12,RAX
JMP 0x0012ae7a
LAB_0012adf8:
MOV R13,R12
JMP 0x0012ae7a
LAB_0012adfd:
MOV R12,RAX
JMP 0x0012ae7a
LAB_0012ae02:
LEA RDI,[RBP + -0x240]
MOV RSI,R12
CALL 0x001242e0
LEA RBX,[RAX + -0x1]
LEA RCX,[RAX + -0x2]
CMP byte ptr [RAX + -0x1],0x2f
CMOVZ RBX,RCX
LAB_0012ae21:
MOV R12,RBX
CMP RBX,R13
JC 0x0012ae3b
MOV R12,RBX
LAB_0012ae2c:
CMP byte ptr [R12],0x2f
JZ 0x0012ae45
DEC R12
CMP R12,R13
JNC 0x0012ae2c
LAB_0012ae3b:
CMP byte ptr [R12 + 0x1],0x7e
JZ 0x0012ae66
JMP 0x0012ae7a
LAB_0012ae45:
CMP byte ptr [R12 + 0x1],0x7e
JZ 0x0012ae66
MOVZX EAX,word ptr [R12]
XOR AX,word ptr [RBP + -0x35]
MOV CL,byte ptr [R12 + 0x2]
XOR CL,byte ptr [RBP + -0x33]
MOVZX ECX,CL
OR CX,AX
JNZ 0x0012ae7a
LAB_0012ae66:
INC RBX
MOV RDI,RBX
MOV RSI,R15
CALL 0x001242e0
MOV R12,RAX
MOV byte ptr [RAX],0x2f
LAB_0012ae7a:
INC R14
INC R12
JMP 0x0012aca8
LAB_0012ae85:
LEA RBX,[RBP + -0x240]
MOV RDI,qword ptr [RBP + -0x248]
MOV RSI,RBX
CALL 0x00124290
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0012aec2
SUB R12,RBX
MOV RAX,R12
ADD RSP,0x228
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012aec2:
CALL 0x00124320
|
long cleanup_dirname(char *param_1,char *param_2)
{
char cVar1;
int iVar2;
ulong uVar3;
char *pcVar4;
short *psVar5;
short *psVar6;
short *psVar7;
short *psVar8;
short *psVar9;
long in_FS_OFFSET;
short local_248 [261];
int1 local_3d [2];
char cStack_3b;
int1 local_3a;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
_local_3d = 0x2e2e2f;
local_3a = 0;
psVar7 = local_248;
psVar8 = psVar7;
do {
cVar1 = *param_2;
*(char *)psVar7 = cVar1;
psVar5 = psVar7;
psVar9 = psVar8;
if (cVar1 == '/') {
*(char *)psVar7 = '/';
uVar3 = (long)psVar7 - (long)psVar8;
if (uVar3 < 4) {
if (uVar3 != 2) goto LAB_0012adb6;
psVar9 = psVar7;
if (*psVar8 == stack0xffffffffffffffc4) goto LAB_0012ae7a;
cVar1 = *(char *)((long)psVar7 + -1);
if (cVar1 == '/') goto LAB_0012adc9;
LAB_0012addb:
psVar9 = psVar8;
if ((cVar1 == '.') && ((char)psVar7[-1] == '/')) {
psVar5 = psVar7 + -1;
}
}
else if (*(char *)((long)psVar7 + -1) == cStack_3b &&
(int1 [2])*(short *)((long)psVar7 + -3) == local_3d) {
psVar5 = (short *)((long)psVar7 + -3);
if (psVar5 == psVar8) goto LAB_0012ae7a;
psVar5 = psVar7 + -2;
cVar1 = (char)psVar7[-2];
if (cVar1 == '~') {
if ((psVar5 == psVar8) || (psVar6 = psVar5, *(char *)((long)psVar7 + -5) == '/')) {
psVar5 = psVar7;
if (home_dir == (char *)0x0) goto LAB_0012ae7a;
pcVar4 = stpcpy((char *)local_248,home_dir);
psVar5 = (short *)(pcVar4 + -1);
if (pcVar4[-1] == '/') {
psVar5 = (short *)(pcVar4 + -2);
}
cVar1 = pcVar4[~(ulong)(pcVar4[-1] == '/')];
goto LAB_0012ad5c;
}
}
else {
LAB_0012ad5c:
psVar6 = psVar5;
if ((cVar1 == '.') && ((psVar5 == psVar8 || (*(char *)((long)psVar5 + -1) == '/')))) {
iVar2 = my_getwd(&curr_dir,0x200,0);
if (iVar2 != 0) {
psVar5 = psVar5 + 2;
goto LAB_0012ae7a;
}
pcVar4 = stpcpy((char *)local_248,&curr_dir);
psVar5 = (short *)(pcVar4 + -1);
psVar6 = (short *)(pcVar4 + -1);
if (pcVar4[-1] == '/') {
psVar5 = (short *)(pcVar4 + -2);
psVar6 = (short *)(pcVar4 + -2);
}
}
}
for (; psVar8 <= psVar5; psVar5 = (short *)((long)psVar5 + -1)) {
if ((char)*psVar5 == '/') {
if (*(char *)((long)psVar5 + 1) == '~') goto LAB_0012ae66;
if ((char)psVar5[1] != cStack_3b || (int1 [2])*psVar5 != local_3d)
goto LAB_0012ae7a;
goto LAB_0012ae66;
}
}
if (*(char *)((long)psVar5 + 1) == '~') {
LAB_0012ae66:
psVar5 = (short *)stpcpy((char *)((long)psVar6 + 1),local_3d);
*(int1 *)psVar5 = 0x2f;
}
}
else {
LAB_0012adb6:
if (0 < (long)uVar3) {
cVar1 = *(char *)((long)psVar7 + -1);
if (cVar1 == '/') {
LAB_0012adc9:
psVar5 = (short *)((long)psVar7 + -1);
psVar9 = psVar8;
}
else if (uVar3 != 1) goto LAB_0012addb;
}
}
}
else if (cVar1 == '\0') {
strcpy(param_1,(char *)local_248);
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (long)psVar7 - (long)local_248;
}
LAB_0012ae7a:
param_2 = param_2 + 1;
psVar7 = (short *)((long)psVar5 + 1);
psVar8 = psVar9;
} while( true );
}
| |
54,736 | my_strnxfrm_simple | eloqsql/strings/ctype-simple.c | size_t my_strnxfrm_simple(CHARSET_INFO * cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
uchar *d0= dst;
dst= d0 + my_strnxfrm_simple_internal(cs, dst, dstlen, &nweights,
src, srclen);
return my_strxfrm_pad_desc_and_reverse(cs, d0, dst, d0 + dstlen,
nweights, flags, 0);
} | O0 | c | my_strnxfrm_simple:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x1c(%rbp), %rcx
callq 0x491f0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
addq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x49390
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnxfrm_simple:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov r8, [rbp+var_28]
mov r9, [rbp+var_30]
lea rcx, [rbp+var_1C]
call my_strnxfrm_simple_internal
mov rcx, rax
mov rax, [rbp+var_40]
add rax, rcx
mov [rbp+var_10], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_38]
add rcx, [rbp+var_18]
mov r8d, [rbp+var_1C]
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+50h+var_50], 0
call my_strxfrm_pad_desc_and_reverse
add rsp, 50h
pop rbp
retn
| long long my_strnxfrm_simple(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
unsigned __int8 *a5,
unsigned long long a6,
int a7)
{
_BYTE *v7; // rax
unsigned int v9; // [rsp+34h] [rbp-1Ch] BYREF
unsigned long long v10; // [rsp+38h] [rbp-18h]
unsigned __int8 *v11; // [rsp+40h] [rbp-10h]
long long v12; // [rsp+48h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v7 = my_strnxfrm_simple_internal(a1, a2, a3, &v9, a5, a6);
v11 = &a2[(_QWORD)v7];
return my_strxfrm_pad_desc_and_reverse(v12, (_DWORD)a2, (int)v7 + (int)a2, (int)v10 + (int)a2, v9, a7, 0);
}
| my_strnxfrm_simple:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x1c]
CALL 0x001491f0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,qword ptr [RBP + -0x18]
MOV R8D,dword ptr [RBP + -0x1c]
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x00149390
ADD RSP,0x50
POP RBP
RET
|
void my_strnxfrm_simple(int8 param_1,long param_2,long param_3,int4 param_4,
int8 param_5,int8 param_6,int4 param_7)
{
int4 local_24;
long local_20;
long local_18;
int8 local_10;
local_24 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_18 = my_strnxfrm_simple_internal(param_1,param_2,param_3,&local_24,param_5,param_6);
local_18 = param_2 + local_18;
my_strxfrm_pad_desc_and_reverse(local_10,param_2,local_18,param_2 + local_20,local_24,param_7,0);
return;
}
| |
54,737 | Binary_string::real_alloc(unsigned long) | eloqsql/sql/sql_string.cc | bool Binary_string::real_alloc(size_t length)
{
size_t arg_length= ALIGN_SIZE(length + 1);
DBUG_ASSERT(arg_length > length);
if (arg_length <= length)
return TRUE; /* Overflow */
DBUG_ASSERT(length < UINT_MAX32); // cast to uint32 is safe
str_length=0;
if (Alloced_length < arg_length)
{
free_buffer();
if (!(Ptr=(char*) my_malloc(STRING_PSI_MEMORY_KEY,
arg_length,MYF(MY_WME | (thread_specific ?
MY_THREAD_SPECIFIC : 0)))))
return TRUE;
Alloced_length=(uint32) arg_length;
alloced=1;
}
Ptr[0]=0;
return FALSE;
} | O0 | cpp | Binary_string::real_alloc(unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x776e2
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x776f2
movb $0x1, -0x1(%rbp)
jmp 0x77769
jmp 0x776f4
jmp 0x776f6
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
movl 0xc(%rax), %eax
cmpq -0x20(%rbp), %rax
jae 0x7775b
movq -0x28(%rbp), %rdi
callq 0x77620
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rsi
movb 0x15(%rax), %dl
xorl %eax, %eax
movl $0x10000, %ecx # imm = 0x10000
testb $0x1, %dl
cmovnel %ecx, %eax
orl $0x10, %eax
movl %eax, %eax
movl %eax, %edx
xorl %edi, %edi
callq 0xc2350
movq -0x28(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x7774c
movb $0x1, -0x1(%rbp)
jmp 0x77769
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movl %ecx, 0xc(%rax)
movb $0x1, 0x14(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN13Binary_string10real_allocEm:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
add rax, 1
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_20], rax
jmp short $+2
loc_776E2:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_18]
ja short loc_776F2
mov [rbp+var_1], 1
jmp short loc_77769
loc_776F2:
jmp short $+2
loc_776F4:
jmp short $+2
loc_776F6:
mov rax, [rbp+var_28]
mov dword ptr [rax+8], 0
mov eax, [rax+0Ch]
cmp rax, [rbp+var_20]
jnb short loc_7775B
mov rdi, [rbp+var_28]; this
call _ZN13Binary_string11free_bufferEv; Binary_string::free_buffer(void)
mov rax, [rbp+var_28]
mov rsi, [rbp+var_20]
mov dl, [rax+15h]
xor eax, eax
mov ecx, 10000h
test dl, 1
cmovnz eax, ecx
or eax, 10h
mov eax, eax
mov edx, eax
xor edi, edi
call my_malloc
mov rcx, [rbp+var_28]
mov [rcx], rax
cmp rax, 0
jnz short loc_7774C
mov [rbp+var_1], 1
jmp short loc_77769
loc_7774C:
mov rax, [rbp+var_28]
mov rcx, [rbp+var_20]
mov [rax+0Ch], ecx
mov byte ptr [rax+14h], 1
loc_7775B:
mov rax, [rbp+var_28]
mov rax, [rax]
mov byte ptr [rax], 0
mov [rbp+var_1], 0
loc_77769:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
| char Binary_string::real_alloc(Binary_string *this, unsigned long long a2)
{
int v2; // eax
long long v3; // rax
unsigned long long v5; // [rsp+10h] [rbp-20h]
v5 = (a2 + 8) & 0xFFFFFFFFFFFFFFF8LL;
if ( v5 > a2 )
{
*((_DWORD *)this + 2) = 0;
if ( *((unsigned int *)this + 3) < v5 )
{
Binary_string::free_buffer(this);
v2 = 0;
if ( (*((_BYTE *)this + 21) & 1) != 0 )
v2 = 0x10000;
v3 = my_malloc(0LL, v5, v2 | 0x10u);
*(_QWORD *)this = v3;
if ( !v3 )
return 1;
*((_DWORD *)this + 3) = v5;
*((_BYTE *)this + 20) = 1;
}
**(_BYTE **)this = 0;
return 0;
}
return 1;
}
| real_alloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001776e2
LAB_001776e2:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x18]
JA 0x001776f2
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00177769
LAB_001776f2:
JMP 0x001776f4
LAB_001776f4:
JMP 0x001776f6
LAB_001776f6:
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x8],0x0
MOV EAX,dword ptr [RAX + 0xc]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0017775b
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00177620
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x20]
MOV DL,byte ptr [RAX + 0x15]
XOR EAX,EAX
MOV ECX,0x10000
TEST DL,0x1
CMOVNZ EAX,ECX
OR EAX,0x10
MOV EAX,EAX
MOV EDX,EAX
XOR EDI,EDI
CALL 0x001c2350
MOV RCX,qword ptr [RBP + -0x28]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x0017774c
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00177769
LAB_0017774c:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0xc],ECX
MOV byte ptr [RAX + 0x14],0x1
LAB_0017775b:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV byte ptr [RAX],0x0
MOV byte ptr [RBP + -0x1],0x0
LAB_00177769:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x30
POP RBP
RET
|
/* Binary_string::real_alloc(unsigned long) */
int8 __thiscall Binary_string::real_alloc(Binary_string *this,ulong param_1)
{
uint uVar1;
int1 *puVar2;
long lVar3;
int1 local_9;
puVar2 = (int1 *)(param_1 + 8 & 0xfffffffffffffff8);
if (param_1 < puVar2) {
*(int4 *)(this + 8) = 0;
if ((int1 *)(ulong)*(uint *)(this + 0xc) < puVar2) {
free_buffer(this);
uVar1 = 0;
if (((byte)this[0x15] & 1) != 0) {
uVar1 = 0x10000;
}
lVar3 = my_malloc(0,puVar2,uVar1 | 0x10);
*(long *)this = lVar3;
if (lVar3 == 0) {
local_9 = 1;
puVar2 = (int1 *)0x0;
goto LAB_00177769;
}
*(int *)(this + 0xc) = (int)puVar2;
this[0x14] = (Binary_string)0x1;
}
puVar2 = *(int1 **)this;
*puVar2 = 0;
local_9 = 0;
}
else {
local_9 = 1;
}
LAB_00177769:
return CONCAT71((int7)((ulong)puVar2 >> 8),local_9);
}
| |
54,738 | insert_dynamic | eloqsql/mysys/array.c | my_bool insert_dynamic(DYNAMIC_ARRAY *array, const void * element)
{
void *buffer;
if (array->elements == array->max_element)
{ /* Call only when necessary */
if (!(buffer=alloc_dynamic(array)))
return TRUE;
}
else
{
buffer=array->buffer+(array->elements * array->size_of_element);
array->elements++;
}
memcpy(buffer,element,(size_t) array->size_of_element);
return FALSE;
} | O0 | c | insert_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x3408b
movq -0x10(%rbp), %rdi
callq 0x340e0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x34089
movb $0x1, -0x1(%rbp)
jmp 0x340d1
jmp 0x340b7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movq -0x10(%rbp), %rdx
imull 0x14(%rdx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %edx
callq 0x24200
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| insert_dynamic:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
cmp eax, [rcx+0Ch]
jnz short loc_3408B
mov rdi, [rbp+var_10]
call alloc_dynamic
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_34089
mov [rbp+var_1], 1
jmp short loc_340D1
loc_34089:
jmp short loc_340B7
loc_3408B:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
mov ecx, [rcx+8]
mov rdx, [rbp+var_10]
imul ecx, [rdx+14h]
mov ecx, ecx
add rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov ecx, [rax+8]
add ecx, 1
mov [rax+8], ecx
loc_340B7:
mov rdi, [rbp+var_20]
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_340D1:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char insert_dynamic(long long a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-20h]
if ( *(_DWORD *)(a1 + 8) != *(_DWORD *)(a1 + 12) )
{
v3 = (unsigned int)(*(_DWORD *)(a1 + 20) * (*(_DWORD *)(a1 + 8))++) + *(_QWORD *)a1;
LABEL_6:
memcpy(v3, a2, *(unsigned int *)(a1 + 20));
return 0;
}
v3 = alloc_dynamic(a1);
if ( v3 )
goto LABEL_6;
return 1;
}
| insert_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0xc]
JNZ 0x0013408b
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001340e0
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x00134089
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001340d1
LAB_00134089:
JMP 0x001340b7
LAB_0013408b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x8]
MOV RDX,qword ptr [RBP + -0x10]
IMUL ECX,dword ptr [RDX + 0x14]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x8]
ADD ECX,0x1
MOV dword ptr [RAX + 0x8],ECX
LAB_001340b7:
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
MOV EDX,EAX
CALL 0x00124200
MOV byte ptr [RBP + -0x1],0x0
LAB_001340d1:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 insert_dynamic(long *param_1,void *param_2)
{
void *local_28;
if ((int)param_1[1] == *(int *)((long)param_1 + 0xc)) {
local_28 = (void *)alloc_dynamic(param_1);
if (local_28 == (void *)0x0) {
return 1;
}
}
else {
local_28 = (void *)(*param_1 + (ulong)(uint)((int)param_1[1] * *(int *)((long)param_1 + 0x14)));
*(int *)(param_1 + 1) = (int)param_1[1] + 1;
}
memcpy(local_28,param_2,(ulong)*(uint *)((long)param_1 + 0x14));
return 0;
}
| |
54,739 | insert_dynamic | eloqsql/mysys/array.c | my_bool insert_dynamic(DYNAMIC_ARRAY *array, const void * element)
{
void *buffer;
if (array->elements == array->max_element)
{ /* Call only when necessary */
if (!(buffer=alloc_dynamic(array)))
return TRUE;
}
else
{
buffer=array->buffer+(array->elements * array->size_of_element);
array->elements++;
}
memcpy(buffer,element,(size_t) array->size_of_element);
return FALSE;
} | O3 | c | insert_dynamic:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %ecx
cmpl 0xc(%rdi), %ecx
jne 0x2dec1
movq %r14, %rdi
callq 0x2dee8
testq %rax, %rax
je 0x2dee4
movq %rax, %rdi
movl 0x14(%r14), %eax
jmp 0x2ded3
movl 0x14(%r14), %eax
movl %eax, %edi
imull %ecx, %edi
addq (%r14), %rdi
incl %ecx
movl %ecx, 0x8(%r14)
movl %eax, %edx
movq %rbx, %rsi
callq 0x24230
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
jmp 0x2dedf
| insert_dynamic:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov ecx, [rdi+8]
cmp ecx, [rdi+0Ch]
jnz short loc_2DEC1
mov rdi, r14
call alloc_dynamic
test rax, rax
jz short loc_2DEE4
mov rdi, rax
mov eax, [r14+14h]
jmp short loc_2DED3
loc_2DEC1:
mov eax, [r14+14h]
mov edi, eax
imul edi, ecx
add rdi, [r14]
inc ecx
mov [r14+8], ecx
loc_2DED3:
mov edx, eax
mov rsi, rbx
call _memcpy
xor eax, eax
loc_2DEDF:
pop rbx
pop r14
pop rbp
retn
loc_2DEE4:
mov al, 1
jmp short loc_2DEDF
| long long insert_dynamic(long long a1, long long a2)
{
int v3; // ecx
long long v4; // rax
long long v5; // rdi
unsigned int v6; // eax
v3 = *(_DWORD *)(a1 + 8);
if ( v3 != *(_DWORD *)(a1 + 12) )
{
v6 = *(_DWORD *)(a1 + 20);
v5 = *(_QWORD *)a1 + v3 * v6;
*(_DWORD *)(a1 + 8) = v3 + 1;
goto LABEL_5;
}
v4 = alloc_dynamic(a1);
if ( v4 )
{
v5 = v4;
v6 = *(_DWORD *)(a1 + 20);
LABEL_5:
memcpy(v5, a2, v6);
return 0LL;
}
return 1LL;
}
| insert_dynamic:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV ECX,dword ptr [RDI + 0x8]
CMP ECX,dword ptr [RDI + 0xc]
JNZ 0x0012dec1
MOV RDI,R14
CALL 0x0012dee8
TEST RAX,RAX
JZ 0x0012dee4
MOV RDI,RAX
MOV EAX,dword ptr [R14 + 0x14]
JMP 0x0012ded3
LAB_0012dec1:
MOV EAX,dword ptr [R14 + 0x14]
MOV EDI,EAX
IMUL EDI,ECX
ADD RDI,qword ptr [R14]
INC ECX
MOV dword ptr [R14 + 0x8],ECX
LAB_0012ded3:
MOV EDX,EAX
MOV RSI,RBX
CALL 0x00124230
XOR EAX,EAX
LAB_0012dedf:
POP RBX
POP R14
POP RBP
RET
LAB_0012dee4:
MOV AL,0x1
JMP 0x0012dedf
|
int8 insert_dynamic(long *param_1,void *param_2)
{
int iVar1;
uint uVar2;
void *__dest;
iVar1 = (int)param_1[1];
if (iVar1 == *(int *)((long)param_1 + 0xc)) {
__dest = (void *)alloc_dynamic(param_1);
if (__dest == (void *)0x0) {
return 1;
}
uVar2 = *(uint *)((long)param_1 + 0x14);
}
else {
uVar2 = *(uint *)((long)param_1 + 0x14);
__dest = (void *)((ulong)(uVar2 * iVar1) + *param_1);
*(int *)(param_1 + 1) = iVar1 + 1;
}
memcpy(__dest,param_2,(ulong)uVar2);
return 0;
}
| |
54,740 | JS_GetImportMeta | bluesky950520[P]quickjs/quickjs.c | JSValue JS_GetImportMeta(JSContext *ctx, JSModuleDef *m)
{
JSValue obj;
/* allocate meta_obj only if requested to save memory */
obj = m->meta_obj;
if (JS_IsUndefined(obj)) {
obj = JS_NewObjectProto(ctx, JS_NULL);
if (JS_IsException(obj))
return JS_EXCEPTION;
m->meta_obj = obj;
}
return js_dup(obj);
} | O1 | c | JS_GetImportMeta:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x110(%rsi), %rdx
cmpl $0x3, %edx
jne 0x34f7c
xorl %ebx, %ebx
movl $0x2, %edx
xorl %esi, %esi
movl $0x1, %ecx
callq 0x24f61
movq %rdx, %rcx
movl $0x6, %edx
cmpl $0x6, %ecx
je 0x34f92
movq %rax, 0x108(%r14)
movq %rcx, 0x110(%r14)
movq %rax, %rbx
movq %rcx, %rdx
jmp 0x34f83
movq 0x108(%r14), %rbx
movq %rbx, (%rsp)
cmpl $-0x9, %edx
jb 0x34f92
movq (%rsp), %rax
incl (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| JS_GetImportMeta:
push r14
push rbx
push rax
mov r14, rsi
mov rdx, [rsi+110h]
cmp edx, 3
jnz short loc_34F7C
xor ebx, ebx
mov edx, 2
xor esi, esi
mov ecx, 1
call JS_NewObjectProtoClass
mov rcx, rdx
mov edx, 6
cmp ecx, 6
jz short loc_34F92
mov [r14+108h], rax
mov [r14+110h], rcx
mov rbx, rax
mov rdx, rcx
jmp short loc_34F83
loc_34F7C:
mov rbx, [r14+108h]
loc_34F83:
mov [rsp+18h+var_18], rbx
cmp edx, 0FFFFFFF7h
jb short loc_34F92
mov rax, [rsp+18h+var_18]
inc dword ptr [rax]
loc_34F92:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| _DWORD * JS_GetImportMeta(long long a1, long long a2)
{
long long v2; // rdx
_DWORD *v3; // rbx
long long v4; // rax
v2 = *(_QWORD *)(a2 + 272);
if ( (_DWORD)v2 == 3 )
{
v3 = 0LL;
v4 = JS_NewObjectProtoClass(a1, 0LL, 2, 1u);
if ( (_DWORD)v2 == 6 )
return v3;
*(_QWORD *)(a2 + 264) = v4;
*(_QWORD *)(a2 + 272) = v2;
v3 = (_DWORD *)v4;
}
else
{
v3 = *(_DWORD **)(a2 + 264);
}
if ( (unsigned int)v2 >= 0xFFFFFFF7 )
++*v3;
return v3;
}
| JS_GetImportMeta:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RDX,qword ptr [RSI + 0x110]
CMP EDX,0x3
JNZ 0x00134f7c
XOR EBX,EBX
MOV EDX,0x2
XOR ESI,ESI
MOV ECX,0x1
CALL 0x00124f61
MOV RCX,RDX
MOV EDX,0x6
CMP ECX,0x6
JZ 0x00134f92
MOV qword ptr [R14 + 0x108],RAX
MOV qword ptr [R14 + 0x110],RCX
MOV RBX,RAX
MOV RDX,RCX
JMP 0x00134f83
LAB_00134f7c:
MOV RBX,qword ptr [R14 + 0x108]
LAB_00134f83:
MOV qword ptr [RSP],RBX
CMP EDX,-0x9
JC 0x00134f92
MOV RAX,qword ptr [RSP]
INC dword ptr [RAX]
LAB_00134f92:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
int1 [16] JS_GetImportMeta(int8 param_1,long param_2)
{
int1 auVar1 [16];
if ((int)*(int8 *)(param_2 + 0x110) == 3) {
auVar1 = JS_NewObjectProtoClass(param_1,0,2,1);
if (auVar1._8_4_ == 6) {
return ZEXT816(6) << 0x40;
}
*(int1 (*) [16])(param_2 + 0x108) = auVar1;
}
else {
auVar1._8_8_ = *(int8 *)(param_2 + 0x110);
auVar1._0_8_ = *(int8 *)(param_2 + 0x108);
}
if (0xfffffff6 < auVar1._8_4_) {
*auVar1._0_8_ = *auVar1._0_8_ + 1;
}
return auVar1;
}
| |
54,741 | JS_GetImportMeta | bluesky950520[P]quickjs/quickjs.c | JSValue JS_GetImportMeta(JSContext *ctx, JSModuleDef *m)
{
JSValue obj;
/* allocate meta_obj only if requested to save memory */
obj = m->meta_obj;
if (JS_IsUndefined(obj)) {
obj = JS_NewObjectProto(ctx, JS_NULL);
if (JS_IsException(obj))
return JS_EXCEPTION;
m->meta_obj = obj;
}
return js_dup(obj);
} | O2 | c | JS_GetImportMeta:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x110(%rsi), %rdx
cmpl $0x3, %edx
jne 0x2d076
xorl %ebx, %ebx
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x1ee63
cmpl $0x6, %edx
jne 0x2d07f
pushq $0x6
popq %rdx
jmp 0x2d097
movq 0x108(%r14), %rbx
jmp 0x2d090
movq %rax, 0x108(%r14)
movq %rdx, 0x110(%r14)
movq %rax, %rbx
cmpl $-0x9, %edx
jb 0x2d097
incl (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| JS_GetImportMeta:
push r14
push rbx
push rax
mov r14, rsi
mov rdx, [rsi+110h]
cmp edx, 3
jnz short loc_2D076
xor ebx, ebx
push 2
pop rdx
xor esi, esi
call JS_NewObjectProto
cmp edx, 6
jnz short loc_2D07F
push 6
pop rdx
jmp short loc_2D097
loc_2D076:
mov rbx, [r14+108h]
jmp short loc_2D090
loc_2D07F:
mov [r14+108h], rax
mov [r14+110h], rdx
mov rbx, rax
loc_2D090:
cmp edx, 0FFFFFFF7h
jb short loc_2D097
inc dword ptr [rbx]
loc_2D097:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| _DWORD * JS_GetImportMeta(long long a1, long long a2)
{
long long v2; // rdx
_DWORD *v3; // rbx
long long v4; // rax
v2 = *(_QWORD *)(a2 + 272);
if ( (_DWORD)v2 == 3 )
{
v3 = 0LL;
v4 = JS_NewObjectProto(a1, 0LL, 2);
if ( (_DWORD)v2 == 6 )
return v3;
*(_QWORD *)(a2 + 264) = v4;
*(_QWORD *)(a2 + 272) = v2;
v3 = (_DWORD *)v4;
}
else
{
v3 = *(_DWORD **)(a2 + 264);
}
if ( (unsigned int)v2 >= 0xFFFFFFF7 )
++*v3;
return v3;
}
| JS_GetImportMeta:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RDX,qword ptr [RSI + 0x110]
CMP EDX,0x3
JNZ 0x0012d076
XOR EBX,EBX
PUSH 0x2
POP RDX
XOR ESI,ESI
CALL 0x0011ee63
CMP EDX,0x6
JNZ 0x0012d07f
PUSH 0x6
POP RDX
JMP 0x0012d097
LAB_0012d076:
MOV RBX,qword ptr [R14 + 0x108]
JMP 0x0012d090
LAB_0012d07f:
MOV qword ptr [R14 + 0x108],RAX
MOV qword ptr [R14 + 0x110],RDX
MOV RBX,RAX
LAB_0012d090:
CMP EDX,-0x9
JC 0x0012d097
INC dword ptr [RBX]
LAB_0012d097:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
int * JS_GetImportMeta(int8 param_1,long param_2)
{
int1 auVar1 [12];
int *piVar2;
int1 auVar3 [16];
if ((int)*(int8 *)(param_2 + 0x110) == 3) {
auVar3 = JS_NewObjectProto(param_1,0,2);
auVar1 = auVar3._0_12_;
if (auVar3._8_4_ == 6) {
return (int *)0x0;
}
*(int1 (*) [16])(param_2 + 0x108) = auVar3;
}
else {
auVar3._8_8_ = *(int8 *)(param_2 + 0x110);
auVar3._0_8_ = *(int8 *)(param_2 + 0x108);
auVar1 = auVar3._0_12_;
}
piVar2 = auVar1._0_8_;
if (0xfffffff6 < auVar1._8_4_) {
*piVar2 = *piVar2 + 1;
}
return piVar2;
}
| |
54,742 | translog_log_debug_info | eloqsql/storage/maria/ma_loghandler.c | my_bool translog_log_debug_info(TRN *trn __attribute__((unused)),
enum translog_debug_info_type type
__attribute__((unused)),
uchar *info __attribute__((unused)),
size_t length __attribute__((unused)))
{
#ifdef EXTRA_DEBUG
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
uchar debug_type;
LSN lsn;
if (!trn)
{
/*
We can't log the current transaction because we don't have
an active transaction. Use a temporary transaction object instead
*/
trn= &dummy_transaction_object;
}
debug_type= (uchar) type;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= &debug_type;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= 1;
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= info;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= length;
return translog_write_record(&lsn, LOGREC_DEBUG_INFO,
trn, NULL,
(translog_size_t) (1+ length),
sizeof(log_array)/sizeof(log_array[0]),
log_array, NULL, NULL);
#else
return 0;
#endif
} | O0 | c | translog_log_debug_info:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
| translog_log_debug_info:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
xor eax, eax
pop rbp
retn
| long long translog_log_debug_info()
{
return 0LL;
}
| translog_log_debug_info:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
XOR EAX,EAX
POP RBP
RET
|
int8 translog_log_debug_info(void)
{
return 0;
}
| |
54,743 | ftxui::ScreenInteractive::CaptureMouse() | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/component/screen_interactive.cpp | CapturedMouse ScreenInteractive::CaptureMouse() {
if (mouse_captured) {
return nullptr;
}
mouse_captured = true;
return std::make_unique<CapturedMouseImpl>(
[this] { mouse_captured = false; });
} | O2 | cpp | ftxui::ScreenInteractive::CaptureMouse():
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xe8(%rsi)
je 0x270a4
xorl %r14d, %r14d
jmp 0x270ff
movq %rsi, %r15
movb $0x1, 0xe8(%rsi)
pushq $0x28
popq %rdi
callq 0xc450
movq %rax, %r14
movq %rsp, %rdi
andq $0x0, 0x8(%rdi)
movq %r15, (%rdi)
leaq 0x2a335(%rip), %rax # 0x51400
movq %rax, (%r14)
leaq 0x1bef(%rip), %rax # 0x28cc4
movq %rax, 0x20(%r14)
movq (%rdi), %rax
movq %rax, 0x8(%r14)
movq 0x8(%rdi), %rax
movq %rax, 0x10(%r14)
leaq 0x1be1(%rip), %rax # 0x28cd0
movq %rax, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
callq 0x13b10
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN5ftxui17ScreenInteractive12CaptureMouseEv:
push r15
push r14
push rbx
sub rsp, 20h
mov rbx, rdi
cmp byte ptr [rsi+0E8h], 0
jz short loc_270A4
xor r14d, r14d
jmp short loc_270FF
loc_270A4:
mov r15, rsi
mov byte ptr [rsi+0E8h], 1
push 28h ; '('
pop rdi; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rdi, rsp; this
and qword ptr [rdi+8], 0
mov [rdi], r15
lea rax, off_51400
mov [r14], rax
lea rax, _ZNSt17_Function_handlerIFvvEZN5ftxui17ScreenInteractive12CaptureMouseEvE3$_0E9_M_invokeERKSt9_Any_data; std::_Function_handler<void ()(void),ftxui::ScreenInteractive::CaptureMouse(void)::$_0>::_M_invoke(std::_Any_data const&)
mov [r14+20h], rax
mov rax, [rdi]
mov [r14+8], rax
mov rax, [rdi+8]
mov [r14+10h], rax
lea rax, _ZNSt17_Function_handlerIFvvEZN5ftxui17ScreenInteractive12CaptureMouseEvE3$_0E10_M_managerERSt9_Any_dataRKS5_St18_Manager_operation; std::_Function_handler<void ()(void),ftxui::ScreenInteractive::CaptureMouse(void)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [r14+18h], rax
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
loc_270FF:
mov [rbx], r14
mov rax, rbx
add rsp, 20h
pop rbx
pop r14
pop r15
retn
| ftxui::ScreenInteractive * ftxui::ScreenInteractive::CaptureMouse(ftxui::ScreenInteractive *this, long long a2)
{
_QWORD *v2; // r14
long long v4; // [rsp+0h] [rbp-38h] BYREF
long long v5; // [rsp+8h] [rbp-30h]
__int128 v6; // [rsp+10h] [rbp-28h]
if ( *(_BYTE *)(a2 + 232) )
{
v2 = 0LL;
}
else
{
*(_BYTE *)(a2 + 232) = 1;
v2 = (_QWORD *)operator new(0x28uLL);
v5 = 0LL;
v4 = a2;
*v2 = off_51400;
v2[4] = std::_Function_handler<void ()(void),ftxui::ScreenInteractive::CaptureMouse(void)::$_0>::_M_invoke;
v2[1] = v4;
v2[2] = v5;
v2[3] = std::_Function_handler<void ()(void),ftxui::ScreenInteractive::CaptureMouse(void)::$_0>::_M_manager;
v6 = 0LL;
std::_Function_base::~_Function_base((std::_Function_base *)&v4);
}
*(_QWORD *)this = v2;
return this;
}
| CaptureMouse:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
CMP byte ptr [RSI + 0xe8],0x0
JZ 0x001270a4
XOR R14D,R14D
JMP 0x001270ff
LAB_001270a4:
MOV R15,RSI
MOV byte ptr [RSI + 0xe8],0x1
PUSH 0x28
POP RDI
CALL 0x0010c450
MOV R14,RAX
MOV RDI,RSP
AND qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI],R15
LEA RAX,[0x151400]
MOV qword ptr [R14],RAX
LEA RAX,[0x128cc4]
MOV qword ptr [R14 + 0x20],RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [R14 + 0x8],RAX
MOV RAX,qword ptr [RDI + 0x8]
MOV qword ptr [R14 + 0x10],RAX
LEA RAX,[0x128cd0]
MOV qword ptr [R14 + 0x18],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
CALL 0x00113b10
LAB_001270ff:
MOV qword ptr [RBX],R14
MOV RAX,RBX
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
|
/* ftxui::ScreenInteractive::CaptureMouse() */
void ftxui::ScreenInteractive::CaptureMouse(void)
{
int8 *puVar1;
long in_RSI;
int8 *in_RDI;
_Function_base local_38 [8];
int8 local_30;
int8 local_28;
int8 uStack_20;
if (*(char *)(in_RSI + 0xe8) == '\0') {
*(int1 *)(in_RSI + 0xe8) = 1;
puVar1 = (int8 *)operator_new(0x28);
local_30 = 0;
*puVar1 = &PTR__CapturedMouseImpl_00151400;
puVar1[4] = std::_Function_handler<void(),ftxui::ScreenInteractive::CaptureMouse()::$_0>::
_M_invoke;
puVar1[1] = in_RSI;
puVar1[2] = 0;
puVar1[3] = std::_Function_handler<void(),ftxui::ScreenInteractive::CaptureMouse()::$_0>::
_M_manager;
local_28 = 0;
uStack_20 = 0;
std::_Function_base::~_Function_base(local_38);
}
else {
puVar1 = (int8 *)0x0;
}
*in_RDI = puVar1;
return;
}
| |
54,744 | ImPlot3DBox::Contains(ImPlot3DPoint const&) const | zkingston[P]unknot/build_O0/_deps/implot3d-src/implot3d.cpp | bool ImPlot3DBox::Contains(const ImPlot3DPoint& point) const {
return (point.x >= Min.x && point.x <= Max.x) &&
(point.y >= Min.y && point.y <= Max.y) &&
(point.z >= Min.z && point.z <= Max.z);
} | O0 | cpp | ImPlot3DBox::Contains(ImPlot3DPoint const&) const:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rcx
movq %rcx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movss (%rax), %xmm0
xorl %eax, %eax
ucomiss (%rcx), %xmm0
movb %al, -0x11(%rsp)
jb 0xd7675
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
movss (%rcx), %xmm1
movss 0xc(%rax), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rsp)
jb 0xd7675
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rax
movss 0x4(%rax), %xmm0
xorl %eax, %eax
ucomiss 0x4(%rcx), %xmm0
movb %al, -0x11(%rsp)
jb 0xd7675
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
movss 0x4(%rcx), %xmm1
movss 0x10(%rax), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rsp)
jb 0xd7675
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rax
movss 0x8(%rax), %xmm0
xorl %eax, %eax
ucomiss 0x8(%rcx), %xmm0
movb %al, -0x21(%rsp)
jb 0xd766d
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
movss 0x8(%rcx), %xmm1
movss 0x14(%rax), %xmm0
ucomiss %xmm1, %xmm0
setae %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
| _ZNK11ImPlot3DBox8ContainsERK13ImPlot3DPoint:
mov [rsp+var_8], rdi
mov [rsp+var_10], rsi
mov rcx, [rsp+var_8]
mov [rsp+var_20], rcx
mov rax, [rsp+var_10]
movss xmm0, dword ptr [rax]
xor eax, eax
ucomiss xmm0, dword ptr [rcx]
mov [rsp+var_11], al
jb loc_D7675
mov rax, [rsp+var_20]
mov rcx, [rsp+var_10]
movss xmm1, dword ptr [rcx]
movss xmm0, dword ptr [rax+0Ch]
xor eax, eax
ucomiss xmm0, xmm1
mov [rsp+var_11], al
jb short loc_D7675
mov rcx, [rsp+var_20]
mov rax, [rsp+var_10]
movss xmm0, dword ptr [rax+4]
xor eax, eax
ucomiss xmm0, dword ptr [rcx+4]
mov [rsp+var_11], al
jb short loc_D7675
mov rax, [rsp+var_20]
mov rcx, [rsp+var_10]
movss xmm1, dword ptr [rcx+4]
movss xmm0, dword ptr [rax+10h]
xor eax, eax
ucomiss xmm0, xmm1
mov [rsp+var_11], al
jb short loc_D7675
mov rcx, [rsp+var_20]
mov rax, [rsp+var_10]
movss xmm0, dword ptr [rax+8]
xor eax, eax
ucomiss xmm0, dword ptr [rcx+8]
mov [rsp+var_21], al
jb short loc_D766D
mov rax, [rsp+var_20]
mov rcx, [rsp+var_10]
movss xmm1, dword ptr [rcx+8]
movss xmm0, dword ptr [rax+14h]
ucomiss xmm0, xmm1
setnb al
mov [rsp+var_21], al
loc_D766D:
mov al, [rsp+var_21]
mov [rsp+var_11], al
loc_D7675:
mov al, [rsp+var_11]
and al, 1
retn
| bool ImPlot3DBox::Contains(ImPlot3DBox *this, const ImPlot3DPoint *a2)
{
bool v3; // [rsp+1h] [rbp-21h]
bool v4; // [rsp+11h] [rbp-11h]
v4 = 0;
if ( *(float *)a2 >= *(float *)this )
{
v4 = 0;
if ( *((float *)this + 3) >= *(float *)a2 )
{
v4 = 0;
if ( *((float *)a2 + 1) >= *((float *)this + 1) )
{
v4 = 0;
if ( *((float *)this + 4) >= *((float *)a2 + 1) )
{
v3 = 0;
if ( *((float *)a2 + 2) >= *((float *)this + 2) )
return *((float *)this + 5) >= *((float *)a2 + 2);
return v3;
}
}
}
}
return v4;
}
| Contains:
MOV qword ptr [RSP + -0x8],RDI
MOV qword ptr [RSP + -0x10],RSI
MOV RCX,qword ptr [RSP + -0x8]
MOV qword ptr [RSP + -0x20],RCX
MOV RAX,qword ptr [RSP + -0x10]
MOVSS XMM0,dword ptr [RAX]
XOR EAX,EAX
UCOMISS XMM0,dword ptr [RCX]
MOV byte ptr [RSP + -0x11],AL
JC 0x001d7675
MOV RAX,qword ptr [RSP + -0x20]
MOV RCX,qword ptr [RSP + -0x10]
MOVSS XMM1,dword ptr [RCX]
MOVSS XMM0,dword ptr [RAX + 0xc]
XOR EAX,EAX
UCOMISS XMM0,XMM1
MOV byte ptr [RSP + -0x11],AL
JC 0x001d7675
MOV RCX,qword ptr [RSP + -0x20]
MOV RAX,qword ptr [RSP + -0x10]
MOVSS XMM0,dword ptr [RAX + 0x4]
XOR EAX,EAX
UCOMISS XMM0,dword ptr [RCX + 0x4]
MOV byte ptr [RSP + -0x11],AL
JC 0x001d7675
MOV RAX,qword ptr [RSP + -0x20]
MOV RCX,qword ptr [RSP + -0x10]
MOVSS XMM1,dword ptr [RCX + 0x4]
MOVSS XMM0,dword ptr [RAX + 0x10]
XOR EAX,EAX
UCOMISS XMM0,XMM1
MOV byte ptr [RSP + -0x11],AL
JC 0x001d7675
MOV RCX,qword ptr [RSP + -0x20]
MOV RAX,qword ptr [RSP + -0x10]
MOVSS XMM0,dword ptr [RAX + 0x8]
XOR EAX,EAX
UCOMISS XMM0,dword ptr [RCX + 0x8]
MOV byte ptr [RSP + -0x21],AL
JC 0x001d766d
MOV RAX,qword ptr [RSP + -0x20]
MOV RCX,qword ptr [RSP + -0x10]
MOVSS XMM1,dword ptr [RCX + 0x8]
MOVSS XMM0,dword ptr [RAX + 0x14]
UCOMISS XMM0,XMM1
SETNC AL
MOV byte ptr [RSP + -0x21],AL
LAB_001d766d:
MOV AL,byte ptr [RSP + -0x21]
MOV byte ptr [RSP + -0x11],AL
LAB_001d7675:
MOV AL,byte ptr [RSP + -0x11]
AND AL,0x1
RET
|
/* ImPlot3DBox::Contains(ImPlot3DPoint const&) const */
int8 __thiscall ImPlot3DBox::Contains(ImPlot3DBox *this,ImPlot3DPoint *param_1)
{
int7 uVar1;
bool local_21;
bool local_11;
uVar1 = 0;
local_11 = false;
if (*(float *)this <= *(float *)param_1) {
uVar1 = 0;
local_11 = false;
if (*(float *)param_1 <= *(float *)(this + 0xc)) {
uVar1 = 0;
local_11 = false;
if (*(float *)(this + 4) <= *(float *)(param_1 + 4)) {
uVar1 = 0;
local_11 = false;
if (*(float *)(param_1 + 4) <= *(float *)(this + 0x10)) {
uVar1 = 0;
local_21 = false;
if (*(float *)(this + 8) <= *(float *)(param_1 + 8)) {
local_21 = *(float *)(param_1 + 8) <= *(float *)(this + 0x14);
uVar1 = (int7)((ulong)this >> 8);
}
local_11 = local_21;
}
}
}
}
return CONCAT71(uVar1,local_11);
}
| |
54,745 | psi_rwlock_tryrdlock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD
int psi_rwlock_tryrdlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_rdwait)
(&state, that->m_psi, PSI_RWLOCK_TRYREADLOCK, file, line);
int result= rw_tryrdlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, result);
return result;
} | O0 | c | psi_rwlock_tryrdlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1a6d4e(%rip), %rax # 0x1d8c48
movq (%rax), %rax
movq 0x1a0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
movl $0x2, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x325a0
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x31f53
leaq 0x1a6d08(%rip), %rax # 0x1d8c48
movq (%rax), %rax
movq 0x1a8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| psi_rwlock_tryrdlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1A0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+90h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
mov edx, 2
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call my_rw_tryrdlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_31F53
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1A8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_31F53:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
| long long psi_rwlock_tryrdlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = (*((long long ( **)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server[0] + 52))(
v6,
*(_QWORD *)(a1 + 144),
2LL,
a2,
a3);
v4 = my_rw_tryrdlock(v9);
if ( v5 )
(*((void ( **)(long long, _QWORD))PSI_server[0] + 53))(v5, v4);
return v4;
}
| psi_rwlock_tryrdlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
LEA RAX,[0x2d8c48]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1a0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
MOV EDX,0x2
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001325a0
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x00131f53
LEA RAX,[0x2d8c48]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1a8]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_00131f53:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4 psi_rwlock_tryrdlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
long local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1a0))
(local_50,*(int8 *)(param_1 + 0x90),2,param_2,param_3);
uVar1 = my_rw_tryrdlock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1a8))(lVar2,uVar1);
}
return uVar1;
}
| |
54,746 | PFS_host::aggregate_stages() | eloqsql/storage/perfschema/pfs_host.cc | void PFS_host::aggregate_stages()
{
if (read_instr_class_stages_stats() == NULL)
return;
/*
Aggregate EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME to:
- EVENTS_STAGES_SUMMARY_GLOBAL_BY_EVENT_NAME
*/
aggregate_all_stages(write_instr_class_stages_stats(),
global_instr_class_stages_array);
} | O0 | cpp | PFS_host::aggregate_stages():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x41830
cmpq $0x0, %rax
jne 0x58fa1
jmp 0x58fbc
movq -0x10(%rbp), %rdi
callq 0x41870
movq %rax, %rdi
leaq 0x3b4b44(%rip), %rax # 0x40daf8
movq (%rax), %rsi
callq 0x3c270
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN8PFS_host16aggregate_stagesEv:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
mov [rbp+var_10], rdi
call _ZNK20PFS_connection_slice29read_instr_class_stages_statsEv; PFS_connection_slice::read_instr_class_stages_stats(void)
cmp rax, 0
jnz short loc_58FA1
jmp short loc_58FBC
loc_58FA1:
mov rdi, [rbp+var_10]; this
call _ZN20PFS_connection_slice30write_instr_class_stages_statsEv; PFS_connection_slice::write_instr_class_stages_stats(void)
mov rdi, rax; PFS_stage_stat *
lea rax, global_instr_class_stages_array
mov rsi, [rax]; PFS_stage_stat *
call _Z20aggregate_all_stagesP14PFS_stage_statS0_; aggregate_all_stages(PFS_stage_stat *,PFS_stage_stat *)
loc_58FBC:
add rsp, 10h
pop rbp
retn
| PFS_stage_stat * PFS_host::aggregate_stages(PFS_host *this)
{
PFS_stage_stat *result; // rax
PFS_stage_stat *v2; // rax
result = (PFS_stage_stat *)PFS_connection_slice::read_instr_class_stages_stats(this);
if ( result )
{
v2 = (PFS_stage_stat *)PFS_connection_slice::write_instr_class_stages_stats(this);
return aggregate_all_stages(v2, global_instr_class_stages_array);
}
return result;
}
| aggregate_stages:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RDI
CALL 0x00141830
CMP RAX,0x0
JNZ 0x00158fa1
JMP 0x00158fbc
LAB_00158fa1:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00141870
MOV RDI,RAX
LEA RAX,[0x50daf8]
MOV RSI,qword ptr [RAX]
CALL 0x0013c270
LAB_00158fbc:
ADD RSP,0x10
POP RBP
RET
|
/* PFS_host::aggregate_stages() */
void __thiscall PFS_host::aggregate_stages(PFS_host *this)
{
long lVar1;
PFS_stage_stat *pPVar2;
lVar1 = PFS_connection_slice::read_instr_class_stages_stats((PFS_connection_slice *)this);
if (lVar1 != 0) {
pPVar2 = (PFS_stage_stat *)
PFS_connection_slice::write_instr_class_stages_stats((PFS_connection_slice *)this);
aggregate_all_stages(pPVar2,global_instr_class_stages_array);
}
return;
}
| |
54,747 | ft_boolean_check_syntax_string | eloqsql/storage/myisam/ft_parser.c | my_bool ft_boolean_check_syntax_string(const uchar *str, size_t length,
CHARSET_INFO *cs)
{
uint i, j;
if (cs->mbminlen != 1)
{
DBUG_ASSERT(0);
return 1;
}
if (!str ||
(length + 1 != sizeof(DEFAULT_FTB_SYNTAX)) ||
(str[0] != ' ' && str[1] != ' '))
return 1;
for (i=0; i<sizeof(DEFAULT_FTB_SYNTAX); i++)
{
/* limiting to 7-bit ascii only */
if ((unsigned char)(str[i]) > 127 || my_isalnum(cs, str[i]))
return 1;
for (j=0; j<i; j++)
if (str[i] == str[j] && (i != 11 || j != 10))
return 1;
}
return 0;
} | O0 | c | ft_boolean_check_syntax_string:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, 0x98(%rax)
je 0xc520a
jmp 0xc51ff
jmp 0xc5201
movb $0x1, -0x1(%rbp)
jmp 0xc52e7
cmpq $0x0, -0x10(%rbp)
je 0xc5238
movq -0x18(%rbp), %rax
addq $0x1, %rax
cmpq $0xf, %rax
jne 0xc5238
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0xc5241
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x20, %eax
je 0xc5241
movb $0x1, -0x1(%rbp)
jmp 0xc52e7
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq $0xf, %rax
jae 0xc52e3
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x7f, %eax
jg 0xc5285
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movl -0x24(%rbp), %edx
movzbl (%rcx,%rdx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0xc528b
movb $0x1, -0x1(%rbp)
jmp 0xc52e7
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xc52d3
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movl -0x28(%rbp), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xc52c6
cmpl $0xb, -0x24(%rbp)
jne 0xc52c0
cmpl $0xa, -0x28(%rbp)
je 0xc52c6
movb $0x1, -0x1(%rbp)
jmp 0xc52e7
jmp 0xc52c8
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xc5292
jmp 0xc52d5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc5248
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
| ft_boolean_check_syntax_string:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_20]
cmp dword ptr [rax+98h], 1
jz short loc_C520A
jmp short $+2
loc_C51FF:
jmp short $+2
loc_C5201:
mov [rbp+var_1], 1
jmp loc_C52E7
loc_C520A:
cmp [rbp+var_10], 0
jz short loc_C5238
mov rax, [rbp+var_18]
add rax, 1
cmp rax, 0Fh
jnz short loc_C5238
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
cmp eax, 20h ; ' '
jz short loc_C5241
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
cmp eax, 20h ; ' '
jz short loc_C5241
loc_C5238:
mov [rbp+var_1], 1
jmp loc_C52E7
loc_C5241:
mov [rbp+var_24], 0
loc_C5248:
mov eax, [rbp+var_24]
cmp rax, 0Fh
jnb loc_C52E3
mov rax, [rbp+var_10]
mov ecx, [rbp+var_24]
movzx eax, byte ptr [rax+rcx]
cmp eax, 7Fh
jg short loc_C5285
mov rax, [rbp+var_20]
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
mov edx, [rbp+var_24]
movzx ecx, byte ptr [rcx+rdx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 7
cmp eax, 0
jz short loc_C528B
loc_C5285:
mov [rbp+var_1], 1
jmp short loc_C52E7
loc_C528B:
mov [rbp+var_28], 0
loc_C5292:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_24]
jnb short loc_C52D3
mov rax, [rbp+var_10]
mov ecx, [rbp+var_24]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_10]
mov edx, [rbp+var_28]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jnz short loc_C52C6
cmp [rbp+var_24], 0Bh
jnz short loc_C52C0
cmp [rbp+var_28], 0Ah
jz short loc_C52C6
loc_C52C0:
mov [rbp+var_1], 1
jmp short loc_C52E7
loc_C52C6:
jmp short $+2
loc_C52C8:
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_28], eax
jmp short loc_C5292
loc_C52D3:
jmp short $+2
loc_C52D5:
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp loc_C5248
loc_C52E3:
mov [rbp+var_1], 0
loc_C52E7:
mov al, [rbp+var_1]
pop rbp
retn
| char ft_boolean_check_syntax_string(_BYTE *a1, long long a2, long long a3)
{
unsigned int j; // [rsp+0h] [rbp-28h]
unsigned int i; // [rsp+4h] [rbp-24h]
if ( *(_DWORD *)(a3 + 152) != 1 )
return 1;
if ( !a1 || a2 != 14 || *a1 != 32 && a1[1] != 32 )
return 1;
for ( i = 0; i < 0xFuLL; ++i )
{
if ( (unsigned __int8)a1[i] > 0x7Fu || (*(_BYTE *)(*(_QWORD *)(a3 + 64) + (unsigned __int8)a1[i] + 1LL) & 7) != 0 )
return 1;
for ( j = 0; j < i; ++j )
{
if ( a1[i] == a1[j] && (i != 11 || j != 10) )
return 1;
}
}
return 0;
}
| ft_boolean_check_syntax_string:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x98],0x1
JZ 0x001c520a
JMP 0x001c51ff
LAB_001c51ff:
JMP 0x001c5201
LAB_001c5201:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001c52e7
LAB_001c520a:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001c5238
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
CMP RAX,0xf
JNZ 0x001c5238
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x20
JZ 0x001c5241
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x20
JZ 0x001c5241
LAB_001c5238:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001c52e7
LAB_001c5241:
MOV dword ptr [RBP + -0x24],0x0
LAB_001c5248:
MOV EAX,dword ptr [RBP + -0x24]
CMP RAX,0xf
JNC 0x001c52e3
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x24]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x7f
JG 0x001c5285
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x7
CMP EAX,0x0
JZ 0x001c528b
LAB_001c5285:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001c52e7
LAB_001c528b:
MOV dword ptr [RBP + -0x28],0x0
LAB_001c5292:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x24]
JNC 0x001c52d3
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x24]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JNZ 0x001c52c6
CMP dword ptr [RBP + -0x24],0xb
JNZ 0x001c52c0
CMP dword ptr [RBP + -0x28],0xa
JZ 0x001c52c6
LAB_001c52c0:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001c52e7
LAB_001c52c6:
JMP 0x001c52c8
LAB_001c52c8:
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001c5292
LAB_001c52d3:
JMP 0x001c52d5
LAB_001c52d5:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001c5248
LAB_001c52e3:
MOV byte ptr [RBP + -0x1],0x0
LAB_001c52e7:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int1 ft_boolean_check_syntax_string(char *param_1,long param_2,long param_3)
{
uint local_30;
uint local_2c;
int1 local_9;
if (*(int *)(param_3 + 0x98) == 1) {
if (((param_1 == (char *)0x0) || (param_2 != 0xe)) || ((*param_1 != ' ' && (param_1[1] != ' ')))
) {
local_9 = 1;
}
else {
for (local_2c = 0; local_2c < 0xf; local_2c = local_2c + 1) {
if ((0x7f < (byte)param_1[local_2c]) ||
((*(byte *)(*(long *)(param_3 + 0x40) + 1 + (ulong)(byte)param_1[local_2c]) & 7) != 0)) {
return 1;
}
for (local_30 = 0; local_30 < local_2c; local_30 = local_30 + 1) {
if ((param_1[local_2c] == param_1[local_30]) && ((local_2c != 0xb || (local_30 != 10)))) {
return 1;
}
}
}
local_9 = 0;
}
}
else {
local_9 = 1;
}
return local_9;
}
| |
54,748 | mi_fix_status | eloqsql/storage/myisam/mi_locking.c | void mi_fix_status(MI_INFO *org_table, MI_INFO *new_table)
{
DBUG_ENTER("mi_fix_status");
if (!new_table)
{
/* First in group. Set state as in mi_get_status() */
org_table->state= &org_table->save_state;
}
else
{
/* Set new_table to use state from org_table (first lock of this table) */
new_table->state= org_table->state;
}
DBUG_VOID_RETURN;
} | O0 | c | mi_fix_status:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb0df5
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xb0e05
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xb0e07
jmp 0xb0e09
popq %rbp
retq
nopl (%rax,%rax)
| mi_fix_status:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
cmp [rbp+var_10], 0
jnz short loc_B0DF5
mov rcx, [rbp+var_8]
add rcx, 10h
mov rax, [rbp+var_8]
mov [rax+8], rcx
jmp short loc_B0E05
loc_B0DF5:
mov rax, [rbp+var_8]
mov rcx, [rax+8]
mov rax, [rbp+var_10]
mov [rax+8], rcx
loc_B0E05:
jmp short $+2
loc_B0E07:
jmp short $+2
loc_B0E09:
pop rbp
retn
| long long mi_fix_status(long long a1, long long a2)
{
long long result; // rax
if ( a2 )
{
result = a2;
*(_QWORD *)(a2 + 8) = *(_QWORD *)(a1 + 8);
}
else
{
result = a1;
*(_QWORD *)(a1 + 8) = a1 + 16;
}
return result;
}
| mi_fix_status:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x001b0df5
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x10
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001b0e05
LAB_001b0df5:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
LAB_001b0e05:
JMP 0x001b0e07
LAB_001b0e07:
JMP 0x001b0e09
LAB_001b0e09:
POP RBP
RET
|
void mi_fix_status(long param_1,long param_2)
{
if (param_2 == 0) {
*(long *)(param_1 + 8) = param_1 + 0x10;
}
else {
*(int8 *)(param_2 + 8) = *(int8 *)(param_1 + 8);
}
return;
}
| |
54,749 | minja::IfTemplateToken::~IfTemplateToken() | monkey531[P]llama/common/minja.hpp | IfTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && c) : TemplateToken(Type::If, location, pre, post), condition(std::move(c)) {} | O3 | cpp | minja::IfTemplateToken::~IfTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x91f09(%rip), %rax # 0x12cb30
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x9ac3c
callq 0x70324
leaq 0x916a5(%rip), %rax # 0x12c2e8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9ac58
callq 0x70324
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1ba20
| _ZN5minja15IfTemplateTokenD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja15IfTemplateTokenE; `vtable for'minja::IfTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_9AC3C
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9AC3C:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_9AC58
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9AC58:
mov esi, 40h ; '@'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void minja::IfTemplateToken::~IfTemplateToken(minja::IfTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::IfTemplateToken + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x40uLL);
}
| ~IfTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22cb30]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x0019ac3c
CALL 0x00170324
LAB_0019ac3c:
LEA RAX,[0x22c2e8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x0019ac58
CALL 0x00170324
LAB_0019ac58:
MOV ESI,0x40
MOV RDI,RBX
POP RBX
JMP 0x0011ba20
|
/* minja::IfTemplateToken::~IfTemplateToken() */
void __thiscall minja::IfTemplateToken::~IfTemplateToken(IfTemplateToken *this)
{
*(int ***)this = &PTR__IfTemplateToken_0022cb40;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38));
}
*(int ***)this = &PTR__TemplateToken_0022c2f8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
}
operator_delete(this,0x40);
return;
}
| |
54,750 | mysql_close@libmariadbclient_18 | eloqsql/libmariadb/libmariadb/mariadb_lib.c | void STDCALL
mysql_close(MYSQL *mysql)
{
if (mysql) /* Some simple safety */
{
if (mysql->extension && mysql->extension->conn_hdlr)
{
MA_CONNECTION_HANDLER *p= mysql->extension->conn_hdlr;
if (p->plugin->close)
p->plugin->close(mysql);
free(p);
/* Fix for CONC-294: Since we already called plugin->close function
we need to prevent that mysql_close_slow_part (which sends COM_QUIT
to the server) will be handled by plugin again. */
mysql->extension->conn_hdlr= NULL;
}
if (mysql->methods)
mysql->methods->db_close(mysql);
/* reset the connection in all active statements */
ma_invalidate_stmts(mysql, "mysql_close()");
mysql_close_memory(mysql);
mysql_close_options(mysql);
ma_clear_session_state(mysql);
if (mysql->net.extension)
{
if (compression_plugin(&mysql->net))
compression_plugin(&mysql->net)->free_ctx(compression_ctx(&mysql->net));
free(mysql->net.extension);
}
mysql->host_info=mysql->user=mysql->passwd=mysql->db=0;
/* Clear pointers for better safety */
memset((char*) &mysql->options, 0, sizeof(mysql->options));
if (mysql->extension)
free(mysql->extension);
/* Clear pointers for better safety */
mysql->net.extension = NULL;
mysql->extension = NULL;
mysql->net.pvio= 0;
if (mysql->free_me)
free(mysql);
}
return;
} | O0 | c | mysql_close@libmariadbclient_18:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x28756
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4f0(%rax)
je 0x28602
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rax
cmpq $0x0, (%rax)
je 0x28602
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x60(%rax)
je 0x285e7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
callq 0x17710
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4d0(%rax)
je 0x28625
movq -0x8(%rbp), %rax
movq 0x4d0(%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
leaq 0x2a912(%rip), %rsi # 0x52f42
callq 0x28760
movq -0x8(%rbp), %rdi
callq 0x27f70
movq -0x8(%rbp), %rdi
callq 0x28070
movq -0x8(%rbp), %rdi
callq 0x28d80
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2a0(%rax)
je 0x286a4
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x28694
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rax
movq 0x10(%rax), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x2a0(%rcx), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rdi
callq 0x17710
movq -0x8(%rbp), %rax
movq $0x0, 0x2e8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x2c0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x2b8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x2d8(%rax)
movq -0x8(%rbp), %rdi
addq $0x390, %rdi # imm = 0x390
xorl %esi, %esi
movl $0xf8, %edx
callq 0x17330
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4f0(%rax)
je 0x28715
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rdi
callq 0x17710
movq -0x8(%rbp), %rax
movq $0x0, 0x2a0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x4f0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x48c(%rax)
je 0x28754
movq -0x8(%rbp), %rdi
callq 0x17710
jmp 0x28756
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| mysql_close@libmariadbclient_18:
push rbp; Alternative name is 'mysql_close'
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
cmp [rbp+var_8], 0
jz loc_28756
mov rax, [rbp+var_8]
cmp qword ptr [rax+4F0h], 0
jz short loc_28602
mov rax, [rbp+var_8]
mov rax, [rax+4F0h]
cmp qword ptr [rax], 0
jz short loc_28602
mov rax, [rbp+var_8]
mov rax, [rax+4F0h]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
cmp qword ptr [rax+60h], 0
jz short loc_285E7
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+60h]
mov rdi, [rbp+var_8]
call rax
loc_285E7:
mov rdi, [rbp+var_10]
call _free
mov rax, [rbp+var_8]
mov rax, [rax+4F0h]
mov qword ptr [rax], 0
loc_28602:
mov rax, [rbp+var_8]
cmp qword ptr [rax+4D0h], 0
jz short loc_28625
mov rax, [rbp+var_8]
mov rax, [rax+4D0h]
mov rax, [rax+8]
mov rdi, [rbp+var_8]
call rax
loc_28625:
mov rdi, [rbp+var_8]
lea rsi, aMysqlClose_0; "mysql_close()"
call ma_invalidate_stmts
mov rdi, [rbp+var_8]
call mysql_close_memory
mov rdi, [rbp+var_8]
call mysql_close_options
mov rdi, [rbp+var_8]
call ma_clear_session_state
mov rax, [rbp+var_8]
cmp qword ptr [rax+2A0h], 0
jz short loc_286A4
mov rax, [rbp+var_8]
mov rax, [rax+2A0h]
cmp qword ptr [rax+10h], 0
jz short loc_28694
mov rax, [rbp+var_8]
mov rax, [rax+2A0h]
mov rax, [rax+10h]
mov rax, [rax+60h]
mov rcx, [rbp+var_8]
mov rcx, [rcx+2A0h]
mov rdi, [rcx+8]
call rax
loc_28694:
mov rax, [rbp+var_8]
mov rdi, [rax+2A0h]
call _free
loc_286A4:
mov rax, [rbp+var_8]
mov qword ptr [rax+2E8h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+2C0h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+2B8h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+2D8h], 0
mov rdi, [rbp+var_8]
add rdi, 390h
xor esi, esi
mov edx, 0F8h
call _memset
mov rax, [rbp+var_8]
cmp qword ptr [rax+4F0h], 0
jz short loc_28715
mov rax, [rbp+var_8]
mov rdi, [rax+4F0h]
call _free
loc_28715:
mov rax, [rbp+var_8]
mov qword ptr [rax+2A0h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+4F0h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
mov rax, [rbp+var_8]
cmp byte ptr [rax+48Ch], 0
jz short loc_28754
mov rdi, [rbp+var_8]
call _free
loc_28754:
jmp short $+2
loc_28756:
add rsp, 10h
pop rbp
retn
| long long mysql_close_libmariadbclient_18(long long a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-10h]
if ( a1 )
{
if ( *(_QWORD *)(a1 + 1264) && **(_QWORD **)(a1 + 1264) )
{
v2 = **(_QWORD **)(a1 + 1264);
if ( *(_QWORD *)(*(_QWORD *)v2 + 96LL) )
(*(void ( **)(long long))(*(_QWORD *)v2 + 96LL))(a1);
free(v2);
**(_QWORD **)(a1 + 1264) = 0LL;
}
if ( *(_QWORD *)(a1 + 1232) )
(*(void ( **)(long long))(*(_QWORD *)(a1 + 1232) + 8LL))(a1);
ma_invalidate_stmts(a1, "mysql_close()");
mysql_close_memory((_QWORD *)a1);
mysql_close_options((_QWORD *)a1);
ma_clear_session_state(a1);
if ( *(_QWORD *)(a1 + 672) )
{
if ( *(_QWORD *)(*(_QWORD *)(a1 + 672) + 16LL) )
(*(void ( **)(_QWORD))(*(_QWORD *)(*(_QWORD *)(a1 + 672) + 16LL) + 96LL))(*(_QWORD *)(*(_QWORD *)(a1 + 672) + 8LL));
free(*(_QWORD *)(a1 + 672));
}
*(_QWORD *)(a1 + 744) = 0LL;
*(_QWORD *)(a1 + 704) = 0LL;
*(_QWORD *)(a1 + 696) = 0LL;
*(_QWORD *)(a1 + 728) = 0LL;
memset(a1 + 912, 0LL, 248LL);
if ( *(_QWORD *)(a1 + 1264) )
free(*(_QWORD *)(a1 + 1264));
*(_QWORD *)(a1 + 672) = 0LL;
*(_QWORD *)(a1 + 1264) = 0LL;
*(_QWORD *)a1 = 0LL;
result = a1;
if ( *(_BYTE *)(a1 + 1164) )
return free(a1);
}
return result;
}
| mysql_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00128756
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x4f0],0x0
JZ 0x00128602
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x4f0]
CMP qword ptr [RAX],0x0
JZ 0x00128602
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x001285e7
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x60]
MOV RDI,qword ptr [RBP + -0x8]
CALL RAX
LAB_001285e7:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00117710
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV qword ptr [RAX],0x0
LAB_00128602:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x4d0],0x0
JZ 0x00128625
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x8]
CALL RAX
LAB_00128625:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x152f42]
CALL 0x00128760
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00127f70
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00128070
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00128d80
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x2a0],0x0
JZ 0x001286a4
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2a0]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x00128694
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x60]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x2a0]
MOV RDI,qword ptr [RCX + 0x8]
CALL RAX
LAB_00128694:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x2a0]
CALL 0x00117710
LAB_001286a4:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2e8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2c0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2b8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2d8],0x0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x390
XOR ESI,ESI
MOV EDX,0xf8
CALL 0x00117330
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x4f0],0x0
JZ 0x00128715
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x4f0]
CALL 0x00117710
LAB_00128715:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2a0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x4f0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x48c],0x0
JZ 0x00128754
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00117710
LAB_00128754:
JMP 0x00128756
LAB_00128756:
ADD RSP,0x10
POP RBP
RET
|
void mysql_close(int8 *param_1)
{
long *__ptr;
if (param_1 != (int8 *)0x0) {
if ((param_1[0x9e] != 0) && (*(long *)param_1[0x9e] != 0)) {
__ptr = *(long **)param_1[0x9e];
if (*(long *)(*__ptr + 0x60) != 0) {
(**(code **)(*__ptr + 0x60))(param_1);
}
free(__ptr);
*(int8 *)param_1[0x9e] = 0;
}
if (param_1[0x9a] != 0) {
(**(code **)(param_1[0x9a] + 8))(param_1);
}
ma_invalidate_stmts(param_1);
mysql_close_memory(param_1);
mysql_close_options(param_1);
ma_clear_session_state(param_1);
if (param_1[0x54] != 0) {
if (*(long *)(param_1[0x54] + 0x10) != 0) {
(**(code **)(*(long *)(param_1[0x54] + 0x10) + 0x60))(*(int8 *)(param_1[0x54] + 8));
}
free((void *)param_1[0x54]);
}
param_1[0x5d] = 0;
param_1[0x58] = 0;
param_1[0x57] = 0;
param_1[0x5b] = 0;
memset(param_1 + 0x72,0,0xf8);
if (param_1[0x9e] != 0) {
free((void *)param_1[0x9e]);
}
param_1[0x54] = 0;
param_1[0x9e] = 0;
*param_1 = 0;
if (*(char *)((long)param_1 + 0x48c) != '\0') {
free(param_1);
}
}
return;
}
| |
54,751 | mz_inflateReset | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | int mz_inflateReset(mz_streamp pStream) {
inflate_state *pDecomp;
if (!pStream)
return MZ_STREAM_ERROR;
pStream->data_type = 0;
pStream->adler = 0;
pStream->msg = NULL;
pStream->total_in = 0;
pStream->total_out = 0;
pStream->reserved = 0;
pDecomp = (inflate_state *)pStream->state;
tinfl_init(&pDecomp->m_decomp);
pDecomp->m_dict_ofs = 0;
pDecomp->m_dict_avail = 0;
pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
pDecomp->m_first_call = 1;
pDecomp->m_has_flushed = 0;
/* pDecomp->m_window_bits = window_bits */;
return MZ_OK;
} | O0 | c | mz_inflateReset:
movq %rdi, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0xf55aa
movl $0xfffffffe, -0x4(%rsp) # imm = 0xFFFFFFFE
jmp 0xf5663
movq -0x10(%rsp), %rax
movl $0x0, 0x58(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x60(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x68(%rax)
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movl $0x0, (%rax)
movq -0x18(%rsp), %rax
movl $0x0, 0x2af8(%rax)
movq -0x18(%rsp), %rax
movl $0x0, 0x2afc(%rax)
movq -0x18(%rsp), %rax
movl $0x1, 0xab0c(%rax)
movq -0x18(%rsp), %rax
movl $0x1, 0x2b00(%rax)
movq -0x18(%rsp), %rax
movl $0x0, 0x2b04(%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
| mz_inflateReset:
mov [rsp+var_10], rdi
cmp [rsp+var_10], 0
jnz short loc_F55AA
mov [rsp+var_4], 0FFFFFFFEh
jmp loc_F5663
loc_F55AA:
mov rax, [rsp+var_10]
mov dword ptr [rax+58h], 0
mov rax, [rsp+var_10]
mov qword ptr [rax+60h], 0
mov rax, [rsp+var_10]
mov qword ptr [rax+30h], 0
mov rax, [rsp+var_10]
mov qword ptr [rax+10h], 0
mov rax, [rsp+var_10]
mov qword ptr [rax+28h], 0
mov rax, [rsp+var_10]
mov qword ptr [rax+68h], 0
mov rax, [rsp+var_10]
mov rax, [rax+38h]
mov [rsp+var_18], rax
mov rax, [rsp+var_18]
mov dword ptr [rax], 0
mov rax, [rsp+var_18]
mov dword ptr [rax+2AF8h], 0
mov rax, [rsp+var_18]
mov dword ptr [rax+2AFCh], 0
mov rax, [rsp+var_18]
mov dword ptr [rax+0AB0Ch], 1
mov rax, [rsp+var_18]
mov dword ptr [rax+2B00h], 1
mov rax, [rsp+var_18]
mov dword ptr [rax+2B04h], 0
mov [rsp+var_4], 0
loc_F5663:
mov eax, [rsp+var_4]
retn
| long long mz_inflateReset(long long a1)
{
_DWORD *v2; // [rsp+0h] [rbp-18h]
if ( a1 )
{
*(_DWORD *)(a1 + 88) = 0;
*(_QWORD *)(a1 + 96) = 0LL;
*(_QWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
*(_QWORD *)(a1 + 104) = 0LL;
v2 = *(_DWORD **)(a1 + 56);
*v2 = 0;
v2[2750] = 0;
v2[2751] = 0;
v2[10947] = 1;
v2[2752] = 1;
v2[2753] = 0;
return 0;
}
else
{
return (unsigned int)-2;
}
}
| mz_inflateReset:
MOV qword ptr [RSP + -0x10],RDI
CMP qword ptr [RSP + -0x10],0x0
JNZ 0x001f55aa
MOV dword ptr [RSP + -0x4],0xfffffffe
JMP 0x001f5663
LAB_001f55aa:
MOV RAX,qword ptr [RSP + -0x10]
MOV dword ptr [RAX + 0x58],0x0
MOV RAX,qword ptr [RSP + -0x10]
MOV qword ptr [RAX + 0x60],0x0
MOV RAX,qword ptr [RSP + -0x10]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RSP + -0x10]
MOV qword ptr [RAX + 0x10],0x0
MOV RAX,qword ptr [RSP + -0x10]
MOV qword ptr [RAX + 0x28],0x0
MOV RAX,qword ptr [RSP + -0x10]
MOV qword ptr [RAX + 0x68],0x0
MOV RAX,qword ptr [RSP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RSP + -0x18],RAX
MOV RAX,qword ptr [RSP + -0x18]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RSP + -0x18]
MOV dword ptr [RAX + 0x2af8],0x0
MOV RAX,qword ptr [RSP + -0x18]
MOV dword ptr [RAX + 0x2afc],0x0
MOV RAX,qword ptr [RSP + -0x18]
MOV dword ptr [RAX + 0xab0c],0x1
MOV RAX,qword ptr [RSP + -0x18]
MOV dword ptr [RAX + 0x2b00],0x1
MOV RAX,qword ptr [RSP + -0x18]
MOV dword ptr [RAX + 0x2b04],0x0
MOV dword ptr [RSP + -0x4],0x0
LAB_001f5663:
MOV EAX,dword ptr [RSP + -0x4]
RET
|
int4 mz_inflateReset(long param_1)
{
int4 *puVar1;
int4 local_4;
if (param_1 == 0) {
local_4 = 0xfffffffe;
}
else {
*(int4 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x60) = 0;
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x68) = 0;
puVar1 = *(int4 **)(param_1 + 0x38);
*puVar1 = 0;
puVar1[0xabe] = 0;
puVar1[0xabf] = 0;
puVar1[0x2ac3] = 1;
puVar1[0xac0] = 1;
puVar1[0xac1] = 0;
local_4 = 0;
}
return local_4;
}
| |
54,752 | mz_inflateReset | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | int mz_inflateReset(mz_streamp pStream) {
inflate_state *pDecomp;
if (!pStream)
return MZ_STREAM_ERROR;
pStream->data_type = 0;
pStream->adler = 0;
pStream->msg = NULL;
pStream->total_in = 0;
pStream->total_out = 0;
pStream->reserved = 0;
pDecomp = (inflate_state *)pStream->state;
tinfl_init(&pDecomp->m_decomp);
pDecomp->m_dict_ofs = 0;
pDecomp->m_dict_avail = 0;
pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
pDecomp->m_first_call = 1;
pDecomp->m_has_flushed = 0;
/* pDecomp->m_window_bits = window_bits */;
return MZ_OK;
} | O1 | c | mz_inflateReset:
testq %rdi, %rdi
je 0x7f4ad
xorl %eax, %eax
movl %eax, 0x58(%rdi)
movq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x60(%rdi)
movq 0x38(%rdi), %rcx
movl %eax, (%rcx)
movl $0x1, 0xab0c(%rcx)
movaps 0x3bc1b(%rip), %xmm0 # 0xbb0c0
movups %xmm0, 0x2af8(%rcx)
retq
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
retq
| mz_inflateReset:
test rdi, rdi
jz short loc_7F4AD
xor eax, eax
mov [rdi+58h], eax
mov qword ptr [rdi+10h], 0
xorps xmm0, xmm0
movups xmmword ptr [rdi+28h], xmm0
movups xmmword ptr [rdi+60h], xmm0
mov rcx, [rdi+38h]
mov [rcx], eax
mov dword ptr [rcx+0AB0Ch], 1
movaps xmm0, cs:xmmword_BB0C0
movups xmmword ptr [rcx+2AF8h], xmm0
retn
loc_7F4AD:
mov eax, 0FFFFFFFEh
retn
| long long mz_inflateReset(long long a1)
{
long long result; // rax
long long v2; // rcx
if ( !a1 )
return 4294967294LL;
result = 0LL;
*(_DWORD *)(a1 + 88) = 0;
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 40) = 0LL;
*(_OWORD *)(a1 + 96) = 0LL;
v2 = *(_QWORD *)(a1 + 56);
*(_DWORD *)v2 = 0;
*(_DWORD *)(v2 + 43788) = 1;
*(_OWORD *)(v2 + 11000) = xmmword_BB0C0;
return result;
}
| |||
54,753 | mz_inflateReset | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | int mz_inflateReset(mz_streamp pStream) {
inflate_state *pDecomp;
if (!pStream)
return MZ_STREAM_ERROR;
pStream->data_type = 0;
pStream->adler = 0;
pStream->msg = NULL;
pStream->total_in = 0;
pStream->total_out = 0;
pStream->reserved = 0;
pDecomp = (inflate_state *)pStream->state;
tinfl_init(&pDecomp->m_decomp);
pDecomp->m_dict_ofs = 0;
pDecomp->m_dict_avail = 0;
pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
pDecomp->m_first_call = 1;
pDecomp->m_has_flushed = 0;
/* pDecomp->m_window_bits = window_bits */;
return MZ_OK;
} | O2 | c | mz_inflateReset:
testq %rdi, %rdi
je 0x5af50
andl $0x0, 0x58(%rdi)
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x60(%rdi)
movq 0x38(%rdi), %rax
andl $0x0, (%rax)
movl $0x1, 0xab0c(%rax)
movaps 0x4468a(%rip), %xmm0 # 0x9f5d0
movups %xmm0, 0x2af8(%rax)
xorl %eax, %eax
retq
pushq $-0x2
popq %rax
retq
| mz_inflateReset:
test rdi, rdi
jz short loc_5AF50
and dword ptr [rdi+58h], 0
and qword ptr [rdi+10h], 0
xorps xmm0, xmm0
movups xmmword ptr [rdi+28h], xmm0
movups xmmword ptr [rdi+60h], xmm0
mov rax, [rdi+38h]
and dword ptr [rax], 0
mov dword ptr [rax+0AB0Ch], 1
movaps xmm0, cs:xmmword_9F5D0
movups xmmword ptr [rax+2AF8h], xmm0
xor eax, eax
retn
loc_5AF50:
push 0FFFFFFFFFFFFFFFEh
pop rax
retn
| long long mz_inflateReset(long long a1)
{
long long v1; // rax
if ( !a1 )
return -2LL;
*(_DWORD *)(a1 + 88) = 0;
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 40) = 0LL;
*(_OWORD *)(a1 + 96) = 0LL;
v1 = *(_QWORD *)(a1 + 56);
*(_DWORD *)v1 = 0;
*(_DWORD *)(v1 + 43788) = 1;
*(_OWORD *)(v1 + 11000) = xmmword_9F5D0;
return 0LL;
}
| mz_inflateReset:
TEST RDI,RDI
JZ 0x0015af50
AND dword ptr [RDI + 0x58],0x0
AND qword ptr [RDI + 0x10],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x28],XMM0
MOVUPS xmmword ptr [RDI + 0x60],XMM0
MOV RAX,qword ptr [RDI + 0x38]
AND dword ptr [RAX],0x0
MOV dword ptr [RAX + 0xab0c],0x1
MOVAPS XMM0,xmmword ptr [0x0019f5d0]
MOVUPS xmmword ptr [RAX + 0x2af8],XMM0
XOR EAX,EAX
RET
LAB_0015af50:
PUSH -0x2
POP RAX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 mz_inflateReset(long param_1)
{
int4 *puVar1;
int8 uVar2;
if (param_1 != 0) {
*(int4 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x60) = 0;
*(int8 *)(param_1 + 0x68) = 0;
puVar1 = *(int4 **)(param_1 + 0x38);
*puVar1 = 0;
puVar1[0x2ac3] = 1;
uVar2 = _UNK_0019f5d8;
*(int8 *)(puVar1 + 0xabe) = _DAT_0019f5d0;
*(int8 *)(puVar1 + 0xac0) = uVar2;
return 0;
}
return 0xfffffffffffffffe;
}
| |
54,754 | mz_inflateReset | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | int mz_inflateReset(mz_streamp pStream) {
inflate_state *pDecomp;
if (!pStream)
return MZ_STREAM_ERROR;
pStream->data_type = 0;
pStream->adler = 0;
pStream->msg = NULL;
pStream->total_in = 0;
pStream->total_out = 0;
pStream->reserved = 0;
pDecomp = (inflate_state *)pStream->state;
tinfl_init(&pDecomp->m_decomp);
pDecomp->m_dict_ofs = 0;
pDecomp->m_dict_avail = 0;
pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
pDecomp->m_first_call = 1;
pDecomp->m_has_flushed = 0;
/* pDecomp->m_window_bits = window_bits */;
return MZ_OK;
} | O3 | c | mz_inflateReset:
testq %rdi, %rdi
je 0x7e426
xorl %eax, %eax
movl %eax, 0x58(%rdi)
movq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x60(%rdi)
movq 0x38(%rdi), %rcx
movl %eax, (%rcx)
movl $0x1, 0xab0c(%rcx)
movaps 0x3bca2(%rip), %xmm0 # 0xba0c0
movups %xmm0, 0x2af8(%rcx)
retq
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
retq
| mz_inflateReset:
test rdi, rdi
jz short loc_7E426
xor eax, eax
mov [rdi+58h], eax
mov qword ptr [rdi+10h], 0
xorps xmm0, xmm0
movups xmmword ptr [rdi+28h], xmm0
movups xmmword ptr [rdi+60h], xmm0
mov rcx, [rdi+38h]
mov [rcx], eax
mov dword ptr [rcx+0AB0Ch], 1
movaps xmm0, cs:xmmword_BA0C0
movups xmmword ptr [rcx+2AF8h], xmm0
retn
loc_7E426:
mov eax, 0FFFFFFFEh
retn
| long long mz_inflateReset(long long a1)
{
long long result; // rax
long long v2; // rcx
if ( !a1 )
return 4294967294LL;
result = 0LL;
*(_DWORD *)(a1 + 88) = 0;
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 40) = 0LL;
*(_OWORD *)(a1 + 96) = 0LL;
v2 = *(_QWORD *)(a1 + 56);
*(_DWORD *)v2 = 0;
*(_DWORD *)(v2 + 43788) = 1;
*(_OWORD *)(v2 + 11000) = xmmword_BA0C0;
return result;
}
| |||
54,755 | my_casedn_utf8mb4 | eloqsql/strings/ctype-utf8.c | static size_t
my_casedn_utf8mb4(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_mb_wc_utf8mb4(cs, &wc,
(uchar*) src, (uchar*) srcend)) > 0)
{
my_tolower_utf8mb4(uni_plane, &wc);
if ((dstres= my_wc_mb_utf8mb4(cs, wc, (uchar*) dst, (uchar*) dstend)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
return (size_t) (dst - dst0);
} | O0 | c | my_casedn_utf8mb4:
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 0xc3f0a
jmp 0xc3f0c
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0xc3f3c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0xc3a80
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0xc3f45
jmp 0xc3f98
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc7ee0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0xc3ab0
movl %eax, -0x38(%rbp)
cmpl $0x0, %eax
jg 0xc3f71
jmp 0xc3f98
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 0xc3f0c
movq -0x20(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| my_casedn_utf8mb4:
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_C3F0A:
jmp short $+2
loc_C3F0C:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_59], al
jnb short loc_C3F3C
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_mb_wc_utf8mb4
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_59], al
loc_C3F3C:
mov al, [rbp+var_59]
test al, 1
jnz short loc_C3F45
jmp short loc_C3F98
loc_C3F45:
mov rdi, [rbp+var_58]
lea rsi, [rbp+var_30]
call my_tolower_utf8mb4
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_wc_mb_utf8mb4
mov [rbp+var_38], eax
cmp eax, 0
jg short loc_C3F71
jmp short loc_C3F98
loc_C3F71:
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_C3F0C
loc_C3F98:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_50]
sub rax, rcx
add rsp, 60h
pop rbp
retn
| _BYTE * my_casedn_utf8mb4(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_mb_wc_utf8mb4(v18, (long long)v14, v17, v11, a5, a6);
v7 = v13 > 0;
}
if ( !v7 )
break;
my_tolower_utf8mb4(v8, v14);
v12 = my_wc_mb_utf8mb4(v18, v14[0], v15, v10);
if ( v12 <= 0 )
break;
v17 += v13;
v15 += v12;
}
return (_BYTE *)(v15 - a4);
}
| my_casedn_utf8mb4:
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 0x001c3f0a
LAB_001c3f0a:
JMP 0x001c3f0c
LAB_001c3f0c:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x59],AL
JNC 0x001c3f3c
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x001c3a80
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x59],AL
LAB_001c3f3c:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x001c3f45
JMP 0x001c3f98
LAB_001c3f45:
MOV RDI,qword ptr [RBP + -0x58]
LEA RSI,[RBP + -0x30]
CALL 0x001c7ee0
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 0x001c3ab0
MOV dword ptr [RBP + -0x38],EAX
CMP EAX,0x0
JG 0x001c3f71
JMP 0x001c3f98
LAB_001c3f71:
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 0x001c3f0c
LAB_001c3f98:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long my_casedn_utf8mb4(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_mb_wc_utf8mb4(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_tolower_utf8mb4(uVar1,&local_38);
iVar3 = my_wc_mb_utf8mb4(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;
}
| |
54,756 | ggml_opt_result_loss | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-opt.cpp | void ggml_opt_result_loss(ggml_opt_result_t result, double * loss, double * unc) {
const int64_t nbatches = result->loss.size(); // Number of physical batches.
if (nbatches == 0) {
*loss = 0.0;
*unc = NAN;
return;
}
double sum = 0.0;
double sum_squared = 0.0;
for (const float & loss : result->loss) {
// If the loss is per datapoint it was scaled by 1.0f/opt_period for each physical batch.
const float loss_scaled = result->loss_per_datapoint ? loss*result->opt_period : loss;
sum += loss_scaled;
sum_squared += loss_scaled*loss_scaled;
}
const double mean = sum/nbatches;
*loss = result->loss_per_datapoint ? mean : sum;
if (!unc) {
return;
}
if (nbatches < 2) {
*unc = NAN;
return;
}
const double var_sum = sum_squared/nbatches - mean*mean; // variance without Bessel's correction, i.e. nbatches/(nbatches-1)
*unc = result->loss_per_datapoint ? sqrt(var_sum / (nbatches - 1)) : sqrt(var_sum * nbatches/(nbatches - 1));
} | O1 | cpp | ggml_opt_result_loss:
pushq %rbx
movq %rdx, %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
je 0x2ba7c
sarq $0x2, %rax
movb 0x48(%rdi), %r8b
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
movss (%rcx), %xmm2
testb %r8b, %r8b
je 0x2b9fb
xorps %xmm3, %xmm3
cvtsi2ssq 0x40(%rdi), %xmm3
mulss %xmm3, %xmm2
xorps %xmm3, %xmm3
cvtss2sd %xmm2, %xmm3
addsd %xmm3, %xmm1
mulss %xmm2, %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm2, %xmm0
addq $0x4, %rcx
cmpq %rdx, %rcx
jne 0x2b9e5
xorps %xmm2, %xmm2
cvtsi2sd %rax, %xmm2
movapd %xmm1, %xmm3
divsd %xmm2, %xmm3
movb 0x48(%rdi), %cl
movapd %xmm3, %xmm4
testb %cl, %cl
jne 0x2ba3a
movapd %xmm1, %xmm4
movsd %xmm4, (%rsi)
testq %rbx, %rbx
je 0x2ba8f
cmpq $0x2, %rax
jl 0x2ba83
divsd %xmm2, %xmm0
mulsd %xmm3, %xmm3
subsd %xmm3, %xmm0
testb %cl, %cl
jne 0x2ba5d
mulsd %xmm2, %xmm0
decq %rax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2ba91
sqrtsd %xmm0, %xmm0
jmp 0x2ba8b
movq $0x0, (%rsi)
movsd 0x24a05(%rip), %xmm0 # 0x50490
movsd %xmm0, (%rbx)
popq %rbx
retq
callq 0x17d60
jmp 0x2ba8b
| ggml_opt_result_loss:
push rbx
mov rbx, rdx
mov rcx, [rdi+8]
mov rdx, [rdi+10h]
mov rax, rdx
sub rax, rcx
jz loc_2BA7C
sar rax, 2
mov r8b, [rdi+48h]
xorpd xmm1, xmm1
xorpd xmm0, xmm0
loc_2B9E5:
movss xmm2, dword ptr [rcx]
test r8b, r8b
jz short loc_2B9FB
xorps xmm3, xmm3
cvtsi2ss xmm3, qword ptr [rdi+40h]
mulss xmm2, xmm3
loc_2B9FB:
xorps xmm3, xmm3
cvtss2sd xmm3, xmm2
addsd xmm1, xmm3
mulss xmm2, xmm2
cvtss2sd xmm2, xmm2
addsd xmm0, xmm2
add rcx, 4
cmp rcx, rdx
jnz short loc_2B9E5
xorps xmm2, xmm2
cvtsi2sd xmm2, rax
movapd xmm3, xmm1
divsd xmm3, xmm2
mov cl, [rdi+48h]
movapd xmm4, xmm3
test cl, cl
jnz short loc_2BA3A
movapd xmm4, xmm1
loc_2BA3A:
movsd qword ptr [rsi], xmm4
test rbx, rbx
jz short loc_2BA8F
cmp rax, 2
jl short loc_2BA83
divsd xmm0, xmm2
mulsd xmm3, xmm3
subsd xmm0, xmm3
test cl, cl
jnz short loc_2BA5D
mulsd xmm0, xmm2
loc_2BA5D:
dec rax
xorps xmm1, xmm1
cvtsi2sd xmm1, rax
divsd xmm0, xmm1
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jb short loc_2BA91
sqrtsd xmm0, xmm0
jmp short loc_2BA8B
loc_2BA7C:
mov qword ptr [rsi], 0
loc_2BA83:
movsd xmm0, cs:qword_50490
loc_2BA8B:
movsd qword ptr [rbx], xmm0
loc_2BA8F:
pop rbx
retn
loc_2BA91:
call _sqrt
jmp short loc_2BA8B
| void ggml_opt_result_loss(long long a1, double *a2, double *a3)
{
float *v4; // rcx
long long v5; // rax
long long v6; // rax
double v7; // xmm1_8
double v8; // xmm0_8
float v9; // xmm2_4
double v10; // xmm2_8
char v11; // cl
double v12; // xmm4_8
double v13; // xmm0_8
double v14; // xmm0_8
double v15; // xmm0_8
v4 = *(float **)(a1 + 8);
v5 = *(_QWORD *)(a1 + 16) - (_QWORD)v4;
if ( !v5 )
{
*a2 = 0.0;
goto LABEL_15;
}
v6 = v5 >> 2;
v7 = 0.0;
v8 = 0.0;
do
{
v9 = *v4;
if ( *(_BYTE *)(a1 + 72) )
v9 = v9 * (float)(int)*(_QWORD *)(a1 + 64);
v7 = v7 + v9;
v8 = v8 + (float)(v9 * v9);
++v4;
}
while ( v4 != *(float **)(a1 + 16) );
v10 = (double)(int)v6;
v11 = *(_BYTE *)(a1 + 72);
v12 = v7 / (double)(int)v6;
if ( !v11 )
v12 = v7;
*a2 = v12;
if ( a3 )
{
if ( v6 >= 2 )
{
v13 = v8 / v10 - v7 / (double)(int)v6 * (v7 / (double)(int)v6);
if ( !v11 )
v13 = v13 * v10;
v14 = v13 / (double)((int)v6 - 1);
if ( v14 < 0.0 )
v15 = sqrt(v14);
else
v15 = sqrt(v14);
goto LABEL_16;
}
LABEL_15:
v15 = NAN;
LABEL_16:
*a3 = v15;
}
}
| ggml_opt_result_loss:
PUSH RBX
MOV RBX,RDX
MOV RCX,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI + 0x10]
MOV RAX,RDX
SUB RAX,RCX
JZ 0x0012ba7c
SAR RAX,0x2
MOV R8B,byte ptr [RDI + 0x48]
XORPD XMM1,XMM1
XORPD XMM0,XMM0
LAB_0012b9e5:
MOVSS XMM2,dword ptr [RCX]
TEST R8B,R8B
JZ 0x0012b9fb
XORPS XMM3,XMM3
CVTSI2SS XMM3,qword ptr [RDI + 0x40]
MULSS XMM2,XMM3
LAB_0012b9fb:
XORPS XMM3,XMM3
CVTSS2SD XMM3,XMM2
ADDSD XMM1,XMM3
MULSS XMM2,XMM2
CVTSS2SD XMM2,XMM2
ADDSD XMM0,XMM2
ADD RCX,0x4
CMP RCX,RDX
JNZ 0x0012b9e5
XORPS XMM2,XMM2
CVTSI2SD XMM2,RAX
MOVAPD XMM3,XMM1
DIVSD XMM3,XMM2
MOV CL,byte ptr [RDI + 0x48]
MOVAPD XMM4,XMM3
TEST CL,CL
JNZ 0x0012ba3a
MOVAPD XMM4,XMM1
LAB_0012ba3a:
MOVSD qword ptr [RSI],XMM4
TEST RBX,RBX
JZ 0x0012ba8f
CMP RAX,0x2
JL 0x0012ba83
DIVSD XMM0,XMM2
MULSD XMM3,XMM3
SUBSD XMM0,XMM3
TEST CL,CL
JNZ 0x0012ba5d
MULSD XMM0,XMM2
LAB_0012ba5d:
DEC RAX
XORPS XMM1,XMM1
CVTSI2SD XMM1,RAX
DIVSD XMM0,XMM1
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JC 0x0012ba91
SQRTSD XMM0,XMM0
JMP 0x0012ba8b
LAB_0012ba7c:
MOV qword ptr [RSI],0x0
LAB_0012ba83:
MOVSD XMM0,qword ptr [0x00150490]
LAB_0012ba8b:
MOVSD qword ptr [RBX],XMM0
LAB_0012ba8f:
POP RBX
RET
LAB_0012ba91:
CALL 0x00117d60
JMP 0x0012ba8b
|
void ggml_opt_result_loss(long param_1,double *param_2,double *param_3)
{
char cVar1;
long lVar2;
float *pfVar3;
double dVar4;
double dVar5;
float fVar6;
double dVar7;
double dVar8;
double dVar9;
pfVar3 = *(float **)(param_1 + 8);
lVar2 = (long)*(float **)(param_1 + 0x10) - (long)pfVar3;
if (lVar2 == 0) {
*param_2 = 0.0;
dVar5 = DAT_00150490;
}
else {
lVar2 = lVar2 >> 2;
dVar5 = 0.0;
dVar4 = 0.0;
do {
fVar6 = *pfVar3;
if (*(char *)(param_1 + 0x48) != '\0') {
fVar6 = fVar6 * (float)*(long *)(param_1 + 0x40);
}
dVar5 = dVar5 + (double)fVar6;
dVar4 = dVar4 + (double)(fVar6 * fVar6);
pfVar3 = pfVar3 + 1;
} while (pfVar3 != *(float **)(param_1 + 0x10));
dVar7 = (double)lVar2;
dVar8 = dVar5 / dVar7;
cVar1 = *(char *)(param_1 + 0x48);
dVar9 = dVar8;
if (cVar1 == '\0') {
dVar9 = dVar5;
}
*param_2 = dVar9;
if (param_3 == (double *)0x0) {
return;
}
dVar5 = DAT_00150490;
if (1 < lVar2) {
dVar5 = dVar4 / dVar7 - dVar8 * dVar8;
if (cVar1 == '\0') {
dVar5 = dVar5 * dVar7;
}
dVar5 = dVar5 / (double)(lVar2 + -1);
if (dVar5 < 0.0) {
dVar5 = sqrt(dVar5);
}
else {
dVar5 = SQRT(dVar5);
}
}
}
*param_3 = dVar5;
return;
}
| |
54,757 | string_indexof | bluesky950520[P]quickjs/quickjs.c | static int string_indexof(JSString *p1, JSString *p2, int from)
{
/* assuming 0 <= from <= p1->len */
int c, i, j, len1 = p1->len, len2 = p2->len;
if (len2 == 0)
return from;
for (i = from, c = string_get(p2, 0); i + len2 <= len1; i = j + 1) {
j = string_indexof_char(p1, c, i);
if (j < 0 || j + len2 > len1)
break;
if (!string_cmp(p1, p2, j + 1, 1, len2 - 1))
return j;
}
return -1;
} | O0 | c | string_indexof:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0xd797c
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0xd7a19
movl 0x1c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x5cbd0
movl %eax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jg 0xd7a11
movq 0x28(%rsp), %rdi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x84780
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jl 0xd79cd
movl 0x10(%rsp), %eax
addl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jle 0xd79cf
jmp 0xd7a11
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x10(%rsp), %edx
addl $0x1, %edx
movl 0x8(%rsp), %r8d
subl $0x1, %r8d
movl $0x1, %ecx
callq 0xd76e0
cmpl $0x0, %eax
jne 0xd7a02
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0xd7a19
jmp 0xd7a04
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xd7994
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| string_indexof:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_1C], edx
mov rax, [rsp+38h+var_10]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov [rsp+38h+var_2C], eax
mov rax, [rsp+38h+var_18]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov [rsp+38h+var_30], eax
cmp [rsp+38h+var_30], 0
jnz short loc_D797C
mov eax, [rsp+38h+var_1C]
mov [rsp+38h+var_4], eax
jmp loc_D7A19
loc_D797C:
mov eax, [rsp+38h+var_1C]
mov [rsp+38h+var_24], eax
mov rdi, [rsp+38h+var_18]
xor esi, esi
call string_get
mov [rsp+38h+var_20], eax
loc_D7994:
mov eax, [rsp+38h+var_24]
add eax, [rsp+38h+var_30]
cmp eax, [rsp+38h+var_2C]
jg short loc_D7A11
mov rdi, [rsp+38h+var_10]
mov esi, [rsp+38h+var_20]
mov edx, [rsp+38h+var_24]
call string_indexof_char
mov [rsp+38h+var_28], eax
cmp [rsp+38h+var_28], 0
jl short loc_D79CD
mov eax, [rsp+38h+var_28]
add eax, [rsp+38h+var_30]
cmp eax, [rsp+38h+var_2C]
jle short loc_D79CF
loc_D79CD:
jmp short loc_D7A11
loc_D79CF:
mov rdi, [rsp+38h+var_10]
mov rsi, [rsp+38h+var_18]
mov edx, [rsp+38h+var_28]
add edx, 1
mov r8d, [rsp+38h+var_30]
sub r8d, 1
mov ecx, 1
call string_cmp
cmp eax, 0
jnz short loc_D7A02
mov eax, [rsp+38h+var_28]
mov [rsp+38h+var_4], eax
jmp short loc_D7A19
loc_D7A02:
jmp short $+2
loc_D7A04:
mov eax, [rsp+38h+var_28]
add eax, 1
mov [rsp+38h+var_24], eax
jmp short loc_D7994
loc_D7A11:
mov [rsp+38h+var_4], 0FFFFFFFFh
loc_D7A19:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| long long string_indexof(long long a1, long long a2, unsigned int a3)
{
int v4; // [rsp+8h] [rbp-30h]
int v5; // [rsp+Ch] [rbp-2Ch]
int v6; // [rsp+10h] [rbp-28h]
unsigned int v7; // [rsp+14h] [rbp-24h]
int v8; // [rsp+18h] [rbp-20h]
v5 = *(_QWORD *)(a1 + 4) & 0x7FFFFFFF;
v4 = *(_DWORD *)(a2 + 4) & 0x7FFFFFFF;
if ( v4 )
{
v7 = a3;
v8 = string_get(a2, 0);
while ( (int)(v4 + v7) <= v5 )
{
v6 = string_indexof_char(a1, v8, v7);
if ( v6 < 0 || v4 + v6 > v5 )
break;
if ( !(unsigned int)string_cmp(a1, a2, v6 + 1, 1, v4 - 1) )
return (unsigned int)v6;
v7 = v6 + 1;
}
return (unsigned int)-1;
}
else
{
return a3;
}
}
| string_indexof:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV dword ptr [RSP + 0x1c],EDX
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV dword ptr [RSP + 0xc],EAX
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV dword ptr [RSP + 0x8],EAX
CMP dword ptr [RSP + 0x8],0x0
JNZ 0x001d797c
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x34],EAX
JMP 0x001d7a19
LAB_001d797c:
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x14],EAX
MOV RDI,qword ptr [RSP + 0x20]
XOR ESI,ESI
CALL 0x0015cbd0
MOV dword ptr [RSP + 0x18],EAX
LAB_001d7994:
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,dword ptr [RSP + 0x8]
CMP EAX,dword ptr [RSP + 0xc]
JG 0x001d7a11
MOV RDI,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RSP + 0x18]
MOV EDX,dword ptr [RSP + 0x14]
CALL 0x00184780
MOV dword ptr [RSP + 0x10],EAX
CMP dword ptr [RSP + 0x10],0x0
JL 0x001d79cd
MOV EAX,dword ptr [RSP + 0x10]
ADD EAX,dword ptr [RSP + 0x8]
CMP EAX,dword ptr [RSP + 0xc]
JLE 0x001d79cf
LAB_001d79cd:
JMP 0x001d7a11
LAB_001d79cf:
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x20]
MOV EDX,dword ptr [RSP + 0x10]
ADD EDX,0x1
MOV R8D,dword ptr [RSP + 0x8]
SUB R8D,0x1
MOV ECX,0x1
CALL 0x001d76e0
CMP EAX,0x0
JNZ 0x001d7a02
MOV EAX,dword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x34],EAX
JMP 0x001d7a19
LAB_001d7a02:
JMP 0x001d7a04
LAB_001d7a04:
MOV EAX,dword ptr [RSP + 0x10]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
JMP 0x001d7994
LAB_001d7a11:
MOV dword ptr [RSP + 0x34],0xffffffff
LAB_001d7a19:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int string_indexof(long param_1,long param_2,int param_3)
{
uint uVar1;
uint uVar2;
int4 uVar3;
int iVar4;
int local_24;
int local_4;
uVar1 = (uint)*(int8 *)(param_1 + 4) & 0x7fffffff;
uVar2 = (uint)*(ulong *)(param_2 + 4) & 0x7fffffff;
local_4 = param_3;
if ((*(ulong *)(param_2 + 4) & 0x7fffffff) != 0) {
uVar3 = string_get(param_2,0);
local_24 = param_3;
while ((((int)(local_24 + uVar2) <= (int)uVar1 &&
(local_24 = string_indexof_char(param_1,uVar3,local_24), -1 < local_24)) &&
((int)(local_24 + uVar2) <= (int)uVar1))) {
iVar4 = string_cmp(param_1,param_2,local_24 + 1,1,uVar2 - 1);
if (iVar4 == 0) {
return local_24;
}
local_24 = local_24 + 1;
}
local_4 = -1;
}
return local_4;
}
| |
54,758 | string_indexof | bluesky950520[P]quickjs/quickjs.c | static int string_indexof(JSString *p1, JSString *p2, int from)
{
/* assuming 0 <= from <= p1->len */
int c, i, j, len1 = p1->len, len2 = p2->len;
if (len2 == 0)
return from;
for (i = from, c = string_get(p2, 0); i + len2 <= len1; i = j + 1) {
j = string_indexof_char(p1, c, i);
if (j < 0 || j + len2 > len1)
break;
if (!string_cmp(p1, p2, j + 1, 1, len2 - 1))
return j;
}
return -1;
} | O2 | c | string_indexof:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl $0x7fffffff, %r12d # imm = 0x7FFFFFFF
movq 0x4(%rsi), %rax
movl %eax, %ebp
andl %r12d, %ebp
je 0x697b2
movq %rsi, %r14
movq %rdi, %r15
andl 0x4(%rdi), %r12d
testl %eax, %eax
js 0x69762
movzbl 0x18(%r14), %eax
jmp 0x69767
movzwl 0x18(%r14), %eax
movl %eax, 0x4(%rsp)
subl %ebp, %r12d
decl %ebp
cmpl %r12d, %ebx
jg 0x697af
movq %r15, %rdi
movl 0x4(%rsp), %esi
movl %ebx, %edx
callq 0x414fc
testl %eax, %eax
js 0x697af
movl %eax, %r13d
cmpl %r12d, %eax
jg 0x697af
leal 0x1(%r13), %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
pushq $0x1
popq %rcx
movl %ebp, %r8d
callq 0x6961a
testl %eax, %eax
jne 0x69770
movl %r13d, %ebx
jmp 0x697b2
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| string_indexof:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, edx
mov r12d, 7FFFFFFFh
mov rax, [rsi+4]
mov ebp, eax
and ebp, r12d
jz short loc_697B2
mov r14, rsi
mov r15, rdi
and r12d, [rdi+4]
test eax, eax
js short loc_69762
movzx eax, byte ptr [r14+18h]
jmp short loc_69767
loc_69762:
movzx eax, word ptr [r14+18h]
loc_69767:
mov [rsp+38h+var_34], eax
sub r12d, ebp
dec ebp
loc_69770:
cmp ebx, r12d
jg short loc_697AF
mov rdi, r15
mov esi, [rsp+38h+var_34]
mov edx, ebx
call string_indexof_char
test eax, eax
js short loc_697AF
mov r13d, eax
cmp eax, r12d
jg short loc_697AF
lea ebx, [r13+1]
mov rdi, r15
mov rsi, r14
mov edx, ebx
push 1
pop rcx
mov r8d, ebp
call string_cmp
test eax, eax
jnz short loc_69770
mov ebx, r13d
jmp short loc_697B2
loc_697AF:
push 0FFFFFFFFFFFFFFFFh
pop rbx
loc_697B2:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long string_indexof(long long a1, long long a2, unsigned int a3)
{
long long v4; // rax
int v5; // ebp
unsigned int v6; // eax
int v7; // r12d
unsigned int v8; // ebp
int v9; // eax
unsigned int v10; // r13d
unsigned int v12; // [rsp+0h] [rbp-34h]
v4 = *(_QWORD *)(a2 + 4);
v5 = v4 & 0x7FFFFFFF;
if ( (v4 & 0x7FFFFFFF) != 0 )
{
if ( (int)v4 < 0 )
v6 = *(unsigned __int16 *)(a2 + 24);
else
v6 = *(unsigned __int8 *)(a2 + 24);
v12 = v6;
v7 = (*(_DWORD *)(a1 + 4) & 0x7FFFFFFF) - v5;
v8 = v5 - 1;
while ( (int)a3 <= v7 )
{
v9 = string_indexof_char(a1, v12, a3);
if ( v9 < 0 )
break;
v10 = v9;
if ( v9 > v7 )
break;
a3 = v9 + 1;
if ( !(unsigned int)string_cmp(a1, a2, v9 + 1, 1, v8) )
return v10;
}
return (unsigned int)-1;
}
return a3;
}
| string_indexof:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,EDX
MOV R12D,0x7fffffff
MOV RAX,qword ptr [RSI + 0x4]
MOV EBP,EAX
AND EBP,R12D
JZ 0x001697b2
MOV R14,RSI
MOV R15,RDI
AND R12D,dword ptr [RDI + 0x4]
TEST EAX,EAX
JS 0x00169762
MOVZX EAX,byte ptr [R14 + 0x18]
JMP 0x00169767
LAB_00169762:
MOVZX EAX,word ptr [R14 + 0x18]
LAB_00169767:
MOV dword ptr [RSP + 0x4],EAX
SUB R12D,EBP
DEC EBP
LAB_00169770:
CMP EBX,R12D
JG 0x001697af
MOV RDI,R15
MOV ESI,dword ptr [RSP + 0x4]
MOV EDX,EBX
CALL 0x001414fc
TEST EAX,EAX
JS 0x001697af
MOV R13D,EAX
CMP EAX,R12D
JG 0x001697af
LEA EBX,[R13 + 0x1]
MOV RDI,R15
MOV RSI,R14
MOV EDX,EBX
PUSH 0x1
POP RCX
MOV R8D,EBP
CALL 0x0016961a
TEST EAX,EAX
JNZ 0x00169770
MOV EBX,R13D
JMP 0x001697b2
LAB_001697af:
PUSH -0x1
POP RBX
LAB_001697b2:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int string_indexof(long param_1,long param_2,int param_3)
{
ushort uVar1;
uint uVar2;
int iVar3;
int iVar4;
uint uVar5;
int iVar6;
uVar2 = (uint)*(ulong *)(param_2 + 4);
uVar5 = uVar2 & 0x7fffffff;
iVar3 = param_3;
if ((*(ulong *)(param_2 + 4) & 0x7fffffff) != 0) {
if ((int)uVar2 < 0) {
uVar1 = *(ushort *)(param_2 + 0x18);
}
else {
uVar1 = (ushort)*(byte *)(param_2 + 0x18);
}
iVar6 = (*(uint *)(param_1 + 4) & 0x7fffffff) - uVar5;
do {
if (((iVar6 < param_3) || (iVar3 = string_indexof_char(param_1,uVar1,param_3), iVar3 < 0)) ||
(iVar6 < iVar3)) {
return -1;
}
param_3 = iVar3 + 1;
iVar4 = string_cmp(param_1,param_2,param_3,1,uVar5 - 1);
} while (iVar4 != 0);
}
return iVar3;
}
| |
54,759 | string_indexof | bluesky950520[P]quickjs/quickjs.c | static int string_indexof(JSString *p1, JSString *p2, int from)
{
/* assuming 0 <= from <= p1->len */
int c, i, j, len1 = p1->len, len2 = p2->len;
if (len2 == 0)
return from;
for (i = from, c = string_get(p2, 0); i + len2 <= len1; i = j + 1) {
j = string_indexof_char(p1, c, i);
if (j < 0 || j + len2 > len1)
break;
if (!string_cmp(p1, p2, j + 1, 1, len2 - 1))
return j;
}
return -1;
} | O3 | c | string_indexof:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
movl $0x7fffffff, %ebx # imm = 0x7FFFFFFF
movq %rsi, 0x10(%rsp)
movq 0x4(%rsi), %rax
movl %eax, %ebp
andl %ebx, %ebp
je 0x804c0
movq %rdi, %r14
andl 0x4(%rdi), %ebx
testl %eax, %eax
js 0x804c5
movq 0x10(%rsp), %rax
movzbl 0x18(%rax), %eax
jmp 0x804ce
movl %r15d, %r13d
jmp 0x8051f
movq 0x10(%rsp), %rax
movzwl 0x18(%rax), %eax
movl %eax, 0xc(%rsp)
subl %ebp, %ebx
decl %ebp
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
cmpl %ebx, %r15d
jg 0x8051f
movq %r14, %rdi
movl 0xc(%rsp), %esi
movl %r15d, %edx
callq 0x4d8ce
testl %eax, %eax
js 0x8051f
movl %eax, %r12d
cmpl %ebx, %eax
jg 0x8051f
leal 0x1(%r12), %r15d
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movl %r15d, %edx
movl $0x1, %ecx
movl %ebp, %r8d
callq 0x80343
testl %eax, %eax
jne 0x804dc
movl %r12d, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| string_indexof:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15d, edx
mov ebx, 7FFFFFFFh
mov [rsp+48h+var_38], rsi
mov rax, [rsi+4]
mov ebp, eax
and ebp, ebx
jz short loc_804C0
mov r14, rdi
and ebx, [rdi+4]
test eax, eax
js short loc_804C5
mov rax, [rsp+48h+var_38]
movzx eax, byte ptr [rax+18h]
jmp short loc_804CE
loc_804C0:
mov r13d, r15d
jmp short loc_8051F
loc_804C5:
mov rax, [rsp+48h+var_38]
movzx eax, word ptr [rax+18h]
loc_804CE:
mov [rsp+48h+var_3C], eax
sub ebx, ebp
dec ebp
mov r13d, 0FFFFFFFFh
loc_804DC:
cmp r15d, ebx
jg short loc_8051F
mov rdi, r14
mov esi, [rsp+48h+var_3C]
mov edx, r15d
call string_indexof_char
test eax, eax
js short loc_8051F
mov r12d, eax
cmp eax, ebx
jg short loc_8051F
lea r15d, [r12+1]
mov rdi, r14
mov rsi, [rsp+48h+var_38]
mov edx, r15d
mov ecx, 1
mov r8d, ebp
call string_cmp
test eax, eax
jnz short loc_804DC
mov r13d, r12d
loc_8051F:
mov eax, r13d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long string_indexof(long long a1, long long a2, unsigned int a3)
{
int v3; // r15d
long long v4; // rax
int v5; // ebp
unsigned int v6; // eax
unsigned int v7; // r13d
int v8; // ebx
int v9; // ebp
int v10; // eax
unsigned int v11; // r12d
unsigned int v13; // [rsp+Ch] [rbp-3Ch]
v3 = a3;
v4 = *(_QWORD *)(a2 + 4);
v5 = v4 & 0x7FFFFFFF;
if ( (v4 & 0x7FFFFFFF) != 0 )
{
if ( (int)v4 < 0 )
v6 = *(unsigned __int16 *)(a2 + 24);
else
v6 = *(unsigned __int8 *)(a2 + 24);
v13 = v6;
v8 = (*(_DWORD *)(a1 + 4) & 0x7FFFFFFF) - v5;
v9 = v5 - 1;
v7 = -1;
while ( v3 <= v8 )
{
v10 = string_indexof_char(a1, v13, v3);
if ( v10 < 0 )
break;
v11 = v10;
if ( v10 > v8 )
break;
v3 = v10 + 1;
if ( !(unsigned int)string_cmp(a1, a2, v10 + 1, 1, v9) )
return v11;
}
}
else
{
return a3;
}
return v7;
}
| string_indexof:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15D,EDX
MOV EBX,0x7fffffff
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr [RSI + 0x4]
MOV EBP,EAX
AND EBP,EBX
JZ 0x001804c0
MOV R14,RDI
AND EBX,dword ptr [RDI + 0x4]
TEST EAX,EAX
JS 0x001804c5
MOV RAX,qword ptr [RSP + 0x10]
MOVZX EAX,byte ptr [RAX + 0x18]
JMP 0x001804ce
LAB_001804c0:
MOV R13D,R15D
JMP 0x0018051f
LAB_001804c5:
MOV RAX,qword ptr [RSP + 0x10]
MOVZX EAX,word ptr [RAX + 0x18]
LAB_001804ce:
MOV dword ptr [RSP + 0xc],EAX
SUB EBX,EBP
DEC EBP
MOV R13D,0xffffffff
LAB_001804dc:
CMP R15D,EBX
JG 0x0018051f
MOV RDI,R14
MOV ESI,dword ptr [RSP + 0xc]
MOV EDX,R15D
CALL 0x0014d8ce
TEST EAX,EAX
JS 0x0018051f
MOV R12D,EAX
CMP EAX,EBX
JG 0x0018051f
LEA R15D,[R12 + 0x1]
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x10]
MOV EDX,R15D
MOV ECX,0x1
MOV R8D,EBP
CALL 0x00180343
TEST EAX,EAX
JNZ 0x001804dc
MOV R13D,R12D
LAB_0018051f:
MOV EAX,R13D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int string_indexof(long param_1,long param_2,int param_3)
{
ushort uVar1;
uint uVar2;
int iVar3;
int iVar4;
int iVar5;
uint uVar6;
uVar2 = (uint)*(ulong *)(param_2 + 4);
uVar6 = uVar2 & 0x7fffffff;
iVar3 = param_3;
if ((*(ulong *)(param_2 + 4) & 0x7fffffff) != 0) {
if ((int)uVar2 < 0) {
uVar1 = *(ushort *)(param_2 + 0x18);
}
else {
uVar1 = (ushort)*(byte *)(param_2 + 0x18);
}
iVar5 = (*(uint *)(param_1 + 4) & 0x7fffffff) - uVar6;
do {
if (iVar5 < param_3) {
return -1;
}
iVar3 = string_indexof_char(param_1,uVar1,param_3);
if (iVar3 < 0) {
return -1;
}
if (iVar5 < iVar3) {
return -1;
}
param_3 = iVar3 + 1;
iVar4 = string_cmp(param_1,param_2,param_3,1,uVar6 - 1);
} while (iVar4 != 0);
}
return iVar3;
}
| |
54,760 | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_array() | monkey531[P]llama/common/json.hpp | bool end_array()
{
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(ref_stack.back()->is_array());
ref_stack.back()->set_parents();
ref_stack.pop_back();
return true;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_array():
pushq %rax
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x46574
movq -0x8(%rax), %rcx
cmpb $0x2, (%rcx)
jne 0x46590
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rcx
retq
leaq 0x6a981(%rip), %rdi # 0xb0efc
leaq 0x64cb2(%rip), %rdx # 0xab234
leaq 0x6b96d(%rip), %rcx # 0xb1ef6
movl $0x1b01, %esi # imm = 0x1B01
jmp 0x465aa
leaq 0x6a965(%rip), %rdi # 0xb0efc
leaq 0x64c96(%rip), %rdx # 0xab234
leaq 0x6bc1c(%rip), %rcx # 0xb21c1
movl $0x1b02, %esi # imm = 0x1B02
xorl %eax, %eax
callq 0x23eb0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail19json_sax_dom_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9end_arrayEv:
push rax
mov rax, [rdi+10h]
cmp [rdi+8], rax
jz short loc_46574
mov rcx, [rax-8]
cmp byte ptr [rcx], 2
jnz short loc_46590
add rax, 0FFFFFFFFFFFFFFF8h
mov [rdi+10h], rax
mov al, 1
pop rcx
retn
loc_46574:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackEmpty; "!ref_stack.empty()"
mov esi, 1B01h
jmp short loc_465AA
loc_46590:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackBackIs_0; "ref_stack.back()->is_array()"
mov esi, 1B02h
loc_465AA:
xor eax, eax
call _ggml_abort
nop
| char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::end_array(
long long a1)
{
long long v1; // rax
long long v3; // rsi
long long v4; // rdx
long long v5; // rcx
v1 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v1 )
{
v3 = 6913LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
6913LL,
"GGML_ASSERT(%s) failed",
"!ref_stack.empty()");
}
else
{
if ( **(_BYTE **)(v1 - 8) == 2 )
{
*(_QWORD *)(a1 + 16) = v1 - 8;
return 1;
}
v3 = 6914LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
6914LL,
"GGML_ASSERT(%s) failed",
"ref_stack.back()->is_array()");
}
return nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::parse_error<nlohmann::json_abi_v3_11_3::detail::out_of_range>(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v3,
v4,
v5);
}
| end_array:
PUSH RAX
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RDI + 0x8],RAX
JZ 0x00146574
MOV RCX,qword ptr [RAX + -0x8]
CMP byte ptr [RCX],0x2
JNZ 0x00146590
ADD RAX,-0x8
MOV qword ptr [RDI + 0x10],RAX
MOV AL,0x1
POP RCX
RET
LAB_00146574:
LEA RDI,[0x1b0efc]
LEA RDX,[0x1ab234]
LEA RCX,[0x1b1ef6]
MOV ESI,0x1b01
JMP 0x001465aa
LAB_00146590:
LEA RDI,[0x1b0efc]
LEA RDX,[0x1ab234]
LEA RCX,[0x1b21c1]
MOV ESI,0x1b02
LAB_001465aa:
XOR EAX,EAX
CALL 0x00123eb0
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::end_array() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::end_array(json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
long lVar1;
char *pcVar2;
int8 uVar3;
lVar1 = *(long *)(this + 0x10);
if (*(long *)(this + 8) == lVar1) {
pcVar2 = "!ref_stack.empty()";
uVar3 = 0x1b01;
}
else {
if (**(char **)(lVar1 + -8) == '\x02') {
*(long *)(this + 0x10) = lVar1 + -8;
return CONCAT71((int7)((ulong)(lVar1 + -8) >> 8),1);
}
pcVar2 = "ref_stack.back()->is_array()";
uVar3 = 0x1b02;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
| |
54,761 | minja::SubscriptExpr::SubscriptExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&) | monkey531[P]llama/common/minja.hpp | SubscriptExpr(const Location & location, std::shared_ptr<Expression> && b, std::shared_ptr<Expression> && i)
: Expression(location), base(std::move(b)), index(std::move(i)) {} | O2 | cpp | minja::SubscriptExpr::SubscriptExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&):
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x62b30
leaq 0x91ebc(%rip), %rax # 0xfc778
addq $0x10, %rax
movq %rax, (%r15)
andq $0x0, 0x28(%r15)
movups (%r14), %xmm0
andq $0x0, 0x8(%r14)
movups %xmm0, 0x20(%r15)
andq $0x0, (%r14)
andq $0x0, 0x38(%r15)
movups (%rbx), %xmm0
andq $0x0, 0x8(%rbx)
movups %xmm0, 0x30(%r15)
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
| _ZN5minja13SubscriptExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEES7_:
push r15
push r14
push rbx
mov rbx, rcx
mov r14, rdx
mov r15, rdi
call _ZN5minja10ExpressionC2ERKNS_8LocationE; minja::Expression::Expression(minja::Location const&)
lea rax, _ZTVN5minja13SubscriptExprE; `vtable for'minja::SubscriptExpr
add rax, 10h
mov [r15], rax
and qword ptr [r15+28h], 0
movups xmm0, xmmword ptr [r14]
and qword ptr [r14+8], 0
movups xmmword ptr [r15+20h], xmm0
and qword ptr [r14], 0
and qword ptr [r15+38h], 0
movups xmm0, xmmword ptr [rbx]
and qword ptr [rbx+8], 0
movups xmmword ptr [r15+30h], xmm0
and qword ptr [rbx], 0
pop rbx
pop r14
pop r15
retn
| long long * minja::SubscriptExpr::SubscriptExpr(long long a1, _QWORD *a2, __int128 *a3, __int128 *a4)
{
long long *result; // rax
__int128 v7; // xmm0
__int128 v8; // xmm0
minja::Expression::Expression((_QWORD *)a1, a2);
result = &`vtable for'minja::SubscriptExpr + 2;
*(_QWORD *)a1 = &`vtable for'minja::SubscriptExpr + 2;
*(_QWORD *)(a1 + 40) = 0LL;
v7 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v7;
*(_QWORD *)a3 = 0LL;
*(_QWORD *)(a1 + 56) = 0LL;
v8 = *a4;
*((_QWORD *)a4 + 1) = 0LL;
*(_OWORD *)(a1 + 48) = v8;
*(_QWORD *)a4 = 0LL;
return result;
}
| SubscriptExpr:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RDI
CALL 0x00162b30
LEA RAX,[0x1fc778]
ADD RAX,0x10
MOV qword ptr [R15],RAX
AND qword ptr [R15 + 0x28],0x0
MOVUPS XMM0,xmmword ptr [R14]
AND qword ptr [R14 + 0x8],0x0
MOVUPS xmmword ptr [R15 + 0x20],XMM0
AND qword ptr [R14],0x0
AND qword ptr [R15 + 0x38],0x0
MOVUPS XMM0,xmmword ptr [RBX]
AND qword ptr [RBX + 0x8],0x0
MOVUPS xmmword ptr [R15 + 0x30],XMM0
AND qword ptr [RBX],0x0
POP RBX
POP R14
POP R15
RET
|
/* minja::SubscriptExpr::SubscriptExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&,
std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::SubscriptExpr::SubscriptExpr
(SubscriptExpr *this,Location *param_1,shared_ptr *param_2,shared_ptr *param_3)
{
int8 uVar1;
Expression::Expression((Expression *)this,param_1);
*(int ***)this = &PTR_do_evaluate_001fc788;
*(int8 *)(this + 0x28) = 0;
uVar1 = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar1;
*(int8 *)param_2 = 0;
*(int8 *)(this + 0x38) = 0;
uVar1 = *(int8 *)(param_3 + 8);
*(int8 *)(param_3 + 8) = 0;
*(int8 *)(this + 0x30) = *(int8 *)param_3;
*(int8 *)(this + 0x38) = uVar1;
*(int8 *)param_3 = 0;
return;
}
| |
54,762 | Settings::allSlaveShipsSunk() const | 666mxvbee[P]BattleShip/lib/Settings/Settings.cpp | bool Settings::allSlaveShipsSunk() const {
std::lock_guard<std::mutex> lock(settings_mutex);
for (const auto& ship : slaveShips) {
if (!ship.isSunk()) return false;
}
return true;
} | O1 | cpp | Settings::allSlaveShipsSunk() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5520
testl %eax, %eax
jne 0x71c9
movq 0xa8(%rbx), %r14
movq 0xb0(%rbx), %r15
cmpq %r15, %r14
sete %bpl
je 0x71b0
movq %r14, %rdi
callq 0x15506
testb %al, %al
je 0x71b0
addq $0x40, %r14
jmp 0x7195
movq %rbx, %rdi
callq 0x52f0
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x5260
movq %rax, %r14
movq %rbx, %rdi
callq 0x52f0
movq %r14, %rdi
callq 0x5600
nop
| _ZNK8Settings17allSlaveShipsSunkEv:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rdi
call _pthread_mutex_lock
test eax, eax
jnz short loc_71C9
mov r14, [rbx+0A8h]
mov r15, [rbx+0B0h]
loc_7195:
cmp r14, r15
setz bpl
jz short loc_71B0
mov rdi, r14; this
call _ZNK4Ship6isSunkEv; Ship::isSunk(void)
test al, al
jz short loc_71B0
add r14, 40h ; '@'
jmp short loc_7195
loc_71B0:
mov rdi, rbx
call _pthread_mutex_unlock
and bpl, 1
mov eax, ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_71C9:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov r14, rax
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, r14
call __Unwind_Resume
| long long Settings::allSlaveShipsSunk(Ship **this)
{
unsigned int v1; // ebp
int v2; // eax
Ship *v3; // r14
Ship *v4; // r15
v2 = pthread_mutex_lock(this);
if ( v2 )
std::__throw_system_error(v2);
v3 = this[21];
v4 = this[22];
while ( v3 != v4 && (unsigned __int8)Ship::isSunk(v3) )
v3 = (Ship *)((char *)v3 + 64);
pthread_mutex_unlock(this);
LOBYTE(v1) = v3 == v4;
return v1;
}
| allSlaveShipsSunk:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00105520
TEST EAX,EAX
JNZ 0x001071c9
MOV R14,qword ptr [RBX + 0xa8]
MOV R15,qword ptr [RBX + 0xb0]
LAB_00107195:
CMP R14,R15
SETZ BPL
JZ 0x001071b0
LAB_0010719e:
MOV RDI,R14
CALL 0x00115506
LAB_001071a6:
TEST AL,AL
JZ 0x001071b0
ADD R14,0x40
JMP 0x00107195
LAB_001071b0:
MOV RDI,RBX
CALL 0x001052f0
AND BPL,0x1
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001071c9:
MOV EDI,EAX
CALL 0x00105260
|
/* Settings::allSlaveShipsSunk() const */
ulong __thiscall Settings::allSlaveShipsSunk(Settings *this)
{
Ship *pSVar1;
char cVar2;
int iVar3;
int8 unaff_RBP;
int7 uVar4;
Ship *this_00;
bool bVar5;
iVar3 = pthread_mutex_lock((pthread_mutex_t *)this);
if (iVar3 != 0) {
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar3);
}
this_00 = *(Ship **)(this + 0xa8);
pSVar1 = *(Ship **)(this + 0xb0);
while( true ) {
bVar5 = this_00 == pSVar1;
uVar4 = (int7)((ulong)unaff_RBP >> 8);
unaff_RBP = CONCAT71(uVar4,bVar5);
if (bVar5) break;
/* try { // try from 0010719e to 001071a5 has its CatchHandler @ 001071d0 */
cVar2 = Ship::isSunk(this_00);
if (cVar2 == '\0') break;
this_00 = this_00 + 0x40;
}
pthread_mutex_unlock((pthread_mutex_t *)this);
return CONCAT71(uVar4,bVar5) & 0xffffffff;
}
| |
54,763 | pagecache_unpin | eloqsql/storage/maria/ma_pagecache.c | void pagecache_unpin(PAGECACHE *pagecache,
PAGECACHE_FILE *file,
pgcache_page_no_t pageno,
LSN lsn)
{
PAGECACHE_BLOCK_LINK *block;
int page_st;
DBUG_ENTER("pagecache_unpin");
DBUG_PRINT("enter", ("fd: %u page: %lu",
(uint) file->file, (ulong) pageno));
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
/*
As soon as we keep lock cache can be used, and we have lock bacause want
aunlock.
*/
DBUG_ASSERT(pagecache->can_be_used);
inc_counter_for_resize_op(pagecache);
/* See NOTE for pagecache_unlock about registering requests */
block= find_block(pagecache, file, pageno, 0, 0, 0, 0, FALSE, &page_st);
DBUG_ASSERT(block != 0);
DBUG_ASSERT(page_st == PAGE_READ);
/* we can't unpin such page without unlock */
DBUG_ASSERT((block->status & PCBLOCK_DIRECT_W) == 0);
if (lsn != LSN_IMPOSSIBLE)
check_and_set_lsn(pagecache, lsn, block);
/*
we can just unpin only with keeping read lock because:
a) we can't pin without any lock
b) we can't unpin keeping write lock
*/
if (make_lock_and_pin(pagecache, block,
PAGECACHE_LOCK_LEFT_READLOCKED,
PAGECACHE_UNPIN, FALSE))
DBUG_ASSERT(0); /* should not happend */
remove_reader(block);
/*
Link the block into the LRU chain if it's the last submitted request
for the block and block will not be pinned.
See NOTE for pagecache_unlock about registering requests
*/
unreg_request(pagecache, block, 1);
dec_counter_for_resize_op(pagecache);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_VOID_RETURN;
} | O3 | c | pagecache_unpin:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0xc8(%rdi), %rbx
cmpq $0x0, 0x108(%rdi)
jne 0x4bf1f
movq %rbx, %rdi
callq 0x2a230
incq 0x68(%r14)
subq $0x8, %rsp
leaq -0x2c(%rbp), %rax
xorl %r10d, %r10d
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %r10
callq 0x4b49c
addq $0x20, %rsp
movq %rax, %r12
testq %r15, %r15
je 0x4be91
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4bae6
decl 0x64(%r12)
movq 0x20(%r12), %rax
decl 0x68(%rax)
jne 0x4bebf
movq 0x28(%r12), %r15
testq %r15, %r15
je 0x4bebf
movq 0x30(%r15), %rdi
testq %rdi, %rdi
jne 0x4bf4a
movq %r15, %rdi
callq 0x2a630
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x4bd13
decq 0x68(%r14)
jne 0x4befd
movq 0x110(%r14), %rax
testq %rax, %rax
je 0x4befd
movq 0x88(%rax), %r15
movq 0x38(%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x4bf5f
movq %r15, %rdi
callq 0x2a630
movq 0x108(%r14), %rdi
testq %rdi, %rdi
jne 0x4bf38
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a1f0
leaq 0xade7c(%rip), %rsi # 0xf9da2
movq %rbx, %rdi
movl $0xcef, %edx # imm = 0xCEF
callq 0x312ea
jmp 0x4be4d
leaq 0x362ad9(%rip), %rax # 0x3aea18
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4bf09
leaq 0x362ac7(%rip), %rax # 0x3aea18
movq (%rax), %rax
callq *0x170(%rax)
jmp 0x4beb7
leaq 0x362ab2(%rip), %rax # 0x3aea18
movq (%rax), %rax
callq *0x170(%rax)
jmp 0x4bef5
| pagecache_unpin:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rcx
mov r12, rdx
mov r13, rsi
mov r14, rdi
lea rbx, [rdi+0C8h]
cmp qword ptr [rdi+108h], 0
jnz loc_4BF1F
mov rdi, rbx
call _pthread_mutex_lock
loc_4BE4D:
inc qword ptr [r14+68h]
sub rsp, 8
lea rax, [rbp+var_2C]
xor r10d, r10d
mov rdi, r14
mov rsi, r13
mov rdx, r12
xor ecx, ecx
xor r8d, r8d
xor r9d, r9d
push rax
push r10
push r10
call find_block
add rsp, 20h
mov r12, rax
test r15, r15
jz short loc_4BE91
mov rdi, r14
mov rsi, r15
mov rdx, r12
call check_and_set_lsn
loc_4BE91:
dec dword ptr [r12+64h]
mov rax, [r12+20h]
dec dword ptr [rax+68h]
jnz short loc_4BEBF
mov r15, [r12+28h]
test r15, r15
jz short loc_4BEBF
mov rdi, [r15+30h]
test rdi, rdi
jnz loc_4BF4A
loc_4BEB7:
mov rdi, r15
call _pthread_cond_signal
loc_4BEBF:
mov rdi, r14
mov rsi, r12
mov edx, 1
call unreg_request
dec qword ptr [r14+68h]
jnz short loc_4BEFD
mov rax, [r14+110h]
test rax, rax
jz short loc_4BEFD
mov r15, [rax+88h]
mov rdi, [r15+38h]
add r15, 8
test rdi, rdi
jnz short loc_4BF5F
loc_4BEF5:
mov rdi, r15
call _pthread_cond_signal
loc_4BEFD:
mov rdi, [r14+108h]
test rdi, rdi
jnz short loc_4BF38
loc_4BF09:
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_4BF1F:
lea rsi, aWorkspaceLlm4b_33; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 0CEFh
call psi_mutex_lock
jmp loc_4BE4D
loc_4BF38:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_4BF09
loc_4BF4A:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp loc_4BEB7
loc_4BF5F:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp short loc_4BEF5
| long long pagecache_unpin(_QWORD *a1, int *a2, long long a3, signed long long a4)
{
long long v4; // rax
_QWORD *v8; // rbx
long long block; // rax
long long v10; // r12
long long v11; // rax
bool v12; // zf
long long v13; // r15
long long v14; // rdi
long long v15; // rax
long long v16; // r15
long long v17; // rdi
long long v18; // r15
long long v19; // rdi
_DWORD v21[11]; // [rsp+0h] [rbp-2Ch] BYREF
v21[0] = HIDWORD(v4);
v8 = a1 + 25;
if ( a1[33] )
psi_mutex_lock(
(long long)(a1 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xCEFu);
else
pthread_mutex_lock(a1 + 25);
++a1[13];
block = find_block((long long)a1, a2, a3, 0, 0, 0, 0, 0, v21);
v10 = block;
if ( a4 )
check_and_set_lsn((long long)a1, a4, block);
--*(_DWORD *)(v10 + 100);
v11 = *(_QWORD *)(v10 + 32);
v12 = (*(_DWORD *)(v11 + 104))-- == 1;
if ( v12 )
{
v13 = *(_QWORD *)(v10 + 40);
if ( v13 )
{
v14 = *(_QWORD *)(v13 + 48);
if ( v14 )
((void ( *)(long long))PSI_server[46])(v14);
pthread_cond_signal(v13);
}
}
unreg_request(a1, v10, 1);
v12 = a1[13]-- == 1LL;
if ( v12 )
{
v15 = a1[34];
if ( v15 )
{
v16 = *(_QWORD *)(v15 + 136);
v17 = *(_QWORD *)(v16 + 56);
v18 = v16 + 8;
if ( v17 )
((void ( *)(long long))PSI_server[46])(v17);
pthread_cond_signal(v18);
}
}
v19 = a1[33];
if ( v19 )
((void ( *)(long long))PSI_server[44])(v19);
return pthread_mutex_unlock(v8);
}
| pagecache_unpin:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RCX
MOV R12,RDX
MOV R13,RSI
MOV R14,RDI
LEA RBX,[RDI + 0xc8]
CMP qword ptr [RDI + 0x108],0x0
JNZ 0x0014bf1f
MOV RDI,RBX
CALL 0x0012a230
LAB_0014be4d:
INC qword ptr [R14 + 0x68]
SUB RSP,0x8
LEA RAX,[RBP + -0x2c]
XOR R10D,R10D
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
PUSH RAX
PUSH R10
PUSH R10
CALL 0x0014b49c
ADD RSP,0x20
MOV R12,RAX
TEST R15,R15
JZ 0x0014be91
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x0014bae6
LAB_0014be91:
DEC dword ptr [R12 + 0x64]
MOV RAX,qword ptr [R12 + 0x20]
DEC dword ptr [RAX + 0x68]
JNZ 0x0014bebf
MOV R15,qword ptr [R12 + 0x28]
TEST R15,R15
JZ 0x0014bebf
MOV RDI,qword ptr [R15 + 0x30]
TEST RDI,RDI
JNZ 0x0014bf4a
LAB_0014beb7:
MOV RDI,R15
CALL 0x0012a630
LAB_0014bebf:
MOV RDI,R14
MOV RSI,R12
MOV EDX,0x1
CALL 0x0014bd13
DEC qword ptr [R14 + 0x68]
JNZ 0x0014befd
MOV RAX,qword ptr [R14 + 0x110]
TEST RAX,RAX
JZ 0x0014befd
MOV R15,qword ptr [RAX + 0x88]
MOV RDI,qword ptr [R15 + 0x38]
ADD R15,0x8
TEST RDI,RDI
JNZ 0x0014bf5f
LAB_0014bef5:
MOV RDI,R15
CALL 0x0012a630
LAB_0014befd:
MOV RDI,qword ptr [R14 + 0x108]
TEST RDI,RDI
JNZ 0x0014bf38
LAB_0014bf09:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0012a1f0
LAB_0014bf1f:
LEA RSI,[0x1f9da2]
MOV RDI,RBX
MOV EDX,0xcef
CALL 0x001312ea
JMP 0x0014be4d
LAB_0014bf38:
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014bf09
LAB_0014bf4a:
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x0014beb7
LAB_0014bf5f:
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x0014bef5
|
void pagecache_unpin(long param_1,int8 param_2,int8 param_3,long param_4)
{
int *piVar1;
long *plVar2;
pthread_mutex_t *__mutex;
pthread_cond_t *__cond;
long lVar3;
int1 local_34 [4];
__mutex = (pthread_mutex_t *)(param_1 + 200);
if (*(long *)(param_1 + 0x108) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xcef);
}
*(long *)(param_1 + 0x68) = *(long *)(param_1 + 0x68) + 1;
lVar3 = find_block(param_1,param_2,param_3,0,0,0,0,0,local_34);
if (param_4 != 0) {
check_and_set_lsn(param_1,param_4,lVar3);
}
*(int *)(lVar3 + 100) = *(int *)(lVar3 + 100) + -1;
piVar1 = (int *)(*(long *)(lVar3 + 0x20) + 0x68);
*piVar1 = *piVar1 + -1;
if ((*piVar1 == 0) &&
(__cond = *(pthread_cond_t **)(lVar3 + 0x28), __cond != (pthread_cond_t *)0x0)) {
if (__cond[1].__align != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal(__cond);
}
unreg_request(param_1,lVar3,1);
plVar2 = (long *)(param_1 + 0x68);
*plVar2 = *plVar2 + -1;
if ((*plVar2 == 0) && (*(long *)(param_1 + 0x110) != 0)) {
lVar3 = *(long *)(*(long *)(param_1 + 0x110) + 0x88);
if (*(long *)(lVar3 + 0x38) != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal((pthread_cond_t *)(lVar3 + 8));
}
if (*(long *)(param_1 + 0x108) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return;
}
| |
54,764 | translog_flush_set_new_goal_and_wait | eloqsql/storage/maria/ma_loghandler.c | void translog_flush_set_new_goal_and_wait(TRANSLOG_ADDRESS lsn)
{
int flush_no= log_descriptor.flush_no;
DBUG_ENTER("translog_flush_set_new_goal_and_wait");
DBUG_PRINT("enter", ("LSN: " LSN_FMT, LSN_IN_PARTS(lsn)));
mysql_mutex_assert_owner(&log_descriptor.log_flush_lock);
if (cmp_translog_addr(lsn, log_descriptor.next_pass_max_lsn) > 0)
{
log_descriptor.next_pass_max_lsn= lsn;
log_descriptor.max_lsn_requester= pthread_self();
mysql_cond_broadcast(&log_descriptor.new_goal_cond);
}
while (flush_no == log_descriptor.flush_no)
{
mysql_cond_wait(&log_descriptor.log_flush_cond,
&log_descriptor.log_flush_lock);
}
DBUG_VOID_RETURN;
} | O0 | c | translog_flush_set_new_goal_and_wait:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0xc243b2(%rip), %eax # 0xc7a294
movl %eax, -0xc(%rbp)
jmp 0x55ee7
jmp 0x55ee9
jmp 0x55eeb
movq -0x8(%rbp), %rax
subq 0xc243a2(%rip), %rax # 0xc7a298
cmpq $0x0, %rax
jle 0x55f26
movq -0x8(%rbp), %rax
movq %rax, 0xc24391(%rip) # 0xc7a298
callq 0x2a540
movq %rax, 0xc2438d(%rip) # 0xc7a2a0
leaq 0x4234a6(%rip), %rdi # 0x4793c0
addq $0x800d88, %rdi # imm = 0x800D88
callq 0x55f70
jmp 0x55f28
movl -0xc(%rbp), %eax
movl 0xc24363(%rip), %ecx # 0xc7a294
cmpl %ecx, %eax
jne 0x55f60
leaq 0x423484(%rip), %rsi # 0x4793c0
movq %rsi, %rdi
addq $0x800d50, %rdi # imm = 0x800D50
addq $0x800d08, %rsi # imm = 0x800D08
leaq 0xfbd7a(%rip), %rdx # 0x151cce
movl $0x1eac, %ecx # imm = 0x1EAC
callq 0x50050
jmp 0x55f28
jmp 0x55f62
jmp 0x55f64
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| translog_flush_set_new_goal_and_wait:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov eax, cs:dword_C7A294
mov [rbp+var_C], eax
jmp short $+2
loc_55EE7:
jmp short $+2
loc_55EE9:
jmp short $+2
loc_55EEB:
mov rax, [rbp+var_8]
sub rax, cs:qword_C7A298
cmp rax, 0
jle short loc_55F26
mov rax, [rbp+var_8]
mov cs:qword_C7A298, rax
call _pthread_self
mov cs:qword_C7A2A0, rax
lea rdi, log_descriptor
add rdi, 800D88h
call inline_mysql_cond_broadcast_0
loc_55F26:
jmp short $+2
loc_55F28:
mov eax, [rbp+var_C]
mov ecx, cs:dword_C7A294
cmp eax, ecx
jnz short loc_55F60
lea rsi, log_descriptor
mov rdi, rsi
add rdi, 800D50h
add rsi, 800D08h
lea rdx, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1EACh
call inline_mysql_cond_wait_1
jmp short loc_55F28
loc_55F60:
jmp short $+2
loc_55F62:
jmp short $+2
loc_55F64:
add rsp, 10h
pop rbp
retn
| long long translog_flush_set_new_goal_and_wait(long long a1)
{
long long result; // rax
unsigned int v2; // [rsp+4h] [rbp-Ch]
v2 = dword_C7A294;
if ( a1 - qword_C7A298 > 0 )
{
qword_C7A298 = a1;
qword_C7A2A0 = pthread_self();
inline_mysql_cond_broadcast_0(&log_descriptor[1049009]);
}
while ( 1 )
{
result = v2;
if ( v2 != dword_C7A294 )
break;
inline_mysql_cond_wait_1(
(long long)&log_descriptor[1049002],
(long long)&log_descriptor[1048993],
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x1EACu);
}
return result;
}
| translog_flush_set_new_goal_and_wait:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV EAX,dword ptr [0x00d7a294]
MOV dword ptr [RBP + -0xc],EAX
JMP 0x00155ee7
LAB_00155ee7:
JMP 0x00155ee9
LAB_00155ee9:
JMP 0x00155eeb
LAB_00155eeb:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr [0x00d7a298]
CMP RAX,0x0
JLE 0x00155f26
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [0x00d7a298],RAX
CALL 0x0012a540
MOV qword ptr [0x00d7a2a0],RAX
LEA RDI,[0x5793c0]
ADD RDI,0x800d88
CALL 0x00155f70
LAB_00155f26:
JMP 0x00155f28
LAB_00155f28:
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,dword ptr [0x00d7a294]
CMP EAX,ECX
JNZ 0x00155f60
LEA RSI,[0x5793c0]
MOV RDI,RSI
ADD RDI,0x800d50
ADD RSI,0x800d08
LEA RDX,[0x251cce]
MOV ECX,0x1eac
CALL 0x00150050
JMP 0x00155f28
LAB_00155f60:
JMP 0x00155f62
LAB_00155f62:
JMP 0x00155f64
LAB_00155f64:
ADD RSP,0x10
POP RBP
RET
|
void translog_flush_set_new_goal_and_wait(long param_1)
{
int iVar1;
iVar1 = DAT_00d7a294;
if (0 < param_1 - DAT_00d7a298) {
DAT_00d7a298 = param_1;
DAT_00d7a2a0 = pthread_self();
inline_mysql_cond_broadcast(&DAT_00d7a148);
}
while (iVar1 == DAT_00d7a294) {
inline_mysql_cond_wait
(&DAT_00d7a110,&DAT_00d7a0c8,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",0x1eac);
}
return;
}
| |
54,765 | mysql_read_query_result_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_read_query_result_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_read_query_result,
(parms->mysql),
parms->mysql,
my_bool,
r_my_bool)
} | O3 | c | mysql_read_query_result_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq 0x480(%rdi), %rax
movq 0x28(%rax), %rbx
callq 0x2217c
movb %al, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_read_query_result_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdi, [rdi]
mov rax, [rdi+480h]
mov rbx, [rax+28h]
call mysql_read_query_result
mov [rbx+8], al
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| bool mysql_read_query_result_start_internal(long long *a1)
{
long long v1; // rdi
long long v2; // rbx
bool result; // al
v1 = *a1;
v2 = *(_QWORD *)(*(_QWORD *)(v1 + 1152) + 40LL);
result = mysql_read_query_result(v1);
*(_BYTE *)(v2 + 8) = result;
*(_DWORD *)v2 = 0;
return result;
}
| mysql_read_query_result_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x480]
MOV RBX,qword ptr [RAX + 0x28]
CALL 0x0012217c
MOV byte ptr [RBX + 0x8],AL
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_read_query_result_start_internal(long *param_1)
{
int4 *puVar1;
int1 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_read_query_result();
*(int1 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
| |
54,766 | ma_store_blob_length | eloqsql/storage/maria/ma_dynrec.c | void _ma_store_blob_length(uchar *pos,uint pack_length,uint length)
{
switch (pack_length) {
case 1:
*pos= (uchar) length;
break;
case 2:
int2store(pos,length);
break;
case 3:
int3store(pos,length);
break;
case 4:
int4store(pos,length);
default:
break;
}
return;
} | O3 | c | ma_store_blob_length:
pushq %rbp
movq %rsp, %rbp
decl %esi
cmpl $0x3, %esi
ja 0x456d1
leaq 0x9dc4c(%rip), %rax # 0xe32fc
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb %dl, (%rdi)
jmp 0x456d1
movb %dl, (%rdi)
movb %dh, 0x1(%rdi)
shrl $0x10, %edx
movb %dl, 0x2(%rdi)
jmp 0x456d1
movl %edx, (%rdi)
jmp 0x456d1
movw %dx, (%rdi)
popq %rbp
retq
| _ma_store_blob_length:
push rbp
mov rbp, rsp
dec esi; switch 4 cases
cmp esi, 3
ja short def_456B7; jumptable 00000000000456B7 default case
lea rax, jpt_456B7
movsxd rcx, ds:(jpt_456B7 - 0E32FCh)[rax+rsi*4]
add rcx, rax
jmp rcx; switch jump
loc_456B9:
mov [rdi], dl; jumptable 00000000000456B7 case 1
jmp short def_456B7; jumptable 00000000000456B7 default case
loc_456BD:
mov [rdi], dl; jumptable 00000000000456B7 case 3
mov [rdi+1], dh
shr edx, 10h
mov [rdi+2], dl
jmp short def_456B7; jumptable 00000000000456B7 default case
loc_456CA:
mov [rdi], edx; jumptable 00000000000456B7 case 4
jmp short def_456B7; jumptable 00000000000456B7 default case
loc_456CE:
mov [rdi], dx; jumptable 00000000000456B7 case 2
def_456B7:
pop rbp; jumptable 00000000000456B7 default case
retn
| void ma_store_blob_length(_BYTE *a1, int a2, int a3)
{
switch ( a2 )
{
case 1:
*a1 = a3;
break;
case 2:
*(_WORD *)a1 = a3;
break;
case 3:
*(_WORD *)a1 = a3;
a1[2] = BYTE2(a3);
break;
case 4:
*(_DWORD *)a1 = a3;
break;
default:
return;
}
}
| _ma_store_blob_length:
PUSH RBP
MOV RBP,RSP
DEC ESI
CMP ESI,0x3
JA 0x001456d1
LEA RAX,[0x1e32fc]
MOVSXD RCX,dword ptr [RAX + RSI*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_1:
MOV byte ptr [RDI],DL
JMP 0x001456d1
caseD_3:
MOV byte ptr [RDI],DL
MOV byte ptr [RDI + 0x1],DH
SHR EDX,0x10
MOV byte ptr [RDI + 0x2],DL
JMP 0x001456d1
caseD_4:
MOV dword ptr [RDI],EDX
JMP 0x001456d1
caseD_2:
MOV word ptr [RDI],DX
default:
POP RBP
RET
|
void _ma_store_blob_length(int4 *param_1,int4 param_2,int4 param_3)
{
switch(param_2) {
case 1:
*(char *)param_1 = (char)param_3;
break;
case 2:
*(short *)param_1 = (short)param_3;
break;
case 3:
*(char *)param_1 = (char)param_3;
*(char *)((long)param_1 + 1) = (char)((uint)param_3 >> 8);
*(char *)((long)param_1 + 2) = (char)((uint)param_3 >> 0x10);
break;
case 4:
*param_1 = param_3;
}
return;
}
| |
54,767 | my_setwd | eloqsql/mysys/my_getwd.c | int my_setwd(const char *dir, myf MyFlags)
{
int res;
size_t length;
char *start, *pos;
DBUG_ENTER("my_setwd");
DBUG_PRINT("my",("dir: '%s' MyFlags %lu", dir, MyFlags));
start=(char *) dir;
if (! dir[0] || (dir[0] == FN_LIBCHAR && dir[1] == 0))
dir=FN_ROOTDIR;
if ((res=chdir((char*) dir)) != 0)
{
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_SETWD,MYF(ME_BELL),start,errno);
}
else
{
if (test_if_hard_path(start))
{ /* Hard pathname */
pos= strmake(&curr_dir[0],start,(size_t) FN_REFLEN-1);
if (pos[-1] != FN_LIBCHAR)
{
length=(uint) (pos-(char*) curr_dir);
curr_dir[length]=FN_LIBCHAR; /* must end with '/' */
curr_dir[length+1]='\0';
}
}
else
curr_dir[0]='\0'; /* Don't save name */
}
DBUG_RETURN(res);
} | O0 | c | my_setwd:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x80402
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x8042c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x80437
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x80437
leaq 0x5e2ba(%rip), %rax # 0xde6ed
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28530
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x80490
callq 0x28040
movl (%rax), %eax
movl %eax, -0x34(%rbp)
callq 0x86110
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x8048e
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x28040
movq -0x40(%rbp), %rdx
movl (%rax), %ecx
movl $0x11, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x7fcb0
jmp 0x80505
movq -0x28(%rbp), %rdi
callq 0x80520
cmpl $0x0, %eax
je 0x804f9
movq -0x28(%rbp), %rsi
leaq 0x37f6a7(%rip), %rdi # 0x3ffb50
movl $0x1ff, %edx # imm = 0x1FF
callq 0xd9450
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x804f7
movq -0x30(%rbp), %rax
leaq 0x37f681(%rip), %rcx # 0x3ffb50
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0x37f66d(%rip), %rax # 0x3ffb50
movb $0x2f, (%rax,%rcx)
movq -0x20(%rbp), %rcx
leaq 0x37f65e(%rip), %rax # 0x3ffb50
movb $0x0, 0x1(%rax,%rcx)
jmp 0x80503
leaq 0x37f650(%rip), %rax # 0x3ffb50
movb $0x0, (%rax)
jmp 0x80505
jmp 0x80507
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_setwd:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_80402:
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov rax, [rbp+var_8]
cmp byte ptr [rax], 0
jz short loc_8042C
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_80437
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax+1]
cmp eax, 0
jnz short loc_80437
loc_8042C:
lea rax, word_DE6ED
mov [rbp+var_8], rax
loc_80437:
mov rdi, [rbp+var_8]
call _chdir
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_80490
call ___errno_location
mov eax, [rax]
mov [rbp+var_34], eax
call _my_thread_var
mov ecx, [rbp+var_34]
mov [rax], ecx
mov rax, [rbp+var_10]
and rax, 10h
cmp rax, 0
jz short loc_8048E
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
call ___errno_location
mov rdx, [rbp+var_40]
mov ecx, [rax]
mov edi, 11h
mov esi, 4
mov al, 0
call my_error
loc_8048E:
jmp short loc_80505
loc_80490:
mov rdi, [rbp+var_28]
call test_if_hard_path
cmp eax, 0
jz short loc_804F9
mov rsi, [rbp+var_28]
lea rdi, curr_dir
mov edx, 1FFh
call strmake
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jz short loc_804F7
mov rax, [rbp+var_30]
lea rcx, curr_dir
sub rax, rcx
mov eax, eax
mov [rbp+var_20], rax
mov rcx, [rbp+var_20]
lea rax, curr_dir
mov byte ptr [rax+rcx], 2Fh ; '/'
mov rcx, [rbp+var_20]
lea rax, curr_dir
mov byte ptr [rax+rcx+1], 0
loc_804F7:
jmp short loc_80503
loc_804F9:
lea rax, curr_dir
mov byte ptr [rax], 0
loc_80503:
jmp short $+2
loc_80505:
jmp short $+2
loc_80507:
mov eax, [rbp+var_14]
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
add rsp, 50h
pop rbp
retn
| long long my_setwd(__int16 *a1, const char *a2)
{
unsigned int *v2; // rax
int v4; // [rsp+1Ch] [rbp-34h]
long long v5; // [rsp+20h] [rbp-30h]
unsigned int v6; // [rsp+3Ch] [rbp-14h]
__int16 *v7; // [rsp+48h] [rbp-8h]
v7 = a1;
if ( !*(_BYTE *)a1 || *(_BYTE *)a1 == 47 && !*((_BYTE *)a1 + 1) )
v7 = &word_DE6ED;
v6 = chdir(v7);
if ( v6 )
{
v4 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(v7, a2) = v4;
if ( ((unsigned __int8)a2 & 0x10) != 0 )
{
v2 = (unsigned int *)__errno_location();
my_error(0x11u, 4LL, a1, *v2);
}
}
else if ( (unsigned int)test_if_hard_path(a1) )
{
v5 = strmake(curr_dir, a1, 511LL);
if ( *(_BYTE *)(v5 - 1) != 47 )
{
curr_dir[(unsigned int)(v5 - (_QWORD)curr_dir)] = 47;
curr_dir[(unsigned int)(v5 - (_QWORD)curr_dir) + 1] = 0;
}
}
else
{
curr_dir[0] = 0;
}
return v6;
}
| my_setwd:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x00180402
LAB_00180402:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX],0x0
JZ 0x0018042c
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x00180437
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x0
JNZ 0x00180437
LAB_0018042c:
LEA RAX,[0x1de6ed]
MOV qword ptr [RBP + -0x8],RAX
LAB_00180437:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00128530
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x00180490
CALL 0x00128040
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
CALL 0x00186110
MOV ECX,dword ptr [RBP + -0x34]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x10
CMP RAX,0x0
JZ 0x0018048e
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
CALL 0x00128040
MOV RDX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RAX]
MOV EDI,0x11
MOV ESI,0x4
MOV AL,0x0
CALL 0x0017fcb0
LAB_0018048e:
JMP 0x00180505
LAB_00180490:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00180520
CMP EAX,0x0
JZ 0x001804f9
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[0x4ffb50]
MOV EDX,0x1ff
CALL 0x001d9450
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JZ 0x001804f7
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x4ffb50]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0x20],RAX
MOV RCX,qword ptr [RBP + -0x20]
LEA RAX,[0x4ffb50]
MOV byte ptr [RAX + RCX*0x1],0x2f
MOV RCX,qword ptr [RBP + -0x20]
LEA RAX,[0x4ffb50]
MOV byte ptr [RAX + RCX*0x1 + 0x1],0x0
LAB_001804f7:
JMP 0x00180503
LAB_001804f9:
LEA RAX,[0x4ffb50]
MOV byte ptr [RAX],0x0
LAB_00180503:
JMP 0x00180505
LAB_00180505:
JMP 0x00180507
LAB_00180507:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
ADD RSP,0x50
POP RBP
RET
|
int my_setwd(char *param_1,ulong param_2)
{
int iVar1;
int iVar2;
uint uVar3;
int *piVar4;
long lVar5;
char *local_10;
if ((*param_1 == '\0') || ((local_10 = param_1, *param_1 == '/' && (param_1[1] == '\0')))) {
local_10 = "/";
}
iVar1 = chdir(local_10);
if (iVar1 == 0) {
iVar2 = test_if_hard_path(param_1);
if (iVar2 == 0) {
curr_dir = 0;
}
else {
lVar5 = strmake(&curr_dir,param_1,0x1ff);
if (*(char *)(lVar5 + -1) != '/') {
uVar3 = (int)lVar5 - 0x4ffb50;
(&curr_dir)[uVar3] = 0x2f;
(&DAT_004ffb51)[uVar3] = 0;
}
}
}
else {
piVar4 = __errno_location();
iVar2 = *piVar4;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar2;
if ((param_2 & 0x10) != 0) {
piVar4 = __errno_location();
my_error(0x11,4,param_1,*piVar4);
}
}
return iVar1;
}
| |
54,768 | ok1 | eloqsql/unittest/mytap/tap.c | void
ok1(int const pass)
{
va_list ap;
memset(&ap, 0, sizeof(ap));
if (!pass && *g_test.todo == '\0')
++g_test.failed;
vemit_tap(pass, NULL, ap);
if (*g_test.todo != '\0')
emit_dir("todo", g_test.todo);
emit_endl();
} | O3 | c | ok1:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
testl %edi, %edi
jne 0x2d616
cmpb $0x0, 0x360ce6(%rip) # 0x38e2f4
jne 0x2d616
incl 0x360cda(%rip) # 0x38e2f0
leaq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0x2d53d
cmpb $0x0, 0x360ccc(%rip) # 0x38e2f4
je 0x2d65d
movq 0x2e9967(%rip), %rbx # 0x316f98
movq (%rbx), %rdi
leaq 0x4dc2c(%rip), %rdx # 0x7b267
leaq 0x4dbb4(%rip), %rcx # 0x7b1f6
leaq 0x360cab(%rip), %r8 # 0x38e2f4
movl $0x1, %esi
xorl %eax, %eax
callq 0x265e0
movq (%rbx), %rdi
callq 0x263e0
movq 0x2e9934(%rip), %rbx # 0x316f98
movq (%rbx), %rdi
leaq 0x527a2(%rip), %rdx # 0x7fe10
movl $0x1, %esi
xorl %eax, %eax
callq 0x265e0
movq (%rbx), %rdi
callq 0x263e0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
| ok1:
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
xorps xmm0, xmm0
movaps [rbp+var_20], xmm0
mov [rbp+var_10], 0
test edi, edi
jnz short loc_2D616
cmp cs:byte_38E2F4, 0
jnz short loc_2D616
inc cs:dword_38E2F0
loc_2D616:
lea rdx, [rbp+var_20]
xor esi, esi
call vemit_tap
cmp cs:byte_38E2F4, 0
jz short loc_2D65D
mov rbx, cs:stdout_ptr
mov rdi, [rbx]
lea rdx, aSS; " # %s %s"
lea rcx, aTodo; "todo"
lea r8, byte_38E2F4
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
call _fflush
loc_2D65D:
mov rbx, cs:stdout_ptr
mov rdi, [rbx]
lea rdx, asc_7FE0D+3; "\n"
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
call _fflush
add rsp, 18h
pop rbx
pop rbp
retn
| long long ok1(int a1)
{
long long v1; // rcx
long long v2; // r8
long long v3; // r9
__int128 v5; // [rsp+0h] [rbp-20h] BYREF
long long v6; // [rsp+10h] [rbp-10h]
v5 = 0LL;
v6 = 0LL;
if ( !a1 && !byte_38E2F4 )
++dword_38E2F0;
vemit_tap(a1, 0LL, (long long)&v5);
if ( byte_38E2F4 )
{
__fprintf_chk(stdout, 1LL, " # %s %s", "todo", &byte_38E2F4);
fflush(stdout);
}
__fprintf_chk(stdout, 1LL, "\n", v1, v2, v3, v5, v6);
return fflush(stdout);
}
| ok1:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x20],XMM0
MOV qword ptr [RBP + -0x10],0x0
TEST EDI,EDI
JNZ 0x0012d616
CMP byte ptr [0x0048e2f4],0x0
JNZ 0x0012d616
INC dword ptr [0x0048e2f0]
LAB_0012d616:
LEA RDX,[RBP + -0x20]
XOR ESI,ESI
CALL 0x0012d53d
CMP byte ptr [0x0048e2f4],0x0
JZ 0x0012d65d
MOV RBX,qword ptr [0x00416f98]
MOV RDI,qword ptr [RBX]
LEA RDX,[0x17b267]
LEA RCX,[0x17b1f6]
LEA R8,[0x48e2f4]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x001265e0
MOV RDI,qword ptr [RBX]
CALL 0x001263e0
LAB_0012d65d:
MOV RBX,qword ptr [0x00416f98]
MOV RDI,qword ptr [RBX]
LEA RDX,[0x17fe10]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x001265e0
MOV RDI,qword ptr [RBX]
CALL 0x001263e0
ADD RSP,0x18
POP RBX
POP RBP
RET
|
void ok1(int8 param_1)
{
int *puVar1;
int8 local_28;
int8 uStack_20;
int8 local_18;
local_28 = 0;
uStack_20 = 0;
local_18 = 0;
if (((int)param_1 == 0) && (DAT_0048e2f4 == '\0')) {
DAT_0048e2f0 = DAT_0048e2f0 + 1;
}
vemit_tap(param_1,0,&local_28);
puVar1 = PTR_stdout_00416f98;
if (DAT_0048e2f4 != '\0') {
__fprintf_chk(*(int8 *)PTR_stdout_00416f98,1," # %s %s",&DAT_0017b1f6,&DAT_0048e2f4);
fflush(*(FILE **)puVar1);
}
puVar1 = PTR_stdout_00416f98;
__fprintf_chk(*(int8 *)PTR_stdout_00416f98,1,&DAT_0017fe10);
fflush(*(FILE **)puVar1);
return;
}
| |
54,769 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) | llama.cpp/common/json.hpp | inline void grisu2(char* buf, int& len, int& decimal_exponent,
diyfp m_minus, diyfp v, diyfp m_plus)
{
JSON_ASSERT(m_plus.e == m_minus.e);
JSON_ASSERT(m_plus.e == v.e);
// --------(-----------------------+-----------------------)-------- (A)
// m- v m+
//
// --------------------(-----------+-----------------------)-------- (B)
// m- v m+
//
// First scale v (and m- and m+) such that the exponent is in the range
// [alpha, gamma].
const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
// The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
const diyfp w = diyfp::mul(v, c_minus_k);
const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
// ----(---+---)---------------(---+---)---------------(---+---)----
// w- w w+
// = c*m- = c*v = c*m+
//
// diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
// w+ are now off by a small amount.
// In fact:
//
// w - v * 10^k < 1 ulp
//
// To account for this inaccuracy, add resp. subtract 1 ulp.
//
// --------+---[---------------(---+---)---------------]---+--------
// w- M- w M+ w+
//
// Now any number in [M-, M+] (bounds included) will round to w when input,
// regardless of how the input rounding algorithm breaks ties.
//
// And digit_gen generates the shortest possible such number in [M-, M+].
// Note that this does not mean that Grisu2 always generates the shortest
// possible number in the interval (m-, m+).
const diyfp M_minus(w_minus.f + 1, w_minus.e);
const diyfp M_plus (w_plus.f - 1, w_plus.e );
decimal_exponent = -cached.k; // = -(-k) = k
grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x58(%rsp)
movl %r8d, 0x60(%rsp)
cmpl %r8d, 0xc8(%rsp)
jne 0x7f8c8
movq %rdi, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0xb0(%rsp), %r13
cmpl %r8d, 0x8(%r13)
jne 0x7f8e4
movl %r8d, %edi
callq 0x7f99f
movq %rdx, %r12
leaq 0x68(%rsp), %r14
movq %rax, (%r14)
movl %r12d, 0x8(%r14)
movq %r13, %rdi
movq %r14, %rsi
callq 0x7fae0
movq %rax, %r15
movl %edx, %ebx
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x7fae0
movq %rax, %r13
movl %edx, %ebp
leaq 0xc0(%rsp), %rdi
movq %r14, %rsi
callq 0x7fae0
incq %r13
decq %rax
shrq $0x20, %r12
negl %r12d
movq 0x30(%rsp), %rcx
movl %r12d, (%rcx)
movq %r15, 0x48(%rsp)
movl %ebx, 0x50(%rsp)
movq %rax, 0x38(%rsp)
movl %edx, 0x40(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rcx, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x7fb3c
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9a5c9(%rip), %rdi # 0x119e98
leaq 0x9a5fd(%rip), %rdx # 0x119ed3
leaq 0x9bb46(%rip), %rcx # 0x11b423
movl $0x454b, %esi # imm = 0x454B
jmp 0x7f8fe
leaq 0x9a5ad(%rip), %rdi # 0x119e98
leaq 0x9a5e1(%rip), %rdx # 0x119ed3
leaq 0x9bb40(%rip), %rcx # 0x11b439
movl $0x454c, %esi # imm = 0x454C
xorl %eax, %eax
callq 0x20e70
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl6grisu2EPcRiS4_NS2_5diyfpES5_S5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov [rsp+0A8h+var_50], rcx
mov [rsp+0A8h+var_48], r8d
cmp [rsp+0A8h+arg_18], r8d
jnz loc_7F8C8
mov [rsp+0A8h+var_88], rdi
mov [rsp+0A8h+var_80], rsi
mov [rsp+0A8h+var_78], rdx
lea r13, [rsp+0A8h+arg_0]
cmp [r13+8], r8d
jnz loc_7F8E4
mov edi, r8d; this
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl36get_cached_power_for_binary_exponentEi; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(int)
mov r12, rdx
lea r14, [rsp+0A8h+var_40]
mov [r14], rax
mov [r14+8], r12d
mov rdi, r13
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov r15, rax
mov ebx, edx
lea rdi, [rsp+0A8h+var_50]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov r13, rax
mov ebp, edx
lea rdi, [rsp+0A8h+arg_10]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
inc r13
dec rax
shr r12, 20h
neg r12d
mov rcx, [rsp+0A8h+var_78]
mov [rcx], r12d
mov qword ptr [rsp+0A8h+var_60], r15
mov dword ptr [rsp+0A8h+var_60+8], ebx
mov qword ptr [rsp+0A8h+var_70], rax
mov dword ptr [rsp+0A8h+var_70+8], edx
movups xmm0, xmmword ptr [rsp+0A8h+var_70]
movups xmmword ptr [rsp+0A8h+var_98], xmm0; char
movups xmm0, xmmword ptr [rsp+0A8h+var_60]
movups xmmword ptr [rsp+0A8h+var_A8], xmm0; char
mov rdi, [rsp+0A8h+var_88]; this
mov rsi, [rsp+0A8h+var_80]
mov rdx, rcx
mov rcx, r13
mov r8d, ebp
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl16grisu2_digit_genEPcRiS4_NS2_5diyfpES5_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char *,int &,int &,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7F8C8:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEMMinusE; "m_plus.e == m_minus.e"
mov esi, 454Bh
jmp short loc_7F8FE
loc_7F8E4:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEVE; "m_plus.e == v.e"
mov esi, 454Ch
loc_7F8FE:
xor eax, eax
call _ggml_abort
nop
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *a1,
int a2,
_DWORD *a3,
long long a4,
unsigned int a5,
long long a6,
char a7,
int a8,
char a9,
int a10)
{
long long cached_power_for_binary_exponent; // rax
int v11; // rdx^4
int v12; // r12^4
int v13; // edx
char v14; // r15
int v15; // edx
int v16; // ebx
char v17; // al
int v18; // edx
long long v20; // rsi
long long v22; // [rsp+58h] [rbp-50h] BYREF
unsigned int v23; // [rsp+60h] [rbp-48h]
long long v24; // [rsp+68h] [rbp-40h] BYREF
int v25; // [rsp+70h] [rbp-38h]
v22 = a4;
v23 = a5;
if ( a10 == a5 )
{
if ( a8 == a5 )
{
cached_power_for_binary_exponent = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)a5,
a2);
v12 = v11;
v24 = cached_power_for_binary_exponent;
v25 = v13;
v14 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&a7, &v24);
v16 = v15;
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&v22, &v24);
v17 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&a9, &v24);
*a3 = -v12;
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(a1, v14, v16, v17 - 1, v18);
}
v20 = 17740LL;
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17740LL,
"GGML_ASSERT(%s) failed",
"m_plus.e == v.e");
}
else
{
v20 = 17739LL;
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
17739LL,
"GGML_ASSERT(%s) failed",
"m_plus.e == m_minus.e");
}
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
v20);
}
| grisu2:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RSP + 0x58],RCX
MOV dword ptr [RSP + 0x60],R8D
CMP dword ptr [RSP + 0xc8],R8D
JNZ 0x0017f8c8
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
LEA R13,[RSP + 0xb0]
CMP dword ptr [R13 + 0x8],R8D
JNZ 0x0017f8e4
MOV EDI,R8D
CALL 0x0017f99f
MOV R12,RDX
LEA R14,[RSP + 0x68]
MOV qword ptr [R14],RAX
MOV dword ptr [R14 + 0x8],R12D
MOV RDI,R13
MOV RSI,R14
CALL 0x0017fae0
MOV R15,RAX
MOV EBX,EDX
LEA RDI,[RSP + 0x58]
MOV RSI,R14
CALL 0x0017fae0
MOV R13,RAX
MOV EBP,EDX
LEA RDI,[RSP + 0xc0]
MOV RSI,R14
CALL 0x0017fae0
INC R13
DEC RAX
SHR R12,0x20
NEG R12D
MOV RCX,qword ptr [RSP + 0x30]
MOV dword ptr [RCX],R12D
MOV qword ptr [RSP + 0x48],R15
MOV dword ptr [RSP + 0x50],EBX
MOV qword ptr [RSP + 0x38],RAX
MOV dword ptr [RSP + 0x40],EDX
MOVUPS XMM0,xmmword ptr [RSP + 0x38]
MOVUPS xmmword ptr [RSP + 0x10],XMM0
MOVUPS XMM0,xmmword ptr [RSP + 0x48]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,RCX
MOV RCX,R13
MOV R8D,EBP
CALL 0x0017fb3c
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017f8c8:
LEA RDI,[0x219e98]
LEA RDX,[0x219ed3]
LEA RCX,[0x21b423]
MOV ESI,0x454b
JMP 0x0017f8fe
LAB_0017f8e4:
LEA RDI,[0x219e98]
LEA RDX,[0x219ed3]
LEA RCX,[0x21b439]
MOV ESI,0x454c
LAB_0017f8fe:
XOR EAX,EAX
CALL 0x00120e70
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2
(int8 param_1,int8 param_2,int *param_3,int8 param_4,int param_5,
int8 param_6,int8 param_7,int param_8,int8 param_9,int param_10)
{
int4 uVar1;
char *pcVar2;
int4 extraout_EDX;
int8 uVar3;
int1 auVar4 [12];
int1 auVar5 [12];
int1 auVar6 [16];
int4 uStack_64;
int8 local_50;
int local_48;
int8 local_40;
int4 local_38;
local_50 = param_4;
local_48 = param_5;
if (param_10 == param_5) {
if (param_8 == param_5) {
auVar6 = get_cached_power_for_binary_exponent(param_5);
local_40 = auVar6._0_8_;
local_38 = auVar6._8_4_;
uVar1 = diyfp::mul((diyfp *)¶m_7,(diyfp *)&local_40);
auVar4 = diyfp::mul((diyfp *)&local_50,(diyfp *)&local_40);
auVar5 = diyfp::mul((diyfp *)¶m_9,(diyfp *)&local_40);
*param_3 = -auVar6._12_4_;
grisu2_digit_gen(param_1,param_2,param_3,auVar4._0_8_ + 1,auVar4._8_4_,param_6,uVar1,
extraout_EDX,auVar5._0_8_ + -1,CONCAT44(uStack_64,auVar5._8_4_));
return;
}
pcVar2 = "m_plus.e == v.e";
uVar3 = 0x454c;
}
else {
pcVar2 = "m_plus.e == m_minus.e";
uVar3 = 0x454b;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
| |
54,770 | count_square | eloqsql/storage/myisam/rt_split.c | static double count_square(const double *a, int n_dim)
{
const double *end = a + n_dim * 2;
double square = 1.0;
do
{
square *= a[1] - a[0];
a += 2;
}while (a != end);
return square;
} | O0 | c | count_square:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movsd 0x830e6(%rip), %xmm0 # 0x158c60
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd (%rax), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xd5b7f
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
| count_square_0:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
mov ecx, [rbp+var_C]
shl ecx, 1
movsxd rcx, ecx
shl rcx, 3
add rax, rcx
mov [rbp+var_18], rax
movsd xmm0, cs:qword_158C60
movsd [rbp+var_20], xmm0
loc_D5B7F:
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax+8]
mov rax, [rbp+var_8]
subsd xmm0, qword ptr [rax]
mulsd xmm0, [rbp+var_20]
movsd [rbp+var_20], xmm0
mov rax, [rbp+var_8]
add rax, 10h
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
cmp rax, [rbp+var_18]
jnz short loc_D5B7F
movsd xmm0, [rbp+var_20]
pop rbp
retn
| double count_square_0(double *a1, int a2)
{
double v3; // [rsp+0h] [rbp-20h]
double *v4; // [rsp+18h] [rbp-8h]
v4 = a1;
v3 = 1.0;
do
{
v3 = (v4[1] - *v4) * v3;
v4 += 2;
}
while ( v4 != &a1[2 * a2] );
return v3;
}
| count_square:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
SHL ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOVSD XMM0,qword ptr [0x00258c60]
MOVSD qword ptr [RBP + -0x20],XMM0
LAB_001d5b7f:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x8]
SUBSD XMM0,qword ptr [RAX]
MULSD XMM0,qword ptr [RBP + -0x20]
MOVSD qword ptr [RBP + -0x20],XMM0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x10
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x001d5b7f
MOVSD XMM0,qword ptr [RBP + -0x20]
POP RBP
RET
|
double count_square(double *param_1,int param_2)
{
double local_28;
double *local_10;
local_28 = DAT_00258c60;
local_10 = param_1;
do {
local_28 = (local_10[1] - *local_10) * local_28;
local_10 = local_10 + 2;
} while (local_10 != param_1 + (param_2 << 1));
return local_28;
}
| |
54,771 | host_emit_log | corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_evmone.c | static void host_emit_log(void* context, const evmc_address* addr, const uint8_t* data, size_t data_size, const evmc_bytes32 topics[], size_t topics_count) {
evmone_context_t* ctx = (evmone_context_t*) context;
debug_print_address("emit_log from", addr);
EVM_LOG("emit_log: data size: %zu bytes, topics count: %zu", data_size, topics_count);
if (data && data_size > 0 && EVM_DEBUG) {
fprintf(stderr, "[EVM] Log data (hex): 0x");
for (size_t i = 0; i < (data_size > 64 ? 64 : data_size); i++) {
fprintf(stderr, "%02x", data[i]);
}
if (data_size > 64) fprintf(stderr, "...");
fprintf(stderr, "\n");
}
for (size_t i = 0; i < topics_count && EVM_DEBUG; i++) {
debug_print_bytes32("Log topic", &topics[i]);
}
} | O0 | c | host_emit_log:
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 %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq 0xaf4e2(%rip), %rdi # 0xdda25
callq 0x2db70
jmp 0x2e54a
cmpq $0x0, -0x18(%rbp)
je 0x2e623
cmpq $0x0, -0x20(%rbp)
jbe 0x2e623
xorl %eax, %eax
testb $0x1, %al
jne 0x2e56b
jmp 0x2e623
movq 0x10aa56(%rip), %rax # 0x138fc8
movq (%rax), %rdi
leaq 0xaf4b7(%rip), %rsi # 0xdda33
movb $0x0, %al
callq 0x23160
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x40, -0x20(%rbp)
jbe 0x2e5a5
movl $0x40, %eax
movq %rax, -0x58(%rbp)
jmp 0x2e5ad
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
cmpq %rcx, %rax
jae 0x2e5ec
movq 0x10aa07(%rip), %rax # 0x138fc8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0xaf299(%rip), %rsi # 0xdd870
movb $0x0, %al
callq 0x23160
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x2e58b
cmpq $0x40, -0x20(%rbp)
jbe 0x2e60b
movq 0x10a9ce(%rip), %rax # 0x138fc8
movq (%rax), %rdi
leaq 0xaf271(%rip), %rsi # 0xdd875
movb $0x0, %al
callq 0x23160
movq 0x10a9b6(%rip), %rax # 0x138fc8
movq (%rax), %rdi
leaq 0xada6a(%rip), %rsi # 0xdc086
movb $0x0, %al
callq 0x23160
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0x2e641
xorl %eax, %eax
movb %al, -0x59(%rbp)
jmp 0x2e641
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x2e64a
jmp 0x2e673
movq -0x28(%rbp), %rsi
movq -0x48(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
leaq 0xaf3ec(%rip), %rdi # 0xdda4c
callq 0x2db80
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x2e62b
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| host_emit_log:
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 [rbp+var_30], r9
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
mov rsi, [rbp+var_10]
lea rdi, aEmitLogFrom; "emit_log from"
call debug_print_address
jmp short $+2
loc_2E54A:
cmp [rbp+var_18], 0
jz loc_2E623
cmp [rbp+var_20], 0
jbe loc_2E623
xor eax, eax
test al, 1
jnz short loc_2E56B
jmp loc_2E623
loc_2E56B:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aEvmLogDataHex0; "[EVM] Log data (hex): 0x"
mov al, 0
call _fprintf
mov [rbp+var_40], 0
loc_2E58B:
mov rax, [rbp+var_40]
mov [rbp+var_50], rax
cmp [rbp+var_20], 40h ; '@'
jbe short loc_2E5A5
mov eax, 40h ; '@'
mov [rbp+var_58], rax
jmp short loc_2E5AD
loc_2E5A5:
mov rax, [rbp+var_20]
mov [rbp+var_58], rax
loc_2E5AD:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_58]
cmp rax, rcx
jnb short loc_2E5EC
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rax, [rbp+var_18]
mov rcx, [rbp+var_40]
movzx edx, byte ptr [rax+rcx]
lea rsi, a02x; "%02x"
mov al, 0
call _fprintf
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp short loc_2E58B
loc_2E5EC:
cmp [rbp+var_20], 40h ; '@'
jbe short loc_2E60B
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, asc_DD875; "..."
mov al, 0
call _fprintf
loc_2E60B:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aOptions+9; "\n"
mov al, 0
call _fprintf
loc_2E623:
mov [rbp+var_48], 0
loc_2E62B:
mov rcx, [rbp+var_48]
xor eax, eax
cmp rcx, [rbp+var_30]
mov [rbp+var_59], al
jnb short loc_2E641
xor eax, eax
mov [rbp+var_59], al
jmp short $+2
loc_2E641:
mov al, [rbp+var_59]
test al, 1
jnz short loc_2E64A
jmp short loc_2E673
loc_2E64A:
mov rsi, [rbp+var_28]
mov rax, [rbp+var_48]
shl rax, 5
add rsi, rax
lea rdi, aLogTopic; "Log topic"
call debug_print_bytes32
mov rax, [rbp+var_48]
add rax, 1
mov [rbp+var_48], rax
jmp short loc_2E62B
loc_2E673:
add rsp, 60h
pop rbp
retn
| char host_emit_log()
{
debug_print_address();
return 0;
}
| host_emit_log:
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 qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV RSI,qword ptr [RBP + -0x10]
LEA RDI,[0x1dda25]
CALL 0x0012db70
JMP 0x0012e54a
LAB_0012e54a:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0012e623
CMP qword ptr [RBP + -0x20],0x0
JBE 0x0012e623
XOR EAX,EAX
TEST AL,0x1
JNZ 0x0012e56b
JMP 0x0012e623
LAB_0012e56b:
MOV RAX,qword ptr [0x00238fc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1dda33]
MOV AL,0x0
CALL 0x00123160
MOV qword ptr [RBP + -0x40],0x0
LAB_0012e58b:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x50],RAX
CMP qword ptr [RBP + -0x20],0x40
JBE 0x0012e5a5
MOV EAX,0x40
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0012e5ad
LAB_0012e5a5:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x58],RAX
LAB_0012e5ad:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x58]
CMP RAX,RCX
JNC 0x0012e5ec
MOV RAX,qword ptr [0x00238fc8]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x40]
MOVZX EDX,byte ptr [RAX + RCX*0x1]
LEA RSI,[0x1dd870]
MOV AL,0x0
CALL 0x00123160
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0012e58b
LAB_0012e5ec:
CMP qword ptr [RBP + -0x20],0x40
JBE 0x0012e60b
MOV RAX,qword ptr [0x00238fc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1dd875]
MOV AL,0x0
CALL 0x00123160
LAB_0012e60b:
MOV RAX,qword ptr [0x00238fc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1dc086]
MOV AL,0x0
CALL 0x00123160
LAB_0012e623:
MOV qword ptr [RBP + -0x48],0x0
LAB_0012e62b:
MOV RCX,qword ptr [RBP + -0x48]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x30]
MOV byte ptr [RBP + -0x59],AL
JNC 0x0012e641
XOR EAX,EAX
MOV byte ptr [RBP + -0x59],AL
JMP 0x0012e641
LAB_0012e641:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x0012e64a
JMP 0x0012e673
LAB_0012e64a:
MOV RSI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x48]
SHL RAX,0x5
ADD RSI,RAX
LEA RDI,[0x1dda4c]
CALL 0x0012db80
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0012e62b
LAB_0012e673:
ADD RSP,0x60
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x0012e56b) */
/* WARNING: Removing unreachable block (ram,0x0012e58b) */
/* WARNING: Removing unreachable block (ram,0x0012e5a5) */
/* WARNING: Removing unreachable block (ram,0x0012e59a) */
/* WARNING: Removing unreachable block (ram,0x0012e5ad) */
/* WARNING: Removing unreachable block (ram,0x0012e5ec) */
/* WARNING: Removing unreachable block (ram,0x0012e5f3) */
/* WARNING: Removing unreachable block (ram,0x0012e60b) */
/* WARNING: Removing unreachable block (ram,0x0012e5ba) */
/* WARNING: Removing unreachable block (ram,0x0012e64a) */
void host_emit_log(int8 param_1,int8 param_2)
{
debug_print_address("emit_log from",param_2);
return;
}
| |
54,772 | host_emit_log | corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_evmone.c | static void host_emit_log(void* context, const evmc_address* addr, const uint8_t* data, size_t data_size, const evmc_bytes32 topics[], size_t topics_count) {
evmone_context_t* ctx = (evmone_context_t*) context;
debug_print_address("emit_log from", addr);
EVM_LOG("emit_log: data size: %zu bytes, topics count: %zu", data_size, topics_count);
if (data && data_size > 0 && EVM_DEBUG) {
fprintf(stderr, "[EVM] Log data (hex): 0x");
for (size_t i = 0; i < (data_size > 64 ? 64 : data_size); i++) {
fprintf(stderr, "%02x", data[i]);
}
if (data_size > 64) fprintf(stderr, "...");
fprintf(stderr, "\n");
}
for (size_t i = 0; i < topics_count && EVM_DEBUG; i++) {
debug_print_bytes32("Log topic", &topics[i]);
}
} | O2 | c | host_emit_log:
retq
| host_emit_log:
retn
| void host_emit_log()
{
;
}
| host_emit_log:
RET
|
void host_emit_log(void)
{
return;
}
| |
54,773 | wait_for_free_space | eloqsql/mysys/errors.c | void wait_for_free_space(const char *filename, int errors)
{
if (errors == 0)
my_error(EE_DISK_FULL,MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
filename,my_errno,MY_WAIT_FOR_USER_TO_FIX_PANIC);
if (!(errors % MY_WAIT_GIVE_USER_A_MESSAGE))
my_printf_error(EE_DISK_FULL,
"Retry in %d secs. Message reprinted in %d secs",
MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
MY_WAIT_FOR_USER_TO_FIX_PANIC,
MY_WAIT_GIVE_USER_A_MESSAGE * MY_WAIT_FOR_USER_TO_FIX_PANIC );
(void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
} | O3 | c | wait_for_free_space:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x2dcf5
imull $0xcccccccd, %esi, %eax # imm = 0xCCCCCCCD
movl $0x19999998, %ecx # imm = 0x19999998
addl %ecx, %eax
rorl %eax
cmpl %ecx, %eax
ja 0x2dd3c
jmp 0x2dd19
movq %rdi, %rbx
callq 0x2a19e
movl (%rax), %ecx
movl $0x844, %esi # imm = 0x844
movl $0x14, %edi
movq %rbx, %rdx
movl $0x3c, %r8d
xorl %eax, %eax
callq 0x2fcb7
leaq 0x354d3(%rip), %rsi # 0x631f3
movl $0x844, %edx # imm = 0x844
movl $0x14, %edi
movl $0x3c, %ecx
movl $0x258, %r8d # imm = 0x258
xorl %eax, %eax
callq 0x2fdd1
movl $0x3c, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x24200
| wait_for_free_space:
push rbp
mov rbp, rsp
push rbx
push rax
test esi, esi
jz short loc_2DCF5
imul eax, esi, 0CCCCCCCDh
mov ecx, 19999998h
add eax, ecx
ror eax, 1
cmp eax, ecx
ja short loc_2DD3C
jmp short loc_2DD19
loc_2DCF5:
mov rbx, rdi
call _my_thread_var
mov ecx, [rax]
mov esi, 844h
mov edi, 14h
mov rdx, rbx
mov r8d, 3Ch ; '<'
xor eax, eax
call my_error
loc_2DD19:
lea rsi, aRetryInDSecsMe; "Retry in %d secs. Message reprinted in "...
mov edx, 844h
mov edi, 14h
mov ecx, 3Ch ; '<'
mov r8d, 258h
xor eax, eax
call my_printf_error
loc_2DD3C:
mov edi, 3Ch ; '<'
add rsp, 8
pop rbx
pop rbp
jmp _sleep
| long long wait_for_free_space(int a1, int a2, long long a3, long long a4, long long a5, int a6)
{
char v6; // al
_DWORD *v7; // rax
int v8; // r9d
char v10; // [rsp-8h] [rbp-10h]
v10 = v6;
if ( !a2 )
{
v7 = (_DWORD *)my_thread_var();
my_error(20, 2116, a1, *v7, 60, v8);
LABEL_5:
my_printf_error(20, (unsigned int)"Retry in %d secs. Message reprinted in %d secs", 2116, 60, 600, a6, v10);
return sleep(60LL);
}
if ( __ROR4__(-858993459 * a2 + 429496728, 1) <= 0x19999998u )
goto LABEL_5;
return sleep(60LL);
}
| wait_for_free_space:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
TEST ESI,ESI
JZ 0x0012dcf5
IMUL EAX,ESI,-0x33333333
MOV ECX,0x19999998
ADD EAX,ECX
ROR EAX,0x1
CMP EAX,ECX
JA 0x0012dd3c
JMP 0x0012dd19
LAB_0012dcf5:
MOV RBX,RDI
CALL 0x0012a19e
MOV ECX,dword ptr [RAX]
MOV ESI,0x844
MOV EDI,0x14
MOV RDX,RBX
MOV R8D,0x3c
XOR EAX,EAX
CALL 0x0012fcb7
LAB_0012dd19:
LEA RSI,[0x1631f3]
MOV EDX,0x844
MOV EDI,0x14
MOV ECX,0x3c
MOV R8D,0x258
XOR EAX,EAX
CALL 0x0012fdd1
LAB_0012dd3c:
MOV EDI,0x3c
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00124200
|
void wait_for_free_space(int8 param_1,int param_2)
{
uint uVar1;
int4 *puVar2;
if (param_2 == 0) {
puVar2 = (int4 *)_my_thread_var();
my_error(0x14,0x844,param_1,*puVar2,0x3c);
}
else {
uVar1 = param_2 * -0x33333333 + 0x19999998;
if (0x19999998 < (uVar1 >> 1 | (uint)((uVar1 & 1) != 0) << 0x1f)) goto LAB_0012dd3c;
}
my_printf_error(0x14,"Retry in %d secs. Message reprinted in %d secs",0x844,0x3c,600);
LAB_0012dd3c:
sleep(0x3c);
return;
}
| |
54,774 | SchemaConverter::check_errors() | monkey531[P]llama/common/json-schema-to-grammar.cpp | void check_errors() {
if (!_errors.empty()) {
throw std::runtime_error("JSON schema conversion failed:\n" + string_join(_errors, "\n"));
}
if (!_warnings.empty()) {
fprintf(stderr, "WARNING: JSON schema conversion was incomplete: %s\n", string_join(_warnings, "; ").c_str());
}
} | O2 | cpp | SchemaConverter::check_errors():
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
movq 0xc8(%rdi), %rax
cmpq 0xd0(%rdi), %rax
jne 0x8ce7c
movq 0xe0(%r14), %rax
cmpq 0xe8(%r14), %rax
jne 0x8ce16
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x7116b(%rip), %rax # 0xfdf88
movq (%rax), %rbx
leaq 0x2bbf2(%rip), %rsi # 0xb8a19
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x2724a
addq $0xe0, %r14
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
callq 0x53e02
leaq 0x30(%rsp), %r14
movq (%r14), %rdx
leaq 0x2bb87(%rip), %rsi # 0xb89e5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x23ce0
movq %r14, %rdi
callq 0x24218
leaq 0x10(%rsp), %rdi
callq 0x24218
jmp 0x8ce0d
pushq $0x10
popq %rdi
callq 0x23480
movq %rax, %rbx
leaq 0x22eaa(%rip), %rsi # 0xafd38
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2724a
addq $0xc8, %r14
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movq %r14, %rsi
callq 0x53e02
leaq 0x2bb08(%rip), %rsi # 0xb89c5
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x2730b
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x23e70
xorl %ebp, %ebp
movq 0x7110b(%rip), %rsi # 0xfdff0
movq 0x7106c(%rip), %rdx # 0xfdf58
movq %rbx, %rdi
callq 0x23f40
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x24218
jmp 0x8cf09
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x24218
jmp 0x8cf1b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rdi
callq 0x24218
testb %bpl, %bpl
jne 0x8cf2f
jmp 0x8cf4b
movq %rax, %r14
movq %rbx, %rdi
callq 0x236b0
jmp 0x8cf4b
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x24218
jmp 0x8cf4b
movq %rax, %r14
movq %r14, %rdi
callq 0x23fd0
nop
| _ZN15SchemaConverter12check_errorsEv:
push rbp
push r14
push rbx
sub rsp, 70h
mov r14, rdi
mov rax, [rdi+0C8h]
cmp rax, [rdi+0D0h]
jnz short loc_8CE7C
mov rax, [r14+0E0h]
cmp rax, [r14+0E8h]
jnz short loc_8CE16
loc_8CE0D:
add rsp, 70h
pop rbx
pop r14
pop rbp
retn
loc_8CE16:
mov rax, cs:stderr_ptr
mov rbx, [rax]
lea rsi, asc_B8A19; "; "
lea rdi, [rsp+88h+var_78]
lea rdx, [rsp+88h+var_38]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
add r14, 0E0h
lea rdi, [rsp+88h+var_58]
lea rdx, [rsp+88h+var_78]
mov rsi, r14
call _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_; string_join(std::vector<std::string> const&,std::string const&)
lea r14, [rsp+88h+var_58]
mov rdx, [r14]
lea rsi, aWarningJsonSch; "WARNING: JSON schema conversion was inc"...
mov rdi, rbx
xor eax, eax
call _fprintf
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+88h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8CE0D
loc_8CE7C:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aErrorWhileHand_0+33h; "\n"
lea rdi, [rsp+88h+var_38]
lea rdx, [rsp+88h+var_79]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
add r14, 0C8h
lea rdi, [rsp+88h+var_78]
lea rdx, [rsp+88h+var_38]
mov rsi, r14
call _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_; string_join(std::vector<std::string> const&,std::string const&)
lea rsi, aJsonSchemaConv; "JSON schema conversion failed:\n"
lea rdi, [rsp+88h+var_58]
lea rdx, [rsp+88h+var_78]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+88h+var_58]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+88h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8CF09
mov r14, rax
mov bpl, 1
loc_8CF09:
lea rdi, [rsp+88h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8CF1B
mov r14, rax
mov bpl, 1
loc_8CF1B:
lea rdi, [rsp+88h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_8CF2F
jmp short loc_8CF4B
mov r14, rax
loc_8CF2F:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_8CF4B
mov r14, rax
lea rdi, [rsp+88h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8CF4B
mov r14, rax
loc_8CF4B:
mov rdi, r14
call __Unwind_Resume
| void SchemaConverter::check_errors(SchemaConverter *this)
{
long long v1; // rbx
void *exception; // rbx
_QWORD v3[4]; // [rsp+10h] [rbp-78h] BYREF
const char *v4[4]; // [rsp+30h] [rbp-58h] BYREF
_QWORD v5[7]; // [rsp+50h] [rbp-38h] BYREF
if ( *((_QWORD *)this + 25) != *((_QWORD *)this + 26) )
{
exception = __cxa_allocate_exception(0x10uLL);
std::string::basic_string<std::allocator<char>>(v5, (long long)"\n");
string_join((long long)v3, (long long *)this + 25, (long long)v5);
std::operator+<char>((long long)v4, (long long)"JSON schema conversion failed:\n", (long long)v3);
std::runtime_error::runtime_error(exception, v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( *((_QWORD *)this + 28) != *((_QWORD *)this + 29) )
{
v1 = stderr;
std::string::basic_string<std::allocator<char>>(v3, (long long)"; ");
string_join((long long)v4, (long long *)this + 28, (long long)v3);
fprintf(v1, "WARNING: JSON schema conversion was incomplete: %s\n", v4[0]);
std::string::~string(v4);
std::string::~string(v3);
}
}
| check_errors:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x70
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0xc8]
CMP RAX,qword ptr [RDI + 0xd0]
JNZ 0x0018ce7c
MOV RAX,qword ptr [R14 + 0xe0]
CMP RAX,qword ptr [R14 + 0xe8]
JNZ 0x0018ce16
LAB_0018ce0d:
ADD RSP,0x70
POP RBX
POP R14
POP RBP
RET
LAB_0018ce16:
MOV RAX,qword ptr [0x001fdf88]
MOV RBX,qword ptr [RAX]
LAB_0018ce20:
LEA RSI,[0x1b8a19]
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x50]
CALL 0x0012724a
LAB_0018ce36:
ADD R14,0xe0
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0x10]
MOV RSI,R14
CALL 0x00153e02
LAB_0018ce4f:
LEA R14,[RSP + 0x30]
MOV RDX,qword ptr [R14]
LEA RSI,[0x1b89e5]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00123ce0
MOV RDI,R14
CALL 0x00124218
LEA RDI,[RSP + 0x10]
CALL 0x00124218
JMP 0x0018ce0d
LAB_0018ce7c:
PUSH 0x10
POP RDI
CALL 0x00123480
MOV RBX,RAX
LAB_0018ce87:
LEA RSI,[0x1afd38]
LEA RDI,[RSP + 0x50]
LEA RDX,[RSP + 0xf]
CALL 0x0012724a
LAB_0018ce9d:
ADD R14,0xc8
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x50]
MOV RSI,R14
CALL 0x00153e02
LAB_0018ceb6:
LEA RSI,[0x1b89c5]
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0x10]
CALL 0x0012730b
MOV BPL,0x1
LAB_0018cecf:
LEA RSI,[RSP + 0x30]
MOV RDI,RBX
CALL 0x00123e70
XOR EBP,EBP
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,RBX
CALL 0x00123f40
|
/* SchemaConverter::check_errors() */
void __thiscall SchemaConverter::check_errors(SchemaConverter *this)
{
FILE *__stream;
runtime_error *this_00;
allocator local_79;
string local_78 [32];
int8 local_58 [4];
allocator local_38 [32];
if (*(long *)(this + 200) == *(long *)(this + 0xd0)) {
if (*(long *)(this + 0xe0) != *(long *)(this + 0xe8)) {
__stream = *(FILE **)PTR_stderr_001fdf88;
/* try { // try from 0018ce20 to 0018ce35 has its CatchHandler @ 0018cf48 */
std::__cxx11::string::string<std::allocator<char>>(local_78,"; ",local_38);
/* try { // try from 0018ce36 to 0018ce4e has its CatchHandler @ 0018cf39 */
string_join((vector *)local_58,(string *)(this + 0xe0));
fprintf(__stream,"WARNING: JSON schema conversion was incomplete: %s\n",local_58[0]);
std::__cxx11::string::~string((string *)local_58);
std::__cxx11::string::~string(local_78);
}
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0018ce87 to 0018ce9c has its CatchHandler @ 0018cf2c */
std::__cxx11::string::string<std::allocator<char>>((string *)local_38,"\n",&local_79);
/* try { // try from 0018ce9d to 0018ceb5 has its CatchHandler @ 0018cf15 */
string_join((vector *)local_78,(string *)(this + 200));
/* try { // try from 0018ceb6 to 0018cecb has its CatchHandler @ 0018cf03 */
std::operator+((char *)local_58,(string *)"JSON schema conversion failed:\n");
/* try { // try from 0018cecf to 0018cef3 has its CatchHandler @ 0018cef4 */
std::runtime_error::runtime_error(this_00,(string *)local_58);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
| |
54,775 | OpenSubdiv::v3_6_0::Vtr::internal::QuadRefinement::allocateParentChildIndices() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/quadRefinement.cpp | void
QuadRefinement::allocateParentChildIndices() {
//
// Initialize the vectors of indices mapping parent components to those child components
// that will originate from each.
//
int faceChildFaceCount = (int) _parent->_faceVertIndices.size();
int faceChildEdgeCount = (int) _parent->_faceEdgeIndices.size();
int edgeChildEdgeCount = (int) _parent->_edgeVertIndices.size();
int faceChildVertCount = _parent->getNumFaces();
int edgeChildVertCount = _parent->getNumEdges();
int vertChildVertCount = _parent->getNumVertices();
//
// First reference the parent Level's face-vertex counts/offsets -- they can be used
// here for both the face-child-faces and face-child-edges as they both have one per
// face-vertex.
//
// Given we will be ignoring initial values with uniform refinement and assigning all
// directly, initializing here is a waste...
//
Index initValue = 0;
_faceChildFaceCountsAndOffsets = _parent->shareFaceVertCountsAndOffsets();
_faceChildEdgeCountsAndOffsets = _parent->shareFaceVertCountsAndOffsets();
_faceChildFaceIndices.resize(faceChildFaceCount, initValue);
_faceChildEdgeIndices.resize(faceChildEdgeCount, initValue);
_edgeChildEdgeIndices.resize(edgeChildEdgeCount, initValue);
_faceChildVertIndex.resize(faceChildVertCount, initValue);
_edgeChildVertIndex.resize(edgeChildVertCount, initValue);
_vertChildVertIndex.resize(vertChildVertCount, initValue);
} | O1 | cpp | OpenSubdiv::v3_6_0::Vtr::internal::QuadRefinement::allocateParentChildIndices():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x38(%rcx), %rax
movq 0x50(%rcx), %r14
subq 0x30(%rcx), %rax
subq 0x48(%rcx), %r14
movq 0x80(%rcx), %rbp
subq 0x78(%rcx), %rbp
movslq (%rcx), %r13
movslq 0x4(%rcx), %r12
movslq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
leaq 0x14(%rsp), %r15
movl $0x0, (%r15)
movq 0x18(%rcx), %rdx
movq 0x20(%rcx), %rsi
subq %rdx, %rsi
shrq $0x2, %rsi
movq %rdx, 0x58(%rdi)
movl %esi, 0x60(%rdi)
movq 0x18(%rcx), %rdx
movq 0x20(%rcx), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movq %rdx, 0x68(%rdi)
movl %ecx, 0x70(%rdi)
addq $0x78, %rdi
shrq $0x2, %rax
movslq %eax, %rsi
movq %r15, %rdx
callq 0x38f90
leaq 0x90(%rbx), %rdi
shrq $0x2, %r14
movslq %r14d, %rsi
movq %r15, %rdx
callq 0x38f90
leaq 0xc0(%rbx), %rdi
shrq $0x2, %rbp
movslq %ebp, %rsi
movq %r15, %rdx
callq 0x38f90
leaq 0xa8(%rbx), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x38f90
leaq 0xd8(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x38f90
addq $0xf0, %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x38f90
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN10OpenSubdiv6v3_6_03Vtr8internal14QuadRefinement26allocateParentChildIndicesEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov rcx, [rdi+8]
mov rax, [rcx+38h]
mov r14, [rcx+50h]
sub rax, [rcx+30h]
sub r14, [rcx+48h]
mov rbp, [rcx+80h]
sub rbp, [rcx+78h]
movsxd r13, dword ptr [rcx]
movsxd r12, dword ptr [rcx+4]
movsxd rdx, dword ptr [rcx+8]
mov [rsp+48h+var_40], rdx
lea r15, [rsp+48h+var_34]
mov dword ptr [r15], 0
mov rdx, [rcx+18h]
mov rsi, [rcx+20h]
sub rsi, rdx
shr rsi, 2
mov [rdi+58h], rdx
mov [rdi+60h], esi
mov rdx, [rcx+18h]
mov rcx, [rcx+20h]
sub rcx, rdx
shr rcx, 2
mov [rdi+68h], rdx
mov [rdi+70h], ecx
add rdi, 78h ; 'x'
shr rax, 2
movsxd rsi, eax
mov rdx, r15
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
lea rdi, [rbx+90h]
shr r14, 2
movsxd rsi, r14d
mov rdx, r15
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
lea rdi, [rbx+0C0h]
shr rbp, 2
movsxd rsi, ebp
mov rdx, r15
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
lea rdi, [rbx+0A8h]
mov rsi, r13
mov rdx, r15
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
lea rdi, [rbx+0D8h]
mov rsi, r12
mov rdx, r15
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
add rbx, 0F0h
mov rdi, rbx
mov rsi, [rsp+48h+var_40]
mov rdx, r15
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Vtr::internal::QuadRefinement::allocateParentChildIndices(
OpenSubdiv::v3_6_0::Vtr::internal::QuadRefinement *this)
{
int *v1; // rcx
unsigned long long v2; // rax
unsigned long long v3; // r14
unsigned long long v4; // rbp
long long v5; // r13
long long v6; // r12
long long v7; // rdx
unsigned long long v8; // rsi
long long v9; // rdx
unsigned long long v10; // rcx
long long v12; // [rsp+8h] [rbp-40h]
_DWORD v13[13]; // [rsp+14h] [rbp-34h] BYREF
v1 = (int *)*((_QWORD *)this + 1);
v2 = *((_QWORD *)v1 + 7) - *((_QWORD *)v1 + 6);
v3 = *((_QWORD *)v1 + 10) - *((_QWORD *)v1 + 9);
v4 = *((_QWORD *)v1 + 16) - *((_QWORD *)v1 + 15);
v5 = *v1;
v6 = v1[1];
v12 = v1[2];
v13[0] = 0;
v7 = *((_QWORD *)v1 + 3);
v8 = (unsigned long long)(*((_QWORD *)v1 + 4) - v7) >> 2;
*((_QWORD *)this + 11) = v7;
*((_DWORD *)this + 24) = v8;
v9 = *((_QWORD *)v1 + 3);
v10 = (unsigned long long)(*((_QWORD *)v1 + 4) - v9) >> 2;
*((_QWORD *)this + 13) = v9;
*((_DWORD *)this + 28) = v10;
std::vector<int>::resize((char *)this + 120, (int)(v2 >> 2), v13);
std::vector<int>::resize((char *)this + 144, (int)(v3 >> 2), v13);
std::vector<int>::resize((char *)this + 192, (int)(v4 >> 2), v13);
std::vector<int>::resize((char *)this + 168, v5, v13);
std::vector<int>::resize((char *)this + 216, v6, v13);
return std::vector<int>::resize((char *)this + 240, v12, v13);
}
| allocateParentChildIndices:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RCX,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RCX + 0x38]
MOV R14,qword ptr [RCX + 0x50]
SUB RAX,qword ptr [RCX + 0x30]
SUB R14,qword ptr [RCX + 0x48]
MOV RBP,qword ptr [RCX + 0x80]
SUB RBP,qword ptr [RCX + 0x78]
MOVSXD R13,dword ptr [RCX]
MOVSXD R12,dword ptr [RCX + 0x4]
MOVSXD RDX,dword ptr [RCX + 0x8]
MOV qword ptr [RSP + 0x8],RDX
LEA R15,[RSP + 0x14]
MOV dword ptr [R15],0x0
MOV RDX,qword ptr [RCX + 0x18]
MOV RSI,qword ptr [RCX + 0x20]
SUB RSI,RDX
SHR RSI,0x2
MOV qword ptr [RDI + 0x58],RDX
MOV dword ptr [RDI + 0x60],ESI
MOV RDX,qword ptr [RCX + 0x18]
MOV RCX,qword ptr [RCX + 0x20]
SUB RCX,RDX
SHR RCX,0x2
MOV qword ptr [RDI + 0x68],RDX
MOV dword ptr [RDI + 0x70],ECX
ADD RDI,0x78
SHR RAX,0x2
MOVSXD RSI,EAX
MOV RDX,R15
CALL 0x00138f90
LEA RDI,[RBX + 0x90]
SHR R14,0x2
MOVSXD RSI,R14D
MOV RDX,R15
CALL 0x00138f90
LEA RDI,[RBX + 0xc0]
SHR RBP,0x2
MOVSXD RSI,EBP
MOV RDX,R15
CALL 0x00138f90
LEA RDI,[RBX + 0xa8]
MOV RSI,R13
MOV RDX,R15
CALL 0x00138f90
LEA RDI,[RBX + 0xd8]
MOV RSI,R12
MOV RDX,R15
CALL 0x00138f90
ADD RBX,0xf0
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R15
CALL 0x00138f90
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::QuadRefinement::allocateParentChildIndices() */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::QuadRefinement::allocateParentChildIndices(QuadRefinement *this)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
long lVar9;
long lVar10;
long lVar11;
long lVar12;
int local_34;
piVar4 = *(int **)(this + 8);
lVar5 = *(long *)(piVar4 + 0xe);
lVar6 = *(long *)(piVar4 + 0x14);
lVar7 = *(long *)(piVar4 + 0xc);
lVar8 = *(long *)(piVar4 + 0x12);
lVar9 = *(long *)(piVar4 + 0x20);
lVar10 = *(long *)(piVar4 + 0x1e);
iVar1 = *piVar4;
iVar2 = piVar4[1];
iVar3 = piVar4[2];
local_34 = 0;
lVar11 = *(long *)(piVar4 + 6);
lVar12 = *(long *)(piVar4 + 8);
*(long *)(this + 0x58) = lVar11;
*(int *)(this + 0x60) = (int)((ulong)(lVar12 - lVar11) >> 2);
lVar11 = *(long *)(piVar4 + 6);
lVar12 = *(long *)(piVar4 + 8);
*(long *)(this + 0x68) = lVar11;
*(int *)(this + 0x70) = (int)((ulong)(lVar12 - lVar11) >> 2);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(this + 0x78),
(long)(int)((ulong)(lVar5 - lVar7) >> 2),&local_34);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(this + 0x90),
(long)(int)((ulong)(lVar6 - lVar8) >> 2),&local_34);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(this + 0xc0),
(long)(int)((ulong)(lVar9 - lVar10) >> 2),&local_34);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(this + 0xa8),(long)iVar1,&local_34);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(this + 0xd8),(long)iVar2,&local_34);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(this + 0xf0),(long)iVar3,&local_34);
return;
}
| |
54,776 | OpenSubdiv::v3_6_0::Vtr::internal::QuadRefinement::allocateParentChildIndices() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/quadRefinement.cpp | void
QuadRefinement::allocateParentChildIndices() {
//
// Initialize the vectors of indices mapping parent components to those child components
// that will originate from each.
//
int faceChildFaceCount = (int) _parent->_faceVertIndices.size();
int faceChildEdgeCount = (int) _parent->_faceEdgeIndices.size();
int edgeChildEdgeCount = (int) _parent->_edgeVertIndices.size();
int faceChildVertCount = _parent->getNumFaces();
int edgeChildVertCount = _parent->getNumEdges();
int vertChildVertCount = _parent->getNumVertices();
//
// First reference the parent Level's face-vertex counts/offsets -- they can be used
// here for both the face-child-faces and face-child-edges as they both have one per
// face-vertex.
//
// Given we will be ignoring initial values with uniform refinement and assigning all
// directly, initializing here is a waste...
//
Index initValue = 0;
_faceChildFaceCountsAndOffsets = _parent->shareFaceVertCountsAndOffsets();
_faceChildEdgeCountsAndOffsets = _parent->shareFaceVertCountsAndOffsets();
_faceChildFaceIndices.resize(faceChildFaceCount, initValue);
_faceChildEdgeIndices.resize(faceChildEdgeCount, initValue);
_edgeChildEdgeIndices.resize(edgeChildEdgeCount, initValue);
_faceChildVertIndex.resize(faceChildVertCount, initValue);
_edgeChildVertIndex.resize(edgeChildVertCount, initValue);
_vertChildVertIndex.resize(vertChildVertCount, initValue);
} | O2 | cpp | OpenSubdiv::v3_6_0::Vtr::internal::QuadRefinement::allocateParentChildIndices():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x38(%rcx), %rax
movq 0x50(%rcx), %r14
subq 0x30(%rcx), %rax
subq 0x48(%rcx), %r14
movq 0x80(%rcx), %rbp
subq 0x78(%rcx), %rbp
movslq (%rcx), %r13
movslq 0x4(%rcx), %r12
movslq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
leaq 0x14(%rsp), %r15
andl $0x0, (%r15)
movq 0x18(%rcx), %rdx
movq 0x20(%rcx), %rsi
subq %rdx, %rsi
shrq $0x2, %rsi
movq %rdx, 0x58(%rdi)
movl %esi, 0x60(%rdi)
movq 0x18(%rcx), %rdx
movq 0x20(%rcx), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movq %rdx, 0x68(%rdi)
movl %ecx, 0x70(%rdi)
addq $0x78, %rdi
shrq $0x2, %rax
movslq %eax, %rsi
movq %r15, %rdx
callq 0x50850
leaq 0x90(%rbx), %rdi
shrq $0x2, %r14
movslq %r14d, %rsi
movq %r15, %rdx
callq 0x50850
leaq 0xc0(%rbx), %rdi
shrq $0x2, %rbp
movslq %ebp, %rsi
movq %r15, %rdx
callq 0x50850
leaq 0xa8(%rbx), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x50850
leaq 0xd8(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x50850
addq $0xf0, %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x50850
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN10OpenSubdiv6v3_6_03Vtr8internal14QuadRefinement26allocateParentChildIndicesEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov rcx, [rdi+8]
mov rax, [rcx+38h]
mov r14, [rcx+50h]
sub rax, [rcx+30h]
sub r14, [rcx+48h]
mov rbp, [rcx+80h]
sub rbp, [rcx+78h]
movsxd r13, dword ptr [rcx]
movsxd r12, dword ptr [rcx+4]
movsxd rdx, dword ptr [rcx+8]
mov [rsp+48h+var_40], rdx
lea r15, [rsp+48h+var_34]
and dword ptr [r15], 0
mov rdx, [rcx+18h]
mov rsi, [rcx+20h]
sub rsi, rdx
shr rsi, 2
mov [rdi+58h], rdx
mov [rdi+60h], esi
mov rdx, [rcx+18h]
mov rcx, [rcx+20h]
sub rcx, rdx
shr rcx, 2
mov [rdi+68h], rdx
mov [rdi+70h], ecx
add rdi, 78h ; 'x'
shr rax, 2
movsxd rsi, eax
mov rdx, r15
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
lea rdi, [rbx+90h]
shr r14, 2
movsxd rsi, r14d
mov rdx, r15
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
lea rdi, [rbx+0C0h]
shr rbp, 2
movsxd rsi, ebp
mov rdx, r15
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
lea rdi, [rbx+0A8h]
mov rsi, r13
mov rdx, r15
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
lea rdi, [rbx+0D8h]
mov rsi, r12
mov rdx, r15
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
add rbx, 0F0h
mov rdi, rbx
mov rsi, [rsp+48h+var_40]
mov rdx, r15
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Vtr::internal::QuadRefinement::allocateParentChildIndices(
OpenSubdiv::v3_6_0::Vtr::internal::QuadRefinement *this)
{
int *v1; // rcx
unsigned long long v2; // rax
unsigned long long v3; // r14
unsigned long long v4; // rbp
long long v5; // r13
long long v6; // r12
long long v7; // rdx
unsigned long long v8; // rsi
long long v9; // rdx
unsigned long long v10; // rcx
long long v12; // [rsp+8h] [rbp-40h]
_DWORD v13[13]; // [rsp+14h] [rbp-34h] BYREF
v1 = (int *)*((_QWORD *)this + 1);
v2 = *((_QWORD *)v1 + 7) - *((_QWORD *)v1 + 6);
v3 = *((_QWORD *)v1 + 10) - *((_QWORD *)v1 + 9);
v4 = *((_QWORD *)v1 + 16) - *((_QWORD *)v1 + 15);
v5 = *v1;
v6 = v1[1];
v12 = v1[2];
v13[0] = 0;
v7 = *((_QWORD *)v1 + 3);
v8 = (unsigned long long)(*((_QWORD *)v1 + 4) - v7) >> 2;
*((_QWORD *)this + 11) = v7;
*((_DWORD *)this + 24) = v8;
v9 = *((_QWORD *)v1 + 3);
v10 = (unsigned long long)(*((_QWORD *)v1 + 4) - v9) >> 2;
*((_QWORD *)this + 13) = v9;
*((_DWORD *)this + 28) = v10;
std::vector<int>::resize((char *)this + 120, (int)(v2 >> 2), v13);
std::vector<int>::resize((char *)this + 144, (int)(v3 >> 2), v13);
std::vector<int>::resize((char *)this + 192, (int)(v4 >> 2), v13);
std::vector<int>::resize((char *)this + 168, v5, v13);
std::vector<int>::resize((char *)this + 216, v6, v13);
return std::vector<int>::resize((char *)this + 240, v12, v13);
}
| allocateParentChildIndices:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RCX,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RCX + 0x38]
MOV R14,qword ptr [RCX + 0x50]
SUB RAX,qword ptr [RCX + 0x30]
SUB R14,qword ptr [RCX + 0x48]
MOV RBP,qword ptr [RCX + 0x80]
SUB RBP,qword ptr [RCX + 0x78]
MOVSXD R13,dword ptr [RCX]
MOVSXD R12,dword ptr [RCX + 0x4]
MOVSXD RDX,dword ptr [RCX + 0x8]
MOV qword ptr [RSP + 0x8],RDX
LEA R15,[RSP + 0x14]
AND dword ptr [R15],0x0
MOV RDX,qword ptr [RCX + 0x18]
MOV RSI,qword ptr [RCX + 0x20]
SUB RSI,RDX
SHR RSI,0x2
MOV qword ptr [RDI + 0x58],RDX
MOV dword ptr [RDI + 0x60],ESI
MOV RDX,qword ptr [RCX + 0x18]
MOV RCX,qword ptr [RCX + 0x20]
SUB RCX,RDX
SHR RCX,0x2
MOV qword ptr [RDI + 0x68],RDX
MOV dword ptr [RDI + 0x70],ECX
ADD RDI,0x78
SHR RAX,0x2
MOVSXD RSI,EAX
MOV RDX,R15
CALL 0x00150850
LEA RDI,[RBX + 0x90]
SHR R14,0x2
MOVSXD RSI,R14D
MOV RDX,R15
CALL 0x00150850
LEA RDI,[RBX + 0xc0]
SHR RBP,0x2
MOVSXD RSI,EBP
MOV RDX,R15
CALL 0x00150850
LEA RDI,[RBX + 0xa8]
MOV RSI,R13
MOV RDX,R15
CALL 0x00150850
LEA RDI,[RBX + 0xd8]
MOV RSI,R12
MOV RDX,R15
CALL 0x00150850
ADD RBX,0xf0
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R15
CALL 0x00150850
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::QuadRefinement::allocateParentChildIndices() */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::QuadRefinement::allocateParentChildIndices(QuadRefinement *this)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
long lVar9;
long lVar10;
long lVar11;
long lVar12;
int local_34;
piVar4 = *(int **)(this + 8);
lVar5 = *(long *)(piVar4 + 0xe);
lVar6 = *(long *)(piVar4 + 0x14);
lVar7 = *(long *)(piVar4 + 0xc);
lVar8 = *(long *)(piVar4 + 0x12);
lVar9 = *(long *)(piVar4 + 0x20);
lVar10 = *(long *)(piVar4 + 0x1e);
iVar1 = *piVar4;
iVar2 = piVar4[1];
iVar3 = piVar4[2];
local_34 = 0;
lVar11 = *(long *)(piVar4 + 6);
lVar12 = *(long *)(piVar4 + 8);
*(long *)(this + 0x58) = lVar11;
*(int *)(this + 0x60) = (int)((ulong)(lVar12 - lVar11) >> 2);
lVar11 = *(long *)(piVar4 + 6);
lVar12 = *(long *)(piVar4 + 8);
*(long *)(this + 0x68) = lVar11;
*(int *)(this + 0x70) = (int)((ulong)(lVar12 - lVar11) >> 2);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(this + 0x78),
(long)(int)((ulong)(lVar5 - lVar7) >> 2),&local_34);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(this + 0x90),
(long)(int)((ulong)(lVar6 - lVar8) >> 2),&local_34);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(this + 0xc0),
(long)(int)((ulong)(lVar9 - lVar10) >> 2),&local_34);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(this + 0xa8),(long)iVar1,&local_34);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(this + 0xd8),(long)iVar2,&local_34);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(this + 0xf0),(long)iVar3,&local_34);
return;
}
| |
54,777 | common_arg::common_arg(std::initializer_list<char const*> const&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(common_params&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)) | llama.cpp/common/arg.h | common_arg(
const std::initializer_list<const char *> & args,
const char * value_hint,
const std::string & help,
void (*handler)(common_params & params, const std::string &)
) : args(args), value_hint(value_hint), help(help), handler_string(handler) {} | O3 | c | common_arg::common_arg(std::initializer_list<char const*> const&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(common_params&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
leaq 0x3(%rsp), %rcx
leaq 0x2(%rsp), %r8
movl $0x1, %edx
callq 0x87978
leaq 0x38(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq %rax, 0x48(%rbx)
movq %rax, 0x50(%rbx)
movq %rcx, 0x58(%rbx)
leaq 0x60(%rbx), %r13
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
leaq 0x1(%rsp), %rcx
movq %r13, %rdi
callq 0x879fa
movq %r12, 0x78(%rbx)
leaq 0x90(%rbx), %rdi
leaq 0xa0(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rbx)
movq %rax, 0x90(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x2c98c
movb $0x0, 0xb0(%rbx)
movq $0x0, 0xb8(%rbx)
movq %r14, 0xc0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r13), %rdi
testq %rdi, %rdi
je 0x69278
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x20180
jmp 0x69278
movq %rax, %r14
leaq 0x30(%rbx), %rdi
callq 0x87a40
movq %rbx, %rdi
callq 0x87a40
movq %r14, %rdi
callq 0x20b50
nop
| _ZN10common_argC2ERKSt16initializer_listIPKcES2_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPFvR13common_paramsSD_E:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15, rcx
mov r12, rdx
mov rbp, rsi
mov rbx, rdi
lea rsi, [rsp+38h+var_34]
mov dword ptr [rsi], 0
lea rcx, [rsp+38h+var_35]
lea r8, [rsp+38h+var_36]
mov edx, 1
call _ZNSt3setI13llama_exampleSt4lessIS0_ESaIS0_EEC2ESt16initializer_listIS0_ERKS2_RKS3_; std::set<llama_example>::set(std::initializer_list<llama_example>,std::less<llama_example> const&,std::allocator<llama_example> const&)
lea rax, [rbx+38h]
xor ecx, ecx
mov [rbx+40h], rcx
xorps xmm0, xmm0
movups xmmword ptr [rbx+30h], xmm0
mov [rbx+48h], rax
mov [rbx+50h], rax
mov [rbx+58h], rcx
lea r13, [rbx+60h]
mov rsi, [rbp+0]
mov rdx, [rbp+8]
lea rcx, [rsp+38h+var_37]
mov rdi, r13
call _ZNSt6vectorIPKcSaIS1_EEC2ESt16initializer_listIS1_ERKS2_; std::vector<char const*>::vector(std::initializer_list<char const*>,std::allocator<char const*> const&)
mov [rbx+78h], r12
lea rdi, [rbx+90h]
lea rax, [rbx+0A0h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+80h], xmm0
mov [rbx+90h], rax
mov rsi, [r15]
mov rdx, [r15+8]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov byte ptr [rbx+0B0h], 0
mov qword ptr [rbx+0B8h], 0
mov [rbx+0C0h], r14
xorps xmm0, xmm0
movups xmmword ptr [rbx+0C8h], xmm0
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [r13+0]; void *
test rdi, rdi
jz short loc_69278
mov rsi, [rbx+70h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_69278
mov r14, rax
loc_69278:
lea rdi, [rbx+30h]
call _ZNSt8_Rb_treeI13llama_exampleS0_St9_IdentityIS0_ESt4lessIS0_ESaIS0_EED2Ev; std::_Rb_tree<llama_example,llama_example,std::_Identity<llama_example>,std::less<llama_example>,std::allocator<llama_example>>::~_Rb_tree()
mov rdi, rbx
call _ZNSt8_Rb_treeI13llama_exampleS0_St9_IdentityIS0_ESt4lessIS0_ESaIS0_EED2Ev; std::_Rb_tree<llama_example,llama_example,std::_Identity<llama_example>,std::less<llama_example>,std::allocator<llama_example>>::~_Rb_tree()
mov rdi, r14
call __Unwind_Resume
| long long common_arg::common_arg(long long a1, _QWORD *a2, long long a3, long long a4, long long a5)
{
int v5; // eax
long long result; // rax
int v10; // [rsp+0h] [rbp-38h] BYREF
_DWORD v11[13]; // [rsp+4h] [rbp-34h] BYREF
v10 = v5;
v11[0] = 0;
std::set<llama_example>::set(a1, v11, 1LL, (char *)&v10 + 3, (char *)&v10 + 2);
*(_QWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 72) = a1 + 56;
*(_QWORD *)(a1 + 80) = a1 + 56;
*(_QWORD *)(a1 + 88) = 0LL;
std::vector<char const*>::vector(a1 + 96, *a2, a2[1], (char *)&v10 + 1);
*(_QWORD *)(a1 + 120) = a3;
*(_OWORD *)(a1 + 128) = 0LL;
*(_QWORD *)(a1 + 144) = a1 + 160;
result = std::string::_M_construct<char *>(a1 + 144, *(_BYTE **)a4, *(_QWORD *)a4 + *(_QWORD *)(a4 + 8));
*(_BYTE *)(a1 + 176) = 0;
*(_QWORD *)(a1 + 184) = 0LL;
*(_QWORD *)(a1 + 192) = a5;
*(_OWORD *)(a1 + 200) = 0LL;
return result;
}
| common_arg:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15,RCX
MOV R12,RDX
MOV RBP,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x4]
MOV dword ptr [RSI],0x0
LEA RCX,[RSP + 0x3]
LEA R8,[RSP + 0x2]
MOV EDX,0x1
CALL 0x00187978
LEA RAX,[RBX + 0x38]
XOR ECX,ECX
MOV qword ptr [RBX + 0x40],RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV qword ptr [RBX + 0x48],RAX
MOV qword ptr [RBX + 0x50],RAX
MOV qword ptr [RBX + 0x58],RCX
LEA R13,[RBX + 0x60]
MOV RSI,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
LAB_001691ea:
LEA RCX,[RSP + 0x1]
MOV RDI,R13
CALL 0x001879fa
MOV qword ptr [RBX + 0x78],R12
LEA RDI,[RBX + 0x90]
LEA RAX,[RBX + 0xa0]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x80],XMM0
MOV qword ptr [RBX + 0x90],RAX
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
ADD RDX,RSI
LAB_00169224:
CALL 0x0012c98c
LAB_00169229:
MOV byte ptr [RBX + 0xb0],0x0
MOV qword ptr [RBX + 0xb8],0x0
MOV qword ptr [RBX + 0xc0],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0xc8],XMM0
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* common_arg::common_arg(std::initializer_list<char const*> const&, char const*,
std::__cxx11::string const&, void (*)(common_params&, std::__cxx11::string const&)) */
void __thiscall
common_arg::common_arg
(common_arg *this,initializer_list *param_1,char *param_2,string *param_3,
_func_void_common_params_ptr_string_ptr *param_4)
{
int4 in_EAX;
int8 in_R9;
std::set<llama_example,std::less<llama_example>,std::allocator<llama_example>>::set
(this,&stack0xffffffffffffffcc,1,&stack0xffffffffffffffcb,&stack0xffffffffffffffca,in_R9
,in_EAX);
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(common_arg **)(this + 0x48) = this + 0x38;
*(common_arg **)(this + 0x50) = this + 0x38;
*(int8 *)(this + 0x58) = 0;
/* try { // try from 001691ea to 001691f6 has its CatchHandler @ 00169275 */
std::vector<char_const*,std::allocator<char_const*>>::vector
((vector<char_const*,std::allocator<char_const*>> *)(this + 0x60),*(int8 *)param_1
,*(int8 *)(param_1 + 8),&stack0xffffffffffffffc9);
*(char **)(this + 0x78) = param_2;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
*(common_arg **)(this + 0x90) = this + 0xa0;
/* try { // try from 00169224 to 00169228 has its CatchHandler @ 0016925b */
std::__cxx11::string::_M_construct<char*>
(this + 0x90,*(long *)param_3,*(long *)(param_3 + 8) + *(long *)param_3);
this[0xb0] = (common_arg)0x0;
*(int8 *)(this + 0xb8) = 0;
*(_func_void_common_params_ptr_string_ptr **)(this + 0xc0) = param_4;
*(int8 *)(this + 200) = 0;
*(int8 *)(this + 0xd0) = 0;
return;
}
| |
54,778 | strmake | eloqsql/strings/strmake.c | char *strmake(register char *dst, register const char *src, size_t length)
{
while (length--)
{
if (! (*dst++ = *src++))
{
#ifdef EXTRA_DEBUG
/*
'length' is the maximum length of the string; the buffer needs
to be one character larger to accommodate the terminating
'\0'. This is easy to get wrong, so we make sure we write to
the entire length of the buffer to identify incorrect
buffer-sizes. We only initialism the "unused" part of the
buffer here, a) for efficiency, and b) because dst==src is
allowed, so initializing the entire buffer would overwrite the
source-string. Also, we write a character rather than '\0' as
this makes spotting these problems in the results easier.
If we are using purify/valgrind, we only set one character at
end to be able to detect also wrong accesses after the end of
dst.
*/
if (length)
{
#ifdef HAVE_valgrind
dst[length-1]= 'Z';
#else
bfill(dst, length-1, (int) 'Z');
#endif /* HAVE_valgrind */
}
#endif /* EXTRA_DEBUG */
return dst-1;
}
}
*dst=0;
return dst;
} | O0 | c | strmake:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
je 0x7bfab
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %al, (%rcx)
cmpb $0x0, %al
jne 0x7bfa9
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x7bfba
jmp 0x7bf60
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
| strmake:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
loc_7BF60:
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_20], rcx
cmp rax, 0
jz short loc_7BFAB
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov al, [rax]
mov rcx, [rbp+var_10]
mov rdx, rcx
add rdx, 1
mov [rbp+var_10], rdx
mov [rcx], al
cmp al, 0
jnz short loc_7BFA9
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_8], rax
jmp short loc_7BFBA
loc_7BFA9:
jmp short loc_7BF60
loc_7BFAB:
mov rax, [rbp+var_10]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_7BFBA:
mov rax, [rbp+var_8]
pop rbp
retn
| _BYTE * strmake(_BYTE *a1, _BYTE *a2, long long a3)
{
_BYTE *v4; // rax
_BYTE *v5; // rcx
while ( a3-- )
{
v4 = a2++;
LOBYTE(v4) = *v4;
v5 = a1++;
*v5 = (_BYTE)v4;
if ( !(_BYTE)v4 )
return a1 - 1;
}
*a1 = 0;
return a1;
}
| strmake:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
LAB_0017bf60:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RBP + -0x20],RCX
CMP RAX,0x0
JZ 0x0017bfab
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV AL,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RCX],AL
CMP AL,0x0
JNZ 0x0017bfa9
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017bfba
LAB_0017bfa9:
JMP 0x0017bf60
LAB_0017bfab:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_0017bfba:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
char * strmake(char *param_1,char *param_2,long param_3)
{
char cVar1;
char *pcVar2;
long local_28;
char *local_20;
char *local_18;
local_28 = param_3;
local_20 = param_2;
pcVar2 = param_1;
do {
local_18 = pcVar2;
if (local_28 == 0) {
*local_18 = '\0';
return local_18;
}
cVar1 = *local_20;
*local_18 = cVar1;
local_28 = local_28 + -1;
local_20 = local_20 + 1;
pcVar2 = local_18 + 1;
} while (cVar1 != '\0');
return local_18;
}
| |
54,779 | change_victim | eloqsql/mysys/waiting_threads.c | static void change_victim(WT_THD* found, struct deadlock_arg *arg)
{
if (found->weight < arg->victim->weight)
{
if (arg->victim != arg->thd)
{
rc_unlock(arg->victim->waiting_for); /* release the previous victim */
DBUG_ASSERT(arg->last_locked_rc == found->waiting_for);
}
arg->victim= found;
arg->last_locked_rc= 0;
}
} | O3 | c | change_victim:
movq 0x58(%rdi), %rcx
movq 0x10(%rsi), %rax
cmpq 0x58(%rax), %rcx
jae 0xa710a
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq (%rsi), %rax
je 0xa70fa
movq 0x28(%rax), %rdi
addq $0x18, %rdi
callq 0xa40b2
movq %r14, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
| change_victim:
mov rcx, [rdi+58h]
mov rax, [rsi+10h]
cmp rcx, [rax+58h]
jnb short locret_A710A
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
cmp rax, [rsi]
jz short loc_A70FA
mov rdi, [rax+28h]
add rdi, 18h
call my_rw_unlock
loc_A70FA:
mov [rbx+10h], r14
mov qword ptr [rbx+18h], 0
pop rbx
pop r14
pop rbp
locret_A710A:
retn
| long long change_victim(long long a1, _QWORD *a2)
{
long long result; // rax
result = a2[2];
if ( *(_QWORD *)(a1 + 88) < *(_QWORD *)(result + 88) )
{
if ( result != *a2 )
result = my_rw_unlock(*(_QWORD *)(result + 40) + 24LL);
a2[2] = a1;
a2[3] = 0LL;
}
return result;
}
| change_victim:
MOV RCX,qword ptr [RDI + 0x58]
MOV RAX,qword ptr [RSI + 0x10]
CMP RCX,qword ptr [RAX + 0x58]
JNC 0x001a710a
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CMP RAX,qword ptr [RSI]
JZ 0x001a70fa
MOV RDI,qword ptr [RAX + 0x28]
ADD RDI,0x18
CALL 0x001a40b2
LAB_001a70fa:
MOV qword ptr [RBX + 0x10],R14
MOV qword ptr [RBX + 0x18],0x0
POP RBX
POP R14
POP RBP
LAB_001a710a:
RET
|
void change_victim(long param_1,long *param_2)
{
long lVar1;
lVar1 = param_2[2];
if (*(ulong *)(param_1 + 0x58) < *(ulong *)(lVar1 + 0x58)) {
if (lVar1 != *param_2) {
my_rw_unlock(*(long *)(lVar1 + 0x28) + 0x18);
}
param_2[2] = param_1;
param_2[3] = 0;
}
return;
}
| |
54,780 | evmone::instr::core::selfdestruct(evmone::StackTop, long, evmone::ExecutionState&) | corpus-core[P]colibri-stateless/build_O3/_deps/evmone_external-src/lib/evmone/instructions.hpp | inline TermResult selfdestruct(StackTop stack, int64_t gas_left, ExecutionState& state) noexcept
{
if (state.in_static_mode())
return {EVMC_STATIC_MODE_VIOLATION, gas_left};
const auto beneficiary = intx::be::trunc<evmc::address>(stack[0]);
if (state.rev >= EVMC_BERLIN && state.host.access_account(beneficiary) == EVMC_ACCESS_COLD)
{
if ((gas_left -= instr::cold_account_access_cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
}
if (state.rev >= EVMC_TANGERINE_WHISTLE)
{
if (state.rev == EVMC_TANGERINE_WHISTLE || state.host.get_balance(state.msg->recipient))
{
// After TANGERINE_WHISTLE apply additional cost of
// sending value to a non-existing account.
if (!state.host.account_exists(beneficiary))
{
if ((gas_left -= 25000) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
}
}
}
if (state.host.selfdestruct(state.msg->recipient, beneficiary))
{
if (state.rev < EVMC_LONDON)
state.gas_refund += 24000;
}
return {EVMC_SUCCESS, gas_left};
} | O3 | cpp | evmone::instr::core::selfdestruct(evmone::StackTop, long, evmone::ExecutionState&):
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq 0x20(%rdx), %rcx
movl $0xb, %eax
testb $0x1, 0x4(%rcx)
jne 0x41262
movq %rdx, %r14
movq 0x10(%rdi), %rax
bswapq %rax
shrq $0x20, %rax
movl %eax, 0xc(%rsp)
movdqu (%rdi), %xmm0
pshufb 0x3fe9c(%rip), %xmm0 # 0x81000
movdqu %xmm0, 0x10(%rsp)
movl 0x40(%rdx), %eax
cmpl $0x8, %eax
jl 0x411a6
movq 0x30(%r14), %rax
movq 0x38(%r14), %rdi
leaq 0xc(%rsp), %rsi
callq *0x60(%rax)
testl %eax, %eax
jne 0x411a2
leaq -0xa28(%rbx), %rcx
movl $0x3, %eax
cmpq $0xa28, %rbx # imm = 0xA28
movq %rcx, %rbx
jl 0x41262
movl 0x40(%r14), %eax
cmpl $0x2, %eax
jl 0x41220
je 0x411f5
movq 0x20(%r14), %rax
movl 0x28(%rax), %ecx
leaq 0x40(%rsp), %rdx
movl %ecx, 0x10(%rdx)
movdqu 0x18(%rax), %xmm0
movdqa %xmm0, (%rdx)
movq 0x30(%r14), %rax
movq 0x38(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq *0x18(%rax)
cmpq $0x0, 0x20(%rsp)
jne 0x411f5
cmpq $0x0, 0x28(%rsp)
jne 0x411f5
cmpq $0x0, 0x30(%rsp)
jne 0x411f5
cmpq $0x0, 0x38(%rsp)
je 0x41220
movq 0x30(%r14), %rax
movq 0x38(%r14), %rdi
leaq 0xc(%rsp), %rsi
callq *(%rax)
testb %al, %al
jne 0x41220
leaq -0x61a8(%rbx), %rcx
movl $0x3, %eax
cmpq $0x61a8, %rbx # imm = 0x61A8
movq %rcx, %rbx
jl 0x41262
movq 0x20(%r14), %rax
movl 0x28(%rax), %ecx
leaq 0x20(%rsp), %rsi
movl %ecx, 0x10(%rsi)
movdqu 0x18(%rax), %xmm0
movdqa %xmm0, (%rsi)
movq 0x30(%r14), %rax
movq 0x38(%r14), %rdi
leaq 0xc(%rsp), %rdx
callq *0x38(%rax)
movl %eax, %ecx
cmpl $0x9, 0x40(%r14)
setl %al
andb %al, %cl
xorl %eax, %eax
cmpb $0x1, %cl
jne 0x41262
addq $0x5dc0, (%r14) # imm = 0x5DC0
movq %rbx, %rdx
addq $0x58, %rsp
popq %rbx
popq %r14
retq
jmp 0x41273
jmp 0x41273
jmp 0x41273
movq %rax, %rdi
callq 0x2e015
nop
| _ZN6evmone5instr4core12selfdestructENS_8StackTopElRNS_14ExecutionStateE:
push r14
push rbx
sub rsp, 58h
mov rbx, rsi
mov rcx, [rdx+20h]
mov eax, 0Bh
test byte ptr [rcx+4], 1
jnz loc_41262
mov r14, rdx
mov rax, [rdi+10h]
bswap rax
shr rax, 20h
mov [rsp+68h+var_5C], eax
movdqu xmm0, xmmword ptr [rdi]
pshufb xmm0, cs:xmmword_81000
movdqu [rsp+68h+var_58], xmm0
mov eax, [rdx+40h]
cmp eax, 8
jl short loc_411A6
mov rax, [r14+30h]
mov rdi, [r14+38h]
lea rsi, [rsp+68h+var_5C]
call qword ptr [rax+60h]
test eax, eax
jnz short loc_411A2
lea rcx, [rbx-0A28h]
mov eax, 3
cmp rbx, 0A28h
mov rbx, rcx
jl loc_41262
loc_411A2:
mov eax, [r14+40h]
loc_411A6:
cmp eax, 2
jl short loc_41220
jz short loc_411F5
mov rax, [r14+20h]
mov ecx, [rax+28h]
lea rdx, [rsp+68h+var_28]
mov [rdx+10h], ecx
movdqu xmm0, xmmword ptr [rax+18h]
movdqa xmmword ptr [rdx], xmm0
mov rax, [r14+30h]
mov rsi, [r14+38h]
lea rdi, [rsp+68h+var_48]
call qword ptr [rax+18h]
cmp [rsp+68h+var_48], 0
jnz short loc_411F5
cmp [rsp+68h+var_40], 0
jnz short loc_411F5
cmp [rsp+68h+var_38], 0
jnz short loc_411F5
cmp [rsp+68h+var_30], 0
jz short loc_41220
loc_411F5:
mov rax, [r14+30h]
mov rdi, [r14+38h]
lea rsi, [rsp+68h+var_5C]
call qword ptr [rax]
test al, al
jnz short loc_41220
lea rcx, [rbx-61A8h]
mov eax, 3
cmp rbx, 61A8h
mov rbx, rcx
jl short loc_41262
loc_41220:
mov rax, [r14+20h]
mov ecx, [rax+28h]
lea rsi, [rsp+68h+var_48]
mov [rsi+10h], ecx
movdqu xmm0, xmmword ptr [rax+18h]
movdqa xmmword ptr [rsi], xmm0
mov rax, [r14+30h]
mov rdi, [r14+38h]
lea rdx, [rsp+68h+var_5C]
call qword ptr [rax+38h]
mov ecx, eax
cmp dword ptr [r14+40h], 9
setl al
and cl, al
xor eax, eax
cmp cl, 1
jnz short loc_41262
add qword ptr [r14], 5DC0h
loc_41262:
mov rdx, rbx
add rsp, 58h
pop rbx
pop r14
retn
jmp short loc_41273
jmp short loc_41273
jmp short $+2
loc_41273:
mov rdi, rax
call __clang_call_terminate
| long long evmone::instr::core::selfdestruct(const __m128i *a1, long long a2, long long a3)
{
long long v3; // rbx
long long result; // rax
int v6; // eax
long long v7; // rax
long long v8; // rax
char v9; // cl
int v10; // [rsp+Ch] [rbp-5Ch] BYREF
__m128i v11; // [rsp+10h] [rbp-58h]
__m128i v12; // [rsp+20h] [rbp-48h] BYREF
long long v13; // [rsp+30h] [rbp-38h]
long long v14; // [rsp+38h] [rbp-30h]
__m128i v15; // [rsp+40h] [rbp-28h]
int v16; // [rsp+50h] [rbp-18h]
v3 = a2;
result = 11LL;
if ( (*(_BYTE *)(*(_QWORD *)(a3 + 32) + 4LL) & 1) == 0 )
{
v10 = _byteswap_uint64(a1[1].m128i_u64[0]) >> 32;
v11 = _mm_shuffle_epi8(_mm_loadu_si128(a1), (__m128i)xmmword_81000);
v6 = *(_DWORD *)(a3 + 64);
if ( v6 >= 8 )
{
if ( !(*(unsigned int ( **)(_QWORD, int *))(*(_QWORD *)(a3 + 48) + 96LL))(*(_QWORD *)(a3 + 56), &v10) )
{
result = 3LL;
v3 = a2 - 2600;
if ( a2 < 2600 )
return result;
}
v6 = *(_DWORD *)(a3 + 64);
}
if ( v6 < 2
|| v6 != 2
&& (v7 = *(_QWORD *)(a3 + 32),
v16 = *(_DWORD *)(v7 + 40),
v15 = _mm_loadu_si128((const __m128i *)(v7 + 24)),
(*(void ( **)(__m128i *, _QWORD))(*(_QWORD *)(a3 + 48) + 24LL))(&v12, *(_QWORD *)(a3 + 56)),
!v12.m128i_i64[0])
&& !v12.m128i_i64[1]
&& !v13
&& !v14
|| (**(unsigned __int8 ( ***)(_QWORD, int *))(a3 + 48))(*(_QWORD *)(a3 + 56), &v10)
|| (result = 3LL, v3 >= 25000) )
{
v8 = *(_QWORD *)(a3 + 32);
LODWORD(v13) = *(_DWORD *)(v8 + 40);
v12 = _mm_loadu_si128((const __m128i *)(v8 + 24));
v9 = (*(_DWORD *)(a3 + 64) < 9) & (*(long long ( **)(_QWORD, __m128i *, int *))(*(_QWORD *)(a3 + 48) + 56LL))(
*(_QWORD *)(a3 + 56),
&v12,
&v10);
result = 0LL;
if ( v9 == 1 )
*(_QWORD *)a3 += 24000LL;
}
}
return result;
}
| selfdestruct:
PUSH R14
PUSH RBX
SUB RSP,0x58
MOV RBX,RSI
MOV RCX,qword ptr [RDX + 0x20]
MOV EAX,0xb
TEST byte ptr [RCX + 0x4],0x1
JNZ 0x00141262
MOV R14,RDX
MOV RAX,qword ptr [RDI + 0x10]
BSWAP RAX
SHR RAX,0x20
MOV dword ptr [RSP + 0xc],EAX
MOVDQU XMM0,xmmword ptr [RDI]
PSHUFB XMM0,xmmword ptr [0x00181000]
MOVDQU xmmword ptr [RSP + 0x10],XMM0
MOV EAX,dword ptr [RDX + 0x40]
CMP EAX,0x8
JL 0x001411a6
MOV RAX,qword ptr [R14 + 0x30]
MOV RDI,qword ptr [R14 + 0x38]
LAB_0014117a:
LEA RSI,[RSP + 0xc]
CALL qword ptr [RAX + 0x60]
TEST EAX,EAX
JNZ 0x001411a2
LEA RCX,[RBX + -0xa28]
MOV EAX,0x3
CMP RBX,0xa28
MOV RBX,RCX
JL 0x00141262
LAB_001411a2:
MOV EAX,dword ptr [R14 + 0x40]
LAB_001411a6:
CMP EAX,0x2
JL 0x00141220
JZ 0x001411f5
MOV RAX,qword ptr [R14 + 0x20]
MOV ECX,dword ptr [RAX + 0x28]
LEA RDX,[RSP + 0x40]
MOV dword ptr [RDX + 0x10],ECX
MOVDQU XMM0,xmmword ptr [RAX + 0x18]
MOVDQA xmmword ptr [RDX],XMM0
MOV RAX,qword ptr [R14 + 0x30]
MOV RSI,qword ptr [R14 + 0x38]
LAB_001411cd:
LEA RDI,[RSP + 0x20]
CALL qword ptr [RAX + 0x18]
CMP qword ptr [RSP + 0x20],0x0
JNZ 0x001411f5
CMP qword ptr [RSP + 0x28],0x0
JNZ 0x001411f5
CMP qword ptr [RSP + 0x30],0x0
JNZ 0x001411f5
CMP qword ptr [RSP + 0x38],0x0
JZ 0x00141220
LAB_001411f5:
MOV RAX,qword ptr [R14 + 0x30]
MOV RDI,qword ptr [R14 + 0x38]
LAB_001411fd:
LEA RSI,[RSP + 0xc]
CALL qword ptr [RAX]
TEST AL,AL
JNZ 0x00141220
LEA RCX,[RBX + -0x61a8]
MOV EAX,0x3
CMP RBX,0x61a8
MOV RBX,RCX
JL 0x00141262
LAB_00141220:
MOV RAX,qword ptr [R14 + 0x20]
MOV ECX,dword ptr [RAX + 0x28]
LEA RSI,[RSP + 0x20]
MOV dword ptr [RSI + 0x10],ECX
MOVDQU XMM0,xmmword ptr [RAX + 0x18]
MOVDQA xmmword ptr [RSI],XMM0
MOV RAX,qword ptr [R14 + 0x30]
MOV RDI,qword ptr [R14 + 0x38]
LAB_00141240:
LEA RDX,[RSP + 0xc]
CALL qword ptr [RAX + 0x38]
MOV ECX,EAX
CMP dword ptr [R14 + 0x40],0x9
SETL AL
AND CL,AL
XOR EAX,EAX
CMP CL,0x1
JNZ 0x00141262
ADD qword ptr [R14],0x5dc0
LAB_00141262:
MOV RDX,RBX
ADD RSP,0x58
POP RBX
POP R14
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* evmone::instr::core::selfdestruct(evmone::StackTop, long, evmone::ExecutionState&) */
int1 [16]
evmone::instr::core::selfdestruct(int1 (*param_1) [16],long param_2,long *param_3)
{
ulong uVar1;
long lVar2;
char cVar3;
byte bVar4;
int iVar5;
int8 uVar6;
long lVar7;
int1 auVar8 [16];
uint local_5c;
int1 local_58 [16];
long local_48;
long lStack_40;
int4 local_38;
int4 uStack_34;
long local_30;
int8 local_28;
int8 uStack_20;
int4 local_18;
uVar6 = 0xb;
lVar7 = param_2;
if ((*(byte *)(param_3[4] + 4) & 1) != 0) goto LAB_00141262;
uVar1 = *(ulong *)param_1[1];
local_5c = (uint)(uVar1 >> 0x18) & 0xff | (uint)(uVar1 >> 8) & 0xff00 |
(uint)(((uVar1 & 0xff00) << 0x28) >> 0x20) | (uint)((uVar1 << 0x38) >> 0x20);
local_58 = pshufb(*param_1,_DAT_00181000);
iVar5 = (int)param_3[8];
if (7 < iVar5) {
/* try { // try from 0014117a to 00141181 has its CatchHandler @ 00141271 */
iVar5 = (**(code **)(param_3[6] + 0x60))(param_3[7],&local_5c);
if (iVar5 == 0) {
lVar7 = param_2 + -0xa28;
uVar6 = 3;
if (param_2 < 0xa28) goto LAB_00141262;
}
iVar5 = (int)param_3[8];
param_2 = lVar7;
}
lVar7 = param_2;
if (1 < iVar5) {
if (iVar5 != 2) {
lVar2 = param_3[4];
local_18 = *(int4 *)(lVar2 + 0x28);
local_28 = *(int8 *)(lVar2 + 0x18);
uStack_20 = *(int8 *)(lVar2 + 0x20);
/* try { // try from 001411cd to 001411d4 has its CatchHandler @ 0014126d */
(**(code **)(param_3[6] + 0x18))(&local_48,param_3[7]);
if ((((local_48 == 0) && (lStack_40 == 0)) && (CONCAT44(uStack_34,local_38) == 0)) &&
(local_30 == 0)) goto LAB_00141220;
}
/* try { // try from 001411fd to 00141203 has its CatchHandler @ 0014126f */
cVar3 = (**(code **)param_3[6])(param_3[7],&local_5c);
if (cVar3 == '\0') {
lVar7 = param_2 + -25000;
uVar6 = 3;
if (param_2 < 25000) goto LAB_00141262;
}
}
LAB_00141220:
lVar2 = param_3[4];
local_38 = *(int4 *)(lVar2 + 0x28);
local_48 = *(long *)(lVar2 + 0x18);
lStack_40 = *(int8 *)(lVar2 + 0x20);
/* try { // try from 00141240 to 00141247 has its CatchHandler @ 00141273 */
bVar4 = (**(code **)(param_3[6] + 0x38))(param_3[7],&local_48,&local_5c);
uVar6 = 0;
if ((bVar4 & (int)param_3[8] < 9) == 1) {
*param_3 = *param_3 + 24000;
}
LAB_00141262:
auVar8._8_8_ = lVar7;
auVar8._0_8_ = uVar6;
return auVar8;
}
| |
54,781 | js_array_buffer_get_detached | bluesky950520[P]quickjs/quickjs.c | static JSValue js_array_buffer_get_detached(JSContext *ctx,
JSValue this_val)
{
JSArrayBuffer *abuf = JS_GetOpaque2(ctx, this_val, JS_CLASS_ARRAY_BUFFER);
if (!abuf)
return JS_EXCEPTION;
if (abuf->shared)
return JS_ThrowTypeError(ctx, "detached called on SharedArrayBuffer");
return js_bool(abuf->detached);
} | O1 | c | js_array_buffer_get_detached:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl $0x13, %ecx
callq 0x275b5
movl $0x6, %ebx
testq %rax, %rax
je 0x7fc08
cmpb $0x0, 0x9(%rax)
je 0x7fc0d
leaq 0x22971(%rip), %rsi # 0xa256a
xorl %r14d, %r14d
movq %r15, %rdi
xorl %eax, %eax
callq 0x22567
jmp 0x7fc1d
xorl %r14d, %r14d
jmp 0x7fc1d
xorl %r14d, %r14d
cmpb $0x0, 0x8(%rax)
setne %r14b
movl $0x1, %ebx
movq %r14, %rax
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
retq
| js_array_buffer_get_detached:
push r15
push r14
push rbx
mov r15, rdi
mov ecx, 13h
call JS_GetOpaque2
mov ebx, 6
test rax, rax
jz short loc_7FC08
cmp byte ptr [rax+9], 0
jz short loc_7FC0D
lea rsi, aDetachedCalled; "detached called on SharedArrayBuffer"
xor r14d, r14d
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
jmp short loc_7FC1D
loc_7FC08:
xor r14d, r14d
jmp short loc_7FC1D
loc_7FC0D:
xor r14d, r14d
cmp byte ptr [rax+8], 0
setnz r14b
mov ebx, 1
loc_7FC1D:
mov rax, r14
mov rdx, rbx
pop rbx
pop r14
pop r15
retn
| _BOOL8 js_array_buffer_get_detached(
long long a1,
long long a2,
int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long Opaque2; // rax
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
long long v18; // r14
char v20; // [rsp+0h] [rbp-18h]
Opaque2 = JS_GetOpaque2(a1, a2, a3, 0x13u);
if ( !Opaque2 )
return 0LL;
if ( !*(_BYTE *)(Opaque2 + 9) )
return *(_BYTE *)(Opaque2 + 8) != 0;
v18 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"detached called on SharedArrayBuffer",
v12,
v13,
v14,
v15,
a4,
a5,
a6,
a7,
v16,
v17,
a10,
a11,
v20);
return v18;
}
| |||
54,782 | js_array_buffer_get_detached | bluesky950520[P]quickjs/quickjs.c | static JSValue js_array_buffer_get_detached(JSContext *ctx,
JSValue this_val)
{
JSArrayBuffer *abuf = JS_GetOpaque2(ctx, this_val, JS_CLASS_ARRAY_BUFFER);
if (!abuf)
return JS_EXCEPTION;
if (abuf->shared)
return JS_ThrowTypeError(ctx, "detached called on SharedArrayBuffer");
return js_bool(abuf->detached);
} | O2 | c | js_array_buffer_get_detached:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
pushq $0x13
popq %rcx
callq 0x21207
pushq $0x6
popq %rbx
testq %rax, %rax
je 0x6b66f
cmpb $0x0, 0x9(%rax)
je 0x6b674
leaq 0x1de44(%rip), %rsi # 0x894a4
xorl %r14d, %r14d
movq %r15, %rdi
xorl %eax, %eax
callq 0x1c64d
jmp 0x6b682
xorl %r14d, %r14d
jmp 0x6b682
xorl %r14d, %r14d
cmpb $0x0, 0x8(%rax)
setne %r14b
pushq $0x1
popq %rbx
movq %r14, %rax
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
retq
| js_array_buffer_get_detached:
push r15
push r14
push rbx
mov r15, rdi
push 13h
pop rcx
call JS_GetOpaque2
push 6
pop rbx
test rax, rax
jz short loc_6B66F
cmp byte ptr [rax+9], 0
jz short loc_6B674
lea rsi, aDetachedCalled; "detached called on SharedArrayBuffer"
xor r14d, r14d
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
jmp short loc_6B682
loc_6B66F:
xor r14d, r14d
jmp short loc_6B682
loc_6B674:
xor r14d, r14d
cmp byte ptr [rax+8], 0
setnz r14b
push 1
pop rbx
loc_6B682:
mov rax, r14
mov rdx, rbx
pop rbx
pop r14
pop r15
retn
| _BOOL8 js_array_buffer_get_detached(
long long a1,
long long a2,
int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long Opaque2; // rax
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
long long v18; // r14
char v20; // [rsp+0h] [rbp-18h]
Opaque2 = JS_GetOpaque2(a1, a2, a3, 0x13u);
if ( !Opaque2 )
return 0LL;
if ( !*(_BYTE *)(Opaque2 + 9) )
return *(_BYTE *)(Opaque2 + 8) != 0;
v18 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"detached called on SharedArrayBuffer",
v12,
v13,
v14,
v15,
a4,
a5,
a6,
a7,
v16,
v17,
a10,
a11,
v20);
return v18;
}
| js_array_buffer_get_detached:
PUSH R15
PUSH R14
PUSH RBX
MOV R15,RDI
PUSH 0x13
POP RCX
CALL 0x00121207
PUSH 0x6
POP RBX
TEST RAX,RAX
JZ 0x0016b66f
CMP byte ptr [RAX + 0x9],0x0
JZ 0x0016b674
LEA RSI,[0x1894a4]
XOR R14D,R14D
MOV RDI,R15
XOR EAX,EAX
CALL 0x0011c64d
JMP 0x0016b682
LAB_0016b66f:
XOR R14D,R14D
JMP 0x0016b682
LAB_0016b674:
XOR R14D,R14D
CMP byte ptr [RAX + 0x8],0x0
SETNZ R14B
PUSH 0x1
POP RBX
LAB_0016b682:
MOV RAX,R14
MOV RDX,RBX
POP RBX
POP R14
POP R15
RET
|
bool js_array_buffer_get_detached(int8 param_1)
{
long lVar1;
bool bVar2;
lVar1 = JS_GetOpaque2();
if (lVar1 == 0) {
bVar2 = false;
}
else if (*(char *)(lVar1 + 9) == '\0') {
bVar2 = *(char *)(lVar1 + 8) != '\0';
}
else {
bVar2 = false;
JS_ThrowTypeError(param_1,"detached called on SharedArrayBuffer");
}
return bVar2;
}
| |
54,783 | nglog::tools::GetSectionHeaderByType(int, unsigned short, unsigned long, unsigned int, Elf64_Shdr*) | ng-log[P]ng-log/src/symbolize.cc | static ATTRIBUTE_NOINLINE bool GetSectionHeaderByType(const int fd,
ElfW(Half) sh_num,
const size_t sh_offset,
ElfW(Word) type,
ElfW(Shdr) * out) {
// Read at most 16 section headers at a time to save read calls.
ElfW(Shdr) buf[16];
for (size_t i = 0; i < sh_num;) {
const size_t num_bytes_left = (sh_num - i) * sizeof(buf[0]);
const size_t num_bytes_to_read =
(sizeof(buf) > num_bytes_left) ? num_bytes_left : sizeof(buf);
const ssize_t len = ReadFromOffset(fd, buf, num_bytes_to_read,
sh_offset + i * sizeof(buf[0]));
if (len == -1) {
return false;
}
NGLOG_SAFE_ASSERT(static_cast<size_t>(len) % sizeof(buf[0]) == 0);
const size_t num_headers_in_buf = static_cast<size_t>(len) / sizeof(buf[0]);
NGLOG_SAFE_ASSERT(num_headers_in_buf <= sizeof(buf) / sizeof(buf[0]));
for (size_t j = 0; j < num_headers_in_buf; ++j) {
if (buf[j].sh_type == type) {
*out = buf[j];
return true;
}
}
i += num_headers_in_buf;
}
return false;
} | O2 | cpp | nglog::tools::GetSectionHeaderByType(int, unsigned short, unsigned long, unsigned int, Elf64_Shdr*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %r8, 0x8(%rsp)
movl %ecx, %ebp
movq %rdx, %r8
movl %esi, %ebx
xorl %r12d, %r12d
movl $0x400, %eax # imm = 0x400
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
subq %r12, %rdx
jbe 0x1e7f9
shlq $0x6, %rdx
cmpq %rax, %rdx
cmovaeq %rax, %rdx
movq %r12, %rcx
shlq $0x6, %rcx
movq %r8, %r15
addq %r8, %rcx
movl %edi, %r13d
movq %rsi, %r14
callq 0x1dda3
cmpq $-0x1, %rax
je 0x1e7f9
testb $0x3f, %al
jne 0x1e7fd
cmpq $0x43f, %rax # imm = 0x43F
ja 0x1e7fd
shrq $0x6, %rax
leaq 0x1(%rax), %rcx
leaq 0x14(%rsp), %rdx
decq %rcx
je 0x1e7ae
leaq 0x40(%rdx), %rsi
cmpl %ebp, (%rdx)
movq %rsi, %rdx
jne 0x1e79c
jmp 0x1e7c1
addq %rax, %r12
movl $0x400, %eax # imm = 0x400
movq %r14, %rsi
movq %r15, %r8
movl %r13d, %edi
jmp 0x1e74e
movups -0x44(%rsi), %xmm0
movups -0x34(%rsi), %xmm1
movups -0x24(%rsi), %xmm2
movups -0x14(%rsi), %xmm3
movq 0x8(%rsp), %rax
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movb $0x1, %al
addq $0x418, %rsp # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x1e7e7
callq 0x8310
| _ZN5nglog5toolsL22GetSectionHeaderByTypeEitmjP10Elf64_Shdr:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 418h
mov [rsp+448h+var_440], r8
mov ebp, ecx
mov r8, rdx; unsigned __int64
mov ebx, esi
xor r12d, r12d
mov eax, offset stru_3F8.st_value
lea rsi, [rsp+448h+var_438]; int
loc_1E74E:
mov rdx, rbx
sub rdx, r12
jbe loc_1E7F9
shl rdx, 6
cmp rdx, rax
cmovnb rdx, rax; void *
mov rcx, r12
shl rcx, 6
mov r15, r8
add rcx, r8; unsigned __int64
mov r13d, edi
mov r14, rsi
call _ZN5nglog5toolsL14ReadFromOffsetEiPvmm; nglog::tools::ReadFromOffset(int,void *,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_1E7F9
test al, 3Fh
jnz short loc_1E7FD
cmp rax, 43Fh
ja short loc_1E7FD
shr rax, 6
lea rcx, [rax+1]
lea rdx, [rsp+448h+var_434]
loc_1E79C:
dec rcx
jz short loc_1E7AE
lea rsi, [rdx+40h]
cmp [rdx], ebp
mov rdx, rsi
jnz short loc_1E79C
jmp short loc_1E7C1
loc_1E7AE:
add r12, rax
mov eax, 400h
mov rsi, r14
mov r8, r15
mov edi, r13d
jmp short loc_1E74E
loc_1E7C1:
movups xmm0, xmmword ptr [rsi-44h]
movups xmm1, xmmword ptr [rsi-34h]
movups xmm2, xmmword ptr [rsi-24h]
movups xmm3, xmmword ptr [rsi-14h]
mov rax, [rsp+448h+var_440]
movups xmmword ptr [rax+30h], xmm3
movups xmmword ptr [rax+20h], xmm2
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
mov al, 1
loc_1E7E7:
add rsp, 418h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1E7F9:
xor eax, eax
jmp short loc_1E7E7
loc_1E7FD:
call _abort
| char nglog::tools::GetSectionHeaderByType(
unsigned long long a1,
unsigned int a2,
long long a3,
int a4,
_OWORD *a5)
{
unsigned long long v7; // rbx
unsigned long long v8; // r12
unsigned long long *p_st_value; // rax
int *v10; // rsi
char *v11; // rdx
long long v12; // r15
int *v13; // r14
unsigned long long v14; // rax
unsigned long long v15; // rax
unsigned long long v16; // rcx
char *v17; // rdx
_DWORD *v18; // rsi
bool v19; // zf
__int128 v20; // xmm0
__int128 v21; // xmm1
__int128 v22; // xmm2
int v25; // [rsp+10h] [rbp-438h] BYREF
char v26; // [rsp+14h] [rbp-434h] BYREF
v7 = a2;
v8 = 0LL;
p_st_value = &stru_3F8.st_value;
v10 = &v25;
while ( v7 > v8 )
{
v11 = (char *)((v7 - v8) << 6);
if ( v11 >= (char *)p_st_value )
v11 = (char *)p_st_value;
v12 = a3;
v13 = v10;
v14 = nglog::tools::ReadFromOffset(a1, (long long)v10, v11, a3 + (v8 << 6));
if ( v14 == -1LL )
break;
if ( (v14 & 0x3F) != 0 || v14 > 0x43F )
abort(a1);
v15 = v14 >> 6;
v16 = v15 + 1;
v17 = &v26;
while ( --v16 )
{
v18 = v17 + 64;
v19 = *(_DWORD *)v17 == a4;
v17 += 64;
if ( v19 )
{
v20 = *(_OWORD *)(v18 - 17);
v21 = *(_OWORD *)(v18 - 13);
v22 = *(_OWORD *)(v18 - 9);
a5[3] = *(_OWORD *)(v18 - 5);
a5[2] = v22;
a5[1] = v21;
*a5 = v20;
return 1;
}
}
v8 += v15;
p_st_value = (_QWORD *)(&stru_3F8 + 8);
v10 = v13;
a3 = v12;
a1 = (unsigned int)a1;
}
return 0;
}
| GetSectionHeaderByType:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x418
MOV qword ptr [RSP + 0x8],R8
MOV EBP,ECX
MOV R8,RDX
MOV EBX,ESI
XOR R12D,R12D
MOV EAX,0x400
LEA RSI,[RSP + 0x10]
LAB_0011e74e:
MOV RDX,RBX
SUB RDX,R12
JBE 0x0011e7f9
SHL RDX,0x6
CMP RDX,RAX
CMOVNC RDX,RAX
MOV RCX,R12
SHL RCX,0x6
MOV R15,R8
ADD RCX,R8
MOV R13D,EDI
MOV R14,RSI
CALL 0x0011dda3
CMP RAX,-0x1
JZ 0x0011e7f9
TEST AL,0x3f
JNZ 0x0011e7fd
CMP RAX,0x43f
JA 0x0011e7fd
SHR RAX,0x6
LEA RCX,[RAX + 0x1]
LEA RDX,[RSP + 0x14]
LAB_0011e79c:
DEC RCX
JZ 0x0011e7ae
LEA RSI,[RDX + 0x40]
CMP dword ptr [RDX],EBP
MOV RDX,RSI
JNZ 0x0011e79c
JMP 0x0011e7c1
LAB_0011e7ae:
ADD R12,RAX
MOV EAX,0x400
MOV RSI,R14
MOV R8,R15
MOV EDI,R13D
JMP 0x0011e74e
LAB_0011e7c1:
MOVUPS XMM0,xmmword ptr [RSI + -0x44]
MOVUPS XMM1,xmmword ptr [RSI + -0x34]
MOVUPS XMM2,xmmword ptr [RSI + -0x24]
MOVUPS XMM3,xmmword ptr [RSI + -0x14]
MOV RAX,qword ptr [RSP + 0x8]
MOVUPS xmmword ptr [RAX + 0x30],XMM3
MOVUPS xmmword ptr [RAX + 0x20],XMM2
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
MOV AL,0x1
LAB_0011e7e7:
ADD RSP,0x418
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011e7f9:
XOR EAX,EAX
JMP 0x0011e7e7
LAB_0011e7fd:
CALL 0x00108310
|
/* nglog::tools::GetSectionHeaderByType(int, unsigned short, unsigned long, unsigned int,
Elf64_Shdr*) */
int8
nglog::tools::GetSectionHeaderByType
(int param_1,ushort param_2,ulong param_3,uint param_4,Elf64_Shdr *param_5)
{
qword qVar1;
qword qVar2;
qword qVar3;
qword qVar4;
qword qVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
uint *puVar10;
long lVar11;
ulong uVar12;
uint *puVar13;
ulong uVar14;
int6 in_register_00000032;
ulong uVar15;
int1 local_438 [4];
uint auStack_434 [257];
uVar14 = CONCAT62(in_register_00000032,param_2) & 0xffffffff;
uVar15 = 0;
while( true ) {
lVar11 = uVar14 - uVar15;
if (uVar14 < uVar15 || lVar11 == 0) {
return 0;
}
uVar12 = lVar11 * 0x40;
if (0x3ff < uVar12) {
uVar12 = 0x400;
}
uVar12 = ReadFromOffset(param_1,local_438,uVar12,uVar15 * 0x40 + param_3);
if (uVar12 == 0xffffffffffffffff) break;
if (((uVar12 & 0x3f) != 0) || (0x43f < uVar12)) {
/* WARNING: Subroutine does not return */
abort();
}
lVar11 = (uVar12 >> 6) + 1;
puVar10 = auStack_434;
while (puVar13 = puVar10, lVar11 = lVar11 + -1, lVar11 != 0) {
puVar10 = puVar13 + 0x10;
if (*puVar13 == param_4) {
uVar8 = puVar13[-1];
uVar9 = puVar13[0];
qVar1 = *(qword *)(puVar13 + 1);
qVar2 = *(qword *)(puVar13 + 3);
qVar3 = *(qword *)(puVar13 + 5);
qVar4 = *(qword *)(puVar13 + 7);
uVar6 = puVar13[9];
uVar7 = puVar13[10];
qVar5 = *(qword *)(puVar13 + 0xd);
param_5->sh_addralign = *(qword *)(puVar13 + 0xb);
param_5->sh_entsize = qVar5;
param_5->sh_size = qVar4;
param_5->sh_link = uVar6;
param_5->sh_info = uVar7;
param_5->sh_addr = qVar2;
param_5->sh_offset = qVar3;
param_5->sh_name = uVar8;
param_5->sh_type = uVar9;
param_5->sh_flags = qVar1;
return 1;
}
}
uVar15 = uVar15 + (uVar12 >> 6);
}
return 0;
}
| |
54,784 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsigned long) const | monkey531[P]llama/common/json.hpp | const_reference operator[](size_type idx) const
{
// const operator[] only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
return m_data.m_value.array->operator[](idx);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
} | O1 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsigned long) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0x80c59
movq 0x8(%r14), %rax
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x19370
movq %rax, %rbx
movq %r14, %rdi
callq 0x37e02
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x39e09(%rip), %rsi # 0xbaa86
leaq 0x10(%rsp), %rdi
callq 0x4b7fa
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x46ffc
xorl %ebp, %ebp
leaq 0x6b4d8(%rip), %rsi # 0xec180
leaq -0x4cd11(%rip), %rdx # 0x33f9e
movq %rbx, %rdi
callq 0x19ba0
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x80cdd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x196d0
jmp 0x80cdd
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x80cea
movq %rbx, %rdi
callq 0x19510
movq %r14, %rdi
callq 0x19c00
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixEm:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 2
jnz short loc_80C59
mov rax, [r14+8]
shl rsi, 4
add rsi, [rax]
mov rax, rsi
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_80C59:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseOpera; "cannot use operator[] with a numeric ar"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA52_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(char const(&)[52],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_80CDD
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_80CDD
mov r14, rax
mov bpl, 1
loc_80CDD:
test bpl, bpl
jz short loc_80CEA
mov rdi, rbx; void *
call ___cxa_free_exception
loc_80CEA:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
long long a1,
long long a2)
{
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v4; // [rsp+8h] [rbp-40h] BYREF
_QWORD v5[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v4 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(
(long long)v5,
(long long)"cannot use operator[] with a numeric argument with ",
&v4);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
305,
v5);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return **(_QWORD **)(a1 + 8) + 16 * a2;
}
| operator[]:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x2
JNZ 0x00180c59
MOV RAX,qword ptr [R14 + 0x8]
SHL RSI,0x4
ADD RSI,qword ptr [RAX]
MOV RAX,RSI
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_00180c59:
MOV EDI,0x20
CALL 0x00119370
MOV RBX,RAX
MOV RDI,R14
CALL 0x00137e02
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_00180c76:
LEA RSI,[0x1baa86]
LEA RDI,[RSP + 0x10]
CALL 0x0014b7fa
MOV BPL,0x1
LAB_00180c8a:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x131
MOV RCX,R14
CALL 0x00146ffc
XOR EBP,EBP
LEA RSI,[0x1ec180]
LEA RDX,[0x133f9e]
MOV RDI,RBX
CALL 0x00119ba0
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[](unsigned long) const */
long __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[](basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,ulong param_1)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
return param_1 * 0x10 + **(long **)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 00180c76 to 00180c86 has its CatchHandler @ 00180cd7 */
detail::concat<std::__cxx11::string,char_const(&)[52],char_const*>
(local_38,"cannot use operator[] with a numeric argument with ",&local_40);
/* try { // try from 00180c8a to 00180cb6 has its CatchHandler @ 00180cb7 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x131,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
54,785 | google::protobuf::FileDescriptorTables::GetEmptyInstance() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | inline const FileDescriptorTables& FileDescriptorTables::GetEmptyInstance() {
static auto file_descriptor_tables =
internal::OnShutdownDelete(new FileDescriptorTables());
return *file_descriptor_tables;
} | O0 | cpp | google::protobuf::FileDescriptorTables::GetEmptyInstance():
subq $0x28, %rsp
cmpb $0x0, 0x205bcd(%rip) # 0x27d168
jne 0x775f4
leaq 0x205bc4(%rip), %rdi # 0x27d168
callq 0x13770
cmpl $0x0, %eax
je 0x775f4
movl $0x160, %edi # imm = 0x160
callq 0x13450
movq %rax, 0x10(%rsp)
jmp 0x775bf
movq 0x10(%rsp), %rdi
callq 0x32790
jmp 0x775cb
movq 0x10(%rsp), %rdi
callq 0x83d70
movq %rax, 0x8(%rsp)
jmp 0x775dc
movq 0x8(%rsp), %rax
movq %rax, 0x205b78(%rip) # 0x27d160
leaq 0x205b79(%rip), %rdi # 0x27d168
callq 0x132e0
movq 0x205b65(%rip), %rax # 0x27d160
addq $0x28, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x77628
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x13400
leaq 0x205b39(%rip), %rdi # 0x27d168
callq 0x132d0
movq 0x20(%rsp), %rdi
callq 0x13750
nop
| _ZN6google8protobuf20FileDescriptorTables16GetEmptyInstanceEv:
sub rsp, 28h
cmp cs:_ZGVZN6google8protobuf20FileDescriptorTables16GetEmptyInstanceEvE22file_descriptor_tables, 0; `guard variable for'google::protobuf::FileDescriptorTables::GetEmptyInstance(void)::file_descriptor_tables
jnz short loc_775F4
lea rdi, _ZGVZN6google8protobuf20FileDescriptorTables16GetEmptyInstanceEvE22file_descriptor_tables; __guard *
call ___cxa_guard_acquire
cmp eax, 0
jz short loc_775F4
mov edi, 160h; unsigned __int64
call __Znwm; operator new(ulong)
mov [rsp+28h+var_18], rax
jmp short $+2
loc_775BF:
mov rdi, [rsp+28h+var_18]; this
call _ZN6google8protobuf20FileDescriptorTablesC2Ev; google::protobuf::FileDescriptorTables::FileDescriptorTables(void)
jmp short $+2
loc_775CB:
mov rdi, [rsp+28h+var_18]
call _ZN6google8protobuf8internal16OnShutdownDeleteINS0_20FileDescriptorTablesEEEPT_S5_; google::protobuf::internal::OnShutdownDelete<google::protobuf::FileDescriptorTables>(google::protobuf::FileDescriptorTables *)
mov [rsp+28h+var_20], rax
jmp short $+2
loc_775DC:
mov rax, [rsp+28h+var_20]
mov cs:_ZZN6google8protobuf20FileDescriptorTables16GetEmptyInstanceEvE22file_descriptor_tables, rax; google::protobuf::FileDescriptorTables::GetEmptyInstance(void)::file_descriptor_tables
lea rdi, _ZGVZN6google8protobuf20FileDescriptorTables16GetEmptyInstanceEvE22file_descriptor_tables; __guard *
call ___cxa_guard_release
loc_775F4:
mov rax, cs:_ZZN6google8protobuf20FileDescriptorTables16GetEmptyInstanceEvE22file_descriptor_tables; google::protobuf::FileDescriptorTables::GetEmptyInstance(void)::file_descriptor_tables
add rsp, 28h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
jmp short loc_77628
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
call __ZdlPv; operator delete(void *)
loc_77628:
lea rdi, _ZGVZN6google8protobuf20FileDescriptorTables16GetEmptyInstanceEvE22file_descriptor_tables; __guard *
call ___cxa_guard_abort
mov rdi, [rsp+arg_18]
call __Unwind_Resume
| long long google::protobuf::FileDescriptorTables::GetEmptyInstance(
google::protobuf::FileDescriptorTables *this)
{
google::protobuf::FileDescriptorTables *v2; // [rsp+10h] [rbp-18h]
if ( !(_BYTE)`guard variable for'google::protobuf::FileDescriptorTables::GetEmptyInstance(void)::file_descriptor_tables
&& __cxa_guard_acquire(&`guard variable for'google::protobuf::FileDescriptorTables::GetEmptyInstance(void)::file_descriptor_tables) )
{
v2 = (google::protobuf::FileDescriptorTables *)operator new(0x160uLL);
google::protobuf::FileDescriptorTables::FileDescriptorTables(v2);
google::protobuf::FileDescriptorTables::GetEmptyInstance(void)::file_descriptor_tables = google::protobuf::internal::OnShutdownDelete<google::protobuf::FileDescriptorTables>(v2);
__cxa_guard_release(&`guard variable for'google::protobuf::FileDescriptorTables::GetEmptyInstance(void)::file_descriptor_tables);
}
return google::protobuf::FileDescriptorTables::GetEmptyInstance(void)::file_descriptor_tables;
}
| GetEmptyInstance:
SUB RSP,0x28
CMP byte ptr [0x0037d168],0x0
JNZ 0x001775f4
LEA RDI,[0x37d168]
CALL 0x00113770
CMP EAX,0x0
JZ 0x001775f4
LAB_001775ae:
MOV EDI,0x160
CALL 0x00113450
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001775bf
LAB_001775bf:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00132790
JMP 0x001775cb
LAB_001775cb:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00183d70
LAB_001775d5:
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001775dc
LAB_001775dc:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [0x0037d160],RAX
LEA RDI,[0x37d168]
CALL 0x001132e0
LAB_001775f4:
MOV RAX,qword ptr [0x0037d160]
ADD RSP,0x28
RET
|
/* google::protobuf::FileDescriptorTables::GetEmptyInstance() */
FileDescriptorTables * google::protobuf::FileDescriptorTables::GetEmptyInstance(void)
{
int iVar1;
FileDescriptorTables *this;
if (GetEmptyInstance()::file_descriptor_tables == '\0') {
iVar1 = __cxa_guard_acquire(&GetEmptyInstance()::file_descriptor_tables);
if (iVar1 != 0) {
/* try { // try from 001775ae to 001775b7 has its CatchHandler @ 00177600 */
this = (FileDescriptorTables *)operator_new(0x160);
/* try { // try from 001775bf to 001775c8 has its CatchHandler @ 00177610 */
FileDescriptorTables(this);
/* try { // try from 001775cb to 001775d4 has its CatchHandler @ 00177600 */
GetEmptyInstance()::file_descriptor_tables =
internal::OnShutdownDelete<google::protobuf::FileDescriptorTables>(this);
__cxa_guard_release(&GetEmptyInstance()::file_descriptor_tables);
}
}
return GetEmptyInstance()::file_descriptor_tables;
}
| |
54,786 | google::protobuf::compiler::CodeGeneratorResponse::CodeGeneratorResponse(google::protobuf::compiler::CodeGeneratorResponse const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/plugin.pb.cc | CodeGeneratorResponse::CodeGeneratorResponse(const CodeGeneratorResponse& from)
: ::PROTOBUF_NAMESPACE_ID::Message() {
CodeGeneratorResponse* const _this = this; (void)_this;
new (&_impl_) Impl_{
decltype(_impl_._has_bits_){from._impl_._has_bits_}
, /*decltype(_impl_._cached_size_)*/{}
, decltype(_impl_.file_){from._impl_.file_}
, decltype(_impl_.error_){}
, decltype(_impl_.supported_features_){}};
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
_impl_.error_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.error_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_error()) {
_this->_impl_.error_.Set(from._internal_error(),
_this->GetArenaForAllocation());
}
_this->_impl_.supported_features_ = from._impl_.supported_features_;
// @@protoc_insertion_point(copy_constructor:google.protobuf.compiler.CodeGeneratorResponse)
} | O3 | cpp | google::protobuf::compiler::CodeGeneratorResponse::CodeGeneratorResponse(google::protobuf::compiler::CodeGeneratorResponse const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq $0x0, 0x8(%rdi)
leaq 0x52e5e(%rip), %rax # 0x101b70
movq %rax, (%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%rdi)
movups %xmm0, 0x20(%rdi)
cmpl $0x0, 0x20(%rsi)
je 0xaed45
leaq 0x18(%rbx), %rdi
leaq 0x18(%r15), %rsi
leaq 0x8db(%rip), %rdx # 0xaf616
xorl %ecx, %ecx
callq 0x4769a
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq 0x8(%r15), %rsi
testb $0x1, %sil
je 0xaed63
andq $-0x4, %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x59718
leaq 0x30(%rbx), %rdi
leaq 0x5450a(%rip), %rax # 0x103278
movq %rax, (%rdi)
testb $0x1, 0x10(%r15)
je 0xaed93
movq 0x30(%r15), %rsi
andq $-0x4, %rsi
movq (%r14), %rax
movq %rax, %rdx
andq $-0x4, %rdx
testb $0x1, %al
jne 0xaeda1
callq 0x9308e
movq 0x38(%r15), %rax
movq %rax, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq (%rdx), %rdx
jmp 0xaed8e
movq %rax, %r15
leaq 0x52570(%rip), %rax # 0x101320
addq $0x10, %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x59494
movq %r15, %rdi
callq 0xf570
nop
| _ZN6google8protobuf8compiler21CodeGeneratorResponseC2ERKS2_:
push r15
push r14
push rbx
mov r15, rsi
mov rbx, rdi
lea r14, [rdi+8]
mov qword ptr [rdi+8], 0
lea rax, off_101B70
mov [rdi], rax
mov eax, [rsi+10h]
mov [rdi+10h], eax
xorps xmm0, xmm0
movups xmmword ptr [rdi+14h], xmm0
movups xmmword ptr [rdi+20h], xmm0
cmp dword ptr [rsi+20h], 0
jz short loc_AED45
lea rdi, [rbx+18h]
lea rsi, [r15+18h]
lea rdx, _ZN6google8protobuf8internal20RepeatedPtrFieldBase18MergeFromInnerLoopINS0_16RepeatedPtrFieldINS0_8compiler26CodeGeneratorResponse_FileEE11TypeHandlerEEEvPPvSA_ii; google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<google::protobuf::compiler::CodeGeneratorResponse_File>::TypeHandler>(void **,void **,int,int)
xor ecx, ecx
call _ZN6google8protobuf8internal20RepeatedPtrFieldBase17MergeFromInternalERKS2_MS2_FvPPvS6_iiE; google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInternal(google::protobuf::internal::RepeatedPtrFieldBase const&,void (google::protobuf::internal::RepeatedPtrFieldBase::*)(void **,void **,int,int))
xorps xmm0, xmm0
loc_AED45:
movups xmmword ptr [rbx+30h], xmm0
mov rsi, [r15+8]
test sil, 1
jz short loc_AED63
and rsi, 0FFFFFFFFFFFFFFFCh
add rsi, 8
mov rdi, r14
call _ZN6google8protobuf8internal16InternalMetadata11DoMergeFromINS0_15UnknownFieldSetEEEvRKT_; google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(google::protobuf::UnknownFieldSet const&)
loc_AED63:
lea rdi, [rbx+30h]
lea rax, _ZN6google8protobuf8internal26fixed_address_empty_stringB5cxx11E; google::protobuf::internal::fixed_address_empty_string
mov [rdi], rax
test byte ptr [r15+10h], 1
jz short loc_AED93
mov rsi, [r15+30h]
and rsi, 0FFFFFFFFFFFFFFFCh
mov rax, [r14]
mov rdx, rax
and rdx, 0FFFFFFFFFFFFFFFCh
test al, 1
jnz short loc_AEDA1
loc_AED8E:
call _ZN6google8protobuf8internal14ArenaStringPtr3SetERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPNS0_5ArenaE; google::protobuf::internal::ArenaStringPtr::Set(std::string const&,google::protobuf::Arena *)
loc_AED93:
mov rax, [r15+38h]
mov [rbx+38h], rax
pop rbx
pop r14
pop r15
retn
loc_AEDA1:
mov rdx, [rdx]
jmp short loc_AED8E
mov r15, rax
lea rax, _ZTVN6google8protobuf11MessageLiteE; `vtable for'google::protobuf::MessageLite
add rax, 10h
mov [rbx], rax
mov rdi, r14; this
call _ZN6google8protobuf8internal16InternalMetadataD2Ev; google::protobuf::internal::InternalMetadata::~InternalMetadata()
mov rdi, r15
call __Unwind_Resume
| long long google::protobuf::compiler::CodeGeneratorResponse::CodeGeneratorResponse(
google::protobuf::compiler::CodeGeneratorResponse *this,
const google::protobuf::compiler::CodeGeneratorResponse *a2)
{
long long *v3; // r14
__int128 v4; // xmm0
long long v5; // rsi
google::protobuf::Arena *v6; // rdx
long long result; // rax
v3 = (long long *)((char *)this + 8);
*((_QWORD *)this + 1) = 0LL;
*(_QWORD *)this = off_101B70;
*((_DWORD *)this + 4) = *((_DWORD *)a2 + 4);
v4 = 0LL;
*(_OWORD *)((char *)this + 20) = 0LL;
*((_OWORD *)this + 2) = 0LL;
if ( *((_DWORD *)a2 + 8) )
{
google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInternal(
(long long)this + 24,
(long long)a2 + 24,
(char *)google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<google::protobuf::compiler::CodeGeneratorResponse_File>::TypeHandler>,
0LL);
v4 = 0LL;
}
*((_OWORD *)this + 3) = v4;
v5 = *((_QWORD *)a2 + 1);
if ( (v5 & 1) != 0 )
google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(
v3,
(const google::protobuf::UnknownFieldSet *)((v5 & 0xFFFFFFFFFFFFFFFCLL) + 8));
*((_QWORD *)this + 6) = google::protobuf::internal::fixed_address_empty_string[abi:cxx11];
if ( (*((_BYTE *)a2 + 16) & 1) != 0 )
{
v6 = (google::protobuf::Arena *)(*v3 & 0xFFFFFFFFFFFFFFFCLL);
if ( (*v3 & 1) != 0 )
v6 = *(google::protobuf::Arena **)v6;
google::protobuf::internal::ArenaStringPtr::Set((long long *)this + 6, *((_QWORD *)a2 + 6) & 0xFFFFFFFFFFFFFFFCLL, v6);
}
result = *((_QWORD *)a2 + 7);
*((_QWORD *)this + 7) = result;
return result;
}
| CodeGeneratorResponse:
PUSH R15
PUSH R14
PUSH RBX
MOV R15,RSI
MOV RBX,RDI
LEA R14,[RDI + 0x8]
MOV qword ptr [RDI + 0x8],0x0
LEA RAX,[0x201b70]
MOV qword ptr [RDI],RAX
MOV EAX,dword ptr [RSI + 0x10]
MOV dword ptr [RDI + 0x10],EAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x14],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
CMP dword ptr [RSI + 0x20],0x0
JZ 0x001aed45
LEA RDI,[RBX + 0x18]
LEA RSI,[R15 + 0x18]
LAB_001aed34:
LEA RDX,[0x1af616]
XOR ECX,ECX
CALL 0x0014769a
XORPS XMM0,XMM0
LAB_001aed45:
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV RSI,qword ptr [R15 + 0x8]
TEST SIL,0x1
JZ 0x001aed63
AND RSI,-0x4
ADD RSI,0x8
MOV RDI,R14
CALL 0x00159718
LAB_001aed63:
LEA RDI,[RBX + 0x30]
LEA RAX,[0x203278]
MOV qword ptr [RDI],RAX
TEST byte ptr [R15 + 0x10],0x1
JZ 0x001aed93
MOV RSI,qword ptr [R15 + 0x30]
AND RSI,-0x4
MOV RAX,qword ptr [R14]
MOV RDX,RAX
AND RDX,-0x4
TEST AL,0x1
JNZ 0x001aeda1
LAB_001aed8e:
CALL 0x0019308e
LAB_001aed93:
MOV RAX,qword ptr [R15 + 0x38]
MOV qword ptr [RBX + 0x38],RAX
POP RBX
POP R14
POP R15
RET
LAB_001aeda1:
MOV RDX,qword ptr [RDX]
JMP 0x001aed8e
|
/* google::protobuf::compiler::CodeGeneratorResponse::CodeGeneratorResponse(google::protobuf::compiler::CodeGeneratorResponse
const&) */
void __thiscall
google::protobuf::compiler::CodeGeneratorResponse::CodeGeneratorResponse
(CodeGeneratorResponse *this,CodeGeneratorResponse *param_1)
{
ulong uVar1;
Arena *pAVar2;
*(int8 *)(this + 8) = 0;
*(int ***)this = &PTR__CodeGeneratorResponse_00201b70;
*(int4 *)(this + 0x10) = *(int4 *)(param_1 + 0x10);
*(int8 *)(this + 0x14) = 0;
*(int8 *)(this + 0x1c) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
if (*(int *)(param_1 + 0x20) != 0) {
/* try { // try from 001aed34 to 001aed92 has its CatchHandler @ 001aeda6 */
internal::RepeatedPtrFieldBase::MergeFromInternal
((RepeatedPtrFieldBase *)(this + 0x18),
(_func_void_void_ptr_ptr_void_ptr_ptr_int_int *)(param_1 + 0x18));
}
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
if ((*(ulong *)(param_1 + 8) & 1) != 0) {
internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>
((InternalMetadata *)(this + 8),
(UnknownFieldSet *)((*(ulong *)(param_1 + 8) & 0xfffffffffffffffc) + 8));
}
*(int8 **)(this + 0x30) = &internal::fixed_address_empty_string_abi_cxx11_;
if (((byte)param_1[0x10] & 1) != 0) {
uVar1 = *(ulong *)(this + 8);
pAVar2 = (Arena *)(uVar1 & 0xfffffffffffffffc);
if ((uVar1 & 1) != 0) {
pAVar2 = *(Arena **)pAVar2;
}
internal::ArenaStringPtr::Set
((ArenaStringPtr *)(this + 0x30),
(string *)(*(ulong *)(param_1 + 0x30) & 0xfffffffffffffffc),pAVar2);
}
*(int8 *)(this + 0x38) = *(int8 *)(param_1 + 0x38);
return;
}
| |
54,787 | ftxui::Color::Interpolate(float, ftxui::Color const&, ftxui::Color const&) | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/screen/color.cpp | Color Color::Interpolate(float t, const Color& a, const Color& b) {
if (a.type_ == ColorType::Palette1 || //
b.type_ == ColorType::Palette1) {
if (t < 0.5F) { // NOLINT
return a;
} else {
return b;
}
}
auto get_color = [](const Color& color, //
uint8_t* red, uint8_t* green, uint8_t* blue) {
switch (color.type_) {
case ColorType::Palette1: {
return;
}
case ColorType::Palette16: {
const ColorInfo info = GetColorInfo(Color::Palette16(color.red_));
*red = info.red;
*green = info.green;
*blue = info.blue;
return;
}
case ColorType::Palette256: {
const ColorInfo info = GetColorInfo(Color::Palette256(color.red_));
*red = info.red;
*green = info.green;
*blue = info.blue;
return;
}
case ColorType::TrueColor:
default: {
*red = color.red_;
*green = color.green_;
*blue = color.blue_;
return;
}
}
};
uint8_t a_r = 0;
uint8_t a_g = 0;
uint8_t a_b = 0;
uint8_t b_r = 0;
uint8_t b_g = 0;
uint8_t b_b = 0;
get_color(a, &a_r, &a_g, &a_b);
get_color(b, &b_r, &b_g, &b_b);
// Gamma correction:
// https://en.wikipedia.org/wiki/Gamma_correction
auto interp = [t](uint8_t a_u, uint8_t b_u) {
constexpr float gamma = 2.2F;
const float a_f = powf(a_u, gamma);
const float b_f = powf(b_u, gamma);
const float c_f = a_f * (1.0F - t) + //
b_f * t;
return static_cast<uint8_t>(powf(c_f, 1.F / gamma));
};
return Color::RGB(interp(a_r, b_r), //
interp(a_g, b_g), //
interp(a_b, b_b)); //
} | O3 | cpp | ftxui::Color::Interpolate(float, ftxui::Color const&, ftxui::Color const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0x20de5
cmpb $0x0, (%r14)
je 0x20de5
movb 0x1(%rdi), %bpl
cmpl $0x2, %eax
movss %xmm0, 0xc(%rsp)
je 0x20e01
cmpl $0x1, %eax
jne 0x20e1f
movzbl %bpl, %edi
callq 0x2101c
jmp 0x20e0a
movss 0x1c043(%rip), %xmm1 # 0x3ce30
ucomiss %xmm0, %xmm1
jbe 0x20df9
movl (%rdi), %eax
jmp 0x20fc7
movl (%r14), %eax
jmp 0x20fc7
movzbl %bpl, %edi
callq 0x21008
movq %rdx, %rbx
movl %ebx, %ebp
shrl $0x10, %ebp
movl %ebx, %r15d
shrl $0x18, %r15d
shrq $0x20, %rbx
jmp 0x20e26
movb 0x2(%rdi), %r15b
movb 0x3(%rdi), %bl
movzbl (%r14), %r13d
testl %r13d, %r13d
je 0x20e68
cmpl $0x2, %r13d
je 0x20e47
cmpl $0x1, %r13d
jne 0x20e70
movzbl 0x1(%r14), %edi
callq 0x2101c
jmp 0x20e51
movzbl 0x1(%r14), %edi
callq 0x21008
movq %rdx, %r14
movl %r14d, %r13d
shrl $0x10, %r13d
movl %r14d, %r12d
shrl $0x18, %r12d
shrq $0x20, %r14
jmp 0x20e7c
movl %r13d, %r12d
movl %r13d, %r14d
jmp 0x20e7c
movb 0x1(%r14), %r13b
movb 0x2(%r14), %r12b
movb 0x3(%r14), %r14b
movzbl %bpl, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x1bf95(%rip), %xmm1 # 0x3ce24
callq 0xb690
movss %xmm0, 0x8(%rsp)
movzbl %r13b, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x1bf77(%rip), %xmm1 # 0x3ce24
callq 0xb690
movss 0x1bf6e(%rip), %xmm1 # 0x3ce28
movss 0xc(%rsp), %xmm2
subss %xmm2, %xmm1
movss %xmm1, 0x10(%rsp)
mulss %xmm2, %xmm0
movss 0x8(%rsp), %xmm2
mulss %xmm1, %xmm2
addss %xmm2, %xmm0
movss 0x1bf48(%rip), %xmm1 # 0x3ce2c
callq 0xb690
cvttss2si %xmm0, %ebp
movzbl %r15b, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x1bf24(%rip), %xmm1 # 0x3ce24
callq 0xb690
movss %xmm0, 0x8(%rsp)
movzbl %r12b, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x1bf06(%rip), %xmm1 # 0x3ce24
callq 0xb690
mulss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
mulss 0x10(%rsp), %xmm1
addss %xmm1, %xmm0
movss 0x1beeb(%rip), %xmm1 # 0x3ce2c
callq 0xb690
cvttss2si %xmm0, %r15d
movzbl %bl, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x1bec7(%rip), %xmm1 # 0x3ce24
callq 0xb690
movss %xmm0, 0x8(%rsp)
movzbl %r14b, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x1bea9(%rip), %xmm1 # 0x3ce24
callq 0xb690
mulss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
mulss 0x10(%rsp), %xmm1
addss %xmm1, %xmm0
movss 0x1be8e(%rip), %xmm1 # 0x3ce2c
callq 0xb690
cvttss2si %xmm0, %ecx
movl $0xff, %eax
andl %eax, %ebp
andl %eax, %r15d
andl %eax, %ecx
leaq 0x14(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x20bc4
movl (%rbx), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN5ftxui5Color11InterpolateEfRKS0_S2_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rsi
movzx eax, byte ptr [rdi]
test eax, eax
jz short loc_20DE5
cmp byte ptr [r14], 0
jz short loc_20DE5
mov bpl, [rdi+1]
cmp eax, 2
movss [rsp+48h+var_3C], xmm0
jz short loc_20E01
cmp eax, 1
jnz short loc_20E1F
movzx edi, bpl
call _ZN5ftxui12GetColorInfoENS_5Color9Palette16E; ftxui::GetColorInfo(ftxui::Color::Palette16)
jmp short loc_20E0A
loc_20DE5:
movss xmm1, cs:dword_3CE30
ucomiss xmm1, xmm0
jbe short loc_20DF9
mov eax, [rdi]
jmp loc_20FC7
loc_20DF9:
mov eax, [r14]
jmp loc_20FC7
loc_20E01:
movzx edi, bpl
call _ZN5ftxui12GetColorInfoENS_5Color10Palette256E; ftxui::GetColorInfo(ftxui::Color::Palette256)
loc_20E0A:
mov rbx, rdx
mov ebp, ebx
shr ebp, 10h
mov r15d, ebx
shr r15d, 18h
shr rbx, 20h
jmp short loc_20E26
loc_20E1F:
mov r15b, [rdi+2]
mov bl, [rdi+3]
loc_20E26:
movzx r13d, byte ptr [r14]
test r13d, r13d
jz short loc_20E68
cmp r13d, 2
jz short loc_20E47
cmp r13d, 1
jnz short loc_20E70
movzx edi, byte ptr [r14+1]
call _ZN5ftxui12GetColorInfoENS_5Color9Palette16E; ftxui::GetColorInfo(ftxui::Color::Palette16)
jmp short loc_20E51
loc_20E47:
movzx edi, byte ptr [r14+1]
call _ZN5ftxui12GetColorInfoENS_5Color10Palette256E; ftxui::GetColorInfo(ftxui::Color::Palette256)
loc_20E51:
mov r14, rdx
mov r13d, r14d
shr r13d, 10h
mov r12d, r14d
shr r12d, 18h
shr r14, 20h
jmp short loc_20E7C
loc_20E68:
mov r12d, r13d
mov r14d, r13d
jmp short loc_20E7C
loc_20E70:
mov r13b, [r14+1]
mov r12b, [r14+2]
mov r14b, [r14+3]
loc_20E7C:
movzx eax, bpl
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_3CE24
call _powf
movss [rsp+48h+var_40], xmm0
movzx eax, r13b
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_3CE24
call _powf
movss xmm1, cs:dword_3CE28
movss xmm2, [rsp+48h+var_3C]
subss xmm1, xmm2
movss [rsp+48h+var_38], xmm1
mulss xmm0, xmm2
movss xmm2, [rsp+48h+var_40]
mulss xmm2, xmm1
addss xmm0, xmm2
movss xmm1, cs:dword_3CE2C
call _powf
cvttss2si ebp, xmm0
movzx eax, r15b
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_3CE24
call _powf
movss [rsp+48h+var_40], xmm0
movzx eax, r12b
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_3CE24
call _powf
mulss xmm0, [rsp+48h+var_3C]
movss xmm1, [rsp+48h+var_40]
mulss xmm1, [rsp+48h+var_38]
addss xmm0, xmm1
movss xmm1, cs:dword_3CE2C
call _powf
cvttss2si r15d, xmm0
movzx eax, bl
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_3CE24
call _powf
movss [rsp+48h+var_40], xmm0
movzx eax, r14b
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_3CE24
call _powf
mulss xmm0, [rsp+48h+var_3C]
movss xmm1, [rsp+48h+var_40]
mulss xmm1, [rsp+48h+var_38]
addss xmm0, xmm1
movss xmm1, cs:dword_3CE2C
call _powf
cvttss2si ecx, xmm0
mov eax, 0FFh
and ebp, eax
and r15d, eax
and ecx, eax; unsigned __int8
lea rbx, [rsp+48h+var_34]
mov rdi, rbx; this
mov esi, ebp; unsigned __int8
mov edx, r15d; unsigned __int8
call _ZN5ftxui5ColorC2Ehhh; ftxui::Color::Color(uchar,uchar,uchar)
mov eax, [rbx]
loc_20FC7:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ftxui::Color::Interpolate(ftxui::Color *this, float a2, const ftxui::Color *a3, unsigned long long a4)
{
int v4; // eax
unsigned int v5; // ebp
unsigned int v7; // r15d
unsigned long long v8; // rbx
unsigned int v9; // r13d
unsigned long long v10; // rdx
unsigned int v11; // r12d
unsigned long long v12; // r14
float v13; // xmm0_4
int v14; // ebp
float v15; // xmm0_4
int v16; // r15d
float v17; // xmm0_4
float v18; // xmm0_4
float v19; // [rsp+8h] [rbp-40h]
float v20; // [rsp+8h] [rbp-40h]
float v21; // [rsp+8h] [rbp-40h]
_DWORD v23[13]; // [rsp+14h] [rbp-34h] BYREF
v4 = *(unsigned __int8 *)this;
if ( *(_BYTE *)this && *(_BYTE *)a3 )
{
LOBYTE(v5) = *((_BYTE *)this + 1);
if ( v4 == 2 )
{
ftxui::GetColorInfo((unsigned __int8)v5);
}
else
{
if ( v4 != 1 )
{
LOBYTE(v7) = *((_BYTE *)this + 2);
LOBYTE(v8) = *((_BYTE *)this + 3);
LABEL_12:
v9 = *(unsigned __int8 *)a3;
if ( *(_BYTE *)a3 )
{
if ( v9 == 2 )
{
ftxui::GetColorInfo(*((unsigned __int8 *)a3 + 1));
}
else
{
if ( v9 != 1 )
{
LOBYTE(v9) = *((_BYTE *)a3 + 1);
LOBYTE(v11) = *((_BYTE *)a3 + 2);
LOBYTE(v12) = *((_BYTE *)a3 + 3);
goto LABEL_20;
}
ftxui::GetColorInfo(*((unsigned __int8 *)a3 + 1), a3, a4);
}
v9 = WORD1(v10);
v11 = BYTE3(v10);
v12 = HIDWORD(v10);
}
else
{
LOBYTE(v11) = *(_BYTE *)a3;
LOBYTE(v12) = *(_BYTE *)a3;
}
LABEL_20:
v19 = powf((float)(unsigned __int8)v5, 2.2);
v13 = powf((float)(unsigned __int8)v9, 2.2);
v14 = (int)powf((float)(v13 * a2) + (float)(v19 * (float)(1.0 - a2)), 0.45454544);
v20 = powf((float)(unsigned __int8)v7, 2.2);
v15 = powf((float)(unsigned __int8)v11, 2.2);
v16 = (int)powf((float)(v15 * a2) + (float)(v20 * (float)(1.0 - a2)), 0.45454544);
v21 = powf((float)(unsigned __int8)v8, 2.2);
v17 = powf((float)(unsigned __int8)v12, 2.2);
v18 = powf((float)(v17 * a2) + (float)(v21 * (float)(1.0 - a2)), 0.45454544);
ftxui::Color::Color((ftxui::Color *)v23, v14, v16, (int)v18);
return v23[0];
}
ftxui::GetColorInfo((unsigned __int8)v5, a3, a4);
}
v5 = WORD1(a4);
v7 = BYTE3(a4);
v8 = HIDWORD(a4);
goto LABEL_12;
}
if ( a2 >= 0.5 )
return *(unsigned int *)a3;
else
return *(unsigned int *)this;
}
| Interpolate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JZ 0x00120de5
CMP byte ptr [R14],0x0
JZ 0x00120de5
MOV BPL,byte ptr [RDI + 0x1]
CMP EAX,0x2
MOVSS dword ptr [RSP + 0xc],XMM0
JZ 0x00120e01
CMP EAX,0x1
JNZ 0x00120e1f
MOVZX EDI,BPL
CALL 0x0012101c
JMP 0x00120e0a
LAB_00120de5:
MOVSS XMM1,dword ptr [0x0013ce30]
UCOMISS XMM1,XMM0
JBE 0x00120df9
MOV EAX,dword ptr [RDI]
JMP 0x00120fc7
LAB_00120df9:
MOV EAX,dword ptr [R14]
JMP 0x00120fc7
LAB_00120e01:
MOVZX EDI,BPL
CALL 0x00121008
LAB_00120e0a:
MOV RBX,RDX
MOV EBP,EBX
SHR EBP,0x10
MOV R15D,EBX
SHR R15D,0x18
SHR RBX,0x20
JMP 0x00120e26
LAB_00120e1f:
MOV R15B,byte ptr [RDI + 0x2]
MOV BL,byte ptr [RDI + 0x3]
LAB_00120e26:
MOVZX R13D,byte ptr [R14]
TEST R13D,R13D
JZ 0x00120e68
CMP R13D,0x2
JZ 0x00120e47
CMP R13D,0x1
JNZ 0x00120e70
MOVZX EDI,byte ptr [R14 + 0x1]
CALL 0x0012101c
JMP 0x00120e51
LAB_00120e47:
MOVZX EDI,byte ptr [R14 + 0x1]
CALL 0x00121008
LAB_00120e51:
MOV R14,RDX
MOV R13D,R14D
SHR R13D,0x10
MOV R12D,R14D
SHR R12D,0x18
SHR R14,0x20
JMP 0x00120e7c
LAB_00120e68:
MOV R12D,R13D
MOV R14D,R13D
JMP 0x00120e7c
LAB_00120e70:
MOV R13B,byte ptr [R14 + 0x1]
MOV R12B,byte ptr [R14 + 0x2]
MOV R14B,byte ptr [R14 + 0x3]
LAB_00120e7c:
MOVZX EAX,BPL
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0013ce24]
CALL 0x0010b690
MOVSS dword ptr [RSP + 0x8],XMM0
MOVZX EAX,R13B
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0013ce24]
CALL 0x0010b690
MOVSS XMM1,dword ptr [0x0013ce28]
MOVSS XMM2,dword ptr [RSP + 0xc]
SUBSS XMM1,XMM2
MOVSS dword ptr [RSP + 0x10],XMM1
MULSS XMM0,XMM2
MOVSS XMM2,dword ptr [RSP + 0x8]
MULSS XMM2,XMM1
ADDSS XMM0,XMM2
MOVSS XMM1,dword ptr [0x0013ce2c]
CALL 0x0010b690
CVTTSS2SI EBP,XMM0
MOVZX EAX,R15B
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0013ce24]
CALL 0x0010b690
MOVSS dword ptr [RSP + 0x8],XMM0
MOVZX EAX,R12B
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0013ce24]
CALL 0x0010b690
MULSS XMM0,dword ptr [RSP + 0xc]
MOVSS XMM1,dword ptr [RSP + 0x8]
MULSS XMM1,dword ptr [RSP + 0x10]
ADDSS XMM0,XMM1
MOVSS XMM1,dword ptr [0x0013ce2c]
CALL 0x0010b690
CVTTSS2SI R15D,XMM0
MOVZX EAX,BL
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0013ce24]
CALL 0x0010b690
MOVSS dword ptr [RSP + 0x8],XMM0
MOVZX EAX,R14B
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0013ce24]
CALL 0x0010b690
MULSS XMM0,dword ptr [RSP + 0xc]
MOVSS XMM1,dword ptr [RSP + 0x8]
MULSS XMM1,dword ptr [RSP + 0x10]
ADDSS XMM0,XMM1
MOVSS XMM1,dword ptr [0x0013ce2c]
CALL 0x0010b690
CVTTSS2SI ECX,XMM0
MOV EAX,0xff
AND EBP,EAX
AND R15D,EAX
AND ECX,EAX
LEA RBX,[RSP + 0x14]
MOV RDI,RBX
MOV ESI,EBP
MOV EDX,R15D
CALL 0x00120bc4
MOV EAX,dword ptr [RBX]
LAB_00120fc7:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ftxui::Color::Interpolate(float, ftxui::Color const&, ftxui::Color const&) */
int4 ftxui::Color::Interpolate(float param_1,Color *param_2,Color *param_3)
{
Color CVar1;
Color CVar2;
int8 extraout_RDX;
int8 extraout_RDX_00;
int8 extraout_RDX_01;
int8 extraout_RDX_02;
int8 uVar3;
uint uVar4;
uint uVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
float fVar10;
float fVar11;
float fVar12;
float fVar13;
float fVar14;
int4 local_34;
CVar2 = *param_2;
if ((CVar2 == (Color)0x0) || (*param_3 == (Color)0x0)) {
if (param_1 < DAT_0013ce30) {
return *(int4 *)param_2;
}
return *(int4 *)param_3;
}
CVar1 = param_2[1];
uVar5 = (uint)(byte)CVar1;
if (CVar2 == (Color)0x2) {
GetColorInfo(CVar1);
uVar3 = extraout_RDX_00;
LAB_00120e0a:
uVar5 = (uint)((ulong)uVar3 >> 0x10) & 0xffff;
uVar9 = (uint)((ulong)uVar3 >> 0x18) & 0xff;
uVar4 = (uint)((ulong)uVar3 >> 0x20);
}
else {
if (CVar2 == (Color)0x1) {
GetColorInfo(CVar1);
uVar3 = extraout_RDX;
goto LAB_00120e0a;
}
uVar9 = (uint)(byte)param_2[2];
uVar4 = (uint)(byte)param_2[3];
}
CVar2 = *param_3;
uVar7 = (uint)(byte)CVar2;
uVar6 = uVar7;
uVar8 = uVar7;
if (CVar2 != (Color)0x0) {
if (CVar2 == (Color)0x2) {
GetColorInfo(param_3[1]);
uVar3 = extraout_RDX_02;
}
else {
if (CVar2 != (Color)0x1) {
uVar7 = (uint)(byte)param_3[1];
uVar6 = (uint)(byte)param_3[2];
uVar8 = (uint)(byte)param_3[3];
goto LAB_00120e7c;
}
GetColorInfo(param_3[1]);
uVar3 = extraout_RDX_01;
}
uVar7 = (uint)((ulong)uVar3 >> 0x10) & 0xffff;
uVar6 = (uint)((ulong)uVar3 >> 0x18) & 0xff;
uVar8 = (uint)((ulong)uVar3 >> 0x20);
}
LAB_00120e7c:
fVar10 = powf((float)(uVar5 & 0xff),DAT_0013ce24);
fVar11 = powf((float)(uVar7 & 0xff),DAT_0013ce24);
fVar14 = DAT_0013ce28 - param_1;
fVar10 = powf(fVar11 * param_1 + fVar10 * fVar14,DAT_0013ce2c);
fVar11 = powf((float)uVar9,DAT_0013ce24);
fVar12 = powf((float)uVar6,DAT_0013ce24);
fVar11 = powf(fVar12 * param_1 + fVar11 * fVar14,DAT_0013ce2c);
fVar12 = powf((float)(uVar4 & 0xff),DAT_0013ce24);
fVar13 = powf((float)(uVar8 & 0xff),DAT_0013ce24);
fVar12 = powf(fVar13 * param_1 + fVar12 * fVar14,DAT_0013ce2c);
Color((Color *)&local_34,(uchar)(int)fVar10,(uchar)(int)fVar11,(uchar)(int)fVar12);
return local_34;
}
| |
54,788 | my_coll_parser_init | eloqsql/strings/ctype-uca.c | static void
my_coll_parser_init(MY_COLL_RULE_PARSER *p,
MY_COLL_RULES *rules,
const char *str, const char *str_end)
{
/*
Initialize parser to the input buffer and scan two tokens,
to make the current token and the next token known.
*/
memset(p, 0, sizeof(*p));
p->rules= rules;
p->errstr[0]= '\0';
my_coll_lexem_init(my_coll_parser_curr(p), str, str_end);
my_coll_lexem_next(my_coll_parser_curr(p));
my_coll_parser_next(p)[0]= my_coll_parser_curr(p)[0];
my_coll_lexem_next(my_coll_parser_next(p));
} | O0 | c | my_coll_parser_init:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x178, %edx # imm = 0x178
callq 0x251e0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xf0(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xf8(%rax)
movq -0x8(%rbp), %rdi
callq 0x633c0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x633d0
movq -0x8(%rbp), %rdi
callq 0x633c0
movq %rax, %rdi
callq 0x63420
movq -0x8(%rbp), %rdi
callq 0x63810
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x633c0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl $0x28, %edx
callq 0x252a0
movq -0x8(%rbp), %rdi
callq 0x63810
movq %rax, %rdi
callq 0x63420
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| my_coll_parser_init:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rdi, [rbp+var_8]
xor esi, esi
mov edx, 178h
call _memset
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax+0F0h], rcx
mov rax, [rbp+var_8]
mov byte ptr [rax+0F8h], 0
mov rdi, [rbp+var_8]
call my_coll_parser_curr
mov rdi, rax
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call my_coll_lexem_init
mov rdi, [rbp+var_8]
call my_coll_parser_curr
mov rdi, rax
call my_coll_lexem_next
mov rdi, [rbp+var_8]
call my_coll_parser_next
mov [rbp+var_28], rax
mov rdi, [rbp+var_8]
call my_coll_parser_curr
mov rdi, [rbp+var_28]
mov rsi, rax
mov edx, 28h ; '('
call _memcpy
mov rdi, [rbp+var_8]
call my_coll_parser_next
mov rdi, rax
call my_coll_lexem_next
add rsp, 30h
pop rbp
retn
| long long my_coll_parser_init(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // rax
long long v6; // rsi
long long v7; // rax
long long v9; // [rsp+8h] [rbp-28h]
memset(a1, 0LL, 376LL);
*(_QWORD *)(a1 + 240) = a2;
*(_BYTE *)(a1 + 248) = 0;
v4 = my_coll_parser_curr(a1);
my_coll_lexem_init(v4, a3, a4);
v5 = my_coll_parser_curr(a1);
my_coll_lexem_next(v5);
v9 = my_coll_parser_next(a1);
v6 = my_coll_parser_curr(a1);
memcpy(v9, v6, 40LL);
v7 = my_coll_parser_next(a1);
return my_coll_lexem_next(v7);
}
| my_coll_parser_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RDI,qword ptr [RBP + -0x8]
XOR ESI,ESI
MOV EDX,0x178
CALL 0x001251e0
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xf0],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0xf8],0x0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001633c0
MOV RDI,RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001633d0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001633c0
MOV RDI,RAX
CALL 0x00163420
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00163810
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001633c0
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,RAX
MOV EDX,0x28
CALL 0x001252a0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00163810
MOV RDI,RAX
CALL 0x00163420
ADD RSP,0x30
POP RBP
RET
|
void my_coll_parser_init(void *param_1,int8 param_2,int8 param_3,int8 param_4)
{
int8 uVar1;
void *__dest;
void *__src;
memset(param_1,0,0x178);
*(int8 *)((long)param_1 + 0xf0) = param_2;
*(int1 *)((long)param_1 + 0xf8) = 0;
uVar1 = my_coll_parser_curr(param_1);
my_coll_lexem_init(uVar1,param_3,param_4);
uVar1 = my_coll_parser_curr(param_1);
my_coll_lexem_next(uVar1);
__dest = (void *)my_coll_parser_next(param_1);
__src = (void *)my_coll_parser_curr(param_1);
memcpy(__dest,__src,0x28);
uVar1 = my_coll_parser_next(param_1);
my_coll_lexem_next(uVar1);
return;
}
| |
54,789 | my_casedn_str_mb | eloqsql/strings/ctype-mb.c | size_t my_casedn_str_mb(CHARSET_INFO * cs, char *str)
{
register uint32 l;
register const uchar *map= cs->to_lower;
char *str_orig= str;
while (*str)
{
/* Pointing after the '\0' is safe here. */
if ((l= my_ismbchar(cs, str, str + cs->mbmaxlen)))
str+= l;
else
{
*str= (char) map[(uchar)*str];
str++;
}
}
return (size_t) (str - str_orig);
} | O0 | c | my_casedn_str_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x9e237
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x9c(%rax), %eax
addq %rax, %rdx
callq 0x9e150
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x9e215
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x9e235
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9e1d4
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_casedn_str_mb:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax+48h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
loc_9E1D4:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jz short loc_9E237
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
mov rax, [rbp+var_8]
mov eax, [rax+9Ch]
add rdx, rax
call my_ismbchar_0
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_9E215
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov ecx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp short loc_9E235
loc_9E215:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov cl, [rax+rcx]
mov rax, [rbp+var_10]
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
loc_9E235:
jmp short loc_9E1D4
loc_9E237:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_28]
sub rax, rcx
add rsp, 30h
pop rbp
retn
| _BYTE * my_casedn_str_mb(long long a1, _BYTE *a2)
{
long long v3; // [rsp+10h] [rbp-20h]
unsigned int v4; // [rsp+1Ch] [rbp-14h]
_BYTE *v5; // [rsp+20h] [rbp-10h]
v5 = a2;
v3 = *(_QWORD *)(a1 + 72);
while ( *v5 )
{
v4 = my_ismbchar_0(a1, (long long)v5, (long long)&v5[*(unsigned int *)(a1 + 156)]);
if ( v4 )
{
v5 += v4;
}
else
{
*v5 = *(_BYTE *)(v3 + (unsigned __int8)*v5);
++v5;
}
}
return (_BYTE *)(v5 - a2);
}
| my_casedn_str_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
LAB_0019e1d4:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JZ 0x0019e237
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x9c]
ADD RDX,RAX
CALL 0x0019e150
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x0019e215
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0019e235
LAB_0019e215:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_0019e235:
JMP 0x0019e1d4
LAB_0019e237:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
ADD RSP,0x30
POP RBP
RET
|
long my_casedn_str_mb(long param_1,byte *param_2)
{
long lVar1;
uint uVar2;
byte *local_18;
lVar1 = *(long *)(param_1 + 0x48);
local_18 = param_2;
while (*local_18 != 0) {
uVar2 = my_ismbchar(param_1,local_18,local_18 + *(uint *)(param_1 + 0x9c));
if (uVar2 == 0) {
*local_18 = *(byte *)(lVar1 + (ulong)*local_18);
local_18 = local_18 + 1;
}
else {
local_18 = local_18 + uVar2;
}
}
return (long)local_18 - (long)param_2;
}
| |
54,790 | ftxui::TerminalInputParser::ParseUTF8() | Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/component/terminal_input_parser.cpp | TerminalInputParser::Output TerminalInputParser::ParseUTF8() {
auto head = Current();
unsigned char selector = 0b1000'0000; // NOLINT
// The non code-point part of the first byte.
unsigned char mask = selector;
// Find the first zero in the first byte.
unsigned int first_zero = 8; // NOLINT
for (unsigned int i = 0; i < 8; ++i) { // NOLINT
mask |= selector;
if (!(head & selector)) {
first_zero = i;
break;
}
selector >>= 1U;
}
// Accumulate the value of the first byte.
auto value = uint32_t(head & ~mask); // NOLINT
// Invalid UTF8, with more than 5 bytes.
const unsigned int max_utf8_bytes = 5;
if (first_zero == 1 || first_zero >= max_utf8_bytes) {
return DROP;
}
// Multi byte UTF-8.
for (unsigned int i = 2; i <= first_zero; ++i) {
if (!Eat()) {
return UNCOMPLETED;
}
// Invalid continuation byte.
head = Current();
if ((head & 0b1100'0000) != 0b1000'0000) { // NOLINT
return DROP;
}
value <<= 6; // NOLINT
value += head & 0b0011'1111; // NOLINT
}
// Check for overlong UTF8 encoding.
int extra_byte = 0;
if (value <= 0b000'0000'0111'1111) { // NOLINT
extra_byte = 0; // NOLINT
} else if (value <= 0b000'0111'1111'1111) { // NOLINT
extra_byte = 1; // NOLINT
} else if (value <= 0b1111'1111'1111'1111) { // NOLINT
extra_byte = 2; // NOLINT
} else if (value <= 0b1'0000'1111'1111'1111'1111) { // NOLINT
extra_byte = 3; // NOLINT
} else { // NOLINT
return DROP;
}
if (extra_byte != position_) {
return DROP;
}
return CHARACTER;
} | O0 | cpp | ftxui::TerminalInputParser::ParseUTF8():
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x72a80
movb %al, -0x9(%rbp)
movb $-0x80, -0xa(%rbp)
movb -0xa(%rbp), %al
movb %al, -0xb(%rbp)
movl $0x8, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jae 0x72c2a
movzbl -0xa(%rbp), %ecx
movzbl -0xb(%rbp), %eax
orl %ecx, %eax
movb %al, -0xb(%rbp)
movzbl -0x9(%rbp), %eax
movzbl -0xa(%rbp), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x72c16
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x72c2a
movzbl -0xa(%rbp), %eax
sarl %eax
movb %al, -0xa(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x72bec
movzbl -0x9(%rbp), %eax
movzbl -0xb(%rbp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x18(%rbp)
movl $0x5, -0x1c(%rbp)
cmpl $0x1, -0x10(%rbp)
je 0x72c4d
cmpl $0x5, -0x10(%rbp)
jb 0x72c60
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x73b90
jmp 0x72d68
movl $0x2, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
ja 0x72cdc
movq -0x30(%rbp), %rdi
callq 0x72ab0
testb $0x1, %al
jne 0x72c8c
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x73b90
jmp 0x72d68
movq -0x30(%rbp), %rdi
callq 0x72a80
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
andl $0xc0, %eax
cmpl $0x80, %eax
je 0x72cbb
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x73b90
jmp 0x72d68
movl -0x18(%rbp), %eax
shll $0x6, %eax
movl %eax, -0x18(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x3f, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x72c67
movl $0x0, -0x24(%rbp)
cmpl $0x7f, -0x18(%rbp)
ja 0x72cf2
movl $0x0, -0x24(%rbp)
jmp 0x72d3e
cmpl $0x7ff, -0x18(%rbp) # imm = 0x7FF
ja 0x72d04
movl $0x1, -0x24(%rbp)
jmp 0x72d3c
cmpl $0xffff, -0x18(%rbp) # imm = 0xFFFF
ja 0x72d16
movl $0x2, -0x24(%rbp)
jmp 0x72d3a
cmpl $0x10ffff, -0x18(%rbp) # imm = 0x10FFFF
ja 0x72d28
movl $0x3, -0x24(%rbp)
jmp 0x72d38
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x73b90
jmp 0x72d68
jmp 0x72d3a
jmp 0x72d3c
jmp 0x72d3e
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x8(%rcx), %eax
je 0x72d5a
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x73b90
jmp 0x72d68
movq -0x40(%rbp), %rdi
movl $0x2, %esi
callq 0x73b90
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN5ftxui19TerminalInputParser9ParseUTF8Ev:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_40], rdi
mov [rbp+var_38], rdi
mov [rbp+var_8], rsi
mov rdi, [rbp+var_8]; this
mov [rbp+var_30], rdi
call _ZN5ftxui19TerminalInputParser7CurrentEv; ftxui::TerminalInputParser::Current(void)
mov [rbp+var_9], al
mov [rbp+var_A], 80h
mov al, [rbp+var_A]
mov [rbp+var_B], al
mov [rbp+var_10], 8
mov [rbp+var_14], 0
loc_72BEC:
cmp [rbp+var_14], 8
jnb short loc_72C2A
movzx ecx, [rbp+var_A]
movzx eax, [rbp+var_B]
or eax, ecx
mov [rbp+var_B], al
movzx eax, [rbp+var_9]
movzx ecx, [rbp+var_A]
and eax, ecx
cmp eax, 0
jnz short loc_72C16
mov eax, [rbp+var_14]
mov [rbp+var_10], eax
jmp short loc_72C2A
loc_72C16:
movzx eax, [rbp+var_A]
sar eax, 1
mov [rbp+var_A], al
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_72BEC
loc_72C2A:
movzx eax, [rbp+var_9]
movzx ecx, [rbp+var_B]
xor ecx, 0FFFFFFFFh
and eax, ecx
mov [rbp+var_18], eax
mov [rbp+var_1C], 5
cmp [rbp+var_10], 1
jz short loc_72C4D
cmp [rbp+var_10], 5
jb short loc_72C60
loc_72C4D:
mov rdi, [rbp+var_40]
mov esi, 1
call _ZN5ftxui19TerminalInputParser6OutputC2ENS0_4TypeE; ftxui::TerminalInputParser::Output::Output(ftxui::TerminalInputParser::Type)
jmp loc_72D68
loc_72C60:
mov [rbp+var_20], 2
loc_72C67:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_10]
ja short loc_72CDC
mov rdi, [rbp+var_30]; this
call _ZN5ftxui19TerminalInputParser3EatEv; ftxui::TerminalInputParser::Eat(void)
test al, 1
jnz short loc_72C8C
mov rdi, [rbp+var_40]
xor esi, esi
call _ZN5ftxui19TerminalInputParser6OutputC2ENS0_4TypeE; ftxui::TerminalInputParser::Output::Output(ftxui::TerminalInputParser::Type)
jmp loc_72D68
loc_72C8C:
mov rdi, [rbp+var_30]; this
call _ZN5ftxui19TerminalInputParser7CurrentEv; ftxui::TerminalInputParser::Current(void)
mov [rbp+var_9], al
movzx eax, [rbp+var_9]
and eax, 0C0h
cmp eax, 80h
jz short loc_72CBB
mov rdi, [rbp+var_40]
mov esi, 1
call _ZN5ftxui19TerminalInputParser6OutputC2ENS0_4TypeE; ftxui::TerminalInputParser::Output::Output(ftxui::TerminalInputParser::Type)
jmp loc_72D68
loc_72CBB:
mov eax, [rbp+var_18]
shl eax, 6
mov [rbp+var_18], eax
movzx eax, [rbp+var_9]
and eax, 3Fh
add eax, [rbp+var_18]
mov [rbp+var_18], eax
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp short loc_72C67
loc_72CDC:
mov [rbp+var_24], 0
cmp [rbp+var_18], 7Fh
ja short loc_72CF2
mov [rbp+var_24], 0
jmp short loc_72D3E
loc_72CF2:
cmp [rbp+var_18], 7FFh
ja short loc_72D04
mov [rbp+var_24], 1
jmp short loc_72D3C
loc_72D04:
cmp [rbp+var_18], 0FFFFh
ja short loc_72D16
mov [rbp+var_24], 2
jmp short loc_72D3A
loc_72D16:
cmp [rbp+var_18], 10FFFFh
ja short loc_72D28
mov [rbp+var_24], 3
jmp short loc_72D38
loc_72D28:
mov rdi, [rbp+var_40]
mov esi, 1
call _ZN5ftxui19TerminalInputParser6OutputC2ENS0_4TypeE; ftxui::TerminalInputParser::Output::Output(ftxui::TerminalInputParser::Type)
jmp short loc_72D68
loc_72D38:
jmp short $+2
loc_72D3A:
jmp short $+2
loc_72D3C:
jmp short $+2
loc_72D3E:
mov rcx, [rbp+var_30]
mov eax, [rbp+var_24]
cmp eax, [rcx+8]
jz short loc_72D5A
mov rdi, [rbp+var_40]
mov esi, 1
call _ZN5ftxui19TerminalInputParser6OutputC2ENS0_4TypeE; ftxui::TerminalInputParser::Output::Output(ftxui::TerminalInputParser::Type)
jmp short loc_72D68
loc_72D5A:
mov rdi, [rbp+var_40]
mov esi, 2
call _ZN5ftxui19TerminalInputParser6OutputC2ENS0_4TypeE; ftxui::TerminalInputParser::Output::Output(ftxui::TerminalInputParser::Type)
loc_72D68:
mov rax, [rbp+var_38]
add rsp, 40h
pop rbp
retn
| ftxui::TerminalInputParser * ftxui::TerminalInputParser::ParseUTF8(
ftxui::TerminalInputParser *this,
ftxui::TerminalInputParser *a2)
{
char v2; // al
int v4; // [rsp+1Ch] [rbp-24h]
unsigned int j; // [rsp+20h] [rbp-20h]
unsigned int v6; // [rsp+28h] [rbp-18h]
unsigned int i; // [rsp+2Ch] [rbp-14h]
unsigned int v8; // [rsp+30h] [rbp-10h]
char v9; // [rsp+35h] [rbp-Bh]
unsigned __int8 v10; // [rsp+36h] [rbp-Ah]
char v11; // [rsp+37h] [rbp-9h]
v11 = ftxui::TerminalInputParser::Current(a2);
v10 = 0x80;
v9 = 0x80;
v8 = 8;
for ( i = 0; i < 8; ++i )
{
v9 |= v10;
if ( (v10 & (unsigned __int8)v11) == 0 )
{
v8 = i;
break;
}
v10 = (int)v10 >> 1;
}
v6 = (unsigned __int8)(~v9 & v11);
if ( v8 == 1 || v8 >= 5 )
goto LABEL_25;
for ( j = 2; j <= v8; ++j )
{
if ( !ftxui::TerminalInputParser::Eat(a2) )
{
ftxui::TerminalInputParser::Output::Output(this, 0LL);
return this;
}
v2 = ftxui::TerminalInputParser::Current(a2);
if ( (v2 & 0xC0) != 0x80 )
goto LABEL_25;
v6 = (v6 << 6) + (v2 & 0x3F);
}
if ( v6 > 0x7F )
{
if ( v6 > 0x7FF )
{
if ( v6 > 0xFFFF )
{
if ( v6 > 0x10FFFF )
goto LABEL_25;
v4 = 3;
}
else
{
v4 = 2;
}
}
else
{
v4 = 1;
}
}
else
{
v4 = 0;
}
if ( v4 == *((_DWORD *)a2 + 2) )
{
ftxui::TerminalInputParser::Output::Output(this, 2LL);
return this;
}
LABEL_25:
ftxui::TerminalInputParser::Output::Output(this, 1LL);
return this;
}
| ParseUTF8:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x40],RDI
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x8],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x30],RDI
CALL 0x00172a80
MOV byte ptr [RBP + -0x9],AL
MOV byte ptr [RBP + -0xa],0x80
MOV AL,byte ptr [RBP + -0xa]
MOV byte ptr [RBP + -0xb],AL
MOV dword ptr [RBP + -0x10],0x8
MOV dword ptr [RBP + -0x14],0x0
LAB_00172bec:
CMP dword ptr [RBP + -0x14],0x8
JNC 0x00172c2a
MOVZX ECX,byte ptr [RBP + -0xa]
MOVZX EAX,byte ptr [RBP + -0xb]
OR EAX,ECX
MOV byte ptr [RBP + -0xb],AL
MOVZX EAX,byte ptr [RBP + -0x9]
MOVZX ECX,byte ptr [RBP + -0xa]
AND EAX,ECX
CMP EAX,0x0
JNZ 0x00172c16
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x10],EAX
JMP 0x00172c2a
LAB_00172c16:
MOVZX EAX,byte ptr [RBP + -0xa]
SAR EAX,0x1
MOV byte ptr [RBP + -0xa],AL
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00172bec
LAB_00172c2a:
MOVZX EAX,byte ptr [RBP + -0x9]
MOVZX ECX,byte ptr [RBP + -0xb]
XOR ECX,0xffffffff
AND EAX,ECX
MOV dword ptr [RBP + -0x18],EAX
MOV dword ptr [RBP + -0x1c],0x5
CMP dword ptr [RBP + -0x10],0x1
JZ 0x00172c4d
CMP dword ptr [RBP + -0x10],0x5
JC 0x00172c60
LAB_00172c4d:
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,0x1
CALL 0x00173b90
JMP 0x00172d68
LAB_00172c60:
MOV dword ptr [RBP + -0x20],0x2
LAB_00172c67:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x10]
JA 0x00172cdc
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00172ab0
TEST AL,0x1
JNZ 0x00172c8c
MOV RDI,qword ptr [RBP + -0x40]
XOR ESI,ESI
CALL 0x00173b90
JMP 0x00172d68
LAB_00172c8c:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00172a80
MOV byte ptr [RBP + -0x9],AL
MOVZX EAX,byte ptr [RBP + -0x9]
AND EAX,0xc0
CMP EAX,0x80
JZ 0x00172cbb
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,0x1
CALL 0x00173b90
JMP 0x00172d68
LAB_00172cbb:
MOV EAX,dword ptr [RBP + -0x18]
SHL EAX,0x6
MOV dword ptr [RBP + -0x18],EAX
MOVZX EAX,byte ptr [RBP + -0x9]
AND EAX,0x3f
ADD EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x00172c67
LAB_00172cdc:
MOV dword ptr [RBP + -0x24],0x0
CMP dword ptr [RBP + -0x18],0x7f
JA 0x00172cf2
MOV dword ptr [RBP + -0x24],0x0
JMP 0x00172d3e
LAB_00172cf2:
CMP dword ptr [RBP + -0x18],0x7ff
JA 0x00172d04
MOV dword ptr [RBP + -0x24],0x1
JMP 0x00172d3c
LAB_00172d04:
CMP dword ptr [RBP + -0x18],0xffff
JA 0x00172d16
MOV dword ptr [RBP + -0x24],0x2
JMP 0x00172d3a
LAB_00172d16:
CMP dword ptr [RBP + -0x18],0x10ffff
JA 0x00172d28
MOV dword ptr [RBP + -0x24],0x3
JMP 0x00172d38
LAB_00172d28:
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,0x1
CALL 0x00173b90
JMP 0x00172d68
LAB_00172d38:
JMP 0x00172d3a
LAB_00172d3a:
JMP 0x00172d3c
LAB_00172d3c:
JMP 0x00172d3e
LAB_00172d3e:
MOV RCX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RCX + 0x8]
JZ 0x00172d5a
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,0x1
CALL 0x00173b90
JMP 0x00172d68
LAB_00172d5a:
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,0x2
CALL 0x00173b90
LAB_00172d68:
MOV RAX,qword ptr [RBP + -0x38]
ADD RSP,0x40
POP RBP
RET
|
/* ftxui::TerminalInputParser::ParseUTF8() */
Output * ftxui::TerminalInputParser::ParseUTF8(void)
{
byte bVar1;
ulong uVar2;
TerminalInputParser *in_RSI;
Output *in_RDI;
int local_2c;
uint local_28;
uint local_20;
uint local_1c;
uint local_18;
byte local_13;
byte local_12;
bVar1 = Current(in_RSI);
local_12 = 0x80;
local_13 = 0x80;
local_18 = 8;
local_1c = 0;
do {
if (7 < local_1c) {
LAB_00172c2a:
local_20 = (uint)bVar1 & (local_13 ^ 0xffffffff);
if ((local_18 == 1) || (4 < local_18)) {
Output::Output(in_RDI,1);
}
else {
for (local_28 = 2; local_28 <= local_18; local_28 = local_28 + 1) {
uVar2 = Eat(in_RSI);
if ((uVar2 & 1) == 0) {
Output::Output(in_RDI,0);
return in_RDI;
}
bVar1 = Current(in_RSI);
if ((bVar1 & 0xc0) != 0x80) {
Output::Output(in_RDI,1);
return in_RDI;
}
local_20 = (bVar1 & 0x3f) + local_20 * 0x40;
}
if (local_20 < 0x80) {
local_2c = 0;
}
else if (local_20 < 0x800) {
local_2c = 1;
}
else if (local_20 < 0x10000) {
local_2c = 2;
}
else {
if (0x10ffff < local_20) {
Output::Output(in_RDI,1);
return in_RDI;
}
local_2c = 3;
}
if (local_2c == *(int *)(in_RSI + 8)) {
Output::Output(in_RDI,2);
}
else {
Output::Output(in_RDI,1);
}
}
return in_RDI;
}
local_13 = local_13 | local_12;
if ((bVar1 & local_12) == 0) {
local_18 = local_1c;
goto LAB_00172c2a;
}
local_12 = (byte)((int)(uint)local_12 >> 1);
local_1c = local_1c + 1;
} while( true );
}
| |
54,791 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) | zkingston[P]unknot/build_O0/_deps/json-src/include/nlohmann/detail/conversions/to_chars.hpp | inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
diyfp M_minus, diyfp w, diyfp M_plus)
{
static_assert(kAlpha >= -60, "internal error");
static_assert(kGamma <= -32, "internal error");
// Generates the digits (and the exponent) of a decimal floating-point
// number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
// w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
//
// <--------------------------- delta ---->
// <---- dist --------->
// --------------[------------------+-------------------]--------------
// M- w M+
//
// Grisu2 generates the digits of M+ from left to right and stops as soon as
// V is in [M-,M+].
JSON_ASSERT(M_plus.e >= kAlpha);
JSON_ASSERT(M_plus.e <= kGamma);
std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
// Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
//
// M+ = f * 2^e
// = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
// = ((p1 ) * 2^-e + (p2 )) * 2^e
// = p1 + p2 * 2^e
const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
// 1)
//
// Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
JSON_ASSERT(p1 > 0);
std::uint32_t pow10{};
const int k = find_largest_pow10(p1, pow10);
// 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
//
// p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
// = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1))
//
// M+ = p1 + p2 * 2^e
// = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e
// = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
// = d[k-1] * 10^(k-1) + ( rest) * 2^e
//
// Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
//
// p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
//
// but stop as soon as
//
// rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
int n = k;
while (n > 0)
{
// Invariants:
// M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
// pow10 = 10^(n-1) <= p1 < 10^n
//
const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
//
// M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
// = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
//
JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
//
p1 = r;
n--;
//
// M+ = buffer * 10^n + (p1 + p2 * 2^e)
// pow10 = 10^n
//
// Now check if enough digits have been generated.
// Compute
//
// p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
//
// Note:
// Since rest and delta share the same exponent e, it suffices to
// compare the significands.
const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
if (rest <= delta)
{
// V = buffer * 10^n, with M- <= V <= M+.
decimal_exponent += n;
// We may now just stop. But instead look if the buffer could be
// decremented to bring V closer to w.
//
// pow10 = 10^n is now 1 ulp in the decimal representation V.
// The rounding procedure works with diyfp's with an implicit
// exponent of e.
//
// 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
//
const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
grisu2_round(buffer, length, dist, delta, rest, ten_n);
return;
}
pow10 /= 10;
//
// pow10 = 10^(n-1) <= p1 < 10^n
// Invariants restored.
}
// 2)
//
// The digits of the integral part have been generated:
//
// M+ = d[k-1]...d[1]d[0] + p2 * 2^e
// = buffer + p2 * 2^e
//
// Now generate the digits of the fractional part p2 * 2^e.
//
// Note:
// No decimal point is generated: the exponent is adjusted instead.
//
// p2 actually represents the fraction
//
// p2 * 2^e
// = p2 / 2^-e
// = d[-1] / 10^1 + d[-2] / 10^2 + ...
//
// Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
//
// p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
// + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
//
// using
//
// 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
// = ( d) * 2^-e + ( r)
//
// or
// 10^m * p2 * 2^e = d + r * 2^e
//
// i.e.
//
// M+ = buffer + p2 * 2^e
// = buffer + 10^-m * (d + r * 2^e)
// = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
//
// and stop as soon as 10^-m * r * 2^e <= delta * 2^e
JSON_ASSERT(p2 > delta);
int m = 0;
for (;;)
{
// Invariant:
// M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
// = buffer * 10^-m + 10^-m * (p2 ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
//
JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
p2 *= 10;
const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
//
// M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
// = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
p2 = r;
m++;
//
// M+ = buffer * 10^-m + 10^-m * p2 * 2^e
// Invariant restored.
// Check if enough digits have been generated.
//
// 10^-m * p2 * 2^e <= delta * 2^e
// p2 * 2^e <= 10^m * delta * 2^e
// p2 <= 10^m * delta
delta *= 10;
dist *= 10;
if (p2 <= delta)
{
break;
}
}
// V = buffer * 10^-m, with M- <= V <= M+.
decimal_exponent -= m;
// 1 ulp in the decimal representation is now 10^-m.
// Since delta and dist are now scaled by 10^m, we need to do the
// same with ulp in order to keep the units in sync.
//
// 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
//
const std::uint64_t ten_m = one.f;
grisu2_round(buffer, length, dist, delta, p2, ten_m);
// By construction this algorithm generates the shortest possible decimal
// number (Loitsch, Theorem 6.2) which rounds back to w.
// For an input number of precision p, at least
//
// N = 1 + ceil(p * log_10(2))
//
// decimal digits are sufficient to identify all binary floating-point
// numbers (Matula, "In-and-Out conversions").
// This implies that the algorithm does not produce more than N decimal
// digits.
//
// N = 17 for p = 53 (IEEE double precision)
// N = 9 for p = 24 (IEEE single precision)
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp):
subq $0xf8, %rsp
movq %rdi, %rax
leaq 0x110(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x100(%rsp), %r9
movq %r9, 0x8(%rsp)
movq %rcx, 0xe8(%rsp)
movl %r8d, 0xf0(%rsp)
movq %rax, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
leaq 0xe8(%rsp), %rsi
callq 0x6d120
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl %edx, 0xb0(%rsp)
movq %rax, 0xa8(%rsp)
movl 0xb0(%rsp), %eax
movl %eax, 0xc0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0xc8(%rsp)
callq 0x6d120
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl %edx, 0x88(%rsp)
movq %rcx, 0x80(%rsp)
movq 0x80(%rsp), %rcx
movq %rcx, 0x90(%rsp)
movl 0x88(%rsp), %ecx
movl %ecx, 0x98(%rsp)
movq 0x90(%rsp), %rcx
movq %rcx, 0xa0(%rsp)
xorl %ecx, %ecx
subl 0x8(%rax), %ecx
movl %ecx, %ecx
movl $0x1, %esi
shlq %cl, %rsi
movl 0x8(%rax), %edx
leaq 0x70(%rsp), %rdi
callq 0x6caa0
movq 0x10(%rsp), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
subl 0x78(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movl %ecx, 0x6c(%rsp)
movq (%rax), %rax
movq 0x70(%rsp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movl 0x6c(%rsp), %edi
leaq 0x5c(%rsp), %rsi
callq 0x6d160
movl %eax, 0x58(%rsp)
movl 0x58(%rsp), %eax
movl %eax, 0x54(%rsp)
cmpl $0x0, 0x54(%rsp)
jle 0x6cfc0
movl 0x6c(%rsp), %eax
xorl %edx, %edx
divl 0x5c(%rsp)
movl %eax, 0x50(%rsp)
movl 0x6c(%rsp), %eax
xorl %edx, %edx
divl 0x5c(%rsp)
movl %edx, 0x4c(%rsp)
movl 0x50(%rsp), %eax
addl $0x30, %eax
movb %al, %dl
movq 0xe0(%rsp), %rax
movq 0xd8(%rsp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x4c(%rsp), %eax
movl %eax, 0x6c(%rsp)
movl 0x54(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x54(%rsp)
movl 0x6c(%rsp), %eax
xorl %ecx, %ecx
subl 0x78(%rsp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
addq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0xc8(%rsp), %rax
ja 0x6cfaa
movl 0x54(%rsp), %ecx
movq 0xd0(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl 0x5c(%rsp), %eax
xorl %ecx, %ecx
subl 0x78(%rsp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, 0x38(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xd8(%rsp), %rax
movl (%rax), %esi
movq 0xa0(%rsp), %rdx
movq 0xc8(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x38(%rsp), %r9
callq 0x6d2b0
jmp 0x6d0c2
movl 0x5c(%rsp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, 0x5c(%rsp)
jmp 0x6cec6
movl $0x0, 0x34(%rsp)
imulq $0xa, 0x60(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
xorl %ecx, %ecx
subl 0x78(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq 0x70(%rsp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq $0x30, %rax
movb %al, %dl
movq 0xe0(%rsp), %rax
movq 0xd8(%rsp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
imulq $0xa, 0xc8(%rsp), %rax
movq %rax, 0xc8(%rsp)
imulq $0xa, 0xa0(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x60(%rsp), %rax
cmpq 0xc8(%rsp), %rax
ja 0x6d070
jmp 0x6d075
jmp 0x6cfc8
movl 0x34(%rsp), %edx
movq 0xd0(%rsp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xd8(%rsp), %rax
movl (%rax), %esi
movq 0xa0(%rsp), %rdx
movq 0xc8(%rsp), %rcx
movq 0x60(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x6d2b0
addq $0xf8, %rsp
retq
nopw (%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl16grisu2_digit_genEPcRiS4_NS2_5diyfpES5_S5_:
sub rsp, 0F8h
mov rax, rdi
lea rdi, [rsp+0F8h+arg_10]; this
mov [rsp+0F8h+var_E8], rdi
lea r9, [rsp+0F8h+arg_0]
mov [rsp+0F8h+var_F0], r9
mov [rsp+0F8h+var_10], rcx
mov [rsp+0F8h+var_8], r8d
mov [rsp+0F8h+var_18], rax
mov [rsp+0F8h+var_20], rsi
mov [rsp+0F8h+var_28], rdx
lea rsi, [rsp+0F8h+var_10]; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3subERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov rsi, [rsp+0F8h+var_F0]; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *
mov rdi, [rsp+0F8h+var_E8]; this
mov [rsp+0F8h+var_48], edx
mov [rsp+0F8h+var_50], rax
mov eax, [rsp+0F8h+var_48]
mov [rsp+0F8h+var_38], eax
mov rax, [rsp+0F8h+var_50]
mov [rsp+0F8h+var_40], rax
mov rax, [rsp+0F8h+var_40]
mov [rsp+0F8h+var_30], rax
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3subERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov rcx, rax
mov rax, [rsp+0F8h+var_E8]
mov [rsp+0F8h+var_70], edx
mov [rsp+0F8h+var_78], rcx
mov rcx, [rsp+0F8h+var_78]
mov [rsp+0F8h+var_68], rcx
mov ecx, [rsp+0F8h+var_70]
mov [rsp+0F8h+var_60], ecx
mov rcx, [rsp+0F8h+var_68]
mov qword ptr [rsp+0F8h+var_58], rcx
xor ecx, ecx
sub ecx, [rax+8]
mov ecx, ecx
mov esi, 1
shl rsi, cl; unsigned __int64
mov edx, [rax+8]; int
lea rdi, [rsp+0F8h+var_8C+4]; this
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfpC2Emi; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::diyfp(ulong,int)
mov rax, [rsp+0F8h+var_E8]
mov rdx, [rax]
xor ecx, ecx
sub ecx, [rsp+0F8h+var_80]
mov ecx, ecx
shr rdx, cl; unsigned int *
mov rcx, rdx
mov dword ptr [rsp+0F8h+var_8C], ecx
mov rax, [rax]
mov rcx, [rsp+0F8h+var_8C+4]
sub rcx, 1
and rax, rcx
mov [rsp+0F8h+var_98], rax
mov [rsp+0F8h+var_9C], 0
mov edi, dword ptr [rsp+0F8h+var_8C]; this
lea rsi, [rsp+0F8h+var_9C]; unsigned int
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl18find_largest_pow10EjRj; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(uint,uint &)
mov [rsp+0F8h+var_A0], eax
mov eax, [rsp+0F8h+var_A0]
mov [rsp+0F8h+var_A4], eax
loc_6CEC6:
cmp [rsp+0F8h+var_A4], 0
jle loc_6CFC0
mov eax, dword ptr [rsp+0F8h+var_8C]
xor edx, edx
div [rsp+0F8h+var_9C]
mov [rsp+0F8h+var_A8], eax
mov eax, dword ptr [rsp+0F8h+var_8C]
xor edx, edx
div [rsp+0F8h+var_9C]
mov [rsp+0F8h+var_AC], edx
mov eax, [rsp+0F8h+var_A8]
add eax, 30h ; '0'
mov dl, al
mov rax, [rsp+0F8h+var_18]
mov rsi, [rsp+0F8h+var_20]
mov ecx, [rsi]
mov edi, ecx
add edi, 1
mov [rsi], edi
movsxd rcx, ecx
mov [rax+rcx], dl
mov eax, [rsp+0F8h+var_AC]
mov dword ptr [rsp+0F8h+var_8C], eax
mov eax, [rsp+0F8h+var_A4]
add eax, 0FFFFFFFFh
mov [rsp+0F8h+var_A4], eax
mov eax, dword ptr [rsp+0F8h+var_8C]
xor ecx, ecx
sub ecx, [rsp+0F8h+var_80]
mov ecx, ecx
shl rax, cl
add rax, [rsp+0F8h+var_98]
mov [rsp+0F8h+var_B8], rax
mov rax, [rsp+0F8h+var_B8]
cmp rax, [rsp+0F8h+var_30]
ja short loc_6CFAA
mov ecx, [rsp+0F8h+var_A4]
mov rax, [rsp+0F8h+var_28]
add ecx, [rax]
mov [rax], ecx
mov eax, [rsp+0F8h+var_9C]
xor ecx, ecx
sub ecx, [rsp+0F8h+var_80]
mov ecx, ecx
shl rax, cl
mov [rsp+0F8h+var_C0], rax
mov rdi, [rsp+0F8h+var_18]; this
mov rax, [rsp+0F8h+var_20]
mov esi, [rax]; char *
mov rdx, qword ptr [rsp+0F8h+var_58]; int
mov rcx, [rsp+0F8h+var_30]; unsigned __int64
mov r8, [rsp+0F8h+var_B8]; unsigned __int64
mov r9, [rsp+0F8h+var_C0]; unsigned __int64
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl12grisu2_roundEPcimmmm; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(char *,int,ulong,ulong,ulong,ulong)
jmp loc_6D0C2
loc_6CFAA:
mov eax, [rsp+0F8h+var_9C]
mov ecx, 0Ah
xor edx, edx
div ecx
mov [rsp+0F8h+var_9C], eax
jmp loc_6CEC6
loc_6CFC0:
mov [rsp+0F8h+var_C4], 0
loc_6CFC8:
imul rax, [rsp+0F8h+var_98], 0Ah
mov [rsp+0F8h+var_98], rax
mov rax, [rsp+0F8h+var_98]
xor ecx, ecx
sub ecx, [rsp+0F8h+var_80]
mov ecx, ecx
shr rax, cl
mov [rsp+0F8h+var_D0], rax
mov rax, [rsp+0F8h+var_98]
mov rcx, [rsp+0F8h+var_8C+4]
sub rcx, 1
and rax, rcx
mov [rsp+0F8h+var_D8], rax
mov rax, [rsp+0F8h+var_D0]
add rax, 30h ; '0'
mov dl, al
mov rax, [rsp+0F8h+var_18]
mov rsi, [rsp+0F8h+var_20]
mov ecx, [rsi]
mov edi, ecx
add edi, 1
mov [rsi], edi
movsxd rcx, ecx
mov [rax+rcx], dl
mov rax, [rsp+0F8h+var_D8]
mov [rsp+0F8h+var_98], rax
mov eax, [rsp+0F8h+var_C4]
add eax, 1
mov [rsp+0F8h+var_C4], eax
imul rax, [rsp+0F8h+var_30], 0Ah
mov [rsp+0F8h+var_30], rax
imul rax, qword ptr [rsp+0F8h+var_58], 0Ah
mov qword ptr [rsp+0F8h+var_58], rax
mov rax, [rsp+0F8h+var_98]
cmp rax, [rsp+0F8h+var_30]
ja short loc_6D070
jmp short loc_6D075
loc_6D070:
jmp loc_6CFC8
loc_6D075:
mov edx, [rsp+0F8h+var_C4]
mov rax, [rsp+0F8h+var_28]
mov ecx, [rax]
sub ecx, edx
mov [rax], ecx
mov rax, [rsp+0F8h+var_8C+4]
mov [rsp+0F8h+var_E0], rax
mov rdi, [rsp+0F8h+var_18]; this
mov rax, [rsp+0F8h+var_20]
mov esi, [rax]; char *
mov rdx, qword ptr [rsp+0F8h+var_58]; int
mov rcx, [rsp+0F8h+var_30]; unsigned __int64
mov r8, [rsp+0F8h+var_98]; unsigned __int64
mov r9, [rsp+0F8h+var_E0]; unsigned __int64
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl12grisu2_roundEPcimmmm; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(char *,int,ulong,ulong,ulong,ulong)
loc_6D0C2:
add rsp, 0F8h
retn
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *a1,
_DWORD *a2,
const nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *a3,
long long a4,
int a5,
long long a6,
char a7,
long long a8,
unsigned long long a9,
int a10)
{
unsigned long long v10; // rax
const nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *v11; // rdx
long long v12; // rax
int v13; // edx
char v14; // dl
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *v15; // rax
int v16; // ecx
char v18; // dl
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *v19; // rax
int v20; // ecx
unsigned long long v21; // [rsp+0h] [rbp-F8h]
unsigned long long v22; // [rsp+20h] [rbp-D8h]
int v23; // [rsp+34h] [rbp-C4h]
unsigned long long v24; // [rsp+40h] [rbp-B8h]
unsigned int v25; // [rsp+4Ch] [rbp-ACh]
int largest_pow10; // [rsp+54h] [rbp-A4h]
unsigned int v27; // [rsp+5Ch] [rbp-9Ch] BYREF
unsigned long long v28; // [rsp+60h] [rbp-98h]
_DWORD v29[3]; // [rsp+6Ch] [rbp-8Ch] BYREF
int v30; // [rsp+78h] [rbp-80h]
long long v31; // [rsp+80h] [rbp-78h]
int v32; // [rsp+88h] [rbp-70h]
long long v33; // [rsp+90h] [rbp-68h]
int v34; // [rsp+98h] [rbp-60h]
int v35[2]; // [rsp+A0h] [rbp-58h]
unsigned long long v36; // [rsp+A8h] [rbp-50h]
int v37; // [rsp+B0h] [rbp-48h]
unsigned long long v38; // [rsp+B8h] [rbp-40h]
int v39; // [rsp+C0h] [rbp-38h]
unsigned long long v40; // [rsp+C8h] [rbp-30h]
const nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *v41; // [rsp+D0h] [rbp-28h]
_DWORD *v42; // [rsp+D8h] [rbp-20h]
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *v43; // [rsp+E0h] [rbp-18h]
long long v44; // [rsp+E8h] [rbp-10h] BYREF
int v45; // [rsp+F0h] [rbp-8h]
v44 = a4;
v45 = a5;
v43 = a1;
v42 = a2;
v41 = a3;
v10 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *)&a9,
(const nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *)&v44,
a3);
v37 = (int)v11;
v36 = v10;
v39 = (int)v11;
v38 = v10;
v40 = v10;
v12 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *)&a9,
(const nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *)&a7,
v11);
v32 = v13;
v31 = v12;
v33 = v12;
v34 = v13;
*(_QWORD *)v35 = v12;
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::diyfp(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *)&v29[1],
1LL << -(char)a10,
a10);
v29[0] = a9 >> -(char)v30;
v28 = (*(_QWORD *)&v29[1] - 1LL) & a9;
v27 = 0;
largest_pow10 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)v29[0],
(unsigned int)&v27,
(unsigned int *)(a9 >> -(char)v30));
while ( largest_pow10 > 0 )
{
v25 = v29[0] % v27;
v14 = v29[0] / v27 + 48;
v15 = v43;
v16 = (*v42)++;
*((_BYTE *)v15 + v16) = v14;
v29[0] = v25;
--largest_pow10;
v24 = v28 + ((unsigned long long)v25 << -(char)v30);
if ( v24 <= v40 )
{
*(_DWORD *)v41 += largest_pow10;
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(
v43,
(char *)(unsigned int)*v42,
v35[0],
v40,
v24,
(unsigned long long)v27 << -(char)v30,
v21);
}
v27 /= 0xAu;
}
v23 = 0;
do
{
v28 *= 10LL;
v22 = (*(_QWORD *)&v29[1] - 1LL) & v28;
v18 = (v28 >> -(char)v30) + 48;
v19 = v43;
v20 = (*v42)++;
*((_BYTE *)v19 + v20) = v18;
v28 = v22;
++v23;
v40 *= 10LL;
*(_QWORD *)v35 *= 10LL;
}
while ( v22 > v40 );
*(_DWORD *)v41 -= v23;
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(
v43,
(char *)(unsigned int)*v42,
v35[0],
v40,
v28,
*(unsigned long long *)&v29[1],
v21);
}
| grisu2_digit_gen:
SUB RSP,0xf8
MOV RAX,RDI
LEA RDI,[RSP + 0x110]
MOV qword ptr [RSP + 0x10],RDI
LEA R9,[RSP + 0x100]
MOV qword ptr [RSP + 0x8],R9
MOV qword ptr [RSP + 0xe8],RCX
MOV dword ptr [RSP + 0xf0],R8D
MOV qword ptr [RSP + 0xe0],RAX
MOV qword ptr [RSP + 0xd8],RSI
MOV qword ptr [RSP + 0xd0],RDX
LEA RSI,[RSP + 0xe8]
CALL 0x0016d120
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0xb0],EDX
MOV qword ptr [RSP + 0xa8],RAX
MOV EAX,dword ptr [RSP + 0xb0]
MOV dword ptr [RSP + 0xc0],EAX
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0xc8],RAX
CALL 0x0016d120
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x88],EDX
MOV qword ptr [RSP + 0x80],RCX
MOV RCX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x90],RCX
MOV ECX,dword ptr [RSP + 0x88]
MOV dword ptr [RSP + 0x98],ECX
MOV RCX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0xa0],RCX
XOR ECX,ECX
SUB ECX,dword ptr [RAX + 0x8]
MOV ECX,ECX
MOV ESI,0x1
SHL RSI,CL
MOV EDX,dword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x70]
CALL 0x0016caa0
MOV RAX,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RAX]
XOR ECX,ECX
SUB ECX,dword ptr [RSP + 0x78]
MOV ECX,ECX
SHR RDX,CL
MOV RCX,RDX
MOV dword ptr [RSP + 0x6c],ECX
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RSP + 0x70]
SUB RCX,0x1
AND RAX,RCX
MOV qword ptr [RSP + 0x60],RAX
MOV dword ptr [RSP + 0x5c],0x0
MOV EDI,dword ptr [RSP + 0x6c]
LEA RSI,[RSP + 0x5c]
CALL 0x0016d160
MOV dword ptr [RSP + 0x58],EAX
MOV EAX,dword ptr [RSP + 0x58]
MOV dword ptr [RSP + 0x54],EAX
LAB_0016cec6:
CMP dword ptr [RSP + 0x54],0x0
JLE 0x0016cfc0
MOV EAX,dword ptr [RSP + 0x6c]
XOR EDX,EDX
DIV dword ptr [RSP + 0x5c]
MOV dword ptr [RSP + 0x50],EAX
MOV EAX,dword ptr [RSP + 0x6c]
XOR EDX,EDX
DIV dword ptr [RSP + 0x5c]
MOV dword ptr [RSP + 0x4c],EDX
MOV EAX,dword ptr [RSP + 0x50]
ADD EAX,0x30
MOV DL,AL
MOV RAX,qword ptr [RSP + 0xe0]
MOV RSI,qword ptr [RSP + 0xd8]
MOV ECX,dword ptr [RSI]
MOV EDI,ECX
ADD EDI,0x1
MOV dword ptr [RSI],EDI
MOVSXD RCX,ECX
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RSP + 0x4c]
MOV dword ptr [RSP + 0x6c],EAX
MOV EAX,dword ptr [RSP + 0x54]
ADD EAX,-0x1
MOV dword ptr [RSP + 0x54],EAX
MOV EAX,dword ptr [RSP + 0x6c]
XOR ECX,ECX
SUB ECX,dword ptr [RSP + 0x78]
MOV ECX,ECX
SHL RAX,CL
ADD RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x40]
CMP RAX,qword ptr [RSP + 0xc8]
JA 0x0016cfaa
MOV ECX,dword ptr [RSP + 0x54]
MOV RAX,qword ptr [RSP + 0xd0]
ADD ECX,dword ptr [RAX]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RSP + 0x5c]
XOR ECX,ECX
SUB ECX,dword ptr [RSP + 0x78]
MOV ECX,ECX
SHL RAX,CL
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0xe0]
MOV RAX,qword ptr [RSP + 0xd8]
MOV ESI,dword ptr [RAX]
MOV RDX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0xc8]
MOV R8,qword ptr [RSP + 0x40]
MOV R9,qword ptr [RSP + 0x38]
CALL 0x0016d2b0
JMP 0x0016d0c2
LAB_0016cfaa:
MOV EAX,dword ptr [RSP + 0x5c]
MOV ECX,0xa
XOR EDX,EDX
DIV ECX
MOV dword ptr [RSP + 0x5c],EAX
JMP 0x0016cec6
LAB_0016cfc0:
MOV dword ptr [RSP + 0x34],0x0
LAB_0016cfc8:
IMUL RAX,qword ptr [RSP + 0x60],0xa
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x60]
XOR ECX,ECX
SUB ECX,dword ptr [RSP + 0x78]
MOV ECX,ECX
SHR RAX,CL
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RSP + 0x70]
SUB RCX,0x1
AND RAX,RCX
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,0x30
MOV DL,AL
MOV RAX,qword ptr [RSP + 0xe0]
MOV RSI,qword ptr [RSP + 0xd8]
MOV ECX,dword ptr [RSI]
MOV EDI,ECX
ADD EDI,0x1
MOV dword ptr [RSI],EDI
MOVSXD RCX,ECX
MOV byte ptr [RAX + RCX*0x1],DL
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x60],RAX
MOV EAX,dword ptr [RSP + 0x34]
ADD EAX,0x1
MOV dword ptr [RSP + 0x34],EAX
IMUL RAX,qword ptr [RSP + 0xc8],0xa
MOV qword ptr [RSP + 0xc8],RAX
IMUL RAX,qword ptr [RSP + 0xa0],0xa
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0x60]
CMP RAX,qword ptr [RSP + 0xc8]
JA 0x0016d070
JMP 0x0016d075
LAB_0016d070:
JMP 0x0016cfc8
LAB_0016d075:
MOV EDX,dword ptr [RSP + 0x34]
MOV RAX,qword ptr [RSP + 0xd0]
MOV ECX,dword ptr [RAX]
SUB ECX,EDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0xe0]
MOV RAX,qword ptr [RSP + 0xd8]
MOV ESI,dword ptr [RAX]
MOV RDX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0xc8]
MOV R8,qword ptr [RSP + 0x60]
MOV R9,qword ptr [RSP + 0x18]
CALL 0x0016d2b0
LAB_0016d0c2:
ADD RSP,0xf8
RET
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen
(char *param_1,int *param_2,int *param_3,int8 param_4,int4 param_5)
{
int iVar1;
uint uVar2;
ulong uVar3;
ulong in_stack_00000018;
int in_stack_00000020;
int local_c4;
int local_a4;
uint local_9c;
ulong local_98;
uint local_8c;
ulong local_88;
char local_80;
int1 local_78 [12];
int1 local_68 [12];
ulong local_58;
int1 local_50 [12];
int1 local_40 [12];
ulong local_30;
int *local_28;
int *local_20;
char *local_18;
int8 local_10;
int4 local_8;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_10 = param_4;
local_8 = param_5;
local_50 = diyfp::sub((diyfp *)&stack0x00000018,(diyfp *)&local_10);
local_30 = local_50._0_8_;
local_40 = local_50;
local_78 = diyfp::sub((diyfp *)&stack0x00000018,&stack0x00000008);
local_58 = local_78._0_8_;
local_68 = local_78;
diyfp::diyfp((diyfp *)&local_88,1L << (-(char)in_stack_00000020 & 0x3fU),in_stack_00000020);
local_8c = (uint)(in_stack_00000018 >> (-local_80 & 0x3fU));
local_98 = in_stack_00000018 & local_88 - 1;
local_9c = 0;
local_a4 = find_largest_pow10(local_8c,&local_9c);
while( true ) {
if (local_a4 < 1) {
local_c4 = 0;
do {
uVar3 = local_98 * 10;
local_98 = uVar3 & local_88 - 1;
iVar1 = *local_20;
*local_20 = iVar1 + 1;
local_18[iVar1] = (char)(uVar3 >> (-local_80 & 0x3fU)) + '0';
local_c4 = local_c4 + 1;
local_30 = local_30 * 10;
local_58 = local_58 * 10;
} while (local_30 < local_98);
*local_28 = *local_28 - local_c4;
grisu2_round(local_18,*local_20,local_58,local_30,local_98,local_88);
return;
}
uVar2 = local_8c / local_9c;
local_8c = local_8c % local_9c;
iVar1 = *local_20;
*local_20 = iVar1 + 1;
local_18[iVar1] = (char)uVar2 + '0';
local_a4 = local_a4 + -1;
uVar3 = ((ulong)local_8c << (-local_80 & 0x3fU)) + local_98;
if (uVar3 <= local_30) break;
local_9c = local_9c / 10;
}
*local_28 = local_a4 + *local_28;
grisu2_round(local_18,*local_20,local_58,local_30,uVar3,(ulong)local_9c << (-local_80 & 0x3fU));
return;
}
| |
54,792 | alaya::LinearPool<float, unsigned int>::insert(unsigned int, float) | AlayaLite/include/executor/jobs/../../utils/query_utils.hpp | auto insert(IDType u, DistanceType dist) -> bool {
if (size_ == capacity_ && dist >= data_[size_ - 1].distance_) {
return false;
}
int lo = find_bsearch(dist);
std::memmove(&data_[lo + 1], &data_[lo], (size_ - lo) * sizeof(Neighbor<DistanceType>));
data_[lo] = {u, dist};
if (size_ < capacity_) {
size_++;
}
if (lo < cur_) {
cur_ = lo;
}
for (int i = 0; i < size_; i++) {
// LOG_INFO("i {} ,dist is {}", data_[i].id_, data_[i].distance_);
}
// LOG_INFO("cur is {} , size {}", cur_, size_);
return true;
} | O0 | cpp | alaya::LinearPool<float, unsigned int>::insert(unsigned int, float):
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movss %xmm0, 0x30(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rcx), %rax
cmpq 0x18(%rcx), %rax
jne 0x4f252
movq 0x10(%rsp), %rax
movss 0x30(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movq %rax, %rdi
addq $0x20, %rdi
movq 0x8(%rax), %rsi
subq $0x1, %rsi
callq 0x515e0
movss 0xc(%rsp), %xmm0
ucomiss 0x4(%rax), %xmm0
jb 0x4f252
movb $0x0, 0x47(%rsp)
jmp 0x4f358
movq 0x10(%rsp), %rdi
movss 0x30(%rsp), %xmm0
callq 0x51760
movq 0x10(%rsp), %rdi
movl %eax, 0x2c(%rsp)
addq $0x20, %rdi
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x515e0
movq 0x10(%rsp), %rdi
movq %rax, (%rsp)
addq $0x20, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x515e0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x2c(%rsp), %rcx
subq %rcx, %rax
imulq $0xc, %rax, %rdx
callq 0x15cd0
movl 0x34(%rsp), %esi
movss 0x30(%rsp), %xmm0
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
callq 0x517f0
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x515e0
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rdx
movq %rdx, (%rax)
movb 0x28(%rsp), %dl
movb %dl, 0x8(%rax)
movq 0x8(%rcx), %rax
cmpq 0x18(%rcx), %rax
jae 0x4f30e
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movslq 0x2c(%rsp), %rax
cmpq 0x10(%rcx), %rax
jae 0x4f32c
movq 0x10(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movslq 0x1c(%rsp), %rax
cmpq 0x8(%rcx), %rax
jae 0x4f353
jmp 0x4f346
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4f334
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN5alaya10LinearPoolIfjE6insertEjf:
sub rsp, 48h
mov [rsp+48h+var_10], rdi
mov [rsp+48h+var_14], esi
movss [rsp+48h+var_18], xmm0
mov rcx, [rsp+48h+var_10]
mov [rsp+48h+var_38], rcx
mov rax, [rcx+8]
cmp rax, [rcx+18h]
jnz short loc_4F252
mov rax, [rsp+48h+var_38]
movss xmm0, [rsp+48h+var_18]
movss [rsp+48h+var_3C], xmm0
mov rdi, rax
add rdi, 20h ; ' '
mov rsi, [rax+8]
sub rsi, 1
call _ZNSt6vectorIN5alaya8NeighborIjfEENS0_10AlignAllocIS2_EEEixEm; std::vector<alaya::Neighbor<uint,float>,alaya::AlignAlloc<alaya::Neighbor<uint,float>>>::operator[](ulong)
movss xmm0, [rsp+48h+var_3C]
ucomiss xmm0, dword ptr [rax+4]
jb short loc_4F252
mov [rsp+48h+var_1], 0
jmp loc_4F358
loc_4F252:
mov rdi, [rsp+48h+var_38]
movss xmm0, [rsp+48h+var_18]
call _ZN5alaya10LinearPoolIfjE12find_bsearchEf; alaya::LinearPool<float,uint>::find_bsearch(float)
mov rdi, [rsp+48h+var_38]
mov [rsp+48h+var_1C], eax
add rdi, 20h ; ' '
mov eax, [rsp+48h+var_1C]
add eax, 1
movsxd rsi, eax
call _ZNSt6vectorIN5alaya8NeighborIjfEENS0_10AlignAllocIS2_EEEixEm; std::vector<alaya::Neighbor<uint,float>,alaya::AlignAlloc<alaya::Neighbor<uint,float>>>::operator[](ulong)
mov rdi, [rsp+48h+var_38]
mov [rsp+48h+var_48], rax
add rdi, 20h ; ' '
movsxd rsi, [rsp+48h+var_1C]
call _ZNSt6vectorIN5alaya8NeighborIjfEENS0_10AlignAllocIS2_EEEixEm; std::vector<alaya::Neighbor<uint,float>,alaya::AlignAlloc<alaya::Neighbor<uint,float>>>::operator[](ulong)
mov rdi, [rsp+48h+var_48]
mov rsi, rax
mov rax, [rsp+48h+var_38]
mov rax, [rax+8]
movsxd rcx, [rsp+48h+var_1C]
sub rax, rcx
imul rdx, rax, 0Ch
call _memmove
mov esi, [rsp+48h+var_14]
movss xmm0, [rsp+48h+var_18]
lea rdi, [rsp+48h+var_28]
xor edx, edx
call _ZN5alaya8NeighborIjfEC2Ejfb; alaya::Neighbor<uint,float>::Neighbor(uint,float,bool)
mov rdi, [rsp+48h+var_38]
add rdi, 20h ; ' '
movsxd rsi, [rsp+48h+var_1C]
call _ZNSt6vectorIN5alaya8NeighborIjfEENS0_10AlignAllocIS2_EEEixEm; std::vector<alaya::Neighbor<uint,float>,alaya::AlignAlloc<alaya::Neighbor<uint,float>>>::operator[](ulong)
mov rcx, [rsp+48h+var_38]
mov rdx, [rsp+48h+var_28]
mov [rax], rdx
mov dl, [rsp+48h+var_20]
mov [rax+8], dl
mov rax, [rcx+8]
cmp rax, [rcx+18h]
jnb short loc_4F30E
mov rax, [rsp+48h+var_38]
mov rcx, [rax+8]
add rcx, 1
mov [rax+8], rcx
loc_4F30E:
mov rcx, [rsp+48h+var_38]
movsxd rax, [rsp+48h+var_1C]
cmp rax, [rcx+10h]
jnb short loc_4F32C
mov rax, [rsp+48h+var_38]
movsxd rcx, [rsp+48h+var_1C]
mov [rax+10h], rcx
loc_4F32C:
mov [rsp+48h+var_2C], 0
loc_4F334:
mov rcx, [rsp+48h+var_38]
movsxd rax, [rsp+48h+var_2C]
cmp rax, [rcx+8]
jnb short loc_4F353
jmp short $+2
loc_4F346:
mov eax, [rsp+48h+var_2C]
add eax, 1
mov [rsp+48h+var_2C], eax
jmp short loc_4F334
loc_4F353:
mov [rsp+48h+var_1], 1
loc_4F358:
mov al, [rsp+48h+var_1]
and al, 1
add rsp, 48h
retn
| char alaya::LinearPool<float,unsigned int>::insert(_QWORD *a1, unsigned int a2, float a3)
{
long long v3; // rax
long long v4; // rax
long long v6; // [rsp+0h] [rbp-48h]
int i; // [rsp+1Ch] [rbp-2Ch]
long long v8; // [rsp+20h] [rbp-28h] BYREF
char v9; // [rsp+28h] [rbp-20h]
int bsearch; // [rsp+2Ch] [rbp-1Ch]
float v11; // [rsp+30h] [rbp-18h]
unsigned int v12; // [rsp+34h] [rbp-14h]
_QWORD *v13; // [rsp+38h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
if ( a1[1] == a1[3]
&& v11 >= *(float *)(std::vector<alaya::Neighbor<unsigned int,float>,alaya::AlignAlloc<alaya::Neighbor<unsigned int,float>>>::operator[](
a1 + 4,
a1[1] - 1LL)
+ 4) )
{
return 0;
}
bsearch = alaya::LinearPool<float,unsigned int>::find_bsearch(a1, v11);
v6 = std::vector<alaya::Neighbor<unsigned int,float>,alaya::AlignAlloc<alaya::Neighbor<unsigned int,float>>>::operator[](
a1 + 4,
bsearch + 1);
v3 = std::vector<alaya::Neighbor<unsigned int,float>,alaya::AlignAlloc<alaya::Neighbor<unsigned int,float>>>::operator[](
a1 + 4,
bsearch);
memmove(v6, v3, 12 * (a1[1] - bsearch));
alaya::Neighbor<unsigned int,float>::Neighbor(&v8, v12, 0LL, v11);
v4 = std::vector<alaya::Neighbor<unsigned int,float>,alaya::AlignAlloc<alaya::Neighbor<unsigned int,float>>>::operator[](
a1 + 4,
bsearch);
*(_QWORD *)v4 = v8;
*(_BYTE *)(v4 + 8) = v9;
if ( a1[1] < a1[3] )
++a1[1];
if ( (unsigned long long)bsearch < a1[2] )
a1[2] = bsearch;
for ( i = 0; (unsigned long long)i < a1[1]; ++i )
;
return 1;
}
| insert:
SUB RSP,0x48
MOV qword ptr [RSP + 0x38],RDI
MOV dword ptr [RSP + 0x34],ESI
MOVSS dword ptr [RSP + 0x30],XMM0
MOV RCX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x10],RCX
MOV RAX,qword ptr [RCX + 0x8]
CMP RAX,qword ptr [RCX + 0x18]
JNZ 0x0014f252
MOV RAX,qword ptr [RSP + 0x10]
MOVSS XMM0,dword ptr [RSP + 0x30]
MOVSS dword ptr [RSP + 0xc],XMM0
MOV RDI,RAX
ADD RDI,0x20
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,0x1
CALL 0x001515e0
MOVSS XMM0,dword ptr [RSP + 0xc]
UCOMISS XMM0,dword ptr [RAX + 0x4]
JC 0x0014f252
MOV byte ptr [RSP + 0x47],0x0
JMP 0x0014f358
LAB_0014f252:
MOV RDI,qword ptr [RSP + 0x10]
MOVSS XMM0,dword ptr [RSP + 0x30]
CALL 0x00151760
MOV RDI,qword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x2c],EAX
ADD RDI,0x20
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,0x1
MOVSXD RSI,EAX
CALL 0x001515e0
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RAX
ADD RDI,0x20
MOVSXD RSI,dword ptr [RSP + 0x2c]
CALL 0x001515e0
MOV RDI,qword ptr [RSP]
MOV RSI,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOVSXD RCX,dword ptr [RSP + 0x2c]
SUB RAX,RCX
IMUL RDX,RAX,0xc
CALL 0x00115cd0
MOV ESI,dword ptr [RSP + 0x34]
MOVSS XMM0,dword ptr [RSP + 0x30]
LEA RDI,[RSP + 0x20]
XOR EDX,EDX
CALL 0x001517f0
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x20
MOVSXD RSI,dword ptr [RSP + 0x2c]
CALL 0x001515e0
MOV RCX,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX],RDX
MOV DL,byte ptr [RSP + 0x28]
MOV byte ptr [RAX + 0x8],DL
MOV RAX,qword ptr [RCX + 0x8]
CMP RAX,qword ptr [RCX + 0x18]
JNC 0x0014f30e
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RAX + 0x8]
ADD RCX,0x1
MOV qword ptr [RAX + 0x8],RCX
LAB_0014f30e:
MOV RCX,qword ptr [RSP + 0x10]
MOVSXD RAX,dword ptr [RSP + 0x2c]
CMP RAX,qword ptr [RCX + 0x10]
JNC 0x0014f32c
MOV RAX,qword ptr [RSP + 0x10]
MOVSXD RCX,dword ptr [RSP + 0x2c]
MOV qword ptr [RAX + 0x10],RCX
LAB_0014f32c:
MOV dword ptr [RSP + 0x1c],0x0
LAB_0014f334:
MOV RCX,qword ptr [RSP + 0x10]
MOVSXD RAX,dword ptr [RSP + 0x1c]
CMP RAX,qword ptr [RCX + 0x8]
JNC 0x0014f353
JMP 0x0014f346
LAB_0014f346:
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x0014f334
LAB_0014f353:
MOV byte ptr [RSP + 0x47],0x1
LAB_0014f358:
MOV AL,byte ptr [RSP + 0x47]
AND AL,0x1
ADD RSP,0x48
RET
|
/* alaya::LinearPool<float, unsigned int>::insert(unsigned int, float) */
int1 __thiscall
alaya::LinearPool<float,unsigned_int>::insert
(LinearPool<float,unsigned_int> *this,uint param_1,float param_2)
{
long lVar1;
void *__dest;
void *__src;
int8 *puVar2;
int local_2c;
int8 local_28;
int1 local_20;
int local_1c;
float local_18;
uint local_14;
LinearPool<float,unsigned_int> *local_10;
local_18 = param_2;
local_14 = param_1;
local_10 = this;
if ((*(long *)(this + 8) == *(long *)(this + 0x18)) &&
(lVar1 = std::
vector<alaya::Neighbor<unsigned_int,float>,alaya::AlignAlloc<alaya::Neighbor<unsigned_int,float>>>
::operator[]((vector<alaya::Neighbor<unsigned_int,float>,alaya::AlignAlloc<alaya::Neighbor<unsigned_int,float>>>
*)(this + 0x20),*(long *)(this + 8) - 1),
*(float *)(lVar1 + 4) <= param_2)) {
return 0;
}
local_1c = find_bsearch(this,local_18);
__dest = (void *)std::
vector<alaya::Neighbor<unsigned_int,float>,alaya::AlignAlloc<alaya::Neighbor<unsigned_int,float>>>
::operator[]((vector<alaya::Neighbor<unsigned_int,float>,alaya::AlignAlloc<alaya::Neighbor<unsigned_int,float>>>
*)(this + 0x20),(long)(local_1c + 1));
__src = (void *)std::
vector<alaya::Neighbor<unsigned_int,float>,alaya::AlignAlloc<alaya::Neighbor<unsigned_int,float>>>
::operator[]((vector<alaya::Neighbor<unsigned_int,float>,alaya::AlignAlloc<alaya::Neighbor<unsigned_int,float>>>
*)(this + 0x20),(long)local_1c);
memmove(__dest,__src,(*(long *)(this + 8) - (long)local_1c) * 0xc);
Neighbor<unsigned_int,float>::Neighbor
((Neighbor<unsigned_int,float> *)&local_28,local_14,local_18,false);
puVar2 = (int8 *)
std::
vector<alaya::Neighbor<unsigned_int,float>,alaya::AlignAlloc<alaya::Neighbor<unsigned_int,float>>>
::operator[]((vector<alaya::Neighbor<unsigned_int,float>,alaya::AlignAlloc<alaya::Neighbor<unsigned_int,float>>>
*)(this + 0x20),(long)local_1c);
*puVar2 = local_28;
*(int1 *)(puVar2 + 1) = local_20;
if (*(ulong *)(this + 8) < *(ulong *)(this + 0x18)) {
*(long *)(this + 8) = *(long *)(this + 8) + 1;
}
if ((ulong)(long)local_1c < *(ulong *)(this + 0x10)) {
*(long *)(this + 0x10) = (long)local_1c;
}
for (local_2c = 0; (ulong)(long)local_2c < *(ulong *)(this + 8); local_2c = local_2c + 1) {
}
return 1;
}
| |
54,793 | alaya::LinearPool<float, unsigned int>::insert(unsigned int, float) | AlayaLite/include/executor/jobs/../../utils/query_utils.hpp | auto insert(IDType u, DistanceType dist) -> bool {
if (size_ == capacity_ && dist >= data_[size_ - 1].distance_) {
return false;
}
int lo = find_bsearch(dist);
std::memmove(&data_[lo + 1], &data_[lo], (size_ - lo) * sizeof(Neighbor<DistanceType>));
data_[lo] = {u, dist};
if (size_ < capacity_) {
size_++;
}
if (lo < cur_) {
cur_ = lo;
}
for (int i = 0; i < size_; i++) {
// LOG_INFO("i {} ,dist is {}", data_[i].id_, data_[i].distance_);
}
// LOG_INFO("cur is {} , size {}", cur_, size_);
return true;
} | O3 | cpp | alaya::LinearPool<float, unsigned int>::insert(unsigned int, float):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x18(%rdi), %rax
jne 0x23cf1
movq 0x28(%rbx), %rcx
leaq (%rax,%rax,2), %rdx
ucomiss -0x8(%rcx,%rdx,4), %xmm0
jae 0x23d87
xorl %r14d, %r14d
movq 0x28(%rbx), %rsi
testl %eax, %eax
movss %xmm0, 0x4(%rsp)
jle 0x23d26
movl %eax, %ecx
leal (%rcx,%r14), %edx
shrl %edx
leaq (%rdx,%rdx,2), %rdi
ucomiss 0x4(%rsi,%rdi,4), %xmm0
jb 0x23d1c
incl %edx
movl %edx, %r14d
jmp 0x23d1e
movl %edx, %ecx
cmpl %ecx, %r14d
jl 0x23d04
movl %r14d, %r14d
leaq (,%r14,4), %rcx
leaq (%rcx,%rcx,2), %r15
leaq (%rsi,%r15), %rdi
addq $0xc, %rdi
addq %r15, %rsi
subq %r14, %rax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdx
callq 0x111b0
movq 0x28(%rbx), %rax
movl %ebp, (%rax,%r15)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%rax,%r15)
movb $0x0, 0x8(%rax,%r15)
movq 0x8(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x23d79
incq %rax
movq %rax, 0x8(%rbx)
movb $0x1, %al
cmpq %r14, 0x10(%rbx)
jbe 0x23d89
movq %r14, 0x10(%rbx)
jmp 0x23d89
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| _ZN5alaya10LinearPoolIfjE6insertEjf:
push rbp
push r15
push r14
push rbx
push rax
mov ebp, esi
mov rbx, rdi
mov rax, [rdi+8]
cmp rax, [rdi+18h]
jnz short loc_23CF1
mov rcx, [rbx+28h]
lea rdx, [rax+rax*2]
ucomiss xmm0, dword ptr [rcx+rdx*4-8]
jnb loc_23D87
loc_23CF1:
xor r14d, r14d
mov rsi, [rbx+28h]
test eax, eax
movss [rsp+28h+var_24], xmm0
jle short loc_23D26
mov ecx, eax
loc_23D04:
lea edx, [rcx+r14]
shr edx, 1
lea rdi, [rdx+rdx*2]
ucomiss xmm0, dword ptr [rsi+rdi*4+4]
jb short loc_23D1C
inc edx
mov r14d, edx
jmp short loc_23D1E
loc_23D1C:
mov ecx, edx
loc_23D1E:
cmp r14d, ecx
jl short loc_23D04
mov r14d, r14d
loc_23D26:
lea rcx, ds:0[r14*4]
lea r15, [rcx+rcx*2]
lea rdi, [rsi+r15]
add rdi, 0Ch
add rsi, r15
sub rax, r14
shl rax, 2
lea rdx, [rax+rax*2]
call _memmove
mov rax, [rbx+28h]
mov [rax+r15], ebp
movss xmm0, [rsp+28h+var_24]
movss dword ptr [rax+r15+4], xmm0
mov byte ptr [rax+r15+8], 0
mov rax, [rbx+8]
cmp rax, [rbx+18h]
jnb short loc_23D79
inc rax
mov [rbx+8], rax
loc_23D79:
mov al, 1
cmp [rbx+10h], r14
jbe short loc_23D89
mov [rbx+10h], r14
jmp short loc_23D89
loc_23D87:
xor eax, eax
loc_23D89:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| char alaya::LinearPool<float,unsigned int>::insert(_QWORD *a1, int a2, float a3)
{
long long v4; // rax
unsigned long long v5; // r14
long long v6; // rsi
signed int v7; // ecx
long long v8; // rdx
long long v9; // r15
long long v10; // rax
unsigned long long v11; // rax
char result; // al
v4 = a1[1];
if ( v4 == a1[3] && a3 >= *(float *)(a1[5] + 12 * v4 - 8) )
return 0;
v5 = 0LL;
v6 = a1[5];
if ( (int)v4 > 0 )
{
v7 = a1[1];
do
{
v8 = (unsigned int)(v7 + v5) >> 1;
if ( a3 < *(float *)(v6 + 12 * v8 + 4) )
v7 = (unsigned int)(v7 + v5) >> 1;
else
LODWORD(v5) = v8 + 1;
}
while ( (int)v5 < v7 );
v5 = (unsigned int)v5;
}
v9 = 12 * v5;
memmove(v6 + 12 * v5 + 12, 12 * v5 + v6);
v10 = a1[5];
*(_DWORD *)(v10 + 12 * v5) = a2;
*(float *)(v10 + v9 + 4) = a3;
*(_BYTE *)(v10 + v9 + 8) = 0;
v11 = a1[1];
if ( v11 < a1[3] )
a1[1] = v11 + 1;
result = 1;
if ( a1[2] > v5 )
a1[2] = v5;
return result;
}
| insert:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBP,ESI
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x8]
CMP RAX,qword ptr [RDI + 0x18]
JNZ 0x00123cf1
MOV RCX,qword ptr [RBX + 0x28]
LEA RDX,[RAX + RAX*0x2]
UCOMISS XMM0,dword ptr [RCX + RDX*0x4 + -0x8]
JNC 0x00123d87
LAB_00123cf1:
XOR R14D,R14D
MOV RSI,qword ptr [RBX + 0x28]
TEST EAX,EAX
MOVSS dword ptr [RSP + 0x4],XMM0
JLE 0x00123d26
MOV ECX,EAX
LAB_00123d04:
LEA EDX,[RCX + R14*0x1]
SHR EDX,0x1
LEA RDI,[RDX + RDX*0x2]
UCOMISS XMM0,dword ptr [RSI + RDI*0x4 + 0x4]
JC 0x00123d1c
INC EDX
MOV R14D,EDX
JMP 0x00123d1e
LAB_00123d1c:
MOV ECX,EDX
LAB_00123d1e:
CMP R14D,ECX
JL 0x00123d04
MOV R14D,R14D
LAB_00123d26:
LEA RCX,[R14*0x4]
LEA R15,[RCX + RCX*0x2]
LEA RDI,[RSI + R15*0x1]
ADD RDI,0xc
ADD RSI,R15
SUB RAX,R14
SHL RAX,0x2
LEA RDX,[RAX + RAX*0x2]
CALL 0x001111b0
MOV RAX,qword ptr [RBX + 0x28]
MOV dword ptr [RAX + R15*0x1],EBP
MOVSS XMM0,dword ptr [RSP + 0x4]
MOVSS dword ptr [RAX + R15*0x1 + 0x4],XMM0
MOV byte ptr [RAX + R15*0x1 + 0x8],0x0
MOV RAX,qword ptr [RBX + 0x8]
CMP RAX,qword ptr [RBX + 0x18]
JNC 0x00123d79
INC RAX
MOV qword ptr [RBX + 0x8],RAX
LAB_00123d79:
MOV AL,0x1
CMP qword ptr [RBX + 0x10],R14
JBE 0x00123d89
MOV qword ptr [RBX + 0x10],R14
JMP 0x00123d89
LAB_00123d87:
XOR EAX,EAX
LAB_00123d89:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* alaya::LinearPool<float, unsigned int>::insert(unsigned int, float) */
int8 __thiscall
alaya::LinearPool<float,unsigned_int>::insert
(LinearPool<float,unsigned_int> *this,uint param_1,float param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
int8 uVar4;
ulong uVar5;
ulong uVar6;
uint uVar7;
ulong uVar8;
uVar3 = *(ulong *)(this + 8);
if ((uVar3 != *(ulong *)(this + 0x18)) ||
(param_2 < *(float *)(*(long *)(this + 0x28) + -8 + uVar3 * 0xc))) {
uVar8 = 0;
lVar1 = *(long *)(this + 0x28);
if (0 < (int)uVar3) {
uVar5 = uVar3 & 0xffffffff;
do {
uVar7 = (uint)((int)uVar5 + (int)uVar8) >> 1;
uVar6 = (ulong)uVar7;
if (*(float *)(lVar1 + 4 + uVar6 * 0xc) <= param_2) {
uVar8 = (ulong)(uVar7 + 1);
uVar6 = uVar5;
}
uVar5 = uVar6;
} while ((int)uVar8 < (int)uVar6);
}
lVar2 = uVar8 * 0xc;
memmove((void *)(lVar1 + lVar2 + 0xc),(void *)(lVar1 + lVar2),(uVar3 - uVar8) * 0xc);
lVar1 = *(long *)(this + 0x28);
*(uint *)(lVar1 + lVar2) = param_1;
*(float *)(lVar1 + 4 + lVar2) = param_2;
*(int1 *)(lVar1 + 8 + lVar2) = 0;
uVar3 = *(ulong *)(this + 8);
if (uVar3 < *(ulong *)(this + 0x18)) {
uVar3 = uVar3 + 1;
*(ulong *)(this + 8) = uVar3;
}
uVar4 = CONCAT71((int7)(uVar3 >> 8),1);
if (uVar8 < *(ulong *)(this + 0x10)) {
*(ulong *)(this + 0x10) = uVar8;
}
}
else {
uVar4 = 0;
}
return uVar4;
}
| |
54,794 | wqueue_add_to_queue | eloqsql/mysys/wqueue.c | void wqueue_add_to_queue(WQUEUE *wqueue, struct st_my_thread_var *thread)
{
struct st_my_thread_var *last;
if (!(last= wqueue->last_thread))
thread->next= thread;
else
{
thread->next= last->next;
last->next= thread;
}
#ifndef DBUG_OFF
thread->prev= NULL; /* force segfault if used */
#endif
wqueue->last_thread= thread;
} | O3 | c | wqueue_add_to_queue:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
testq %rax, %rax
je 0xa66f1
movq 0x88(%rax), %rcx
addq $0x88, %rax
movq %rcx, 0x88(%rsi)
jmp 0xa66f8
leaq 0x88(%rsi), %rax
movq %rsi, (%rax)
movq %rsi, (%rdi)
popq %rbp
retq
| wqueue_add_to_queue:
push rbp
mov rbp, rsp
mov rax, [rdi]
test rax, rax
jz short loc_A66F1
mov rcx, [rax+88h]
add rax, 88h
mov [rsi+88h], rcx
jmp short loc_A66F8
loc_A66F1:
lea rax, [rsi+88h]
loc_A66F8:
mov [rax], rsi
mov [rdi], rsi
pop rbp
retn
| _QWORD * wqueue_add_to_queue(long long *a1, long long a2)
{
long long v2; // rax
long long v3; // rcx
_QWORD *result; // rax
v2 = *a1;
if ( *a1 )
{
v3 = *(_QWORD *)(v2 + 136);
result = (_QWORD *)(v2 + 136);
*(_QWORD *)(a2 + 136) = v3;
}
else
{
result = (_QWORD *)(a2 + 136);
}
*result = a2;
*a1 = a2;
return result;
}
| wqueue_add_to_queue:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001a66f1
MOV RCX,qword ptr [RAX + 0x88]
ADD RAX,0x88
MOV qword ptr [RSI + 0x88],RCX
JMP 0x001a66f8
LAB_001a66f1:
LEA RAX,[RSI + 0x88]
LAB_001a66f8:
MOV qword ptr [RAX],RSI
MOV qword ptr [RDI],RSI
POP RBP
RET
|
void wqueue_add_to_queue(long *param_1,long param_2)
{
long lVar1;
long *plVar2;
lVar1 = *param_1;
if (lVar1 == 0) {
plVar2 = (long *)(param_2 + 0x88);
}
else {
plVar2 = (long *)(lVar1 + 0x88);
*(int8 *)(param_2 + 0x88) = *(int8 *)(lVar1 + 0x88);
}
*plVar2 = param_2;
*param_1 = param_2;
return;
}
| |
54,795 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::empty() const | monkey531[P]llama/common/json.hpp | bool empty() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
{
// null values are empty
return true;
}
case value_t::array:
{
// delegate call to array_t::empty()
return m_data.m_value.array->empty();
}
case value_t::object:
{
// delegate call to object_t::empty()
return m_data.m_value.object->empty();
}
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
// all other types are nonempty
return false;
}
}
} | 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>::empty() const:
movzbl (%rdi), %eax
testl %eax, %eax
je 0xc4fe4
cmpl $0x1, %eax
je 0xc4fd5
cmpl $0x2, %eax
jne 0xc4fe7
movq 0x8(%rdi), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
sete %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5emptyEv:
movzx eax, byte ptr [rdi]
test eax, eax
jz short loc_C4FE4
cmp eax, 1
jz short loc_C4FD5
cmp eax, 2
jnz short loc_C4FE7
loc_C4FD5:
mov rax, [rdi+8]
mov rcx, [rax]
cmp rcx, [rax+8]
setz al
retn
loc_C4FE4:
mov al, 1
retn
loc_C4FE7:
xor eax, eax
retn
| bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::empty(
unsigned __int8 *a1)
{
int v1; // eax
v1 = *a1;
if ( !*a1 )
return 1;
if ( v1 == 1 || v1 == 2 )
return **((_QWORD **)a1 + 1) == *(_QWORD *)(*((_QWORD *)a1 + 1) + 8LL);
return 0;
}
| empty:
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JZ 0x001c4fe4
CMP EAX,0x1
JZ 0x001c4fd5
CMP EAX,0x2
JNZ 0x001c4fe7
LAB_001c4fd5:
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX]
CMP RCX,qword ptr [RAX + 0x8]
SETZ AL
RET
LAB_001c4fe4:
MOV AL,0x1
RET
LAB_001c4fe7:
XOR EAX,EAX
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::empty() const */
int8 __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::empty(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this)
{
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
long *plVar2;
bVar1 = *this;
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
return 1;
}
if ((bVar1 != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) &&
(bVar1 != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2)) {
return 0;
}
plVar2 = *(long **)(this + 8);
return CONCAT71((int7)((ulong)plVar2 >> 8),*plVar2 == plVar2[1]);
}
| |
54,796 | mi_update_blob_record | eloqsql/storage/myisam/mi_dynrec.c | int _mi_update_blob_record(MI_INFO *info, my_off_t pos, const uchar *record)
{
uchar *rec_buff;
int error;
ulong reclength,extra;
extra= (ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
MI_DYN_DELETE_BLOCK_HEADER);
reclength= (info->s->base.pack_reclength+
_mi_calc_total_blob_length(info,record)+ extra);
if (!(rec_buff=(uchar*) my_alloca(reclength)))
{
my_errno= HA_ERR_OUT_OF_MEM; /* purecov: inspected */
return(-1);
}
reclength=_mi_rec_pack(info,rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
record);
error=update_dynamic_record(info,pos,
rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
reclength);
my_afree(rec_buff);
return(error);
} | O3 | c | mi_update_blob_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x148(%rax), %r12
movq %rdx, %rsi
callq 0x7a788
leaq (%r12,%rax), %rsi
addq $0x5c, %rsi
xorl %edi, %edi
xorl %edx, %edx
callq 0xa63e5
testq %rax, %rax
je 0x7a884
movq %rax, %r12
movq %rax, %r13
addq $0x18, %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x79e4e
movl %eax, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x7a2da
movl %eax, %ebx
movq %r12, %rdi
callq 0xa6612
movl %ebx, %eax
jmp 0x7a894
callq 0xa8156
movl $0x80, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mi_update_blob_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov rbx, rsi
mov r14, rdi
mov rax, [rdi]
mov r12, [rax+148h]
mov rsi, rdx
call _mi_calc_total_blob_length
lea rsi, [r12+rax]
add rsi, 5Ch ; '\'
xor edi, edi
xor edx, edx
call my_malloc
test rax, rax
jz short loc_7A884
mov r12, rax
mov r13, rax
add r13, 18h
mov rdi, r14
mov rsi, r13
mov rdx, r15
call _mi_rec_pack
mov ecx, eax
mov rdi, r14
mov rsi, rbx
mov rdx, r13
call update_dynamic_record_0
mov ebx, eax
mov rdi, r12
call my_free
mov eax, ebx
jmp short loc_7A894
loc_7A884:
call _my_thread_var
mov dword ptr [rax], 80h
mov eax, 0FFFFFFFFh
loc_7A894:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mi_update_blob_record(long long *a1, long long a2, char *a3)
{
long long v4; // r12
long long v5; // rax
long long v6; // rax
long long v7; // r12
long long v8; // r13
unsigned int v9; // eax
unsigned int updated; // ebx
v4 = *(_QWORD *)(*a1 + 328);
v5 = mi_calc_total_blob_length(a1, (long long)a3);
v6 = my_malloc(0LL, v4 + v5 + 92, 0LL);
if ( v6 )
{
v7 = v6;
v8 = v6 + 24;
v9 = mi_rec_pack((long long)a1, (_BYTE *)(v6 + 24), a3);
updated = update_dynamic_record_0(a1, a2, v8, v9);
my_free(v7);
return updated;
}
else
{
*(_DWORD *)my_thread_var(0LL) = 128;
return 0xFFFFFFFFLL;
}
}
| _mi_update_blob_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI]
MOV R12,qword ptr [RAX + 0x148]
MOV RSI,RDX
CALL 0x0017a788
LEA RSI,[R12 + RAX*0x1]
ADD RSI,0x5c
XOR EDI,EDI
XOR EDX,EDX
CALL 0x001a63e5
TEST RAX,RAX
JZ 0x0017a884
MOV R12,RAX
MOV R13,RAX
ADD R13,0x18
MOV RDI,R14
MOV RSI,R13
MOV RDX,R15
CALL 0x00179e4e
MOV ECX,EAX
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R13
CALL 0x0017a2da
MOV EBX,EAX
MOV RDI,R12
CALL 0x001a6612
MOV EAX,EBX
JMP 0x0017a894
LAB_0017a884:
CALL 0x001a8156
MOV dword ptr [RAX],0x80
MOV EAX,0xffffffff
LAB_0017a894:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4 _mi_update_blob_record(long *param_1,int8 param_2,int8 param_3)
{
int4 uVar1;
long lVar2;
long lVar3;
int4 *puVar4;
lVar3 = *(long *)(*param_1 + 0x148);
lVar2 = _mi_calc_total_blob_length(param_1,param_3);
lVar3 = my_malloc(0,lVar3 + lVar2 + 0x5c,0);
if (lVar3 == 0) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x80;
uVar1 = 0xffffffff;
}
else {
uVar1 = _mi_rec_pack(param_1,lVar3 + 0x18,param_3);
uVar1 = update_dynamic_record(param_1,param_2,lVar3 + 0x18,uVar1);
my_free(lVar3);
}
return uVar1;
}
| |
54,797 | my_string_metadata_get_mb | eloqsql/strings/ctype.c | static void
my_string_metadata_get_mb(MY_STRING_METADATA *metadata,
CHARSET_INFO *cs, const char *str, ulong length)
{
const char *strend= str + length;
for (my_string_metadata_init(metadata) ;
str < strend;
metadata->char_length++)
{
my_wc_t wc;
int mblen= my_ci_mb_wc(cs, &wc, (const uchar *) str, (const uchar *) strend);
if (mblen > 0) /* Assigned character */
{
if (wc > 0x7F)
metadata->repertoire|= MY_REPERTOIRE_EXTENDED;
str+= mblen;
}
else if (mblen == MY_CS_ILSEQ) /* Bad byte sequence */
{
metadata->repertoire|= MY_REPERTOIRE_EXTENDED;
str++;
}
else if (mblen > MY_CS_TOOSMALL) /* Unassigned character */
{
metadata->repertoire|= MY_REPERTOIRE_EXTENDED;
str+= (-mblen);
}
else /* Incomplete character, premature end-of-line */
{
metadata->repertoire|= MY_REPERTOIRE_EXTENDED; /* Just in case */
break;
}
}
} | O0 | c | my_string_metadata_get_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6fd10
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x6e89d
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0x6e82c
cmpq $0x7f, -0x30(%rbp)
jbe 0x6e819
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x8(%rax)
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6e888
cmpl $0x0, -0x34(%rbp)
jne 0x6e84d
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6e886
cmpl $-0x65, -0x34(%rbp)
jle 0x6e875
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x8(%rax)
xorl %ecx, %ecx
subl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6e884
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x8(%rax)
jmp 0x6e89d
jmp 0x6e886
jmp 0x6e888
jmp 0x6e88a
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x6e7cd
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_string_metadata_get_mb:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_28], rax
mov rdi, [rbp+var_8]
call my_string_metadata_init
loc_6E7CD:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_28]
jnb loc_6E89D
mov rax, [rbp+var_10]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_28]
lea rsi, [rbp+var_30]
call rax
mov [rbp+var_34], eax
cmp [rbp+var_34], 0
jle short loc_6E82C
cmp [rbp+var_30], 7Fh
jbe short loc_6E819
mov rax, [rbp+var_8]
mov ecx, [rax+8]
or ecx, 2
mov [rax+8], ecx
loc_6E819:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp short loc_6E888
loc_6E82C:
cmp [rbp+var_34], 0
jnz short loc_6E84D
mov rax, [rbp+var_8]
mov ecx, [rax+8]
or ecx, 2
mov [rax+8], ecx
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_6E886
loc_6E84D:
cmp [rbp+var_34], 0FFFFFF9Bh
jle short loc_6E875
mov rax, [rbp+var_8]
mov ecx, [rax+8]
or ecx, 2
mov [rax+8], ecx
xor ecx, ecx
sub ecx, [rbp+var_34]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp short loc_6E884
loc_6E875:
mov rax, [rbp+var_8]
mov ecx, [rax+8]
or ecx, 2
mov [rax+8], ecx
jmp short loc_6E89D
loc_6E884:
jmp short $+2
loc_6E886:
jmp short $+2
loc_6E888:
jmp short $+2
loc_6E88A:
mov rax, [rbp+var_8]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
jmp loc_6E7CD
loc_6E89D:
add rsp, 40h
pop rbp
retn
| unsigned long long my_string_metadata_get_mb(unsigned long long a1, long long a2, unsigned long long a3, long long a4)
{
unsigned long long result; // rax
int v5; // [rsp+Ch] [rbp-34h]
unsigned long long v6; // [rsp+10h] [rbp-30h] BYREF
unsigned long long v7; // [rsp+18h] [rbp-28h]
long long v8; // [rsp+20h] [rbp-20h]
unsigned long long v9; // [rsp+28h] [rbp-18h]
long long v10; // [rsp+30h] [rbp-10h]
unsigned long long v11; // [rsp+38h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v7 = a4 + a3;
my_string_metadata_init(a1);
while ( 1 )
{
result = v9;
if ( v9 >= v7 )
break;
v5 = (*(long long ( **)(long long, unsigned long long *, unsigned long long, unsigned long long))(*(_QWORD *)(v10 + 184) + 40LL))(
v10,
&v6,
v9,
v7);
if ( v5 <= 0 )
{
if ( v5 )
{
if ( v5 <= -101 )
{
result = v11;
*(_DWORD *)(v11 + 8) |= 2u;
return result;
}
*(_DWORD *)(v11 + 8) |= 2u;
v9 += -v5;
}
else
{
*(_DWORD *)(v11 + 8) |= 2u;
++v9;
}
}
else
{
if ( v6 > 0x7F )
*(_DWORD *)(v11 + 8) |= 2u;
v9 += v5;
}
++*(_QWORD *)v11;
}
return result;
}
| my_string_metadata_get_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0016fd10
LAB_0016e7cd:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x0016e89d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x30]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP dword ptr [RBP + -0x34],0x0
JLE 0x0016e82c
CMP qword ptr [RBP + -0x30],0x7f
JBE 0x0016e819
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x8]
OR ECX,0x2
MOV dword ptr [RAX + 0x8],ECX
LAB_0016e819:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016e888
LAB_0016e82c:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x0016e84d
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x8]
OR ECX,0x2
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016e886
LAB_0016e84d:
CMP dword ptr [RBP + -0x34],-0x65
JLE 0x0016e875
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x8]
OR ECX,0x2
MOV dword ptr [RAX + 0x8],ECX
XOR ECX,ECX
SUB ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016e884
LAB_0016e875:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x8]
OR ECX,0x2
MOV dword ptr [RAX + 0x8],ECX
JMP 0x0016e89d
LAB_0016e884:
JMP 0x0016e886
LAB_0016e886:
JMP 0x0016e888
LAB_0016e888:
JMP 0x0016e88a
LAB_0016e88a:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
JMP 0x0016e7cd
LAB_0016e89d:
ADD RSP,0x40
POP RBP
RET
|
void my_string_metadata_get_mb(long *param_1,long param_2,ulong param_3,long param_4)
{
int iVar1;
ulong local_38;
ulong local_30;
long local_28;
ulong local_20;
long local_18;
long *local_10;
local_30 = param_3 + param_4;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
my_string_metadata_init(param_1);
do {
if (local_30 <= local_20) {
return;
}
iVar1 = (**(code **)(*(long *)(local_18 + 0xb8) + 0x28))(local_18,&local_38,local_20,local_30);
if (iVar1 < 1) {
if (iVar1 == 0) {
*(uint *)(local_10 + 1) = *(uint *)(local_10 + 1) | 2;
local_20 = local_20 + 1;
}
else {
if (iVar1 < -100) {
*(uint *)(local_10 + 1) = *(uint *)(local_10 + 1) | 2;
return;
}
*(uint *)(local_10 + 1) = *(uint *)(local_10 + 1) | 2;
local_20 = local_20 + (long)-iVar1;
}
}
else {
if (0x7f < local_38) {
*(uint *)(local_10 + 1) = *(uint *)(local_10 + 1) | 2;
}
local_20 = local_20 + (long)iVar1;
}
*local_10 = *local_10 + 1;
} while( true );
}
| |
54,798 | nglog::TruncateStdoutStderr() | ng-log[P]ng-log/src/logging.cc | static uint32 MaxLogSize() {
return (FLAGS_max_log_size > 0 && FLAGS_max_log_size < 4096
? FLAGS_max_log_size
: 1);
} | O1 | cpp | nglog::TruncateStdoutStderr():
pushq %rbx
leaq 0x236c6(%rip), %rax # 0x32b24
movl (%rax), %eax
leal -0x1(%rax), %ecx
shll $0x14, %eax
cmpl $0xfff, %ecx # imm = 0xFFF
movl $0x100000, %ebx # imm = 0x100000
cmovbl %eax, %ebx
leaq 0x1549c(%rip), %rdi # 0x24917
movl $0x100000, %edx # imm = 0x100000
movq %rbx, %rsi
callq 0xecdd
leaq 0x15498(%rip), %rdi # 0x24927
movl $0x100000, %edx # imm = 0x100000
movq %rbx, %rsi
popq %rbx
jmp 0xecdd
| _ZN5nglog20TruncateStdoutStderrEv:
push rbx
lea rax, _ZN3fLU18FLAGS_max_log_sizeE; fLU::FLAGS_max_log_size
mov eax, [rax]
lea ecx, [rax-1]; unsigned __int64
shl eax, 14h
cmp ecx, 0FFFh
mov ebx, 100000h
cmovb ebx, eax
lea rdi, aProcSelfFd1; "/proc/self/fd/1"
mov edx, 100000h; unsigned __int64
mov rsi, rbx; char *
call _ZN5nglog15TruncateLogFileEPKcmm; nglog::TruncateLogFile(char const*,ulong,ulong)
lea rdi, aProcSelfFd2; "/proc/self/fd/2"
mov edx, 100000h; unsigned __int64
mov rsi, rbx; char *
pop rbx
jmp _ZN5nglog15TruncateLogFileEPKcmm; nglog::TruncateLogFile(char const*,ulong,ulong)
| void nglog::TruncateStdoutStderr(nglog *this)
{
long long v1; // rbx
v1 = 0x100000LL;
if ( (unsigned int)(fLU::FLAGS_max_log_size - 1) < 0xFFF )
v1 = (unsigned int)(fLU::FLAGS_max_log_size << 20);
nglog::TruncateLogFile((nglog *)"/proc/self/fd/1", (const char *)v1, 0x100000LL);
nglog::TruncateLogFile((nglog *)"/proc/self/fd/2", (const char *)v1, 0x100000LL);
}
| TruncateStdoutStderr:
PUSH RBX
LEA RAX,[0x132b24]
MOV EAX,dword ptr [RAX]
LEA ECX,[RAX + -0x1]
SHL EAX,0x14
CMP ECX,0xfff
MOV EBX,0x100000
CMOVC EBX,EAX
LEA RDI,[0x124917]
MOV EDX,0x100000
MOV RSI,RBX
CALL 0x0010ecdd
LEA RDI,[0x124927]
MOV EDX,0x100000
MOV RSI,RBX
POP RBX
JMP 0x0010ecdd
|
/* nglog::TruncateStdoutStderr() */
void nglog::TruncateStdoutStderr(void)
{
ulong uVar1;
uVar1 = 0x100000;
if (fLU::FLAGS_max_log_size - 1U < 0xfff) {
uVar1 = (ulong)(uint)(fLU::FLAGS_max_log_size << 0x14);
}
TruncateLogFile("/proc/self/fd/1",uVar1,0x100000);
TruncateLogFile("/proc/self/fd/2",uVar1,0x100000);
return;
}
| |
54,799 | minja::IfExpr::IfExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&) | monkey531[P]llama/common/minja.hpp | IfExpr(const Location & location, std::shared_ptr<Expression> && c, std::shared_ptr<Expression> && t, std::shared_ptr<Expression> && e)
: Expression(location), condition(std::move(c)), then_expr(std::move(t)), else_expr(std::move(e)) {} | O2 | cpp | minja::IfExpr::IfExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
callq 0x63412
leaq 0x8ae02(%rip), %rax # 0xfcac8
addq $0x10, %rax
movq %rax, (%r12)
andq $0x0, 0x28(%r12)
movups (%r15), %xmm0
andq $0x0, 0x8(%r15)
movups %xmm0, 0x20(%r12)
andq $0x0, (%r15)
andq $0x0, 0x38(%r12)
movups (%r14), %xmm0
andq $0x0, 0x8(%r14)
movups %xmm0, 0x30(%r12)
andq $0x0, (%r14)
andq $0x0, 0x48(%r12)
movups (%rbx), %xmm0
andq $0x0, 0x8(%rbx)
movups %xmm0, 0x40(%r12)
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZN5minja6IfExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEES7_S7_:
push r15
push r14
push r12
push rbx
push rax
mov rbx, r8
mov r14, rcx
mov r15, rdx
mov r12, rdi
call _ZN5minja10ExpressionC2ERKNS_8LocationE; minja::Expression::Expression(minja::Location const&)
lea rax, _ZTVN5minja6IfExprE; `vtable for'minja::IfExpr
add rax, 10h
mov [r12], rax
and qword ptr [r12+28h], 0
movups xmm0, xmmword ptr [r15]
and qword ptr [r15+8], 0
movups xmmword ptr [r12+20h], xmm0
and qword ptr [r15], 0
and qword ptr [r12+38h], 0
movups xmm0, xmmword ptr [r14]
and qword ptr [r14+8], 0
movups xmmword ptr [r12+30h], xmm0
and qword ptr [r14], 0
and qword ptr [r12+48h], 0
movups xmm0, xmmword ptr [rbx]
and qword ptr [rbx+8], 0
movups xmmword ptr [r12+40h], xmm0
and qword ptr [rbx], 0
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long * minja::IfExpr::IfExpr(long long a1, _QWORD *a2, __int128 *a3, __int128 *a4, __int128 *a5)
{
long long *result; // rax
__int128 v9; // xmm0
__int128 v10; // xmm0
__int128 v11; // xmm0
minja::Expression::Expression((_QWORD *)a1, a2);
result = &`vtable for'minja::IfExpr + 2;
*(_QWORD *)a1 = &`vtable for'minja::IfExpr + 2;
*(_QWORD *)(a1 + 40) = 0LL;
v9 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v9;
*(_QWORD *)a3 = 0LL;
*(_QWORD *)(a1 + 56) = 0LL;
v10 = *a4;
*((_QWORD *)a4 + 1) = 0LL;
*(_OWORD *)(a1 + 48) = v10;
*(_QWORD *)a4 = 0LL;
*(_QWORD *)(a1 + 72) = 0LL;
v11 = *a5;
*((_QWORD *)a5 + 1) = 0LL;
*(_OWORD *)(a1 + 64) = v11;
*(_QWORD *)a5 = 0LL;
return result;
}
| IfExpr:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,R8
MOV R14,RCX
MOV R15,RDX
MOV R12,RDI
CALL 0x00163412
LEA RAX,[0x1fcac8]
ADD RAX,0x10
MOV qword ptr [R12],RAX
AND qword ptr [R12 + 0x28],0x0
MOVUPS XMM0,xmmword ptr [R15]
AND qword ptr [R15 + 0x8],0x0
MOVUPS xmmword ptr [R12 + 0x20],XMM0
AND qword ptr [R15],0x0
AND qword ptr [R12 + 0x38],0x0
MOVUPS XMM0,xmmword ptr [R14]
AND qword ptr [R14 + 0x8],0x0
MOVUPS xmmword ptr [R12 + 0x30],XMM0
AND qword ptr [R14],0x0
AND qword ptr [R12 + 0x48],0x0
MOVUPS XMM0,xmmword ptr [RBX]
AND qword ptr [RBX + 0x8],0x0
MOVUPS xmmword ptr [R12 + 0x40],XMM0
AND qword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::IfExpr::IfExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&,
std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::IfExpr::IfExpr
(IfExpr *this,Location *param_1,shared_ptr *param_2,shared_ptr *param_3,
shared_ptr *param_4)
{
int8 uVar1;
Expression::Expression((Expression *)this,param_1);
*(int ***)this = &PTR_do_evaluate_001fcad8;
*(int8 *)(this + 0x28) = 0;
uVar1 = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar1;
*(int8 *)param_2 = 0;
*(int8 *)(this + 0x38) = 0;
uVar1 = *(int8 *)(param_3 + 8);
*(int8 *)(param_3 + 8) = 0;
*(int8 *)(this + 0x30) = *(int8 *)param_3;
*(int8 *)(this + 0x38) = uVar1;
*(int8 *)param_3 = 0;
*(int8 *)(this + 0x48) = 0;
uVar1 = *(int8 *)(param_4 + 8);
*(int8 *)(param_4 + 8) = 0;
*(int8 *)(this + 0x40) = *(int8 *)param_4;
*(int8 *)(this + 0x48) = uVar1;
*(int8 *)param_4 = 0;
return;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.