name string | code string | asm string | file string |
|---|---|---|---|
spdlog::details::c_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 24;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::append_string_view(days[static_cast<size_t>(tm_time.tm_wday)], dest);
dest.push_back(' ');
fmt_h... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x8(%rdi), %rdx
leaq 0x40(%rsp), %rdi
movl $0x18, %esi
callq 0x3da0a
movslq 0x18(%r14), %rax
leaq 0x9468d(%rip), %rcx # 0xd2608
movq (%rcx,%rax,8), %r15
movq %r15, %rdi
callq 0x17250
leaq (%rax,%r15), %rdx
movq %rbx, %... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::d_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_mday, dest);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x8(%rdi), %rdx
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x3da0a
movl 0xc(%r14), %r14d
cmpq $0x63, %r14
ja 0x3ea18
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x3e9be
movq (%rbx), %rax
movq %rbx, %rdi
callq... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::R_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 5;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_hour, dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_min, dest);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x8(%rdi), %rdx
leaq 0x18(%rsp), %rdi
movl $0x5, %esi
callq 0x3da0a
movl 0x8(%r14), %r15d
cmpq $0x63, %r15
ja 0x3f818
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x3f7be
movq (%rbx), %rax
movq %rbx... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::t_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
{
const auto field_size = ScopedPadder::count_digits(msg.thread_id);
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::append_int(msg.thread_id, dest);
} | subq $0x28, %rsp
movq 0x20(%rsi), %r8
leaq 0x1d(%rsp), %rsi
leaq 0x569e5(%rip), %rdi # 0x9742b
cmpq $0x64, %r8
jb 0x40a89
movabsq $0x28f5c28f5c28f5c3, %r9 # imm = 0x28F5C28F5C28F5C3
movq %r8, %rax
shrq $0x2, %rax
mulq %r9
shrq $0x2, %rdx
imulq $0x64, %rdx, %rax
movq %r8, %r10
subq %rax, %r10
movzwl (%rdi,%r10,2), %... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::C_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_year % 100, dest);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movslq 0x14(%rdx), %rax
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
cmpl $0x63, %eax
ja 0x4108b
movzbl %al, %ebp
imull $0xcd, %ebp, %r14d
shrl ... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::D_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 10;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_mon + 1, dest);
dest.push_back('/');
fmt_helper::pad2(tm_time.tm_mday, dest);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl 0x10(%rdx), %eax
incl %eax
cmpl $0x63, %eax
ja 0x411ba
movzbl %al, %ebp
imull $0xcd, %ebp, %r15d
shrl $0xb, %r15d
leal (%r15,%r15), %eax
leal (%rax,%rax,4), %eax
subb %al, %bpl
orb $0x30, %r15b
movq 0x10(%rbx), ... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::I_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(to12h(tm_time), dest);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movl 0x8(%rdx), %ecx
leal -0xc(%rcx), %eax
cmpl $0xd, %ecx
cmovll %ecx, %eax
cmpl $0x63, %eax
ja 0x41744
movzbl %al, %ebp
imull $0xcd, %ebp, %r14d
shrl $0xb, %r14d
leal (%r14,%r14), %eax
leal (%rax,%rax,4), %eax
subb %al, %bpl
orb $0x30, %r14b
movq 0x10(... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::M_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_min, dest);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movl 0x4(%rdx), %r14d
cmpq $0x63, %r14
ja 0x41829
movzbl %r14b, %eax
imull $0xcd, %eax, %r15d
shrl $0xb, %r15d
leal (%r15,%r15), %eax
leal (%rax,%rax,4), %eax
subb %al, %r14b
orb $0x30, %r15b
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rb... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
util_shortname | const char *
util_shortname(
const char *path)
{
const char *ret;
if (!path) {
fprintf(stderr, "%s: NULL path passed to short_name\n", argv0);
abort();
}
ret = strrchr(path, '/');
#ifdef _WIN32
{
const char *p = strrchr(path, '\\');
ret = MAX(ret, p);
}
#endif... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x9637
movq 0x569d6(%rip), %rax # 0x5fff0
movq (%rax), %rdi
movq 0x56bf4(%rip), %rdx # 0x60218
leaq 0x42bbf(%rip), %rsi # 0x4c1ea
movb $0x0, %al
callq 0x4250
callq 0x4040
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq ... | /thpatch[P]thtk/util/program.c |
util_scan_files | int
util_scan_files(
const char* dir,
char*** result)
{
struct stat stat_buf;
if (stat(dir, &stat_buf) == -1)
return -1;
// We can only scan directories
if (!S_ISDIR(stat_buf.st_mode))
return -1;
struct dirent **files;
int n;
n = scandir(dir, &files, util_scan_files_... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x4270
cmpl $-0x1, %eax
jne 0x9bf4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa01a
movl -0x90(%rbp), %eax
andl $0xf000, %eax # imm ... | /thpatch[P]thtk/util/util.c |
value_size | ssize_t
value_size(
const value_t* value)
{
switch (value->type) {
case 'f':
return sizeof(float);
case 'd':
return sizeof(double);
case 'b':
return sizeof(unsigned char);
case 'c':
return sizeof(char);
case 'u':
return sizeof(uint16_t);
case 's':
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $-0x43, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x37, %eax
ja 0xb3df
movq -0x18(%rbp), %rax
leaq 0x41839(%rip), %rcx # 0x4cb88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x4, -... | /thpatch[P]thtk/util/value.c |
rank::Rank::Rank(std::vector<rank::KeyValue, std::allocator<rank::KeyValue>> const&) | Rank::Rank(const std::vector<KeyValue>& key_values) {
_dirty = true;
_entries.reserve(key_values.size());
for (auto &kv: key_values) { _entries.push_back(kv); }
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movb $0x1, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x78(%rbp)
callq 0x35b40
movq -0x80(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rdi
callq 0x35c60
movq -0x78(%rbp), %rdi
movq %rax, %rs... | /laurolins[P]topkube_benchmark/src/rank.cc |
topk_algorithms::ThresholdAlgorithmInstance::ranks_str[abi:cxx11]() const | std::string ThresholdAlgorithmInstance::ranks_str() const {
std::vector<Count> ranks;
for (auto i=0;i<_rms_list.size();++i) { ranks.push_back(_rms_list.rank(i)->size()); }
std::sort(ranks.begin(), ranks.end(), [](Count a, Count b) { return a > b; });
std::stringstream ss;
bool fi... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %rdi, -0x228(%rbp)
movq %rdi, %rax
movq %rax, -0x220(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x218(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x411d0
movl $0x0, -0x2c(%rbp)
movq -0x218(%rbp), %rdi
movslq -0x... | /laurolins[P]topkube_benchmark/src/topk_algorithms.cc |
topk_algorithms::ta_zipf_instance_sample(unsigned long, unsigned long, unsigned long)::Entry::Entry(unsigned long, unsigned long, unsigned long) | Entry(Index r, Index c, Value v):
row(r), column(c), value(v)
{
key = std::to_string(row) + std::string(":") + std::to_string(column);
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
callq 0x27420
movq -0xe0(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %... | /laurolins[P]topkube_benchmark/src/topk_algorithms.cc |
main | int main(int argc, char* argv[]) {
Timer timer;
timer.tic();
xLearn::Solver solver;
solver.SetPredict();
solver.Initialize(argc, argv);
solver.StartWork();
solver.Clear();
Color::print_info(
StringPrintf("Total time cost: %.2f (sec)",
timer.toc()), false);
return 0;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x2e0, %rsp # imm = 0x2E0
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x55f98
movq %r14, %rdi
callq 0x55fd0
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x2a4fe
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x220(%r14)
vmovups %ymm0, 0x210(%r1... | /aksnzhy[P]xlearn/src/solver/predict_main.cc |
void ReadVectorFromFile<float>(_IO_FILE*, std::vector<float, std::allocator<float>>&) | void ReadVectorFromFile(FILE *file_ptr, std::vector<T> &vec) {
CHECK_NOTNULL(file_ptr);
// First, read the length of vector
size_t len = 0;
ReadDataFromDisk(file_ptr, reinterpret_cast<char *>(&len), sizeof(len));
CHECK_GT(len, 0);
// Clear the original vector
std::vector<T>().swap(vec);
vec.resize(len);... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
testq %rdi, %rdi
je 0x3e5f5
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq $0x0, (%r15)
movl $0x8, %edx
movq %r15, %rsi
callq 0x3c6f1
cmpq $0x0, (%r15)
je 0x3e6fe
movq (%r14), %rdi
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
testq %rdi, ... | /aksnzhy[P]xlearn/src/base/file_util.h |
xLearn::FFMParser::Parse(char*, unsigned long, xLearn::DMatrix&, bool) | void FFMParser::Parse(char* buf,
uint64 size,
DMatrix& matrix,
bool reset) {
CHECK_NOTNULL(buf);
CHECK_GT(size, 0);
// Clear the data matrix
if (reset) {
matrix.Reset();
}
// Parse every line
uint64 pos = 0;
for (;;) {
uint64 ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x10(%rsp)
movq %rsi, 0x70(%rsp)
testq %rsi, %rsi
je 0x4076f
movq %rdx, %rbx
testq %rdx, %rdx
je 0x4087b
movq %rdi, %r12
testb %r8b, %r8b
je 0x40548
movq 0x10(%rsp), %rdi
callq 0x3e13a
xorl %r14d, %r14d
leaq 0x2e0ee(%rip), %r1... | /aksnzhy[P]xlearn/src/reader/parser.cc |
xLearn::CSVParser::Parse(char*, unsigned long, xLearn::DMatrix&, bool) | void CSVParser::Parse(char* buf,
uint64 size,
DMatrix& matrix,
bool reset) {
CHECK_NOTNULL(buf);
CHECK_GT(size, 0);
// Clear the data matrix
if (reset) {
matrix.Reset();
}
// Parse every line
uint64 pos = 0;
std::vector<std::stri... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x70(%rsp)
testq %rsi, %rsi
je 0x40c26
movq %rdx, %r14
testq %rdx, %rdx
je 0x40d32
movq %rcx, %rbx
testb %r8b, %r8b
je 0x40a54
movq %rbx, %rdi
callq 0x3e13a
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %ra... | /aksnzhy[P]xlearn/src/reader/parser.cc |
xLearn::DMatrix::AddRow() | void AddRow() {
this->Y.push_back(0);
this->norm.push_back(1.0);
this->row.push_back(nullptr);
row_length++;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x0, 0x8(%rsp)
movq 0x38(%rdi), %rsi
cmpq 0x40(%rdi), %rsi
je 0x40fa2
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x40fb0
leaq 0x30(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x41708
movl $0x3f800000, 0x8(%rsp) # imm = 0x3F800000
movq 0x50(%rbx), %rsi
cmpq ... | /aksnzhy[P]xlearn/src/data/data_structure.h |
xLearn::FFMParser::~FFMParser() | ~FFMParser() { } | pushq %rbx
movq %rdi, %rbx
leaq 0x2bd55(%rip), %rax # 0x6cff8
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x412b8
callq 0x28450
movq %rbx, %rdi
popq %rbx
jmp 0x28450
nop
| /aksnzhy[P]xlearn/src/reader/parser.h |
xLearn::CSVParser::~CSVParser() | ~CSVParser() { } | pushq %rbx
movq %rdi, %rbx
leaq 0x2bd0b(%rip), %rax # 0x6cff8
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x41302
callq 0x28450
movq %rbx, %rdi
popq %rbx
jmp 0x28450
nop
| /aksnzhy[P]xlearn/src/reader/parser.h |
xLearn::pred_thread(xLearn::DMatrix const*, xLearn::Model*, std::vector<float, std::allocator<float>>*, xLearn::Score*, bool, unsigned long, unsigned long) | void pred_thread(const DMatrix* matrix,
Model* model,
std::vector<real_t>* pred,
Score* score_func_,
bool is_norm,
size_t start_idx,
size_t end_idx) {
CHECK_GE(end_idx, start_idx);
for (size_t i = start_idx; i < en... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
cmpq %r9, 0x80(%rsp)
jb 0x41aec
jbe 0x41add
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
vmovss 0x1946f(%rip), %xmm0 # 0x5af14
testb %bpl, %bpl
je 0x41ab3
movq 0x48(%r14), %rax
vmovss ... | /aksnzhy[P]xlearn/src/loss/loss.cc |
xLearn::DMatrix::GetMiniBatch(unsigned int, xLearn::DMatrix&) | index_t GetMiniBatch(index_t batch_size, DMatrix& mini_batch) {
// Copy mini-batch
for (index_t i = 0; i < batch_size; ++i) {
if (this->pos >= this->row_length) {
return i;
}
mini_batch.AddRow();
mini_batch.row[i] = this->row[pos];
mini_batch.Y[i] = this->Y[pos];
mini... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
testl %esi, %esi
je 0x425de
movq %rdx, %r14
movq %rdi, %r15
movl %ebx, %r13d
xorl %r12d, %r12d
movl 0x64(%r15), %eax
cmpl 0x10(%r15), %eax
jae 0x425e1
movq %r14, %rdi
callq 0x40f78
movl 0x64(%r15), %eax
movq 0x18(%r15), %rcx
movq (%rcx,%rax,8), %rcx... | /aksnzhy[P]xlearn/src/data/data_structure.h |
xLearn::SquaredLoss::Evaluate(std::vector<float, std::allocator<float>> const&, std::vector<float, std::allocator<float>> const&) | void SquaredLoss::Evaluate(const std::vector<real_t>& pred,
const std::vector<real_t>& label) {
CHECK_NE(pred.empty(), true);
CHECK_NE(label.empty(), true);
total_example_ += pred.size();
// multi-thread training
std::vector<real_t> sum(threadNumber_, 0);
for (int i = 0; i < thread... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
cmpq %rax, %rcx
je 0x44d21
movq %rdx, %r13
movq (%rdx), %rdx
cmpq 0x8(%r13), %rdx
je 0x44e85
movq %rdi, %r15
subq %rcx, %rax
shrq $0x2, %rax
addl %eax, 0x2c(%rdi)
movq 0x20(%rdi), %r... | /aksnzhy[P]xlearn/src/loss/squared_loss.cc |
xLearn::sq_gradient_thread(xLearn::DMatrix const*, xLearn::Model*, xLearn::Score*, bool, float*, unsigned int, unsigned int) | void sq_gradient_thread(const DMatrix* matrix,
Model* model,
Score* score_func,
bool is_norm,
real_t* sum,
index_t start,
index_t end) {
CHECK_GE(end, start);
*sum = 0;
f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %ebx
movl %ecx, 0x8(%rsp)
movl 0x90(%rsp), %ebp
cmpl %r9d, %ebp
jb 0x45354
movq %r8, %r14
movl $0x0, (%r8)
jbe 0x45333
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl %ebp, %eax
movq %rax, 0x10(%rsp)
movl %ebx, %ebp
vmovs... | /aksnzhy[P]xlearn/src/loss/squared_loss.cc |
std::future<std::result_of<std::_Bind<void (* (std::vector<float, std::allocator<float>> const*, std::vector<float, std::allocator<float>> const*, float*, unsigned long, unsigned long))(std::vector<float, std::allocator<float>> const*, std::vector<float, std::allocator<float>> const*, float*, unsigned long, unsigned lo... | auto ThreadPool::enqueue(F&& f, Args&&... args)
-> std::future<typename std::result_of<F(Args...)>::type> {
using return_type = typename std::result_of<F(Args...)>::type;
auto task = std::make_shared< std::packaged_task<return_type()> >(
std::bind(std::forward<F>(f), std::forward<Args>(args)...)
);
std:... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
leaq 0x28(%rsp), %rcx
movq %rax, (%rcx)
vmovups 0x8(%rdx), %ymm0
vmovups %ymm0, 0x8(%rcx)
movq 0x28(%rdx), %rax
movq %rax, 0x28(%rcx)
leaq 0x8(%rsp), %rdi
movq $0x0, -0x8(%rdi)
movq %rsp, %r15
leaq 0x10(%rsp), %rdx
movq ... | /aksnzhy[P]xlearn/src/base/thread_pool.h |
xLearn::ce_evaluate_thread(std::vector<float, std::allocator<float>> const*, std::vector<float, std::allocator<float>> const*, float*, unsigned long, unsigned long) | static void ce_evaluate_thread(const std::vector<real_t>* pred,
const std::vector<real_t>* label,
real_t* tmp_sum,
size_t start_idx,
size_t end_idx) {
CHECK_GE(end_idx, start_idx);
*tmp_sum = 0;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %r8, %r14
movq %rcx, %rbx
cmpq %rcx, %r8
jb 0x474ca
movq %rdx, %r15
movl $0x0, (%rdx)
jbe 0x474bc
movq %rsi, %r12
movq %rdi, %r13
movq (%r12), %rax
movq (%r13), %rcx
vmovss (%rcx,%rbx,4), %xmm0
vxorps 0x13a82(%rip){1to4}, %xmm0, %xmm1 # 0x5af1... | /aksnzhy[P]xlearn/src/loss/cross_entropy_loss.cc |
xLearn::FFMScore::calc_grad_ftrl(std::vector<xLearn::Node, std::allocator<xLearn::Node>> const*, xLearn::Model&, float, float) | void FFMScore::calc_grad_ftrl(const SparseRow* row,
Model& model,
real_t pg,
real_t norm) {
/*********************************************************
* linear term and bias term *
*************... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
vmovss %xmm0, 0x18(%rsp)
movq %rdx, %rbx
movq %rsi, 0x20(%rsp)
movq %rdi, %r14
vxorps %xmm0, %xmm0, %xmm0
vucomiss %xmm0, %xmm1
vmovss %xmm1, 0x58(%rsp)
jb 0x50f52
vsqrtss %xmm1, %xmm1, %xmm0
jmp 0x50f5b
vmovaps %xmm1, %xmm0
callq 0x2886... | /aksnzhy[P]xlearn/src/score/ffm_score.cc |
xLearn::Model::Model(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Model::Model(const std::string& filename) {
CHECK_NE(filename.empty(), true);
if (this->Deserialize(filename) == false) {
Color::print_error(
StringPrintf("Cannot Load model from the file: %s",
filename.c_str())
);
exit(0);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %r13
movq %r13, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
vxorps %xmm0, %xmm0,... | /aksnzhy[P]xlearn/src/data/model_parameters.cc |
xLearn::Model::Deserialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool Model::Deserialize(const std::string& filename) {
CHECK_NE(filename.empty(), true);
#ifndef _MSC_VER
FILE* file = OpenFileOrDie(filename.c_str(), "r");
#else
FILE* file = OpenFileOrDie(filename.c_str(), "rb");
#endif
if (file == NULL) { return false; }
// Read score function
ReadStringFromFile(file, sc... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x5288f
movq %rdi, %r14
movq (%rbx), %rdi
leaq 0x77be(%rip), %rsi # 0x59fc0
callq 0x3a235
movq %rax, %rbx
testq %rax, %rax
je 0x5287d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53a5b
leaq 0x20(%r14), %rsi
movq %rbx, %... | /aksnzhy[P]xlearn/src/data/model_parameters.cc |
xLearn::Model::SerializeToTXT(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Model::SerializeToTXT(const std::string& filename) {
CHECK_NE(filename.empty(), true);
std::ofstream o_file(filename);
/*********************************************************
* Write linear and bias term *
*********************************************************/
// bias ter... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rsi, %r14
cmpq $0x0, 0x8(%rsi)
je 0x530fb
movq %rdi, %rbx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x28880
leaq 0xb509(%rip), %rsi # 0x5e295
movl $0x6, %edx
movq %r... | /aksnzhy[P]xlearn/src/data/model_parameters.cc |
WriteStringToFile(_IO_FILE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline void WriteStringToFile(FILE * file_ptr, const std::string &str) {
CHECK_NOTNULL(file_ptr);
// We do not want to serialize an empty string
CHECK(!str.empty());
size_t len =str.size();
// First, write the length of string
WriteDataToDisk(file_ptr, reinterpret_cast<char *>(&len), sizeof(len));
// Then... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rdi, %rdi
je 0x537d7
movq %rsi, %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x538e3
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movl $0x8, %edx
movq %r15, %rsi
callq 0x3f1fe
movq (%rbx), %rsi
movq (%r15), %rdx
movq %r14, %rdi
callq 0x3f1fe... | /aksnzhy[P]xlearn/src/base/file_util.h |
Timer::toc() | float Timer::toc() {
duration += std::chrono::duration_cast<std::chrono::milliseconds>
(std::chrono::high_resolution_clock::now()-begin);
return get();
} | pushq %rbx
movq %rdi, %rbx
callq 0x28080
subq (%rbx), %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
addq 0x8(%rbx), %rdx
movq %rdx, 0x8(%rbx)
vcvtsi2ss %rdx, %xmm0, %xmm0
vdivss 0x8602(%rip), %xmm0, %xmm0 # 0x5e61c
popq %rb... | /aksnzhy[P]xlearn/src/base/timer.cc |
dtl_av_sort | dtl_error_t dtl_av_sort(dtl_av_t *self, dtl_key_func_t *key, bool reverse)
{
if (self != 0)
{
if (key != 0)
{
return DTL_NOT_IMPLEMENTED_ERROR;
}
return dtl_av_insertion_sort(self, reverse);
}
return DTL_INVALID_ARGUMENT_ERROR;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x39f9
movl $0x3, %eax
testq %rsi, %rsi
jne 0x3a0b
movq (%rdi), %rax
movl 0x14(%rax), %eax
movl %eax, 0xc(%rsp)
cmpl $0x2, %eax
jl 0x3a09
movl %edx, 0x8(%rsp)
movl $0x1, %esi
movq %rdi, 0x10(%rsp)
movl %esi, %ebx
cmpl... | /cogu[P]c-apx/dtl_type/src/dtl_av.c |
dtl_dv_delete | void dtl_dv_delete(dtl_dv_t* dv ){
if(dv){
switch(dtl_dv_type(dv))
{
case DTL_DV_INVALID:
break;
case DTL_DV_NULL:
free(dv);
break;
case DTL_DV_SCALAR:
dtl_sv_delete((dtl_sv_t*) dv);
break;
case DTL_DV_ARRAY:
dtl_av_delete((dtl_av_t*) dv);
break;
case DTL_DV_HASH:
dtl_hv_delete((d... | testq %rdi, %rdi
je 0x3aa9
movl 0xc(%rdi), %eax
andl $0xf, %eax
decl %eax
cmpl $0x3, %eax
ja 0x3aa9
leaq 0x2615(%rip), %rcx # 0x60b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x3540
retq
jmp 0x3490
jmp 0x3430
jmp 0x30a0
| /cogu[P]c-apx/dtl_type/src/dtl_dv.c |
dtl_hv_keys | dtl_av_t* dtl_hv_keys(const dtl_hv_t *self)
{
if( (self != 0) )
{
dtl_av_t *array = 0;
adt_ary_t *tmp = 0; //adt_ary returns a list of cstr (C strings).
array = dtl_av_new();
if (array != 0)
{
tmp = adt_ary_new(vfree);
}
if ( (array != 0) && (tmp != 0) )
{
int32_t numItem... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3d52
movq %rdi, %r15
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x3040
movq %rax, %rbx
testq %rax, %rax
je 0x3cdb
movq 0x52fd(%rip), %rdi # 0x8fd0
callq 0x3310
movq %rax, %r14
testq %rbx, %rbx
setne %al
testq %r14, %r14
setne %cl
andb %al, %... | /cogu[P]c-apx/dtl_type/src/dtl_hv.c |
dtl_sv_create | void dtl_sv_create(dtl_sv_t* self)
{
if(self)
{
self->pAny = (dtl_svx_t*) malloc(sizeof(dtl_svx_t));
if (self->pAny != 0)
{
memset(self->pAny, 0, sizeof(dtl_svx_t));
self->u32Flags = ((uint32_t)DTL_DV_SCALAR);
self->u32RefCnt = 1;
self->pAny->tmpStr = (adt_str... | pushq %rbx
testq %rdi, %rdi
je 0x3df8
movq %rdi, %rbx
movl $0x18, %edi
callq 0x3320
movq %rax, (%rbx)
testq %rax, %rax
je 0x3dfa
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movabsq $0x200000001, %rdx # imm = 0x200000001
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
popq %rbx
retq
leaq 0x... | /cogu[P]c-apx/dtl_type/src/dtl_sv.c |
dtl_sv_destroy | void dtl_sv_destroy(dtl_sv_t* self)
{
if(self != 0)
{
switch(dtl_sv_type(self))
{
case DTL_SV_STR:
adt_str_delete(self->pAny->val.str);
break;
case DTL_SV_PTR:
if(self->pAny->val.ptr.pDestructor != 0)
{
self->pAny->val.ptr.pDestructor(self->p... | testq %rdi, %rdi
je 0x3ed8
pushq %rbx
movq %rdi, %rbx
movl 0xc(%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
addl $-0x9, %eax
cmpl $0x4, %eax
ja 0x3eae
leaq 0x231a(%rip), %rcx # 0x6170
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x33a0
jmp 0x3eae
movq (%rbx), %r... | /cogu[P]c-apx/dtl_type/src/dtl_sv.c |
dtl_sv_set_ptr | void dtl_sv_set_ptr(dtl_sv_t *self, void *p, void (*pDestructor)(void*)){
if(self){
if(dtl_sv_type(self)==DTL_SV_DV){
dtl_dv_dec_ref(self->pAny->val.dv);
}
dtl_sv_set_type(self,DTL_SV_PTR);
self->pAny->val.ptr.p = p;
self->pAny->val.ptr.pDestructor = pDestructor;
}
} | testq %rdi, %rdi
je 0x42b5
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0xf0, %eax
andl 0xc(%rdi), %eax
cmpl $0xb0, %eax
jne 0x4295
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x3100
movq %r14, %rdi
movl $0xa, %esi
callq 0x45db
movq (%r14), %rax
movq %r15, 0x8(%rax)
movq (%r14... | /cogu[P]c-apx/dtl_type/src/dtl_sv.c |
dtl_sv_to_u32 | uint32_t dtl_sv_to_u32(const dtl_sv_t *self, bool *ok)
{
bool success = false;
uint32_t retval = 0u;
if(self)
{
switch(dtl_sv_type(self)){
case DTL_SV_NONE:
break;
case DTL_SV_I32:
if (self->pAny->val.i32 >= 0)
{
retval = (uint32_t)self->pAny->val.i32... | testq %rdi, %rdi
je 0x4869
movl 0xc(%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
decl %eax
cmpl $0x7, %eax
ja 0x4869
leaq 0x1959(%rip), %rcx # 0x61a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rax
movl 0x8(%rax), %edx
xorl %eax, %eax
testl %edx, %edx
setns %cl
cmovnsl %edx, %eax
jmp 0x4908
... | /cogu[P]c-apx/dtl_type/src/dtl_sv.c |
dtl_sv_to_dbl | double dtl_sv_to_dbl(const dtl_sv_t *self, bool *ok)
{
bool success = false;
double retval = 0u;
if(self != 0)
{
switch(dtl_sv_type(self))
{
case DTL_SV_NONE:
break;
case DTL_SV_I32:
retval = (double) self->pAny->val.i32;
success = true;
break;
... | xorpd %xmm0, %xmm0
testq %rdi, %rdi
je 0x4b59
movl 0xc(%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
decl %eax
cmpl $0x7, %eax
ja 0x4b59
leaq 0x16e4(%rip), %rcx # 0x6224
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rax
movsbl 0x8(%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
jmp 0x4bc2
x... | /cogu[P]c-apx/dtl_type/src/dtl_sv.c |
dtl_sv_get_bytes | const adt_bytes_t* dtl_sv_get_bytes(const dtl_sv_t* self)
{
const adt_bytes_t *retval = (const adt_bytes_t*) 0;
if (self != 0)
{
dtl_sv_type_id currentType = dtl_sv_type(self);
if (currentType == DTL_SV_BYTES)
{
retval = self->pAny->val.bytes;
}
}
return retval;
} | testq %rdi, %rdi
je 0x52d6
movl $0xf0, %eax
andl 0xc(%rdi), %eax
cmpl $0xc0, %eax
jne 0x52d6
movq (%rdi), %rax
movq 0x8(%rax), %rax
retq
xorl %eax, %eax
retq
| /cogu[P]c-apx/dtl_type/src/dtl_sv.c |
int waitForValue<int>(QtPromise::QPromise<int> const&, int const&) | static inline T waitForValue(const QtPromise::QPromise<T>& promise, const T& initial)
{
T value(initial);
promise
.then([&](const T& res) {
value = res;
})
.wait();
return value;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %r15
movl %esi, 0x3c(%rsp)
movl $0x58, %edi
callq 0x40a0
movq %rax, %r14
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movq $0x... | /simonbrunel[P]qtpromise/tests/auto/qtpromise/helpers/../shared/utils.h |
void QtPromisePrivate::PromiseDispatch<void>::call<QtPromise::QPromiseResolve<void>, QtPromise::QPromiseReject<void>, void QtPromisePrivate::PromiseFulfill<QtPromise::QPromise<void>>::call<QtPromise::QPromise<void>, QtPromise::QPromiseResolve<void>, QtPromise::QPromiseReject<void>>(QtPromise::QPromise<void> const&, QtP... | static void call(const Resolve& resolve, const Reject& reject, Functor fn, Args&&... args)
{
try {
fn(std::forward<Args>(args)...);
resolve();
} catch (...) {
reject(std::current_exception());
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdx), %rsi
addq $0x50, %rsi
movq %rdx, %rdi
callq 0x266f0
movq %r14, %rdi
callq 0x250ae
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x4030
movq %rsp, %r14
movq %r14, %rdi
callq 0x4160
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2... | /simonbrunel[P]qtpromise/include/../src/qtpromise/qpromise_p.h |
void QtPromisePrivate::PromiseDataBase<QString, void (QString const&)>::reject<std::__exception_ptr::exception_ptr>(std::__exception_ptr::exception_ptr&&) | void reject(E&& error)
{
Q_ASSERT(isPending());
Q_ASSERT(m_error.isNull());
m_error = PromiseError{std::forward<E>(error)};
setSettled();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x2ae09
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4100
movq (%r14), %rax
jmp 0x2ae0b
xorl %eax, %eax
movq $0x0, 0x8(%rsp)
movq 0x50(%rbx), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x50(%rbx)
testq %rcx, %rc... | /simonbrunel[P]qtpromise/include/../src/qtpromise/qpromise_p.h |
bool sptk::ReadStream<long double>(long double*, std::istream*) | bool ReadStream(T* data_to_read, std::istream* input_stream) {
if (NULL == data_to_read || NULL == input_stream || input_stream->eof()) {
return false;
}
const int type_byte(sizeof(*data_to_read));
input_stream->read(reinterpret_cast<char*>(data_to_read), type_byte);
return (type_byte == input_stream->g... | pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x5f87
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rbx,%rax)
jne 0x5f87
movq %rdi, %rsi
movl $0x10, %edx
movq %rbx, %rdi
callq 0x32b0
cmpq $0x10, 0x8(%rbx)
jne 0x5f87
movq (%rbx), %rax
movq -0x18(%rax), %rax
t... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<float>(bool, int, int, int, std::vector<float, std::allocator<float>>*, 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 0x6f1d
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /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 0x77fa
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<float>(int, int, std::vector<float, std::allocator<float>> 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 0x7d45
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 0x67f3(%rip), %rax # 0xfd28
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x9ee4
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::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 0x709e
leaq 0x28(%r15), %r14
movslq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x9eb2
... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::SymmetricMatrix::SymmetricMatrix(int) | SymmetricMatrix::SymmetricMatrix(int num_dimension)
: num_dimension_(num_dimension < 0 ? 0 : num_dimension) {
data_.resize(num_dimension_ * (num_dimension_ + 1) / 2);
index_.resize(num_dimension_);
for (int i(0), j(0); i < num_dimension_; ++i, j += i) {
index_[i] = &data_[j];
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x5acd(%rip), %rax # 0xfd58
movq %rax, (%rdi)
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movl %esi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x28(%rdi), %r14
leal 0x1(%rsi), %eax
imull %eax, %esi
shrl %esi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
sptk::SymmetricMatrix::operator=(sptk::SymmetricMatrix const&) | SymmetricMatrix& SymmetricMatrix::operator=(const SymmetricMatrix& matrix) {
if (this != &matrix) {
num_dimension_ = matrix.num_dimension_;
data_ = matrix.data_;
index_.resize(num_dimension_);
for (int i(0), j(0); i < num_dimension_; ++i, j += i) {
index_[i] = &data_[j];
}
}
return *thi... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xa402
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rbx)
addq $0x10, %rsi
leaq 0x10(%rbx), %r14
movq %r14, %rdi
callq 0x9ff2
leaq 0x28(%rbx), %r15
movslq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x9eb2
movslq 0x8(%rbx), %rax
testq %rax, %rax
jle 0xa402
xorl %ecx,... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
die | void die(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fprintf(stderr, "\n");
exit(1);
} | subq $0xd8, %rsp
testb %al, %al
je 0x174c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x1... | /ask[P]rabbitmq-c/examples/utils.c |
amqp_dump | void amqp_dump(void const *buffer, size_t len)
{
unsigned char *buf = (unsigned char *) buffer;
long count = 0;
int numinrow = 0;
int chs[16];
int oldchs[16] = {0};
int showed_dots = 0;
size_t i;
for (i = 0; i < len; i++) {
int ch = buf[i];
if (numinrow == 16) {
int i;
if (rows_eq... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq $0x0, 0xa8(%rsp)
movl $0x0, 0xa4(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1090
movl $0x0, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0xb8(%rsp), %rax
jae 0x1b37
movq... | /ask[P]rabbitmq-c/examples/utils.c |
rows_eq | static int rows_eq(int *a, int *b)
{
int i;
for (i=0; i<16; i++)
if (a[i] != b[i]) {
return 0;
}
return 1;
} | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0x10, -0x1c(%rsp)
jge 0x1bce
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x1bbf
movl $0x0, -0x4(%rsp)
jmp 0x1bd6
jmp 0x1bc1
movl -0x1c(%rsp)... | /ask[P]rabbitmq-c/examples/utils.c |
hrgls::datablob::DataBlob::Time() const | struct timeval DataBlob::Time() const
{
struct timeval ret = {};
if (!m_private->blob) {
m_private->status = hrgls_STATUS_NULL_OBJECT_POINTER;
return ret;
}
if (hrgls_STATUS_OKAY !=
(m_private->status = hrgls_DataBlobGetTime(m_private->blob, &ret))) {
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq (%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3928
movq %rsp, %r14
movq %r14, %rsi
callq 0x3430
movq (%rbx), %rcx
movl %eax, 0x8(%rcx)
movq (%r14), %rax
movq 0x8(%r14), %rdx
jmp 0x3933
movl $0x3ee, 0x8(%rax) ... | /ReliaSolve[P]Hourglass/hrgls_DataBlob_impl.hpp |
hrgls::datablob::DataBlobSource::SetStreamCallback(void (*)(hrgls::datablob::DataBlob&, void*), void*) | hrgls_Status DataBlobSource::SetStreamCallback(StreamCallback callback, void *userdata)
{
if (!m_private) {
return hrgls_STATUS_NULL_OBJECT_POINTER;
}
// Lock the mutex while we're changing the handler data so we don't
// change it out from under an active callback handler.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x4e4f
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x33e0
testl %eax, %eax
jne 0x4eaf
movq (%r14), %rdx
movq %r15, 0x38(%rdx)
movq %r12, 0x40(%rdx)
movq (%rdx), %rdi
t... | /ReliaSolve[P]Hourglass/hrgls_api.hpp |
leveldb::test::RunAllTests() | int RunAllTests() {
const char* matcher = getenv("LEVELDB_TESTS");
int num = 0;
if (tests != nullptr) {
for (size_t i = 0; i < tests->size(); i++) {
const Test& t = (*tests)[i];
if (matcher != nullptr) {
std::string name = t.base;
name.push_back('.');
name.append(t.name);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x1d589(%rip), %rdi # 0x24004
callq 0x6480
movq %rax, %rbx
movq 0x34996(%rip), %rax # 0x3b420
xorl %edx, %edx
testq %rax, %rax
je 0x6b50
leaq 0x8(%rsp), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movl $0x0, 0x4(%rsp)
movq (%ra... | /CDDSCLab[P]leveldb/util/testharness.cc |
leveldb::DBImpl::RecordReadSample(leveldb::Slice) | void DBImpl::RecordReadSample(Slice key) {
MutexLock l(&mutex_);
if (versions_->current()->RecordReadSample(key)) {
MaybeScheduleCompaction();
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0xc8(%rdi), %rbx
movq %rbx, %rdi
callq 0xff50
movq 0x228(%r14), %rax
movq 0x168(%rax), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x15ccc
testb %al, %al
je 0xd84b
movq %r14, %rdi
callq 0xc0b2
movq %rbx, %rdi
addq... | /CDDSCLab[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::GetSnapshot() | const Snapshot* DBImpl::GetSnapshot() {
MutexLock l(&mutex_);
return snapshots_.New(versions_->LastSequence());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xc8(%rdi), %rbx
movq %rbx, %rdi
callq 0xff50
movq 0x228(%r14), %rax
addq $0x1c0, %r14 # imm = 0x1C0
movq 0x58(%rax), %rsi
movq %r14, %rdi
callq 0xfb9c
movq %rax, %r14
movq %rbx, %rdi
callq 0x6310
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
m... | /CDDSCLab[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::DumpRange(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, leveldb::Slice const&, leveldb::Slice const&) | Status DBImpl::DumpRange(const std::string& fname,
const Slice& start,
const Slice& end) {
Status s;
WritableFile* file;
env_->NewWritableFile(fname, &file);
Options options;
options.filter_policy = nullptr;
options.compression = kSnappyCompres... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, %rbp
movq %rcx, %rbx
movq %rdi, 0x18(%rsp)
andq $0x0, (%rdi)
movq %rdx, %r14
movq %rsi, %r15
movq 0x8(%rsi), %rsi
movq (%rsi), %rax
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rcx
callq *0x20(%rax)
leaq 0x40(%rsp), %rdi
callq 0x6db... | /CDDSCLab[P]leveldb/db/db_impl.cc |
leveldb::DestroyDB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, leveldb::Options const&) | Status DestroyDB(const std::string& dbname, const Options& options) {
Env* env = options.env;
std::vector<std::string> filenames;
Status result = env->GetChildren(dbname, &filenames);
if (!result.ok()) {
// Ignore error in case directory does not exist
return Status::OK();
}
FileLock* lock;
const... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r8
movq %rdi, %rbx
movq 0x10(%rdx), %r15
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
movq (%r15), %rax
movq %rsp, %rdi
movq %r15, %rsi
movq %r8, 0x8(%rsp)
movq %r8, %rdx
callq *0x38(%ra... | /CDDSCLab[P]leveldb/db/db_impl.cc |
leveldb::InternalKey::user_key() const | Slice user_key() const { return ExtractUserKey(rep_); } | subq $0x18, %rsp
movq (%rdi), %rcx
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, %rdi
callq 0x10341
addq $0x18, %rsp
retq
| /CDDSCLab[P]leveldb/db/dbformat.h |
leveldb::Status::operator=(leveldb::Status const&) | inline Status& Status::operator=(const Status& rhs) {
// The following condition catches both aliasing (when this == &rhs),
// and the common case where both rhs and *this are ok.
if (state_ != rhs.state_) {
delete[] state_;
state_ = (rhs.state_ == nullptr) ? nullptr : CopyState(rhs.state_);
}
return ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rsi), %rdi
cmpq %rdi, %rax
je 0xfac4
testq %rax, %rax
je 0xfab3
movq %rsi, %r14
movq %rax, %rdi
callq 0x64c0
movq (%r14), %rdi
testq %rdi, %rdi
je 0xfabf
callq 0x1e8cc
jmp 0xfac1
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
p... | /CDDSCLab[P]leveldb/include/leveldb/status.h |
leveldb::InternalKey::DebugString[abi:cxx11]() const | std::string InternalKey::DebugString() const {
ParsedInternalKey parsed;
if (ParseInternalKey(rep_, &parsed)) {
return parsed.DebugString();
}
std::ostringstream ss;
ss << "(bad)" << EscapeString(rep_);
return ss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq $0x8, %rax
jb 0x12292
movq (%r14), %rcx
movq -0x8(%rcx,%rax), %rdx
movzbl %dl, %esi
shrq $0x8, %rdx
movq %rdx, 0x18(%rsp)
movl %esi, 0x20(%rsp)
addq $-0x8, %rax
movq %rcx, 0x8(%rsp)
movq... | /CDDSCLab[P]leveldb/db/dbformat.cc |
leveldb::InternalFilterPolicy::CreateFilter(leveldb::Slice const*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) const | void InternalFilterPolicy::CreateFilter(const Slice* keys, int n,
std::string* dst) const {
// We rely on the fact that the code in table.cc does not mind us
// adjusting keys[].
Slice* mkey = const_cast<Slice*>(keys);
for (int i = 0; i < n; i++) {
mkey[i] = ExtractUs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testl %edx, %edx
movl $0x0, %r13d
cmovgl %edx, %r13d
shlq $0x4, %r13
cmpq %r12, %r13
je 0x126a2
leaq (%r14,%r12), %rdi
callq 0x10341
movq %rax, (%r14,%r12)
movq ... | /CDDSCLab[P]leveldb/db/dbformat.cc |
leveldb::log::Reader::ReadPhysicalRecord(leveldb::Slice*) | unsigned int Reader::ReadPhysicalRecord(Slice* result) {
while (true) {
if (buffer_.size() < kHeaderSize) {
if (!eof_) {
// Last read was a full read, so this is a trailer to skip
buffer_.clear();
Status status = file_->Read(kBlockSize, &buffer_, backing_store_);
end_of_buffe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
leaq 0x20(%rdi), %r12
leaq 0x1166e(%rip), %rbp # 0x2477b
pushq $0x5
popq %rbx
leaq 0x18(%rsp), %r13
movq 0x28(%r14), %rsi
cmpq $0x6, %rsi
ja 0x13197
movq %rbp, 0x20(%r14)
andq $0x0, 0x28(%r14)
cm... | /CDDSCLab[P]leveldb/db/log_reader.cc |
leveldb::log::Writer::EmitPhysicalRecord(leveldb::log::RecordType, char const*, unsigned long) | Status Writer::EmitPhysicalRecord(RecordType t, const char* ptr,
size_t length) {
assert(length <= 0xffff); // Must fit in two bytes
assert(block_offset_ + kHeaderSize + length <= kBlockSize);
// Format the header
char buf[kHeaderSize];
buf[4] = static_cast<char>(length & 0... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpq $0x10000, %r8 # imm = 0x10000
jae 0x135e2
movq %r8, %rbx
movq %rsi, %r15
movslq 0x8(%rsi), %rax
addq %r8, %rax
addq $0x7, %rax
cmpq $0x8001, %rax # imm = 0x8001
jae 0x135fb
movq %rcx, %r12
movq %rdi, %r14
movq %rsp, %r13
mo... | /CDDSCLab[P]leveldb/db/log_writer.cc |
leveldb::MemTable::~MemTable() | MemTable::~MemTable() { assert(refs_ == 0); } | pushq %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x136db
movq %rdi, %rbx
addq $0x48, %rdi
callq 0x1dd8e
leaq 0x18(%rbx), %rdi
callq 0x1cd6c
movq %rbx, %rdi
popq %rbx
jmp 0x1dd8e
leaq 0x13363(%rip), %rdi # 0x26a45
leaq 0x126e7(%rip), %rsi # 0x25dd0
leaq 0x12739(%rip), %rcx # 0x25e29
pushq $0x18
popq %rdx
callq 0x6280
| /CDDSCLab[P]leveldb/db/memtable.cc |
leveldb::SkipList<char const*, leveldb::MemTable::KeyComparator>::Insert(char const* const&) | void SkipList<Key, Comparator>::Insert(const Key& key) {
// TODO(opt): We can use a barrier-free variant of FindGreaterOrEqual()
// here since Insert() is externally synchronized.
Node* prev[kMaxHeight];
Node* x = FindGreaterOrEqual(key, prev);
// Our data structure does not allow duplicate insertion
asser... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rdx
callq 0x13ef8
testq %rax, %rax
je 0x13b08
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x13f88
testb %al, %al
jne 0x13b90
movq %r15, %rdi
callq 0x13f9c
movl %eax, %ebx
movl 0x20(%r15), %eax
cmpl %eax, %ebx
jle 0x1... | /CDDSCLab[P]leveldb/db/skiplist.h |
leveldb::MemTableIterator::Seek(leveldb::Slice const&) | void Seek(const Slice& k) override { iter_.Seek(EncodeKey(&tmp_, k)); } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rdi), %r15
andq $0x0, 0x40(%rdi)
leaq 0x38(%rdi), %r12
movq 0x38(%rdi), %rax
movb $0x0, (%rax)
movl 0x8(%rsi), %esi
movq %r12, %rdi
callq 0x1db0f
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r12, %rdi
callq 0x6060
movq 0x3... | /CDDSCLab[P]leveldb/db/memtable.cc |
leveldb::SkipList<char const*, leveldb::MemTable::KeyComparator>::RandomHeight() | int SkipList<Key, Comparator>::RandomHeight() {
// Increase height with probability 1 in kBranching
static const unsigned int kBranching = 4;
int height = 1;
while (height < kMaxHeight && ((rnd_.Next() % kBranching) == 0)) {
height++;
}
assert(height > 0);
assert(height <= kMaxHeight);
return height... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x24, %rbx
pushq $0x1
popq %rbp
cmpl $0xc, %ebp
je 0x13fbe
movq %rbx, %rdi
callq 0x6f4a
testb $0x3, %al
jne 0x13fbe
incl %ebp
jmp 0x13fa9
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /CDDSCLab[P]leveldb/db/skiplist.h |
leveldb::VersionEdit::Clear() | void VersionEdit::Clear() {
comparator_.clear();
log_number_ = 0;
prev_log_number_ = 0;
last_sequence_ = 0;
next_file_number_ = 0;
has_comparator_ = false;
has_log_number_ = false;
has_prev_log_number_ = false;
has_next_file_number_ = false;
has_last_sequence_ = false;
deleted_files_.clear();
ne... | pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq (%rdi), %rax
movb $0x0, (%rax)
addq $0x60, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
andq $0x0, 0x3d(%rbx)
callq 0x150f4
addq $0x90, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x14ee2
| /CDDSCLab[P]leveldb/db/version_edit.cc |
leveldb::Version::~Version() | Version::~Version() {
assert(refs_ == 0);
// Remove from linked list
prev_->next_ = next_;
next_->prev_ = prev_;
// Drop references to files
for (int level = 0; level < config::kNumLevels; level++) {
for (size_t i = 0; i < files_[level].size(); i++) {
FileMetaData* f = files_[level][i];
as... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x18(%rdi)
jne 0x1521b
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rax)
leaq 0x20(%rdi), %r15
xorl %r12d, %r12d
cmpq $0x7, %r12
je 0x151d6
imulq $0x18, %r12, %r13
addq %r15, %r13
... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::Version::ForEachOverlapping(leveldb::Slice, leveldb::Slice, void*, bool (*)(void*, int, leveldb::FileMetaData*)) | void Version::ForEachOverlapping(Slice user_key, Slice internal_key, void* arg,
bool (*func)(void*, int, FileMetaData*)) {
// TODO(sanjay): Change Version::Get() to use this function.
const Comparator* ucmp = vset_->icmp_.user_comparator();
// Search level-0 in order from newest ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, (%rsp)
movq %rdi, %r14
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x60(%rsp)
movq (%rdi), %rax
movq 0x40(%rax), %r15
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::Version::Get(leveldb::ReadOptions const&, leveldb::LookupKey const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, leveldb::Version::GetStats*) | Status Version::Get(const ReadOptions& options, const LookupKey& k,
std::string* value, GetStats* stats) {
Slice ikey = k.internal_key();
Slice user_key = k.user_key();
const Comparator* ucmp = vset_->icmp_.user_comparator();
Status s;
stats->seek_file = nullptr;
stats->seek_file_level ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
subq %rax, %rcx
leaq 0xc8(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
addq $-0x8, %rcx
leaq 0x98(%rsp), %r13
movq %rax, (%r13)
movq %rcx, 0x8(%r... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::Version::UpdateStats(leveldb::Version::GetStats const&) | bool Version::UpdateStats(const GetStats& stats) {
FileMetaData* f = stats.seek_file;
if (f != nullptr) {
f->allowed_seeks--;
if (f->allowed_seeks <= 0 && file_to_compact_ == nullptr) {
file_to_compact_ = f;
file_to_compact_level_ = stats.seek_file_level;
return true;
}
}
return fa... | movq (%rsi), %rax
testq %rax, %rax
je 0x15cb6
movl 0x4(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x4(%rax)
cmpl $0x1, %ecx
jg 0x15cb6
cmpq $0x0, 0xc8(%rdi)
je 0x15cb9
xorl %eax, %eax
retq
movq %rax, 0xc8(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0xd0(%rdi)
movb $0x1, %al
retq
| /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::Version::RecordReadSample(leveldb::Slice)::State::Match(void*, int, leveldb::FileMetaData*) | static bool Match(void* arg, int level, FileMetaData* f) {
State* state = reinterpret_cast<State*>(arg);
state->matches++;
if (state->matches == 1) {
// Remember first match.
state->stats.seek_file = f;
state->stats.seek_file_level = level;
}
// We can stop iteratin... | movl 0x10(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x10(%rdi)
testl %eax, %eax
jne 0x15d41
movq %rdx, (%rdi)
movl %esi, 0x8(%rdi)
testl %eax, %eax
setle %al
retq
nop
| /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::Version::PickLevelForMemTableOutput(leveldb::Slice const&, leveldb::Slice const&) | int Version::PickLevelForMemTableOutput(const Slice& smallest_user_key,
const Slice& largest_user_key) {
int level = 0;
if (!OverlapInLevel(0, &smallest_user_key, &largest_user_key)) {
// Push to next level if there is no overlap in next level,
// and the #bytes overl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x15dbc
testb %al, %al
jne 0x15eca
leaq 0x38(%rsp), %rdi
movabsq $0xffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFF
pus... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::VersionSet::AppendVersion(leveldb::Version*) | void VersionSet::AppendVersion(Version* v) {
// Make "v" current
assert(v->refs_ == 0);
assert(v != current_);
if (current_ != nullptr) {
current_->Unref();
}
current_ = v;
v->Ref();
// Append to linked list
v->prev_ = dummy_versions_.prev_;
v->next_ = &dummy_versions_;
v->prev_->next_ = v;
... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x18(%rsi)
jne 0x164b7
movq %rsi, %rbx
movq %rdi, %r14
movq 0x168(%rdi), %rdi
cmpq %rsi, %rdi
je 0x164d6
testq %rdi, %rdi
je 0x16483
callq 0x15d4c
movl 0x18(%rbx), %eax
incl %eax
jmp 0x16486
pushq $0x1
popq %rax
movq %rbx, 0x168(%r14)
movl %eax, 0x18(%rbx)
movq 0x90(%r14), %r... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::VersionSet::WriteSnapshot(leveldb::log::Writer*) | Status VersionSet::WriteSnapshot(log::Writer* log) {
// TODO: Break up into multiple records to reduce memory usage on recovery?
// Save metadata
VersionEdit edit;
edit.SetComparatorName(icmp_.user_comparator()->Name());
// Save compaction pointers
for (int level = 0; level < config::kNumLevels; level++) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, %r15
movq %rdi, 0x28(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xf734
movq 0x40(%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rax, %rdi
callq 0x6130
movq %rax, 0x8(%r14)
... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::VersionSet::ApproximateOffsetOf(leveldb::Version*, leveldb::InternalKey const&) | uint64_t VersionSet::ApproximateOffsetOf(Version* v, const InternalKey& ikey) {
uint64_t result = 0;
for (int level = 0; level < config::kNumLevels; level++) {
const std::vector<FileMetaData*>& files = v->files_[level];
for (size_t i = 0; i < files.size(); i++) {
if (icmp_.Compare(files[i]->largest, i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
addq $0x20, %rsi
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
leaq 0x38(%rdi), %r12
xorl %r13d, %r13d
leaq 0x8(%rsp), %rbp
movq $0x0, (%rsp)
cmpq $0x7, %r13
je 0x178cf
imulq $0x18, %r13, %r15
addq 0x18(%rsp), %r15
xorl %r1... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::Compaction::Compaction(leveldb::Options const*, int) | Compaction::Compaction(const Options* options, int level)
: level_(level),
max_output_file_size_(MaxFileSizeForLevel(options, level)),
input_version_(nullptr),
grandparent_index_(0),
seen_key_(false),
overlapped_bytes_(0) {
for (int i = 0; i < config::kNumLevels; i++) {
level_ptr... | pushq %rbx
movq %rdi, %rbx
movl %edx, (%rdi)
movq 0x48(%rsi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
addq $0x18, %rdi
callq 0xf734
andq $0x0, 0x118(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rbx)
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xe0(%rbx)
movups %xmm0, 0xf0(%rbx)
movups %xmm0, 0x100(%rbx)
movb $0x0, 0... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::Compaction::IsBaseLevelForKey(leveldb::Slice const&) | bool Compaction::IsBaseLevelForKey(const Slice& user_key) {
// Maybe use binary search to find right entry instead of linear search?
const Comparator* user_cmp = input_version_->vset_->icmp_.user_comparator();
for (int lvl = level_ + 2; lvl < config::kNumLevels; lvl++) {
const std::vector<FileMetaData*>& file... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq (%rax), %rax
movq 0x40(%rax), %r15
movl (%rdi), %eax
addl $0x2, %eax
movslq %eax, %rbp
cmpq $0x6, %rbp
jg 0x18a52
movq 0x10(%r14), %rax
imulq $0x18, %rbp, %rcx
leaq (%rax,%rcx), ... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::Version::LevelFileNumIterator::LevelFileNumIterator(leveldb::InternalKeyComparator const&, std::vector<leveldb::FileMetaData*, std::allocator<leveldb::FileMetaData*>> const*) | LevelFileNumIterator(const InternalKeyComparator& icmp,
const std::vector<FileMetaData*>* flist)
: icmp_(icmp), flist_(flist), index_(flist->size()) { // Marks as invalid
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1a72c
leaq 0x21500(%rip), %rax # 0x3a098
movq %rax, (%r15)
leaq 0x21386(%rip), %rax # 0x39f28
addq $0x10, %rax
movq %rax, 0x28(%r15)
movq 0x8(%r14), %rax
movq %rax, 0x30(%r15)
movq %rbx, 0x38(%r15)
movq 0x8(%rbx), %rax
subq... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::VersionSet::Builder::SaveTo(leveldb::Version*) | void SaveTo(Version* v) {
BySmallestKey cmp;
cmp.internal_comparator = &vset_->icmp_;
for (int level = 0; level < config::kNumLevels; level++) {
// Merge the set of added files with the set of pre-existing files.
// Drop any deleted files. Store the result in *v.
const std::vector<FileMet... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
addq $0x38, %rax
movq %rax, 0x20(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsi), %rax
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
cmpq $0x7, %r12
je 0x19025
movq 0x8(%r14), ... | /CDDSCLab[P]leveldb/db/version_set.cc |
leveldb::WriteBatch::Iterate(leveldb::WriteBatch::Handler*) const | Status WriteBatch::Iterate(Handler* handler) const {
Slice input(rep_);
if (input.size() < kHeader) {
return Status::Corruption("malformed WriteBatch (too small)");
}
input.remove_prefix(kHeader);
Slice key, value;
int found = 0;
while (!input.empty()) {
found++;
char tag = input[0];
inpu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x40(%rsp)
cmpq $0xb, %rax
ja 0x1a3fa
leaq 0xcd54(%rip), %rax # 0x27125
leaq 0x58(%rsp), %rsi
movq %rax, (%rsi)
movq $0x20, 0x8(%rsi)
leaq 0xa39... | /CDDSCLab[P]leveldb/db/write_batch.cc |
leveldb::Iterator::~Iterator() | Iterator::~Iterator() {
if (!cleanup_head_.IsEmpty()) {
cleanup_head_.Run();
for (CleanupNode* node = cleanup_head_.next; node != nullptr;) {
node->Run();
CleanupNode* next_node = node->next;
delete node;
node = next_node;
}
}
} | pushq %r14
pushq %rbx
pushq %rax
leaq 0x1fa93(%rip), %rax # 0x3a1e0
movq %rax, (%rdi)
cmpq $0x0, 0x8(%rdi)
je 0x1a785
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x1a9a2
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
je 0x1a785
movq %rbx, %rdi
callq 0x1a9a2
movq 0x18(%rbx), %r14
movq %rbx, %rdi
callq 0x6390
movq %r14, %rbx
jmp 0... | /CDDSCLab[P]leveldb/table/iterator.cc |
leveldb::Table::ReadFilter(leveldb::Slice const&) | void Table::ReadFilter(const Slice& filter_handle_value) {
Slice v = filter_handle_value;
BlockHandle filter_handle;
if (!filter_handle.DecodeFrom(&v).ok()) {
return;
}
// We might want to unify with ReadBlock() if we start
// requiring checksum verification in Table::Open.
ReadOptions opt;
if (rep... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movdqu (%rsi), %xmm0
leaq 0x50(%rsp), %rdx
movdqa %xmm0, (%rdx)
pcmpeqd %xmm0, %xmm0
leaq 0x30(%rsp), %rsi
movdqa %xmm0, (%rsi)
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x2390c
movq (%r14), %r15
movq %r14, %rdi
callq 0x6db6
testq %r15, %r15
jne 0x1c25... | /CDDSCLab[P]leveldb/table/table.cc |
leveldb::(anonymous namespace)::TwoLevelIterator::InitDataBlock() | void TwoLevelIterator::InitDataBlock() {
if (!index_iter_.Valid()) {
SetDataIterator(nullptr);
} else {
Slice handle = index_iter_.value();
if (data_iter_.iter() != nullptr &&
handle.compare(data_block_handle_) == 0) {
// data_iter_ is already constructed with this iterator, so
// no... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x58(%rdi)
je 0x1cc07
leaq 0x50(%rbx), %rdi
callq 0x1b1de
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x70(%rbx)
je 0x1cbcb
movq 0x90(%rbx), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x98(%rbx), %rax
movq %rax, 0x8(%rsi)
movq %rs... | /CDDSCLab[P]leveldb/table/two_level_iterator.cc |
leveldb::(anonymous namespace)::TwoLevelIterator::SetDataIterator(leveldb::Iterator*) | void TwoLevelIterator::SetDataIterator(Iterator* data_iter) {
if (data_iter_.iter() != nullptr) SaveError(data_iter_.status());
data_iter_.Set(data_iter);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x70(%rdi), %r14
cmpq $0x0, 0x70(%rdi)
je 0x1ccbf
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1b20c
cmpq $0x0, 0x48(%r15)
jne 0x1ccb5
cmpq $0x0, 0x8(%rsp)
je 0x1ccb5
addq $0x48, %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xfa8e... | /CDDSCLab[P]leveldb/table/two_level_iterator.cc |
leveldb::Arena::AllocateFallback(unsigned long) | char* Arena::AllocateFallback(size_t bytes) {
if (bytes > kBlockSize / 4) {
// Object is more than a quarter of our block size. Allocate it separately
// to avoid wasting too much space in leftover bytes.
char* result = AllocateNewBlock(bytes);
return result;
}
// We waste the remaining space in... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x401, %rsi # imm = 0x401
jb 0x1cdd4
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1cdfc
movl $0x1000, %r15d # imm = 0x1000
movl $0x1000, %esi # imm = 0x1000
movq %r14, %rdi
callq 0x1cdfc
leaq (%ra... | /CDDSCLab[P]leveldb/util/arena.cc |
leveldb::(anonymous namespace)::ShardedLRUCache::Lookup(leveldb::Slice const&) | Handle* Lookup(const Slice& key) override {
const uint32_t hash = HashSlice(key);
return shard_[Shard(hash)].Lookup(key, hash);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1d946
movl %eax, %ebp
shrl $0x1c, %eax
imulq $0xd8, %rax, %r12
leaq (%r14,%r12), %rbx
addq $0x18, %rbx
movq %rbx, %rdi
callq 0xff50
leaq 0xd8(%r14), %rdi
addq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0... | /CDDSCLab[P]leveldb/util/cache.cc |
leveldb::(anonymous namespace)::ShardedLRUCache::Prune() | void Prune() override {
for (int s = 0; s < kNumShards; s++) {
shard_[s].Prune();
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
addq $0x10, %rdi
movq %rdi, 0x10(%rsp)
xorl %r15d, %r15d
leaq 0x18(%rsp), %r14
cmpq $0x10, %r15
je 0x1d6dc
imulq $0xd8, %r15, %r13
movq 0x10(%rsp), %rbp
movq %rbp, %r12
addq %r13, %r12
leaq 0x8(,%r13), %rdi
addq %rbp, %rdi
movq %rdi, 0x8... | /CDDSCLab[P]leveldb/util/cache.cc |
leveldb::GetVarint32PtrFallback(char const*, char const*, unsigned int*) | const char* GetVarint32PtrFallback(const char* p, const char* limit,
uint32_t* value) {
uint32_t result = 0;
for (uint32_t shift = 0; shift <= 28 && p < limit; shift += 7) {
uint32_t byte = *(reinterpret_cast<const unsigned char*>(p));
p++;
if (byte & 128) {
// M... | xorl %eax, %eax
xorl %r8d, %r8d
xorl %ecx, %ecx
cmpl $0x1c, %ecx
ja 0x1dc06
cmpq %rsi, %rdi
jae 0x1dc06
movzbl (%rdi), %r9d
testb %r9b, %r9b
jns 0x1dbf7
andl $0x7f, %r9d
shll %cl, %r9d
incq %rdi
orl %r9d, %r8d
addl $0x7, %ecx
jmp 0x1dbd2
shll %cl, %r9d
orl %r8d, %r9d
movl %r9d, (%rdx)
incq %rdi
movq %rdi, %rax
retq
| /CDDSCLab[P]leveldb/util/coding.cc |
leveldb::GetLengthPrefixedSlice(leveldb::Slice*, leveldb::Slice*) | bool GetLengthPrefixedSlice(Slice* input, Slice* result) {
uint32_t len;
if (GetVarint32(input, &len) && input->size() >= len) {
*result = Slice(input->data(), len);
input->remove_prefix(len);
return true;
} else {
return false;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
callq 0x1dc07
testb %al, %al
je 0x1dd26
movl 0x4(%rsp), %esi
cmpq %rsi, 0x8(%rbx)
jae 0x1dd2a
xorl %eax, %eax
jmp 0x1dd3e
movq (%rbx), %rax
movq %rax, (%r14)
movq %rsi, 0x8(%r14)
movq %rbx, %rdi
callq 0xfcd6
movb $0x1, %al
addq $0x8, ... | /CDDSCLab[P]leveldb/util/coding.cc |
leveldb::crc32c::Extend(unsigned int, char const*, unsigned long) | uint32_t Extend(uint32_t crc, const char* data, size_t n) {
static bool accelerate = CanAccelerateCRC32C();
if (accelerate) {
return port::AcceleratedCRC32C(crc, data, n);
}
const uint8_t* p = reinterpret_cast<const uint8_t*>(data);
const uint8_t* e = p + n;
uint32_t l = crc ^ kCRC32Xor;
// Process on... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
movb 0x1d56e(%rip), %al # 0x3b440
testb %al, %al
je 0x1e186
addq %r14, %rbx
notl %r15d
leaq 0x3(%r14), %rax
andq $-0x4, %rax
cmpq %rax, %rbx
jae 0x1def2
movq %r14, %rax
jmp 0x1df22
movq %ra... | /CDDSCLab[P]leveldb/util/crc32c.cc |
leveldb::AppendEscapedStringTo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, leveldb::Slice const&) | void AppendEscapedStringTo(std::string* str, const Slice& value) {
for (size_t i = 0; i < value.size(); i++) {
char c = value[i];
if (c >= ' ' && c <= '~') {
str->push_back(c);
} else {
char buf[10];
snprintf(buf, sizeof(buf), "\\x%02x",
static_cast<unsigned int>(c) & 0xff... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb0ae(%rip), %r15 # 0x297b8
leaq 0xe(%rsp), %r12
pushq $0xa
popq %r13
xorl %ebp, %ebp
cmpq 0x8(%rbx), %rbp
jae 0x1e75e
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x1a700
leal -0x20(%rax), %ecx
cmpb $... | /CDDSCLab[P]leveldb/util/logging.cc |
leveldb::Options::Options() | Options::Options() : comparator(BytewiseComparator()), env(Env::Default()) {} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1dd4a
movq %rax, (%rbx)
andw $0x0, 0x8(%rbx)
xorl %ebp, %ebp
movb %bpl, 0xa(%rbx)
callq 0x1eab0
movq %rax, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
movq $0x400000, 0x20(%rbx) # imm = 0x400000
movl $0x3e8, 0x28(%rbx) # imm = 0x3E8
andq $0x0, 0x30(%rbx)
movq $0x1000... | /CDDSCLab[P]leveldb/util/options.cc |
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.