name string | code string | asm string | file string |
|---|---|---|---|
LowMC_test_vector_192_192_4_4 | static int LowMC_test_vector_192_192_4_4(void) {
const uint8_t key[24] = {
0x56, 0x9d, 0x7d, 0x82, 0x23, 0x0, 0x94, 0x3d, 0x94, 0x83, 0x47, 0x74,
0x27, 0xe8, 0x8e, 0xa2, 0x27, 0xa2, 0xe3, 0x17, 0x2c, 0x4, 0xbc, 0xd3,
};
const uint8_t plaintext[24] = {
0xae, 0xeb, 0x9d, 0x5b, 0x61, 0xa2, 0xa5, ... | subq $0x58, %rsp
movq 0x1c8c5(%rip), %rax # 0x21410
movq %rax, 0x40(%rsp)
movq 0x1c8c1(%rip), %rax # 0x21418
movq %rax, 0x48(%rsp)
movq 0x1c8bd(%rip), %rax # 0x21420
movq %rax, 0x50(%rsp)
movq 0x1c8c1(%rip), %rax # 0x21430
movq %rax, 0x20(%rsp)
movq 0x1c8bd(%rip), %rax # 0x21438
movq %rax, 0x28(%rsp... | /IAIK[P]Picnic/tests/lowmc_test.c |
LowMC_test_vector_255_255_4_1 | static int LowMC_test_vector_255_255_4_1(void) {
const uint8_t key[32] = {
0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
};
const uint8_t plaintext[32] = {
0xab, 0xff, 0x0, 0x0, 0x... | subq $0x68, %rsp
movq 0x1c895(%rip), %rax # 0x21470
movq %rax, 0x40(%rsp)
movq 0x1c891(%rip), %rax # 0x21478
movq %rax, 0x48(%rsp)
movq 0x1c88d(%rip), %rax # 0x21480
movq %rax, 0x50(%rsp)
movq 0x1c889(%rip), %rax # 0x21488
movq %rax, 0x58(%rsp)
movq 0x1c885(%rip), %rax # 0x21490
movq %rax, 0x20(%rsp... | /IAIK[P]Picnic/tests/lowmc_test.c |
sbox_s128_full | ATTR_TARGET_S128
static inline void sbox_s128_full(mzd_local_t* in, const mzd_local_t* mask_a,
const mzd_local_t* mask_b, const mzd_local_t* mask_c) {
word128 inm[2] = {mm128_load(&in->w64[0]), mm128_load(&in->w64[2])};
word128 x0m[2] = {mm128_load(&mask_a->w64[0]), mm128_load(&mas... | subq $0xa08, %rsp # imm = 0xA08
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movq %rcx, 0xe8(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x140(%rsp)
movq 0x140(%rsp), %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm0, 0xc0(%rsp)
movq 0x100(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x138(%rsp)
movq 0x1... | /IAIK[P]Picnic/lowmc.c |
mzd_shift_left_uint64_256 | void mzd_shift_left_uint64_256(mzd_local_t* res, const mzd_local_t* val, unsigned int count) {
const unsigned int right_count = 8 * sizeof(word) - count;
const block_t* block = CONST_BLOCK(val, 0);
block_t* rblock = BLOCK(res, 0);
rblock->w64[3] = (block->w64[3] << count) | (block->w64... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, %ecx
movl $0x40, %eax
subq %rcx, %rax
movl %eax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movl -0x14(%rsp), %ec... | /IAIK[P]Picnic/mzd_additional.c |
PDCLIB_prepwrite | int _PDCLIB_prepwrite( struct _PDCLIB_file_t * stream )
{
if ( ( stream->bufidx < stream->bufend ) || ( stream->ungetidx > 0 ) ||
( stream->status & ( _PDCLIB_FREAD | _PDCLIB_ERRORFLAG | _PDCLIB_WIDESTREAM | _PDCLIB_EOFFLAG ) ) ||
!( stream->status & ( _PDCLIB_FWRITE | _PDCLIB_FAPPEND | _PDCLIB_FR... | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x20(%rdi), %rax
jb 0x23a4
cmpq $0x0, 0x38(%rbx)
jne 0x23a4
movl 0x44(%rbx), %eax
testw $0xe08, %ax # imm = 0xE08
sete %cl
testb $0x70, %al
setne %dl
testb %dl, %cl
jne 0x23b8
callq 0x3864
movl $0x9, (%rax)
orb $0x2, 0x45(%rbx)
pushq $-0x1
popq %rax
popq... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_prepwrite.c |
PDCLIB_print | const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status )
{
const char * orig_spec = spec;
if ( *( ++spec ) == '%' )
{
/* %% -> print single '%' */
PUT( *spec );
return ++spec;
}
/* Initializing status structure */
status->flags = 0;
status->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
incq %rdi
movq %rdi, 0x10(%rsp)
cmpb $0x25, 0x1(%r14)
jne 0x240d
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jae 0x2523
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x251b
pushq $0x25
popq %rdi
callq 0x36b0
jmp 0x2523
an... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print.c |
intformat | static void intformat( intmax_t value, struct _PDCLIB_status_t * status )
{
/* At worst, we need two prefix characters (hex prefix). */
char preface[3] = "\0";
size_t preidx = 0;
if ( status->prec < 0 )
{
status->prec = 1;
}
if ( ( status->flags & E_alt ) && ( status->base == 16 ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
andw $0x0, 0x4(%rsp)
movb $0x0, 0x6(%rsp)
cmpl $0x0, 0x30(%rsi)
jns 0x326b
movl $0x1, 0x30(%rbx)
movl 0x4(%rbx), %eax
testb $0x4, %al
jne 0x3276
xorl %edx, %edx
jmp 0x32b9
movl (%rbx), %ecx
cmpl $0x10, %ecx
jne 0x32a1
testq %rd... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_integer.c |
PDCLIB_strtox_main | _PDCLIB_uintmax_t _PDCLIB_strtox_main( const char ** p, unsigned int base, uintmax_t error, uintmax_t limval, int limdigit, char * sign )
{
_PDCLIB_uintmax_t rc = 0;
int digit = -1;
const char * x;
while ( ( x = (const char *)memchr( _PDCLIB_digits, tolower( (unsigned char)**p ), base ) ) != NULL )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, 0x4(%rsp)
movq %rcx, %r14
movq %rdx, 0x8(%rsp)
movq %rdi, %rbx
movl %esi, %r12d
movq (%rdi), %rbp
incq %rbp
pushq $-0x1
popq %r15
xorl %r13d, %r13d
movzbl -0x1(%rbp), %edi
callq 0x3a28
leaq 0x1381(%rip), %... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_strtox_main.c |
PDCLIB_strtox_prelim | const char * _PDCLIB_strtox_prelim( const char * p, char * sign, int * base )
{
/* skipping leading whitespace */
while ( isspace( (unsigned char)*p ) )
{
++p;
}
/* determining / skipping sign */
if ( *p != '+' && *p != '-' )
{
*sign = '+';
}
else
{
*sign... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb (%rbx), %r12b
movzbl %r12b, %ebp
movl %ebp, %edi
callq 0x3a0c
incq %rbx
testl %eax, %eax
jne 0x3965
cmpl $0x2b, %ebp
je 0x398a
cmpl $0x2d, %ebp
je 0x398a
decq %rbx
movb $0x2b, %r12b
movb %r12b, (%r15)
cmpb $0x30,... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_strtox_prelim.c |
Gudhi::Persistence_representations::find_zero_of_a_line_segment_between_those_two_points(std::pair<double, double>, std::pair<double, double>) | double find_zero_of_a_line_segment_between_those_two_points(std::pair<double, double> p1,
std::pair<double, double> p2) {
if (p1.first == p2.first) return p1.first;
if (p1.second * p2.second > 0) {
std::ostringstream errMessage;
errMessage << "In f... | pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
ucomisd %xmm2, %xmm0
jne 0x2764
jnp 0x279a
movapd %xmm1, %xmm5
mulsd %xmm3, %xmm5
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm5
ja 0x27a3
subsd %xmm1, %xmm3
subsd %xmm0, %xmm2
divsd %xmm2, %xmm3
mulsd %xmm3, %xmm0
subsd %xmm0, %xmm1
xorpd 0x289e(%rip), %xmm1 # 0x5030
... | /GUDHI[P]gudhi-devel/src/Persistence_representations/include/gudhi/common_persistence_representations.h |
flag_read::test_method() | BOOST_AUTO_TEST_CASE(flag_read)
{
auto const f = [](std::string const &str) -> std::shared_ptr<int>
{
try {
auto const n = std::stoi(str);
return n <= 100 ? std::make_shared<int>(n) : nullptr;
} catch (...) {
return nullptr;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x798, %rsp # imm = 0x798
leaq 0x11fd7(%rip), %rsi # 0x341bf
leaq 0x98(%rsp), %rdi
leaq 0x3e(%rsp), %rdx
callq 0x21110
leaq 0x12301(%rip), %rsi # 0x34502
leaq 0x420(%rsp), %rdi
leaq 0x3d(%rsp), %rdx
callq 0x21110
leaq 0x50(%rsp),... | /iorate[P]nonsugar/test/flag_default_read_test.cpp |
nonsugar::detail::to_option_map<nonsugar::basic_command<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, std::tuple<nonsugar::detail::flag<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, (char)65, int>>, std::tuple<>, std::tuple<>>>::type nonsug... | inline typename detail::to_option_map<Command>::type parse(
Iterator begin, Iterator end, Command const &command, argument_order order)
{
using string_type = typename Command::string_type;
using error_type = basic_error<string_type>;
using regex_type = std::basic_regex<typename string_type::value_type>;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movl %r8d, 0x4c(%rsp)
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0xb0(%rcx), %rsi
movq %rdi, 0x18(%rsp)
callq 0x25eda
leaq 0xc8(%rsp), %rdi
leaq 0x110(%rsp), %rc... | /iorate[P]nonsugar/nonsugar.hpp |
leveldb::(anonymous namespace)::CorruptionReporter::Corruption(unsigned long, leveldb::Status const&) | void Corruption(size_t bytes, const Status& status) override {
std::string r = "corruption: ";
AppendNumberTo(&r, bytes);
r += " bytes; ";
r += status.ToString();
r.push_back('\n');
dst_->Append(r);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x9cb4(%rip), %rsi # 0x100eb
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x5100
movq %r12, %rdi
movq %r15, %rsi
callq 0xaa64
leaq 0x9c9d(%rip), %rsi # 0x100f8
leaq 0x8(%rsp), ... | /CDDSCLab[P]leveldb/db/dumpfile.cc |
leveldb::Status::operator=(leveldb::Status const&) | inline Status& Status::operator=(const Status& rhs) {
// The following condition catches both aliasing (when this == &rhs),
// and the common case where both rhs and *this are ok.
if (state_ != rhs.state_) {
delete[] state_;
state_ = (rhs.state_ == nullptr) ? nullptr : CopyState(rhs.state_);
}
return ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rsi), %rdi
cmpq %rdi, %rax
je 0x9d14
testq %rax, %rax
je 0x9d03
movq %rsi, %r14
movq %rax, %rdi
callq 0x5430
movq (%r14), %rdi
testq %rdi, %rdi
je 0x9d0f
callq 0xac78
jmp 0x9d11
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
po... | /CDDSCLab[P]leveldb/include/leveldb/status.h |
leveldb::GetVarint32Ptr(char const*, char const*, unsigned int*) | inline const char* GetVarint32Ptr(const char* p, const char* limit,
uint32_t* value) {
if (p < limit) {
uint32_t result = *(reinterpret_cast<const unsigned char*>(p));
if ((result & 128) == 0) {
*value = result;
return p + 1;
}
}
return GetVarint32PtrFallb... | cmpq %rsi, %rdi
jae 0x9fc7
movsbl (%rdi), %eax
testl %eax, %eax
js 0x9fc7
movl %eax, (%rdx)
incq %rdi
movq %rdi, %rax
retq
nop
| /CDDSCLab[P]leveldb/util/coding.h |
leveldb::(anonymous namespace)::BytewiseComparatorImpl::FindShortSuccessor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) const | void FindShortSuccessor(std::string* key) const override {
// Find first character that can be incremented
size_t n = key->size();
for (size_t i = 0; i < n; i++) {
const uint8_t byte = (*key)[i];
if (byte != static_cast<uint8_t>(0xff)) {
(*key)[i] = byte + 1;
key->resize(i + 1);
... | xorl %ecx, %ecx
subq 0x8(%rsi), %rcx
pushq $0x1
popq %rax
leaq (%rcx,%rax), %rdx
cmpq $0x1, %rdx
je 0xa2ba
movq (%rsi), %rdx
movb -0x1(%rdx,%rax), %dil
cmpb $-0x1, %dil
jne 0xa2bb
incq %rax
jmp 0xa29d
retq
incb %dil
movb %dil, -0x1(%rdx,%rax)
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x5490
nop
| /CDDSCLab[P]leveldb/util/comparator.cc |
leveldb::InternalKeyComparator::FindShortSuccessor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) const | void InternalKeyComparator::FindShortSuccessor(std::string* key) const {
Slice user_key = ExtractUserKey(*key);
std::string tmp(user_key.data(), user_key.size());
user_comparator_->FindShortSuccessor(&tmp);
if (tmp.size() < user_key.size() &&
user_comparator_->Compare(user_key, tmp) < 0) {
// User key... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
callq 0xdb44
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
addq %rax, %rdx
movq %rsp, %r15
movq %r15,... | /CDDSCLab[P]leveldb/db/dbformat.cc |
leveldb::Arena::Allocate(unsigned long) | inline char* Arena::Allocate(size_t bytes) {
// The semantics of what to return are a bit messy if we allow
// 0-byte allocations, so we disallow them here (we don't need
// them for our internal use).
assert(bytes > 0);
if (bytes <= alloc_bytes_remaining_) {
char* result = alloc_ptr_;
alloc_ptr_ += b... | testq %rsi, %rsi
je 0xe01f
movq 0x8(%rdi), %rcx
subq %rsi, %rcx
jae 0xe011
jmp 0xfbb4
movq (%rdi), %rax
addq %rax, %rsi
movq %rsi, (%rdi)
movq %rcx, 0x8(%rdi)
retq
pushq %rax
leaq 0x52e2(%rip), %rdi # 0x13309
leaq 0x52e5(%rip), %rsi # 0x13313
leaq 0x5335(%rip), %rcx # 0x1336a
pushq $0x3b
popq %rdx
callq ... | /CDDSCLab[P]leveldb/util/arena.h |
leveldb::Block::Block(leveldb::BlockContents const&) | Block::Block(const BlockContents& contents)
: data_(contents.data.data()),
size_(contents.data.size()),
owned_(contents.heap_allocated) {
if (size_ < sizeof(uint32_t)) {
size_ = 0; // Error marker
} else {
size_t max_restarts_allowed = (size_ - sizeof(uint32_t)) / sizeof(uint32_t);
if (... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %r14
movq %r14, 0x8(%rdi)
movb 0x11(%rsi), %al
movb %al, 0x14(%rdi)
cmpq $0x3, %r14
jbe 0xe5b0
addq $-0x4, %r14
shrq $0x2, %r14
movq %rbx, %rdi
callq 0xe750
movl %eax, %eax
cmpq %rax, %r14
jae 0xe5b7
andq $0x0, 0x8(%rbx... | /CDDSCLab[P]leveldb/table/block.cc |
leveldb::Block::Iter::Seek(leveldb::Slice const&) | void Seek(const Slice& target) override {
// Binary search in restart array to find the last restart point
// with a key < target
uint32_t left = 0;
uint32_t right = num_restarts_ - 1;
while (left < right) {
uint32_t mid = (left + right + 1) / 2;
uint32_t region_offset = GetRestartPoint(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x3c(%rdi), %r13d
decl %r13d
xorl %r15d, %r15d
leaq 0x24(%rsp), %rbp
cmpl %r13d, %r15d
jae 0xe93c
leal (%r15,%r13), %r12d
incl %r12d
shrl %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0xebc4
movq 0x30(... | /CDDSCLab[P]leveldb/table/block.cc |
leveldb::Block::Iter::Prev() | void Prev() override {
assert(Valid());
// Scan backwards to a restart point before current_
const uint32_t original = current_;
while (GetRestartPoint(restart_index_) >= original) {
if (restart_index_ == 0) {
// No more entries
current_ = restarts_;
restart_index_ = num_r... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0xea30
movl 0x40(%rbx), %ebp
movl 0x44(%rbx), %esi
movq %rbx, %rdi
callq 0xebc4
movl 0x44(%rbx), %esi
cmpl %ebp, %eax
jb 0xe9fe
testl %esi, %esi
je 0xea21
decl %esi
movl %esi, 0x44(%rbx)
jmp 0xe9e4
movq %rbx, %rdi
cal... | /CDDSCLab[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 0x4c6f(%rip), %rax # 0x1387e
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq $0x12, 0x8(%rsi)
leaq 0x152b(%rip), %r15 # 0x10151
leaq 0x10(%rsp), %rdx
movq %r15, (%rdx)
andq $0x0, 0x8(%rdx)
leaq 0x8(... | /CDDSCLab[P]leveldb/table/block.cc |
leveldb::ReadBlock(leveldb::RandomAccessFile*, leveldb::ReadOptions const&, leveldb::BlockHandle const&, leveldb::BlockContents*) | Status ReadBlock(RandomAccessFile* file, const ReadOptions& options,
const BlockHandle& handle, BlockContents* result) {
result->data = Slice();
result->cachable = false;
result->heap_allocated = false;
// Read the block contents as well as the type/crc footer.
// See table_builder.cc for th... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r13
movq %rcx, %rbp
leaq 0xaf0(%rip), %r14 # 0x10151
movq %r14, (%r8)
andq $0x0, 0x8(%r8)
movq %rdx, 0x18(%rsp)
andw $0x0, 0x10(%r8)
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
movq 0x8(%rcx), %r15
leaq 0x5(%r15), %r12
movq %r... | /CDDSCLab[P]leveldb/table/format.cc |
leveldb::Arena::AllocateFallback(unsigned long) | char* Arena::AllocateFallback(size_t bytes) {
if (bytes > kBlockSize / 4) {
// Object is more than a quarter of our block size. Allocate it separately
// to avoid wasting too much space in leftover bytes.
char* result = AllocateNewBlock(bytes);
return result;
}
// We waste the remaining space in... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x401, %rsi # imm = 0x401
jb 0xfbd8
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xfc00
movl $0x1000, %r15d # imm = 0x1000
movl $0x1000, %esi # imm = 0x1000
movq %r14, %rdi
callq 0xfc00
leaq (%rax,%... | /CDDSCLab[P]leveldb/util/arena.cc |
iutest::detail::iuOptionMessage::ShowHelp() | inline void iuOptionMessage::ShowHelp()
{
detail::iuConsole::color_output(detail::iuConsole::cyan,
"--------------------------------------------------\n"
"Name\n"
" iutest - iris unit test framework\n"
"--------------------------------------------------\n"
"Command Line Op... | pushq %rbp
movq %rsp, %rbp
movl $0x6, %edi
leaq 0x10864(%rip), %rsi # 0x53ac4
movb $0x0, %al
callq 0x301d0
popq %rbp
retq
nopl (%rax)
| /srz-zumix[P]iutest/test/../include/internal/iutest_option_message.hpp |
iutest::detail::iuOptionMessage::ShowFeature() | inline void iuOptionMessage::ShowFeature()
{
#if 0
IIUT_SHOW_FEATURE_MACROS(IIUT_SHOW_MACRO);
#else
IIUT_SHOW_FEATURE_MACROS(IIUT_SHOW_ENABLE_MACRO);
IIUT_SHOW_FEATURE_MACROS(IIUT_SHOW_DISABLE_MACRO);
#endif
} | pushq %rbp
movq %rsp, %rbp
leaq 0x10f78(%rip), %rdi # 0x54223
leaq 0x10f81(%rip), %rsi # 0x54233
leaq 0x11844(%rip), %rdx # 0x54afd
movb $0x0, %al
callq 0x34130
leaq 0x10f5c(%rip), %rdi # 0x54223
leaq 0x10f7f(%rip), %rsi # 0x5424d
leaq 0x11828(%rip), %rdx # 0x54afd
movb $0x0, %al
callq 0x34130
l... | /srz-zumix[P]iutest/test/../include/internal/iutest_option_message.hpp |
iutest::TestInfo::test_name_with_where[abi:cxx11]() const | ::std::string test_name_with_where() const
{
::std::string str = m_testname;
if( value_param() != NULL )
{
str += ", where GetParam() = ";
str += m_value_param;
}
return str;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2c190
movq -0x38(%rbp), %rdi
callq 0x447b0
movq %rax, -0x30(%rbp)
jmp 0x4473b
movq -0x30(%rb... | /srz-zumix[P]iutest/test/../include/internal/../iutest_info.hpp |
iutest::TestResult::Skipped() const | bool Skipped() const
{
for( TestPartResults::const_iterator it=m_test_part_results.begin()
, end=m_test_part_results.end(); it != end; ++it )
{
if( it->skipped() || it->assume_failed() )
{
return Passed();
}
}
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x399a0
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x399d0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x39a00
testb $0x1, %al
jne 0x475dd
jmp 0x47626
leaq -0x18... | /srz-zumix[P]iutest/test/../include/internal/../iutest_result.hpp |
testing::internal::RegisterTypeParameterizedTestSuite(char const*, testing::internal::CodeLocation) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
CodeLocation code_location) {
GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
test_suite_name, code_location);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe982
movl $0x100, %r15d # imm = 0x100
addq 0x41fbd(%rip), %r15 # 0x517a8
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::internal::UnitTestOptions::PatternMatchesString(char const*, char const*) | bool UnitTestOptions::PatternMatchesString(const char *pattern,
const char *str) {
switch (*pattern) {
case '\0':
case ':': // Either ':' or '\0' marks the end of the pattern.
return *str == '\0';
case '?': // Matches any single character.
return *s... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1(%r14), %r15
movzbl (%rbx), %eax
cmpl $0x2a, %eax
jne 0x112b9
cmpb $0x0, (%r14)
je 0x112b4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11288
testb %al, %al
jne 0x112e5
incq %rbx
jmp 0x11297
testl %eax, %eax
je 0x112dc
cmpl $0x3f, %eax
je 0x112ce
cmpl ... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult(testing::TestPartResult const&) | void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
const TestPartResult& result) {
unit_test_->current_test_result()->AddTestPartResult(result);
unit_test_->listeners()->repeater()->OnTestPartResult(result);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x170(%rax), %rdi
testq %rdi, %rdi
je 0x11c05
addq $0x90, %rdi
jmp 0x11c23
movq 0x168(%rax), %rdi
testq %rdi, %rdi
je 0x11c1a
addq $0x88, %rdi
jmp 0x11c23
addq $0x178, %rax # imm = 0x178
movq %rax, %rdi
addq $0x38, %rd... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::internal::AlwaysTrue() | bool AlwaysTrue() {
#if GTEST_HAS_EXCEPTIONS
// This condition is always false so AlwaysTrue() never actually throws,
// but it makes the compiler think that it may throw.
if (IsTrue(false))
throw ClassUniqueToAlwaysTrue();
#endif // GTEST_HAS_EXCEPTIONS
return true;
} | movb $0x1, %al
retq
nop
| /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::AssertionResult::AssertionResult(testing::AssertionResult const&) | AssertionResult::AssertionResult(const AssertionResult& other)
: success_(other.success_),
message_(other.message_.get() != nullptr
? new ::std::string(*other.message_)
: static_cast< ::std::string*>(nullptr)) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rsi), %al
movb %al, (%rdi)
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x127af
movl $0x20, %edi
callq 0x9520
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xc5b0
jmp 0x127b2
xorl %r14d,... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::TestResult::GetTestProperty(int) const | const TestProperty& TestResult::GetTestProperty(int i) const {
if (i < 0 || i >= test_property_count())
internal::posix::Abort();
return test_properties_.at(static_cast<size_t>(i));
} | pushq %rax
testl %esi, %esi
js 0x15f1b
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rdx
subq %rax, %rdx
movq %rdx, %rcx
shrq $0x6, %rcx
cmpl %esi, %ecx
jle 0x15f1b
movl %esi, %esi
sarq $0x6, %rdx
cmpq %rsi, %rdx
jbe 0x15f20
shlq $0x6, %rsi
addq %rsi, %rax
popq %rcx
retq
callq 0x2fc71
leaq 0x27594(%rip), %rdi # 0x3d4bb
x... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::Test::HasSameFixtureClass() | int UnitTestImpl::test_to_run_count() const {
return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
callq 0xe982
movq 0x3ae72(%rip), %rax # 0x517a8
movq 0x168(%rax), %rcx
movq 0x170(%rax), %rbp
movq 0x30(%rcx), %rax
movq (%rax), %rax
movq 0x78(%rax), %rcx
movq 0x78(%rbp), %rdx
cmpq %rcx, %rdx
je 0x16cda
movq 0x20(%rax), %r14
movq 0... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::TestInfo::TestInfo(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&, char const*, char const*, testing::internal::CodeLocation, void const*, testing::internal::TestFactoryBase*) | TestInfo::TestInfo(const std::string& a_test_suite_name,
const std::string& a_name, const char* a_type_param,
const char* a_value_param,
internal::CodeLocation a_code_location,
internal::TypeId fixture_class_id,
internal::Tes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0xc5b0
leaq 0x20(%rb... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::internal::PrintFullTestCommentIfPresent(testing::TestInfo const&) | int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
// Google Test should handle a SEH exception if:
// 1. the user wants it to, AND
// 2. this is not a breakpoint exception, AND
// 3. this is not a C++ exception (VC++ implements them via SEH,
// apparently).
//
// SEH exception ... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19204
movq (%rdi), %r14
jmp 0x19207
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x19211
movq (%rsi), %rbx
jmp 0x19213
xorl %ebx, %ebx
movq %r14, %rax
orq %rbx, %rax
je 0x1927f
leaq 0x23b1e(%rip), %rdi # 0x3cd40
xorl %eax, %eax
callq 0x9080
testq %r14, %r14
je 0x1925b... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::PrintFailedTests(testing::UnitTest const&) | void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
const int failed_test_count = unit_test.failed_test_count();
ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
for (int i = 0; i < unit_test.total_test_suit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x40(%rdi), %rdi
callq 0x11eda
movl %eax, %ebx
leaq 0x227a6(%rip), %rsi # 0x3bb97
movl $0x1, %edi
xorl %eax, %eax
callq 0x18852
leaq 0x23225(%rip), %rdx # 0x3c629
leaq 0x22740(%rip), %rcx # 0x3bb4b
leaq 0... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::OnTestIterationEnd(testing::UnitTest const&, int) | void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
int iteration) {
if (forwarding_enabled_) {
for (size_t i = listeners_.size(); i > 0; i--) {
listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration);
}
}
} | cmpb $0x1, 0x8(%rdi)
jne 0x1a432
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x18(%rdi), %r12
subq 0x10(%rdi), %r12
je 0x1a427
movl %edx, %ebx
movq %rsi, %r14
sarq $0x3, %r12
movq 0x10(%r15), %rax
movq -0x8(%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x78(... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* xmlout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintXmlUnitTest(&stream, unit_test);
fprintf(xmlout, "%s", StringStreamToString(&stream)... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x1a592
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9390
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x1a6de
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x12687
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream*, testing::UnitTest const&) | void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
const UnitTest& unit_test) {
const std::string kTestsuites = "testsuites";
*stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
*stream << "<" << kTestsuites;
OutputXmlAttribute(stream, ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x21784(%rip), %rsi # 0x3be85
leaq 0x21787(%rip), %rdx # 0x3be8f
leaq 0x50(%rsp), %rdi
callq 0x35340
leaq 0x21777(%rip), %rsi # 0x3be90
movl $0x27, %edx
m... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestsList(std::ostream*, std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void XmlUnitTestResultPrinter::PrintXmlTestsList(
std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
const std::string kTestsuites = "testsuites";
*stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
*stream << "<" << kTestsuites;
int total_tests = 0;
for (auto test_suite : test_s... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x210a0(%rip), %rsi # 0x3be85
leaq 0x210a3(%rip), %rdx # 0x3be8f
leaq 0x50(%rsp), %rdi
callq 0x35340
leaq 0x21093(%rip), %rsi # 0x3be90
movl $0x27, %edx
m... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::UnitTest::GetMutableTestSuite(int) | 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 0x2190e
movq 0x40(%rdi), %rax
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x2190e
movl %esi, %edx
movslq (%rcx,%rdx,4), %rcx
testq %rcx, %rcx
js 0x2190e
movq 0xb8(%rax), %rax
movq (%rax,%rcx,8), %rax
retq
xorl %eax, %eax
retq
nop
| /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest-internal-inl.h |
testing::UnitTest::Run() | int UnitTest::Run() {
const bool in_death_test_child_process =
internal::GTEST_FLAG(internal_run_death_test).length() > 0;
// Google Test implements this protocol for catching that a test
// program exits before returning control to Google Test:
//
// 1. Upon start, Google Test creates a file whose a... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x2fd54(%rip) # 0x517c0
je 0x21a72
xorl %esi, %esi
jmp 0x21a81
leaq 0x1a60f(%rip), %rdi # 0x3c088
callq 0x9700
movq %rax, %rsi
movq %rsp, %rdi
callq 0x30980
movq 0x40(%rbx), %rdi
movb 0x2fbea(%rip), %al # 0x5167d
movb %al, 0x258(%rdi)
leaq 0x36(%rip), ... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::FilterTests(testing::internal::UnitTestImpl::ReactionToSharding) | int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
// num_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
movl %esi, 0x18(%rsp)
testl %esi, %esi
jne 0x22ec3
leaq 0x17090(%rip), %rdi # 0x39f30
movl $0xffffffff, %esi # imm ... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
testing::internal::ExecDeathTest::AssumeRole() | DeathTest::TestRole ExecDeathTest::AssumeRole() {
const UnitTestImpl* const impl = GetUnitTestImpl();
const InternalRunDeathTestFlag* const flag =
impl->internal_run_death_test_flag();
const TestInfo* const info = impl->current_test_info();
const int death_test_index = info->result()->death_test_count();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, %rbx
callq 0xe982
movq 0x2ab74(%rip), %rax # 0x517a8
movq 0x170(%rax), %r14
movq 0x238(%rax), %rax
movl 0xf8(%r14), %ecx
movl %ecx, 0x134(%rsp)
testq %rax, %rax
je 0x26c65
movl 0x28(%rax), %eax
mo... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest-death-test.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<char [12]>(char const (&) [12]) | 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 0x1241e
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x9230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9640
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x329ee
movq 0x8(%r... | /Asyc[P]SocketSys/libs/gtest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [29]>(char const (&) [29]) | 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 0x1241e
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x9230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9640
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x329ee
movq 0x8(%r... | /Asyc[P]SocketSys/libs/gtest/googletest/include/gtest/gtest.h |
testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*) | void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc,
TestInfo* test_info) {
// In order to support thread-safe death tests, we need to
// remember the original working directory when the test program
// was first invoked... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x18(%rdi)
jne 0x3032c
leaq 0x10(%r12), %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x2a398
movq %r13, %rdi
movq %rbp, %rsi
callq 0x92e0
leaq 0x18(%rsp), %rax... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest-internal-inl.h |
testing::internal::UnitTestImpl::Passed() const | bool Passed() const { return !Failed(); } | pushq %rbx
movq %rdi, %rbx
callq 0x11d0c
testl %eax, %eax
jle 0x308d3
xorl %eax, %eax
jmp 0x308e4
addq $0x178, %rbx # imm = 0x178
movq %rbx, %rdi
callq 0x165d0
xorb $0x1, %al
popq %rbx
retq
| /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest-internal-inl.h |
testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile() | ~ScopedPrematureExitFile() {
#if !defined GTEST_OS_ESP8266
if (!premature_exit_filepath_.empty()) {
int retval = remove(premature_exit_filepath_.c_str());
if (retval) {
GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""
<< premature_exit_filepath_ << "\"... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x30bfb
movq (%rbx), %rdi
callq 0x9a70
testl %eax, %eax
je 0x30bfb
movl %eax, %ebp
leaq 0xa423(%rip), %rdx # 0x3afb4
leaq 0xc(%rsp), %rdi
movl $0x2, %esi
movl $0x131d, %ecx # imm = 0x131D
callq 0x2b952
movq 0x2043c(... | /Asyc[P]SocketSys/libs/gtest/googletest/src/gtest.cc |
CLI::App::parse(int, char**) | void parse(int argc, char **argv) {
name_ = argv[0];
std::vector<std::string> args;
for(int i = argc - 1; i > 0; i--)
args.emplace_back(argv[i]);
parse(args);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdx), %rsi
addq $0x8, %rdi
callq 0x4460
xorps %xmm0, %xmm0
movq %rsp, %r14
andq $0x0, 0x10(%r14)
movaps %xmm0, (%r14)
movl %ebp, %eax
incl %ebp
leaq (%r15,%rax,8), %rsi
addq $-0x8, %rsi
decl %ebp
cmpl $0x... | /SX91[P]CLI11/include/CLI/App.hpp |
CLI::App::exit(CLI::Error const&, std::ostream&, std::ostream&) const | int exit(const Error &e, std::ostream &out = std::cout, std::ostream &err = std::cerr) const {
/// Avoid printing anything if this is a CLI::RuntimeError
if(dynamic_cast<const CLI::RuntimeError *>(&e) != nullptr)
return e.get_exit_code();
if(dynamic_cast<const CLI::CallForHelp *>(&... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x14c18(%rip), %rsi # 0x19890
leaq 0x150f9(%rip), %rdx # 0x19d78
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x42a0
testq %rax, %rax
jne 0x4cf7
leaq 0x14bfb(%rip), %rsi # 0x... | /SX91[P]CLI11/include/CLI/App.hpp |
CLI::App::App(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CLI::App*) | App(std::string description_, App *parent) : description_(std::move(description_)), parent_(parent) {
// Inherit if not from a nullptr
if(parent_ != nullptr) {
if(parent_->help_ptr_ != nullptr)
set_help_flag(parent_->help_ptr_->get_name(), parent_->help_ptr_->get_description(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x1498a(%rip), %rax # 0x198d0
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0xc145(%rip), %rsi # 0x11099
leaq 0xf(%rsp), %rdx
movq %rdi, 0x30(%rsp)
callq 0x4100
leaq 0x28(%r14), %r15... | /SX91[P]CLI11/include/CLI/App.hpp |
CLI::App::set_help_flag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | Option *set_help_flag(std::string name = "", std::string description = "") {
if(help_ptr_ != nullptr) {
remove_option(help_ptr_);
help_ptr_ = nullptr;
}
// Empty name will simply remove the help flag
if(!name.empty()) {
help_ptr_ = add_flag(name, desc... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0xd0(%rdi), %rsi
testq %rsi, %rsi
je 0x52c6
movq %rbx, %rdi
callq 0x5ea4
andq $0x0, 0xd0(%rbx)
cmpq $0x0, 0x8(%r15)
je 0x531b
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x4330
movq %rsp, %rdi
movq %r14, %rsi
callq 0x... | /SX91[P]CLI11/include/CLI/App.hpp |
testing::internal::ExecDeathTest::AssumeRole() (.cold.1) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
ExecDeathTestArgs args = { argv, close_fd };
pid_t child_pid = -1;
# if GTEST_OS_QNX
// Obtains the current directory and sets it to be closed in the child
// process.
const int cwd_fd = open(".", O_RDONLY);
GTEST_DEATH_TEST_CHECK_(cw... | pushq %rbx
subq $0x10, %rsp
leaq 0x133a09(%rip), %rdi # 0x153b40
callq 0x1fb50
testl %eax, %eax
je 0x20169
leaq 0xc(%rsp), %rdi
andl $0x0, (%rdi)
leaq 0xb(%rsp), %rbx
movq %rbx, %rsi
callq 0xea7ed
movb (%rbx), %al
movb %al, 0x1339db(%rip) # 0x153b38
leaq 0x1339dc(%rip), %rdi # 0x153b40
callq 0x1f350
addq $0x1... | /SNSystems[P]pstore/3rd_party/googletest/googletest/src/gtest-death-test.cc |
ChunkedSequenceResize_ThreeElementsDownToZero_Test::TestBody() | TEST (ChunkedSequenceResize, ThreeElementsDownToZero) {
cseq_int cs;
cs.emplace_back (37);
cs.emplace_back (41);
cs.emplace_back (43);
// Before: [ 37, 41 ] -> [ 43, _ ]
EXPECT_EQ (cs.chunks_size (), 2U);
// After: [ _, _ ]
cs.resize (0U);
EXPECT_EQ (cs.chunks_size (), 1U);
EXPEC... | pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x53bd2
leaq 0x20(%rsp), %rsi
movl $0x25, (%rsi)
movq %rbx, %rdi
callq 0x53fae
leaq 0x20(%rsp), %rsi
movl $0x29, (%rsi)
leaq 0x48(%rsp), %rdi
callq 0x53fae
leaq 0x20(%rsp), %rsi
movl $0x2b, (%rsi)
leaq 0x48(%rsp), %rdi
callq 0x53fae
movq... | /SNSystems[P]pstore/unittests/adt/test_chunked_sequence.cpp |
testing::AssertionResult testing::internal::PredicateFormatterFromMatcher<unsigned int>::operator()<unsigned long>(char const*, unsigned long const&) const | AssertionResult operator()(const char* value_text, const T& x) const {
// We convert matcher_ to a Matcher<const T&> *now* instead of
// when the PredicateFormatterFromMatcher object was constructed,
// as matcher_ may be polymorphic (e.g. NotNull()) and we won't
// know which type to instantiate it to ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x370, %rsp # imm = 0x370
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leaq 0x1d8(%rsp), %r15
movq %rax, (%r15)
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x59890
movq $0x0, 0x8(%r15)
leaq 0xf5753(%rip), %rax ... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/include/gmock/gmock-matchers.h |
testing::AssertionResult testing::internal::PredicateFormatterFromMatcher<testing::internal::ElementsAreMatcher<std::tuple<int, int, int>>>::operator()<pstore::chunked_sequence<int, 2ul, 4ul, 4ul>>(char const*, pstore::chunked_sequence<int, 2ul, 4ul, 4ul> const&) const | AssertionResult operator()(const char* value_text, const T& x) const {
// We convert matcher_ to a Matcher<const T&> *now* instead of
// when the PredicateFormatterFromMatcher object was constructed,
// as matcher_ may be polymorphic (e.g. NotNull()) and we won't
// know which type to instantiate it to ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x370, %rsp # imm = 0x370
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x5c478
leaq 0x1d8(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq 0xf539f(%rip), %rax # 0x149e50
movq %rax, (%rdx)
movq %r15, %rdi
movq... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/include/gmock/gmock-matchers.h |
pstore::chunked_sequence<int, 2ul, 4ul, 4ul>::iterator_base<false> pstore::chunked_sequence<int, 2ul, 4ul, 4ul>::end_impl<pstore::chunked_sequence<int, 2ul, 4ul, 4ul>, pstore::chunked_sequence<int, 2ul, 4ul, 4ul>::iterator_base<false>>(pstore::chunked_sequence<int, 2ul, 4ul, 4ul>&) | Result chunked_sequence<T, ElementsPerChunk, ActualSize, ActualAlign>::end_impl (
ChunkedSequence & cv) noexcept {
// We always have at least 1 chunk. If the container is empty then return the begin iterator
// otherwise an iterator referencing end and of the last member of the last chunk.
... | pushq %rax
cmpq $0x0, 0x10(%rsi)
je 0x55f1c
cmpq $0x0, 0x18(%rsi)
jne 0x55f0c
movq (%rsi), %rsi
movq %rsi, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdi, %rax
popq %rcx
retq
leaq 0xa69ae(%rip), %rdi # 0xfc8d1
leaq 0xa65e8(%rip), %rsi # 0xfc512
movl $0x13f, %edx # imm = 0x13F
callq 0xfb0b4
movq %rax, %rdi
cal... | /SNSystems[P]pstore/include/pstore/adt/chunked_sequence.hpp |
void testing::internal::ContainerPrinter::PrintValue<pstore::chunked_sequence<int, 2ul, 4ul, 4ul>, void>(pstore::chunked_sequence<int, 2ul, 4ul, 4ul> const&, std::ostream*) | static void PrintValue(const T& container, std::ostream* os) {
const size_t kMaxCount = 32; // The maximum number of elements to print.
*os << '{';
size_t count = 0;
for (auto&& elem : container) {
if (count > 0) {
*os << ',';
if (count == kMaxCount) { // Enough has been printed.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x5(%rsp), %rsi
movb $0x7b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1f660
movq %r12, %rdi
callq 0x59138
movq %rax, %r14
movq %rdx, %r15
movq %r12, %rdi
callq 0x59172
movq %r14, %rsi
movq %rax, ... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/gtest-printers.h |
testing::internal::MatcherBase<unsigned long const&>::~MatcherBase() | ~MatcherBase() override { Destroy(); } | pushq %rax
leaq 0xf090a(%rip), %rax # 0x14a168
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x59885
cmpq $0x0, 0x18(%rax)
je 0x59885
movq 0x10(%rdi), %rax
lock
decl (%rax)
jne 0x59885
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
callq *0x18(%rax)
popq %rax
retq
movq %rax, %rdi
callq 0x553c6
nop
| /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/gtest-matchers.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<int>(int const&) | std::string StreamableToString(const T& streamable) {
return (Message() << streamable).GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xcda52
movq (%r15), %rdi
addq $0x10, %rdi
movl (%r14), %esi
callq 0x1faa0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xcdcb6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5b20b
movq (%rdi), %rax
ca... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/gtest-message.h |
PointerBasedIterator_PostIncrement_Test::~PointerBasedIterator_PostIncrement_Test() | TEST_F (PointerBasedIterator, PostIncrement) {
std::array<int, 2> arr{{1, 3}};
iterator i{&arr[0]};
EXPECT_EQ (*i, 1);
EXPECT_EQ (i++, iterator{&arr[0]});
EXPECT_EQ (*i, 3);
EXPECT_EQ (i++, iterator{&arr[1]});
EXPECT_EQ (i, iterator{&arr[0] + 2});
} | pushq %rbx
movq %rdi, %rbx
callq 0xd140a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1f570
nop
| /SNSystems[P]pstore/unittests/adt/test_pointer_based_iterator.cpp |
PointerBasedIterator_PreDecrement_Test::~PointerBasedIterator_PreDecrement_Test() | TEST_F (PointerBasedIterator, PreDecrement) {
std::array<int, 3> arr{{1, 3, 5}};
iterator i{&arr[0] + 3};
EXPECT_EQ (--i, iterator{&arr[2]});
EXPECT_EQ (*i, 5);
EXPECT_EQ (--i, iterator{&arr[1]});
EXPECT_EQ (*i, 3);
} | pushq %rbx
movq %rdi, %rbx
callq 0xd140a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1f570
nop
| /SNSystems[P]pstore/unittests/adt/test_pointer_based_iterator.cpp |
PointerBasedIterator_PostDecrement_Test::~PointerBasedIterator_PostDecrement_Test() | TEST_F (PointerBasedIterator, PostDecrement) {
std::array<int, 3> arr{{1, 3, 5}};
iterator i{&arr[0] + 3};
EXPECT_EQ (i--, iterator{&arr[0] + 3});
EXPECT_EQ (*i, 5);
EXPECT_EQ (i--, iterator{&arr[2]});
EXPECT_EQ (*i, 3);
} | pushq %rbx
movq %rdi, %rbx
callq 0xd140a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1f570
nop
| /SNSystems[P]pstore/unittests/adt/test_pointer_based_iterator.cpp |
PointerBasedIterator_TotalOrder_Test::~PointerBasedIterator_TotalOrder_Test() | TEST_F (PointerBasedIterator, TotalOrder) {
std::array<int, 2> arr{{1, 3}};
iterator b{&arr[0] + 2};
iterator a{&arr[0]};
EXPECT_TRUE (b > a);
EXPECT_TRUE (b >= a);
EXPECT_FALSE (b < a);
EXPECT_FALSE (b <= a);
EXPECT_FALSE (b == a);
EXPECT_TRUE (b != a);
// Comparing const- and ... | pushq %rbx
movq %rdi, %rbx
callq 0xd140a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1f570
nop
| /SNSystems[P]pstore/unittests/adt/test_pointer_based_iterator.cpp |
PointerBasedIterator_Assign_Test::~PointerBasedIterator_Assign_Test() | TEST_F (PointerBasedIterator, Assign) {
std::array<int, 2> arr{{3, 5}};
iterator b{&arr[0] + 2};
iterator a{&arr[0]};
b = a;
EXPECT_EQ (b, a);
std::array<int const, 2> const carr{{7, 11}};
const_iterator c{&carr[0]};
c = a;
EXPECT_EQ (c, a);
} | pushq %rbx
movq %rdi, %rbx
callq 0xd140a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1f570
nop
| /SNSystems[P]pstore/unittests/adt/test_pointer_based_iterator.cpp |
testing::AssertionResult testing::internal::CmpHelperEQFailure<pstore::pointer_based_iterator<int const>, pstore::pointer_based_iterator<int>>(char const*, char const*, pstore::pointer_based_iterator<int const> const&, pstore::pointer_based_iterator<int> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x63908
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x63786
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xor... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/gtest.h |
SmallVector_ExplicitCtorLessThanStackBuffer_Test::TestBody() | TEST (SmallVector, ExplicitCtorLessThanStackBuffer) {
pstore::small_vector<int, 8> const b (std::size_t{5});
EXPECT_EQ (5U, b.size ());
EXPECT_EQ (8U, b.capacity ());
EXPECT_EQ (5U * sizeof (int), b.size_bytes ());
} | pushq %rbx
subq $0x70, %rsp
movl $0x5, %eax
leaq 0x30(%rsp), %rcx
movq %rax, -0x8(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rcx)
movups %xmm0, (%rcx)
movups %xmm0, 0x10(%rcx)
movups %xmm0, 0x20(%rcx)
movq %rcx, 0x38(%rcx)
leaq 0x10(%rsp), %rcx
movl $0x5, (%rcx)
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x985af(%rip)... | /SNSystems[P]pstore/unittests/adt/test_small_vector.cpp |
SmallVector_ExplicitCtor0_Test::TestBody() | TEST (SmallVector, ElementAccess) {
pstore::small_vector<int, 4> buffer (std::size_t{4});
int count = 42;
for (std::size_t index = 0, end = buffer.size (); index != end; ++index) {
buffer[index] = count++;
}
std::array<int, 4> const expected{{42, 43, 44, 45}};
EXPECT_TRUE (std::equal (s... | pushq %r14
pushq %rbx
subq $0x88, %rsp
leaq 0x48(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x28(%rax)
movaps %xmm0, 0x18(%rax)
movaps %xmm0, 0x8(%rax)
movaps %xmm0, -0x8(%rax)
movq %rax, 0x38(%rax)
movq %rsp, %rcx
movl $0x0, (%rcx)
leaq 0x8(%rsp), %r8
movq $0x0, (%r8)
leaq 0x9ce01(%rip), %rsi # 0x100e19
leaq 0x9... | /SNSystems[P]pstore/unittests/adt/test_small_vector.cpp |
SmallVector_MoveCtor_Test::TestBody() | TEST (SmallVector, ElementAccess) {
pstore::small_vector<int, 4> buffer (std::size_t{4});
int count = 42;
for (std::size_t index = 0, end = buffer.size (); index != end; ++index) {
buffer[index] = count++;
}
std::array<int, 4> const expected{{42, 43, 44, 45}};
EXPECT_TRUE (std::equal (s... | pushq %rbx
subq $0xa0, %rsp
leaq 0x38(%rsp), %rax
movq $0x4, -0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq %rax, 0x28(%rax)
movl $0x10, %ecx
xorl %edx, %edx
movl %edx, 0x38(%rsp,%rdx,4)
incq %rdx
addq $-0x4, %rcx
jne 0x65010
leaq 0x70(%rsp), %rcx
movq $0x4, -0... | /SNSystems[P]pstore/unittests/adt/test_small_vector.cpp |
SmallVector_SizeAfterResizeSmaller_Test::TestBody() | TEST (SmallVector, ElementAccess) {
pstore::small_vector<int, 4> buffer (std::size_t{4});
int count = 42;
for (std::size_t index = 0, end = buffer.size (); index != end; ++index) {
buffer[index] = count++;
}
std::array<int, 4> const expected{{42, 43, 44, 45}};
EXPECT_TRUE (std::equal (s... | pushq %r14
pushq %rbx
subq $0x88, %rsp
leaq 0x48(%rsp), %rax
movq $0x8, -0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq %rax, 0x38(%rax)
leaq 0x40(%rsp), %rdi
movl $0x5, %esi
callq 0x69cb8
movq %rsp, %rcx
movl $0x5, (%rcx)
movq 0x40(%rsp... | /SNSystems[P]pstore/unittests/adt/test_small_vector.cpp |
pstore::small_vector<int, 8ul>::small_vector(std::initializer_list<int>) | small_vector<ElementType, BodyElements>::small_vector (std::initializer_list<ElementType> init)
: small_vector () {
this->reserve (init.size ());
std::copy (std::begin (init), std::end (init), std::back_inserter (*this));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rax, 0x40(%rdi)
leaq 0x28(%rdi), %r14
movq 0x38(%rdi), %ra... | /SNSystems[P]pstore/include/pstore/adt/small_vector.hpp |
testing::AssertionResult testing::internal::PredicateFormatterFromMatcher<testing::internal::ElementsAreMatcher<std::tuple<int, int>>>::operator()<pstore::small_vector<int, 3ul>>(char const*, pstore::small_vector<int, 3ul> const&) const | AssertionResult operator()(const char* value_text, const T& x) const {
// We convert matcher_ to a Matcher<const T&> *now* instead of
// when the PredicateFormatterFromMatcher object was constructed,
// as matcher_ may be polymorphic (e.g. NotNull()) and we won't
// know which type to instantiate it to ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x370, %rsp # imm = 0x370
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x6e706
leaq 0x1d8(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq 0xe0e63(%rip), %rax # 0x149e50
movq %rax, (%rdx)
movq %r15, %rdi
movq... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/include/gmock/gmock-matchers.h |
bool testing::internal::MatchPrintAndExplain<pstore::small_vector<int, 2ul> const, pstore::small_vector<int, 2ul> const&>(pstore::small_vector<int, 2ul> const&, testing::Matcher<pstore::small_vector<int, 2ul> const&> const&, testing::MatchResultListener*) | bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,
MatchResultListener* listener) {
if (!listener->IsInterested()) {
// If the listener is not interested, we do not need to construct the
// inner explanation.
return matcher.Matches(value);
}
StringMatchResult... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %r12
movq %rdi, %r15
cmpq $0x0, 0x8(%rdx)
je 0x6d410
movq %rdx, %r14
leaq 0x50(%rsp), %rbx
leaq 0x60(%rsp), %rax
movq %rax, -0x18(%rax)
leaq 0xdccb3(%rip), %r13 # 0x149f78
movq %r13, -0x20(%rax)
m... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/include/gmock/gmock-matchers.h |
testing::internal::TransformTupleValuesHelper<std::tuple<int, int, int, int, int, int, int, int>, testing::internal::CastAndAppendTransform<int const&>, std::back_insert_iterator<std::vector<testing::Matcher<int const&>, std::allocator<testing::Matcher<int const&>>>>>::IterateOverTuple<std::tuple<int, int, int, int, in... | OutIter operator() (Func f, const Tup& t, OutIter out) const {
*out++ = f(::std::get<TupleSize::value - kRemainingSize>(t));
return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
addq $0x4, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x56be0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56d40
leaq 0x8(%rsp), %rdi
callq 0x5699c
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7139e
addq $0x20, %rsp
popq %... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/include/gmock/gmock-matchers.h |
testing::internal::ElementsAreMatcher<std::tuple<int>>::operator testing::Matcher<pstore::small_vector<int, 2ul> const&><pstore::small_vector<int, 2ul> const&>() const | operator Matcher<Container>() const {
GTEST_COMPILE_ASSERT_(
!IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value ||
::std::tuple_size<MatcherTuple>::value < 2,
use_UnorderedElementsAre_with_hash_tables);
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x1, %esi
callq 0x56740
leaq 0xf(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
callq 0x59572
movl $0x20, %edi
callq 0x1f540
movq %rax, %r14
movq 0x10(%rsp)... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/include/gmock/gmock-matchers.h |
testing::internal::ElementsAreMatcher<std::tuple<int, int>>::operator testing::Matcher<pstore::small_vector<int, 2ul> const&><pstore::small_vector<int, 2ul> const&>() const | operator Matcher<Container>() const {
GTEST_COMPILE_ASSERT_(
!IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value ||
::std::tuple_size<MatcherTuple>::value < 2,
use_UnorderedElementsAre_with_hash_tables);
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x2, %esi
callq 0x56740
leaq 0xf(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
callq 0x58740
movl $0x20, %edi
callq 0x1f540
movq %rax, %r14
movq 0x10(%rsp)... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/include/gmock/gmock-matchers.h |
testing::internal::ElementsAreMatcher<std::tuple<int, int, int>>::operator testing::Matcher<pstore::small_vector<int, 2ul> const&><pstore::small_vector<int, 2ul> const&>() const | operator Matcher<Container>() const {
GTEST_COMPILE_ASSERT_(
!IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value ||
::std::tuple_size<MatcherTuple>::value < 2,
use_UnorderedElementsAre_with_hash_tables);
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x3, %esi
callq 0x56740
leaq 0xf(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
callq 0x56b18
movl $0x20, %edi
callq 0x1f540
movq %rax, %r14
movq 0x10(%rsp)... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/include/gmock/gmock-matchers.h |
pstore::small_vector<int, 1ul>::switch_to_big(unsigned long) | void small_vector<ElementType, BodyElements>::switch_to_big (std::size_t new_elements) {
big_buffer_.clear ();
big_buffer_.reserve (new_elements);
std::copy (buffer_, buffer_ + elements_, std::back_inserter (big_buffer_));
this->set_buffer_ptr (new_elements);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x72951
movq %rax, 0x18(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x6bfe4
movq (%rbx), %rax
movq 0x28(%rbx), %rdi
leaq (%rdi,%rax,4), %rsi
movq %r15, %rdx
callq 0x6c14a
cmpq $0x2, %r14... | /SNSystems[P]pstore/include/pstore/adt/small_vector.hpp |
pstore::small_vector<int, 4ul>::switch_to_big(unsigned long) | void small_vector<ElementType, BodyElements>::switch_to_big (std::size_t new_elements) {
big_buffer_.clear ();
big_buffer_.reserve (new_elements);
std::copy (buffer_, buffer_ + elements_, std::back_inserter (big_buffer_));
this->set_buffer_ptr (new_elements);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq 0x18(%rdi), %rax
cmpq %rax, 0x20(%rdi)
je 0x729db
movq %rax, 0x20(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x6bfe4
movq (%rbx), %rax
movq 0x30(%rbx), %rdi
leaq (%rdi,%rax,4), %rsi
movq %r15, %rdx
callq 0x6c14a
cmpq $0x5, %r14... | /SNSystems[P]pstore/include/pstore/adt/small_vector.hpp |
testing::internal::SuiteApiResolver<SparseArray_Assign_Test<pstore::uint128>>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0xc9a82
testb %al, %al
jne 0x7b111
leaq 0x816d5(%rip), %rdx # 0xfc736
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x211, %ecx # imm = 0x211
callq 0xe85c4
movq 0xd7f74(%rip), %rdi # 0x152ff0
leaq 0x8... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::SuiteApiResolver<SparseArray_Iterator_Test<unsigned int>>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0xc9a82
testb %al, %al
jne 0x89ffd
leaq 0x727e9(%rip), %rdx # 0xfc736
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x211, %ecx # imm = 0x211
callq 0xe85c4
movq 0xc9088(%rip), %rdi # 0x152ff0
leaq 0x7... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
std::unique_ptr<pstore::sparse_array<char const*, unsigned int>, std::default_delete<pstore::sparse_array<char const*, unsigned int>>> pstore::sparse_array<char const*, unsigned int>::make_unique<std::pair<unsigned long, char const*> const*>(std::pair<unsigned long, char const*> const*, std::pair<unsigned long, char co... | auto sparse_array<ValueType, BitmapType>::make_unique (Iterator begin, Iterator end)
-> std::unique_ptr<sparse_array> {
using details::get_accessor;
using details::pair_field_iterator;
auto const accessor0 = get_accessor<0U, Iterator> ();
auto const accessor1 = get_accessor<1U,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x8a630
popcntl %eax, %eax
leal 0x8(,%rax,8), %eax
movl $0x10, %edi
cmovnel %eax, %edi
callq 0x1f540
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r12, %rc... | /SNSystems[P]pstore/include/pstore/adt/sparse_array.hpp |
pstore::sparse_array<char const*, unsigned int>::sparse_array<pstore::details::pair_field_iterator<std::pair<unsigned long, char const*> const*, decltype(auto) pstore::details::get_accessor<0ul, std::pair<unsigned long, char const*> const*>()::'lambda'(std::pair<unsigned long, char const*> const*) const>, pstore::detai... | sparse_array<ValueType, BitmapType>::sparse_array (IteratorIdx first_index,
IteratorIdx last_index,
IteratorV first_value, IteratorV last_value)
: bitmap_{bitmap (first_index, last_index)} {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x8a630
movl %eax, (%r14)
cmpq %rbx, %r15
je 0x8a5c0
cmpq %r12, %r13
je 0x8a5bc
movq 0x8(%r13), %rax
addq $0x10, %r13
movq %rax, 0x8(%r14)
addq $0x1... | /SNSystems[P]pstore/include/pstore/adt/sparse_array.hpp |
unsigned long pstore::sparse_array<char const*, unsigned long>::bitmap<pstore::details::pair_field_iterator<std::pair<unsigned long, char const*> const*, decltype(auto) pstore::details::get_accessor<0ul, std::pair<unsigned long, char const*> const*>()::'lambda'(std::pair<unsigned long, char const*> const*) const>, void... | BitmapType sparse_array<ValueType, BitmapType>::bitmap (InputIterator first,
InputIterator last) {
return std::accumulate (
first, last, BitmapType{0U},
[] (BitmapType const mm, typename std::iterator_traits<InputIterator>::valu... | pushq %rax
xorl %eax, %eax
cmpq %rsi, %rdi
je 0x8adc0
movq (%rdi), %rcx
cmpq $0x40, %rcx
jae 0x8adda
movl $0x1, %edx
shlq %cl, %rdx
btq %rcx, %rax
jb 0x8adc2
orq %rdx, %rax
addq $0x10, %rdi
jmp 0x8ad9b
popq %rcx
retq
leaq 0x75fbb(%rip), %rdi # 0x100d84
leaq 0x75f4b(%rip), %rsi # 0x100d1b
movl $0x25d, %edx ... | /SNSystems[P]pstore/include/pstore/adt/sparse_array.hpp |
testing::internal::SuiteApiResolver<SparseArray_Iterator_Test<pstore::uint128>>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0xc9a82
testb %al, %al
jne 0x8aec9
leaq 0x7191d(%rip), %rdx # 0xfc736
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x211, %ecx # imm = 0x211
callq 0xe85c4
movq 0xc81bc(%rip), %rdi # 0x152ff0
leaq 0x7... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
pstore::sparse_array<char const*, pstore::uint128>::sparse_array<pstore::details::pair_field_iterator<std::pair<unsigned long, char const*> const*, decltype(auto) pstore::details::get_accessor<0ul, std::pair<unsigned long, char const*> const*>()::'lambda'(std::pair<unsigned long, char const*> const*) const>, pstore::de... | sparse_array<ValueType, BitmapType>::sparse_array (IteratorIdx first_index,
IteratorIdx last_index,
IteratorV first_value, IteratorV last_value)
: bitmap_{bitmap (first_index, last_index)} {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x8b512
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
cmpq %rbx, %r15
je 0x8b4a2
cmpq %r12, %r13
je 0x8b49e
movq 0x8(%r13), %rax
addq $0x10, %r13
movq %rax... | /SNSystems[P]pstore/include/pstore/adt/sparse_array.hpp |
testing::internal::SuiteApiResolver<SparseArray_ReverseIterator_Test<unsigned short>>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0xc9a82
testb %al, %al
jne 0x8b69b
leaq 0x7114b(%rip), %rdx # 0xfc736
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x211, %ecx # imm = 0x211
callq 0xe85c4
movq 0xc79ea(%rip), %rdi # 0x152ff0
leaq 0x7... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
SparseArray_ReverseIterator_Test<unsigned short>::TestBody() | TYPED_TEST (SparseArray, ReverseIterator) {
auto arr =
sparse_array<char const *, TypeParam>::make_unique ({{0, "zero"}, {2, "two"}, {4, "four"}});
std::vector<std::string> actual;
std::copy (arr->crbegin (), arr->crend (), std::back_inserter (actual));
std::vector<std::string> const expected{... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
xorl %r12d, %r12d
leaq 0x68(%rsp), %rbx
movq %r12, -0x30(%rbx)
leaq 0x75770(%rip), %rax # 0x100fad
movq %rax, -0x28(%rbx)
movq $0x2, -0x20(%rbx)
leaq 0x75762(%rip), %rax # 0x100fb2
movq %rax, -0x18(%rbx)
movq $0x4, -0x10(%rbx)
leaq 0x75753(%rip), %rax... | /SNSystems[P]pstore/unittests/adt/test_sparse_array.cpp |
SparseArray_ReverseIterator_Test<unsigned long>::~SparseArray_ReverseIterator_Test() | TYPED_TEST (SparseArray, ReverseIterator) {
auto arr =
sparse_array<char const *, TypeParam>::make_unique ({{0, "zero"}, {2, "two"}, {4, "four"}});
std::vector<std::string> actual;
std::copy (arr->crbegin (), arr->crend (), std::back_inserter (actual));
std::vector<std::string> const expected{... | pushq %rbx
movq %rdi, %rbx
callq 0xd140a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1f570
nop
| /SNSystems[P]pstore/unittests/adt/test_sparse_array.cpp |
SparseArray_ReverseIterator_Test<pstore::uint128>::~SparseArray_ReverseIterator_Test() | TYPED_TEST (SparseArray, ReverseIterator) {
auto arr =
sparse_array<char const *, TypeParam>::make_unique ({{0, "zero"}, {2, "two"}, {4, "four"}});
std::vector<std::string> actual;
std::copy (arr->crbegin (), arr->crend (), std::back_inserter (actual));
std::vector<std::string> const expected{... | pushq %rbx
movq %rdi, %rbx
callq 0xd140a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1f570
nop
| /SNSystems[P]pstore/unittests/adt/test_sparse_array.cpp |
SparseArray_ReverseIterator_Test<pstore::uint128>::TestBody() | TYPED_TEST (SparseArray, ReverseIterator) {
auto arr =
sparse_array<char const *, TypeParam>::make_unique ({{0, "zero"}, {2, "two"}, {4, "four"}});
std::vector<std::string> actual;
std::copy (arr->crbegin (), arr->crend (), std::back_inserter (actual));
std::vector<std::string> const expected{... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
xorl %r12d, %r12d
leaq 0x68(%rsp), %rbx
movq %r12, -0x30(%rbx)
leaq 0x744ac(%rip), %rax # 0x100fad
movq %rax, -0x28(%rbx)
movq $0x2, -0x20(%rbx)
leaq 0x7449e(%rip), %rax # 0x100fb2
movq %rax, -0x18(%rbx)
movq $0x4, -0x10(%rbx)
leaq 0x7448f(%rip), %rax... | /SNSystems[P]pstore/unittests/adt/test_sparse_array.cpp |
testing::internal::SuiteApiResolver<SparseArray_Fill_Test<unsigned short>>::GetTearDownCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0xc9a82
testb %al, %al
jne 0x8d069
leaq 0x6f77d(%rip), %rdx # 0xfc736
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x226, %ecx # imm = 0x226
callq 0xe85c4
movq 0xc601c(%rip), %rdi # 0x152ff0
leaq 0x6... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
std::unique_ptr<pstore::sparse_array<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned short>, std::default_delete<pstore::sparse_array<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned short>>> pstore::sparse_array<std::__cxx11::basic_string... | auto sparse_array<ValueType, BitmapType>::make_unique (Iterator begin, Iterator end)
-> std::unique_ptr<sparse_array> {
using details::get_accessor;
using details::pair_field_iterator;
auto const accessor0 = get_accessor<0U, Iterator> ();
auto const accessor1 = get_accessor<1U,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x8d7bc
movzwl %ax, %eax
popcntl %eax, %ecx
shll $0x5, %ecx
orl $0x8, %ecx
testw %ax, %ax
movl $0x28, %edi
cmovnel %ecx, %edi
callq 0x1f540
movq %rax, %r12
movq %rax, %rdi
movq %r... | /SNSystems[P]pstore/include/pstore/adt/sparse_array.hpp |
SparseArray_Fill_Test<unsigned int>::~SparseArray_Fill_Test() | TYPED_TEST (SparseArray, Fill) {
auto arr =
sparse_array<std::string, TypeParam>::make_unique ({{0, "zero"}, {2, "two"}, {4, "four"}});
arr->fill ("foo");
std::vector<std::string> actual;
std::copy (std::begin (*arr), std::end (*arr), std::back_inserter (actual));
std::vector<std::string> c... | pushq %rbx
movq %rdi, %rbx
callq 0xd140a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1f570
nop
| /SNSystems[P]pstore/unittests/adt/test_sparse_array.cpp |
SparseArray_Equal_Test<unsigned int>::TestBody() | TYPED_TEST (SparseArray, Equal) {
auto arr1 = sparse_array<int, TypeParam>::make_unique ({{0, 0}, {2, 2}, {4, 4}});
auto arr2 = sparse_array<int, TypeParam>::make_unique ({{0, 0}, {2, 2}, {4, 4}});
EXPECT_TRUE (*arr1 == *arr2);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
xorl %r14d, %r14d
leaq 0x68(%rsp), %rdx
movq %r14, -0x30(%rdx)
movl %r14d, -0x28(%rdx)
movl $0x2, %r15d
movq %r15, -0x20(%rdx)
movl $0x2, %ebp
movl %ebp, -0x18(%rdx)
movl $0x4, %r12d
movq %r12, -0x10(%rdx)
movl $0x4, %r13d
movl %r13d, -0... | /SNSystems[P]pstore/unittests/adt/test_sparse_array.cpp |
pstore::sparse_array<int, unsigned int>::sparse_array<pstore::details::pair_field_iterator<std::pair<unsigned long, int> const*, decltype(auto) pstore::details::get_accessor<0ul, std::pair<unsigned long, int> const*>()::'lambda'(std::pair<unsigned long, int> const*) const>, pstore::details::pair_field_iterator<std::pai... | sparse_array<ValueType, BitmapType>::sparse_array (IteratorIdx first_index,
IteratorIdx last_index,
IteratorV first_value, IteratorV last_value)
: bitmap_{bitmap (first_index, last_index)} {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x902da
movl %eax, (%r14)
cmpq %rbx, %r15
je 0x9026a
cmpq %r12, %r13
je 0x90266
movl 0x8(%r13), %eax
addq $0x10, %r13
movl %eax, 0x4(%r14)
addq $0x1... | /SNSystems[P]pstore/include/pstore/adt/sparse_array.hpp |
unsigned int pstore::sparse_array<int, unsigned int>::bitmap<pstore::details::pair_field_iterator<std::pair<unsigned long, int> const*, decltype(auto) pstore::details::get_accessor<0ul, std::pair<unsigned long, int> const*>()::'lambda'(std::pair<unsigned long, int> const*) const>, void>(pstore::details::pair_field_iter... | BitmapType sparse_array<ValueType, BitmapType>::bitmap (InputIterator first,
InputIterator last) {
return std::accumulate (
first, last, BitmapType{0U},
[] (BitmapType const mm, typename std::iterator_traits<InputIterator>::valu... | pushq %rax
xorl %eax, %eax
cmpq %rsi, %rdi
je 0x902ff
movq (%rdi), %rcx
cmpq $0x20, %rcx
jae 0x90319
movl $0x1, %edx
shll %cl, %edx
btl %ecx, %eax
jb 0x90301
orl %edx, %eax
addq $0x10, %rdi
jmp 0x902dd
popq %rcx
retq
leaq 0x70a7c(%rip), %rdi # 0x100d84
leaq 0x70a0c(%rip), %rsi # 0x100d1b
movl $0x25d, %edx ... | /SNSystems[P]pstore/include/pstore/adt/sparse_array.hpp |
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.