name string | code string | asm string | file string |
|---|---|---|---|
leveldb::NewErrorIterator(leveldb::Status const&) | Iterator* NewErrorIterator(const Status& status) {
return new EmptyIterator(status);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x30, %edi
callq 0xa5c0
movq %rax, %rbx
movq (%r14), %rdi
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rax, 0x20(%rbx)
leaq 0x5c1a5(%rip), %rcx # 0x7f830
movq %rcx, (%rbx)
testq %rdi, %rdi
je 0x23698
callq 0x27780
movq %rax, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, ... | /walterzhaoJR[P]leveldb/table/iterator.cc |
leveldb::NewMergingIterator(leveldb::Comparator const*, leveldb::Iterator**, int) | Iterator* NewMergingIterator(const Comparator* comparator, Iterator** children,
int n) {
assert(n >= 0);
if (n == 0) {
return NewEmptyIterator();
} else if (n == 1) {
return children[0];
} else {
return new MergingIterator(comparator, children, n);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %edx, %edx
js 0x238a6
movl %edx, %ebp
movq %rsi, %rbx
cmpl $0x1, %edx
je 0x237eb
testl %ebp, %ebp
jne 0x237f3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2363d
movq (%rbx), %r14
jmp 0x2389a
movq %rdi, %r15
movl $0x50, %edi
callq 0xa5c0
movq %rax, ... | /walterzhaoJR[P]leveldb/table/merger.cc |
leveldb::(anonymous namespace)::MergingIterator::Next() | void Next() override {
assert(Valid());
// Ensure that all children are positioned after key().
// If we are moving in the forward direction, it is already
// true for all of the non-current_ children since current_ is
// the smallest child and key() == current_->key(). Otherwise,
// we explic... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x23b3a
cmpl $0x0, 0x48(%rbx)
je 0x23afb
cmpl $0x0, 0x38(%rbx)
jle 0x23af4
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
xorl %r15d, %r15d
movq 0x30(%rbx), %r14
leaq (%r14,%rbp... | /walterzhaoJR[P]leveldb/table/merger.cc |
leveldb::(anonymous namespace)::MergingIterator::key() const | Slice key() const override {
assert(Valid());
return current_->key();
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x23c4e
movq 0x40(%rbx), %rcx
cmpb $0x0, 0x8(%rcx)
je 0x23c6d
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %rdx
popq %rbx
retq
leaq 0x36914(%rip), %rdi # 0x5a569
leaq 0x389bc(%rip), %rsi # 0x5c618
leaq 0x38c5c(%rip), %rcx # 0x5c8bf
m... | /walterzhaoJR[P]leveldb/table/merger.cc |
leveldb::(anonymous namespace)::MergingIterator::status() const | Status status() const override {
Status status;
for (int i = 0; i < n_; i++) {
status = children_[i].status();
if (!status.ok()) {
break;
}
}
return status;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x38(%rsi)
jle 0x23d11
movq %rsi, %r14
leaq 0x8(%rsp), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x30(%r14), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0x240c6
movq 0x8(%rsp), %rax
testq %rax, %rax
jne 0x23d13
incq %r... | /walterzhaoJR[P]leveldb/table/merger.cc |
leveldb::(anonymous namespace)::MergingIterator::FindLargest() | void MergingIterator::FindLargest() {
IteratorWrapper* largest = nullptr;
for (int i = n_ - 1; i >= 0; i--) {
IteratorWrapper* child = &children_[i];
if (child->Valid()) {
if (largest == nullptr) {
largest = child;
} else if (comparator_->Compare(child->key(), largest->key()) > 0) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0x38(%rdi), %r12
testq %r12, %r12
jle 0x23e6d
leaq 0x1(%r12), %r13
shlq $0x5, %r12
addq $-0x20, %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq 0x30(%rbx), %rax
cmpb $0x1, 0x8(%rax,%r12)
jne 0x23e5e
leaq (%rax,%r12)... | /walterzhaoJR[P]leveldb/table/merger.cc |
leveldb::IteratorWrapper::SeekToLast() | void SeekToLast() {
assert(iter_);
iter_->SeekToLast();
Update();
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x23f7b
movq (%rdi), %rax
callq *0x20(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, 0x8(%rbx)
testb %al, %al
je 0x23f79
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
popq %rbx
ret... | /walterzhaoJR[P]leveldb/./table/iterator_wrapper.h |
leveldb::IteratorWrapper::Seek(leveldb::Slice const&) | void Seek(const Slice& k) {
assert(iter_);
iter_->Seek(k);
Update();
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x23fcf
movq (%rdi), %rax
callq *0x28(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, 0x8(%rbx)
testb %al, %al
je 0x23fcd
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
popq %rbx
ret... | /walterzhaoJR[P]leveldb/./table/iterator_wrapper.h |
leveldb::IteratorWrapper::Next() | void Next() {
assert(iter_);
iter_->Next();
Update();
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x24023
movq (%rdi), %rax
callq *0x30(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, 0x8(%rbx)
testb %al, %al
je 0x24021
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
popq %rbx
ret... | /walterzhaoJR[P]leveldb/./table/iterator_wrapper.h |
leveldb::TableBuilder::Add(leveldb::Slice const&, leveldb::Slice const&) | void TableBuilder::Add(const Slice& key, const Slice& value) {
Rep* r = rep_;
assert(!r->closed);
if (!ok()) return;
if (r->num_entries > 0) {
assert(r->options.comparator->Compare(key, Slice(r->last_key)) > 0);
}
if (r->pending_index_entry) {
assert(r->data_block.empty());
r->options.comparato... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %r13
cmpb $0x1, 0x1d0(%r13)
je 0x2441d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x24cce
testb %al, %al
je 0x2440e
cmpq $0x0, 0x1c8(%r13)
jle 0x24308
movq (%r13), %rdi
movq 0x1a8(%r13), %rax
leaq 0x8(%rsp), %rdx
... | /walterzhaoJR[P]leveldb/table/table_builder.cc |
leveldb::TableBuilder::Flush() | void TableBuilder::Flush() {
Rep* r = rep_;
assert(!r->closed);
if (!ok()) return;
if (r->data_block.empty()) return;
assert(!r->pending_index_entry);
WriteBlock(&r->data_block, &r->pending_handle);
if (ok()) {
r->pending_index_entry = true;
r->status = r->file->Flush();
}
if (r->filter_block ... | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
cmpb $0x1, 0x1d0(%r14)
je 0x24536
movq %rdi, %rbx
callq 0x24cce
testb %al, %al
je 0x2452e
cmpq $0x0, 0xe8(%r14)
je 0x2452e
cmpb $0x1, 0x1e0(%r14)
je 0x24555
leaq 0xd8(%r14), %rsi
leaq 0x1e8(%r14), %rdx
movq %rbx, %rdi
callq 0x24574
movq %rbx, %rdi
callq 0x24cce
testb %... | /walterzhaoJR[P]leveldb/table/table_builder.cc |
leveldb::TableBuilder::WriteBlock(leveldb::BlockBuilder*, leveldb::BlockHandle*) | void TableBuilder::WriteBlock(BlockBuilder* block, BlockHandle* handle) {
// File format contains a sequence of blocks where each block has:
// block_data: uint8[n]
// type: uint8
// crc: uint32
assert(ok());
Rep* r = rep_;
Slice raw = block->Finish();
Slice block_contents;
CompressionType t... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x24cce
testb %al, %al
je 0x24604
movq (%r15), %r12
movq %rbx, %rdi
callq 0x2b5e2
leaq 0x3d822(%rip), %rcx # 0x61dc5
movq %rcx, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl 0x50(%r12), %ecx
cmpl $0x1, %ecx
ja ... | /walterzhaoJR[P]leveldb/table/table_builder.cc |
leveldb::TableBuilder::Finish() | Status TableBuilder::Finish() {
Rep* r = rep_;
Flush();
assert(!r->closed);
r->closed = true;
BlockHandle filter_block_handle, metaindex_block_handle, index_block_handle;
// Write filter block
if (ok() && r->filter_block != nullptr) {
WriteRawBlock(r->filter_block->Finish(), kNoCompression,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r14
movq %rsi, %rdi
callq 0x2447a
cmpb $0x1, 0x1d0(%r14)
je 0x24aaa
movb $0x1, 0x1d0(%r14)
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, 0x40(%rsp)
movdqa %xmm0, 0x30(%rsp)
movdqa %xmm0, 0x20(%rsp)
movq... | /walterzhaoJR[P]leveldb/table/table_builder.cc |
leveldb::TableBuilder::Rep::Rep(leveldb::Options const&, leveldb::WritableFile*) | Rep(const Options& opt, WritableFile* f)
: options(opt),
index_block_options(opt),
file(f),
offset(0),
data_block(&options),
index_block(&index_block_options),
num_entries(0),
closed(false),
filter_block(opt.filter_policy == nullptr
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0xc, %ecx
rep movsq (%rsi), %es:(%rdi)
leaq 0x60(%rbx), %r15
movl $0xc, %ecx
movq %r15, %rdi
movq %r14, %rsi
rep movsq (%rsi), %es:(%rdi)
movq %rdx, 0xc0(%rbx)
leaq 0xd8(%rbx), %rdi
pxor %xmm0, %xmm0
movdqu %xmm0, 0xc8(%rbx)
movq %rbx, %rsi
callq ... | /walterzhaoJR[P]leveldb/table/table_builder.cc |
leveldb::Arena::AllocateNewBlock(unsigned long) | char* Arena::AllocateNewBlock(size_t block_bytes) {
char* result = new char[block_bytes];
blocks_.push_back(result);
memory_usage_.fetch_add(block_bytes + sizeof(char*),
std::memory_order_relaxed);
return result;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xa040
movq %rax, 0x8(%rsp)
movq 0x18(%r14), %rsi
cmpq 0x20(%r14), %rsi
je 0x25cec
movq %rax, (%rsi)
addq $0x8, 0x18(%r14)
jmp 0x25d00
leaq 0x10(%r14), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x25d74
movq (%r... | /walterzhaoJR[P]leveldb/util/arena.cc |
leveldb::Arena::AllocateAligned(unsigned long) | char* Arena::AllocateAligned(size_t bytes) {
const int align = (sizeof(void*) > 8) ? sizeof(void*) : 8;
static_assert((align & (align - 1)) == 0,
"Pointer size should be a power of 2");
size_t current_mod = reinterpret_cast<uintptr_t>(alloc_ptr_) & (align - 1);
size_t slop = (current_mod == 0 ? ... | pushq %rax
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
movl %edx, %r8d
andl $0x7, %r8d
movl $0x8, %eax
subq %r8, %rax
testq %r8, %r8
cmoveq %r8, %rax
leaq (%rax,%rsi), %r8
subq %r8, %rcx
jae 0x25d42
callq 0x25c70
jmp 0x25d4f
addq %rdx, %rax
addq %rdx, %r8
movq %r8, (%rdi)
movq %rcx, 0x8(%rdi)
testb $0x7, %al
jne 0x25d55
pop... | /walterzhaoJR[P]leveldb/util/arena.cc |
leveldb::(anonymous namespace)::ShardedLRUCache::~ShardedLRUCache() | ~ShardedLRUCache() override {} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x59a2d(%rip), %rax # 0x7f9c8
movq %rax, (%rdi)
movl $0xd90, %r15d # imm = 0xD90
leaq (%rbx,%r15), %rax
addq $-0x58, %rax
cmpq %rax, 0x18(%rax)
jne 0x26058
leaq (%rbx,%r15), %r14
addq $-0xd8, %r14
leaq 0x38(%r14), %r12
movq 0x50(%... | /walterzhaoJR[P]leveldb/util/cache.cc |
leveldb::(anonymous namespace)::ShardedLRUCache::Insert(leveldb::Slice const&, void*, unsigned long, void (*)(leveldb::Slice const&, void*)) | Handle* Insert(const Slice& key, void* value, size_t charge,
void (*deleter)(const Slice& key, void* value)) override {
const uint32_t hash = HashSlice(key);
return shard_[Shard(hash)].Insert(key, hash, value, charge, deleter);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
xorl %edx, %edx
callq 0x274d4
movl %eax, %ebp
shrl $0x1c, %eax
imulq $0xd8, %rax, %r15
leaq (%r14,%r15), %rdi
a... | /walterzhaoJR[P]leveldb/util/cache.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, %r14
movq %rdi, %r15
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
xorl %edx, %edx
callq 0x274d4
movl %eax, %ebp
shrl $0x1c, %eax
imulq $0xd8, %rax, %r12
leaq (%r15,%r12), %rbx
addq $0x18, %rbx
movq %rbx, %rdi
callq 0xa950
testl %eax, %eax
jne 0x26382
addq %r12... | /walterzhaoJR[P]leveldb/util/cache.cc |
leveldb::(anonymous namespace)::ShardedLRUCache::TotalCharge() const | size_t TotalCharge() const override {
size_t total = 0;
for (int s = 0; s < kNumShards; s++) {
total += shard_[s].TotalCharge();
}
return total;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
xorl %r13d, %r13d
xorl %r14d, %r14d
leaq (%r12,%r13), %r15
movq %r15, %rdi
callq 0xa950
testl %eax, %eax
jne 0x265fa
addq 0x40(%rbx,%r13), %r14
movq %r15, %rdi
callq 0xa4a0
addq $0xd8, %r13
cmpq $0xd80, %r13 # imm = ... | /walterzhaoJR[P]leveldb/util/cache.cc |
leveldb::GetLengthPrefixedSlice(char const*, char const*, leveldb::Slice*) | inline const char* GetVarint32Ptr(const char* p, const char* limit,
uint32_t* value) {
if (p < limit) {
uint32_t result = *(reinterpret_cast<const uint8_t*>(p));
if ((result & 128) == 0) {
*value = result;
return p + 1;
}
}
return GetVarint32PtrFallback(p,... | cmpq %rsi, %rdi
jae 0x26c65
movzbl (%rdi), %r9d
incq %rdi
testb %r9b, %r9b
jns 0x26c59
xorl %eax, %eax
xorl %r10d, %r10d
xorl %ecx, %ecx
cmpl $0x15, %ecx
ja 0x26c67
cmpq %rsi, %rdi
jae 0x26c67
leal 0x7(%rcx), %r8d
andl $0x7f, %r9d
shll %cl, %r9d
orl %r9d, %r10d
movzbl (%rdi), %r9d
incq %rdi
movl %r8d, %ecx
testb %r9b, ... | /walterzhaoJR[P]leveldb/./util/coding.h |
leveldb::Status::Status(leveldb::Status::Code, leveldb::Slice const&, leveldb::Slice const&) | Status::Status(Code code, const Slice& msg, const Slice& msg2) {
assert(code != kOk);
const uint32_t len1 = static_cast<uint32_t>(msg.size());
const uint32_t len2 = static_cast<uint32_t>(msg2.size());
const uint32_t size = len1 + (len2 ? (2 + len2) : 0);
char* result = new char[size + 5];
std::memcpy(result... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
testl %esi, %esi
je 0x27854
movq %rdx, %r12
movl %esi, %ebp
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rbx
leal 0x2(%rbx), %eax
testl %ebx, %ebx
cmovel %ebx, %eax
movq 0x8(%rdx), %r13
leal (%rax,%r13), %edi
addl $0x5, %e... | /walterzhaoJR[P]leveldb/util/status.cc |
leveldb::(anonymous namespace)::PosixEnv::GetFileSize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long*) | Status GetFileSize(const std::string& filename, uint64_t* size) override {
struct ::stat file_stat;
if (::stat(filename.c_str(), &file_stat) != 0) {
*size = 0;
return PosixError(filename, errno);
}
*size = file_stat.st_size;
return Status::OK();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
movq %rsp, %rsi
callq 0xa540
testl %eax, %eax
je 0x28295
movq $0x0, (%r15)
callq 0xa070
movl (%rax), %ecx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x28add
jmp 0x282a4
movq 0x30(%rsp), ... | /walterzhaoJR[P]leveldb/util/env_posix.cc |
leveldb::(anonymous namespace)::PosixEnv::UnlockFile(leveldb::FileLock*) | Status UnlockFile(FileLock* lock) override {
PosixFileLock* posix_file_lock = static_cast<PosixFileLock*>(lock);
if (LockOrUnlock(posix_file_lock->fd(), false) == -1) {
return PosixError("unlock " + posix_file_lock->filename(), errno);
}
locks_.Remove(posix_file_lock->filename());
::close(posi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdx), %ebp
callq 0xa070
movq %rax, %r12
movl $0x0, (%rax)
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movw $0x2, (%rdx)
movups %xmm0, 0x8(%rdx)
movl %ebp... | /walterzhaoJR[P]leveldb/util/env_posix.cc |
leveldb::(anonymous namespace)::PosixSequentialFile::~PosixSequentialFile() | ~PosixSequentialFile() override { close(fd_); } | pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %edi
callq 0xacb0
movq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x28b7c
callq 0xa570
movq %rbx, %rdi
popq %rbx
jmp 0x271da
nop
| /walterzhaoJR[P]leveldb/util/env_posix.cc |
leveldb::(anonymous namespace)::PosixWritableFile::WriteUnbuffered(char const*, unsigned long) | Status WriteUnbuffered(const char* data, size_t size) {
while (size > 0) {
ssize_t write_result = ::write(fd_, data, size);
if (write_result < 0) {
if (errno == EINTR) {
continue; // Retry
}
return PosixError(filename_, errno);
}
data += write_result;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rcx, %rcx
je 0x2935b
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movl 0x10010(%r14), %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0xa1d0
testq %rax, %rax
js 0x2934a
addq %rax, %r12
subq %rax, %r15
jmp 0x29356
callq 0xa070
movl (%rax), %ecx
... | /walterzhaoJR[P]leveldb/util/env_posix.cc |
leveldb::(anonymous namespace)::PosixLockTable::Remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | LOCKS_EXCLUDED(mu_) {
mu_.Lock();
locked_files_.erase(fname);
mu_.Unlock();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa950
testl %eax, %eax
jne 0x2940d
leaq 0x28(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x29940
movq %r15, %rdi
movq %rax, %rsi
callq 0x29a02
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xa4a0
movl %eax, %edi
callq 0xa3f0
| /walterzhaoJR[P]leveldb/util/env_posix.cc |
leveldb::(anonymous namespace)::PosixFileLock::~PosixFileLock() | PosixFileLock(int fd, std::string filename)
: fd_(fd), filename_(std::move(filename)) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x56a8f(%rip), %rax # 0x7fed8
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x2945e
callq 0xa570
movq %rbx, %rdi
callq 0x271ea
movq %rbx, %rdi
popq %rbx
jmp 0xa570
nop
| /walterzhaoJR[P]leveldb/util/env_posix.cc |
leveldb::PosixLogger::Logv(char const*, __va_list_tag*) | void Logv(const char* format, std::va_list arguments) override {
// Record the time as close to the Logv() call as possible.
struct ::timeval now_timeval;
::gettimeofday(&now_timeval, nullptr);
const std::time_t now_seconds = now_timeval.tv_sec;
struct std::tm now_components;
::localtime_r(&now_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xaa90
movq (%rbx), %rax
leaq 0x80(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x48(%rsp), %rsi
callq 0xa... | /walterzhaoJR[P]leveldb/./util/posix_logger.h |
leveldb::(anonymous namespace)::InMemoryEnv::~InMemoryEnv() | ~InMemoryEnv() override {
for (const auto& kvp : file_map_) {
kvp.second->Unref();
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x560b1(%rip), %rax # 0x7ff70
movq %rax, (%rdi)
movq 0x50(%rdi), %r14
leaq 0x40(%rdi), %r15
cmpq %r15, %r14
je 0x29ee8
movq 0x40(%r14), %rdi
callq 0x2a6de
movq %r14, %rdi
callq 0xa420
movq %rax, %r14
cmpq %r15, %rax
jne 0x29ecf
movq 0x48(%rbx), %rdi
callq 0x2a7c... | /walterzhaoJR[P]leveldb/helpers/memenv/memenv.cc |
leveldb::(anonymous namespace)::InMemoryEnv::NewRandomAccessFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, leveldb::RandomAccessFile**) | Status NewRandomAccessFile(const std::string& fname,
RandomAccessFile** result) override {
MutexLock lock(&mutex_);
if (file_map_.find(fname) == file_map_.end()) {
*result = nullptr;
return Status::IOError(fname, "File not found");
}
*result = new RandomAccessFi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rsi), %r14
movq %r14, %rdi
callq 0xa950
testl %eax, %eax
jne 0x2a0d1
leaq 0x38(%r13), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2a820
addq $0x40, %r13
cmpq %r1... | /walterzhaoJR[P]leveldb/helpers/memenv/memenv.cc |
leveldb::(anonymous namespace)::InMemoryEnv::RemoveFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Status RemoveFile(const std::string& fname) override {
MutexLock lock(&mutex_);
if (file_map_.find(fname) == file_map_.end()) {
return Status::IOError(fname, "File not found");
}
RemoveFileInternal(fname);
return Status::OK();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rsi), %r14
movq %r14, %rdi
callq 0xa950
testl %eax, %eax
jne 0x2a46d
leaq 0x38(%r12), %rdi
movq %r15, %rsi
callq 0x2a820
leaq 0x40(%r12), %rcx
cmpq %rcx, %rax
je 0x2a41f
movq %r12, %rdi
movq %r15, %rs... | /walterzhaoJR[P]leveldb/helpers/memenv/memenv.cc |
leveldb::(anonymous namespace)::InMemoryEnv::RenameFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Status RenameFile(const std::string& src,
const std::string& target) override {
MutexLock lock(&mutex_);
if (file_map_.find(src) == file_map_.end()) {
return Status::IOError(src, "File not found");
}
RemoveFileInternal(target);
file_map_[target] = file_map_[src];
file_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x10(%rsi), %r14
movq %r14, %rdi
callq 0xa950
testl %eax, %eax
jne 0x2a61e
leaq 0x38(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2a820
leaq 0x40(%rbp), %rcx
cmp... | /walterzhaoJR[P]leveldb/helpers/memenv/memenv.cc |
leveldb::(anonymous namespace)::FileState::Unref() | void Unref() {
bool do_delete = false;
{
MutexLock lock(&refs_mutex_);
--refs_;
assert(refs_ >= 0);
if (refs_ <= 0) {
do_delete = true;
}
}
if (do_delete) {
delete this;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xa950
testl %eax, %eax
jne 0x2a739
movl 0x28(%rbx), %r14d
leal -0x1(%r14), %eax
movl %eax, 0x28(%rbx)
testl %r14d, %r14d
jle 0x2a740
movq %rbx, %rdi
callq 0xa4a0
cmpl $0x1, %r14d
jne 0x2a731
movq %rbx, %rdi
callq 0x2a760
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0... | /walterzhaoJR[P]leveldb/helpers/memenv/memenv.cc |
leveldb::BlockBuilder::BlockBuilder(leveldb::Options const*) | BlockBuilder::BlockBuilder(const Options* options)
: options_(options), restarts_(), counter_(0), finished_(false) {
assert(options->block_restart_interval >= 1);
restarts_.push_back(0); // First restart point is at offset 0
} | pushq %rax
movq %rsi, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x58(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x35(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
cmpl $0x0, 0x40(%rsi)
jle 0x2b539... | /walterzhaoJR[P]leveldb/table/block_builder.cc |
leveldb::Block::Iter::Iter(leveldb::Comparator const*, char const*, unsigned int, unsigned int) | Iter(const Comparator* comparator, const char* data, uint32_t restarts,
uint32_t num_restarts)
: comparator_(comparator),
data_(data),
restarts_(restarts),
num_restarts_(num_restarts),
current_(restarts_),
restart_index_(num_restarts_) {
assert(num_restarts_ > 0)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x23558
leaq 0x5463c(%rip), %rax # 0x800f8
movq %rax, (%r12)
movq %r15, 0x28(%r12)
movq %r14, 0x30(%r12)
movl %ebp, 0x38(%r12)
movl %ebx, 0x3c(%r12)
movl %ebp, 0x40(%r12)
movl... | /walterzhaoJR[P]leveldb/table/block.cc |
leveldb::Block::Iter::Prev() | void Prev() override {
assert(Valid());
// Scan backwards to a restart point before current_
const uint32_t original = current_;
while (GetRestartPoint(restart_index_) >= original) {
if (restart_index_ == 0) {
// No more entries
current_ = restarts_;
restart_index_ = num_r... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x2be9c
movl 0x3c(%rbx), %eax
movl 0x44(%rbx), %esi
cmpl %esi, %eax
jbe 0x2be4d
movl 0x40(%rbx), %ebp
movl 0x38(%rbx), %ecx
movq %rcx, %rdx
addq 0x30(%rbx), %rdx
leal -0x1(%rsi), %edi
movl %esi, %r8d
cmpl %ebp, (%rdx,... | /walterzhaoJR[P]leveldb/table/block.cc |
leveldb::Block::Iter::CorruptionError() | void CorruptionError() {
current_ = restarts_;
restart_index_ = num_restarts_;
status_ = Status::Corruption("bad entry in block");
key_.clear();
value_.clear();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq %rax, 0x40(%rdi)
leaq 0x3302d(%rip), %rax # 0x5f178
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
movq $0x12, 0x8(%rdx)
leaq 0x35c63(%rip), %r15 # 0x61dc5
leaq 0x10(%rsp), %rcx
movq %r15, (%rcx)
movq $0x0, 0x8(%rcx)
leaq 0x8(... | /walterzhaoJR[P]leveldb/table/block.cc |
leveldb::FilterBlockBuilder::FilterBlockBuilder(leveldb::FilterPolicy const*) | FilterBlockBuilder::FilterBlockBuilder(const FilterPolicy* policy)
: policy_(policy) {} | movq %rsi, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movq %rax, 0x38(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x70(%rd... | /walterzhaoJR[P]leveldb/table/filter_block.cc |
leveldb::FilterBlockBuilder::StartBlock(unsigned long) | void FilterBlockBuilder::StartBlock(uint64_t block_offset) {
uint64_t filter_index = (block_offset / kFilterBase);
assert(filter_index >= filter_offsets_.size());
while (filter_index > filter_offsets_.size()) {
GenerateFilter();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
shrq $0xb, %rbx
movq 0x80(%rdi), %rax
subq 0x78(%rdi), %rax
sarq $0x2, %rax
cmpq %rax, %rbx
jb 0x2c242
jbe 0x2c23a
movq %rdi, %r14
movq %r14, %rdi
callq 0x2c262
movq 0x80(%r14), %rax
subq 0x78(%r14), %rax
sarq $0x2, %rax
cmpq %rax, %rbx
ja 0x2c21e
addq $0x8, %rsp
popq %r... | /walterzhaoJR[P]leveldb/table/filter_block.cc |
testing::internal::ExpectationBase::~ExpectationBase() | ExpectationBase::~ExpectationBase() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x51a57(%rip), %rax # 0x80160
movq %rax, (%rdi)
addq $0xb0, %rdi
callq 0x3144e
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x2e729
callq 0xa570
leaq 0x50(%rbx), %rdi
callq 0x3205c
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x2e740
callq 0x1098a
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmp... | /walterzhaoJR[P]leveldb/third_party/googletest/googlemock/src/gmock-spec-builders.cc |
testing::internal::ThreadLocal<testing::Sequence*>::~ThreadLocal() | ~ThreadLocal() {
// Destroys the managed object for the current thread, if any.
DeleteThreadLocalValue(pthread_getspecific(key_));
// Releases resources associated with the key. This will *not*
// delete managed objects for other threads.
GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0xa9b0
testq %rax, %rax
je 0x3165f
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl (%rbx), %edi
callq 0xa720
testl %eax, %eax
je 0x316cf
movl %eax, %ebp
leaq 0x2e98c(%rip), %rdx # 0x5ffff
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x6d... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::ThreadLocal<testing::Sequence*>::GetOrCreateValue() const | T* GetOrCreateValue() const {
ThreadLocalValueHolderBase* const holder =
static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
if (holder != nullptr) {
return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
}
ValueHolder* const new_holder = default_factory_->Ma... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0xa9b0
movq %rax, %rbx
testq %rax, %rax
jne 0x32cfb
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0xa0d0
testl %eax, %eax
je 0x32cfb
movl %eax, %ebp
leaq 0x2d360(%... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::Random::Generate(unsigned int) | uint32_t Random::Generate(uint32_t range) {
// These constants are the same as are used in glibc's rand(3).
// Use wider types than necessary to prevent unsigned overflow diagnostics.
state_ = static_cast<uint32_t>(1103515245ULL*state_ + 12345U) % kMaxRange;
GTEST_CHECK_(range > 0)
<< "Cannot generate a ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
imull $0x41c64e6d, (%rdi), %eax # imm = 0x41C64E6D
addl $0x3039, %eax # imm = 0x3039
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movl %eax, (%rdi)
testl %esi, %esi
je 0x33218
cmpl $0x80000001, %ebx # imm = 0x80000001
j... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::InternalStrings::GetId(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | size_t GetId(const std::string& str) {
IdMap::iterator it = ids_.find(str);
if (it != ids_.end()) return it->second;
size_t id = ids_.size();
return ids_[str] = id;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x53a9c
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x3733f
movq 0x40(%rax), %r15
jmp 0x37351
movq 0x28(%r14), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x53a20
movq %r15, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseEnd(testing::TestSuite const&) | void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
if (!GTEST_FLAG(print_time)) return;
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(GTestColor::kGreen, "[----------] ");
printf("%s from %s (%s ms total)\n\n", coun... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpb $0x1, 0x44843(%rip) # 0x819f1
jne 0x3d273
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x3d1d8
movq (%rax), %rdx
movzbl 0x80(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x3d1c1
leaq 0x25604(%rip), %rdx #... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(std::ostream*, char const*, testing::TestInfo const&) | void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
const char* test_suite_name,
const TestInfo& test_info) {
const TestResult& result = *test_info.result();
const std::string kTestsuite = "testcas... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
leaq 0x88(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x22123(%rip), %rsi # 0x61f7e
leaq 0x22124(%rip), %rdx # 0x61f86
leaq 0x78(%rsp), %rdi
callq 0x105c0
cmpb $0x0, 0x83(%r14)
jne... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestProperties(std::ostream*, testing::TestResult const&) | void XmlUnitTestResultPrinter::OutputXmlTestProperties(
std::ostream* stream, const TestResult& result) {
const std::string kProperties = "properties";
const std::string kProperty = "property";
if (result.test_property_count() <= 0) {
return;
}
*stream << "<" << kProperties << ">\n";
for (int i = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2165d(%rip), %rsi # 0x6208e
leaq 0x21660(%rip), %rdx # 0x62098
leaq 0x28(%rsp), %rdi
callq 0x105c0
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
l... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes[abi:cxx11](testing::TestResult const&) | std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
const TestResult& result) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << " " << property.key() << "="
<< "\"" << EscapeXmlA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, 0x18(%rsp)
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x36908
movq 0x58(%r15), %rax
subq 0x50(%r15), %rax
shrq $0x6, %rax
movq (%rbx), %rcx
movq %rcx, 0x10(%rsp)
testl %eax, %eax
jle 0x41393
movq 0x10(%rsp), %... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(std::ostream*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | void JsonUnitTestResultPrinter::OutputJsonKey(
std::ostream* stream,
const std::string& element_name,
const std::string& name,
int value,
const std::string& indent,
bool comma) {
const std::vector<std::string>& allowed_names =
GetReservedOutputAttributesForElement(element_name);
GTEST... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movq %r8, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl %ecx, 0xc(%rsp)
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0x3fd02
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r14, %rdx
callq 0x57134
cmpq 0x38(%rsp),... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::FormatEpochTimeInMillisAsRFC3339[abi:cxx11](long) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
struct tm time_struct;
if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
return "";
// YYYY-MM-DDThh:mm:ss
return StreamableToString(time_struct.tm_year + 1900) + "-" +
String::FormatIntWidth2(time_struct.tm_mon... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rsi, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, (%rdi)
lea... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::TestPropertiesAsJson(testing::TestResult const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
const TestResult& result, const std::string& indent) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << ",\n" << indent << "\"" << property.key... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x36908
movq 0x58(%r12), %rax
subq 0x50(%r12), %rax
shrq $0x6, %rax
movq (%rbx), %rcx
movq %rcx, 0x10(%rsp)
testl %eax, %eax
jle 0x43866
mo... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::StreamingListener::SocketWriter::MakeConnection() | void StreamingListener::SocketWriter::MakeConnection() {
GTEST_CHECK_(sockfd_ == -1)
<< "MakeConnection() can't be called when there is already a connection.";
addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses.
hints.ai_socktype =... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
je 0x443b2
leaq 0x1ceb0(%rip), %rdx # 0x61214
leaq 0x10(%rsp), %rdi
movl $0x3, %esi
movl $0x128b, %ecx # imm = 0x128B
callq 0x4d76a
movq 0x3cc69(%rip), %rdi # 0x80fe8
leaq 0x1dde6(%rip), %rsi # 0x621... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::TestEventListeners::SetDefaultResultPrinter(testing::TestEventListener*) | void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
if (default_result_printer_ != listener) {
// It is an error to pass this method a listener that is already in the
// list.
delete Release(default_result_printer_);
default_result_printer_ = listener;
if (listener != n... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rbx, %rsi
je 0x44676
movq %rdi, %r14
movq $0x0, 0x8(%rdi)
movq (%rdi), %rdi
callq 0x3de32
testq %rax, %rax
je 0x4465b
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x8(%r14)
testq %rbx, %rbx
je 0x44676
movq (%r14), %rdi
movq %rb... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::UnitTest::test_case_to_run_count() const | const internal::UnitTestImpl* impl() const { return impl_; } | movq 0x40(%rdi), %rax
movq 0xb8(%rax), %rcx
movq 0xc0(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x44754
movq (%rcx), %rsi
movzbl 0x70(%rsi), %esi
addl %esi, %eax
addq $0x8, %rcx
jmp 0x44740
retq
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.h |
testing::UnitTest::GetTestCase(int) const | inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
: v[static_cast<size_t>(i)];
} | testl %esi, %esi
js 0x44801
movq 0x40(%rdi), %rax
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x44801
movl %esi, %edx
cmpl $0x0, (%rcx,%rdx,4)
js 0x44801
movq 0xb8(%rax), %rax
movq (%rax,%rdx,8), %rax
retq
xorl %eax, %eax
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-internal-inl.h |
testing::UnitTest::AddEnvironment(testing::Environment*) | Environment* UnitTest::AddEnvironment(Environment* env) {
if (env == nullptr) {
return nullptr;
}
impl_->environments().push_back(env);
return env;
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0x44873
movq %rsi, %rax
movq 0x40(%rdi), %rdi
movq 0xa8(%rdi), %rsi
cmpq 0xb0(%rdi), %rsi
je 0x44877
movq %rax, (%rsi)
addq $0x8, 0xa8(%rdi)
jmp 0x4488e
xorl %eax, %eax
jmp 0x4488e
addq $0xa0, %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x577d8
mo... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::UnitTest::Run() | int UnitTest::Run() {
const bool in_death_test_child_process =
internal::GTEST_FLAG(internal_run_death_test).length() > 0;
// Google Test implements this protocol for catching that a test
// program exits before returning control to Google Test:
//
// 1. Upon start, Google Test creates a file whose a... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x3d13e(%rip) # 0x81ac8
je 0x44990
xorl %esi, %esi
jmp 0x4499f
leaq 0x1d8b8(%rip), %rdi # 0x6224f
callq 0xa770
movq %rax, %rsi
movq %rsp, %rdi
callq 0x51cfc
movq 0x40(%rbx), %rdi
movb 0x3cfd4(%rip), %al # 0x81985
movb %al, 0x258(%rdi)
leaq 0x36(%rip), ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::UnitTest::current_test_suite() const | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
return impl_->current_test_suite();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x317ce
movq 0x40(%rbx), %rax
movq 0x168(%rax), %rbx
movq %r14, %rdi
callq 0x3173c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x318d7
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::UnitTest::current_test_info() const | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
return impl_->current_test_info();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x317ce
movq 0x40(%rbx), %rax
movq 0x170(%rax), %rbx
movq %r14, %rdi
callq 0x3173c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x318d7
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::~UnitTestImpl() | UnitTestImpl::~UnitTestImpl() {
// Deletes every TestSuite.
ForEach(test_suites_, internal::Delete<TestSuite>);
// Deletes every Environment.
ForEach(environments_, internal::Delete<Environment>);
delete os_stack_trace_getter_;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3b0d9(%rip), %rax # 0x805d8
movq %rax, (%rdi)
movq 0xb8(%rdi), %r14
movq 0xc0(%rdi), %r15
cmpq %r15, %r14
je 0x45529
movq (%r14), %rdi
testq %rdi, %rdi
je 0x45523
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x45510
movq 0xa0(%rbx), %r14
movq 0xa8(%r... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::PostFlagParsingInit() | void UnitTestImpl::PostFlagParsingInit() {
// Ensures that this function does not execute more than once.
if (!post_flag_parse_init_performed_) {
post_flag_parse_init_performed_ = true;
#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
// Register to send notifications about key process state changes.
lis... | cmpb $0x0, 0x218(%rdi)
je 0x459fc
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x218(%rdi)
leaq 0x238(%rdi), %r14
callq 0x4c8e4
movq %r14, %rdi
movq %rax, %rsi
callq 0x55806
cmpq $0x0, 0x238(%rbx)
je 0x45a36
movq 0x1f8(%rbx), %rax
movb $0x0, 0x8(%rax)
movq %rbx, %rdi
callq 0x3ba30
movq %rbx, %rdi
ca... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::FilterTests(testing::internal::UnitTestImpl::ReactionToSharding) | int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
// num_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
movl %esi, 0x18(%rsp)
testl %esi, %esi
jne 0x45d5d
leaq 0x1a8e6(%rip), %rdi # 0x60620
movl $0xffffffff, %esi # imm ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::ParseInt32(testing::Message const&, char const*, int*) | bool ParseInt32(const Message& src_text, const char* str, int32_t* value) {
// Parses the environment variable as a decimal integer.
char* end = nullptr;
const long long_value = strtol(str, &end, 10); // NOLINT
// Has strtol() consumed all characters in the string?
if (*end != '\0') {
// No - an invalid... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x30(%rsp), %r15
movq $0x0, (%r15)
movq %rsi, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0xa8f0
movq (%r15), %rcx
cmpb $0x0, (%rcx)
je 0x46570
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x36908
movq (%r14)... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-port.cc |
testing::internal::ParseInt32Flag(char const*, char const*, int*) | bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag, false);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;
// Sets *value to the value of the flag.
return Parse... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x468df
testq %rax, %rax
je 0x468b5
movq %rax, %r15
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x36908
movq (%rbx), %rbx
leaq 0x10(%rbx), %r13
leaq 0x19bb8(%rip), %rsi # 0x60... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::ParseGoogleTestFlagsOnly(int*, char**) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
ParseGoogleTestFlagsOnlyImpl(argc, argv);
// Fix the value of *_NSGetArgc() on macOS, but if and only if
// *_NSGetArgv() == argv
// Only applicable to char** version of argv
#if GTEST_OS_MAC
#ifndef GTEST_OS_IOS
if (*_NSGetArgv() == argv) {
*_NSGet... | jmp 0x5270d
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::TempDir[abi:cxx11]() | std::string TempDir() {
#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
#endif
#if GTEST_OS_WINDOWS_MOBILE
return "\\temp\\";
#elif GTEST_OS_WINDOWS
const char* temp_dir = internal::posix::GetEnv("TEMP");
if (temp_dir == nullptr || temp_dir[0] == '\0')
return "\\temp\\"... | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x1ba34(%rip), %rsi # 0x62503
leaq 0x1ba32(%rip), %rdx # 0x62508
callq 0x105c0
movq %rbx, %rax
popq %rbx
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::InDeathTestChild() | bool InDeathTestChild() {
# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
// On Windows and Fuchsia, death tests are thread-safe regardless of the value
// of the death_test_style flag.
return !GTEST_FLAG(internal_run_death_test).empty();
# else
if (GTEST_FLAG(death_test_style) == "threadsafe")
return !GTEST_F... | pushq %rax
leaq 0x3af64(%rip), %rdi # 0x81ae0
leaq 0x1b986(%rip), %rsi # 0x62509
callq 0xa150
xorl %ecx, %ecx
cmpq $0x0, 0x3af36(%rip) # 0x81ac8
setne %cl
testl %eax, %eax
movzbl 0x3af63(%rip), %eax # 0x81b01
cmovel %ecx, %eax
andb $0x1, %al
popq %rcx
retq
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTest::DeathTest() | DeathTest::DeathTest() {
TestInfo* const info = GetUnitTestImpl()->current_test_info();
if (info == nullptr) {
DeathTestAbort("Cannot run a death test outside of a TEST or "
"TEST_F construct");
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x39eaa(%rip), %rax # 0x80ad8
movq %rax, (%rdi)
callq 0x333fe
movq 0x3ae73(%rip), %rax # 0x81ab0
cmpq $0x0, 0x170(%rax)
je 0x46c4f
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b8b5(%rip), %rsi # 0x62514
leaq 0x1b8e... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestAbort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void DeathTestAbort(const std::string& message) {
// On a POSIX system, this function may be called from a threadsafe-style
// death test child process, which operates on a very small stack. Use
// the heap for any additional non-minuscule memory requirements.
const InternalRunDeathTestFlag* const flag ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x333fe
movq 0x3ae08(%rip), %rax # 0x81ab0
movq 0x238(%rax), %rax
testq %rax, %rax
jne 0x46cd3
movq 0x3a305(%rip), %r14 # 0x80fc0
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0xa690
movq (%r14), %rdi
callq 0xa700
callq 0x31be5
movl 0x28(%rax), %edi
leaq 0x18cc... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::ReadAndInterpretStatusByte() | void DeathTestImpl::ReadAndInterpretStatusByte() {
char flag;
int bytes_read;
// The read() here blocks until data is available (signifying the
// failure of the death test) or until the pipe is closed (signifying
// its success), so it's okay to call this in the parent before
// the child process has exit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, %rbx
leaq 0x7(%rsp), %r14
movl 0x34(%rbx), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0xa910
cmpl $-0x1, %eax
jne 0x46e16
callq 0xa070
cmpl $0x4, (%rax)
je 0x46df5
jmp 0x46e53
testl %eax, %eax
je 0x46... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-death-test.cc |
testing::internal::ExecDeathTest::AssumeRole() | DeathTest::TestRole ExecDeathTest::AssumeRole() {
const UnitTestImpl* const impl = GetUnitTestImpl();
const InternalRunDeathTestFlag* const flag =
impl->internal_run_death_test_flag();
const TestInfo* const info = impl->current_test_info();
const int death_test_index = info->result()->death_test_count();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, %rbx
callq 0x333fe
movq 0x383be(%rip), %rax # 0x81ab0
movq 0x170(%rax), %r14
movq 0x238(%rax), %rax
movl 0xf8(%r14), %ecx
movl %ecx, 0x114(%rsp)
testq %rax, %rax
je 0x49723
movl 0x28(%rax), %eax
m... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-death-test.cc |
testing::internal::FilePath::RemoveFileName() const | FilePath FilePath::RemoveFileName() const {
const char* const last_sep = FindLastPathSeparator();
std::string dir;
if (last_sep) {
dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 - c_str()));
} else {
dir = kCurrentDirectoryString;
}
return FilePath(dir);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
movq %r14, %rdi
movl $0x2f, %esi
callq 0xa670
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
testq %rax, %rax
je 0x4cd1e
incq %rax
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28(%... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::FileOrDirectoryExists() const | bool FilePath::FileOrDirectoryExists() const {
#if GTEST_OS_WINDOWS_MOBILE
LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
const DWORD attributes = GetFileAttributes(unicode);
delete [] unicode;
return attributes != kInvalidFileAttributes;
#else
posix::StatStruct file_stat;
return posix::Stat(path... | subq $0x98, %rsp
movq (%rdi), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa540
testl %eax, %eax
sete %al
addq $0x98, %rsp
retq
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::Normalize() | void FilePath::Normalize() {
if (pathname_.c_str() == nullptr) {
pathname_ = "";
return;
}
const char* src = pathname_.c_str();
char* const dest = new char[pathname_.length() + 1];
char* dest_ptr = dest;
memset(dest_ptr, 0, pathname_.length() + 1);
while (*src != '\0') {
*dest_ptr = *src;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq (%rdi), %r13
movq 0x8(%rdi), %rbx
testq %r13, %r13
je 0x4d036
leaq 0x1(%rbx), %r12
movq %r12, %rdi
callq 0xa040
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xa340
movb (%r13), %cl
movq %r15, %rax
testb %cl, %cl
je 0x4d... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-filepath.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(char const*) | Matcher<const std::string&>::Matcher(const char* s) {
*this = Eq(std::string(s));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x33980(%rip), %rax # 0x80b18
movq %rax, (%rdi)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa210
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-matchers.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(char const*) | Matcher<std::string>::Matcher(const char* s) { *this = Eq(std::string(s)); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3375a(%rip), %rax # 0x80b38
movq %rax, (%rdi)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa210
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-matchers.cc |
testing::internal::RE::Init(char const*) | void RE::Init(const char* regex) {
pattern_ = posix::StrDup(regex);
// Reserves enough bytes to hold the regular expression used for a
// full match.
const size_t full_regex_len = strlen(regex) + 10;
char* const full_pattern = new char[full_regex_len];
snprintf(full_pattern, full_regex_len, "^(%s)$", rege... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0xac00
movq %rax, (%r14)
movq %r15, %rdi
callq 0xa240
leaq 0xa(%rax), %r12
movq %r12, %rdi
callq 0xa040
movq %rax, %rbx
leaq 0x1536f(%rip), %rdx # 0x6291d
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rc... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-port.cc |
testing::internal::ReadEntireFile[abi:cxx11](_IO_FILE*) | std::string ReadEntireFile(FILE* file) {
const size_t file_size = GetFileSize(file);
char* const buffer = new char[file_size];
size_t bytes_last_read = 0; // # of bytes read in the last fread()
size_t bytes_read = 0; // # of bytes read so far
fseek(file, 0, SEEK_SET);
// Keeps reading the file unt... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xa680
movq %r14, %rdi
callq 0xa030
movq %rax, %r12
movq %rax, %rdi
callq 0xa040
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa680
lea... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-port.cc |
testing::internal::PrintBytesInObjectTo(unsigned char const*, unsigned long, std::ostream*) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
ostream* os) {
PrintBytesInObjectToImpl(obj_bytes, count, os);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0xa400
leaq 0x15777(%rip), %rsi # 0x634a6
movl $0xe, %edx
movq %rax, %rdi
callq 0xa6b0
cmpq $0x83, %r14
ja 0x4dd4c
movq %r15, %rdi
xorl %esi, %esi
jmp 0x4dd80
movl $0x40, %edx
movq %r15, %rdi
xorl %esi, %esi
movq ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-printers.cc |
testing::internal::CharFormat testing::internal::PrintCharsAsStringTo<wchar_t>(wchar_t const*, unsigned long, std::ostream*) | static CharFormat PrintCharsAsStringTo(
const CharType* begin, size_t len, ostream* os) {
const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
*os << kQuoteBegin;
bool is_previous_hex = false;
CharFormat print_format = kAsIs;
for (size_t index = 0; index < len; ++index) {
const CharTy... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x15537(%rip), %rsi # 0x634f4
movl $0x2, %edx
movq %rbx, %rdi
callq 0xa6b0
testq %r14, %r14
je 0x4e036
xorl %eax, %eax
leaq 0x1551c(%rip), %r13 # 0x634f4
xorl %r12d, %r12d
movl (%r15... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-printers.cc |
testing::TestPartResult::ExtractSummary[abi:cxx11](char const*) | std::string TestPartResult::ExtractSummary(const char* message) {
const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
return stack_trace == nullptr ? message : std::string(message, stack_trace);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x12253(%rip), %rsi # 0x604f0
movq %r14, %rdi
callq 0xa0e0
testq %rax, %rax
je 0x4e2c1
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x105c0
jmp 0x4e2d1
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r1... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-test-part.cc |
testing::TestPartResultArray::GetTestPartResult(int) const | const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
if (index < 0 || index >= size()) {
printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
internal::posix::Abort();
}
return array_[static_cast<size_t>(index)];
} | testl %esi, %esi
js 0x4e452
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
imull $0xb6db6db7, %ecx, %ecx # imm = 0xB6DB6DB7
cmpl %esi, %ecx
jle 0x4e452
movl %esi, %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
retq
pushq %rax
leaq 0x146ca(%rip), %rdi # 0x62b24
xorl %eax, %eax
callq 0xa080
call... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-test-part.cc |
testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames(char const*, char const*, int, char const*) | const char* TypedTestSuitePState::VerifyRegisteredTestNames(
const char* test_suite_name, const char* file, int line,
const char* registered_tests) {
RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line));
typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
registered_ =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, 0x28(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
callq 0xa210
leaq 0xb0(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x40(%rsp), %rsi
movq 0x48(%rs... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-typed-test.cc |
testing::internal::ExecDeathTestChildMain(void*) | static int ExecDeathTestChildMain(void* child_arg) {
ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
// We need to execute the test program in the same environment where
// it was originally invoked. Therefore we change to the... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %r14
movl 0x8(%r14), %edi
callq 0xacb0
cmpl $-0x1, %eax
jne 0x4eb55
callq 0xa070
cmpl $0x4, (%rax)
je 0x4ead7
leaq 0xb0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x13b40(%rip), %rsi # 0x62642
leaq 0... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-death-test.cc |
testing::TestInfo* testing::RegisterTest<testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::InsertSynthetic... | explicit FactoryImpl(Factory f) : factory_(std::move(f)) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x314f1(%rip), %rax # 0x809e0
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x4f504
callq 0xa570
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x4f516
callq 0xa570
movq %rbx, %rdi
popq %rbx
jmp 0xa570
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.h |
testing::internal::(anonymous namespace)::FailureTest::FailureTest(testing::internal::CodeLocation const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) | explicit FailureTest(const CodeLocation& loc, std::string error_message,
bool as_error)
: loc_(loc),
error_message_(std::move(error_message)),
as_error_(as_error) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3a6d8
leaq 0x31446(%rip), %rax # 0x80a08
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0xfb0e
movl 0x20(%r15), %eax
movl %eax, 0... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::FailureTest::~FailureTest() | explicit FailureTest(const CodeLocation& loc, std::string error_message,
bool as_error)
: loc_(loc),
error_message_(std::move(error_message)),
as_error_(as_error) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x31361(%rip), %rax # 0x80a08
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0x4f6bc
callq 0xa570
movq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x4f6ce
callq 0xa570
leaq 0x30cb3(%rip), %rax # 0x80388
movq %rax, (%rbx)
leaq 0x8(%r... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::TestInfo* testing::RegisterTest<testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0)::FactoryImpl::~FactoryImpl() | explicit FactoryImpl(Factory f) : factory_(std::move(f)) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x3125f(%rip), %rax # 0x80a48
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x4f7fe
callq 0xa570
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x4f810
callq 0xa570
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x4f823
pop... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.h |
testing::TestInfo* testing::RegisterTest<testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0)::FactoryImpl::~FactoryImpl() | explicit FactoryImpl(Factory f) : factory_(std::move(f)) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x31217(%rip), %rax # 0x80a48
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x4f846
callq 0xa570
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x4f858
callq 0xa570
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x4f86... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.h |
testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*) | static std::string FormatCxxExceptionMessage(const char* description,
const char* location) {
Message message;
if (description != nullptr) {
message << "C++ exception with description \"" << description << "\"";
} else {
message << "Unknown C++ exception";
}
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x36908
movq (%rbx), %rbx
leaq 0x10(%rbx), %r15
testq %r13, %r13
je 0x4f963
leaq 0x13c0f(%rip), %rsi # 0x63541
movl $0x20, %edx
movq %r15, %rdi
callq 0xa... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
bool testing::internal::ParseStringFlag<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | static bool ParseStringFlag(const char* str, const char* flag, String* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag, false);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;
// Sets *value to the value of the flag.
*valu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
xorl %edx, %edx
callq 0x468df
movq %rax, %r14
testq %rax, %rax
je 0x4fc8f
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0xa240
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0xaa10
testq %r14, %r14
setne %al
popq %rbx
popq %r14
popq %r1... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::ParseBoolFlag(char const*, char const*, bool*) | static bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag, true);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;
// Converts the string value to a bool.
*value = !(... | pushq %rbx
movq %rdx, %rbx
movl $0x1, %edx
callq 0x468df
testq %rax, %rax
je 0x4ffab
movzbl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x30, %edx
je 0x4ffa9
cmpl $0x66, %edx
je 0x4ffa9
cmpb $0x46, %dl
setne %cl
movb %cl, (%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::PrintAsStringLiteralTo(wchar_t, std::ostream*) | static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
switch (c) {
case L'\'':
*os << "'";
return kAsIs;
case L'"':
*os << "\\\"";
return kSpecialEscape;
default:
return PrintAsCharLiteralTo<wchar_t>(c, os);
}
} | pushq %rax
cmpl $0x22, %edi
je 0x500fd
cmpl $0x27, %edi
jne 0x5011b
leaq 0x113a1(%rip), %rax # 0x6148a
movl $0x1, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0xa6b0
xorl %eax, %eax
jmp 0x50119
leaq 0x135b8(%rip), %rax # 0x636bc
movl $0x2, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0xa6b0
movl $0x2, %eax
popq %rc... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-printers.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<char [6]>(char const (&) [6]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x36908
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0xa240
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa6b0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x10286
movq 0x8(%r... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [17]>(char const (&) [17]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x36908
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0xa240
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa6b0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x10286
movq 0x8(%r... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.h |
testing::internal::ExecDeathTest::ExecDeathTest(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>, char const*, int) | ExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
const char* file, int line)
: ForkingDeathTest(a_statement, std::move(matcher)),
file_(file),
line_(line) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdi, %r15
movups 0x8(%rdx), %xmm0
xorl %ecx, %ecx
movq %rcx, 0x10(%rdx)
leaq 0x8(%rsp), %rax
movups %xmm0, 0x8(%rax)
movq %rcx, 0x8(%rdx)
leaq 0x2de58(%rip), %rcx # 0x80b18
movq %rcx, (%rax)
movq %rax, %rdx
callq 0x48092
movq 0x... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-death-test.cc |
testing::internal::StreamingListener::SocketWriter::CloseConnection() | void CloseConnection() override {
GTEST_CHECK_(sockfd_ != -1)
<< "CloseConnection() can be called only when there is a connection.";
close(sockfd_);
sockfd_ = -1;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %edi
cmpl $-0x1, %edi
jne 0x55762
leaq 0xd5b4(%rip), %rdx # 0x62cc5
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x460, %ecx # imm = 0x460
callq 0x4d76a
movq 0x2b8bc(%rip), %rdi # 0x80fe8
leaq 0xd71f(%rip), %rsi # 0x62e52
movl $0x20, %ed... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::CapturedStream::~CapturedStream() | ~CapturedStream() {
remove(filename_.c_str());
} | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xabc0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x55b60
popq %rbx
jmp 0xa570
popq %rbx
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-port.cc |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::GetOrCreateValue() const | T* GetOrCreateValue() const {
ThreadLocalValueHolderBase* const holder =
static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
if (holder != nullptr) {
return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
}
ValueHolder* const new_holder = default_factory_->Ma... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0xa9b0
movq %rax, %rbx
testq %rax, %rax
jne 0x562c7
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0xa0d0
testl %eax, %eax
je 0x562c7
movl %eax, %ebp
leaq 0x9d94(%r... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/internal/gtest-port.h |
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.