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, %rsp
popq %rbx
popq %r14
retq
nop
|
/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, %r14
movq %rax, %rdi
callq 0x23558
leaq 0x5c086(%rip), %rax # 0x7f898
movq %rax, (%r14)
movq %r15, 0x28(%r14)
movl %ebp, %r12d
movq %r12, %r15
shlq $0x5, %r15
leaq 0x8(%r15), %rdi
callq 0xa040
movq %r12, (%rax)
leaq (%rax,%r15), %rcx
addq $0x8, %rcx
addq $0x8, %rax
xorl %edx, %edx
leaq 0x3e581(%rip), %rsi # 0x61dc5
movq %rax, %rdi
movq %rdx, (%rdi)
movb $0x0, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
addq $0x20, %rdi
cmpq %rcx, %rdi
jne 0x23847
movq %rax, 0x30(%r14)
movl %ebp, 0x38(%r14)
movq $0x0, 0x40(%r14)
movl $0x0, 0x48(%r14)
testl %ebp, %ebp
je 0x2389a
xorl %r12d, %r12d
movq 0x30(%r14), %rdi
addq %r12, %rdi
movq (%rbx), %rsi
callq 0x23ea2
addq $0x20, %r12
addq $0x8, %rbx
cmpq %r12, %r15
jne 0x2387e
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x37796(%rip), %rdi # 0x5b043
leaq 0x38d64(%rip), %rsi # 0x5c618
leaq 0x38dbb(%rip), %rcx # 0x5c676
movl $0xb5, %edx
callq 0xa3e0
nop
|
/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 explicitly position the non-current_ children.
if (direction_ != kForward) {
for (int i = 0; i < n_; i++) {
IteratorWrapper* child = &children_[i];
if (child != current_) {
child->Seek(key());
if (child->Valid() &&
comparator_->Compare(key(), child->key()) == 0) {
child->Next();
}
}
}
direction_ = kForward;
}
current_->Next();
FindSmallest();
}
|
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), %r12
cmpq 0x40(%rbx), %r12
je 0x23ae0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x23f9a
cmpb $0x1, 0x8(%r14,%rbp)
jne 0x23ae0
movq (%rbx), %rax
movq 0x28(%rbx), %r13
movq %rbx, %rdi
callq *0x40(%rax)
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
cmpb $0x0, 0x8(%r14,%rbp)
je 0x23b1b
movups 0x10(%r14,%rbp), %xmm0
movups %xmm0, 0x18(%rsp)
movq (%r13), %rax
movq %r13, %rdi
leaq 0x8(%rsp), %r13
movq %r13, %rsi
leaq 0x18(%rsp), %rdx
callq *0x10(%rax)
testl %eax, %eax
jne 0x23ae0
movq %r12, %rdi
callq 0x23fee
incq %r15
movslq 0x38(%rbx), %rax
addq $0x20, %rbp
cmpq %rax, %r15
jl 0x23a5f
movl $0x0, 0x48(%rbx)
movq 0x40(%rbx), %rdi
callq 0x23fee
movq %rbx, %rdi
callq 0x23d28
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x36a47(%rip), %rdi # 0x5a569
leaq 0x38b9f(%rip), %rsi # 0x5c6c8
leaq 0x38c2e(%rip), %rcx # 0x5c75e
movl $0x27, %edx
callq 0xa3e0
leaq 0x36a28(%rip), %rdi # 0x5a569
leaq 0x38ad0(%rip), %rsi # 0x5c618
leaq 0x38c9a(%rip), %rcx # 0x5c7e9
movl $0x38, %edx
callq 0xa3e0
nop
|
/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
movl $0x6f, %edx
callq 0xa3e0
leaq 0x368f5(%rip), %rdi # 0x5a569
leaq 0x38a4d(%rip), %rsi # 0x5c6c8
leaq 0x38adc(%rip), %rcx # 0x5c75e
movl $0x27, %edx
callq 0xa3e0
|
/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 %r13
movslq 0x38(%r14), %rax
addq $0x20, %r12
cmpq %rax, %r13
jl 0x23ce8
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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) {
largest = child;
}
}
}
current_ = largest;
}
|
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), %r14
testq %rbp, %rbp
je 0x23e5b
movq 0x28(%rbx), %rdi
movups 0x10(%rax,%r12), %xmm0
movups %xmm0, 0x18(%rsp)
cmpb $0x0, 0x8(%rbp)
je 0x23e82
movups 0x10(%rbp), %xmm0
movups %xmm0, 0x8(%rsp)
movq (%rdi), %rax
leaq 0x18(%rsp), %rsi
movq %r15, %rdx
callq *0x10(%rax)
testl %eax, %eax
cmovgq %r14, %rbp
jmp 0x23e5e
movq %r14, %rbp
decq %r13
addq $-0x20, %r12
cmpq $0x1, %r13
ja 0x23e12
jmp 0x23e6f
xorl %ebp, %ebp
movq %rbp, 0x40(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x366e0(%rip), %rdi # 0x5a569
leaq 0x38838(%rip), %rsi # 0x5c6c8
leaq 0x388c7(%rip), %rcx # 0x5c75e
movl $0x27, %edx
callq 0xa3e0
nop
|
/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
retq
leaq 0x38740(%rip), %rdi # 0x5c6c2
leaq 0x3873f(%rip), %rsi # 0x5c6c8
leaq 0x387fa(%rip), %rcx # 0x5c78a
movl $0x48, %edx
callq 0xa3e0
|
/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
retq
leaq 0x386ec(%rip), %rdi # 0x5c6c2
leaq 0x386eb(%rip), %rsi # 0x5c6c8
leaq 0x387d2(%rip), %rcx # 0x5c7b6
movl $0x3e, %edx
callq 0xa3e0
|
/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
retq
leaq 0x38698(%rip), %rdi # 0x5c6c2
leaq 0x38697(%rip), %rsi # 0x5c6c8
leaq 0x387f6(%rip), %rcx # 0x5c82e
movl $0x34, %edx
callq 0xa3e0
|
/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.comparator->FindShortestSeparator(&r->last_key, key);
std::string handle_encoding;
r->pending_handle.EncodeTo(&handle_encoding);
r->index_block.Add(r->last_key, Slice(handle_encoding));
r->pending_index_entry = false;
}
if (r->filter_block != nullptr) {
r->filter_block->AddKey(key);
}
r->last_key.assign(key.data(), key.size());
r->num_entries++;
r->data_block.Add(key, value);
const size_t estimated_block_size = r->data_block.CurrentSizeEstimate();
if (estimated_block_size >= r->options.block_size) {
Flush();
}
}
|
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
movq %rax, (%rdx)
movq 0x1b0(%r13), %rax
movq %rax, 0x8(%rdx)
movq (%rdi), %rax
movq %r15, %rsi
callq *0x10(%rax)
testl %eax, %eax
jle 0x2443c
cmpb $0x1, 0x1e0(%r13)
jne 0x243ac
cmpq $0x0, 0xe8(%r13)
jne 0x2445b
movq (%r13), %rdi
leaq 0x1a8(%r13), %rsi
movq (%rdi), %rax
movq %r15, %rdx
callq *0x20(%rax)
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
xorl %eax, %eax
movb %al, (%rbp)
leaq 0x1e8(%r13), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x2c7a4
leaq 0x140(%r13), %rdi
movq 0x1a8(%r13), %rax
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
movq 0x1b0(%r13), %rax
movq %rax, 0x8(%rsi)
movups (%r12), %xmm0
leaq 0x28(%rsp), %rdx
movups %xmm0, (%rdx)
callq 0x2b642
xorl %eax, %eax
movb %al, 0x1e0(%r13)
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x243ac
callq 0xa570
movq 0x1d8(%r13), %rdi
testq %rdi, %rdi
je 0x243c0
movq %r15, %rsi
callq 0x2c3b2
leaq 0x1a8(%r13), %rdi
movq (%r15), %rcx
movq 0x8(%r15), %r8
movq 0x1b0(%r13), %rdx
xorl %esi, %esi
callq 0xaa10
incq 0x1c8(%r13)
leaq 0xd8(%r13), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2b642
movq %r12, %rdi
callq 0x2b5d0
cmpq 0x38(%r13), %rax
jb 0x2440e
movq %rbx, %rdi
callq 0x2447a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38653(%rip), %rdi # 0x5ca77
leaq 0x38597(%rip), %rsi # 0x5c9c2
leaq 0x38650(%rip), %rcx # 0x5ca82
movl $0x60, %edx
callq 0xa3e0
leaq 0x3867d(%rip), %rdi # 0x5cac0
leaq 0x38578(%rip), %rsi # 0x5c9c2
leaq 0x38631(%rip), %rcx # 0x5ca82
movl $0x63, %edx
callq 0xa3e0
leaq 0x3869a(%rip), %rdi # 0x5cafc
leaq 0x38559(%rip), %rsi # 0x5c9c2
leaq 0x38612(%rip), %rcx # 0x5ca82
movl $0x67, %edx
callq 0xa3e0
|
/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 != nullptr) {
r->filter_block->StartBlock(r->offset);
}
}
|
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 %al, %al
je 0x24516
movb $0x1, 0x1e0(%r14)
movq 0xc0(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %rbx
movq %rbx, %rdi
callq *0x20(%rax)
movq 0xd0(%r14), %rdi
movq (%rbx), %rax
movq %rax, 0xd0(%r14)
movq %rdi, (%rbx)
testq %rdi, %rdi
je 0x24516
callq 0xa810
movq 0x1d8(%r14), %rdi
testq %rdi, %rdi
je 0x2452e
movq 0xc8(%r14), %rsi
callq 0x2c1fa
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3853a(%rip), %rdi # 0x5ca77
leaq 0x3847e(%rip), %rsi # 0x5c9c2
leaq 0x385c7(%rip), %rcx # 0x5cb12
movl $0x7f, %edx
callq 0xa3e0
leaq 0x385da(%rip), %rdi # 0x5cb36
leaq 0x3845f(%rip), %rsi # 0x5c9c2
leaq 0x385a8(%rip), %rcx # 0x5cb12
movl $0x82, %edx
callq 0xa3e0
|
/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 type = r->options.compression;
// TODO(postrelease): Support more compression options: zlib?
switch (type) {
case kNoCompression:
block_contents = raw;
break;
case kSnappyCompression: {
std::string* compressed = &r->compressed_output;
if (port::Snappy_Compress(raw.data(), raw.size(), compressed) &&
compressed->size() < raw.size() - (raw.size() / 8u)) {
block_contents = *compressed;
} else {
// Snappy not supported, or compressed less than 12.5%, so just
// store uncompressed form
block_contents = raw;
type = kNoCompression;
}
break;
}
}
WriteRawBlock(block_contents, type, handle);
r->compressed_output.clear();
block->Reset();
}
|
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 0x245c7
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
xorl %ecx, %ecx
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movl %ecx, %edx
movq %r14, %rcx
callq 0x24624
movq $0x0, 0x200(%r12)
movq 0x1f8(%r12), %rax
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x2b558
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x34ab7(%rip), %rdi # 0x590c2
leaq 0x383b0(%rip), %rsi # 0x5c9c2
leaq 0x38535(%rip), %rcx # 0x5cb4e
movl $0x92, %edx
callq 0xa3e0
nop
|
/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,
&filter_block_handle);
}
// Write metaindex block
if (ok()) {
BlockBuilder meta_index_block(&r->options);
if (r->filter_block != nullptr) {
// Add mapping from "filter.Name" to location of filter data
std::string key = "filter.";
key.append(r->options.filter_policy->Name());
std::string handle_encoding;
filter_block_handle.EncodeTo(&handle_encoding);
meta_index_block.Add(key, handle_encoding);
}
// TODO(postrelease): Add stats and other meta blocks
WriteBlock(&meta_index_block, &metaindex_block_handle);
}
// Write index block
if (ok()) {
if (r->pending_index_entry) {
r->options.comparator->FindShortSuccessor(&r->last_key);
std::string handle_encoding;
r->pending_handle.EncodeTo(&handle_encoding);
r->index_block.Add(r->last_key, Slice(handle_encoding));
r->pending_index_entry = false;
}
WriteBlock(&r->index_block, &index_block_handle);
}
// Write footer
if (ok()) {
Footer footer;
footer.set_metaindex_handle(metaindex_block_handle);
footer.set_index_handle(index_block_handle);
std::string footer_encoding;
footer.EncodeTo(&footer_encoding);
r->status = r->file->Append(footer_encoding);
if (r->status.ok()) {
r->offset += footer_encoding.size();
}
}
return r->status;
}
|
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 %r15, %rdi
callq 0x24cce
testb %al, %al
je 0x247df
movq 0x1d8(%r14), %rdi
testq %rdi, %rdi
je 0x247df
callq 0x2c410
leaq 0x80(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
leaq 0x40(%rsp), %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0x24624
movq %r15, %rdi
callq 0x24cce
testb %al, %al
je 0x2490f
leaq 0x80(%rsp), %rdi
movq %r14, %rsi
callq 0x2b4ec
cmpq $0x0, 0x1d8(%r14)
je 0x248b8
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x3839e(%rip), %rsi # 0x5cbbb
leaq 0x3839e(%rip), %rdx # 0x5cbc2
movq %rsp, %r12
movq %r12, %rdi
callq 0x105c0
movq 0x58(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0xac80
leaq 0x70(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %r13
movq %r13, %rsi
callq 0x2c7a4
movups (%r12), %xmm0
leaq 0x50(%rsp), %rsi
movups %xmm0, (%rsi)
movdqu (%r13), %xmm0
leaq 0xe8(%rsp), %rdx
movdqu %xmm0, (%rdx)
leaq 0x80(%rsp), %rdi
callq 0x2b642
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x248a5
callq 0xa570
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x248b8
callq 0xa570
leaq 0x80(%rsp), %r12
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x24574
movq 0x48(%r12), %rdi
leaq 0xd8(%rsp), %rax
cmpq %rax, %rdi
je 0x248e7
callq 0xa570
movq 0xa8(%rsp), %rdi
testq %rdi, %rdi
je 0x248f9
callq 0xa570
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2490f
callq 0xa570
movq %r15, %rdi
callq 0x24cce
testb %al, %al
je 0x249ca
cmpb $0x1, 0x1e0(%r14)
jne 0x249b6
movq (%r14), %rdi
leaq 0x1a8(%r14), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
leaq 0x90(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
xorl %ebp, %ebp
movb %bpl, (%r13)
leaq 0x1e8(%r14), %rdi
leaq 0x80(%rsp), %r12
movq %r12, %rsi
callq 0x2c7a4
leaq 0x140(%r14), %rdi
movq 0x1a8(%r14), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x1b0(%r14), %rax
movq %rax, 0x8(%rsi)
movdqu (%r12), %xmm0
leaq 0x60(%rsp), %rdx
movdqu %xmm0, (%rdx)
callq 0x2b642
movb %bpl, 0x1e0(%r14)
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x249b6
callq 0xa570
leaq 0x140(%r14), %rsi
leaq 0x20(%rsp), %rdx
movq %r15, %rdi
callq 0x24574
movq %r15, %rdi
callq 0x24cce
testb %al, %al
je 0x24a7d
movaps 0x30(%rsp), %xmm0
leaq 0x80(%rsp), %rdi
movaps %xmm0, (%rdi)
movaps 0x20(%rsp), %xmm0
movaps %xmm0, 0x10(%rdi)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq %rsp, %r15
movq %r15, %rsi
callq 0x2c898
movq 0xc0(%r14), %rsi
movdqu (%r15), %xmm0
leaq 0x60(%rsp), %rdx
movdqu %xmm0, (%rdx)
movq (%rsi), %rax
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq *0x10(%rax)
movq 0xd0(%r14), %rdi
movq (%r15), %rax
movq %rax, 0xd0(%r14)
movq %rdi, (%r15)
testq %rdi, %rdi
je 0x24a5e
callq 0xa810
movq 0xd0(%r14), %rax
testq %rax, %rax
jne 0x24a6f
movq 0x8(%rsp), %rax
addq %rax, 0xc8(%r14)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x24a7d
callq 0xa570
movq 0xd0(%r14), %rdi
testq %rdi, %rdi
je 0x24a90
callq 0x27780
jmp 0x24a92
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x37fc6(%rip), %rdi # 0x5ca77
leaq 0x37f0a(%rip), %rsi # 0x5c9c2
leaq 0x380d5(%rip), %rcx # 0x5cb94
movl $0xc9, %edx
callq 0xa3e0
nop
|
/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
? nullptr
: new FilterBlockBuilder(opt.filter_policy)),
pending_index_entry(false) {
index_block_options.block_restart_interval = 1;
}
|
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 0x2b4ec
leaq 0x140(%rbx), %rdi
movq %r15, %rsi
callq 0x2b4ec
leaq 0x1b8(%rbx), %rax
movq %rax, 0x1a8(%rbx)
xorl %r15d, %r15d
movq %r15, 0x1b0(%rbx)
movb %r15b, 0x1b8(%rbx)
movq %r15, 0x1c8(%rbx)
movb %r15b, 0x1d0(%rbx)
movq 0x58(%r14), %r14
testq %r14, %r14
je 0x24bba
movl $0x90, %edi
callq 0xa5c0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2c1bc
movq %r15, 0x1d8(%rbx)
xorl %eax, %eax
movb %al, 0x1e0(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x1e8(%rbx)
leaq 0x208(%rbx), %rcx
movq %rcx, 0x1f8(%rbx)
movq $0x0, 0x200(%rbx)
movb %al, 0x208(%rbx)
movl $0x1, 0xa0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
/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 (%r15), %rax
addq $0x8, %rbx
lock
addq %rbx, 0x28(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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 ? 0 : align - current_mod);
size_t needed = bytes + slop;
char* result;
if (needed <= alloc_bytes_remaining_) {
result = alloc_ptr_ + slop;
alloc_ptr_ += needed;
alloc_bytes_remaining_ -= needed;
} else {
// AllocateFallback always returned aligned memory
result = AllocateFallback(bytes);
}
assert((reinterpret_cast<uintptr_t>(result) & (align - 1)) == 0);
return result;
}
|
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
popq %rcx
retq
leaq 0x37040(%rip), %rdi # 0x5cd9c
leaq 0x37072(%rip), %rsi # 0x5cdd5
leaq 0x370c7(%rip), %rcx # 0x5ce31
movl $0x36, %edx
callq 0xa3e0
|
/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(%r14), %rsi
cmpq %r12, %rsi
je 0x25ff2
cmpb $0x0, 0x38(%rsi)
je 0x26039
movq 0x18(%rsi), %r13
movb $0x0, 0x38(%rsi)
cmpl $0x1, 0x3c(%rsi)
jne 0x2601a
movq %r14, %rdi
callq 0x266d6
movq %r13, %rsi
cmpq %r12, %r13
jne 0x25fce
movq 0xd0(%r14), %rdi
testq %rdi, %rdi
je 0x26003
callq 0xa810
addq $-0xd8, %r15
cmpq $0x10, %r15
jne 0x25fa4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x36f34(%rip), %rdi # 0x5cf55
leaq 0x36e47(%rip), %rsi # 0x5ce6f
leaq 0x36ef0(%rip), %rcx # 0x5cf1f
movl $0xd4, %edx
callq 0xa3e0
leaq 0x36f71(%rip), %rdi # 0x5cfb1
leaq 0x36e28(%rip), %rsi # 0x5ce6f
leaq 0x36ed1(%rip), %rcx # 0x5cf1f
movl $0xd2, %edx
callq 0xa3e0
leaq 0x36ea7(%rip), %rdi # 0x5cf06
leaq 0x36e09(%rip), %rsi # 0x5ce6f
leaq 0x36eb2(%rip), %rcx # 0x5cf1f
movl $0xcf, %edx
callq 0xa3e0
nop
|
/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
addq $0x18, %rdi
movq %rdi, 0x8(%rsp)
callq 0xa950
testl %eax, %eax
jne 0x262b3
addq %r15, %r14
addq $0x10, %r14
movq 0x8(%rbx), %r13
leaq 0x47(%r13), %rdi
callq 0xa860
movq %rax, %r15
movq %r12, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%r15)
movq (%rsp), %rax
movq %rax, 0x28(%r15)
movq %r13, 0x30(%r15)
movl %ebp, 0x40(%r15)
movb $0x0, 0x38(%r15)
movl $0x1, 0x3c(%r15)
leaq 0x44(%r15), %r12
movq (%rbx), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0xa4e0
cmpq $0x0, (%r14)
je 0x261a6
movl $0x2, 0x3c(%r15)
movb $0x1, 0x38(%r15)
leaq 0x80(%r14), %rax
movq %rax, 0x18(%r15)
movq 0xa0(%r14), %rcx
movq %rcx, 0x20(%r15)
movq %r15, 0x18(%rcx)
movq %r15, 0xa0(%r14)
movq (%rsp), %rcx
addq %rcx, 0x30(%r14)
cmpq %r15, %rax
je 0x26275
movl 0xc8(%r14), %edi
movq 0xd0(%r14), %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x26844
movq (%rax), %rbx
testq %rbx, %rbx
je 0x261b0
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%r15)
movq %r15, (%rax)
jmp 0x261e0
movq $0x0, 0x18(%r15)
jmp 0x261eb
movq $0x0, 0x10(%r15)
movq %r15, (%rax)
movl 0xcc(%r14), %eax
incl %eax
movl %eax, 0xcc(%r14)
cmpl 0xc8(%r14), %eax
jbe 0x261e0
leaq 0xc8(%r14), %rdi
callq 0x26602
movq %r14, %rdi
movq %rbx, %rsi
callq 0x267ba
leaq 0x38(%r14), %r12
leaq 0xc8(%r14), %rbx
movq 0x30(%r14), %rax
cmpq (%r14), %rax
jbe 0x26259
movq 0x50(%r14), %rax
cmpq %r12, %rax
je 0x26259
cmpl $0x1, 0x3c(%rax)
jne 0x26294
cmpq %rax, 0x18(%rax)
je 0x26275
leaq 0x44(%rax), %rsi
movq 0x30(%rax), %rdx
movl 0x40(%rax), %ecx
movq %rbx, %rdi
callq 0x26814
movq %r14, %rdi
movq %rax, %rsi
callq 0x267ba
testb %al, %al
jne 0x261f6
leaq 0x36e5f(%rip), %rdi # 0x5d0a0
leaq 0x36c27(%rip), %rsi # 0x5ce6f
leaq 0x36dc7(%rip), %rcx # 0x5d016
movl $0x12b, %edx # imm = 0x12B
callq 0xa3e0
movq 0x8(%rsp), %rdi
callq 0xa4a0
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x36d41(%rip), %rdi # 0x5cfbd
leaq 0x36bec(%rip), %rsi # 0x5ce6f
leaq 0x36d40(%rip), %rcx # 0x5cfca
movl $0x3b, %edx
callq 0xa3e0
leaq 0x36d6c(%rip), %rdi # 0x5d007
leaq 0x36bcd(%rip), %rsi # 0x5ce6f
leaq 0x36d6d(%rip), %rcx # 0x5d016
movl $0x128, %edx # imm = 0x128
callq 0xa3e0
movl %eax, %edi
callq 0xa3f0
|
/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, %r15
addq $0x10, %r15
movl 0xc8(%r15), %edi
movq 0xd0(%r15), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movl %ebp, %r8d
callq 0x26844
movq (%rax), %r14
testq %r14, %r14
je 0x2636e
movl 0x3c(%r14), %eax
cmpl $0x1, %eax
jne 0x26368
cmpb $0x1, 0x38(%r14)
jne 0x26368
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rdx
movq %rdx, 0x20(%rcx)
movq %rcx, 0x18(%rdx)
leaq 0x80(%r15), %rcx
movq %rcx, 0x18(%r14)
movq 0xa0(%r15), %rcx
movq %rcx, 0x20(%r14)
movq %r14, 0x18(%rcx)
movq 0x18(%r14), %rcx
movq %r14, 0x20(%rcx)
incl %eax
movl %eax, 0x3c(%r14)
movq %rbx, %rdi
callq 0xa4a0
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0xa3f0
nop
|
/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 = 0xD80
jne 0x265c0
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0xa3f0
nop
|
/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, limit, value);
}
|
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, %r9b
js 0x26c29
movl %r8d, %ecx
shll %cl, %r9d
orl %r10d, %r9d
movl %r9d, %ecx
leaq (%rdi,%rcx), %rax
cmpq %rsi, %rax
jbe 0x26c68
xorl %eax, %eax
retq
movq %rdi, (%rdx)
movq %rcx, 0x8(%rdx)
retq
|
/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, &size, sizeof(size));
result[4] = static_cast<char>(code);
std::memcpy(result + 5, msg.data(), len1);
if (len2) {
result[5 + len1] = ':';
result[6 + len1] = ' ';
std::memcpy(result + 7 + len1, msg2.data(), len2);
}
state_ = 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, %edi
movl %eax, %r14d
addl %r13d, %r14d
callq 0xa040
movq %rax, %r15
movl %r14d, (%rax)
movb %bpl, 0x4(%rax)
leaq 0x5(%rax), %rdi
movq (%r12), %rsi
movl %r13d, %r12d
movq %r12, %rdx
callq 0xa4e0
testl %ebx, %ebx
je 0x2783d
movl %ebx, %edx
leal 0x5(%r13), %eax
movb $0x3a, (%r15,%rax)
addl $0x6, %r13d
movb $0x20, (%r15,%r13)
leaq (%r15,%r12), %rdi
addq $0x7, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0xa4e0
movq 0x10(%rsp), %rax
movq %r15, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x36dfe(%rip), %rdi # 0x5e659
leaq 0x36e03(%rip), %rsi # 0x5e665
leaq 0x36e59(%rip), %rcx # 0x5e6c2
movl $0x16, %edx
callq 0xa3e0
nop
|
/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), %rax
movq %rax, (%r15)
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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(posix_file_lock->fd());
delete posix_file_lock;
return Status::OK();
}
|
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, %edi
movl $0x6, %esi
xorl %eax, %eax
callq 0xa370
leaq 0x10(%r14), %rdx
cmpl $-0x1, %eax
je 0x2858c
addq $0xc0, %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x293d2
movl 0x8(%r14), %edi
callq 0xacb0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, (%rbx)
jmp 0x285c3
leaq 0x365a4(%rip), %rsi # 0x5eb37
movq %rsp, %r14
movq %r14, %rdi
callq 0x2978c
movl (%r12), %ecx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x28add
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x285c3
callq 0xa570
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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;
size -= write_result;
}
return Status::OK();
}
|
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
cmpl $0x4, %ecx
jne 0x2936e
testq %r15, %r15
jne 0x2932b
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10018(%r14), %rsi
movq 0x10020(%r14), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x28add
nop
|
/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_seconds, &now_components);
// Record the thread ID.
constexpr const int kMaxThreadIdSize = 32;
std::ostringstream thread_stream;
thread_stream << std::this_thread::get_id();
std::string thread_id = thread_stream.str();
if (thread_id.size() > kMaxThreadIdSize) {
thread_id.resize(kMaxThreadIdSize);
}
// We first attempt to print into a stack-allocated buffer. If this attempt
// fails, we make a second attempt with a dynamically allocated buffer.
constexpr const int kStackBufferSize = 512;
char stack_buffer[kStackBufferSize];
static_assert(sizeof(stack_buffer) == static_cast<size_t>(kStackBufferSize),
"sizeof(char) is expected to be 1 in C++");
int dynamic_buffer_size = 0; // Computed in the first iteration.
for (int iteration = 0; iteration < 2; ++iteration) {
const int buffer_size =
(iteration == 0) ? kStackBufferSize : dynamic_buffer_size;
char* const buffer =
(iteration == 0) ? stack_buffer : new char[dynamic_buffer_size];
// Print the header into the buffer.
int buffer_offset = std::snprintf(
buffer, buffer_size, "%04d/%02d/%02d-%02d:%02d:%02d.%06d %s ",
now_components.tm_year + 1900, now_components.tm_mon + 1,
now_components.tm_mday, now_components.tm_hour, now_components.tm_min,
now_components.tm_sec, static_cast<int>(now_timeval.tv_usec),
thread_id.c_str());
// The header can be at most 28 characters (10 date + 15 time +
// 3 delimiters) plus the thread ID, which should fit comfortably into the
// static buffer.
assert(buffer_offset <= 28 + kMaxThreadIdSize);
static_assert(28 + kMaxThreadIdSize < kStackBufferSize,
"stack-allocated buffer may not fit the message header");
assert(buffer_offset < buffer_size);
// Print the message into the buffer.
std::va_list arguments_copy;
va_copy(arguments_copy, arguments);
buffer_offset +=
std::vsnprintf(buffer + buffer_offset, buffer_size - buffer_offset,
format, arguments_copy);
va_end(arguments_copy);
// The code below may append a newline at the end of the buffer, which
// requires an extra character.
if (buffer_offset >= buffer_size - 1) {
// The message did not fit into the buffer.
if (iteration == 0) {
// Re-run the loop and use a dynamically-allocated buffer. The buffer
// will be large enough for the log message, an extra newline and a
// null terminator.
dynamic_buffer_size = buffer_offset + 2;
continue;
}
// The dynamically-allocated buffer was incorrectly sized. This should
// not happen, assuming a correct implementation of std::(v)snprintf.
// Fail in tests, recover by truncating the log message in production.
assert(false);
buffer_offset = buffer_size - 1;
}
// Add a newline if necessary.
if (buffer[buffer_offset - 1] != '\n') {
buffer[buffer_offset] = '\n';
++buffer_offset;
}
assert(buffer_offset <= buffer_size);
std::fwrite(buffer, 1, buffer_offset, fp_);
std::fflush(fp_);
if (iteration != 0) {
delete[] buffer;
}
break;
}
}
|
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 0xa2f0
leaq 0x98(%rsp), %rdi
callq 0xa880
callq 0xa530
testq %rax, %rax
je 0x29c22
leaq 0x98(%rsp), %rdi
movq %rax, %rsi
callq 0xa400
jmp 0x29c3b
leaq 0x35068(%rip), %rsi # 0x5ec91
leaq 0x98(%rsp), %rdi
movl $0x24, %edx
callq 0xa6b0
leaq 0xa0(%rsp), %rsi
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa40
cmpq $0x21, 0x8(%rbx)
jb 0x29c68
leaq 0x28(%rsp), %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0xa180
movb $0x1, %r13b
xorl %eax, %eax
movl %eax, %ebp
leaq 0x210(%rsp), %r12
testb $0x1, %r13b
movl $0x200, %ecx # imm = 0x200
cmovnel %ecx, %ebp
jne 0x29c8f
movl %eax, %edi
callq 0xa040
movq %rax, %r12
movl %ebp, %esi
movl 0x5c(%rsp), %ecx
movl $0x76c, %eax # imm = 0x76C
addl %eax, %ecx
movl 0x58(%rsp), %r8d
incl %r8d
movl 0x54(%rsp), %r9d
movl 0x50(%rsp), %r10d
movl 0x48(%rsp), %r11d
movl 0x4c(%rsp), %ebx
movl 0x90(%rsp), %r15d
subq $0x8, %rsp
movq %r12, %rdi
leaq 0x34ef6(%rip), %rdx # 0x5ebc3
xorl %eax, %eax
pushq 0x30(%rsp)
pushq %r15
pushq %r11
pushq %rbx
pushq %r10
callq 0xaa50
addq $0x30, %rsp
cmpl $0x3d, %eax
jge 0x29dee
movl %eax, %ebx
movl %ebp, %eax
subl %ebx, %eax
jle 0x29dcf
movq 0x10(%r14), %rcx
movq %rcx, 0x20(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x10(%rsp)
movslq %ebx, %rdi
addq %r12, %rdi
movslq %eax, %rsi
movq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0xa3b0
addl %ebx, %eax
leal -0x1(%rbp), %ecx
cmpl %ecx, %eax
jl 0x29d40
testb $0x1, %r13b
je 0x29e0d
addl $0x2, %eax
xorl %r13d, %r13d
jmp 0x29c6d
movslq %eax, %rcx
cmpb $0xa, -0x1(%rcx,%r12)
je 0x29d52
movb $0xa, (%r12,%rcx)
incl %eax
cmpl %ebp, %eax
jg 0x29e2c
movslq %eax, %rdx
movq (%rsp), %rbx
movq 0x8(%rbx), %rcx
movl $0x1, %esi
movq %r12, %rdi
callq 0xac90
movq 0x8(%rbx), %rdi
callq 0xa700
testb $0x1, %r13b
jne 0x29d89
movq %r12, %rdi
callq 0xa810
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29d9c
callq 0xa570
movq 0x571fd(%rip), %rsi # 0x80fa0
leaq 0x98(%rsp), %rdi
callq 0xa310
leaq 0x108(%rsp), %rdi
callq 0xa1b0
addq $0x418, %rsp # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x34e82(%rip), %rdi # 0x5ec58
leaq 0x34d82(%rip), %rsi # 0x5eb5f
leaq 0x34e2d(%rip), %rcx # 0x5ec11
movl $0x4e, %edx
callq 0xa3e0
leaq 0x34df5(%rip), %rdi # 0x5ebea
leaq 0x34d63(%rip), %rsi # 0x5eb5f
leaq 0x34e0e(%rip), %rcx # 0x5ec11
movl $0x4b, %edx
callq 0xa3e0
leaq 0x2f2b3(%rip), %rdi # 0x590c7
leaq 0x34d44(%rip), %rsi # 0x5eb5f
leaq 0x34def(%rip), %rcx # 0x5ec11
movl $0x67, %edx
callq 0xa3e0
leaq 0x34e41(%rip), %rdi # 0x5ec74
leaq 0x34d25(%rip), %rsi # 0x5eb5f
leaq 0x34dd0(%rip), %rcx # 0x5ec11
movl $0x71, %edx
callq 0xa3e0
nop
|
/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 0x2a7ce
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x27150
|
/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 RandomAccessFileImpl(file_map_[fname]);
return Status::OK();
}
|
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 %r13, %rax
je 0x2a077
movl $0x10, %edi
callq 0xa5c0
movq %rax, %r13
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2a884
movq (%rax), %rdi
leaq 0x5600a(%rip), %rax # 0x80068
movq %rax, (%r13)
movq %rdi, 0x8(%r13)
callq 0x2aae6
movq %r13, (%r15)
movq $0x0, (%rbx)
jmp 0x2a0b7
movq $0x0, (%r15)
movq (%r12), %rax
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rdx)
leaq 0x34cfa(%rip), %rax # 0x5ed94
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq $0xe, 0x8(%rcx)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x277ac
movq %r14, %rdi
callq 0xa4a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0xa3f0
|
/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, %rsi
callq 0x2af4c
movq $0x0, (%rbx)
jmp 0x2a456
movq (%r15), %rax
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rdx)
leaq 0x3495b(%rip), %rax # 0x5ed94
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq $0xe, 0x8(%rcx)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x277ac
movq %r14, %rdi
callq 0xa4a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0xa3f0
|
/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_map_.erase(src);
return Status::OK();
}
|
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
cmpq %rcx, %rax
je 0x2a5cd
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2af4c
movq %r13, %rdi
movq %r15, %rsi
callq 0x2a884
movq (%rax), %rbp
movq %r13, %rdi
movq %r12, %rsi
callq 0x2a884
movq %rbp, (%rax)
movq %r13, %rdi
movq %r15, %rsi
callq 0x2af92
movq $0x0, (%rbx)
jmp 0x2a604
movq (%r15), %rax
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rdx)
leaq 0x347ad(%rip), %rax # 0x5ed94
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq $0xe, 0x8(%rcx)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x277ac
movq %r14, %rdi
callq 0xa4a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0xa3f0
nop
|
/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 0x2a722
callq 0xa570
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa570
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
callq 0xa3f0
leaq 0x2faac(%rip), %rdi # 0x5a1f3
leaq 0x345a7(%rip), %rsi # 0x5ecf5
leaq 0x34607(%rip), %rcx # 0x5ed5c
movl $0x2e, %edx
callq 0xa3e0
nop
|
/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
addq $0x28, %rdi
leaq 0x4(%rsp), %rdx
movl $0x0, (%rdx)
xorl %esi, %esi
callq 0x2b84c
popq %rax
retq
leaq 0x3397f(%rip), %rdi # 0x5eebf
leaq 0x3399d(%rip), %rsi # 0x5eee4
leaq 0x339fb(%rip), %rcx # 0x5ef49
movl $0x2a, %edx
callq 0xa3e0
|
/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 %ebx, 0x44(%r12)
leaq 0x58(%r12), %rax
movq %rax, 0x48(%r12)
movq $0x0, 0x50(%r12)
movb $0x0, 0x58(%r12)
leaq 0x362c7(%rip), %rax # 0x61dc5
movq %rax, 0x68(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r12)
testl %ebx, %ebx
je 0x2bb19
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x335a6(%rip), %rdi # 0x5f0c6
leaq 0x33542(%rip), %rsi # 0x5f069
leaq 0x335aa(%rip), %rcx # 0x5f0d8
movl $0x7c, %edx
callq 0xa3e0
|
/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_restarts_;
return;
}
restart_index_--;
}
SeekToRestartPoint(restart_index_);
do {
// Loop until end of current entry hits the start of original entry
} while (ParseNextKey() && NextEntryOffset() < original);
}
|
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,%r8,4)
jb 0x2be6c
subl $0x1, %esi
jb 0x2be8f
movl %esi, 0x44(%rbx)
cmpl %eax, %edi
jb 0x2be38
leaq 0x332d5(%rip), %rdi # 0x5f129
leaq 0x3320e(%rip), %rsi # 0x5f069
leaq 0x332dd(%rip), %rcx # 0x5f13f
movl $0x65, %edx
callq 0xa3e0
movq %rbx, %rdi
callq 0x2bf4a
movq %rbx, %rdi
callq 0x2bfa0
testb %al, %al
je 0x2be95
movl 0x68(%rbx), %eax
addl 0x70(%rbx), %eax
subl 0x30(%rbx), %eax
cmpl %eax, %ebp
ja 0x2be74
jmp 0x2be95
movl %ecx, 0x40(%rbx)
movl %eax, 0x44(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2e6c6(%rip), %rdi # 0x5a569
leaq 0x331bf(%rip), %rsi # 0x5f069
leaq 0x33304(%rip), %rcx # 0x5f1b5
movl $0x90, %edx
callq 0xa3e0
nop
|
/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(%rsp), %r14
movq %r14, %rdi
movl $0x2, %esi
callq 0x277ac
movq 0x78(%rbx), %rdi
movq (%r14), %rax
movq %rax, 0x78(%rbx)
movq %rdi, (%r14)
testq %rdi, %rdi
je 0x2c19c
callq 0xa810
xorl %eax, %eax
movq %rax, 0x50(%rbx)
movq 0x48(%rbx), %rcx
movb $0x0, (%rcx)
movq %r15, 0x68(%rbx)
movq %rax, 0x70(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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(%rdi)
movups %xmm0, 0x80(%rdi)
retq
|
/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 %rbx
popq %r14
retq
leaq 0x32ff8(%rip), %rdi # 0x5f241
leaq 0x33018(%rip), %rsi # 0x5f268
leaq 0x33075(%rip), %rcx # 0x5f2cc
movl $0x17, %edx
callq 0xa3e0
nop
|
/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
cmpq %rbx, %rdi
je 0x2e753
popq %rbx
jmp 0xa570
popq %rbx
retq
nop
|
/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 $0x6dd, %ecx # imm = 0x6DD
callq 0x4d76a
movq 0x4f95a(%rip), %rdi # 0x80fe8
leaq 0x2ed0a(%rip), %rsi # 0x6039f
movl $0x18, %edx
callq 0xa6b0
movq 0x4f942(%rip), %rdi # 0x80fe8
leaq 0x2ea0b(%rip), %rsi # 0x600b8
movl $0x12, %edx
callq 0xa6b0
movq 0x4f92a(%rip), %rdi # 0x80fe8
movl %ebp, %esi
callq 0xab30
leaq 0x4(%rsp), %rdi
callq 0x4d89c
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x316de
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x318d7
nop
|
/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_->MakeNewHolder();
ThreadLocalValueHolderBase* const holder_base = new_holder;
GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
return new_holder->pointer();
}
|
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(%rip), %rdx # 0x5ffff
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x705, %ecx # imm = 0x705
callq 0x4d76a
movq 0x4e32e(%rip), %rdi # 0x80fe8
leaq 0x2d6f7(%rip), %rsi # 0x603b8
movl $0x26, %edx
callq 0xa6b0
movq 0x4e316(%rip), %rdi # 0x80fe8
leaq 0x2d3df(%rip), %rsi # 0x600b8
movl $0x12, %edx
callq 0xa6b0
movq 0x4e2fe(%rip), %rdi # 0x80fe8
movl %ebp, %esi
callq 0xab30
leaq 0xc(%rsp), %rdi
callq 0x4d89c
addq $0x8, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x4d89c
movq %rbx, %rdi
callq 0xab90
|
/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 number in the range [0, 0).";
GTEST_CHECK_(range <= kMaxRange)
<< "Generation of a number in [0, " << range << ") was requested, "
<< "but this can only generate numbers in [0, " << kMaxRange << ").";
// Converting via modulus introduces a bit of downward bias, but
// it's simple, and a linear congruential generator isn't too good
// to begin with.
return state_ % range;
}
|
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
jb 0x3326d
leaq 0x2e0a1(%rip), %rdx # 0x61214
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x16a, %ecx # imm = 0x16A
callq 0x4d76a
movq 0x4de5a(%rip), %rdi # 0x80fe8
leaq 0x2e147(%rip), %rsi # 0x612dc
movl $0x25, %edx
callq 0xa6b0
movq 0x4de42(%rip), %rdi # 0x80fe8
leaq 0x2e155(%rip), %rsi # 0x61302
movl $0x1e, %edx
callq 0xa6b0
movl %ebx, %esi
movq 0x4de28(%rip), %rdi # 0x80fe8
callq 0xa400
movq %rax, %r15
leaq 0x2e152(%rip), %rsi # 0x61321
movl $0x11, %edx
movq %rax, %rdi
callq 0xa6b0
leaq 0x2e150(%rip), %rsi # 0x61333
movl $0x2a, %edx
movq %r15, %rdi
callq 0xa6b0
movl $0x80000000, %esi # imm = 0x80000000
movq %r15, %rdi
callq 0xa400
leaq 0x2c83e(%rip), %rsi # 0x5fa42
movl $0x2, %edx
movq %rax, %rdi
callq 0xa6b0
leaq 0x8(%rsp), %rdi
jmp 0x33268
leaq 0x2dff5(%rip), %rdx # 0x61214
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x168, %ecx # imm = 0x168
callq 0x4d76a
movq 0x4ddae(%rip), %rdi # 0x80fe8
leaq 0x2e050(%rip), %rsi # 0x61291
movl $0x1c, %edx
callq 0xa6b0
movq 0x4dd96(%rip), %rdi # 0x80fe8
leaq 0x2e055(%rip), %rsi # 0x612ae
movl $0x2d, %edx
callq 0xa6b0
leaq 0xc(%rsp), %rdi
callq 0x4d89c
movl (%r14), %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x33292
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4d89c
movq %rbx, %rdi
callq 0xab90
|
/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", counts.c_str(), test_case.name(),
internal::StreamableToString(test_case.elapsed_time()).c_str());
fflush(stdout);
}
|
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 # 0x627e3
leaq 0x24b61(%rip), %rcx # 0x61d47
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3ce38
leaq 0x24b3f(%rip), %rsi # 0x61d39
movl $0x2, %edi
xorl %eax, %eax
callq 0x3c7a0
movq (%r14), %r14
movq 0x8(%rbx), %r15
movq 0x80(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x51b7c
leaq 0x40(%rsp), %rbx
movq -0x10(%rbx), %rcx
leaq 0x24b75(%rip), %rdi # 0x61dab
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xa080
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x3d251
callq 0xa570
movq 0x43d20(%rip), %rax # 0x80f78
movq (%rax), %rdi
callq 0xa700
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d273
callq 0xa570
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d293
callq 0xa570
movq %rbx, %rdi
callq 0xab90
nop
|
/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 = "testcase";
if (test_info.is_in_another_shard()) {
return;
}
*stream << " <testcase";
OutputXmlAttribute(stream, kTestsuite, "name", test_info.name());
if (test_info.value_param() != nullptr) {
OutputXmlAttribute(stream, kTestsuite, "value_param",
test_info.value_param());
}
if (test_info.type_param() != nullptr) {
OutputXmlAttribute(stream, kTestsuite, "type_param",
test_info.type_param());
}
if (GTEST_FLAG(list_tests)) {
OutputXmlAttribute(stream, kTestsuite, "file", test_info.file());
OutputXmlAttribute(stream, kTestsuite, "line",
StreamableToString(test_info.line()));
*stream << " />\n";
return;
}
OutputXmlAttribute(stream, kTestsuite, "status",
test_info.should_run() ? "run" : "notrun");
OutputXmlAttribute(stream, kTestsuite, "result",
test_info.should_run()
? (result.Skipped() ? "skipped" : "completed")
: "suppressed");
OutputXmlAttribute(stream, kTestsuite, "time",
FormatTimeInMillisAsSeconds(result.elapsed_time()));
OutputXmlAttribute(
stream, kTestsuite, "timestamp",
FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name);
int failures = 0;
for (int i = 0; i < result.total_part_count(); ++i) {
const TestPartResult& part = result.GetTestPartResult(i);
if (part.failed()) {
if (++failures == 1) {
*stream << ">\n";
}
const std::string location =
internal::FormatCompilerIndependentFileLocation(part.file_name(),
part.line_number());
const std::string summary = location + "\n" + part.summary();
*stream << " <failure message=\""
<< EscapeXmlAttribute(summary)
<< "\" type=\"\">";
const std::string detail = location + "\n" + part.message();
OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
*stream << "</failure>\n";
}
}
if (failures == 0 && result.test_property_count() == 0) {
*stream << " />\n";
} else {
if (failures == 0) {
*stream << ">\n";
}
OutputXmlTestProperties(stream, result);
*stream << " </testcase>\n";
}
}
|
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 0x406a7
leaq 0x220f8(%rip), %rsi # 0x61f79
movl $0xd, %edx
movq 0x8(%rsp), %rdi
callq 0xa6b0
leaq 0x40(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x1b94b(%rip), %rsi # 0x5b7eb
leaq 0x1b948(%rip), %rdx # 0x5b7ef
leaq 0x30(%rsp), %rdi
callq 0x105c0
movq 0x20(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0xa210
leaq 0x78(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
callq 0x3fb3e
leaq 0x20(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x3fef0
callq 0xa570
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3feff
callq 0xa570
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x3ff7f
cmpq $0x0, (%rax)
je 0x3ff7f
leaq 0x30(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x2206a(%rip), %rsi # 0x61f87
leaq 0x2206e(%rip), %rdx # 0x61f92
callq 0x105c0
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x3ff37
movq (%rax), %rsi
jmp 0x3ff39
xorl %esi, %esi
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0xa210
leaq 0x78(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
callq 0x3fb3e
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x3ff70
callq 0xa570
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3ff7f
callq 0xa570
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x3ffff
cmpq $0x0, (%rax)
je 0x3ffff
leaq 0x30(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x21ff6(%rip), %rsi # 0x61f93
leaq 0x21ff9(%rip), %rdx # 0x61f9d
callq 0x105c0
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x3ffb7
movq (%rax), %rsi
jmp 0x3ffb9
xorl %esi, %esi
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0xa210
leaq 0x78(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
callq 0x3fb3e
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x3fff0
callq 0xa570
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3ffff
callq 0xa570
cmpb $0x1, 0x419c3(%rip) # 0x819c9
jne 0x400f3
leaq 0x30(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x1b82a(%rip), %rsi # 0x5b845
leaq 0x1b827(%rip), %rdx # 0x5b849
callq 0x105c0
movq 0x50(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0xa210
leaq 0x78(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
callq 0x3fb3e
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x40062
callq 0xa570
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x40071
callq 0xa570
leaq 0x30(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x1bbf7(%rip), %rsi # 0x5bc77
leaq 0x1bbf4(%rip), %rdx # 0x5bc7b
callq 0x105c0
movl 0x70(%r14), %eax
leaq 0x50(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x51be6
leaq 0x78(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
callq 0x3fb3e
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x400c9
callq 0xa570
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x400d8
callq 0xa570
leaq 0x21ebf(%rip), %rsi # 0x61f9e
movl $0x4, %edx
movq 0x8(%rsp), %rdi
callq 0xa6b0
jmp 0x406a7
leaq 0x30(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x21ea1(%rip), %rsi # 0x61fa3
leaq 0x21ea0(%rip), %rdx # 0x61fa9
callq 0x105c0
movzbl 0x80(%r14), %eax
leaq 0x21e90(%rip), %rcx # 0x61fad
leaq 0x21e86(%rip), %rsi # 0x61faa
testq %rax, %rax
cmovneq %rcx, %rsi
leaq 0x10(%rsp), %rdi
movq %r15, (%rdi)
xorq $0x1, %rax
leaq (%rax,%rax,2), %rax
leaq (%rsi,%rax), %rdx
addq $0x3, %rdx
callq 0x105c0
leaq 0x78(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
callq 0x3fb3e
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x40170
callq 0xa570
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4017f
callq 0xa570
leaq 0x30(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x21e23(%rip), %rsi # 0x61fb1
leaq 0x21e22(%rip), %rdx # 0x61fb7
callq 0x105c0
leaq 0x90(%r14), %rdi
cmpb $0x1, 0x80(%r14)
movq %rdi, 0x70(%rsp)
jne 0x401cb
callq 0x3a5f0
leaq 0x21dfc(%rip), %rcx # 0x61fb8
leaq 0x21dfd(%rip), %r15 # 0x61fc0
testb %al, %al
cmovneq %rcx, %r15
jmp 0x401d2
leaq 0x21df8(%rip), %r15 # 0x61fca
leaq 0x10(%rsp), %r13
leaq 0x20(%rsp), %rax
movq %rax, (%r13)
movq %r15, %rdi
callq 0xa240
leaq (%rax,%r15), %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0x105c0
leaq 0x78(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
callq 0x3fb3e
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %r15
cmpq %r15, %rdi
je 0x40224
callq 0xa570
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x40233
callq 0xa570
leaq 0x30(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x21d93(%rip), %rsi # 0x61fd5
leaq 0x21d90(%rip), %rdx # 0x61fd9
callq 0x105c0
movq 0x108(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0x3f078
leaq 0x78(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
callq 0x3fb3e
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x40287
callq 0xa570
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x40296
callq 0xa570
leaq 0x30(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x21d35(%rip), %rsi # 0x61fda
leaq 0x21d37(%rip), %rdx # 0x61fe3
callq 0x105c0
movq 0x100(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0x3f105
leaq 0x78(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
callq 0x3fb3e
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x402ea
callq 0xa570
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x402f9
callq 0xa570
leaq 0x30(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x21cdc(%rip), %rsi # 0x61fe4
leaq 0x21cde(%rip), %rdx # 0x61fed
callq 0x105c0
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movq %r12, %rsi
callq 0xa210
leaq 0x78(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
callq 0x3fb3e
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4034e
callq 0xa570
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
movq 0x70(%rsp), %r15
je 0x40362
callq 0xa570
movq 0xd0(%r14), %rax
subq 0xc8(%r14), %rax
shrq $0x4, %rax
imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7
testl %eax, %eax
jle 0x4064a
leaq 0x60(%rsp), %rbx
xorl %ebp, %ebp
xorl %r13d, %r13d
movq %r15, %rdi
movl %ebp, %esi
callq 0x39f38
movq %rax, %r15
movl (%rax), %eax
decl %eax
cmpl $0x1, %eax
ja 0x4043e
testl %r13d, %r13d
jne 0x403c1
movl $0x2, %edx
movq 0x8(%rsp), %rdi
leaq 0x21be4(%rip), %rsi # 0x61fa0
callq 0xa6b0
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x403ce
movq 0x8(%r15), %rsi
movl 0x28(%r15), %edx
leaq 0x30(%rsp), %rdi
callq 0x40836
movq %rbx, 0x50(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0xfb0e
movq %r12, %rdi
leaq 0x219bf(%rip), %rsi # 0x61dc4
callq 0xac80
movq 0x30(%r15), %rsi
movq %r12, %rdi
callq 0xac80
leaq 0x20(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x40448
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x4044e
movq 0x70(%rsp), %r15
jmp 0x4061b
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x40475
callq 0xa570
movl $0x18, %edx
movq 0x8(%rsp), %rdi
leaq 0x21b68(%rip), %rsi # 0x61fee
callq 0xa6b0
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x3edc4
movq %rbx, %r12
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x8(%rsp), %rdi
callq 0xa6b0
movl $0xa, %edx
movq %rax, %rdi
leaq 0x21b42(%rip), %rsi # 0x62007
callq 0xa6b0
movq %r14, %rbx
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x404dc
callq 0xa570
leaq 0xa8(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
leaq 0x98(%rsp), %r14
movq %r14, %rdi
callq 0xfb0e
movq %r14, %rdi
leaq 0x218b1(%rip), %rsi # 0x61dc4
callq 0xac80
movq 0x50(%r15), %rsi
movq %r14, %rdi
callq 0xac80
movq %r12, %rsi
movq %r12, 0x50(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
movq 0x70(%rsp), %r15
movq %rbx, %r14
je 0x40552
movq %rdx, 0x50(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x60(%rsp)
jmp 0x40558
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq %rsi, %rbx
movq 0x8(%rax), %rdx
movq %rdx, 0x58(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
je 0x4058d
callq 0xa570
leaq 0x98(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3efe0
movq 0x98(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x3fa6a
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
je 0x405cb
callq 0xa570
movl $0xb, %edx
movq 0x8(%rsp), %rdi
leaq 0x21a36(%rip), %rsi # 0x62012
callq 0xa6b0
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x405f0
callq 0xa570
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x40604
callq 0xa570
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x40618
callq 0xa570
incl %r13d
movq 0xd0(%r14), %rax
subq 0xc8(%r14), %rax
incl %ebp
shrq $0x4, %rax
imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7
cmpl %eax, %ebp
jl 0x4038c
testl %r13d, %r13d
leaq 0x88(%rsp), %rbx
jne 0x40676
movq 0xe8(%r14), %rax
subq 0xe0(%r14), %rax
shrq $0x6, %rax
testl %eax, %eax
je 0x40691
leaq 0x21939(%rip), %rsi # 0x61fa0
movl $0x2, %edx
movq 0x8(%rsp), %rdi
callq 0xa6b0
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x40a0a
movl $0x10, %edx
leaq 0x2198f(%rip), %rsi # 0x6201e
jmp 0x4069d
movl $0x4, %edx
leaq 0x21901(%rip), %rsi # 0x61f9e
movq 0x8(%rsp), %rdi
callq 0xa6b0
movq 0x78(%rsp), %rdi
cmpq %rbx, %rdi
je 0x406b6
callq 0xa570
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x40750
jmp 0x4071b
jmp 0x40750
jmp 0x4071b
jmp 0x40814
jmp 0x40750
jmp 0x40814
jmp 0x4071b
jmp 0x40750
jmp 0x40814
jmp 0x4071b
jmp 0x40750
jmp 0x40814
jmp 0x4071b
jmp 0x40750
jmp 0x40814
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
jmp 0x40744
jmp 0x4071b
jmp 0x40750
jmp 0x40750
jmp 0x40814
jmp 0x40814
jmp 0x4071b
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
jne 0x40749
jmp 0x40753
jmp 0x40750
jmp 0x40750
jmp 0x40814
jmp 0x40814
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40753
callq 0xa570
jmp 0x40753
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
jne 0x4080d
jmp 0x40817
jmp 0x40814
jmp 0x40814
jmp 0x40814
jmp 0x40814
jmp 0x407a6
jmp 0x407b5
jmp 0x407b5
jmp 0x407ba
movq %rax, %r14
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
je 0x407db
callq 0xa570
jmp 0x407db
movq %rax, %r14
jmp 0x407fe
movq %rax, %r14
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
jne 0x407f9
jmp 0x407fe
movq %rax, %r14
jmp 0x407ea
movq %rax, %r14
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
jne 0x407e5
jmp 0x407ea
jmp 0x407d8
jmp 0x407d8
movq %rax, %r14
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x407ea
callq 0xa570
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x407fe
callq 0xa570
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x40817
callq 0xa570
jmp 0x40817
movq %rax, %r14
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x4082e
callq 0xa570
movq %r14, %rdi
callq 0xab90
|
/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 = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
*stream << "<" << kProperty;
*stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\"";
*stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\"";
*stream << "/>\n";
}
*stream << "</" << kProperties << ">\n";
}
|
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)
leaq 0x21647(%rip), %rsi # 0x62099
leaq 0x21648(%rip), %rdx # 0x620a1
leaq 0x68(%rsp), %rdi
callq 0x105c0
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
testl %eax, %eax
jle 0x40c6d
leaq 0x215bd(%rip), %rsi # 0x6203b
movl $0x1, %edx
movq %rbx, %rdi
callq 0xa6b0
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0xa6b0
leaq 0x214fc(%rip), %rsi # 0x61fa0
movl $0x2, %edx
movq %rax, %rdi
callq 0xa6b0
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
testl %eax, %eax
jle 0x40c33
xorl %ebp, %ebp
leaq 0x48(%rsp), %r13
leaq 0x2167d(%rip), %r15 # 0x62150
movq %r14, %rdi
movl %ebp, %esi
callq 0x39f96
movq %rax, %r12
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x2154c(%rip), %rsi # 0x6203b
callq 0xa6b0
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq %rbx, %rdi
callq 0xa6b0
movl $0x7, %edx
movq %rbx, %rdi
leaq 0x2158d(%rip), %rsi # 0x620a2
callq 0xa6b0
movq (%r12), %rsi
movq %r13, %rdi
leaq 0x7(%rsp), %rdx
callq 0xa210
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x3edc4
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xa6b0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0xa6b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x40b73
callq 0xa570
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x40b87
callq 0xa570
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x21514(%rip), %rsi # 0x620aa
callq 0xa6b0
movq 0x20(%r12), %rsi
movq %r13, %rdi
leaq 0x7(%rsp), %rdx
callq 0xa210
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x3edc4
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xa6b0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0xa6b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x40bf5
callq 0xa570
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x40c09
callq 0xa570
movl $0x3, %edx
movq %rbx, %rdi
leaq 0x21387(%rip), %rsi # 0x61f9f
callq 0xa6b0
incl %ebp
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jl 0x40ad3
leaq 0x21415(%rip), %rsi # 0x6204f
movl $0x2, %edx
movq %rbx, %rdi
callq 0xa6b0
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0xa6b0
leaq 0x21340(%rip), %rsi # 0x61fa0
movl $0x2, %edx
movq %rax, %rdi
callq 0xa6b0
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x40c81
callq 0xa570
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x40c95
callq 0xa570
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x40cff
jmp 0x40ce8
jmp 0x40ce8
jmp 0x40cb4
jmp 0x40ce8
movq %rax, %rbx
jmp 0x40cd2
jmp 0x40cbb
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x40cd2
callq 0xa570
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x40ceb
callq 0xa570
jmp 0x40ceb
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x40cff
callq 0xa570
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x40d13
callq 0xa570
movq %rbx, %rdi
callq 0xab90
nop
|
/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() << "="
<< "\"" << EscapeXmlAttribute(property.value()) << "\"";
}
return attributes.GetString();
}
|
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), %rax
leaq 0x10(%rax), %r12
xorl %ebp, %ebp
leaq 0x40(%rsp), %r13
movq %r15, %rdi
movl %ebp, %esi
callq 0x39f96
movq %rax, %r14
movl $0x1, %edx
movq %r12, %rdi
leaq 0x20451(%rip), %rsi # 0x61704
callq 0xa6b0
movq (%r14), %rbx
testq %rbx, %rbx
je 0x412cd
movq %rbx, %rdi
callq 0xa240
movq %rax, %rdx
jmp 0x412d9
movl $0x6, %edx
leaq 0x18233(%rip), %rbx # 0x5950c
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa6b0
movl $0x1, %edx
movq %r12, %rdi
leaq 0x181fa(%rip), %rsi # 0x594ed
callq 0xa6b0
movl $0x1, %edx
movq %r12, %rdi
leaq 0x20e49(%rip), %rsi # 0x62150
callq 0xa6b0
movq 0x20(%r14), %rsi
movq %r13, %rdi
leaq 0xf(%rsp), %rdx
callq 0xa210
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x3edc4
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0xa6b0
movl $0x1, %edx
movq %r12, %rdi
leaq 0x20e00(%rip), %rsi # 0x62150
callq 0xa6b0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x41369
callq 0xa570
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x4137d
callq 0xa570
incl %ebp
movq 0x58(%r15), %rax
subq 0x50(%r15), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jl 0x41297
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x36b3d
testq %r14, %r14
je 0x413b6
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4140b
jmp 0x41403
movq %rax, %rbx
jmp 0x413ed
jmp 0x41403
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x413ed
callq 0xa570
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x41406
callq 0xa570
jmp 0x41406
movq %rax, %rbx
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x41419
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xab90
nop
|
/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::allocator<char>> const&, bool)
|
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_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
allowed_names.end())
<< "Key \"" << name << "\" is not allowed for value \"" << element_name
<< "\".";
*stream << indent << "\"" << name << "\": " << StreamableToString(value);
if (comma)
*stream << ",\n";
}
|
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), %rax
jne 0x42017
leaq 0x1f29a(%rip), %rdx # 0x61214
leaq 0x10(%rsp), %rdi
movl $0x3, %esi
movl $0x11a4, %ecx # imm = 0x11A4
callq 0x4d76a
movq 0x3f053(%rip), %rdi # 0x80fe8
leaq 0x1ff4b(%rip), %rsi # 0x61ee7
movl $0x65, %edx
callq 0xa6b0
movq 0x3f03b(%rip), %rdi # 0x80fe8
leaq 0x20134(%rip), %rsi # 0x620e8
movl $0x5, %edx
callq 0xa6b0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x3f01c(%rip), %rdi # 0x80fe8
callq 0xa6b0
movq %rax, %r13
leaq 0x20113(%rip), %rsi # 0x620ee
movl $0x1c, %edx
movq %rax, %rdi
callq 0xa6b0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0xa6b0
leaq 0x2010b(%rip), %rsi # 0x6210b
movl $0x2, %edx
movq %rax, %rdi
callq 0xa6b0
leaq 0x10(%rsp), %rdi
callq 0x4d89c
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0xa6b0
movq %rax, %r15
leaq 0x20120(%rip), %rsi # 0x62150
movl $0x1, %edx
movq %rax, %rdi
callq 0xa6b0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0xa6b0
movq %rax, %r14
leaq 0x200b8(%rip), %rsi # 0x6210e
movl $0x3, %edx
movq %rax, %rdi
callq 0xa6b0
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x51be6
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0xa6b0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42097
callq 0xa570
testb %bpl, %bpl
je 0x420b0
leaq 0x200b0(%rip), %rsi # 0x62153
movl $0x2, %edx
movq %rbx, %rdi
callq 0xa6b0
leaq 0x30(%rsp), %rdi
callq 0x10390
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x420f6
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x420f9
callq 0xa570
jmp 0x420f9
jmp 0x420f6
jmp 0x420f6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4d89c
jmp 0x420f9
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x10390
movq %rbx, %rdi
callq 0xab90
nop
|
/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 + 1) + "-" +
String::FormatIntWidth2(time_struct.tm_mday) + "T" +
String::FormatIntWidth2(time_struct.tm_hour) + ":" +
String::FormatIntWidth2(time_struct.tm_min) + ":" +
String::FormatIntWidth2(time_struct.tm_sec) + "Z";
}
|
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)
leaq 0x1f0(%rsp), %rsi
callq 0xa2f0
testq %rax, %rax
je 0x42d10
movl $0x76c, %eax # imm = 0x76C
addl 0x204(%rsp), %eax
leaq 0x1ec(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x228(%rsp), %r14
movq %r14, %rdi
callq 0x51be6
leaq 0x1d754(%rip), %rsi # 0x6042c
movq %r14, %rdi
callq 0xac80
leaq 0xb8(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x42d2e
movq %rdx, 0xa8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xb8(%rsp)
jmp 0x42d35
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1f0a7(%rip), %rdx # 0x61dc5
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x105c0
jmp 0x434a9
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0xb0(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x200(%rsp), %esi
incl %esi
leaq 0x1c8(%rsp), %rdi
callq 0x39d18
movq 0xa8(%rsp), %rcx
movq 0xb0(%rsp), %r8
movq 0x1d0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r14, %rcx
je 0x42d94
movq 0xb8(%rsp), %rdi
movq 0x1c8(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x42dc0
leaq 0x1d8(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x42dbb
movq 0x1d8(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x42dcf
leaq 0xa8(%rsp), %rdi
callq 0xa190
jmp 0x42de0
leaq 0x1c8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x38(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x42e04
movq %rsi, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x42e0a
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x1d5fe(%rip), %rsi # 0x6042c
leaq 0x28(%rsp), %rdi
callq 0xac80
leaq 0xd8(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x42e68
movq %rdx, 0xc8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xd8(%rsp)
jmp 0x42e6f
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0xd0(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x1fc(%rsp), %esi
leaq 0x1a8(%rsp), %rdi
callq 0x39d18
movq 0xc8(%rsp), %rcx
movq 0xd0(%rsp), %r8
movq 0x1b0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r15, %rcx
je 0x42ecc
movq 0xd8(%rsp), %rdi
movq 0x1a8(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x42ef8
leaq 0x1b8(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x42ef3
movq 0x1b8(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x42f07
leaq 0xc8(%rsp), %rdi
callq 0xa190
jmp 0x42f18
leaq 0x1a8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x58(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x42f3c
movq %rsi, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x42f42
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x17be3(%rip), %rsi # 0x5ab49
leaq 0x48(%rsp), %rdi
callq 0xac80
leaq 0xf8(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x42fa1
movq %rdx, 0xe8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xf8(%rsp)
jmp 0x42fa9
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0xf0(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x1f8(%rsp), %esi
leaq 0x188(%rsp), %rdi
callq 0x39d18
movq 0xe8(%rsp), %rcx
movq 0xf0(%rsp), %r8
movq 0x190(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r12, %rcx
je 0x43006
movq 0xf8(%rsp), %rdi
movq 0x188(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x43032
leaq 0x198(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x4302d
movq 0x198(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x43041
leaq 0xe8(%rsp), %rdi
callq 0xa190
jmp 0x43052
leaq 0x188(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x78(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x43076
movq %rsi, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0x4307c
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x70(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x1c45a(%rip), %rsi # 0x5f4fa
leaq 0x68(%rsp), %rdi
callq 0xac80
leaq 0x118(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x430da
movq %rdx, 0x108(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x118(%rsp)
jmp 0x430e2
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x110(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x1f4(%rsp), %esi
leaq 0x168(%rsp), %rdi
callq 0x39d18
movq 0x108(%rsp), %rcx
movq 0x110(%rsp), %r8
movq 0x170(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r13, %rcx
je 0x4313f
movq 0x118(%rsp), %rdi
movq 0x168(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x4316b
leaq 0x178(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x43166
movq 0x178(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4317a
leaq 0x108(%rsp), %rdi
callq 0xa190
jmp 0x4318b
leaq 0x168(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x98(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x431b8
movq %rsi, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
jmp 0x431be
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x90(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x1c315(%rip), %rsi # 0x5f4fa
leaq 0x88(%rsp), %rdi
callq 0xac80
leaq 0x138(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x43222
movq %rdx, 0x128(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x138(%rsp)
jmp 0x43229
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
movq %rdx, 0x130(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x1f0(%rsp), %esi
leaq 0x148(%rsp), %rdi
callq 0x39d18
movq 0x128(%rsp), %rcx
movq 0x130(%rsp), %r8
movq 0x150(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %rbp, %rcx
je 0x43286
movq 0x138(%rsp), %rdi
movq 0x148(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x432b2
leaq 0x158(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x432ad
movq 0x158(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x432c1
leaq 0x128(%rsp), %rdi
callq 0xa190
jmp 0x432d2
leaq 0x148(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x432f6
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x432fc
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x1faf7(%rip), %rsi # 0x62e17
leaq 0x8(%rsp), %rdi
callq 0xac80
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x4334c
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x43352
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4337c
callq 0xa570
leaq 0x158(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43392
callq 0xa570
movq 0x128(%rsp), %rdi
cmpq %rbp, %rdi
je 0x433a4
callq 0xa570
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x433ba
callq 0xa570
leaq 0x178(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x433d0
callq 0xa570
movq 0x108(%rsp), %rdi
cmpq %r13, %rdi
je 0x433e2
callq 0xa570
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x433f5
callq 0xa570
leaq 0x198(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4340b
callq 0xa570
movq 0xe8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4341d
callq 0xa570
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43430
callq 0xa570
leaq 0x1b8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43446
callq 0xa570
movq 0xc8(%rsp), %rdi
cmpq %r15, %rdi
je 0x43458
callq 0xa570
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4346b
callq 0xa570
leaq 0x1d8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43481
callq 0xa570
movq 0xa8(%rsp), %rdi
cmpq %r14, %rdi
je 0x43493
callq 0xa570
leaq 0x238(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x434a9
callq 0xa570
addq $0x248, %rsp # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x434d6
callq 0xa570
jmp 0x434d6
movq %rax, %rbx
leaq 0x158(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x434f1
callq 0xa570
jmp 0x434f1
movq %rax, %rbx
movq 0x128(%rsp), %rdi
cmpq %rbp, %rdi
je 0x43508
callq 0xa570
jmp 0x43508
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43523
callq 0xa570
jmp 0x43523
movq %rax, %rbx
leaq 0x178(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4353e
callq 0xa570
jmp 0x4353e
movq %rax, %rbx
movq 0x108(%rsp), %rdi
cmpq %r13, %rdi
je 0x43555
callq 0xa570
jmp 0x43555
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4356d
callq 0xa570
jmp 0x4356d
movq %rax, %rbx
leaq 0x198(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43588
callq 0xa570
jmp 0x43588
movq %rax, %rbx
movq 0xe8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4359a
callq 0xa570
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x435ad
callq 0xa570
leaq 0x1b8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x435c3
callq 0xa570
movq 0xc8(%rsp), %rdi
cmpq %r15, %rdi
je 0x435d5
callq 0xa570
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x435e8
callq 0xa570
leaq 0x1d8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x435fe
callq 0xa570
movq 0xa8(%rsp), %rdi
cmpq %r14, %rdi
je 0x43610
callq 0xa570
leaq 0x238(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43626
callq 0xa570
movq %rbx, %rdi
callq 0xab90
movq %rax, %rbx
jmp 0x4359a
movq %rax, %rbx
jmp 0x435ad
movq %rax, %rbx
jmp 0x435c3
movq %rax, %rbx
jmp 0x435d5
movq %rax, %rbx
jmp 0x435e8
movq %rax, %rbx
jmp 0x435fe
movq %rax, %rbx
jmp 0x43610
|
/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() << "\": "
<< "\"" << EscapeJson(property.value()) << "\"";
}
return attributes.GetString();
}
|
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
movq 0x10(%rsp), %rax
leaq 0x10(%rax), %r13
xorl %ebp, %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x39f96
movq %rax, %r14
movl $0x2, %edx
movq %r13, %rdi
leaq 0x1e9f2(%rip), %rsi # 0x62153
callq 0xa6b0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r13, %rdi
callq 0xa6b0
movl $0x1, %edx
movq %r13, %rdi
leaq 0x1e9cc(%rip), %rsi # 0x62150
callq 0xa6b0
movq (%r14), %rbx
testq %rbx, %rbx
je 0x4379e
movq %rbx, %rdi
callq 0xa240
movq %rax, %rdx
jmp 0x437aa
movl $0x6, %edx
leaq 0x15d62(%rip), %rbx # 0x5950c
movq %r13, %rdi
movq %rbx, %rsi
callq 0xa6b0
movl $0x3, %edx
movq %r13, %rdi
leaq 0x1e94a(%rip), %rsi # 0x6210e
callq 0xa6b0
movl $0x1, %edx
movq %r13, %rdi
leaq 0x1e978(%rip), %rsi # 0x62150
callq 0xa6b0
movq 0x20(%r14), %rsi
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
leaq 0xf(%rsp), %rdx
callq 0xa210
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x41b6c
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r13, %rdi
callq 0xa6b0
movl $0x1, %edx
movq %r13, %rdi
leaq 0x1e92f(%rip), %rsi # 0x62150
callq 0xa6b0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x4383a
callq 0xa570
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x4384e
callq 0xa570
incl %ebp
movq 0x58(%r12), %rax
subq 0x50(%r12), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jl 0x43745
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x36b3d
testq %r14, %r14
je 0x43889
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x438de
jmp 0x438d6
movq %rax, %rbx
jmp 0x438be
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x438be
callq 0xa570
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x438d9
callq 0xa570
jmp 0x438d9
jmp 0x438d6
movq %rax, %rbx
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x438ec
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xab90
|
/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 = SOCK_STREAM;
addrinfo* servinfo = nullptr;
// Use the getaddrinfo() to get a linked list of IP addresses for
// the given host name.
const int error_num = getaddrinfo(
host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
if (error_num != 0) {
GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
<< gai_strerror(error_num);
}
// Loop through all the results and connect to the first we can.
for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr;
cur_addr = cur_addr->ai_next) {
sockfd_ = socket(
cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
if (sockfd_ != -1) {
// Connect the client socket to the server socket.
if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
close(sockfd_);
sockfd_ = -1;
}
}
}
freeaddrinfo(servinfo); // all done with this structure
if (sockfd_ == -1) {
GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "
<< host_name_ << ":" << port_num_;
}
}
|
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 # 0x6216c
movl $0x20, %edx
callq 0xa6b0
movq 0x3cc51(%rip), %rdi # 0x80fe8
leaq 0x1ddef(%rip), %rsi # 0x6218d
movl $0x44, %edx
callq 0xa6b0
leaq 0x10(%rsp), %rdi
callq 0x4d89c
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movl $0x1, 0x8(%rdx)
leaq 0x8(%rsp), %rcx
movq $0x0, (%rcx)
movq 0x10(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0xa7e0
testl %eax, %eax
je 0x44472
movl %eax, %ebp
leaq 0x1ce1e(%rip), %rdx # 0x61214
leaq 0x4(%rsp), %rdi
movl $0x1, %esi
movl $0x1299, %ecx # imm = 0x1299
callq 0x4d76a
movq 0x3cbd7(%rip), %r14 # 0x80fe8
leaq 0x1ddba(%rip), %rsi # 0x621d2
movl $0x28, %edx
movq %r14, %rdi
callq 0xa6b0
movl %ebp, %edi
callq 0xa8a0
testq %rax, %rax
je 0x44450
movq %rax, %r15
movq %rax, %rdi
callq 0xa240
movq 0x3cba5(%rip), %rdi # 0x80fe8
movq %r15, %rsi
movq %rax, %rdx
callq 0xa6b0
jmp 0x44468
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xaaf0
leaq 0x4(%rsp), %rdi
callq 0x4d89c
movq 0x8(%rsp), %r14
cmpl $-0x1, 0x8(%rbx)
sete %al
testq %r14, %r14
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x444e3
movl 0x4(%r14), %edi
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
callq 0xa100
movl %eax, 0x8(%rbx)
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x444d0
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movl %eax, %edi
callq 0xa4f0
movl 0x8(%rbx), %edi
cmpl $-0x1, %eax
je 0x444c4
movl %edi, %ebp
jmp 0x444d0
callq 0xacb0
movl $0xffffffff, 0x8(%rbx) # imm = 0xFFFFFFFF
cmpl $-0x1, %ebp
jne 0x444de
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x4448b
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa820
cmpl $-0x1, 0x8(%rbx)
jne 0x44569
leaq 0x1cd1c(%rip), %rdx # 0x61214
leaq 0x4(%rsp), %rdi
movl $0x1, %esi
movl $0x12ae, %ecx # imm = 0x12AE
callq 0x4d76a
movq 0x3cad5(%rip), %rdi # 0x80fe8
leaq 0x1dce1(%rip), %rsi # 0x621fb
movl $0x27, %edx
callq 0xa6b0
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x3cab5(%rip), %rdi # 0x80fe8
callq 0xa6b0
movq %rax, %r14
leaq 0x1afb8(%rip), %rsi # 0x5f4fa
movl $0x1, %edx
movq %rax, %rdi
callq 0xa6b0
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movq %r14, %rdi
callq 0xa6b0
leaq 0x4(%rsp), %rdi
callq 0x4d89c
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x44580
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x44588
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x4d89c
movq %rbx, %rdi
callq 0xab90
nop
|
/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 != nullptr) Append(listener);
}
}
|
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 %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3de08
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
|
/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 absolute path
// is specified by the environment variable
// TEST_PREMATURE_EXIT_FILE.
// 2. When Google Test has finished its work, it deletes the file.
//
// This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
// running a Google-Test-based test program and check the existence
// of the file at the end of the test execution to see if it has
// exited prematurely.
// If we are in the child process of a death test, don't
// create/delete the premature exit file, as doing so is unnecessary
// and will confuse the parent process. Otherwise, create/delete
// the file upon entering/leaving this function. If the program
// somehow exits before this function has a chance to return, the
// premature-exit file will be left undeleted, causing a test runner
// that understands the premature-exit-file protocol to report the
// test as having failed.
const internal::ScopedPrematureExitFile premature_exit_file(
in_death_test_child_process
? nullptr
: internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
// Captures the value of GTEST_FLAG(catch_exceptions). This value will be
// used for the duration of the program.
impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
#if GTEST_OS_WINDOWS
// Either the user wants Google Test to catch exceptions thrown by the
// tests or this is executing in the context of death test child
// process. In either case the user does not want to see pop-up dialogs
// about crashes - they are expected.
if (impl()->catch_exceptions() || in_death_test_child_process) {
# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
// SetErrorMode doesn't exist on CE.
SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
# endif // !GTEST_OS_WINDOWS_MOBILE
# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
// Death test children can be terminated with _abort(). On Windows,
// _abort() can show a dialog with a warning message. This forces the
// abort message to go to stderr instead.
_set_error_mode(_OUT_TO_STDERR);
# endif
# if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
// In the debug version, Visual Studio pops up a separate dialog
// offering a choice to debug the aborted program. We need to suppress
// this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
// executed. Google Test will notify the user of any unexpected
// failure via stderr.
if (!GTEST_FLAG(break_on_failure))
_set_abort_behavior(
0x0, // Clear the following flags:
_WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump.
// In debug mode, the Windows CRT can crash with an assertion over invalid
// input (e.g. passing an invalid file descriptor). The default handling
// for these assertions is to pop up a dialog and wait for user input.
// Instead ask the CRT to dump such assertions to stderr non-interactively.
if (!IsDebuggerPresent()) {
(void)_CrtSetReportMode(_CRT_ASSERT,
_CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
(void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
}
# endif
}
#endif // GTEST_OS_WINDOWS
return internal::HandleExceptionsInMethodIfSupported(
impl(),
&internal::UnitTestImpl::RunAllTests,
"auxiliary test code (environments or event listeners)") ? 0 : 1;
}
|
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), %rsi # 0x449f4
leaq 0x1d8a3(%rip), %rcx # 0x62268
xorl %edx, %edx
callq 0x51d6c
xorb $0x1, %al
movzbl %al, %ebx
movq %rsp, %rdi
callq 0x51ece
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x51ece
movq %rbx, %rdi
callq 0xab90
|
/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(%rbx), %r15
cmpq %r15, %r14
je 0x45550
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4554a
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x45537
movq 0x210(%rbx), %rdi
testq %rdi, %rdi
je 0x45562
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x248(%rbx), %rdi
callq 0x51fd0
movq 0x240(%rbx), %rdi
testq %rdi, %rdi
je 0x45580
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x240(%rbx)
leaq 0x238(%rbx), %rdi
callq 0x52082
movq 0x1f8(%rbx), %rdi
testq %rdi, %rdi
je 0x455a9
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x178(%rbx), %r14
leaq 0x1c8(%rbx), %rdi
callq 0x51098
leaq 0x1b0(%rbx), %rdi
callq 0x510c0
movq %r14, %rdi
callq 0x3144e
leaq 0x130(%rbx), %rdi
callq 0x540c8
leaq 0x100(%rbx), %rdi
callq 0x540dc
leaq 0xe8(%rbx), %rdi
callq 0x520b0
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x45605
callq 0xa570
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x45616
callq 0xa570
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x45627
callq 0xa570
leaq 0x90(%rbx), %rdi
callq 0x520f6
leaq 0x58(%rbx), %rdi
callq 0x3144e
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x45653
popq %rbx
popq %r14
popq %r15
jmp 0xa570
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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.
listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
#endif // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
#if GTEST_HAS_DEATH_TEST
InitDeathTestSubprocessControlInfo();
SuppressTestEventsIfInSubprocess();
#endif // GTEST_HAS_DEATH_TEST
// Registers parameterized tests. This makes parameterized tests
// available to the UnitTest reflection API without running
// RUN_ALL_TESTS.
RegisterParameterizedTests();
// Configures listeners for XML output. This makes it possible for users
// to shut down the default XML output before invoking RUN_ALL_TESTS.
ConfigureXmlOutput();
if (GTEST_FLAG(brief)) {
listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter);
}
#if GTEST_CAN_STREAM_RESULTS_
// Configures listeners for streaming test results to the specified server.
ConfigureStreamingOutput();
#endif // GTEST_CAN_STREAM_RESULTS_
#if GTEST_HAS_ABSL
if (GTEST_FLAG(install_failure_signal_handler)) {
absl::FailureSignalHandlerOptions options;
absl::InstallFailureSignalHandler(options);
}
#endif // GTEST_HAS_ABSL
}
}
|
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
callq 0x45682
cmpb $0x1, 0x3bfa3(%rip) # 0x819f0
jne 0x45a75
leaq 0x1f8(%rbx), %r14
movl $0x8, %edi
callq 0xa5c0
leaq 0x3acc9(%rip), %rcx # 0x80730
movq %rcx, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x4462a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x45848
|
/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_runnable_tests are the number of tests that will
// run across all shards (i.e., match filter and are not disabled).
// num_selected_tests are the number of tests to be run on
// this shard.
int num_runnable_tests = 0;
int num_selected_tests = 0;
for (auto* test_suite : test_suites_) {
const std::string& test_suite_name = test_suite->name();
test_suite->set_should_run(false);
for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
TestInfo* const test_info = test_suite->test_info_list()[j];
const std::string test_name(test_info->name());
// A test is disabled if test suite name or test name matches
// kDisableTestFilter.
const bool is_disabled = internal::UnitTestOptions::MatchesFilter(
test_suite_name, kDisableTestFilter) ||
internal::UnitTestOptions::MatchesFilter(
test_name, kDisableTestFilter);
test_info->is_disabled_ = is_disabled;
const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest(
test_suite_name, test_name);
test_info->matches_filter_ = matches_filter;
const bool is_runnable =
(GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
matches_filter;
const bool is_in_another_shard =
shard_tests != IGNORE_SHARDING_PROTOCOL &&
!ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
test_info->is_in_another_shard_ = is_in_another_shard;
const bool is_selected = is_runnable && !is_in_another_shard;
num_runnable_tests += is_runnable;
num_selected_tests += is_selected;
test_info->should_run_ = is_selected;
test_suite->set_should_run(test_suite->should_run() || is_selected);
}
}
return num_selected_tests;
}
|
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 = 0xFFFFFFFF
callq 0x3cc31
movl %eax, 0x14(%rsp)
leaq 0x1a8f1(%rip), %rdi # 0x60640
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x3cc31
movl %eax, 0x10(%rsp)
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
movq %rcx, 0x20(%rsp)
cmpq %rcx, %rax
je 0x45ed4
xorl %r15d, %r15d
leaq 0x58(%rsp), %r14
xorl %r13d, %r13d
movq %rax, 0x28(%rsp)
movq (%rax), %rbx
movq 0x8(%rbx), %rsi
movq %r14, %rdi
leaq 0x38(%rsp), %rdx
callq 0xa210
movb $0x0, 0x70(%rbx)
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x45eaa
xorl %ebp, %ebp
movq %rbx, 0x30(%rsp)
movq (%rax,%rbp,8), %r12
movq 0x20(%r12), %rsi
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa210
movq %r14, %rdi
leaq 0x1a8c8(%rip), %rsi # 0x606a0
callq 0x35864
movb $0x1, %bl
testb %al, %al
jne 0x45df6
leaq 0x38(%rsp), %rdi
leaq 0x1a8b1(%rip), %rsi # 0x606a0
callq 0x35864
movl %eax, %ebx
movb %bl, 0x81(%r12)
movq %r14, %rdi
leaq 0x38(%rsp), %rsi
callq 0x358b0
movl %eax, %r14d
movl %r13d, 0x1c(%rsp)
movb %al, 0x82(%r12)
xorb $0x1, %bl
orb 0x3bb5f(%rip), %bl # 0x81983
cmpl $0x1, 0x18(%rsp)
jne 0x45e30
xorl %r13d, %r13d
jmp 0x45e40
movl %r15d, %eax
cltd
idivl 0x14(%rsp)
cmpl 0x10(%rsp), %edx
setne %r13b
andb %bl, %r14b
movb %r13b, 0x83(%r12)
xorb $0x1, %r13b
andb %r14b, %r13b
movb %r13b, 0x80(%r12)
movq 0x30(%rsp), %rbx
orb %r13b, 0x70(%rbx)
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x45e77
callq 0xa570
movzbl %r14b, %eax
addl %eax, %r15d
movzbl %r13b, %eax
movl 0x1c(%rsp), %r13d
addl %eax, %r13d
incq %rbp
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %rbp
leaq 0x58(%rsp), %r14
jb 0x45db6
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x45ebe
callq 0xa570
movq 0x28(%rsp), %rax
addq $0x8, %rax
cmpq 0x20(%rsp), %rax
jne 0x45d84
jmp 0x45ed7
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x45f05
movq %rax, %rbx
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x45f05
callq 0xa570
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x45f19
callq 0xa570
movq %rbx, %rdi
callq 0xab90
nop
|
/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 character was encountered.
Message msg;
msg << "WARNING: " << src_text
<< " is expected to be a 32-bit integer, but actually"
<< " has value \"" << str << "\".\n";
printf("%s", msg.GetString().c_str());
fflush(stdout);
return false;
}
// Is the parsed value in the range of an int32_t?
const auto result = static_cast<int32_t>(long_value);
if (long_value == LONG_MAX || long_value == LONG_MIN ||
// The parsed value overflows as a long. (strtol() returns
// LONG_MAX or LONG_MIN when the input overflows.)
result != long_value
// The parsed value overflows as an int32_t.
) {
Message msg;
msg << "WARNING: " << src_text
<< " is expected to be a 32-bit integer, but actually"
<< " has value " << str << ", which overflows.\n";
printf("%s", msg.GetString().c_str());
fflush(stdout);
return false;
}
*value = result;
return true;
}
|
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), %r14
leaq 0x10(%r14), %r15
leaq 0x1c53a(%rip), %rsi # 0x62a2f
movl $0x9, %edx
movq %r15, %rdi
callq 0xa6b0
movq (%r12), %rsi
leaq 0x8(%rsp), %rdi
callq 0x36b3d
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0xa6b0
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x46536
callq 0xa570
leaq 0x1c4fc(%rip), %rsi # 0x62a39
movl $0x31, %edx
movq %r15, %rdi
callq 0xa6b0
leaq 0x1c51a(%rip), %rsi # 0x62a6b
movl $0xc, %edx
movq %r15, %rdi
callq 0xa6b0
testq %rbx, %rbx
je 0x46582
movq %rbx, %rdi
callq 0xa240
movq %rax, %rdx
jmp 0x4658e
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x465bf
movl %eax, (%r14)
movb $0x1, %al
jmp 0x466ce
movl $0x6, %edx
leaq 0x12f7e(%rip), %rbx # 0x5950c
movq %r15, %rdi
movq %rbx, %rsi
callq 0xa6b0
leaq 0x1c4d8(%rip), %rsi # 0x62a78
movl $0x3, %edx
movq %r15, %rdi
callq 0xa6b0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x36b3d
jmp 0x4668d
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x36908
movq (%r14), %r14
leaq 0x10(%r14), %r15
leaq 0x1c455(%rip), %rsi # 0x62a2f
movl $0x9, %edx
movq %r15, %rdi
callq 0xa6b0
movq (%r12), %rsi
leaq 0x8(%rsp), %rdi
callq 0x36b3d
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0xa6b0
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x4661b
callq 0xa570
leaq 0x1c417(%rip), %rsi # 0x62a39
movl $0x31, %edx
movq %r15, %rdi
callq 0xa6b0
leaq 0x1c446(%rip), %rsi # 0x62a7c
movl $0xb, %edx
movq %r15, %rdi
callq 0xa6b0
testq %rbx, %rbx
je 0x46655
movq %rbx, %rdi
callq 0xa240
movq %rax, %rdx
jmp 0x46661
movl $0x6, %edx
leaq 0x12eab(%rip), %rbx # 0x5950c
movq %r15, %rdi
movq %rbx, %rsi
callq 0xa6b0
leaq 0x1c415(%rip), %rsi # 0x62a88
movl $0x13, %edx
movq %r15, %rdi
callq 0xa6b0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x36b3d
movq 0x8(%rsp), %rsi
leaq 0x1be67(%rip), %rdi # 0x62500
xorl %eax, %eax
callq 0xa080
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x466af
callq 0xa570
movq 0x3a8c2(%rip), %rax # 0x80f78
movq (%rax), %rdi
callq 0xa700
testq %r14, %r14
je 0x466cc
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x466fa
jmp 0x466e0
jmp 0x466fa
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x466fd
callq 0xa570
jmp 0x466fd
jmp 0x466fa
movq %rax, %rbx
testq %r14, %r14
je 0x4670b
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xab90
|
/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 ParseInt32(Message() << "The value of flag --" << flag,
value_str, value);
}
|
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 # 0x60419
movl $0x14, %edx
movq %r13, %rdi
callq 0xa6b0
testq %r12, %r12
je 0x46880
movq %r12, %rdi
callq 0xa240
movq %rax, %rdx
jmp 0x4688c
movl $0x6, %edx
leaq 0x12c80(%rip), %r12 # 0x5950c
movq %r13, %rdi
movq %r12, %rsi
callq 0xa6b0
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4649e
movl %eax, %ebp
testq %rbx, %rbx
je 0x468b5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
testq %rbx, %rbx
je 0x468d7
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0xab90
|
/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) {
*_NSGetArgc() = *argc;
}
#endif
#endif
}
|
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\\";
else if (temp_dir[strlen(temp_dir) - 1] == '\\')
return temp_dir;
else
return std::string(temp_dir) + "\\";
#elif GTEST_OS_LINUX_ANDROID
const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
if (temp_dir == nullptr || temp_dir[0] == '\0')
return "/data/local/tmp/";
else
return temp_dir;
#else
return "/tmp/";
#endif // GTEST_OS_WINDOWS_MOBILE
}
|
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_FLAG(internal_run_death_test).empty();
else
return g_in_fast_death_test_child;
#endif
}
|
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 0x1b8eb(%rip), %rdx # 0x62551
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x105c0
movq %rbx, %rdi
callq 0x46c95
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x46c8d
callq 0xa570
movq %rbx, %rdi
callq 0xab90
|
/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 =
GetUnitTestImpl()->internal_run_death_test_flag();
if (flag != nullptr) {
FILE* parent = posix::FDOpen(flag->write_fd(), "w");
fputc(kDeathTestInternalError, parent);
fprintf(parent, "%s", message.c_str());
fflush(parent);
_exit(1);
} else {
fprintf(stderr, "%s", message.c_str());
fflush(stderr);
posix::Abort();
}
}
|
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 0x18ccf(%rip), %rsi # 0x5f9ac
callq 0x55852
movq %rax, %r14
movl $0x49, %edi
movq %rax, %rsi
callq 0xa7b0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xa690
movq %r14, %rdi
callq 0xa700
movl $0x1, %edi
callq 0xaab0
nop
|
/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 exited.
do {
bytes_read = posix::Read(read_fd(), &flag, 1);
} while (bytes_read == -1 && errno == EINTR);
if (bytes_read == 0) {
set_outcome(DIED);
} else if (bytes_read == 1) {
switch (flag) {
case kDeathTestReturned:
set_outcome(RETURNED);
break;
case kDeathTestThrew:
set_outcome(THREW);
break;
case kDeathTestLived:
set_outcome(LIVED);
break;
case kDeathTestInternalError:
FailFromInternalError(read_fd()); // Does not return.
break;
default:
GTEST_LOG_(FATAL) << "Death test child process reported "
<< "unexpected status byte ("
<< static_cast<unsigned int>(flag) << ")";
}
} else {
GTEST_LOG_(FATAL) << "Read from death test child process failed: "
<< GetLastErrnoDescription();
}
GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd()));
set_read_fd(-1);
}
|
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 0x46ed1
cmpl $0x1, %eax
jne 0x46e53
movzbl 0x7(%rsp), %r14d
cmpl $0x51, %r14d
jg 0x46f6e
cmpl $0x49, %r14d
je 0x47010
cmpl $0x4c, %r14d
jne 0x46f8a
movl $0x2, 0x30(%rbx)
jmp 0x46ed8
leaq 0x1b6f8(%rip), %rdx # 0x62552
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x1ef, %ecx # imm = 0x1EF
callq 0x4d76a
movq 0x3a173(%rip), %rdi # 0x80fe8
leaq 0x1b79a(%rip), %rsi # 0x62616
movl $0x2b, %edx
callq 0xa6b0
leaq 0xf0(%rsp), %rdi
callq 0x46be5
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq 0x3a13e(%rip), %rdi # 0x80fe8
callq 0xa6b0
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46ec5
callq 0xa570
leaq 0x8(%rsp), %rdi
callq 0x4d89c
jmp 0x46ed8
movl $0x1, 0x30(%rbx)
movl 0x34(%rbx), %edi
callq 0xacb0
cmpl $-0x1, %eax
jne 0x46f55
callq 0xa070
cmpl $0x4, (%rax)
je 0x46ed8
leaq 0xe0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b740(%rip), %rsi # 0x62642
leaq 0x1b74c(%rip), %rdx # 0x62655
leaq 0xd0(%rsp), %rdi
callq 0x105c0
leaq 0x1b635(%rip), %rsi # 0x62552
leaq 0xd0(%rsp), %rdi
callq 0xac80
leaq 0xc0(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x47195
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x471a8
movl $0xffffffff, 0x34(%rbx) # imm = 0xFFFFFFFF
addq $0x1f8, %rsp # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x54, %r14d
je 0x4707f
cmpl $0x52, %r14d
jne 0x46f8a
movl $0x3, 0x30(%rbx)
jmp 0x46ed8
leaq 0x1b5c1(%rip), %rdx # 0x62552
leaq 0xf0(%rsp), %rdi
movl $0x3, %esi
movl $0x1ea, %ecx # imm = 0x1EA
callq 0x4d76a
movq 0x3a039(%rip), %rdi # 0x80fe8
leaq 0x1b624(%rip), %rsi # 0x625da
movl $0x22, %edx
callq 0xa6b0
movq 0x3a021(%rip), %rdi # 0x80fe8
leaq 0x1b62f(%rip), %rsi # 0x625fd
movl $0x18, %edx
callq 0xa6b0
movsbq %r14b, %rax
movl %eax, %esi
movq 0x3a003(%rip), %rdi # 0x80fe8
callq 0xa400
leaq 0x13bf0(%rip), %rsi # 0x5abe1
movl $0x1, %edx
movq %rax, %rdi
callq 0xa6b0
leaq 0xf0(%rsp), %rdi
callq 0x4d89c
jmp 0x46ed8
movl 0x34(%rbx), %r15d
leaq 0x90(%rsp), %r14
movq %r14, %rdi
callq 0x36908
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0xf0(%rsp), %r13
movl $0xff, %edx
movl %r15d, %edi
movq %r13, %rsi
callq 0xa910
testl %eax, %eax
jle 0x4706c
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movb $0x0, 0xf0(%rsp,%rax)
movq %r13, %rdi
callq 0xa240
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xa6b0
jmp 0x47033
cmpl $-0x1, %eax
jne 0x4708b
callq 0xa070
movl (%rax), %ebp
cmpl $0x4, %ebp
je 0x47033
jmp 0x470d9
movl $0x4, 0x30(%rbx)
jmp 0x46ed8
testl %eax, %eax
jne 0x470d2
leaq 0x1b4bc(%rip), %rdx # 0x62552
leaq 0x28(%rsp), %rdi
movl $0x3, %esi
movl $0x167, %ecx # imm = 0x167
callq 0x4d76a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x36b3d
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x39f20(%rip), %rdi # 0x80fe8
callq 0xa6b0
jmp 0x47161
callq 0xa070
movl (%rax), %ebp
leaq 0x1b472(%rip), %rdx # 0x62552
leaq 0x28(%rsp), %rdi
movl $0x3, %esi
movl $0x16a, %ecx # imm = 0x16A
callq 0x4d76a
movq 0x39eed(%rip), %rdi # 0x80fe8
leaq 0x1bfab(%rip), %rsi # 0x630ad
movl $0x29, %edx
callq 0xa6b0
leaq 0x8(%rsp), %rdi
callq 0x46be5
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x39ec1(%rip), %rdi # 0x80fe8
callq 0xa6b0
movq %rax, %r15
leaq 0x1c511(%rip), %rsi # 0x63647
movl $0x2, %edx
movq %rax, %rdi
callq 0xa6b0
movq %r15, %rdi
movl %ebp, %esi
callq 0xab30
leaq 0x1b8cb(%rip), %rsi # 0x62a1f
movl $0x1, %edx
movq %rax, %rdi
callq 0xa6b0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x47174
callq 0xa570
leaq 0x28(%rsp), %rdi
callq 0x4d89c
testq %r14, %r14
je 0x46ed8
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x46ed8
movq %rdx, 0xb0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xc0(%rsp)
movq 0x8(%rax), %rdx
leaq 0xb0(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1b488(%rip), %rsi # 0x62656
callq 0xac80
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x471f6
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x47203
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x6c(%rsp), %rsi
movl $0x1f2, (%rsi) # imm = 0x1F2
leaq 0x70(%rsp), %rdi
callq 0x51be6
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %r8
movq 0x78(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r12, %rcx
je 0x47252
movq 0x58(%rsp), %rdi
leaq 0x80(%rsp), %r13
movq -0x10(%r13), %rsi
cmpq %rdi, %rax
jbe 0x4727a
movl $0xf, %edi
cmpq %r13, %rsi
je 0x47275
movq 0x80(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x47286
leaq 0x48(%rsp), %rdi
callq 0xa190
jmp 0x47294
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x38(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x472b1
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x472be
movq %rsi, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x134d3(%rip), %rsi # 0x5a7b5
leaq 0x28(%rsp), %rdi
callq 0xac80
leaq 0xa0(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x47310
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
jmp 0x47323
movq %rdx, 0x90(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xa0(%rsp)
movq 0x8(%rax), %rdx
leaq 0x90(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1b315(%rip), %rsi # 0x6265e
callq 0xac80
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x47373
movups (%rcx), %xmm0
leaq 0x18(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x47380
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1b4d0(%rip), %rsi # 0x62873
callq 0xac80
leaq 0x100(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x473d3
movups (%rcx), %xmm0
leaq 0x100(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x473e6
movq %rdx, 0xf0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x100(%rsp)
movq 0x8(%rax), %rdx
leaq 0xf0(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x46c95
jmp 0x47457
jmp 0x47415
jmp 0x4750c
jmp 0x47415
movq %rax, %rbx
jmp 0x4746d
jmp 0x4750c
movq %rax, %rbx
movq 0xf0(%rsp), %rdi
leaq 0x100(%rsp), %rax
cmpq %rax, %rdi
je 0x47441
callq 0xa570
jmp 0x47441
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4748c
callq 0xa570
jmp 0x4748c
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4746d
callq 0xa570
leaq 0x28(%rsp), %rdi
callq 0x4d89c
jmp 0x4750f
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
jmp 0x474dd
movq %rax, %rbx
movq 0x90(%rsp), %rdi
cmpq %rbp, %rdi
je 0x474a3
callq 0xa570
jmp 0x474a3
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x474e7
callq 0xa570
jmp 0x474e7
movq %rax, %rbx
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x474d8
callq 0xa570
jmp 0x474d8
jmp 0x474d5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4d89c
jmp 0x47550
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0x474fb
callq 0xa570
jmp 0x474fb
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x47522
callq 0xa570
jmp 0x47522
movq %rax, %rbx
testq %r14, %r14
je 0x47550
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x47550
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
cmpq %r15, %rdi
je 0x47539
callq 0xa570
jmp 0x47539
movq %rax, %rbx
movq 0xd0(%rsp), %rdi
cmpq %r14, %rdi
je 0x47550
callq 0xa570
jmp 0x47550
movq %rax, %rbx
movq %rbx, %rdi
callq 0xab90
|
/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();
if (flag != nullptr) {
set_write_fd(flag->write_fd());
return EXECUTE_TEST;
}
int pipe_fd[2];
GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
// Clear the close-on-exec flag on the write end of the pipe, lest
// it be closed when the child process does an exec:
GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
kFilterFlag + "=" + info->test_suite_name() +
"." + info->name();
const std::string internal_flag =
std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
+ file_ + "|" + StreamableToString(line_) + "|"
+ StreamableToString(death_test_index) + "|"
+ StreamableToString(pipe_fd[1]);
Arguments args;
args.AddArguments(GetArgvsForDeathTestChildProcess());
args.AddArgument(filter_flag.c_str());
args.AddArgument(internal_flag.c_str());
DeathTest::set_last_death_test_message("");
CaptureStderr();
// See the comment in NoExecDeathTest::AssumeRole for why the next line
// is necessary.
FlushInfoLog();
const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]);
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
set_child_pid(child_pid);
set_read_fd(pipe_fd[0]);
set_spawned(true);
return OVERSEE_TEST;
}
|
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
movl %eax, 0x38(%rbx)
movl $0x1, %eax
jmp 0x4a48a
leaq 0x10c(%rsp), %rdi
callq 0xa890
cmpl $-0x1, %eax
je 0x4a811
movl 0x110(%rsp), %edi
movl $0x2, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xa370
cmpl $-0x1, %eax
je 0x4a86b
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x16cc4(%rip), %rsi # 0x6042b
leaq 0x16cbf(%rip), %rdx # 0x6042d
leaq 0x28(%rsp), %rdi
callq 0x105c0
leaq 0x190fb(%rip), %rsi # 0x6287a
leaq 0x28(%rsp), %rdi
callq 0xac80
leaq 0x18(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x497b0
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x497b6
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x16d8e(%rip), %rsi # 0x60567
callq 0xac80
leaq 0x58(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x49805
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x4980b
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xfcbf(%rip), %rsi # 0x594ed
callq 0xac80
leaq 0x78(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4985a
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0x49860
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rsi
callq 0xac80
leaq 0x1a8(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x498b4
movq %rdx, 0x198(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x1a8(%rsp)
jmp 0x498ba
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
leaq 0x198(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1882c(%rip), %rsi # 0x6210c
callq 0xac80
leaq 0x240(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x49915
movq %rdx, 0x230(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x240(%rsp)
jmp 0x4991d
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x230(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%r14), %rsi
callq 0xac80
leaq 0x2d8(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x49975
movq %rdx, 0x2c8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x2d8(%rsp)
jmp 0x4997c
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
movq %rdx, 0x2d0(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x230(%rsp), %rdi
cmpq %r13, %rdi
je 0x499a9
callq 0xa570
movq 0x198(%rsp), %rdi
leaq 0x1a8(%rsp), %rax
cmpq %rax, %rdi
je 0x499c3
callq 0xa570
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x499d7
callq 0xa570
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x499eb
callq 0xa570
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x499ff
callq 0xa570
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x49a0e
callq 0xa570
leaq 0xf8(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x16a0a(%rip), %rsi # 0x6042b
leaq 0x16a05(%rip), %rdx # 0x6042d
leaq 0xe8(%rsp), %rdi
callq 0x105c0
leaq 0x18e3e(%rip), %rsi # 0x6287a
leaq 0xe8(%rsp), %rdi
callq 0xac80
leaq 0xd8(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x49a79
movq %rdx, 0xc8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xd8(%rsp)
jmp 0x49a7f
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
leaq 0xc8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x16c6b(%rip), %rsi # 0x60710
callq 0xac80
leaq 0xb8(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x49ada
movq %rdx, 0xa8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xb8(%rsp)
jmp 0x49ae1
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0xa8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xf9e6(%rip), %rsi # 0x594ed
callq 0xac80
leaq 0x98(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x49b3c
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
jmp 0x49b42
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x40(%rbx), %rsi
callq 0xac80
movq %r15, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x49b8d
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x49b94
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18cca(%rip), %rsi # 0x62881
callq 0xac80
leaq 0x18(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x49be4
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x49bea
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rbx), %rsi
leaq 0x118(%rsp), %rdi
callq 0x51be6
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x120(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
leaq 0x18(%rsp), %rsi
cmpq %rsi, %rcx
je 0x49c3d
movq 0x18(%rsp), %rdi
movq 0x118(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x49c69
leaq 0x128(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x49c64
movq 0x128(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x49c75
leaq 0x8(%rsp), %rdi
callq 0xa190
jmp 0x49c86
leaq 0x118(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x58(%rsp), %rsi
movq %rsi, 0x48(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0x49cab
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x49cb1
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x18bac(%rip), %rsi # 0x62881
leaq 0x48(%rsp), %rdi
callq 0xac80
leaq 0x78(%rsp), %rsi
movq %rsi, 0x68(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x49d07
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0x49d0d
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x70(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x138(%rsp), %rdi
leaq 0x114(%rsp), %rsi
callq 0x51be6
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %r8
movq 0x140(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
leaq 0x78(%rsp), %rsi
cmpq %rsi, %rcx
je 0x49d64
movq 0x78(%rsp), %rdi
movq 0x138(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x49d90
leaq 0x148(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x49d8b
movq 0x148(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x49d9c
leaq 0x68(%rsp), %rdi
callq 0xa190
jmp 0x49dad
leaq 0x138(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x1a8(%rsp), %rsi
movq %rsi, 0x198(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0x49dde
movq %rdx, 0x198(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x1a8(%rsp)
jmp 0x49de4
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x1a0(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x18a76(%rip), %rsi # 0x62881
leaq 0x198(%rsp), %rdi
callq 0xac80
leaq 0x110(%rsp), %rsi
movq %r13, 0x230(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x49e4c
movq %rdx, 0x230(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x240(%rsp)
jmp 0x49e54
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x238(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x178(%rsp), %rdi
callq 0x51be6
movq 0x230(%rsp), %rcx
movq 0x238(%rsp), %r8
movq 0x180(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r13, %rcx
je 0x49eaa
movq 0x240(%rsp), %rdi
movq 0x178(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x49ed6
leaq 0x188(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x49ed1
movq 0x188(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x49ee5
leaq 0x230(%rsp), %rdi
callq 0xa190
jmp 0x49ef6
leaq 0x178(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x168(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x49f23
movq %rsi, 0x158(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x168(%rsp)
jmp 0x49f29
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x160(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x188(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49f5f
callq 0xa570
movq 0x230(%rsp), %rdi
cmpq %r13, %rdi
je 0x49f71
callq 0xa570
movq 0x198(%rsp), %rdi
leaq 0x1a8(%rsp), %rax
cmpq %rax, %rdi
je 0x49f8b
callq 0xa570
leaq 0x148(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49fa1
callq 0xa570
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x49fb5
callq 0xa570
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x49fc9
callq 0xa570
leaq 0x128(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49fdf
callq 0xa570
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x49ff3
callq 0xa570
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x4a002
callq 0xa570
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x4a01c
callq 0xa570
movq 0xa8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4a02e
callq 0xa570
movq 0xc8(%rsp), %rdi
leaq 0xd8(%rsp), %rax
cmpq %rax, %rdi
je 0x4a048
callq 0xa570
movq 0xe8(%rsp), %rdi
leaq 0xf8(%rsp), %rax
cmpq %rax, %rdi
je 0x4a062
callq 0xa570
leaq 0x118(%rsp), %rdi
callq 0x52bb0
movq 0x37ac2(%rip), %rax # 0x81b38
testq %rax, %rax
leaq 0x379d0(%rip), %rsi # 0x81a50
cmovneq %rax, %rsi
leaq 0x230(%rsp), %rdi
callq 0x5018c
leaq 0x118(%rsp), %rdi
leaq 0x230(%rsp), %rsi
callq 0x52bf0
leaq 0x230(%rsp), %r14
movq %r14, %rdi
callq 0x10390
movq 0x2c8(%rsp), %rdi
leaq 0x118(%rsp), %r15
movq 0x8(%r15), %r12
addq $-0x8, %r12
callq 0xac00
movq %rax, (%r14)
leaq 0x230(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5587e
movq 0x158(%rsp), %rdi
leaq 0x118(%rsp), %r14
movq 0x8(%r14), %r15
addq $-0x8, %r15
callq 0xac00
leaq 0x230(%rsp), %rdx
movq %rax, (%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5587e
leaq 0x230(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x17c97(%rip), %rdx # 0x61dc5
movq %rdx, %rsi
callq 0x105c0
leaq 0x379cb(%rip), %rdi # 0x81b08
leaq 0x230(%rsp), %rsi
callq 0xa320
movq 0x230(%rsp), %rdi
cmpq %r13, %rdi
je 0x4a15c
callq 0xa570
leaq 0x188c5(%rip), %rsi # 0x62a28
leaq 0x379c6(%rip), %rdx # 0x81b30
movl $0x2, %edi
callq 0x4d907
xorl %edi, %edi
callq 0xa700
movq 0x118(%rsp), %rax
movl 0x10c(%rsp), %ecx
movq %rax, 0x138(%rsp)
movl %ecx, 0x140(%rsp)
leaq 0x198(%rsp), %r14
movl $0x98, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xa340
leaq 0x1a0(%rsp), %r15
movq %r15, %rdi
callq 0xa7c0
movq $0x1, -0x8(%r15)
leaq 0x230(%rsp), %r15
movl $0x1b, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0xa7d0
cmpl $-0x1, %eax
jne 0x4a262
callq 0xa070
cmpl $0x4, (%rax)
je 0x4a1d0
movq %rbp, %r12
leaq 0xc8(%rsp), %rdi
leaq 0xd8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x18436(%rip), %rsi # 0x62642
leaq 0x18442(%rip), %rdx # 0x62655
callq 0x105c0
leaq 0x18333(%rip), %rsi # 0x62552
leaq 0xc8(%rsp), %rdi
callq 0xac80
leaq 0xb8(%rsp), %rcx
movq %rcx, 0xa8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4a49c
movups (%rcx), %xmm0
leaq 0xb8(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4a4af
cmpb $0x0, 0x37897(%rip) # 0x81b00
je 0x4a282
movq %rbp, %r12
callq 0xa120
testl %eax, %eax
je 0x4a935
movl %eax, %ebp
jmp 0x4a321
movb 0x378d0(%rip), %al # 0x81b58
testb %al, %al
je 0x4a942
callq 0xabd0
addl %eax, %eax
movslq %eax, %r14
xorl %edi, %edi
movq %r14, %rsi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0xaba0
cmpq $-0x1, %rax
je 0x4a94c
movq %rax, %r15
movq %rbp, %r12
xorl %esi, %esi
cmpb $0x0, 0x37880(%rip) # 0x81b50
leaq -0x40(%r14), %rax
cmovneq %rax, %rsi
cmpl $0x41, %r14d
jb 0x4a9bf
addq %r15, %rsi
movl %esi, %eax
andl $0x3f, %eax
jne 0x4a9bf
leaq 0x47cc(%rip), %rdi # 0x4eac3
leaq 0x138(%rsp), %rcx
movl $0x11, %edx
xorl %eax, %eax
callq 0xac30
movl %eax, %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0xa360
cmpl $-0x1, %eax
je 0x4aa2f
leaq 0x230(%rsp), %r14
movl $0x1b, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0xa7d0
cmpl $-0x1, %eax
jne 0x4a3b7
callq 0xa070
cmpl $0x4, (%rax)
je 0x4a329
leaq 0xc8(%rsp), %rdi
leaq 0xd8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x182e1(%rip), %rsi # 0x62642
leaq 0x182ed(%rip), %rdx # 0x62655
callq 0x105c0
leaq 0x181de(%rip), %rsi # 0x62552
leaq 0xc8(%rsp), %rdi
callq 0xac80
leaq 0xb8(%rsp), %rcx
movq %rcx, 0xa8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4a510
movups (%rcx), %xmm0
leaq 0xb8(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4a523
cmpl $-0x1, %ebp
je 0x4a8c5
movl 0x110(%rsp), %edi
callq 0xacb0
cmpl $-0x1, %eax
jne 0x4a442
callq 0xa070
cmpl $0x4, (%rax)
je 0x4a3c0
leaq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
movq %rax, (%rdi)
leaq 0x1824d(%rip), %rsi # 0x62642
leaq 0x18259(%rip), %rdx # 0x62655
callq 0x105c0
leaq 0x1814a(%rip), %rsi # 0x62552
leaq 0x88(%rsp), %rdi
callq 0xac80
leaq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4a584
movups (%rcx), %xmm0
leaq 0x38(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4a591
movl %ebp, 0x3c(%rbx)
movl 0x10c(%rsp), %eax
movl %eax, 0x34(%rbx)
movb $0x1, 0x28(%rbx)
leaq 0x118(%rsp), %rdi
callq 0x52c4e
leaq 0x168(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4a476
callq 0xa570
movq 0x2c8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4a488
callq 0xa570
xorl %eax, %eax
addq $0x2e8, %rsp # imm = 0x2E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, 0xa8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xb8(%rsp)
movq 0x8(%rax), %rdx
leaq 0xa8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18181(%rip), %rsi # 0x62656
callq 0xac80
leaq 0x98(%rsp), %rcx
movq %rcx, 0x88(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4a5e6
movups (%rcx), %xmm0
leaq 0x98(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4a5f9
movq %rdx, 0xa8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xb8(%rsp)
movq 0x8(%rax), %rdx
leaq 0xa8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1810d(%rip), %rsi # 0x62656
callq 0xac80
leaq 0x98(%rsp), %rcx
movq %rcx, 0x88(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4a6a7
movups (%rcx), %xmm0
leaq 0x98(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4a6ba
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x180a2(%rip), %rsi # 0x62656
callq 0xac80
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4a768
movups (%rcx), %xmm0
leaq 0x18(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4a775
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x90(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x178(%rsp), %rsi
movl $0x54f, (%rsi) # imm = 0x54F
leaq 0xe8(%rsp), %rdi
callq 0x51be6
movq 0x88(%rsp), %rcx
movq 0x90(%rsp), %r8
movq 0xf0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
leaq 0x98(%rsp), %rsi
cmpq %rsi, %rcx
je 0x4a665
movq 0x98(%rsp), %rdi
movq 0xe8(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x4a695
movl $0xf, %edi
leaq 0xf8(%rsp), %r9
cmpq %r9, %rsi
je 0x4a68c
movq 0xf8(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4aa9f
leaq 0x88(%rsp), %rdi
callq 0xa190
jmp 0x4aab0
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x90(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x178(%rsp), %rsi
movl $0x57a, (%rsi) # imm = 0x57A
leaq 0xe8(%rsp), %rdi
callq 0x51be6
movq 0x88(%rsp), %rcx
movq 0x90(%rsp), %r8
movq 0xf0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
leaq 0x98(%rsp), %rsi
cmpq %rsi, %rcx
je 0x4a726
movq 0x98(%rsp), %rdi
movq 0xe8(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x4a756
movl $0xf, %edi
leaq 0xf8(%rsp), %r9
cmpq %r9, %rsi
je 0x4a74d
movq 0xf8(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4ab3b
leaq 0x88(%rsp), %rdi
callq 0xa190
jmp 0x4ab4c
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xc8(%rsp), %rsi
movl $0x5ac, (%rsi) # imm = 0x5AC
leaq 0xa8(%rsp), %rdi
callq 0x51be6
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0xb0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
leaq 0x18(%rsp), %rsi
cmpq %rsi, %rcx
je 0x4a7d2
movq 0x18(%rsp), %rdi
movq 0xa8(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x4a802
movl $0xf, %edi
leaq 0xb8(%rsp), %r9
cmpq %r9, %rsi
je 0x4a7f9
movq 0xb8(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4abd7
leaq 0x8(%rsp), %rdi
callq 0xa190
jmp 0x4abe8
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x17e21(%rip), %rsi # 0x62642
leaq 0x17e2d(%rip), %rdx # 0x62655
leaq 0x28(%rsp), %rdi
callq 0x105c0
leaq 0x17d19(%rip), %rsi # 0x62552
leaq 0x28(%rsp), %rdi
callq 0xac80
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4ada2
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x4adaf
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x17dc7(%rip), %rsi # 0x62642
leaq 0x17dd3(%rip), %rdx # 0x62655
leaq 0x28(%rsp), %rdi
callq 0x105c0
leaq 0x17cbf(%rip), %rsi # 0x62552
leaq 0x28(%rsp), %rdi
callq 0xac80
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4ae01
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x4ae0e
leaq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x17d63(%rip), %rsi # 0x62642
leaq 0x17d6f(%rip), %rdx # 0x62655
callq 0x105c0
leaq 0x17c60(%rip), %rsi # 0x62552
leaq 0xa8(%rsp), %rdi
callq 0xac80
leaq 0x98(%rsp), %rcx
movq %rcx, 0x88(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4ae60
movups (%rcx), %xmm0
leaq 0x98(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4ae73
leaq 0x138(%rsp), %rdi
callq 0x4eac3
callq 0xb598
jmp 0x4a290
movq %rbp, %r12
leaq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x17cd9(%rip), %rsi # 0x62642
leaq 0x17ce5(%rip), %rdx # 0x62655
callq 0x105c0
leaq 0x17bd6(%rip), %rsi # 0x62552
leaq 0xa8(%rsp), %rdi
callq 0xac80
leaq 0x98(%rsp), %rcx
movq %rcx, 0x88(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4b13d
movups (%rcx), %xmm0
leaq 0x98(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4b150
leaq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x17c69(%rip), %rsi # 0x62642
leaq 0x17c75(%rip), %rdx # 0x62655
callq 0x105c0
leaq 0x17b66(%rip), %rsi # 0x62552
leaq 0xa8(%rsp), %rdi
callq 0xac80
leaq 0x98(%rsp), %rcx
movq %rcx, 0x88(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4b1a8
movups (%rcx), %xmm0
leaq 0x98(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4b1bb
leaq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x17bf9(%rip), %rsi # 0x62642
leaq 0x17c05(%rip), %rdx # 0x62655
callq 0x105c0
leaq 0x17af6(%rip), %rsi # 0x62552
leaq 0xa8(%rsp), %rdi
callq 0xac80
leaq 0x98(%rsp), %rcx
movq %rcx, 0x88(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4b213
movups (%rcx), %xmm0
leaq 0x98(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4b226
leaq 0xe8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
jne 0x4aad3
movups (%rcx), %xmm0
leaq 0x38(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4aae0
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xfcb1(%rip), %rsi # 0x5a7b5
leaq 0x28(%rsp), %rdi
callq 0xac80
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4ac73
movups (%rcx), %xmm0
leaq 0x18(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4ac80
leaq 0xe8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
jne 0x4ab6f
movups (%rcx), %xmm0
leaq 0x38(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4ab7c
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xfc15(%rip), %rsi # 0x5a7b5
leaq 0x28(%rsp), %rdi
callq 0xac80
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4acd5
movups (%rcx), %xmm0
leaq 0x18(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4ace2
leaq 0xa8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x58(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
jne 0x4ac0b
movups (%rcx), %xmm0
leaq 0x58(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4ac18
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xfb79(%rip), %rsi # 0x5a7b5
leaq 0x48(%rsp), %rdi
callq 0xac80
leaq 0x78(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4ad37
movups (%rcx), %xmm0
leaq 0x78(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4ad44
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x185f3(%rip), %rsi # 0x63296
callq 0xac80
leaq 0x58(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4aecb
movups (%rcx), %xmm0
leaq 0x58(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4aed8
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18681(%rip), %rsi # 0x63386
callq 0xac80
leaq 0x58(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4af2d
movups (%rcx), %xmm0
leaq 0x58(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4af3a
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x17add(%rip), %rsi # 0x62844
callq 0xac80
leaq 0x1a8(%rsp), %rcx
movq %rcx, 0x198(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4af8f
movups (%rcx), %xmm0
leaq 0x1a8(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4afa2
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x17884(%rip), %rsi # 0x62656
callq 0xac80
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4aff5
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x4b002
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x17825(%rip), %rsi # 0x62656
callq 0xac80
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4b099
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x4b0a6
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x177bd(%rip), %rsi # 0x62656
callq 0xac80
leaq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4b27e
movups (%rcx), %xmm0
leaq 0x38(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4b28b
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x17978(%rip), %rsi # 0x62873
callq 0xac80
leaq 0x78(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4b327
movups (%rcx), %xmm0
leaq 0x78(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4b334
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x17916(%rip), %rsi # 0x62873
callq 0xac80
leaq 0x78(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4b355
movups (%rcx), %xmm0
leaq 0x78(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4b362
movq %rdx, 0x198(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x1a8(%rsp)
movq 0x8(%rax), %rdx
leaq 0x198(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x178ab(%rip), %rsi # 0x62873
callq 0xac80
movq %r13, 0x230(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4b383
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x4b396
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xa8(%rsp), %rsi
movl $0x592, (%rsi) # imm = 0x592
leaq 0x88(%rsp), %rdi
callq 0x51be6
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %r8
movq 0x90(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r12, %rcx
je 0x4b05a
movq 0x58(%rsp), %rdi
movq 0x88(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x4b08a
leaq 0x98(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x4b081
movq 0x98(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4b5b5
leaq 0x48(%rsp), %rdi
callq 0xa190
jmp 0x4b5c6
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xa8(%rsp), %rsi
movl $0x595, (%rsi) # imm = 0x595
leaq 0x88(%rsp), %rdi
callq 0x51be6
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %r8
movq 0x90(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r12, %rcx
je 0x4b0fe
movq 0x58(%rsp), %rdi
movq 0x88(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x4b12e
leaq 0x98(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x4b125
movq 0x98(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4b64a
leaq 0x48(%rsp), %rdi
callq 0xa190
jmp 0x4b65b
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x174e0(%rip), %rsi # 0x62656
callq 0xac80
leaq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4b3ba
movups (%rcx), %xmm0
leaq 0x38(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4b3c7
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x17475(%rip), %rsi # 0x62656
callq 0xac80
leaq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4b463
movups (%rcx), %xmm0
leaq 0x38(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4b470
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1740a(%rip), %rsi # 0x62656
callq 0xac80
leaq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4b50c
movups (%rcx), %xmm0
leaq 0x38(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4b519
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xe8(%rsp), %rsi
movl $0x57d, (%rsi) # imm = 0x57D
leaq 0xc8(%rsp), %rdi
callq 0x51be6
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0xd0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
leaq 0x38(%rsp), %rsi
cmpq %rsi, %rcx
je 0x4b2e8
movq 0x38(%rsp), %rdi
movq 0xc8(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x4b318
movl $0xf, %edi
leaq 0xd8(%rsp), %r9
cmpq %r9, %rsi
je 0x4b30f
movq 0xd8(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4b6df
leaq 0x28(%rsp), %rdi
callq 0xa190
jmp 0x4b6f0
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x46c95
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x46c95
movq %rdx, 0x230(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x240(%rsp)
movq 0x8(%rax), %rdx
leaq 0x230(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x46c95
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xe8(%rsp), %rsi
movl $0x55b, (%rsi) # imm = 0x55B
leaq 0xc8(%rsp), %rdi
callq 0x51be6
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0xd0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
leaq 0x38(%rsp), %rsi
cmpq %rsi, %rcx
je 0x4b424
movq 0x38(%rsp), %rdi
movq 0xc8(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x4b454
movl $0xf, %edi
leaq 0xd8(%rsp), %r9
cmpq %r9, %rsi
je 0x4b44b
movq 0xd8(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4b84d
leaq 0x28(%rsp), %rdi
callq 0xa190
jmp 0x4b85e
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xe8(%rsp), %rsi
movl $0x569, (%rsi) # imm = 0x569
leaq 0xc8(%rsp), %rdi
callq 0x51be6
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0xd0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
leaq 0x38(%rsp), %rsi
cmpq %rsi, %rcx
je 0x4b4cd
movq 0x38(%rsp), %rdi
movq 0xc8(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x4b4fd
movl $0xf, %edi
leaq 0xd8(%rsp), %r9
cmpq %r9, %rsi
je 0x4b4f4
movq 0xd8(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4b8e9
leaq 0x28(%rsp), %rdi
callq 0xa190
jmp 0x4b8fa
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xe8(%rsp), %rsi
movl $0x56d, (%rsi) # imm = 0x56D
leaq 0xc8(%rsp), %rdi
callq 0x51be6
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0xd0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
leaq 0x38(%rsp), %rsi
cmpq %rsi, %rcx
je 0x4b576
movq 0x38(%rsp), %rdi
movq 0xc8(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x4b5a6
movl $0xf, %edi
leaq 0xd8(%rsp), %r9
cmpq %r9, %rsi
je 0x4b59d
movq 0xd8(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4b985
leaq 0x28(%rsp), %rdi
callq 0xa190
jmp 0x4b996
leaq 0x88(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x78(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x4b5e3
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x4b5f0
movq %rsi, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x70(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xf1a1(%rip), %rsi # 0x5a7b5
leaq 0x68(%rsp), %rdi
callq 0xac80
leaq 0x1a8(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4b77b
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x4b78e
leaq 0x88(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x78(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x4b678
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x4b685
movq %rsi, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x70(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xf10c(%rip), %rsi # 0x5a7b5
leaq 0x68(%rsp), %rdi
callq 0xac80
leaq 0x1a8(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4b7e4
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x4b7f7
leaq 0xc8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
jne 0x4b713
movups (%rcx), %xmm0
leaq 0x18(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4b720
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xf071(%rip), %rsi # 0x5a7b5
leaq 0x8(%rsp), %rdi
callq 0xac80
leaq 0x58(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4ba21
movups (%rcx), %xmm0
leaq 0x58(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4ba2e
movq %rdx, 0x198(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x1a8(%rsp)
movq 0x8(%rax), %rdx
leaq 0x198(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1705a(%rip), %rsi # 0x6280e
callq 0xac80
leaq 0x240(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4ba83
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
jmp 0x4ba96
movq %rdx, 0x198(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x1a8(%rsp)
movq 0x8(%rax), %rdx
leaq 0x198(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x17039(%rip), %rsi # 0x62856
callq 0xac80
leaq 0x240(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4baba
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
jmp 0x4bacd
leaq 0xc8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
jne 0x4b881
movups (%rcx), %xmm0
leaq 0x18(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4b88e
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xef03(%rip), %rsi # 0x5a7b5
leaq 0x8(%rsp), %rdi
callq 0xac80
leaq 0x58(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4baf1
movups (%rcx), %xmm0
leaq 0x58(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4bafe
leaq 0xc8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
jne 0x4b91d
movups (%rcx), %xmm0
leaq 0x18(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4b92a
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xee67(%rip), %rsi # 0x5a7b5
leaq 0x8(%rsp), %rdi
callq 0xac80
leaq 0x58(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4bb53
movups (%rcx), %xmm0
leaq 0x58(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4bb60
leaq 0xc8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
jne 0x4b9b9
movups (%rcx), %xmm0
leaq 0x18(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4b9c6
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xedcb(%rip), %rsi # 0x5a7b5
leaq 0x8(%rsp), %rdi
callq 0xac80
leaq 0x58(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4bbb5
movups (%rcx), %xmm0
leaq 0x58(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4bbc2
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x16dd1(%rip), %rsi # 0x62822
callq 0xac80
leaq 0x78(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4bc17
movups (%rcx), %xmm0
leaq 0x78(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4bc24
movq %rdx, 0x230(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x240(%rsp)
movq 0x8(%rax), %rdx
leaq 0x230(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x46c95
movq %rdx, 0x230(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x240(%rsp)
movq 0x8(%rax), %rdx
leaq 0x230(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x46c95
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x177b8(%rip), %rsi # 0x632d9
callq 0xac80
leaq 0x78(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4bc45
movups (%rcx), %xmm0
leaq 0x78(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4bc52
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1776a(%rip), %rsi # 0x632ed
callq 0xac80
leaq 0x78(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4bc73
movups (%rcx), %xmm0
leaq 0x78(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4bc80
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x17781(%rip), %rsi # 0x63366
callq 0xac80
leaq 0x78(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4bca1
movups (%rcx), %xmm0
leaq 0x78(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x4bcae
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x46c95
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x46c95
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x46c95
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x46c95
jmp 0x4bcdb
jmp 0x4bcf4
jmp 0x4bcdb
jmp 0x4bcf4
jmp 0x4bcdb
jmp 0x4bcf4
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x4bcf7
callq 0xa570
jmp 0x4bcf7
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x4bd48
callq 0xa570
jmp 0x4bd48
jmp 0x4bd45
jmp 0x4bd45
jmp 0x4bd45
jmp 0x4bd17
jmp 0x4bd2e
movq %rax, %rbx
movq 0x230(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4bd31
callq 0xa570
jmp 0x4bd31
movq %rax, %rbx
movq 0x198(%rsp), %rdi
cmpq %r13, %rdi
je 0x4bd69
callq 0xa570
jmp 0x4bd69
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4bd81
callq 0xa570
jmp 0x4bd81
jmp 0x4bd7e
jmp 0x4bd7e
jmp 0x4bd7e
jmp 0x4bd66
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4bda8
callq 0xa570
jmp 0x4bda8
movq %rax, %rbx
movq 0xc8(%rsp), %rdi
leaq 0xd8(%rsp), %rax
cmpq %rax, %rdi
je 0x4bdc3
callq 0xa570
jmp 0x4bdc3
jmp 0x4bdc0
jmp 0x4bdc0
jmp 0x4bdc0
jmp 0x4bda5
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4bdf4
callq 0xa570
jmp 0x4bdf4
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4be7b
callq 0xa570
jmp 0x4be7b
jmp 0x4be78
jmp 0x4be78
jmp 0x4be78
jmp 0x4bdf1
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x4bea2
callq 0xa570
jmp 0x4bea2
movq %rax, %rbx
movq 0x230(%rsp), %rdi
cmpq %r13, %rdi
je 0x4be26
callq 0xa570
jmp 0x4be26
movq %rax, %rbx
movq 0x198(%rsp), %rdi
leaq 0x1a8(%rsp), %rax
cmpq %rax, %rdi
je 0x4beb6
callq 0xa570
jmp 0x4beb6
jmp 0x4be46
jmp 0x4be5f
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x4be62
callq 0xa570
jmp 0x4be62
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x4bed1
callq 0xa570
jmp 0x4bed1
movq %rax, %rbx
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x4beea
callq 0xa570
jmp 0x4beea
jmp 0x4bee7
jmp 0x4bee7
jmp 0x4bee7
jmp 0x4be9f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4bf13
callq 0xa570
jmp 0x4bf13
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x4bf29
callq 0xa570
jmp 0x4bf29
jmp 0x4bece
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4bf44
callq 0xa570
jmp 0x4bf44
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
jmp 0x4c2cc
jmp 0x4c2de
jmp 0x4c2de
jmp 0x4c2de
jmp 0x4bf10
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
jne 0x4c311
jmp 0x4c316
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x4bf71
callq 0xa570
jmp 0x4bf71
jmp 0x4bf41
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4bf99
callq 0xa570
jmp 0x4bf99
jmp 0x4c2de
jmp 0x4c2de
jmp 0x4c221
jmp 0x4c221
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x4c22c
callq 0xa570
jmp 0x4c22c
jmp 0x4bf96
movq %rax, %rbx
movq 0xe8(%rsp), %rdi
leaq 0xf8(%rsp), %rax
cmpq %rax, %rdi
je 0x4c247
callq 0xa570
jmp 0x4c247
movq %rbp, %r12
movq %rax, %rbx
movq 0x230(%rsp), %rdi
cmpq %r13, %rdi
jne 0x4c2d1
jmp 0x4c2e1
jmp 0x4c263
movq %rbp, %r12
movq %rax, %rbx
leaq 0x230(%rsp), %rdi
callq 0x10390
jmp 0x4c2e1
jmp 0x4c263
movq %rbp, %r12
movq %rax, %rbx
jmp 0x4c2ee
movq %rbp, %r12
movq %rax, %rbx
leaq 0x188(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c029
callq 0xa570
jmp 0x4c029
movq %rbp, %r12
movq %rax, %rbx
movq 0x230(%rsp), %rdi
cmpq %r13, %rdi
je 0x4c043
callq 0xa570
jmp 0x4c043
movq %rbp, %r12
movq %rax, %rbx
movq 0x198(%rsp), %rdi
leaq 0x1a8(%rsp), %rax
cmpq %rax, %rdi
je 0x4c065
callq 0xa570
jmp 0x4c065
movq %rbp, %r12
movq %rax, %rbx
leaq 0x148(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c083
callq 0xa570
jmp 0x4c083
movq %rbp, %r12
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x4c09f
callq 0xa570
jmp 0x4c09f
movq %rbp, %r12
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x4c0bb
callq 0xa570
jmp 0x4c0bb
movq %rbp, %r12
movq %rax, %rbx
leaq 0x128(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c0d9
callq 0xa570
jmp 0x4c0d9
movq %rbp, %r12
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4c0f5
callq 0xa570
jmp 0x4c0f5
movq %rbp, %r12
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x4c104
callq 0xa570
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x4c11e
callq 0xa570
movq 0xa8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4c130
callq 0xa570
movq 0xc8(%rsp), %rdi
leaq 0xd8(%rsp), %rax
cmpq %rax, %rdi
je 0x4c14a
callq 0xa570
movq 0xe8(%rsp), %rdi
leaq 0xf8(%rsp), %rax
jmp 0x4c2fa
movq %rbp, %r12
movq %rax, %rbx
jmp 0x4c104
movq %rbp, %r12
movq %rax, %rbx
jmp 0x4c11e
movq %rbp, %r12
movq %rax, %rbx
jmp 0x4c130
movq %rbp, %r12
movq %rax, %rbx
jmp 0x4c14a
movq %rbp, %r12
movq %rax, %rbx
jmp 0x4c304
movq %rax, %rbx
movq 0x230(%rsp), %rdi
cmpq %r13, %rdi
je 0x4c1a4
callq 0xa570
jmp 0x4c1a4
movq %rax, %rbx
movq 0x198(%rsp), %rdi
leaq 0x1a8(%rsp), %rax
cmpq %rax, %rdi
je 0x4c1c3
callq 0xa570
jmp 0x4c1c3
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x4c1dc
callq 0xa570
jmp 0x4c1dc
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x4c1f5
callq 0xa570
jmp 0x4c1f5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4c20e
callq 0xa570
jmp 0x4c20e
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
jne 0x4c311
jmp 0x4c316
movq %rax, %rbx
jmp 0x4c316
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4c26b
callq 0xa570
jmp 0x4c26b
jmp 0x4c244
movq %rax, %rbx
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x4c286
callq 0xa570
jmp 0x4c286
movq %rbp, %r12
jmp 0x4c2de
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4c2a5
callq 0xa570
jmp 0x4c2a5
jmp 0x4c283
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x4c2bc
callq 0xa570
jmp 0x4c2bc
movq %rax, %rbx
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
jmp 0x4c2cc
jmp 0x4c2b9
movq %rax, %rbx
movq 0xc8(%rsp), %rdi
leaq 0xd8(%rsp), %rax
cmpq %rax, %rdi
je 0x4c2e1
callq 0xa570
jmp 0x4c2e1
jmp 0x4c2de
jmp 0x4c2de
jmp 0x4c2de
movq %rax, %rbx
leaq 0x118(%rsp), %rdi
callq 0x52c4e
leaq 0x168(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c304
callq 0xa570
movq 0x2c8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4c316
callq 0xa570
movq %rbx, %rdi
callq 0xab90
|
/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(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x105c0
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0xa780
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x4cd39
callq 0xa570
jmp 0x4cd39
leaq 0x13a08(%rip), %rcx # 0x6072d
leaq 0x8(%rsp), %rdi
movl $0x2, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0xaa10
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x50210
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4cd55
callq 0xa570
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4cd66
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4cd78
callq 0xa570
movq %rbx, %rdi
callq 0xab90
|
/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(pathname_.c_str(), &file_stat) == 0;
#endif // GTEST_OS_WINDOWS_MOBILE
}
|
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;
if (!IsPathSeparator(*src)) {
src++;
} else {
#if GTEST_HAS_ALT_PATH_SEP_
if (*dest_ptr == kAlternatePathSeparator) {
*dest_ptr = kPathSeparator;
}
#endif
while (IsPathSeparator(*src))
src++;
}
dest_ptr++;
}
*dest_ptr = '\0';
pathname_ = dest;
delete[] dest;
}
|
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 0x4d007
movq %r15, %rax
movb %cl, (%rax)
cmpb $0x2f, (%r13)
jne 0x4cff9
movb 0x1(%r13), %cl
incq %r13
cmpb $0x2f, %cl
je 0x4cfeb
jmp 0x4d000
movb 0x1(%r13), %cl
incq %r13
incq %rax
testb %cl, %cl
jne 0x4cfe2
movb $0x0, (%rax)
movq %r15, %rdi
callq 0xa240
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0xaa10
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xa810
leaq 0x14d88(%rip), %rcx # 0x61dc5
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
xorl %r8d, %r8d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xaa10
|
/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, %rdx
leaq 0x40(%rsp), %rdi
callq 0xfb0e
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x52df4
movups 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rsp)
movq 0x10(%rbx), %rdi
movups %xmm0, 0x8(%rbx)
testq %rdi, %rdi
je 0x4d215
callq 0x1098a
movq 0x18(%rsp), %rdi
leaq 0x33a1c(%rip), %rax # 0x80c20
movq %rax, 0x8(%rsp)
testq %rdi, %rdi
je 0x4d221
callq 0x1098a
jmp 0x4d221
leaq 0x33a04(%rip), %rax # 0x80c20
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x4d230
callq 0xa570
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4d243
callq 0xa570
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x4d264
callq 0xa570
jmp 0x4d264
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4d27c
callq 0xa570
jmp 0x4d27c
movq %rax, %r14
leaq 0x3399d(%rip), %rax # 0x80c20
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4d294
callq 0x1098a
movq %r14, %rdi
callq 0xab90
|
/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, %rdx
leaq 0x40(%rsp), %rdi
callq 0xfb0e
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x52e72
movups 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rsp)
movq 0x10(%rbx), %rdi
movups %xmm0, 0x8(%rbx)
testq %rdi, %rdi
je 0x4d45b
callq 0x1098a
movq 0x18(%rsp), %rdi
leaq 0x337f6(%rip), %rax # 0x80c40
movq %rax, 0x8(%rsp)
testq %rdi, %rdi
je 0x4d467
callq 0x1098a
jmp 0x4d467
leaq 0x337de(%rip), %rax # 0x80c40
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x4d476
callq 0xa570
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4d489
callq 0xa570
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x4d4aa
callq 0xa570
jmp 0x4d4aa
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4d4c2
callq 0xa570
jmp 0x4d4c2
movq %rax, %r14
leaq 0x33777(%rip), %rax # 0x80c40
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4d4da
callq 0x1098a
movq %r14, %rdi
callq 0xab90
|
/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)$", regex);
is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0;
// We want to call regcomp(&partial_regex_, ...) even if the
// previous expression returns false. Otherwise partial_regex_ may
// not be properly initialized can may cause trouble when it's
// freed.
//
// Some implementation of POSIX regex (e.g. on at least some
// versions of Cygwin) doesn't accept the empty string as a valid
// regex. We change it to an equivalent form "()" to be safe.
if (is_valid_) {
const char* const partial_regex = (*regex == '\0') ? "()" : regex;
is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0;
}
EXPECT_TRUE(is_valid_)
<< "Regular expression \"" << regex
<< "\" is not a valid POSIX Extended regular expression.";
delete[] full_pattern;
}
|
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, %rcx
xorl %eax, %eax
callq 0xaa50
leaq 0x10(%r14), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xa6c0
testl %eax, %eax
sete %al
sete 0x8(%r14)
je 0x4d5ea
movb %al, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
jmp 0x4d622
cmpb $0x0, (%r15)
leaq 0xcf79(%rip), %rsi # 0x5a56e
cmovneq %r15, %rsi
leaq 0x50(%r14), %rdi
movl $0x1, %edx
callq 0xa6c0
testl %eax, %eax
sete 0x8(%r14)
sete 0x18(%rsp)
movq $0x0, 0x20(%rsp)
je 0x4d704
leaq 0x10(%rsp), %rdi
callq 0x36908
movq 0x10(%rsp), %r14
leaq 0x10(%r14), %r12
leaq 0x152e8(%rip), %rsi # 0x62924
movl $0x14, %edx
movq %r12, %rdi
callq 0xa6b0
testq %r15, %r15
je 0x4d65b
movq %r15, %rdi
callq 0xa240
movq %rax, %rdx
jmp 0x4d667
movl $0x6, %edx
leaq 0xbea5(%rip), %r15 # 0x5950c
movq %r12, %rdi
movq %r15, %rsi
callq 0xa6b0
leaq 0x152c0(%rip), %rsi # 0x62939
movl $0x33, %edx
movq %r12, %rdi
callq 0xa6b0
leaq 0x15362(%rip), %rdx # 0x629ef
leaq 0xba33(%rip), %rcx # 0x590c7
leaq 0xba32(%rip), %r8 # 0x590cd
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x37e1b
movq 0x28(%rsp), %r8
leaq 0x152b7(%rip), %rdx # 0x6296d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x2fa, %ecx # imm = 0x2FA
callq 0x332a2
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3332c
leaq 0x8(%rsp), %rdi
callq 0x33308
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4d6f6
callq 0xa570
testq %r14, %r14
je 0x4d704
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xa810
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x33308
jmp 0x4d72a
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4d749
callq 0xa570
jmp 0x4d749
jmp 0x4d746
movq %rax, %rbx
jmp 0x4d757
movq %rax, %rbx
testq %r14, %r14
je 0x4d757
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
callq 0xf4cc
movq %rbx, %rdi
callq 0xab90
nop
|
/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 until we cannot read further or the
// pre-determined file size is reached.
do {
bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
bytes_read += bytes_last_read;
} while (bytes_last_read > 0 && bytes_read < file_size);
const std::string content(buffer, bytes_read);
delete[] buffer;
return content;
}
|
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
leaq (%r15,%r13), %rdi
movq %r12, %rdx
subq %r13, %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0xa990
addq %rax, %r13
testq %rax, %rax
je 0x4dac3
cmpq %r12, %r13
jb 0x4da9f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r15, %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x105c0
movq %r15, %rdi
callq 0xa810
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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 %rbx, %rcx
callq 0x4f3f4
leaq 0x15750(%rip), %rsi # 0x634b5
movl $0x5, %edx
movq %rbx, %rdi
callq 0xa6b0
leaq -0x3f(%r14), %rsi
andq $-0x2, %rsi
subq %rsi, %r14
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x4f3f4
leaq 0x1427e(%rip), %rsi # 0x62010
movl $0x1, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xa6b0
|
/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 CharType cur = begin[index];
if (is_previous_hex && IsXDigit(cur)) {
// Previous character is of '\x..' form and this character can be
// interpreted as another hexadecimal digit in its number. Break string to
// disambiguate.
*os << "\" " << kQuoteBegin;
}
is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
// Remember if any characters required hex escaping.
if (is_previous_hex) {
print_format = kHexEscape;
}
}
*os << "\"";
return print_format;
}
|
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,%r12,4), %ebp
cmpl $0x100, %ebp # imm = 0x100
setb %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x4e01e
movl %ebp, %edi
callq 0xa0f0
testl %eax, %eax
je 0x4e01e
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x156b0(%rip), %rsi # 0x636b9
callq 0xa6b0
movl $0x2, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa6b0
movl %ebp, %edi
movq %rbx, %rsi
callq 0x500d7
cmpl $0x1, %eax
sete %al
incq %r12
cmpq %r12, %r14
jne 0x4dfdb
leaq 0x14113(%rip), %rsi # 0x62150
movl $0x1, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa6b0
|
/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 %r14, %rsi
callq 0xa210
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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
callq 0x31be5
|
/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_ = true;
std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests);
Message errors;
std::set<std::string> tests;
for (std::vector<std::string>::const_iterator name_it = name_vec.begin();
name_it != name_vec.end(); ++name_it) {
const std::string& name = *name_it;
if (tests.count(name) != 0) {
errors << "Test " << name << " is listed more than once.\n";
continue;
}
bool found = false;
for (RegisteredTestIter it = registered_tests_.begin();
it != registered_tests_.end();
++it) {
if (name == it->first) {
found = true;
break;
}
}
if (found) {
tests.insert(name);
} else {
errors << "No test named " << name
<< " can be found in this test suite.\n";
}
}
for (RegisteredTestIter it = registered_tests_.begin();
it != registered_tests_.end();
++it) {
if (tests.count(it->first) == 0) {
errors << "You forgot to list test " << it->first << ".\n";
}
}
const std::string& errors_str = errors.GetString();
if (errors_str != "") {
fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
errors_str.c_str());
fflush(stderr);
posix::Abort();
}
return registered_tests;
}
|
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(%rsp), %rdx
addq %rsi, %rdx
leaq 0xa0(%rsp), %rdi
callq 0xfb0e
leaq 0xa0(%rsp), %rsi
movl %ebp, 0x20(%rsi)
movq %rbx, %rdi
callq 0x340ce
movl %ebp, 0x3c(%rsp)
movq 0xa0(%rsp), %rdi
cmpq %r14, %rdi
je 0x4e5ae
callq 0xa570
movq %r12, 0x90(%rsp)
leaq 0x50(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x4e5c9
callq 0xa570
movq 0x28(%rsp), %rax
movb $0x1, (%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movq $0x0, 0x80(%rsp)
movq %r15, 0x98(%rsp)
leaq -0x1(%r15), %r12
movzbl 0x1(%r12), %edi
incq %r12
callq 0xa0a0
testl %eax, %eax
jne 0x4e5f1
leaq 0x18(%rsp), %rbx
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movl $0x2c, %esi
callq 0xa200
movq %rbx, 0x8(%rsp)
testq %rax, %rax
jne 0x4e62f
movq %r12, %rdi
callq 0xa240
addq %r12, %rax
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x105c0
movq 0x8(%rsp), %r14
movq 0x10(%rsp), %r15
testq %r15, %r15
je 0x4e68b
addq %r14, %r15
movzbl -0x1(%r15), %edi
callq 0xa0a0
testl %eax, %eax
je 0x4e68b
decq %r15
movq %r15, %rbx
subq %r14, %rbx
movl $0x1, %edx
movq %r13, %rdi
movq %rbx, %rsi
callq 0xa730
movq 0x8(%rsp), %rax
addq %rax, %rbx
cmpq %r14, %r15
movq %rax, %r14
movq %rbx, %r15
jne 0x4e64f
jmp 0x4e68e
movq %r14, %rax
movq %rbp, 0x40(%rsp)
leaq 0x18(%rsp), %rbx
cmpq %rbx, %rax
je 0x4e6ae
movq %rax, 0x40(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x4e6b5
movups (%rbx), %xmm0
movups %xmm0, (%rbp)
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
movq %rbx, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x168d0
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4e6f0
callq 0xa570
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x4e6ff
callq 0xa570
movq %r12, %rdi
movl $0x2c, %esi
callq 0xa200
testq %rax, %rax
je 0x4e72b
movq %rax, %r12
movzbl 0x1(%r12), %edi
incq %r12
callq 0xa0a0
testl %eax, %eax
jne 0x4e714
jmp 0x4e60d
leaq 0x30(%rsp), %rdi
callq 0x36908
leaq 0x48(%rsp), %rcx
movl $0x0, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movq 0x70(%rsp), %r14
cmpq 0x78(%rsp), %r14
je 0x4e865
movq 0x30(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x10(%rax), %r13
movq 0x28(%rsp), %rax
leaq 0x10(%rax), %rbp
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x55e3c
leaq 0x48(%rsp), %rcx
cmpq %rcx, %rax
je 0x4e7d2
movl $0x5, %edx
movq %r13, %rdi
leaq 0x143ae(%rip), %rsi # 0x62b53
callq 0xa6b0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r13, %rdi
callq 0xa6b0
movl $0x1b, %edx
movq %r13, %rdi
leaq 0x14391(%rip), %rsi # 0x62b59
callq 0xa6b0
jmp 0x4e856
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rbx
cmpq %rbp, %rbx
je 0x4e812
movq 0x8(%r14), %r12
cmpq 0x28(%rbx), %r12
jne 0x4e802
testq %r12, %r12
je 0x4e84b
movq 0x20(%rbx), %rsi
movq (%r14), %rdi
movq %r12, %rdx
callq 0xa610
testl %eax, %eax
je 0x4e84b
movq %rbx, %rdi
callq 0xa6d0
movq %rax, %rbx
cmpq %rbp, %rax
jne 0x4e7e4
movl $0xe, %edx
movq %r13, %rdi
leaq 0x14354(%rip), %rsi # 0x62b75
callq 0xa6b0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r13, %rdi
callq 0xa6b0
movl $0x22, %edx
movq %r13, %rdi
leaq 0x14340(%rip), %rsi # 0x62b84
callq 0xa6b0
jmp 0x4e856
movq %r15, %rdi
movq %r14, %rsi
callq 0x297f6
addq $0x20, %r14
cmpq 0x78(%rsp), %r14
jne 0x4e781
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rbx
addq $0x10, %rax
cmpq %rax, %rbx
je 0x4e8ec
movq %rax, %r15
leaq 0x40(%rsp), %r14
leaq 0x14321(%rip), %r12 # 0x62ba7
leaq 0x13486(%rip), %r13 # 0x61d13
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x55e3c
leaq 0x48(%rsp), %rcx
cmpq %rcx, %rax
jne 0x4e8dc
movq 0x30(%rsp), %rbp
addq $0x10, %rbp
movl $0x18, %edx
movq %rbp, %rdi
movq %r12, %rsi
callq 0xa6b0
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %rbp, %rdi
callq 0xa6b0
movl $0x2, %edx
movq %rbp, %rdi
movq %r13, %rsi
callq 0xa6b0
movq %rbx, %rdi
callq 0xa6d0
movq %rax, %rbx
cmpq %r15, %rax
jne 0x4e88d
movq 0x30(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x36b3d
leaq 0x134c0(%rip), %rsi # 0x61dc5
leaq 0x8(%rsp), %rdi
callq 0xa150
testl %eax, %eax
movq 0x98(%rsp), %rbx
leaq 0x18(%rsp), %rax
jne 0x4e966
movq 0x8(%rsp), %rdi
cmpq %rax, %rdi
je 0x4e92f
callq 0xa570
leaq 0x40(%rsp), %rdi
callq 0x540c8
testq %r14, %r14
je 0x4e947
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x70(%rsp), %rdi
callq 0x10390
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x32653(%rip), %rax # 0x80fc0
movq (%rax), %rbx
leaq 0xc8(%rsp), %rdi
movq 0x90(%rsp), %rsi
movl 0x3c(%rsp), %edx
callq 0x3b7b5
leaq 0xc8(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0xb5d9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4ea22
callq 0xa570
jmp 0x4ea22
movq %rax, %rbx
jmp 0x4ea22
jmp 0x4e9f4
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
cmpq %r14, %rdi
je 0x4e9d8
callq 0xa570
jmp 0x4e9d8
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4ea5d
callq 0xa570
jmp 0x4ea5d
movq %rax, %rbx
jmp 0x4ea5d
jmp 0x4ea17
movq %rax, %rbx
jmp 0x4ea53
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4ea3f
callq 0xa570
jmp 0x4ea3f
movq %rax, %rbx
movq 0x30(%rsp), %r14
jmp 0x4ea22
movq %rax, %rbx
movq 0x88(%rsp), %r14
leaq 0x40(%rsp), %rdi
callq 0x540c8
testq %r14, %r14
je 0x4ea53
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x4ea53
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4ea53
callq 0xa570
leaq 0x70(%rsp), %rdi
callq 0x10390
movq %rbx, %rdi
callq 0xab90
nop
|
/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 original
// working directory first.
const char* const original_dir =
UnitTest::GetInstance()->original_working_dir();
// We can safely call chdir() as it's a direct system call.
if (chdir(original_dir) != 0) {
DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
GetLastErrnoDescription());
return EXIT_FAILURE;
}
// We can safely call execve() as it's a direct system call. We
// cannot use execvp() as it's a libc function and thus potentially
// unsafe. Since execve() doesn't search the PATH, the user must
// invoke the test program via a valid path that contains at least
// one path separator.
execve(args->argv[0], args->argv, GetEnviron());
DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " +
original_dir + " failed: " +
GetLastErrnoDescription());
return EXIT_FAILURE;
}
|
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 0x13b4c(%rip), %rdx # 0x62655
leaq 0xa0(%rsp), %rdi
callq 0x105c0
leaq 0x13a35(%rip), %rsi # 0x62552
leaq 0xa0(%rsp), %rdi
callq 0xac80
leaq 0xd0(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4ec41
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x4ec54
callq 0x333fe
movq 0x32f4f(%rip), %rax # 0x81ab0
movq 0x10(%rax), %rbx
movq %rbx, %rdi
callq 0xa960
testl %eax, %eax
jne 0x4ebe8
movq (%r14), %rsi
movq (%rsi), %rdi
movq 0x3244a(%rip), %rax # 0x80fc8
movq (%rax), %rdx
callq 0xab10
leaq 0xd0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1484a(%rip), %rsi # 0x633e3
leaq 0x1484a(%rip), %rdx # 0x633ea
leaq 0xc0(%rsp), %rdi
callq 0x105c0
movq (%r14), %rax
movq (%rax), %rsi
leaq 0xc0(%rsp), %rdi
callq 0xac80
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4eca9
movups (%rcx), %xmm0
movups %xmm0, (%r14)
jmp 0x4ecb6
leaq 0x70(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x147d7(%rip), %rsi # 0x633cf
leaq 0x147d7(%rip), %rdx # 0x633d6
leaq 0x60(%rsp), %rdi
callq 0x105c0
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
callq 0xac80
leaq 0x90(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4ed08
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x4ed1b
movq %rdx, 0xc0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xd0(%rsp)
movq 0x8(%rax), %rdx
leaq 0xc0(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x139dc(%rip), %rsi # 0x62656
callq 0xac80
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4ed70
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x4ed7d
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
movq 0x8(%rax), %rdx
leaq 0x40(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x14712(%rip), %rsi # 0x633eb
callq 0xac80
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4ee10
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x4ee1d
movq %rdx, 0x80(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x90(%rsp)
movq 0x8(%rax), %rdx
leaq 0x80(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x14696(%rip), %rsi # 0x633d7
callq 0xac80
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4ee6d
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x4ee79
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x48(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xe4(%rsp), %rsi
movl $0x4e0, (%rsi) # imm = 0x4E0
leaq 0xe8(%rsp), %rdi
callq 0x51be6
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0xf0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r12, %rcx
je 0x4edd5
movq 0x50(%rsp), %rdi
leaq 0xf8(%rsp), %r13
movq -0x10(%r13), %rsi
cmpq %rdi, %rax
jbe 0x4ee01
movl $0xf, %edi
cmpq %r13, %rsi
je 0x4edf8
movq 0xf8(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4ef55
leaq 0x40(%rsp), %rdi
callq 0xa190
jmp 0x4ef66
movq %rdx, 0x60(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x70(%rsp)
movq 0x8(%rax), %rdx
leaq 0x60(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rsi
callq 0xac80
leaq 0x90(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4eeef
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x4ef02
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x40(%rsp), %rdi
callq 0x46be5
movq (%rsp), %rcx
movq 0x8(%rsp), %r8
movq 0x48(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r12, %rcx
je 0x4eebc
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %r13
movq -0x10(%r13), %rsi
cmpq %rdi, %rax
jbe 0x4eee2
movl $0xf, %edi
cmpq %r13, %rsi
je 0x4eed9
movq 0x50(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4efe9
movq %rsp, %rdi
callq 0xa190
jmp 0x4eff7
movq %rdx, 0x80(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x90(%rsp)
movq 0x8(%rax), %rdx
leaq 0x80(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x144b1(%rip), %rsi # 0x633d9
callq 0xac80
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4f01b
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
jmp 0x4f027
leaq 0xe8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x70(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x4ef83
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x4ef90
movq %rsi, 0x60(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x70(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x68(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xb801(%rip), %rsi # 0x5a7b5
leaq 0x60(%rsp), %rdi
callq 0xac80
leaq 0x90(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4f0e5
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
jmp 0x4f0f8
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x30(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x4f0b1
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x4f0be
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xa0(%rsp), %rdi
callq 0x46be5
movq (%rsp), %rcx
movq 0x8(%rsp), %r8
movq 0xa8(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %rbp, %rcx
je 0x4f070
movq 0x10(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
movq -0x10(%rsi), %rsi
cmpq %rdi, %rax
jbe 0x4f0a4
movl $0xf, %edi
leaq 0xb0(%rsp), %r9
cmpq %r9, %rsi
je 0x4f09b
movq 0xb0(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4f195
movq %rsp, %rdi
callq 0xa190
jmp 0x4f1a6
movq %rsi, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x28(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x20(%rsp), %rdi
callq 0x46c95
movq %rdx, 0x80(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x90(%rsp)
movq 0x8(%rax), %rdx
leaq 0x80(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1429b(%rip), %rsi # 0x633b9
callq 0xac80
leaq 0x10(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4f143
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
jmp 0x4f14f
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x13703(%rip), %rsi # 0x62873
callq 0xac80
leaq 0x30(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x4f1f7
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
jmp 0x4f204
leaq 0xa0(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa6a0
leaq 0x30(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x4f1c3
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x4f1d0
movq %rsi, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x28(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x20(%rsp), %rdi
callq 0x46c95
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x46c95
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x4f241
callq 0xa570
jmp 0x4f241
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq (%rsp), %rdi
cmpq %rax, %rdi
je 0x4f290
callq 0xa570
jmp 0x4f290
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f271
callq 0xa570
jmp 0x4f271
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0x4f2a7
callq 0xa570
jmp 0x4f2a7
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4f2ba
callq 0xa570
jmp 0x4f2ba
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x4f2fe
callq 0xa570
jmp 0x4f2fe
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f315
callq 0xa570
jmp 0x4f315
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f2ea
callq 0xa570
jmp 0x4f2ea
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x4f32c
callq 0xa570
jmp 0x4f32c
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r13, %rdi
je 0x4f33f
callq 0xa570
jmp 0x4f33f
movq %rax, %rbx
movq 0xe8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4f353
callq 0xa570
jmp 0x4f353
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4f367
callq 0xa570
jmp 0x4f367
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x4f37e
callq 0xa570
jmp 0x4f37e
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x4f392
callq 0xa570
jmp 0x4f392
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x4f3a9
callq 0xa570
jmp 0x4f3a9
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x4f3b3
callq 0xa570
jmp 0x4f3b3
movq %rax, %rbx
movq 0xc0(%rsp), %rdi
cmpq %r15, %rdi
je 0x4f3c5
callq 0xa570
jmp 0x4f3c5
movq %rax, %rbx
movq 0x60(%rsp), %rdi
jmp 0x4f3cd
movq %rax, %rbx
movq 0xc0(%rsp), %rdi
cmpq %r15, %rdi
jne 0x4f3d2
jmp 0x4f3e0
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
cmpq %r14, %rdi
je 0x4f3e0
callq 0xa570
jmp 0x4f3e0
jmp 0x4f3dd
jmp 0x4f3dd
movq %rax, %rbx
movq %rbx, %rdi
callq 0xab90
|
/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::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0)::FactoryImpl::~FactoryImpl()
|
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, 0x30(%rbx)
leaq 0x48(%rbx), %rcx
movq %rcx, 0x38(%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x4f608
movq %rdx, 0x38(%rbx)
movq (%rax), %rcx
movq %rcx, 0x48(%rbx)
jmp 0x4f60e
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x40(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
xorl %eax, %eax
movb %al, 0x10(%r14)
movb %al, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x30d4e(%rip), %rax # 0x80388
movq %rax, (%rbx)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x514c2
movq %r14, %rdi
callq 0xab90
nop
|
/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(%rbx), %rdi
callq 0x514c2
movq %rbx, %rdi
popq %rbx
jmp 0xa570
|
/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
popq %rbx
jmp 0xa570
popq %rbx
retq
nop
|
/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 0x4f86a
callq 0xa570
movq %rbx, %rdi
popq %rbx
jmp 0xa570
nop
|
/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";
}
message << " thrown in " << location << ".";
return message.GetString();
}
|
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 0xa6b0
movq %r13, %rdi
callq 0xa240
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xa6b0
movl $0x1, %edx
leaq 0x127ef(%rip), %rsi # 0x62150
jmp 0x4f96f
movl $0x15, %edx
leaq 0x13bf3(%rip), %rsi # 0x63562
movq %r15, %rdi
callq 0xa6b0
leaq 0x13bfa(%rip), %rsi # 0x63578
movl $0xb, %edx
movq %r15, %rdi
callq 0xa6b0
testq %r12, %r12
je 0x4f99d
movq %r12, %rdi
callq 0xa240
movq %rax, %rdx
jmp 0x4f9a9
movl $0x6, %edx
leaq 0x9b63(%rip), %r12 # 0x5950c
movq %r15, %rdi
movq %r12, %rsi
callq 0xa6b0
leaq 0x12751(%rip), %rsi # 0x6210c
movl $0x1, %edx
movq %r15, %rdi
callq 0xa6b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x36b3d
testq %rbx, %rbx
je 0x4f9ee
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4fa0f
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xab90
|
/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.
*value = value_str;
return true;
}
|
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 %r15
retq
|
/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 = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
return true;
}
|
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 %rcx
retq
popq %rax
jmp 0x4ffb3
nop
|
/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(%rsp), %rdi
testq %rdi, %rdi
je 0x506a4
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x506c4
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xab90
|
/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(%rsp), %rdi
testq %rdi, %rdi
je 0x50794
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x507b4
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xab90
|
/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 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x52cda
callq 0x1098a
leaq 0x2db9f(%rip), %rax # 0x80880
movq %rax, (%r15)
movq %r14, 0x40(%r15)
movl %ebx, 0x48(%r15)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x52d08
callq 0x1098a
movq %rbx, %rdi
callq 0xab90
|
/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, %edx
callq 0xa6b0
movq 0x2b8a4(%rip), %rdi # 0x80fe8
leaq 0xd785(%rip), %rsi # 0x62ed0
movl $0x40, %edx
callq 0xa6b0
leaq 0xc(%rsp), %rdi
callq 0x4d89c
movl 0x8(%rbx), %edi
callq 0xacb0
movl $0xffffffff, 0x8(%rbx) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x4d89c
movq %rbx, %rdi
callq 0xab90
nop
|
/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_->MakeNewHolder();
ThreadLocalValueHolderBase* const holder_base = new_holder;
GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
return new_holder->pointer();
}
|
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(%rip), %rdx # 0x5ffff
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x705, %ecx # imm = 0x705
callq 0x4d76a
movq 0x2ad62(%rip), %rdi # 0x80fe8
leaq 0xa12b(%rip), %rsi # 0x603b8
movl $0x26, %edx
callq 0xa6b0
movq 0x2ad4a(%rip), %rdi # 0x80fe8
leaq 0x9e13(%rip), %rsi # 0x600b8
movl $0x12, %edx
callq 0xa6b0
movq 0x2ad32(%rip), %rdi # 0x80fe8
movl %ebp, %esi
callq 0xab30
leaq 0xc(%rsp), %rdi
callq 0x4d89c
addq $0x8, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x4d89c
movq %rbx, %rdi
callq 0xab90
|
/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.