name string | code string | asm string | file string |
|---|---|---|---|
bool sptk::ReadStream<double>(bool, int, int, int, std::vector<double, std::allocator<double>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r13d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x8101
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<long double>(bool, int, int, int, std::vector<long double, std::allocator<long double>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r13d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x8277
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<signed char>(int, int, std::vector<signed char, std::allocator<signed char>> const&, std::ostream*, int*) | bool WriteStream(int write_point, int write_size,
const std::vector<T>& sequence_to_write,
std::ostream* output_stream, int* actual_write_size) {
if (write_point < 0 || write_size <= 0 || NULL == output_stream) {
return false;
}
const int end(write_point + write_size);
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testl %edi, %edi
sets %al
testl %esi, %esi
setle %cl
orb %al, %cl
testq %rbx, %rbx
sete %al
orb %cl, %al
jne 0x862b
movq %rdx, %r12
movl %esi, %r15d
movl %edi, %r13d
leal (%r15,%r13), %eax
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<int>(int, int, std::vector<int, std::allocator<int>> const&, std::ostream*, int*) | bool WriteStream(int write_point, int write_size,
const std::vector<T>& sequence_to_write,
std::ostream* output_stream, int* actual_write_size) {
if (write_point < 0 || write_size <= 0 || NULL == output_stream) {
return false;
}
const int end(write_point + write_size);
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testl %edi, %edi
sets %al
testl %esi, %esi
setle %cl
orb %al, %cl
testq %rbx, %rbx
sete %al
orb %cl, %al
jne 0x886e
movq %rdx, %r12
movl %esi, %r15d
movl %edi, %r13d
leal (%r15,%r13), %ecx
movq (%rdx), %rax
movq 0x8(%rdx), %rdx... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<unsigned int>(int, int, std::vector<unsigned int, std::allocator<unsigned int>> const&, std::ostream*, int*) | bool WriteStream(int write_point, int write_size,
const std::vector<T>& sequence_to_write,
std::ostream* output_stream, int* actual_write_size) {
if (write_point < 0 || write_size <= 0 || NULL == output_stream) {
return false;
}
const int end(write_point + write_size);
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testl %edi, %edi
sets %al
testl %esi, %esi
setle %cl
orb %al, %cl
testq %rbx, %rbx
sete %al
orb %cl, %al
jne 0x8c33
movq %rdx, %r12
movl %esi, %r15d
movl %edi, %r13d
leal (%r15,%r13), %ecx
movq (%rdx), %rax
movq 0x8(%rdx), %rdx... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::Matrix::Matrix(sptk::Matrix const&) | Matrix::Matrix(const Matrix& matrix)
: num_row_(matrix.num_row_),
num_column_(matrix.num_column_),
data_(matrix.data_),
index_(num_row_) {
for (int i(0); i < num_row_; ++i) {
index_[i] = &data_[i * num_column_];
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
leaq 0x679b(%rip), %rax # 0x10d28
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0xaf3c
leaq 0x28(%r15), %r14
movslq 0x8(%r15), %rsi
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::operator=(sptk::Matrix const&) | Matrix& Matrix::operator=(const Matrix& matrix) {
if (this != &matrix) {
num_row_ = matrix.num_row_;
num_column_ = matrix.num_column_;
data_ = matrix.data_;
index_.resize(num_row_);
for (int i(0); i < num_row_; ++i) {
index_[i] = &data_[i * num_column_];
}
}
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xa66e
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rbx)
addq $0x10, %rsi
leaq 0x10(%rbx), %r14
movq %r14, %rdi
callq 0xb04a
leaq 0x28(%rbx), %r15
movslq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0xaf0a
movslq 0x8(%rbx), %rax
testq %rax, %rax
jle 0xa66e
movslq 0xc... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::Resize(int, int) | void Matrix::Resize(int num_row, int num_column) {
num_row_ = num_row < 0 ? 0 : num_row;
num_column_ = num_column < 0 ? 0 : num_column;
data_.resize(num_row_ * num_column_);
index_.resize(num_row_);
Fill(0.0);
for (int i(0); i < num_row_; ++i) {
index_[i] = &data_[i * num_column_];
}
} | pushq %r15
pushq %r14
pushq %rbx
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movq %rdi, %r15
testl %edx, %edx
cmovgl %edx, %eax
movl %esi, 0x8(%rdi)
movl %eax, 0xc(%rdi)
leaq 0x10(%rdi), %rbx
imull %eax, %esi
movq %rbx, %rdi
callq 0x8112
leaq 0x28(%r15), %r14
movslq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xaf0a
... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::At(int, int) | double& Matrix::At(int row, int column) {
if (row < 0 || num_row_ <= row || column < 0 || num_column_ <= column) {
throw std::out_of_range(kErrorMessageForOutOfRange);
}
return index_[row][column];
} | pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
js 0xa7e4
testl %edx, %edx
js 0xa7e4
cmpl %esi, 0x8(%rdi)
jle 0xa7e4
cmpl %edx, 0xc(%rdi)
jle 0xa7e4
movl %esi, %ecx
movq 0x28(%rdi), %rsi
movl %edx, %eax
shlq $0x3, %rax
addq (%rsi,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x3140
mov... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::operator+=(sptk::Matrix const&) | Matrix& Matrix::operator+=(const Matrix& matrix) {
if (num_row_ != matrix.num_row_ || num_column_ != matrix.num_column_) {
throw std::logic_error(kErrorMessageForLogicError);
}
std::transform(data_.begin(), data_.end(), matrix.data_.begin(),
data_.begin(), std::plus<double>());
return *this... | pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0xa8e7
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
jne 0xa8e7
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq %rcx, %rax
je 0xa8dc
movq 0x10(%rsi), %rdx
movsd (%rax), %xmm0
addsd (%rdx), %xmm0
movsd %xmm0, (%rax)
addq $0x8, %rax
addq $0x8, %r... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::operator-=(sptk::Matrix const&) | Matrix& Matrix::operator-=(const Matrix& matrix) {
if (num_row_ != matrix.num_row_ || num_column_ != matrix.num_column_) {
throw std::logic_error(kErrorMessageForLogicError);
}
std::transform(data_.begin(), data_.end(), matrix.data_.begin(),
data_.begin(), std::minus<double>());
return *thi... | pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0xa975
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
jne 0xa975
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq %rcx, %rax
je 0xa96a
movq 0x10(%rsi), %rdx
movsd (%rax), %xmm0
subsd (%rdx), %xmm0
movsd %xmm0, (%rax)
addq $0x8, %rax
addq $0x8, %r... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::operator*(sptk::Matrix const&) const | Matrix Matrix::operator*(const Matrix& matrix) const {
if (num_column_ != matrix.num_row_) {
throw std::logic_error(kErrorMessageForLogicError);
}
Matrix result(num_row_, matrix.num_column_);
for (int i(0); i < num_row_; ++i) {
for (int j(0); j < matrix.num_column_; ++j) {
for (int k(0); k < num_c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0xc(%rsi), %eax
cmpl 0x8(%rdx), %eax
jne 0xaab6
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rsi), %esi
movl 0xc(%rdx), %edx
callq 0xa434
movslq 0x8(%r15), %rax
testq %rax, %rax
jle 0xaaa4
movl 0xc(%rbx), %ecx
movl 0xc(%r15),... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::operator-() const | Matrix Matrix::operator-() const {
Matrix result(*this);
result.Negate();
return result;
} | pushq %rbx
movq %rdi, %rbx
callq 0xa57a
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0xabdc
movaps 0x1937(%rip), %xmm0 # 0xc500
movsd (%rax), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rax)
addq $0x8, %rax
cmpq %rcx, %rax
jne 0xabc9
movq %rbx, %rax
popq %rbx
retq
nop
| /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::FillDiagonal(double) | void Matrix::FillDiagonal(double value) {
Fill(0.0);
const int num_ones(std::min(num_row_, num_column_));
for (int i(0); i < num_ones; ++i) {
index_[i][i] = value;
}
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rdx
cmpq %rdx, %rdi
je 0xac41
subq %rdi, %rdx
addq $-0x8, %rdx
andq $-0x8, %rdx
addq $0x8, %rdx
xorl %esi, %esi
movsd %xmm0, 0x8(%rsp)
callq 0x3180
movsd 0x8(%rsp), %xmm0
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %eax
cmpl %ecx, %eax
cmovll ... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::Transpose(sptk::Matrix*) const | bool Matrix::Transpose(Matrix* transposed_matrix) const {
if (NULL == transposed_matrix || this == transposed_matrix) {
return false;
}
if (transposed_matrix->num_row_ != num_column_ ||
transposed_matrix->num_column_ != num_row_) {
transposed_matrix->Resize(num_column_, num_row_);
}
for (int i... | pushq %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
setne %al
cmpq %rsi, %rdi
setne %bpl
andb %al, %bpl
cmpb $0x1, %bpl
jne 0xacf5
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %edi
movl 0xc(%r14), %esi
cmpl %esi, %edi
jne 0xaca6
movl 0x8(%r14), %edx
cmpl %edx, 0xc(%rbx)
jne 0xacaa
jmp 0xacb6
movl 0x8(%r14), %edx
movq ... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::GetSubmatrix(int, int, int, int, sptk::Matrix*) const | bool Matrix::GetSubmatrix(int row_offset, int num_row_of_submatrix,
int column_offset, int num_column_of_submatrix,
Matrix* submatrix) const {
if (row_offset < 0 || num_row_of_submatrix <= 0 ||
num_row_ < row_offset + num_row_of_submatrix || column_offset < 0 ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
testl %esi, %esi
sets %al
testl %edx, %edx
setle %cl
orb %al, %cl
je 0xad28
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r8d, %r14d
xorl %eax, %eax
testl %r8d, %r8d
jle ... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::GetDeterminant(double*) const | bool Matrix::GetDeterminant(double* determinant) const {
if (num_row_ != num_column_ || num_row_ <= 0 || NULL == determinant) {
return false;
}
const int num_dimension(num_row_);
if (1 == num_dimension) {
*determinant = index_[0][0];
return true;
}
const int num_order(num_dimension - 1);
Mat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jne 0xadf2
movq %rsi, %rbx
testl %edx, %edx
setle %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0xae09
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::SymmetricMatrix::SymmetricMatrix(sptk::SymmetricMatrix const&) | SymmetricMatrix::SymmetricMatrix(const SymmetricMatrix& matrix)
: num_dimension_(matrix.num_dimension_),
data_(matrix.data_),
index_(num_dimension_) {
for (int i(0), j(0); i < num_dimension_; ++i, j += i) {
index_[i] = &data_[j];
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
leaq 0x59cf(%rip), %rax # 0x10d58
movq %rax, (%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0xaf3c
leaq 0x28(%r15), %r14
movslq 0x8(%r15), %rsi
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
sptk::SymmetricMatrix::At(int, int) const | const double& SymmetricMatrix::At(int row, int column) const {
if (row < column) {
std::swap(row, column);
}
if (column < 0 || num_dimension_ <= row) {
throw std::out_of_range(kErrorMessageForOutOfRange);
}
return index_[row][column];
} | pushq %r14
pushq %rbx
pushq %rax
cmpl %edx, %esi
movl %edx, %eax
cmovgl %esi, %eax
cmovll %esi, %edx
testl %edx, %edx
js 0xb578
cmpl %eax, 0x8(%rdi)
jle 0xb578
movslq %eax, %rcx
movq 0x28(%rdi), %rsi
movl %edx, %eax
shlq $0x3, %rax
addq (%rsi,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
sptk::SymmetricMatrix::GetDiagonal(std::vector<double, std::allocator<double>>*) const | bool SymmetricMatrix::GetDiagonal(
std::vector<double>* diagonal_elements) const {
if (NULL == diagonal_elements) {
return false;
}
if (diagonal_elements->size() != static_cast<std::size_t>(num_dimension_)) {
diagonal_elements->resize(num_dimension_);
}
for (int i(0); i < num_dimension_; ++i) {
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rsi, %rsi
je 0xb6c2
movq %rdi, %r14
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movl 0x8(%rdi), %edx
movslq %edx, %rsi
cmpq %rsi, %rax
je 0xb69d
movq %rbx, %rdi
callq 0x8112
movl 0x8(%r14), %edx
testl %edx, %edx
jle 0xb6c2
movq 0x28(%r14), %rax
movq (%r... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
test_gzio | void test_gzio(fname, uncompr, uncomprLen)
const char *fname; /* compressed file name */
Byte *uncompr;
uLong uncomprLen;
{
#ifdef NO_GZCOMPRESS
fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n");
#else
int err;
int len = (int)strlen(hello)+1;
gzFile file;
z_off_t pos;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x44db(%rip), %rdi # 0x7140
callq 0x20e0
movq %rax, %r12
leaq 0x13d1(%rip), %rsi # 0x4045
movq %r15, %rdi
callq 0x2170
testq %rax, %rax
je 0x2e35
movq %rax, %r13
movq %rax, %rdi
movl $0... | /coapp-packages[P]zlib/test/example.c |
test_deflate | void test_deflate(compr, comprLen)
Byte *compr;
uLong comprLen;
{
z_stream c_stream; /* compression stream */
int err;
uLong len = (uLong)strlen(hello)+1;
c_stream.zalloc = zalloc;
c_stream.zfree = zfree;
c_stream.opaque = (voidpf)0;
err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x429b(%rip), %r12 # 0x7140
movq %r12, %rdi
callq 0x20e0
movq %rax, %r14
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rdi
movups %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
leaq 0x127b(%rip), %rdx # 0x41... | /coapp-packages[P]zlib/test/example.c |
test_inflate | void test_inflate(compr, comprLen, uncompr, uncomprLen)
Byte *compr, *uncompr;
uLong comprLen, uncomprLen;
{
int err;
z_stream d_stream; /* decompression stream */
strcpy((char*)uncompr, "garbage");
d_stream.zalloc = zalloc;
d_stream.zfree = zfree;
d_stream.opaque = (voidpf)0;
d_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movabsq $0x65676162726167, %rax # imm = 0x65676162726167
movq %rax, (%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movq $0x0, 0x50(%rax)
movq %rdi, (%rax)
movl $0x0, 0x8(%rax)
movq... | /coapp-packages[P]zlib/test/example.c |
test_large_deflate | void test_large_deflate(compr, comprLen, uncompr, uncomprLen)
Byte *compr, *uncompr;
uLong comprLen, uncomprLen;
{
z_stream c_stream; /* compression stream */
int err;
c_stream.zalloc = zalloc;
c_stream.zfree = zfree;
c_stream.opaque = (voidpf)0;
err = deflateInit(&c_stream, Z_BEST_SPE... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movq %rsp, %rdi
movups %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
leaq 0x10bf(%rip), %rdx # 0x4146
movl $0x1, %esi
movl $0x70, %ecx
callq 0x2140
testl %eax, %eax
j... | /coapp-packages[P]zlib/test/example.c |
test_dict_deflate | void test_dict_deflate(compr, comprLen)
Byte *compr;
uLong comprLen;
{
z_stream c_stream; /* compression stream */
int err;
c_stream.zalloc = zalloc;
c_stream.zfree = zfree;
c_stream.opaque = (voidpf)0;
err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
CHECK_ERR(err, "deflateInit")... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdi
movups %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
leaq 0xd31(%rip), %rdx # 0x4146
movl $0x9, %esi
movl $0x70, %ecx
callq 0x2140
testl %eax, %eax
jne 0x3493
leaq 0xbd5(%rip), %rsi # 0x4004
movq %... | /coapp-packages[P]zlib/test/example.c |
test_dict_inflate | void test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
Byte *compr, *uncompr;
uLong comprLen, uncomprLen;
{
int err;
z_stream d_stream; /* decompression stream */
strcpy((char*)uncompr, "garbage");
d_stream.zalloc = zalloc;
d_stream.zfree = zfree;
d_stream.opaque = (voidpf)0;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movabsq $0x65676162726167, %rax # imm = 0x65676162726167
movq %rax, (%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movq $0x0, 0x50(%rax)
movq %rdi, (%rax)
movl %esi, 0x8(%rax)
leaq 0xc5e(%rip), %rsi # 0x4146
movq... | /coapp-packages[P]zlib/test/example.c |
main | int main(argc, argv)
int argc;
char *argv[];
{
Byte *compr, *uncompr;
uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */
uLong uncomprLen = comprLen;
static const char* myVersion = ZLIB_VERSION;
if (zlibVersion()[0] != myVersion[0]) {
fprintf(stderr, "incompatible zli... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %ebp
movq $0x9c40, (%rsp) # imm = 0x9C40
callq 0x21f0
cmpb $0x31, (%rax)
jne 0x3727
callq 0x21f0
leaq 0xb78(%rip), %rsi # 0x4146
movq %rax, %rdi
callq 0x2130
testl %eax, %eax
jne 0x371d
callq 0x2230
leaq 0xd09(%rip), %rdi ... | /coapp-packages[P]zlib/test/example.c |
ted_ub::LGMTreeIndex<cost_model::UnitCostModelLD<label::StringLabel>, node::TreeIndexLGM>::ted_k(node::TreeIndexLGM const&, node::TreeIndexLGM const&, int) | double LGMTreeIndex<CostModel, TreeIndex>::ted_k(const TreeIndex& t1,
const TreeIndex& t2, const int k) {
// Initialize the internals.
init(t2);
// We don't compute the upper bound for node pairs with size lower bound
// greater than threshold.
if (std::abs(t1.tree_size_ - t2.tree_size_) > k) {
retur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rsi
callq 0x5c10
movl (%r14), %eax
subl (%rbx), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl %ebp, %ecx
jle 0x6281
movsd 0x4d89(%rip), %xmm0 # 0xb008
jmp 0x62c... | /DatabaseGroup[P]tree-similarity/src/ted_ub/lgm_tree_index_impl.h |
main | void tst_qpromise_timeout::fulfilled()
{
QElapsedTimer timer;
qint64 elapsed = -1;
timer.start();
auto p = QtPromise::QPromise<int>{[](const QtPromise::QPromiseResolve<int>& resolve) {
QTimer::singleShot(1000, [=]() {
resolve(42);
});
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x17200
movq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rdi
leaq -0x8(%rbp), %rsi
movl $0x60204, %ecx # imm = 0x60204
callq 0x43b0
movl $0x8, %edi
movl $0x1, %esi
callq 0x4350
jmp 0x4512
leaq -0x40(%r... | /simonbrunel[P]qtpromise/tests/auto/qtpromise/qpromise/tst_timeout.cpp |
void QtPromisePrivate::qtpromise_defer<QtPromisePrivate::PromiseDataBase<void, void ()>::dispatch()::'lambda'()>(QtPromisePrivate::PromiseDataBase<void, void ()>::dispatch()::'lambda'()&&, QPointer<QThread> const&) | static void qtpromise_defer(F&& f, const QPointer<QThread>& thread)
{
using FType = typename std::decay<F>::type;
struct Event : public QEvent
{
Event(FType&& f) : QEvent{QEvent::None}, m_f{std::move(f)} { }
Event(const FType& f) : QEvent{QEvent::None}, m_f{f} { }
~Event() override ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19660
cmpq $0x0, %rax
je 0x6f36
movq -0x10(%rbp), %rdi
callq 0x19680
movq %rax, %rdi
callq 0x4280
testb $0x1, %al
jne 0x6f36
jmp 0x6f38
jmp 0x6f97
movq -0x10(%rbp), %rdi
callq 0x19660
movq %rax, %rdi
... | /simonbrunel[P]qtpromise/include/../src/qtpromise/qpromise_p.h |
sx__default_assert_handler | static void sx__default_assert_handler(const char* text, const char* sourcefile, uint32_t line)
{
char output_text[2048];
if (sourcefile) {
sx_snprintf(output_text, sizeof(output_text), "%s(%d): ASSERT FAILURE - ", sourcefile, line);
} else {
sx_strcpy(output_text, sizeof(output_text), "ASSE... | pushq %r14
pushq %rbx
subq $0x808, %rsp # imm = 0x808
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x457a
leaq 0xacb2(%rip), %rdx # 0xf21d
movq %rsp, %rdi
movl $0x800, %esi # imm = 0x800
callq 0x8d82
jmp 0x4596
movl %edx, %r8d
movq %rsi, %rcx
leaq 0xac8e(%rip), %rdx # 0xf215
movq %rsp, %rdi
movl... | /septag[P]sx/src/sx.c |
sx__malloc_cb | static void* sx__malloc_cb(void* ptr, size_t size, uint32_t align, const char* file,
const char* func, uint32_t line, void* user_data)
{
sx_unused(user_data);
sx_unused(line);
sx_unused(func);
sx_unused(file);
if (size == 0) {
if (ptr) {
if (align <= S... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x49dd
movq %rsi, %r14
testq %rbx, %rbx
je 0x49fc
cmpl $0x8, %edx
ja 0x4a12
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4320
testq %rbx, %rbx
je 0x49f5
cmpl $0x8, %edx
jbe 0x49ed
movl -... | /septag[P]sx/src/allocator.c |
sx__malloc_leakd_cb | static void* sx__malloc_leakd_cb(void* ptr, size_t size, uint32_t align, const char* file,
const char* func, uint32_t line, void* user_data)
{
sx_unused(user_data);
if (size == 0) {
if (ptr) {
if (align <= SX_CONFIG_ALLOCATOR_NATURAL_ALIGNMENT) {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x4b74
movq %rsi, %r14
testq %rbx, %rbx
je 0x4b93
cmpl $0x8, %edx
ja 0x4bb6
cmpq %r14, -0x18(%rbx)
jae 0x4ca5
movq %r14, %rdi
movq %rcx, %rsi
movq %r8, %rdx
movl %r9d, %ecx
callq 0x4d55
testq %rax, %rax
je 0x4b8c... | /septag[P]sx/src/allocator.c |
sx_os_dlopen | void* sx_os_dlopen(const char* filepath)
{
#if SX_PLATFORM_WINDOWS
return (void*)LoadLibraryA(filepath);
#elif SX_PLATFORM_EMSCRIPTEN || SX_PLATFORM_PS4 || SX_PLATFORM_XBOXONE || SX_PLATFORM_WINRT
sx_unused(filepath);
return NULL;
#else
return dlopen(filepath, RTLD_LOCAL | RTLD_LAZY);
#endif // SX_PL... | movl $0x1, %esi
jmp 0x4250
| /septag[P]sx/src/os.c |
sx_os_sleep | void sx_os_sleep(int ms)
{
#if SX_PLATFORM_WINDOWS
Sleep(ms);
#else
struct timespec req = { (time_t)ms / 1000, (long)((ms % 1000) * 1000000) };
struct timespec rem = { 0, 0 };
nanosleep(&req, &rem);
#endif // SX_PLATFORM_
} | subq $0x28, %rsp
movslq %edi, %rax
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
movslq %ecx, %rcx
leaq 0x18(%rsp), %rdi
movq %rcx, (%rdi)
imull $0x3e8, %ecx, %ecx # imm = 0x3E8
subl %ecx, %eax
imull $0xf4240, %eax, %eax # imm = 0xF4240
cltq
m... | /septag[P]sx/src/os.c |
sx_os_exec | sx_pinfo sx_os_exec(const char* const* argv)
{
#if SX_PLATFORM_LINUX || SX_PLATFORM_HURD
pid_t pid = fork();
if (0 == pid) {
int result = execvp(argv[0], (char* const*)(&argv[1]));
sx_unused(result);
return (sx_pinfo){ 0 };
}
return (sx_pinfo){ .linux_pid = (uintptr_t)pid };
#e... | pushq %rbx
movq %rdi, %rbx
callq 0x4490
testl %eax, %eax
je 0x4fee
cltq
jmp 0x4fff
movq (%rbx), %rdi
addq $0x8, %rbx
movq %rbx, %rsi
callq 0x4410
xorl %eax, %eax
xorl %edx, %edx
popq %rbx
retq
| /septag[P]sx/src/os.c |
sx_os_del | bool sx_os_del(const char* path, sx_file_type type)
{
sx_assert(type != SX_FILE_TYPE_INVALID);
#if SX_PLATFORM_WINDOWS
if (type == SX_FILE_TYPE_REGULAR)
return DeleteFileA(path) ? true : false;
else
return RemoveDirectoryA(path) ? true : false;
#else
return type == SX_FILE_TYPE_REGULAR ?... | pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %esi
je 0x50d5
testl %esi, %esi
jne 0x50cb
leaq 0x90df(%rip), %rdi # 0xe196
leaq 0x9140(%rip), %rdx # 0xe1fe
movl $0x148, %esi # imm = 0x148
xorl %eax, %eax
callq 0xc102
int3
movq %rbx, %rdi
callq 0x4110
jmp 0x50dd
movq %rbx, %rdi
callq 0x4050
testl %eax, %eax
... | /septag[P]sx/src/os.c |
sx_os_path_exepath | char* sx_os_path_exepath(char* dst, int size)
{
#if SX_PLATFORM_WINDOWS
GetModuleFileName(NULL, dst, size);
return dst;
#elif SX_PLATFORM_LINUX || SX_PLATFORM_RPI
char proc_path[32];
sx_snprintf(proc_path, sizeof(proc_path), "/proc/%d/exe", getpid());
size_t bytes = readlink(proc_path, dst, size);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x40e0
leaq 0x910b(%rip), %rdx # 0xe21b
movq %rsp, %r15
movq %r15, %rdi
movl $0x20, %esi
movl %eax, %ecx
xorl %eax, %eax
callq 0x6b8e
movslq %ebx, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x40c0
movb $0x0, (%r14,%rax)
movq %r... | /septag[P]sx/src/os.c |
sx_os_path_unixpath | char* sx_os_path_unixpath(char* dst, int size, const char* path)
{
int len = sx_strlen(path);
len = sx_min(len, size - 1);
for (int i = 0; i < len; i++) {
if (path[i] != '\\')
dst[i] = path[i];
else
dst[i] = '/';
}
dst[len] = '\0';
return dst;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x8e02
decl %ebp
cmpl %ebp, %eax
cmovll %eax, %ebp
testl %ebp, %ebp
jle 0x5258
movl %ebp, %eax
xorl %ecx, %ecx
movl $0x2f, %edx
movzbl (%r14,%rcx), %esi
cmpb $0x5c, %sil
cmovel %edx, %esi
movb %sil, (%rbx,%rcx)
incq %... | /septag[P]sx/src/os.c |
sx_os_path_winpath | char* sx_os_path_winpath(char* dst, int size, const char* path)
{
int len = sx_strlen(path);
len = sx_min(len, size - 1);
for (int i = 0; i < len; i++) {
if (path[i] != '/')
dst[i] = path[i];
else
dst[i] = '\\';
}
dst[len] = '\0';
return dst;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x8e02
decl %ebp
cmpl %ebp, %eax
cmovll %eax, %ebp
testl %ebp, %ebp
jle 0x52a7
movl %ebp, %eax
xorl %ecx, %ecx
movl $0x5c, %edx
movzbl (%r14,%rcx), %esi
cmpb $0x2f, %sil
cmovel %edx, %esi
movb %sil, (%rbx,%rcx)
incq %... | /septag[P]sx/src/os.c |
sx_os_path_dirname | char* sx_os_path_dirname(char* dst, int size, const char* path)
{
const char* r = sx_strrchar(path, '/');
if (!r)
r = sx_strrchar(path, '\\');
if (r) {
int o = (int)(intptr_t)(r - path);
if (dst == path) {
dst[o] = '\0';
} else {
sx_strncpy(dst, size, ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rdi
movl $0x2f, %esi
callq 0x91c0
testq %rax, %rax
jne 0x533d
movq %r14, %rdi
movl $0x5c, %esi
callq 0x91c0
testq %rax, %rax
je 0x535e
subq %r14, %rax
cmpq %r14, %rbx
je 0x5356
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
mo... | /septag[P]sx/src/os.c |
sx_os_path_normcase | char* sx_os_path_normcase(char* dst, int size, const char* path)
{
#if SX_PLATFORM_WINDOWS
return sx_tolower(dst, size, path);
#else
if (dst != path)
sx_strcpy(dst, size, path);
return dst;
#endif
} | pushq %rbx
movq %rdi, %rbx
cmpq %rdx, %rdi
je 0x55af
movq %rbx, %rdi
callq 0x8d82
movq %rbx, %rax
popq %rbx
retq
| /septag[P]sx/src/os.c |
strpool_internal_add_block | static int strpool_internal_add_block( strpool_t* pool, int size )
{
if( pool->block_count >= pool->block_capacity )
{
pool->block_capacity *= 2;
strpool_internal_block_t* new_blocks = (strpool_internal_block_t*) STRPOOL_MALLOC( pool->memctx,
pool->block_capacity * sizeof( ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl 0x74(%rdi), %eax
movslq 0x70(%rdi), %rsi
cmpl %esi, %eax
jge 0x59c4
movq 0x68(%rbx), %r14
jmp 0x5a2b
leal (%rsi,%rsi), %eax
movl %eax, 0x70(%rbx)
movq (%rbx), %rax
shlq $0x6, %rsi
movq 0x8(%rax), %rcx
movq %rcx, (%rsp)
xorl %edi, %ed... | /septag[P]sx/src/../3rdparty/mattias/strpool.h |
strpool_inject | STRPOOL_U64 strpool_inject( strpool_t* pool, char const* string, int length )
{
if( !string || length < 0 ) return 0;
STRPOOL_U32 hash = strpool_internal_find_in_blocks( pool, string, length );
// If no stored hash, calculate it from data
if( !hash ) hash = strpool_internal_calculate_hash( string, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rsi, %rsi
sete %al
testl %edx, %edx
sets %cl
orb %al, %cl
je 0x6041
xorl %eax, %eax
jmp 0x66cf
movl %edx, %r11d
movslq 0x74(%rdi), %rax
movl %edx, %r10d
testq %rax, %rax
jle 0x6090
movq 0x68(%rdi), %rcx
shlq $0x5, %rax
xorl %edx, ... | /septag[P]sx/src/../3rdparty/mattias/strpool.h |
strpool_decref | int strpool_decref( strpool_t* pool, STRPOOL_U64 handle )
{
strpool_internal_entry_t* entry = strpool_internal_get_entry( pool, handle );
if( entry )
{
STRPOOL_ASSERT( entry->refcount > 0 );
--entry->refcount;
return entry->refcount;
}
return 0;
} | pushq %rax
callq 0x6995
testq %rax, %rax
je 0x6a0f
movq %rax, %rcx
movl 0x18(%rax), %eax
testl %eax, %eax
jle 0x6a13
decl %eax
movl %eax, 0x18(%rcx)
jmp 0x6a11
xorl %eax, %eax
popq %rcx
retq
leaq 0x8056(%rip), %rdi # 0xea70
leaq 0x7e47(%rip), %rsi # 0xe868
leaq 0x805c(%rip), %rcx # 0xea84
movl $0x48a, %e... | /septag[P]sx/src/../3rdparty/mattias/strpool.h |
sx_vsnprintf_alloc | char* sx_vsnprintf_alloc(const sx_alloc* alloc, const char* fmt, va_list args)
{
sx__printf_ctx ctx;
ctx.alloc = alloc;
ctx.buff = NULL;
ctx.len = 0;
stbsp_vsprintfcb(sx__vsnprintf_callback, &ctx, ctx.tmp, fmt, args);
ctx.buff[ctx.len] = '\0';
return ctx.buff;
} | pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %rdx, %r8
movq %rsi, %rcx
leaq 0x1c(%rsp), %rdx
movq %rdi, -0x14(%rdx)
movq $0x0, -0xc(%rdx)
movl $0x0, -0x4(%rdx)
leaq 0x1eda(%rip), %rdi # 0x8caa
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x6df6
movq 0x8(%rbx), %rax
movslq 0x10(%rbx), %rcx
movb $0x0, (%... | /septag[P]sx/src/string.c |
sx_strncpy | char* sx_strncpy(char* SX_RESTRICT dst, int dst_sz, const char* SX_RESTRICT src, int _num)
{
sx_assert(dst);
sx_assert(src);
const int len = sx__strnlen(src, _num);
const int32_t max = dst_sz - 1;
const int32_t num = (len < max ? len : max);
if (num > 0) {
sx_memcpy(dst, src, num);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x8f26
leaq 0x5bde(%rip), %rdi # 0xeaf0
leaq 0x533b(%rip), %rdx # 0xe254
movl $0xd9, %esi
xorl %eax, %eax
callq 0xc102
int3
testq %r14, %r14
je 0x9085
movq %r14, %rax
te... | /septag[P]sx/src/string.c |
sx_strrchar | const char* sx_strrchar(const char* str, char ch)
{
const char *found = NULL, *p;
ch = (uint8_t)ch;
if (ch == '\0')
return sx_strchar(str, '\0');
while ((p = sx_strchar(str, ch)) != NULL) {
found = p;
str = p + 1;
}
return (const char*)found;
} | testb %sil, %sil
je 0x91ed
pushq %r14
pushq %rbx
pushq %rax
xorl %eax, %eax
movsbl %sil, %ebx
movq %rax, %r14
movl %ebx, %esi
callq 0x91f4
leaq 0x1(%rax), %rdi
testq %rax, %rax
jne 0x91cf
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %esi, %esi
jmp 0x91f4
| /septag[P]sx/src/string.c |
sx_strstr | const char* sx_strstr(const char* SX_RESTRICT str, const char* SX_RESTRICT find)
{
sx_assert(str);
sx_assert(find);
char ch = find[0];
const char* _start = sx_strchar(str, ch);
int find_len = sx_strlen(find);
int len = sx_strlen(str);
while (_start) {
// We have the first character... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x934a
leaq 0x57ba(%rip), %rdi # 0xeaf0
leaq 0x5809(%rip), %rdx # 0xeb46
movl $0x15b, %esi # imm = 0x15B
xorl %eax, %eax
callq 0xc102
int3
testq %rbp, %rbp
je 0x9370
mov... | /septag[P]sx/src/string.c |
sx_trim_whitespace | char* sx_trim_whitespace(char* dest, int dest_sz, const char* src)
{
int len = sx_min(sx_strlen(src), dest_sz - 1);
int offset = 0;
for (int i = 0; i < len; i++) {
if (!sx_isspace(src[i]))
dest[offset++] = src[i];
}
dest[offset] = '\0';
return dest;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x8e02
decl %ebp
cmpl %ebp, %eax
cmovll %eax, %ebp
xorl %eax, %eax
testl %ebp, %ebp
jle 0x97b8
movl %ebp, %ecx
movl $0x80001f00, %edx # imm = 0x80001F00
xorl %esi, %esi
movsbl (%r14,%rsi), %edi
leal -0x1(%rdi), ... | /septag[P]sx/src/string.c |
sx_trim | char* sx_trim(char* dest, int dest_sz, const char* src, const char* trim)
{
int len = sx_min(sx_strlen(src), dest_sz - 1);
int offset = 0;
for (int i = 0; i < len; i++) {
const char* t = trim;
char sch = src[i];
bool trim_it = false;
while (*t) {
if (sch != *t) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x8e02
decl %ebp
cmpl %ebp, %eax
cmovll %eax, %ebp
xorl %eax, %eax
testl %ebp, %ebp
jle 0x9822
movl %ebp, %ecx
leaq 0x1(%r14), %rdx
xorl %esi, %esi
movb (%r15,%rsi), %dil
movb (%r... | /septag[P]sx/src/string.c |
sx_replace | char* sx_replace(char* dest, int dest_sz, const char* src, const char* find, const char* replace)
{
sx_assert(dest != src);
char f = find[0];
int flen = sx_strlen(find);
int rlen = sx_strlen(replace);
int srclen = sx_strlen(src);
int offset = 0;
int dest_max = dest_sz - 1;
const char* s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
cmpq %rdx, %rdi
jne 0x98ce
leaq 0x5236(%rip), %rdi # 0xeaf0
leaq 0x5296(%rip), %rdx # 0xeb57
movl $0x23c, %esi # imm = 0x23C
xorl %eax, %... | /septag[P]sx/src/string.c |
sx_EOL_LF | char* sx_EOL_LF(char* dest, int dest_sz, const char* src)
{
assert(dest_sz > 0);
char* end = dest + dest_sz - 1;
for (char ch = *src++; ch != '\0' && dest < end; ch = *src++) {
if ('\r' != ch)
*dest++ = ch;
}
*dest = '\0';
return dest;
} | pushq %rax
testl %esi, %esi
jle 0x9a88
movl %esi, %eax
addq %rdi, %rax
decq %rax
movb (%rdx), %cl
testb %cl, %cl
setne %sil
cmpq %rdi, %rax
seta %r8b
andb %sil, %r8b
cmpb $0x1, %r8b
jne 0x9a80
incq %rdx
cmpb $0xd, %cl
je 0x9a72
movb %cl, (%rdi)
incq %rdi
movb (%rdx), %cl
testb %cl, %cl
je 0x9a80
incq %rdx
cmpq %rax, %r... | /septag[P]sx/src/string.c |
sx_split | bool sx_split(char* dest1, int dest1_sz, char* dest2, int dest2_sz, const char* src, char splitch)
{
const char* sptr = sx_strchar(src, splitch);
if (sptr) {
sx_strncpy(dest1, dest1_sz, src, (int)(uintptr_t)(sptr - src));
sx_strcpy(dest2, dest2_sz, src + 1);
return true;
}
retur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r13
movq %r8, %rdi
movl %r9d, %esi
callq 0x91f4
movq %rax, %r15
testq %rax, %rax
je 0x9af6
movl %r15d, %ecx
subl %ebx, %ecx
movq %r13, %rdi
movl %r12d, %esi
movq %rbx,... | /septag[P]sx/src/string.c |
sx_findblock | sx_str_block sx_findblock(const char* str, char open, char close)
{
int count = 0;
sx_str_block b = { NULL, NULL };
for (char ch = *str; ch && count >= 0; ch = *++str) {
if (!b.start && ch == open) {
b.start = str + 1;
} else if (b.start && ch == close) {
b.end = str... | movb (%rdi), %cl
testb %cl, %cl
je 0x9b4f
incq %rdi
xorl %r8d, %r8d
movq %r8, %rax
testq %r8, %r8
sete %r9b
cmpb %sil, %cl
sete %r10b
movq %rdi, %r8
testb %r10b, %r9b
jne 0x9b41
testq %rax, %rax
je 0x9b3e
cmpb %dl, %cl
je 0x9b57
movq %rax, %r8
jmp 0x9b41
xorl %r8d, %r8d
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x9... | /septag[P]sx/src/string.c |
sx_ishex | bool sx_ishex(const char* str)
{
while (*str) {
if (!sx_ishexchar(*str))
return false;
++str;
}
return true;
} | movb (%rdi), %cl
testb %cl, %cl
je 0x9bc7
incq %rdi
leal -0x41(%rcx), %eax
cmpb $0x1a, %al
setb %al
shlb $0x5, %al
addb %cl, %al
addb $-0x61, %al
cmpb $0x6, %al
setb %dl
addb $-0x30, %cl
cmpb $0xa, %cl
setb %al
orb %dl, %al
je 0x9bc6
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x9b9c
retq
movb $0x1, %al
retq
| /septag[P]sx/src/string.c |
sx_toupper | char* sx_toupper(char* dst, int dst_sz, const char* str)
{
int offset = 0;
int dst_max = dst_sz - 1;
while (*str && offset < dst_max) {
dst[offset++] = sx_toupperchar(*str);
++str;
}
dst[offset] = '\0';
return dst;
} | movq %rdi, %rax
movb (%rdx), %cl
testb %cl, %cl
sete %dil
cmpl $0x2, %esi
setl %r8b
orb %dil, %r8b
jne 0x9c5d
decl %esi
xorl %edi, %edi
leal -0x61(%rcx), %r8d
cmpb $0x1a, %r8b
setae %r8b
shlb $0x5, %r8b
addb %cl, %r8b
addb $-0x20, %r8b
movb %r8b, (%rax,%rdi)
movb 0x1(%rdx,%rdi), %cl
incq %rdi
testb %cl, %cl
je 0x9c5f
c... | /septag[P]sx/src/string.c |
sx_strpool_create | sx_strpool* sx_strpool_create(const sx_alloc* alloc, const sx_strpool_config* conf)
{
strpool_config_t sconf;
sconf.memctx = (void*)alloc;
if (!conf) {
sconf.ignore_case = 0;
sconf.counter_bits = 12;
sconf.index_bits = 20;
sconf.entry_capacity = 4096;
sconf.block_capa... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rax
movq %rdi, 0x10(%rsp)
testq %rsi, %rsi
je 0x9cc7
movups (%rsi), %xmm0
movl 0x10(%rsi), %edx
movl 0x14(%rsi), %ecx
shll $0xa, %ecx
movl 0x18(%rsi), %esi
jmp 0x9cdd
movaps 0x45c2(%rip), %xmm0 # 0xe290
movl $0x17, %esi
movl $0x40000, %ecx # imm = 0x40000
... | /septag[P]sx/src/string.c |
stbsp__clamp_callback | static char *stbsp__clamp_callback(char *buf, void *user, int len)
{
stbsp__context *c = (stbsp__context *)user;
if (len > c->count)
len = c->count;
if (len) {
if (buf != c->buf) {
char *s, *d, *se;
d = c->buf;
s = buf;
se = buf + len;
do {
... | movq %rsi, %rax
movl 0x8(%rsi), %ecx
cmpl %edx, %ecx
cmovll %ecx, %edx
testl %edx, %edx
je 0x9f2a
movq (%rax), %rsi
movslq %edx, %r8
cmpq %rdi, %rsi
je 0x9f1f
leaq (%rdi,%r8), %rcx
movb (%rdi), %r9b
incq %rdi
movb %r9b, (%rsi)
incq %rsi
cmpq %rcx, %rdi
jb 0x9f08
movq (%rax), %rsi
movl 0x8(%rax), %ecx
addq %r8, %rsi
mov... | /septag[P]sx/src/../3rdparty/stb/stb_printf.h |
stbsp__real_to_str | static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits)
{
double d;
stbsp__int64 bits = 0;
stbsp__int32 expo, e, ng, tens;
d = value;
STBSP__COPYFP(bits, d);
expo = (stbsp__int32)((bits >> 52) & 2047... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r13
movq %xmm0, %r11
movq %r11, %rax
shrq $0x34, %rax
andl $0x7ff, %eax # imm = 0x7FF
je 0x9f9e
cmpl $0x7ff, %eax # imm = 0x7FF
jne 0x9fe6
movq %r11, %rax
shlq $0xc, %rax
leaq 0x4da1(%rip... | /septag[P]sx/src/../3rdparty/stb/stb_printf.h |
sx__new_job | static sx__job* sx__new_job(sx_job_context* ctx, int index, sx_job_cb* callback, void* user,
int range_start, int range_end, sx_job_t counter, uint32_t tags,
sx_job_priority priority)
{
sx__job* j = (sx__job*)sx_pool_new(ctx->job_pool);
if (j) {
j... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r14d
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
movl 0x48(%rsp), %eax
movq 0x18(%rdi), %rcx
movq 0x8(%rcx), %rcx
movl 0x18(%rcx), %edx
testl %edx, %edx
jne 0xab88
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0xab... | /septag[P]sx/src/jobs.c |
sx_job_create_context | sx_job_context* sx_job_create_context(const sx_alloc* alloc, const sx_job_context_desc* desc)
{
sx_job_context* ctx = (sx_job_context*)sx_malloc(alloc, sizeof(sx_job_context));
if (!ctx) {
sx_out_of_memory();
return NULL;
}
sx_memset(ctx, 0x0, sizeof(sx_job_context));
ctx->alloc = a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq %rax, (%rsp)
movl $0x1c0, %esi # imm = 0x1C0
xorl %edi, %edi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *(%r14)
testq %rax, %rax
je 0xb5c9
mo... | /septag[P]sx/src/jobs.c |
sx__job_create_tdata | static sx__job_thread_data* sx__job_create_tdata(const sx_alloc* alloc, uint32_t tid, int index,
bool main_thrd)
{
sx__job_thread_data* tdata =
(sx__job_thread_data*)sx_malloc(alloc, sizeof(sx__job_thread_data));
if (!tdata) {
sx_out_of_memory();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r14d
movq %rdi, %rax
movq %rsi, (%rsp)
movl $0x30, %esi
xorl %edi, %edi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *%rax
movq %rax, %rbx
testq %rax, %rax
je 0xb8f9
xorps %xmm0, %xmm0
movups %xm... | /septag[P]sx/src/jobs.c |
sx__del_job | static void sx__del_job(sx_job_context* ctx, sx__job* job)
{
sx_lock(ctx->job_lk) {
sx_pool_del(ctx->job_pool, job);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %eax
xchgl %eax, 0x80(%rdi)
testl %eax, %eax
jne 0xbedf
jmp 0xbef6
pause
movl 0x80(%rbx), %eax
testl %eax, %eax
jne 0xbedd
movl $0x1, %eax
xchgl %eax, 0x80(%rbx)
jmp 0xbed7
movq 0x18(%rbx), %rax
movq 0x8(%rax), %r15
testq ... | /septag[P]sx/src/jobs.c |
sx_thread_create | sx_thread* sx_thread_create(const sx_alloc* alloc, sx_thread_cb* callback, void* user_data1,
int stack_sz, const char* name, void* user_data2)
{
sx_thread* thrd = (sx_thread*)sx_malloc(alloc, sizeof(sx_thread));
if (!thrd)
return NULL;
sx_semaphore_init(&thrd->sem);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r15
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rax
movq 0x8(%rdi), %rcx
movq %rcx, (%rsp)
movl $0xb0, %esi
xorl %edi, %edi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *... | /septag[P]sx/src/threads.c |
thread_fn | static void* thread_fn(void* arg)
{
sx_thread* thrd = (sx_thread*)arg;
union {
void* ptr;
int32_t i;
} cast;
# if SX_PLATFORM_APPLE
if (thrd->name[0])
sx_thread_setname(thrd, thrd->name);
# endif
sx_semaphore_post(&thrd->sem, 1);
cast.i = thrd->callback(thrd->user... | pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0xc7db
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rsi
callq *0x80(%rbx)
movl %eax, %eax
popq %rbx
retq
| /septag[P]sx/src/threads.c |
sx_signal_init | void sx_signal_init(sx_signal* sig)
{
sx__signal* _sig = (sx__signal*)sig->data;
_sig->value = 0;
int r = pthread_mutex_init(&_sig->mutex, NULL);
sx_assertf(r == 0, "pthread_mutex_init failed");
r = pthread_cond_init(&_sig->cond, NULL);
sx_assertf(r == 0, "pthread_cond_init failed");
sx_un... | pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x58(%rdi)
xorl %esi, %esi
callq 0x4470
testl %eax, %eax
je 0xc68d
leaq 0x2bb6(%rip), %rdi # 0xf22f
leaq 0x2cb7(%rip), %rdx # 0xf337
movl $0x161, %esi # imm = 0x161
xorl %eax, %eax
callq 0xc102
int3
addq $0x28, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x42b0
... | /septag[P]sx/src/threads.c |
sx_signal_wait | bool sx_signal_wait(sx_signal* sig, int msecs)
{
sx__signal* _sig = (sx__signal*)sig->data;
int r = pthread_mutex_lock(&_sig->mutex);
sx_assert(r == 0);
if (msecs == -1) {
r = pthread_cond_wait(&_sig->cond, &_sig->mutex);
} else {
struct timespec ts;
clock_gettime(CLOCK_REAL... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x44a0
testl %eax, %eax
je 0xc747
leaq 0x2afc(%rip), %rdi # 0xf22f
leaq 0x2bf6(%rip), %rdx # 0xf330
movl $0x17f, %esi # imm = 0x17F
xorl %eax, %eax
callq 0xc102
int3
cmpl $-0x1, %ebp
je 0xc7ab
movq %rsp, %r14
xo... | /septag[P]sx/src/threads.c |
sx_fiber_stack_init_ptr | void sx_fiber_stack_init_ptr(sx_fiber_stack* fstack, void* ptr, unsigned int size)
{
size_t page_sz = sx_os_pagesz();
sx_unused(page_sz);
sx_assertf((uintptr_t)ptr % page_sz == 0, "buffer size must be dividable to OS page size");
sx_assertf(size % page_sz == 0, "buffer size must be dividable to OS page ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x4e20
movq %rax, %r12
movq %r15, %rax
xorl %edx, %edx
divq %r12
testq %rdx, %rdx
je 0xc976
leaq 0x2a22(%rip), %rdi # 0xf384
leaq 0x2a65(%rip), %rdx # 0xf3ce
movl $0x4b, %esi
xorl %eax, %eax
callq 0xc1... | /septag[P]sx/src/fiber.c |
sx_coro_update | void sx_coro_update(sx_coro_context* ctx, float dt)
{
sx_assert(ctx->cur_coro == NULL);
sx__coro_state* fs = ctx->run_list;
while (fs) {
sx__coro_state* next = fs->next;
// Check state and take action for pending fibers
switch (fs->ret_state) {
case CORO_RET_YIELD: {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0xcfc1
leaq 0x23d7(%rip), %rdi # 0xf384
leaq 0x2504(%rip), %rdx # 0xf4b8
movl $0xf5, %esi
xorl %eax, %eax
callq 0xc102
int3
movq 0x10(%rbx), %r12
testq %r12, %r12
je 0xd048
l... | /septag[P]sx/src/fiber.c |
sx__coro_yield | void sx__coro_yield(sx_coro_context* ctx, sx_fiber_t* pfrom, int nupdates)
{
sx__coro_return(ctx, pfrom, CORO_RET_YIELD, nupdates);
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rax
testq %rax, %rax
jne 0xd42c
leaq 0x1f70(%rip), %rdi # 0xf384
leaq 0x20d3(%rip), %rdx # 0xf4ee
movl $0x135, %esi # imm = 0x135
xorl %eax, %eax
callq 0xc102
int3
movq 0x20(%r14), %rax
movl $0x2, 0x2... | /septag[P]sx/src/fiber.c |
KDReports::Test::vspaceInHeader() | void vspaceInHeader()
{
QFile file(":/vspaceInHeader.xml");
QVERIFY(file.open(QIODevice::ReadOnly));
Report report;
KDReports::ErrorDetails details;
QVERIFY(!report.loadFromXML(&file, &details));
QCOMPARE(details.line(), -1);
QCOMPARE(details.column(), -1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
leaq 0x775f(%rip), %rax # 0x11011
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xc766
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0x53a0
xorps %xmm0, %xmm0
leaq 0x50... | /KDAB[P]KDReports/unittests/XmlParser/XmlParser.cpp |
pugi::impl::(anonymous namespace)::strconv_attribute_impl<pugi::impl::(anonymous namespace)::opt_false>::parse_simple(char*, char) | gap(): end(0), size(0)
{
} | pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0x9f7ff(%rip), %rax # 0xa6680
movq %rdi, %rbx
movzbl (%rdi), %ecx
testb $0x2, (%rcx,%rax)
jne 0x6ebe
movzbl 0x1(%rbx), %ecx
testb $0x2, (%rcx,%rax)
jne 0x6eb5
movzbl 0x2(%rbx), %ecx
testb $0x2, (%rcx,%rax)
jne 0x6eba
movzbl 0x3(%rbx), %ecx
lea... | /JohanSmet[P]lsim/libs/pugixml/src/pugixml.cpp |
pugi::impl::(anonymous namespace)::strconv_attribute_impl<pugi::impl::(anonymous namespace)::opt_true>::parse_simple(char*, char) | static char_t* parse_simple(char_t* s, char_t end_quote)
{
gap g;
while (true)
{
PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr));
if (*s == end_quote)
{
*g.flush(s) = 0;
return s + 1;
}
else if (opt_escape::value && *s == '&')
{
s = strconv_escape(s, g)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %rax
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
leaq 0x9f771(%rip), %r12 # 0xa6680
movq %rax, %r14
movzbl (%rax), %ecx
testb $0x2, (%rcx,%r12)
jne 0x6f53
movzbl 0x1(%r14), %ecx
testb $0x2, (%rcx,%r12)
jne 0x6f4a
mov... | /JohanSmet[P]lsim/libs/pugixml/src/pugixml.cpp |
pugi::impl::(anonymous namespace)::strconv_attribute_impl<pugi::impl::(anonymous namespace)::opt_true>::parse_eol(char*, char) | static char_t* parse_eol(char_t* s, char_t end_quote)
{
gap g;
while (true)
{
PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr));
if (*s == end_quote)
{
*g.flush(s) = 0;
return s + 1;
}
else if (*s == '\r')
{
*s++ = '\n';
if (*s == '\n') g.push(s, 1)... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %rax
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x9f59f(%rip), %r12 # 0xa6680
movzbl (%rax), %ecx
testb $0x2, (%rcx,%r12)
jne 0x71bf
addq $0x2, %rax
movq %rax, %r15
movzbl -0x1(%r15), %ecx
testb $0x2... | /JohanSmet[P]lsim/libs/pugixml/src/pugixml.cpp |
pugi::impl::(anonymous namespace)::strconv_attribute_impl<pugi::impl::(anonymous namespace)::opt_true>::parse_wnorm(char*, char) | static char_t* parse_wnorm(char_t* s, char_t end_quote)
{
gap g;
// trim leading whitespaces
if (PUGI__IS_CHARTYPE(*s, ct_space))
{
char_t* str = s;
do ++str;
while (PUGI__IS_CHARTYPE(*str, ct_space));
g.push(s, str - s);
}
while (true)
{
PUGI__SCANWHILE_UNROLL(!PUGI__IS_C... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movzbl (%rdi), %eax
leaq 0x9f02e(%rip), %r13 # 0xa6680
testb $0x8, (%rax,%r13)
je 0x7677
xorl %eax, %eax
movzbl 0x1(%r12,%rax), %ecx
incq %rax
testb $0x8, (%rcx,... | /JohanSmet[P]lsim/libs/pugixml/src/pugixml.cpp |
pugi::impl::(anonymous namespace)::strconv_pcdata_impl<pugi::impl::(anonymous namespace)::opt_false, pugi::impl::(anonymous namespace)::opt_true, pugi::impl::(anonymous namespace)::opt_false>::parse(char*) | static char_t* parse(char_t* s)
{
gap g;
char_t* begin = s;
while (true)
{
PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_pcdata));
if (*s == '<') // PCDATA ends here
{
char_t* end = g.flush(s);
if (opt_trim::value)
while (end > begin && PUGI__IS_CHARTYPE(end[-1], c... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rdx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0x9ed4c(%rip), %r14 # 0xa6680
movzbl (%rdx), %eax
testb $0x1, (%rax,%r14)
jne 0x79e8
addq $0x2, %rdx
movq %rdx, %rbx
movzbl -0x1(%rbx), %eax
testb $0x1, (%rax,%r14)
jne 0x797e
movzbl (%rbx), %eax
testb $0x... | /JohanSmet[P]lsim/libs/pugixml/src/pugixml.cpp |
pugi::impl::(anonymous namespace)::strconv_cdata(char*, char) | PUGI__FN char_t* strconv_cdata(char_t* s, char_t endch)
{
gap g;
while (true)
{
PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_cdata));
if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
{
*s++ = '\n'; // replace first one with 0x0a
if (*s == '\n') g.push(s, 1);
}
else if... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %rdx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0x9e62e(%rip), %r15 # 0xa6680
xorb $0x3e, %bl
movzbl (%rdx), %eax
testb $0x10, (%rax,%r15)
jne 0x8133
addq $0x2, %rdx
movq %rdx, %r14
movzbl -0x1(%r14), %eax
testb $0x10, (%rax,%... | /JohanSmet[P]lsim/libs/pugixml/src/pugixml.cpp |
ImGui::StyleColorsDark(ImGuiStyle*) | void ImGui::StyleColorsDark(ImGuiStyle* dst)
{
ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
ImVec4* colors = style->Colors;
colors[ImGuiCol_Text] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
colors[ImGuiCol_TextDisabled] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
colors[ImGui... | pushq %rax
testq %rdi, %rdi
jne 0x889a
callq 0x1e7da
movq %rax, %rdi
movaps 0x8576f(%rip), %xmm0 # 0x8e010
movups %xmm0, 0xa8(%rdi)
movaps 0x85771(%rip), %xmm0 # 0x8e020
movups %xmm0, 0xb8(%rdi)
movaps 0x85773(%rip), %xmm0 # 0x8e030
movups %xmm0, 0xc8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rdi)
movaps 0x... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImGui::StyleColorsLight(ImGuiStyle*) | void ImGui::StyleColorsLight(ImGuiStyle* dst)
{
ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
ImVec4* colors = style->Colors;
colors[ImGuiCol_Text] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
colors[ImGuiCol_TextDisabled] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
colors[ImGu... | pushq %rax
testq %rdi, %rdi
jne 0x8dac
callq 0x1e7da
movq %rax, %rdi
movaps 0x856ed(%rip), %xmm0 # 0x8e4a0
movups %xmm0, 0xa8(%rdi)
movaps 0x854bf(%rip), %xmm0 # 0x8e280
movups %xmm0, 0xb8(%rdi)
movaps 0x856e1(%rip), %xmm0 # 0x8e4b0
movups %xmm0, 0xc8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rdi)
movaps 0x... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawListSharedData::ImDrawListSharedData() | ImDrawListSharedData::ImDrawListSharedData()
{
Font = NULL;
FontSize = 0.0f;
CurveTessellationTol = 0.0f;
ClipRectFullscreen = ImVec4(-8192.0f, -8192.0f, +8192.0f, +8192.0f);
// Const data
for (int i = 0; i < IM_ARRAYSIZE(CircleVtx12); i++)
{
const float a = ((float)i * 2 * IM_PI) /... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x88, %edx
xorl %esi, %esi
callq 0x6290
movaps 0x855f9(%rip), %xmm0 # 0x8e630
movups %xmm0, 0x18(%rbx)
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
addss %xmm0, %xmm0
mulss 0x857c1(%rip), %xmm0 # 0x8e810
divss 0x857bd(%rip), %xmm0 # 0x8e814
m... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawList::AddDrawCmd() | void ImDrawList::AddDrawCmd()
{
ImDrawCmd draw_cmd;
draw_cmd.ClipRect = GetCurrentClipRect();
draw_cmd.TextureId = GetCurrentTextureId();
IM_ASSERT(draw_cmd.ClipRect.x <= draw_cmd.ClipRect.z && draw_cmd.ClipRect.y <= draw_cmd.ClipRect.w);
CmdBuffer.push_back(draw_cmd);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movslq 0x60(%rdi), %rax
movq 0x38(%rdi), %rcx
movq 0x68(%rdi), %rdx
movq %rax, %rsi
shlq $0x4, %rsi
addq $0x18, %rcx
testq %rax, %rax
leaq -0x10(%rdx,%rsi), %rax
cmoveq %rcx, %rax
movups (%rax), %xmm2
movslq 0x70(%rdi), %rax
testq %rax, %rax
j... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawList::UpdateClipRect() | void ImDrawList::UpdateClipRect()
{
// If current command is used with different settings we need to add a new command
const ImVec4 curr_clip_rect = GetCurrentClipRect();
ImDrawCmd* curr_cmd = CmdBuffer.Size > 0 ? &CmdBuffer.Data[CmdBuffer.Size-1] : NULL;
if (!curr_cmd || (curr_cmd->ElemCount != 0 && me... | movslq 0x60(%rdi), %rax
movq 0x38(%rdi), %rcx
movq 0x68(%rdi), %rdx
movq %rax, %rsi
shlq $0x4, %rsi
addq $0x18, %rcx
testq %rax, %rax
leaq -0x10(%rdx,%rsi), %rax
cmoveq %rcx, %rax
movdqu (%rax), %xmm0
movdqa %xmm0, -0x18(%rsp)
movslq (%rdi), %rcx
testq %rcx, %rcx
setle %r8b
leaq (%rcx,%rcx,2), %rdx
shlq $0x4, %rdx
addq... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawList::UpdateTextureID() | void ImDrawList::UpdateTextureID()
{
// If current command is used with different settings we need to add a new command
const ImTextureID curr_texture_id = GetCurrentTextureId();
ImDrawCmd* curr_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL;
if (!curr_cmd || (curr_cmd->ElemCount != 0 && curr_cmd->Text... | movslq 0x70(%rdi), %rax
testq %rax, %rax
je 0x993e
movq 0x78(%rdi), %rcx
movq -0x8(%rcx,%rax,8), %rax
jmp 0x9940
xorl %eax, %eax
movl (%rdi), %ecx
testq %rcx, %rcx
je 0x9686
testl %ecx, %ecx
jle 0x99e3
leaq (%rcx,%rcx,2), %rdx
shlq $0x4, %rdx
addq 0x8(%rdi), %rdx
movq %rdx, %rsi
addq $-0x30, %rsi
je 0x9686
movl (%rsi),... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawList::PushClipRect(ImVec2, ImVec2, bool) | void ImDrawList::PushClipRect(ImVec2 cr_min, ImVec2 cr_max, bool intersect_with_current_clip_rect)
{
ImVec4 cr(cr_min.x, cr_min.y, cr_max.x, cr_max.y);
if (intersect_with_current_clip_rect && _ClipRectStack.Size)
{
ImVec4 current = _ClipRectStack.Data[_ClipRectStack.Size-1];
if (cr.x < curre... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movaps %xmm1, %xmm5
shufps $0x55, %xmm1, %xmm5 # xmm5 = xmm5[1,1],xmm1[1,1]
movl 0x60(%rdi), %eax
testl %esi, %esi
je 0x9a4f
testl %eax, %eax
je 0x9a7c
movslq %eax, %rcx
movq 0x68(%rbx), %rdx
shlq $0x4, %rcx
movss -0x8(%rdx,%rcx), %xmm3
movss -0x4(%r... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawList::PushTextureID(void*) | void ImDrawList::PushTextureID(ImTextureID texture_id)
{
_TextureIdStack.push_back(texture_id);
UpdateTextureID();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x70(%rdi), %eax
cmpl 0x74(%rdi), %eax
jne 0x9bdb
leal 0x1(%rax), %ebp
testl %eax, %eax
je 0x9be1
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x9be6
movq 0x78(%rbx), %r15
jmp 0x9c26
movl $0x8, ... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawList::ChannelsSplit(int) | void ImDrawList::ChannelsSplit(int channels_count)
{
IM_ASSERT(_ChannelsCurrent == 0 && _ChannelsCount == 1);
int old_channels_count = _Channels.Size;
if (old_channels_count < channels_count)
_Channels.resize(channels_count);
_ChannelsCount = channels_count;
// _Channels[] (24/32 bytes each... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, 0x90(%rdi)
jne 0x9fdc
movq %rdi, %rbx
cmpl $0x1, 0x94(%rdi)
jne 0x9fdc
movl %esi, %ebp
movl 0x98(%rbx), %r15d
movl %r15d, %eax
cmpl %esi, %r15d
jge 0x9d2d
movl 0x9c(%rbx), %eax
cmpl %ebp, %eax
jge 0x9d25
testl %eax, %eax
je 0x... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawList::ChannelsMerge() | void ImDrawList::ChannelsMerge()
{
// Note that we never use or rely on channels.Size because it is merely a buffer that we never shrink back to 0 to keep all sub-buffers ready for use.
if (_ChannelsCount <= 1)
return;
ChannelsSetCurrent(0);
if (CmdBuffer.Size && CmdBuffer.back().ElemCount == 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, 0x94(%rdi)
jl 0xa292
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %esi, %esi
callq 0xa2e0
movl (%rbx), %eax
movl $0x0, %r12d
testq %rax, %rax
je 0xa055
testl %eax, %eax
jle 0xa2c0
movq 0x8(%rbx), %rcx
leaq (%rax,%rax,2), %rdx
shlq $0x4, %... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawList::ChannelsSetCurrent(int) | void ImDrawList::ChannelsSetCurrent(int idx)
{
IM_ASSERT(idx < _ChannelsCount);
if (_ChannelsCurrent == idx) return;
memcpy(&_Channels.Data[_ChannelsCurrent].CmdBuffer, &CmdBuffer, sizeof(CmdBuffer)); // copy 12 bytes, four times
memcpy(&_Channels.Data[_ChannelsCurrent].IdxBuffer, &IdxBuffer, sizeof(Idx... | cmpl %esi, 0x94(%rdi)
jle 0xa354
movslq 0x90(%rdi), %rax
cmpl %esi, %eax
je 0xa353
movq 0xa0(%rdi), %rcx
shlq $0x5, %rax
movups (%rdi), %xmm0
movups %xmm0, (%rcx,%rax)
movq 0xa0(%rdi), %rax
movslq 0x90(%rdi), %rcx
shlq $0x5, %rcx
movups 0x10(%rdi), %xmm0
movups %xmm0, 0x10(%rax,%rcx)
movl %esi, 0x90(%rdi)
movq 0xa0(%rd... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawList::PrimRect(ImVec2 const&, ImVec2 const&, unsigned int) | void ImDrawList::PrimRect(const ImVec2& a, const ImVec2& c, ImU32 col)
{
ImVec2 b(c.x, a.y), d(a.x, c.y), uv(_Data->TexUvWhitePixel);
ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;
_IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (ImDrawIdx)(idx+2);
_IdxWritePtr[3] = idx; _IdxW... | pushq %rbp
pushq %r14
pushq %rbx
movl (%rsi), %eax
movl 0x4(%rsi), %r10d
movl (%rdx), %r11d
movl 0x4(%rdx), %r8d
movq 0x38(%rdi), %r9
movq (%r9), %r9
movl 0x48(%rdi), %ebx
movq 0x58(%rdi), %r14
movw %bx, (%r14)
leal 0x1(%rbx), %ebp
movw %bp, 0x2(%r14)
leal 0x2(%rbx), %ebp
movw %bp, 0x4(%r14)
movw %bx, 0x6(%r14)
movw %b... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawList::PrimRectUV(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int) | void ImDrawList::PrimRectUV(const ImVec2& a, const ImVec2& c, const ImVec2& uv_a, const ImVec2& uv_c, ImU32 col)
{
ImVec2 b(c.x, a.y), d(a.x, c.y), uv_b(uv_c.x, uv_a.y), uv_d(uv_a.x, uv_c.y);
ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;
_IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl (%rsi), %eax
movl %eax, -0x4(%rsp)
movl 0x4(%rsi), %ebp
movl (%rdx), %r15d
movl 0x4(%rdx), %r11d
movl (%rcx), %eax
movl %eax, -0x8(%rsp)
movl 0x4(%rcx), %r14d
movl (%r8), %r12d
movl 0x4(%r8), %ebx
movl 0x48(%rdi), %r13d
movq 0x58(%rdi), %rax
movw %r... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawList::PrimQuadUV(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int) | void ImDrawList::PrimQuadUV(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a, const ImVec2& uv_b, const ImVec2& uv_c, const ImVec2& uv_d, ImU32 col)
{
ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;
_IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %r11
movq 0x28(%rsp), %rbx
movl 0x40(%rsp), %r10d
movl 0x48(%rdi), %r14d
movq 0x58(%rdi), %r15
movw %r14w, (%r15)
leal 0x1(%r14), %ebp
movw %bp, 0x2(%r15)
leal 0x2(%r14), %ebp
movw %bp, 0x4(%r15)
movw %r14w, 0x6(%r15)
movw %bp, 0x8(%r15)... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawList::PathArcToFast(ImVec2 const&, float, int, int) | void ImDrawList::PathArcToFast(const ImVec2& centre, float radius, int a_min_of_12, int a_max_of_12)
{
if (radius == 0.0f || a_min_of_12 > a_max_of_12)
{
_Path.push_back(centre);
return;
}
_Path.reserve(_Path.Size + (a_max_of_12 - a_min_of_12 + 1));
for (int a = a_min_of_12; a <= a_m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
setp %al
setne %dl
orb %al, %dl
subl %r15d, %ecx
setge %sil
movl 0x80(%rdi), %eax
testb %sil, %dl
jne 0xb1b4
cmpl 0x84(%rbx), %eax
j... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImDrawList::PathRect(ImVec2 const&, ImVec2 const&, float, int) | void ImDrawList::PathRect(const ImVec2& a, const ImVec2& b, float rounding, int rounding_corners)
{
rounding = ImMin(rounding, ImFabs(b.x - a.x) * ( ((rounding_corners & ImDrawCornerFlags_Top) == ImDrawCornerFlags_Top) || ((rounding_corners & ImDrawCornerFlags_Bot) == ImDrawCornerFlags_Bot) ? 0.5f : 1.0f ) - ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %ecx, %eax
notl %eax
movss 0x82c87(%rip), %xmm1 # 0x8e820
movss 0x82c77(%rip), %xmm2 # 0x8e818
movaps %xmm1, %xmm4
testb $0xc, %al
je 0xbbab
movaps %xmm2, %xmm4
movaps %xmm1, %xm... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImFontAtlas::ImFontAtlas() | ImFontAtlas::ImFontAtlas()
{
Locked = false;
Flags = ImFontAtlasFlags_None;
TexID = (ImTextureID)NULL;
TexDesiredWidth = 0;
TexGlyphPadding = 1;
TexPixelsAlpha8 = NULL;
TexPixelsRGBA32 = NULL;
TexWidth = TexHeight = 0;
TexUvScale = ImVec2(0.0f, 0.0f);
TexUvWhitePixel = ImVec2(0.... | movb $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movl $0x1, 0x14(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq $0x0, 0x38(%rdi)
movl $0xffffffff, 0x70(%rdi) # imm = 0xFFFFFFFF
retq
nop
| /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
ImFontAtlas::AddCustomRectFontGlyph(ImFont*, unsigned short, int, int, float, ImVec2 const&) | int ImFontAtlas::AddCustomRectFontGlyph(ImFont* font, ImWchar id, int width, int height, float advance_x, const ImVec2& offset)
{
IM_ASSERT(font != NULL);
IM_ASSERT(width > 0 && width <= 0xFFFF);
IM_ASSERT(height > 0 && height <= 0xFFFF);
CustomRect r;
r.ID = id;
r.Width = (unsigned short)width;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0xf418
movl %ecx, %r12d
leal -0x1(%r12), %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jae 0xf437
movl %r8d, %r15d
leal -0x1(%r15), %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jae 0xf456
movq %rsi, %r14
movq %... | /JohanSmet[P]lsim/src/gui/imgui/imgui_draw.cpp |
stbtt__find_table(unsigned char*, unsigned int, char const*) | static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)
{
stbtt_int32 num_tables = ttUSHORT(data+fontstart+4);
stbtt_uint32 tabledir = fontstart + 12;
stbtt_int32 i;
for (i=0; i < num_tables; ++i) {
stbtt_uint32 loc = tabledir + 16*i;
if (stbtt_tag(data+... | movl %esi, %eax
movzwl 0x4(%rdi,%rax), %ecx
rolw $0x8, %cx
xorl %eax, %eax
testw %cx, %cx
je 0x160b1
movzwl %cx, %r8d
movsbl (%rdx), %ecx
movl %r8d, %r8d
addl $0xc, %esi
movl %esi, %esi
movzbl (%rdi,%rsi), %r9d
cmpl %ecx, %r9d
jne 0x160a9
movzbl 0x1(%rdi,%rsi), %r9d
movsbl 0x1(%rdx), %r10d
cmpl %r10d, %r9d
jne 0x160a9
... | /JohanSmet[P]lsim/src/gui/imgui/imstb_truetype.h |
stbtt__run_charstring(stbtt_fontinfo const*, int, stbtt__csctx*) | static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c)
{
int in_header = 1, maskbits = 0, subr_stack_height = 0, sp = 0, v, i, b0;
int has_subrs = 0, clear_stack;
float s[48];
stbtt__buf subr_stack[10], subrs = info->subrs, b;
float f;
#define STBTT__CSERR(s) (0)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movq 0x70(%rdi), %r12
movq 0x78(%rdi), %rax
movq %rax, 0x148(%rsp)
movq 0x50(%rdi), %rdi
movq 0x58(%r15), %rsi
movl %r14d, %edx
callq 0x161ea
movq %rax, 0x10(%rsp... | /JohanSmet[P]lsim/src/gui/imgui/imstb_truetype.h |
ImGuiIO::AddInputCharacter(unsigned short) | void ImGuiIO::AddInputCharacter(ImWchar c)
{
InputQueueCharacters.push_back(c);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x1540(%rdi), %eax
cmpl 0x1544(%rdi), %eax
jne 0x19367
leal 0x1(%rax), %r15d
testl %eax, %eax
je 0x19373
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x19378
movq 0x1548(%rbx), %r14
jmp 0x19404
... | /JohanSmet[P]lsim/src/gui/imgui/imgui.cpp |
ImGui::DestroyContext(ImGuiContext*) | void ImGui::DestroyContext(ImGuiContext* ctx)
{
if (ctx == NULL)
ctx = GImGui;
Shutdown(ctx);
if (GImGui == ctx)
SetCurrentContext(NULL);
IM_DELETE(ctx);
} | pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x1e2f2
movq 0xb191e(%rip), %rbx # 0xcfc10
movq %rbx, %rdi
callq 0x1e317
cmpq %rbx, 0xb190f(%rip) # 0xcfc10
jne 0x1e30e
movq $0x0, 0xb1902(%rip) # 0xcfc10
movq %rbx, %rdi
popq %rbx
jmp 0x31e2e
| /JohanSmet[P]lsim/src/gui/imgui/imgui.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.