name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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(), last_sep + 1 - c_str());
} else {
dir = kCurrentDirectoryString;
}
return FilePath(dir);
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xa35b0
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x729b0
cmpq $0x0, -0x18(%rbp)
je 0x97223
movq -0x70(%rbp), %rdi
callq 0xac470
movq %rax, -0x88(%rbp)
jmp 0x97175
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rax
incq %rax
movq %rax, -0x98(%rbp)
callq 0xac470
movq %rax, -0x90(%rbp)
jmp 0x97195
movq -0x90(%rbp), %rcx
movq -0x98(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xa8(%rbp)
leaq -0x65(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x72c70
movq -0x88(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xa0(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0x72740
jmp 0x971dd
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x72830
leaq -0x58(%rbp), %rdi
callq 0x72de8
leaq -0x65(%rbp), %rdi
callq 0x726b0
jmp 0x97237
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x9725c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x65(%rbp), %rdi
callq 0x726b0
jmp 0x9725c
leaq 0x3e3ac(%rip), %rsi # 0xd55d6
leaq -0x38(%rbp), %rdi
callq 0x72980
jmp 0x97235
jmp 0x97237
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa6cf0
jmp 0x97246
leaq -0x38(%rbp), %rdi
callq 0x72de8
movq -0x78(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x72de8
movq -0x60(%rbp), %rdi
callq 0x72c60
nop
| /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest-filepath.cc |
testing::Message& testing::Message::operator<<<char [6]>(char const (&) [6]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the global
// namespace, but not other namespaces, including the testing
// namespace which Google Test's Message class is in.
//
// To allow STL containers (and other types that has a << operator
// defined in the global namespace) to be used in Google Test
// assertions, testing::Message must access the custom << operator
// from the global namespace. With this using declaration,
// overloads of << defined in the global namespace and those
// visible via Koenig lookup are both exposed in this function.
using ::operator <<;
*ss_ << val;
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xa7570
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x725c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /DanRuta[P]webassembly-workflow/test/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [31]>(char const (&) [31]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the global
// namespace, but not other namespaces, including the testing
// namespace which Google Test's Message class is in.
//
// To allow STL containers (and other types that has a << operator
// defined in the global namespace) to be used in Google Test
// assertions, testing::Message must access the custom << operator
// from the global namespace. With this using declaration,
// overloads of << defined in the global namespace and those
// visible via Koenig lookup are both exposed in this function.
using ::operator <<;
*ss_ << val;
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xa7570
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x725c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /DanRuta[P]webassembly-workflow/test/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::ParameterizedTestCaseRegistry::RegisterTests() | void RegisterTests() {
for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
it != test_case_infos_.end(); ++it) {
(*it)->RegisterTests();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xb2b60
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb2bd0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xb2b90
testb $0x1, %al
jne 0xaa66d
jmp 0xaa68a
leaq -0x10(%rbp), %rdi
callq 0xb2c00
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq -0x10(%rbp), %rdi
callq 0xb2c20
jmp 0xaa64d
addq $0x20, %rsp
popq %rbp
retq
| /DanRuta[P]webassembly-workflow/test/googletest/googletest/include/gtest/internal/gtest-param-util.h |
testing::internal::StreamingListener::OnTestCaseEnd(testing::TestCase const&) | void OnTestCaseEnd(const TestCase& test_case) {
SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed())
+ "&elapsed_time=" + StreamableToString(test_case.elapsed_time())
+ "ms");
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rdi
callq 0xafd90
movq -0xf8(%rbp), %rsi
movzbl %al, %edx
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0xb4970
movq -0xf0(%rbp), %rdx
leaq 0x23bdc(%rip), %rsi # 0xd7c7e
leaq -0x90(%rbp), %rdi
callq 0xa9070
jmp 0xb40b0
leaq 0x23bb5(%rip), %rdx # 0xd7c6c
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x81190
jmp 0xb40c9
movq -0x10(%rbp), %rdi
callq 0xab3b0
movq %rax, -0xe8(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0xab310
jmp 0xb40ee
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0xab8c0
jmp 0xb4104
leaq 0x23b70(%rip), %rdx # 0xd7c7b
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x81190
jmp 0xb411a
movq -0xf8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb4850
jmp 0xb412c
leaq -0x30(%rbp), %rdi
callq 0x72de8
leaq -0x50(%rbp), %rdi
callq 0x72de8
leaq -0xe0(%rbp), %rdi
callq 0x72de8
leaq -0x70(%rbp), %rdi
callq 0x72de8
leaq -0x90(%rbp), %rdi
callq 0x72de8
leaq -0xb0(%rbp), %rdi
callq 0x72de8
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xb4220
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xb4214
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xb420b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xb41ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xb41f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x72de8
leaq -0x50(%rbp), %rdi
callq 0x72de8
leaq -0xe0(%rbp), %rdi
callq 0x72de8
leaq -0x70(%rbp), %rdi
callq 0x72de8
leaq -0x90(%rbp), %rdi
callq 0x72de8
leaq -0xb0(%rbp), %rdi
callq 0x72de8
movq -0xb8(%rbp), %rdi
callq 0x72c60
nopl (%rax,%rax)
| /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StripTrailingSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline std::string StripTrailingSpaces(std::string str) {
std::string::iterator it = str.end();
while (it != str.begin() && IsSpace(*--it))
it = str.erase(it);
return str;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x72360
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rdi
callq 0x72520
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xb62a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0xb6077
jmp 0xb6093
leaq -0x18(%rbp), %rdi
callq 0xb62e0
movq %rax, %rdi
callq 0xb6300
movsbl (%rax), %edi
callq 0xb6270
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0xb609c
jmp 0xb60c4
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xb6320
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x72850
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xb604f
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x72370
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /DanRuta[P]webassembly-workflow/test/googletest/googletest/include/gtest/internal/gtest-port.h |
FIX::FieldMap::calculateString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const | std::string& FieldMap::calculateString( std::string& result ) const
{
Fields::const_iterator i;
for ( i = m_fields.begin(); i != m_fields.end(); ++i )
{
result += i->getFixString();
// add groups if they exist
if( !m_groups.size() ) continue;
Groups::const_iterator j = m_groups.find( i->getTag() );
if ( j == m_groups.end() ) continue;
std::vector < FieldMap* > ::const_iterator k;
for ( k = j->second.begin(); k != j->second.end(); ++k )
( *k ) ->calculateString( result );
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %r15
cmpq 0x10(%rdi), %r15
je 0x6dcf8
movq %rdi, %r14
leaq 0x28(%rdi), %r12
cmpq $0x0, 0x38(%r15)
jne 0x6dc76
leaq 0x30(%r15), %rsi
movq %r15, %rdi
callq 0x4ec70
movq 0x30(%r15), %rsi
movq 0x38(%r15), %rdx
movq %rbx, %rdi
callq 0x4aab0
cmpq $0x0, 0x48(%r14)
je 0x6dcea
movl 0x8(%r15), %eax
movq 0x30(%r14), %rdx
movq %r12, %rcx
testq %rdx, %rdx
je 0x6dcb7
movq %r12, %rcx
xorl %esi, %esi
cmpl %eax, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x6dca0
movq %r12, %r13
cmpq %r12, %rcx
je 0x6dcc9
cmpl 0x20(%rcx), %eax
cmovlq %r12, %rcx
movq %rcx, %r13
cmpq %r12, %r13
je 0x6dcea
movq 0x28(%r13), %rbp
cmpq 0x30(%r13), %rbp
je 0x6dcea
movq (%rbp), %rdi
movq %rbx, %rsi
callq 0x4ec50
addq $0x8, %rbp
jmp 0x6dcd2
addq $0x60, %r15
cmpq 0x10(%r14), %r15
jne 0x6dc63
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /marlowa[P]quickfix/src/C++/FieldMap.cpp |
FIX::FieldMap::calculateLength(int, int, int) const | int FieldMap::calculateLength( int beginStringField,
int bodyLengthField,
int checkSumField ) const
{
int result = 0;
Fields::const_iterator i;
for ( i = m_fields.begin(); i != m_fields.end(); ++i )
{
int tag = i->getTag();
if ( tag != beginStringField
&& tag != bodyLengthField
&& tag != checkSumField )
{ result += i->getLength(); }
}
Groups::const_iterator j;
for ( j = m_groups.begin(); j != m_groups.end(); ++j )
{
std::vector < FieldMap* > ::const_iterator k;
for ( k = j->second.begin(); k != j->second.end(); ++k )
result += ( *k ) ->calculateLength();
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r13
cmpq 0x10(%rdi), %r13
je 0x6dd58
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
xorl %ebp, %ebp
movl 0x8(%r13), %eax
cmpl %r14d, %eax
je 0x6dd4c
cmpl %r12d, %eax
je 0x6dd4c
cmpl %r15d, %eax
je 0x6dd4c
movq %r13, %rdi
callq 0x4e580
addl 0x50(%r13), %ebp
addq $0x60, %r13
cmpq 0x10(%rbx), %r13
jne 0x6dd2d
jmp 0x6dd5a
xorl %ebp, %ebp
movq 0x38(%rbx), %r14
addq $0x28, %rbx
cmpq %rbx, %r14
je 0x6dda0
movq 0x28(%r14), %r15
cmpq 0x30(%r14), %r15
je 0x6dd90
movq (%r15), %rdi
movl $0x8, %esi
movl $0x9, %edx
movl $0xa, %ecx
callq 0x4cfd0
addl %eax, %ebp
addq $0x8, %r15
jmp 0x6dd6b
movq %r14, %rdi
callq 0x4d010
movq %rax, %r14
cmpq %rbx, %rax
jne 0x6dd67
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /marlowa[P]quickfix/src/C++/FieldMap.cpp |
FIX::FieldMap::calculateTotal(int) const | int FieldMap::calculateTotal( int checkSumField ) const
{
int result = 0;
Fields::const_iterator i;
for ( i = m_fields.begin(); i != m_fields.end(); ++i )
{
if ( i->getTag() != checkSumField )
result += i->getTotal();
}
Groups::const_iterator j;
for ( j = m_groups.begin(); j != m_groups.end(); ++j )
{
std::vector < FieldMap* > ::const_iterator k;
for ( k = j->second.begin(); k != j->second.end(); ++k )
result += ( *k ) ->calculateTotal();
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r15
cmpq 0x10(%rdi), %r15
je 0x6dde9
movl %esi, %r14d
xorl %ebp, %ebp
cmpl %r14d, 0x8(%r15)
je 0x6dddd
movq %r15, %rdi
callq 0x4e580
addl 0x58(%r15), %ebp
addq $0x60, %r15
cmpq 0x10(%rbx), %r15
jne 0x6ddcb
jmp 0x6ddeb
xorl %ebp, %ebp
movq 0x38(%rbx), %r14
addq $0x28, %rbx
cmpq %rbx, %r14
je 0x6de27
movq 0x28(%r14), %r15
cmpq 0x30(%r14), %r15
je 0x6de17
movq (%r15), %rdi
movl $0xa, %esi
callq 0x4ef50
addl %eax, %ebp
addq $0x8, %r15
jmp 0x6ddfc
movq %r14, %rdi
callq 0x4d010
movq %rax, %r14
cmpq %rbx, %rax
jne 0x6ddf8
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /marlowa[P]quickfix/src/C++/FieldMap.cpp |
FIX::FieldMap::setField(FIX::FieldBase const&, bool) | void setField( const FieldBase& field, bool overwrite = true )
EXCEPT ( RepeatedTag )
{
if( !overwrite )
{
addField( field );
}
else
{
Fields::iterator i = findTag( field.getTag() );
if( i == m_fields.end() )
{
addField( field );
}
else
{
i->setString( field.getString() );
}
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x6e0fb
movl 0x8(%rbx), %ecx
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r14, %rdi
callq 0x4d890
cmpq 0x10(%r14), %rax
je 0x6e0fb
movq %rax, %r15
addq $0x10, %rbx
movq %rax, %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x4b430
xorl %eax, %eax
movq %rax, 0x50(%r15)
movl $0x0, 0x58(%r15)
movq %rax, 0x38(%r15)
movq 0x30(%r15), %rax
movb $0x0, (%rax)
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4b420
nop
| /marlowa[P]quickfix/src/C++/FieldMap.h |
FIX::IntField::IntField(int, int) | explicit IntField( int field, int data )
: FieldBase( field, IntConvertor::convert( data ) ) {} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movl %edx, %esi
callq 0x4b1f0
movq 0x81b3b(%rip), %rax # 0xefc68
addq $0x10, %rax
movq %rax, (%rbx)
movl %ebp, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x4ae20
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
xorl %eax, %eax
movq %rax, 0x38(%rbx)
movb $0x0, 0x40(%rbx)
movq %rax, 0x50(%rbx)
movl $0x0, 0x58(%rbx)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e18a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4c970
movq 0x8195f(%rip), %rax # 0xefaf0
addq $0x10, %rax
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e1bf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4c970
movq %rbx, %rdi
callq 0x4e9e0
nop
| /marlowa[P]quickfix/src/C++/Field.h |
cgltf_parse | cgltf_result cgltf_parse(const cgltf_options* options, const void* data, cgltf_size size, cgltf_data** out_data)
{
if (size < GlbHeaderSize)
{
return cgltf_result_data_too_short;
}
if (options == NULL)
{
return cgltf_result_invalid_options;
}
cgltf_options fixed_options = *options;
if (fixed_options.memory.alloc == NULL)
{
fixed_options.memory.alloc = &cgltf_default_alloc;
}
if (fixed_options.memory.free == NULL)
{
fixed_options.memory.free = &cgltf_default_free;
}
uint32_t tmp;
// Magic
memcpy(&tmp, data, 4);
if (tmp != GlbMagic)
{
if (fixed_options.type == cgltf_file_type_invalid)
{
fixed_options.type = cgltf_file_type_gltf;
}
else if (fixed_options.type == cgltf_file_type_glb)
{
return cgltf_result_unknown_format;
}
}
if (fixed_options.type == cgltf_file_type_gltf)
{
cgltf_result json_result = cgltf_parse_json(&fixed_options, (const uint8_t*)data, size, out_data);
if (json_result != cgltf_result_success)
{
return json_result;
}
(*out_data)->file_type = cgltf_file_type_gltf;
return cgltf_result_success;
}
const uint8_t* ptr = (const uint8_t*)data;
// Version
memcpy(&tmp, ptr + 4, 4);
uint32_t version = tmp;
if (version != GlbVersion)
{
return version < GlbVersion ? cgltf_result_legacy_gltf : cgltf_result_unknown_format;
}
// Total length
memcpy(&tmp, ptr + 8, 4);
if (tmp > size)
{
return cgltf_result_data_too_short;
}
const uint8_t* json_chunk = ptr + GlbHeaderSize;
if (GlbHeaderSize + GlbChunkHeaderSize > size)
{
return cgltf_result_data_too_short;
}
// JSON chunk: length
uint32_t json_length;
memcpy(&json_length, json_chunk, 4);
if (GlbHeaderSize + GlbChunkHeaderSize + json_length > size)
{
return cgltf_result_data_too_short;
}
// JSON chunk: magic
memcpy(&tmp, json_chunk + 4, 4);
if (tmp != GlbMagicJsonChunk)
{
return cgltf_result_unknown_format;
}
json_chunk += GlbChunkHeaderSize;
const void* bin = 0;
cgltf_size bin_size = 0;
if (GlbHeaderSize + GlbChunkHeaderSize + json_length + GlbChunkHeaderSize <= size)
{
// We can read another chunk
const uint8_t* bin_chunk = json_chunk + json_length;
// Bin chunk: length
uint32_t bin_length;
memcpy(&bin_length, bin_chunk, 4);
if (GlbHeaderSize + GlbChunkHeaderSize + json_length + GlbChunkHeaderSize + bin_length > size)
{
return cgltf_result_data_too_short;
}
// Bin chunk: magic
memcpy(&tmp, bin_chunk + 4, 4);
if (tmp != GlbMagicBinChunk)
{
return cgltf_result_unknown_format;
}
bin_chunk += GlbChunkHeaderSize;
bin = bin_chunk;
bin_size = bin_length;
}
cgltf_result json_result = cgltf_parse_json(&fixed_options, json_chunk, json_length, out_data);
if (json_result != cgltf_result_success)
{
return json_result;
}
(*out_data)->file_type = cgltf_file_type_glb;
(*out_data)->bin = bin;
(*out_data)->bin_size = bin_size;
return cgltf_result_success;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0xc, -0x20(%rbp)
jae 0x95de
movl $0x1, -0x4(%rbp)
jmp 0x98c3
cmpq $0x0, -0x10(%rbp)
jne 0x95f1
movl $0x5, -0x4(%rbp)
jmp 0x98c3
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movl $0x40, %edx
callq 0x91c0
cmpq $0x0, -0x58(%rbp)
jne 0x9615
leaq 0x2bf(%rip), %rax # 0x98d0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x9627
leaq 0x2cd(%rip), %rax # 0x98f0
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
cmpl $0x46546c67, -0x6c(%rbp) # imm = 0x46546C67
je 0x965e
cmpl $0x0, -0x68(%rbp)
jne 0x9648
movl $0x1, -0x68(%rbp)
jmp 0x965c
cmpl $0x2, -0x68(%rbp)
jne 0x965a
movl $0x2, -0x4(%rbp)
jmp 0x98c3
jmp 0x965c
jmp 0x965e
cmpl $0x1, -0x68(%rbp)
jne 0x96a6
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x68(%rbp), %rdi
callq 0x9910
movl %eax, -0x70(%rbp)
cmpl $0x0, -0x70(%rbp)
je 0x968d
movl -0x70(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x98c3
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x98c3
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x7c(%rbp)
cmpl $0x2, -0x7c(%rbp)
je 0x96df
movl -0x7c(%rbp), %edx
movl $0x2, %eax
movl $0x9, %ecx
cmpl $0x2, %edx
cmovbl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x98c3
movq -0x78(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
cmpq -0x20(%rbp), %rax
jbe 0x96fe
movl $0x1, -0x4(%rbp)
jmp 0x98c3
movq -0x78(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x88(%rbp)
movl $0x14, %eax
cmpq -0x20(%rbp), %rax
jbe 0x9724
movl $0x1, -0x4(%rbp)
jmp 0x98c3
movq -0x88(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
addq $0x14, %rax
cmpq -0x20(%rbp), %rax
jbe 0x974f
movl $0x1, -0x4(%rbp)
jmp 0x98c3
movq -0x88(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x6c(%rbp)
cmpl $0x4e4f534a, -0x6c(%rbp) # imm = 0x4E4F534A
je 0x9771
movl $0x2, -0x4(%rbp)
jmp 0x98c3
movq -0x88(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movq $0x0, -0x98(%rbp)
movq $0x0, -0xa0(%rbp)
movl -0x8c(%rbp), %eax
addq $0x14, %rax
addq $0x8, %rax
cmpq -0x20(%rbp), %rax
ja 0x984f
movq -0x88(%rbp), %rax
movl -0x8c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xac(%rbp)
movl -0x8c(%rbp), %eax
addq $0x14, %rax
addq $0x8, %rax
movl -0xac(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jbe 0x9800
movl $0x1, -0x4(%rbp)
jmp 0x98c3
movq -0xa8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x6c(%rbp)
cmpl $0x4e4942, -0x6c(%rbp) # imm = 0x4E4942
je 0x9822
movl $0x2, -0x4(%rbp)
jmp 0x98c3
movq -0xa8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0xac(%rbp), %eax
movq %rax, -0xa0(%rbp)
movq -0x88(%rbp), %rsi
movl -0x8c(%rbp), %eax
movl %eax, %edx
movq -0x28(%rbp), %rcx
leaq -0x68(%rbp), %rdi
callq 0x9910
movl %eax, -0xb0(%rbp)
cmpl $0x0, -0xb0(%rbp)
je 0x9885
movl -0xb0(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x98c3
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl $0x2, (%rax)
movq -0x98(%rbp), %rcx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x188(%rax)
movq -0xa0(%rbp), %rcx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x190(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
| /infosia[P]vrmpack/cgltf/cgltf.h |
cgltf_validate | cgltf_result cgltf_validate(cgltf_data* data)
{
for (cgltf_size i = 0; i < data->accessors_count; ++i)
{
cgltf_accessor* accessor = &data->accessors[i];
cgltf_size element_size = cgltf_calc_size(accessor->type, accessor->component_type);
if (accessor->buffer_view)
{
cgltf_size req_size = accessor->offset + accessor->stride * (accessor->count - 1) + element_size;
if (accessor->buffer_view->size < req_size)
{
return cgltf_result_data_too_short;
}
}
if (accessor->is_sparse)
{
cgltf_accessor_sparse* sparse = &accessor->sparse;
cgltf_size indices_component_size = cgltf_calc_size(cgltf_type_scalar, sparse->indices_component_type);
cgltf_size indices_req_size = sparse->indices_byte_offset + indices_component_size * sparse->count;
cgltf_size values_req_size = sparse->values_byte_offset + element_size * sparse->count;
if (sparse->indices_buffer_view->size < indices_req_size ||
sparse->values_buffer_view->size < values_req_size)
{
return cgltf_result_data_too_short;
}
if (sparse->indices_component_type != cgltf_component_type_r_8u &&
sparse->indices_component_type != cgltf_component_type_r_16u &&
sparse->indices_component_type != cgltf_component_type_r_32u)
{
return cgltf_result_invalid_gltf;
}
if (sparse->indices_buffer_view->buffer->data)
{
cgltf_size index_bound = cgltf_calc_index_bound(sparse->indices_buffer_view, sparse->indices_byte_offset, sparse->indices_component_type, sparse->count);
if (index_bound >= accessor->count)
{
return cgltf_result_data_too_short;
}
}
}
}
for (cgltf_size i = 0; i < data->buffer_views_count; ++i)
{
cgltf_size req_size = data->buffer_views[i].offset + data->buffer_views[i].size;
if (data->buffer_views[i].buffer && data->buffer_views[i].buffer->size < req_size)
{
return cgltf_result_data_too_short;
}
if (data->buffer_views[i].has_meshopt_compression)
{
cgltf_meshopt_compression* mc = &data->buffer_views[i].meshopt_compression;
if (mc->buffer == NULL || mc->buffer->size < mc->offset + mc->size)
{
return cgltf_result_data_too_short;
}
if (data->buffer_views[i].stride && mc->stride != data->buffer_views[i].stride)
{
return cgltf_result_invalid_gltf;
}
if (data->buffer_views[i].size != mc->stride * mc->count)
{
return cgltf_result_invalid_gltf;
}
if (mc->mode == cgltf_meshopt_compression_mode_invalid)
{
return cgltf_result_invalid_gltf;
}
if (mc->mode == cgltf_meshopt_compression_mode_attributes && !(mc->stride % 4 == 0 && mc->stride <= 256))
{
return cgltf_result_invalid_gltf;
}
if (mc->mode == cgltf_meshopt_compression_mode_triangles && mc->count % 3 != 0)
{
return cgltf_result_invalid_gltf;
}
if ((mc->mode == cgltf_meshopt_compression_mode_triangles || mc->mode == cgltf_meshopt_compression_mode_indices) && mc->stride != 2 && mc->stride != 4)
{
return cgltf_result_invalid_gltf;
}
if ((mc->mode == cgltf_meshopt_compression_mode_triangles || mc->mode == cgltf_meshopt_compression_mode_indices) && mc->filter != cgltf_meshopt_compression_filter_none)
{
return cgltf_result_invalid_gltf;
}
if (mc->filter == cgltf_meshopt_compression_filter_octahedral && mc->stride != 4 && mc->stride != 8)
{
return cgltf_result_invalid_gltf;
}
if (mc->filter == cgltf_meshopt_compression_filter_quaternion && mc->stride != 8)
{
return cgltf_result_invalid_gltf;
}
}
}
for (cgltf_size i = 0; i < data->meshes_count; ++i)
{
if (data->meshes[i].weights)
{
if (data->meshes[i].primitives_count && data->meshes[i].primitives[0].targets_count != data->meshes[i].weights_count)
{
return cgltf_result_invalid_gltf;
}
}
if (data->meshes[i].target_names)
{
if (data->meshes[i].primitives_count && data->meshes[i].primitives[0].targets_count != data->meshes[i].target_names_count)
{
return cgltf_result_invalid_gltf;
}
}
for (cgltf_size j = 0; j < data->meshes[i].primitives_count; ++j)
{
//
// Skip target count check because some VRM files omit targets for root primitive
// which is not valid for glTF but has been accepted for VRM
//
//if (data->meshes[i].primitives[j].targets_count != data->meshes[i].primitives[0].targets_count)
//{
// return cgltf_result_invalid_gltf;
//}
if (data->meshes[i].primitives[j].attributes_count)
{
cgltf_accessor* first = data->meshes[i].primitives[j].attributes[0].data;
if (first == NULL) continue;
for (cgltf_size k = 0; k < data->meshes[i].primitives[j].attributes_count; ++k)
{
cgltf_accessor* accessor = data->meshes[i].primitives[j].attributes[k].data;
if (accessor && accessor->count != first->count)
{
return cgltf_result_invalid_gltf;
}
}
for (cgltf_size k = 0; k < data->meshes[i].primitives[j].targets_count; ++k)
{
for (cgltf_size m = 0; m < data->meshes[i].primitives[j].targets[k].attributes_count; ++m)
{
cgltf_accessor* accessor = data->meshes[i].primitives[j].targets[k].attributes[m].data;
if (accessor && accessor->count != first->count)
{
return cgltf_result_invalid_gltf;
}
}
}
cgltf_accessor* indices = data->meshes[i].primitives[j].indices;
if (indices &&
indices->component_type != cgltf_component_type_r_8u &&
indices->component_type != cgltf_component_type_r_16u &&
indices->component_type != cgltf_component_type_r_32u)
{
return cgltf_result_invalid_gltf;
}
if (indices && indices->buffer_view && indices->buffer_view->buffer->data)
{
cgltf_size index_bound = cgltf_calc_index_bound(indices->buffer_view, indices->offset, indices->component_type, indices->count);
if (index_bound >= first->count)
{
return cgltf_result_data_too_short;
}
}
}
}
}
for (cgltf_size i = 0; i < data->nodes_count; ++i)
{
if (data->nodes[i].weights && data->nodes[i].mesh)
{
if (data->nodes[i].mesh->primitives_count && data->nodes[i].mesh->primitives[0].targets_count != data->nodes[i].weights_count)
{
return cgltf_result_invalid_gltf;
}
}
}
for (cgltf_size i = 0; i < data->nodes_count; ++i)
{
cgltf_node* p1 = data->nodes[i].parent;
cgltf_node* p2 = p1 ? p1->parent : NULL;
while (p1 && p2)
{
if (p1 == p2)
{
return cgltf_result_invalid_gltf;
}
p1 = p1->parent;
p2 = p2->parent ? p2->parent->parent : NULL;
}
}
for (cgltf_size i = 0; i < data->scenes_count; ++i)
{
for (cgltf_size j = 0; j < data->scenes[i].nodes_count; ++j)
{
if (data->scenes[i].nodes[j]->parent)
{
return cgltf_result_invalid_gltf;
}
}
}
for (cgltf_size i = 0; i < data->animations_count; ++i)
{
for (cgltf_size j = 0; j < data->animations[i].channels_count; ++j)
{
cgltf_animation_channel* channel = &data->animations[i].channels[j];
if (!channel->target_node)
{
continue;
}
cgltf_size components = 1;
if (channel->target_path == cgltf_animation_path_type_weights)
{
if (!channel->target_node->mesh || !channel->target_node->mesh->primitives_count)
{
return cgltf_result_invalid_gltf;
}
components = channel->target_node->mesh->primitives[0].targets_count;
}
cgltf_size values = channel->sampler->interpolation == cgltf_interpolation_type_cubic_spline ? 3 : 1;
if (channel->sampler->input->count * components * values != channel->sampler->output->count)
{
return cgltf_result_data_too_short;
}
}
}
return cgltf_result_success;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0xa81a
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
imulq $0x170, -0x18(%rbp), %rcx # imm = 0x170
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0xb400
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xa6ec
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq -0x20(%rbp), %rdx
movq 0x18(%rdx), %rdx
subq $0x1, %rdx
imulq %rdx, %rcx
addq %rcx, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x30(%rbp), %rax
jae 0xa6ea
movl $0x1, -0x4(%rbp)
jmp 0xb3f1
jmp 0xa6ec
movq -0x20(%rbp), %rax
cmpl $0x0, 0xb8(%rax)
je 0xa807
movq -0x20(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x18(%rax), %esi
movl $0x1, %edi
callq 0xb400
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
imulq (%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rdx
imulq (%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x48(%rbp), %rax
jb 0xa77a
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x50(%rbp), %rax
jae 0xa786
movl $0x1, -0x4(%rbp)
jmp 0xb3f1
movq -0x38(%rbp), %rax
cmpl $0x2, 0x18(%rax)
je 0xa7b0
movq -0x38(%rbp), %rax
cmpl $0x4, 0x18(%rax)
je 0xa7b0
movq -0x38(%rbp), %rax
cmpl $0x5, 0x18(%rax)
je 0xa7b0
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xa805
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x38(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x38(%rbp), %rax
movq (%rax), %rcx
callq 0xb480
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0xa803
movl $0x1, -0x4(%rbp)
jmp 0xb3f1
jmp 0xa805
jmp 0xa807
jmp 0xa809
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa657
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x88(%rcx), %rax
jae 0xaaf1
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
imulq $0x90, -0x60(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x80(%rcx), %rcx
imulq $0x90, -0x60(%rbp), %rdx
addq %rdx, %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
imulq $0x90, -0x60(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xa8b9
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
imulq $0x90, -0x60(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq (%rax), %rax
cmpq -0x68(%rbp), %rax
jae 0xa8b9
movl $0x1, -0x4(%rbp)
jmp 0xb3f1
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
imulq $0x90, -0x60(%rbp), %rcx
addq %rcx, %rax
cmpl $0x0, 0x30(%rax)
je 0xaade
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
imulq $0x90, -0x60(%rbp), %rcx
addq %rcx, %rax
addq $0x38, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa920
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x70(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x70(%rbp), %rdx
addq 0x10(%rdx), %rcx
cmpq %rcx, %rax
jae 0xa92c
movl $0x1, -0x4(%rbp)
jmp 0xb3f1
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
imulq $0x90, -0x60(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x18(%rax)
je 0xa979
movq -0x70(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x80(%rcx), %rcx
imulq $0x90, -0x60(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x18(%rcx), %rax
je 0xa979
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
imulq $0x90, -0x60(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq -0x70(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x70(%rbp), %rdx
imulq 0x20(%rdx), %rcx
cmpq %rcx, %rax
je 0xa9b5
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
movq -0x70(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0xa9cb
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
movq -0x70(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0xaa01
movq -0x70(%rbp), %rax
movq 0x18(%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0xa9f5
movq -0x70(%rbp), %rax
cmpq $0x100, 0x18(%rax) # imm = 0x100
jbe 0xaa01
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
movq -0x70(%rbp), %rax
cmpl $0x2, 0x28(%rax)
jne 0xaa2f
movq -0x70(%rbp), %rax
movq 0x20(%rax), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
je 0xaa2f
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
movq -0x70(%rbp), %rax
cmpl $0x2, 0x28(%rax)
je 0xaa43
movq -0x70(%rbp), %rax
cmpl $0x3, 0x28(%rax)
jne 0xaa65
movq -0x70(%rbp), %rax
cmpq $0x2, 0x18(%rax)
je 0xaa65
movq -0x70(%rbp), %rax
cmpq $0x4, 0x18(%rax)
je 0xaa65
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
movq -0x70(%rbp), %rax
cmpl $0x2, 0x28(%rax)
je 0xaa79
movq -0x70(%rbp), %rax
cmpl $0x3, 0x28(%rax)
jne 0xaa8f
movq -0x70(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0xaa8f
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
movq -0x70(%rbp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0xaabb
movq -0x70(%rbp), %rax
cmpq $0x4, 0x18(%rax)
je 0xaabb
movq -0x70(%rbp), %rax
cmpq $0x8, 0x18(%rax)
je 0xaabb
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
movq -0x70(%rbp), %rax
cmpl $0x2, 0x2c(%rax)
jne 0xaadc
movq -0x70(%rbp), %rax
cmpq $0x8, 0x18(%rax)
je 0xaadc
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
jmp 0xaade
jmp 0xaae0
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0xa822
movq $0x0, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jae 0xaf70
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
imulq $0x58, -0x78(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x18(%rax)
je 0xab75
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
imulq $0x58, -0x78(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0xab73
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
imulq $0x58, -0x78(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
imulq $0x58, -0x78(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x20(%rcx), %rax
je 0xab73
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
jmp 0xab75
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
imulq $0x58, -0x78(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x28(%rax)
je 0xabdf
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
imulq $0x58, -0x78(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0xabdd
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
imulq $0x58, -0x78(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
imulq $0x58, -0x78(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x30(%rcx), %rax
je 0xabdd
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
jmp 0xabdf
movq $0x0, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
imulq $0x58, -0x78(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x10(%rcx), %rax
jae 0xaf5d
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
imulq $0x58, -0x78(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
imulq $0x90, -0x80(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x20(%rax)
je 0xaf4a
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
imulq $0x58, -0x78(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
imulq $0x90, -0x80(%rbp), %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x88(%rbp)
jne 0xac6c
jmp 0xaf4c
movq $0x0, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
imulq $0x58, -0x78(%rbp), %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
imulq $0x90, -0x80(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x20(%rcx), %rax
jae 0xad2a
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
imulq $0x58, -0x78(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
imulq $0x90, -0x80(%rbp), %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq -0x90(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0xad11
movq -0x98(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x88(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0xad11
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
jmp 0xad13
movq -0x90(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
jmp 0xac77
movq $0x0, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
imulq $0x58, -0x78(%rbp), %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
imulq $0x90, -0x80(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x30(%rcx), %rax
jae 0xae5f
movq $0x0, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
imulq $0x58, -0x78(%rbp), %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
imulq $0x90, -0x80(%rbp), %rdx
addq %rdx, %rcx
movq 0x28(%rcx), %rcx
movq -0xa0(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jae 0xae46
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
imulq $0x58, -0x78(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
imulq $0x90, -0x80(%rbp), %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
movq -0xa0(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0xa8(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x0, -0xb0(%rbp)
je 0xae2d
movq -0xb0(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x88(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0xae2d
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
jmp 0xae2f
movq -0xa8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa8(%rbp)
jmp 0xad70
jmp 0xae48
movq -0xa0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
jmp 0xad35
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
imulq $0x58, -0x78(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
imulq $0x90, -0x80(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
je 0xaec3
movq -0xb8(%rbp), %rax
cmpl $0x2, (%rax)
je 0xaec3
movq -0xb8(%rbp), %rax
cmpl $0x4, (%rax)
je 0xaec3
movq -0xb8(%rbp), %rax
cmpl $0x5, (%rax)
je 0xaec3
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
cmpq $0x0, -0xb8(%rbp)
je 0xaf48
movq -0xb8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xaf48
movq -0xb8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xaf48
movq -0xb8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0xb8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0xb8(%rbp), %rax
movl (%rax), %edx
movq -0xb8(%rbp), %rax
movq 0x18(%rax), %rcx
callq 0xb480
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movq -0x88(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0xaf46
movl $0x1, -0x4(%rbp)
jmp 0xb3f1
jmp 0xaf48
jmp 0xaf4a
jmp 0xaf4c
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0xabe7
jmp 0xaf5f
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0xaaf9
movq $0x0, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x108(%rcx), %rax
jae 0xb066
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
imulq $0xf0, -0xc8(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x40(%rax)
je 0xb04d
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
imulq $0xf0, -0xc8(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x28(%rax)
je 0xb04d
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
imulq $0xf0, -0xc8(%rbp), %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xb04b
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
imulq $0xf0, -0xc8(%rbp), %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x100(%rcx), %rcx
imulq $0xf0, -0xc8(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x48(%rcx), %rax
je 0xb04b
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
jmp 0xb04d
jmp 0xb04f
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
jmp 0xaf7b
movq $0x0, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x108(%rcx), %rax
jae 0xb19e
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
imulq $0xf0, -0xd0(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0xd8(%rbp)
cmpq $0x0, -0xd8(%rbp)
je 0xb0cb
movq -0xd8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x120(%rbp)
jmp 0xb0d6
xorl %eax, %eax
movq %rax, -0x120(%rbp)
jmp 0xb0d6
movq -0x120(%rbp), %rax
movq %rax, -0xe0(%rbp)
xorl %eax, %eax
cmpq $0x0, -0xd8(%rbp)
movb %al, -0x121(%rbp)
je 0xb107
cmpq $0x0, -0xe0(%rbp)
setne %al
movb %al, -0x121(%rbp)
movb -0x121(%rbp), %al
testb $0x1, %al
jne 0xb113
jmp 0xb185
movq -0xd8(%rbp), %rax
cmpq -0xe0(%rbp), %rax
jne 0xb12f
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
movq -0xd8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd8(%rbp)
movq -0xe0(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb167
movq -0xe0(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x130(%rbp)
jmp 0xb172
xorl %eax, %eax
movq %rax, -0x130(%rbp)
jmp 0xb172
movq -0x130(%rbp), %rax
movq %rax, -0xe0(%rbp)
jmp 0xb0e4
jmp 0xb187
movq -0xd0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd0(%rbp)
jmp 0xb071
movq $0x0, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x118(%rcx), %rax
jae 0xb256
movq $0x0, -0xf0(%rbp)
movq -0xf0(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x110(%rcx), %rcx
imulq $0x38, -0xe8(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x10(%rcx), %rax
jae 0xb23d
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rax
imulq $0x38, -0xe8(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0xf0(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x8(%rax)
je 0xb227
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
jmp 0xb229
movq -0xf0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xf0(%rbp)
jmp 0xb1cc
jmp 0xb23f
movq -0xe8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xe8(%rbp)
jmp 0xb1a9
movq $0x0, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x130(%rcx), %rax
jae 0xb3ea
movq $0x0, -0x100(%rbp)
movq -0x100(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x128(%rcx), %rcx
imulq $0x48, -0xf8(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x20(%rcx), %rax
jae 0xb3d1
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
imulq $0x48, -0xf8(%rbp), %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
imulq $0x38, -0x100(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xb2ea
jmp 0xb3ba
movq $0x1, -0x110(%rbp)
movq -0x108(%rbp), %rax
cmpl $0x4, 0x10(%rax)
jne 0xb354
movq -0x108(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0xb32a
movq -0x108(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0xb336
movl $0x4, -0x4(%rbp)
jmp 0xb3f1
movq -0x108(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x110(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %edx
movl $0x1, %eax
movl $0x3, %ecx
cmpl $0x2, %edx
cmovel %ecx, %eax
cltq
movq %rax, -0x118(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
imulq -0x110(%rbp), %rax
imulq -0x118(%rbp), %rax
movq -0x108(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x18(%rcx), %rax
je 0xb3b8
movl $0x1, -0x4(%rbp)
jmp 0xb3f1
jmp 0xb3ba
movq -0x100(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x100(%rbp)
jmp 0xb284
jmp 0xb3d3
movq -0xf8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xf8(%rbp)
jmp 0xb261
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
nopl (%rax)
| /infosia[P]vrmpack/cgltf/cgltf.h |
cgltf_calc_size(cgltf_type, cgltf_component_type) | static cgltf_size cgltf_calc_size(cgltf_type type, cgltf_component_type component_type)
{
cgltf_size component_size = cgltf_component_size(component_type);
if (type == cgltf_type_mat2 && component_size == 1)
{
return 8 * component_size;
}
else if (type == cgltf_type_mat3 && (component_size == 1 || component_size == 2))
{
return 12 * component_size;
}
return component_size * cgltf_num_components(type);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl -0x10(%rbp), %edi
callq 0xe0a0
movq %rax, -0x18(%rbp)
cmpl $0x5, -0xc(%rbp)
jne 0xb435
cmpq $0x1, -0x18(%rbp)
jne 0xb435
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x8(%rbp)
jmp 0xb475
cmpl $0x6, -0xc(%rbp)
jne 0xb454
cmpq $0x1, -0x18(%rbp)
je 0xb449
cmpq $0x2, -0x18(%rbp)
jne 0xb454
imulq $0xc, -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb475
jmp 0xb456
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0xe020
movq %rax, %rcx
movq -0x20(%rbp), %rax
imulq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| /infosia[P]vrmpack/cgltf/cgltf.h |
cgltf_copy_extras_json | cgltf_result cgltf_copy_extras_json(const cgltf_data* data, const cgltf_extras* extras, char* dest, cgltf_size* dest_size)
{
cgltf_size json_size = extras->end_offset - extras->start_offset;
if (!dest)
{
if (dest_size)
{
*dest_size = json_size + 1;
return cgltf_result_success;
}
return cgltf_result_invalid_options;
}
if (*dest_size + 1 < json_size)
{
strncpy(dest, data->json + extras->start_offset, *dest_size - 1);
dest[*dest_size - 1] = 0;
}
else
{
strncpy(dest, data->json + extras->start_offset, json_size);
dest[json_size] = 0;
}
return cgltf_result_success;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb64d
cmpq $0x0, -0x28(%rbp)
je 0xb644
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xb6cb
movl $0x5, -0x4(%rbp)
jmp 0xb6cb
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq $0x1, %rax
cmpq -0x30(%rbp), %rax
jae 0xb699
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x178(%rax), %rsi
movq -0x18(%rbp), %rax
addq (%rax), %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
subq $0x1, %rdx
callq 0x9140
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
jmp 0xb6c4
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x178(%rax), %rsi
movq -0x18(%rbp), %rax
addq (%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x9140
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /infosia[P]vrmpack/cgltf/cgltf.h |
smf::MidiFile::write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool MidiFile::write(const std::string& filename) {
std::fstream output(filename.c_str(), std::ios::binary | std::ios::out);
if (!output.is_open()) {
std::cerr << "Error: could not write: " << filename << std::endl;
return false;
}
m_rwstatus = write(output);
output.close();
return m_rwstatus;
} | pushq %r14
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x8(%rsp), %rdi
movl $0x14, %edx
callq 0x11400
leaq 0x88(%rsp), %rdi
callq 0x110c0
testb %al, %al
je 0x17645
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x176c8
movb $0x1, 0x68(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x11060
movb 0x68(%rbx), %bl
jmp 0x1769c
movq 0x1c9a4(%rip), %rdi # 0x33ff0
leaq 0x11805(%rip), %rsi # 0x28e58
movl $0x18, %edx
callq 0x11360
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x1c985(%rip), %rdi # 0x33ff0
callq 0x11360
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x112f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x11030
movq %rax, %rdi
callq 0x11200
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x110b0
movl %ebx, %eax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x110b0
movq %rbx, %rdi
callq 0x11550
| /craigsapp[P]midifile/src/MidiFile.cpp |
smf::MidiFile::markSequence(int, int) | void MidiFile::markSequence(int track, int sequence) {
if ((track >= 0) && (track < getTrackCount())) {
operator[](track).markSequence(sequence);
} else {
std::cerr << "Warning: track " << track << " does not exist." << std::endl;
}
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %esi, %esi
js 0x18a76
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %ebx, %ecx
jle 0x18a76
movl %ebx, %ecx
movq (%rax,%rcx,8), %rdi
movl %edx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2549e
movq 0x1b573(%rip), %r14 # 0x33ff0
leaq 0x103ed(%rip), %rsi # 0x28e71
movl $0xf, %edx
movq %r14, %rdi
callq 0x11360
movq %r14, %rdi
movl %ebx, %esi
callq 0x11520
movq %rax, %rbx
leaq 0xf87c(%rip), %rsi # 0x28321
movl $0x10, %edx
movq %rax, %rdi
callq 0x11360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x112f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x11030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11200
| /craigsapp[P]midifile/src/MidiFile.cpp |
smf::MidiFile::writeLittleEndianULong(std::ostream&, unsigned long) | std::ostream& MidiFile::writeLittleEndianULong(std::ostream& out, ulong value) {
union { char bytes[4]; ulong ul; } data;
data.ul = value;
out << data.bytes[0];
out << data.bytes[1];
out << data.bytes[2];
out << data.bytes[3];
return out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %ebx, %r15d
shrl $0x10, %r15d
movl %ebx, %ebp
shrl $0x18, %ebp
leaq 0x5(%rsp), %rsi
movb %bl, (%rsi)
movl $0x1, %edx
callq 0x11360
movb %bh, 0x4(%rsp)
leaq 0x4(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x11360
leaq 0x6(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x11360
leaq 0x7(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x11360
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /craigsapp[P]midifile/src/MidiFile.cpp |
smf::MidiFile::writeBigEndianLong(std::ostream&, long) | std::ostream& MidiFile::writeBigEndianLong(std::ostream& out, long value) {
union { char bytes[4]; long l; } data;
data.l = value;
out << data.bytes[3];
out << data.bytes[2];
out << data.bytes[1];
out << data.bytes[0];
return out;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, %ebp
shrl $0x10, %ebp
movl %esi, %eax
movq %rsi, %r14
shrl $0x18, %eax
leaq 0xd(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
callq 0x11360
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x11360
movq %r14, %rax
movb %ah, 0xc(%rsp)
leaq 0xc(%rsp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x11360
leaq 0xf(%rsp), %rsi
movb %r14b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x11360
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /craigsapp[P]midifile/src/MidiFile.cpp |
smf::MidiMessage::setCommandNibble(int) | void MidiMessage::setCommandNibble(int value) {
if (this->size() < 1) {
this->resize(1);
}
if (value <= 0x0f) {
(*this)[0] = ((*this)[0] & 0x0f) | ((uchar)((value << 4) & 0xf0));
} else {
(*this)[0] = ((*this)[0] & 0x0f) | ((uchar)(value & 0xf0));
}
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
jne 0x1ce2f
movl $0x1, %esi
movq %r14, %rdi
callq 0x1b748
movq (%r14), %rax
movb (%rax), %cl
andb $0xf, %cl
movl %ebx, %edx
andb $-0x10, %dl
movl %ebx, %esi
shlb $0x4, %sil
cmpl $0x10, %ebx
movzbl %sil, %esi
movzbl %dl, %edx
cmovll %esi, %edx
orb %cl, %dl
movb %dl, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /craigsapp[P]midifile/src/MidiMessage.cpp |
smf::MidiMessage::setParameters(int, int) | void MidiMessage::setParameters(int p1, int p2) {
int oldsize = (int)size();
resize(3);
(*this)[1] = (uchar)p1;
(*this)[2] = (uchar)p2;
if (oldsize < 1) {
(*this)[0] = 0;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl 0x8(%rdi), %r15d
subl (%rdi), %r15d
movl $0x3, %esi
callq 0x1b748
movq (%rbx), %rax
movb %r14b, 0x1(%rax)
movq (%rbx), %rax
movb %bpl, 0x2(%rax)
testl %r15d, %r15d
jg 0x1cf01
movq (%rbx), %rax
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /craigsapp[P]midifile/src/MidiMessage.cpp |
smf::MidiMessage::setMetaTempo(double) | void MidiMessage::setMetaTempo(double tempo) {
int microseconds = (int)(60.0 / tempo * 1000000.0 + 0.5);
setTempoMicroseconds(microseconds);
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0xad62(%rip), %xmm1 # 0x28420
divsd %xmm0, %xmm1
mulsd 0xbe9e(%rip), %xmm1 # 0x29568
addsd 0xad56(%rip), %xmm1 # 0x28428
cvttsd2si %xmm1, %ebp
movl $0x6, %esi
callq 0x1b748
movq (%rbx), %rax
movb $-0x1, (%rax)
movq (%rbx), %rax
movb $0x51, 0x1(%rax)
movq (%rbx), %rax
movb $0x3, 0x2(%rax)
movl %ebp, %edx
movl %ebp, %eax
shrl $0x10, %eax
movq (%rbx), %rcx
movb %al, 0x3(%rcx)
movq (%rbx), %rax
movb %dh, 0x4(%rax)
movq (%rbx), %rax
movb %dl, 0x5(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /craigsapp[P]midifile/src/MidiMessage.cpp |
smf::MidiMessage::makeNoteOn(int, int, int) | void MidiMessage::makeNoteOn(int channel, int key, int velocity) {
resize(3);
(*this)[0] = 0x90 | (0x0f & channel);
(*this)[1] = key & 0x7f;
(*this)[2] = velocity & 0x7f;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movl $0x3, %esi
callq 0x1b748
andb $0xf, %r14b
orb $-0x70, %r14b
movq (%r15), %rax
movb %r14b, (%rax)
andb $0x7f, %bpl
movq (%r15), %rax
movb %bpl, 0x1(%rax)
andb $0x7f, %bl
movq (%r15), %rax
movb %bl, 0x2(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /craigsapp[P]midifile/src/MidiMessage.cpp |
smf::MidiMessage::makeNoteOff(int, int) | void MidiMessage::makeNoteOff(int channel, int key) {
resize(3);
(*this)[0] = 0x90 | (0x0f & channel);
(*this)[1] = key & 0x7f;
(*this)[2] = 0x00;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl $0x3, %esi
callq 0x1b748
andb $0xf, %bpl
orb $-0x70, %bpl
movq (%r14), %rax
movb %bpl, (%rax)
andb $0x7f, %bl
movq (%r14), %rax
movb %bl, 0x1(%rax)
movq (%r14), %rax
movb $0x0, 0x2(%rax)
popq %rbx
popq %r14
popq %rbp
retq
| /craigsapp[P]midifile/src/MidiMessage.cpp |
smf::MidiMessage::makePatchChange(int, int) | void MidiMessage::makePatchChange(int channel, int patchnum) {
resize(0);
push_back(0xc0 | (0x0f & channel));
push_back(0x7f & patchnum);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
xorl %esi, %esi
callq 0x1b748
andb $0xf, %r14b
orb $-0x40, %r14b
movb %r14b, 0xf(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1d956
movb %r14b, (%rsi)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1d967
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x1efa6
movq 0x8(%rbx), %rsi
andb $0x7f, %bpl
movb %bpl, 0xe(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x1d97f
movb %bpl, (%rsi)
incq 0x8(%rbx)
jmp 0x1d98c
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x1efa6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| /craigsapp[P]midifile/src/MidiMessage.cpp |
smf::MidiMessage::makePitchBendDouble(int, double) | void MidiMessage::makePitchBendDouble(int channel, double value) {
// value is in the range from -1 for minimum and 2^18 - 1 for the maximum
resize(0);
double dvalue = (value + 1.0) * (pow(2.0, 15.0));
if (dvalue < 0.0) {
dvalue = 0.0;
}
if (dvalue > pow(2.0, 15.0) - 1.0) {
dvalue = pow(2.0, 15.0) - 1.0;
}
ulong uivalue = (ulong)dvalue;
uchar lsb = uivalue & 0x7f;
uchar msb = (uivalue >> 7) & 0x7f;
push_back(0xe0 | (0x7f & channel));
push_back(lsb);
push_back(msb);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
xorl %esi, %esi
callq 0x1b748
movsd 0x10(%rsp), %xmm0
addsd 0xa856(%rip), %xmm0 # 0x28430
mulsd 0xb996(%rip), %xmm0 # 0x29578
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
maxsd %xmm1, %xmm0
movsd 0xb98a(%rip), %xmm1 # 0x29580
minsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0xb97e(%rip), %xmm1 # 0x29588
sarq $0x3f, %rcx
cvttsd2si %xmm1, %r14
andq %rcx, %r14
orq %rax, %r14
movl %r14d, %r15d
andb $0x7f, %r15b
movb %r15b, 0xf(%rsp)
shrl $0x7, %r14d
andb $0x7f, %r14b
movb %r14b, 0xe(%rsp)
orb $-0x20, %bpl
movb %bpl, 0xd(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1dc55
movb %bpl, (%rsi)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1dc66
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0x1efa6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1dc7c
movb %r15b, (%rsi)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1dc8d
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x1be68
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1dc9c
movb %r14b, (%rsi)
incq 0x8(%rbx)
jmp 0x1dca9
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x1be68
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /craigsapp[P]midifile/src/MidiMessage.cpp |
smf::MidiMessage::frequencyToSemitones(double, double) | double MidiMessage::frequencyToSemitones(double frequency, double a4frequency) {
if (frequency < 1) {
return 0.0;
}
if (a4frequency <= 0) {
return 0.0;
}
double semitones = 69.0 + 12.0 * log2(frequency/a4frequency);
if (semitones >= 128.0) {
return 127.0;
} else if (semitones < 0.0) {
return 0.0;
}
return semitones;
} | movapd %xmm0, %xmm2
movsd 0xa4a4(%rip), %xmm0 # 0x28430
ucomisd %xmm2, %xmm0
xorpd %xmm0, %xmm0
ja 0x1dfef
xorpd %xmm3, %xmm3
ucomisd %xmm1, %xmm3
jae 0x1dfef
pushq %rax
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
callq 0x11570
movapd %xmm0, %xmm1
mulsd 0xb5d6(%rip), %xmm1 # 0x29590
addsd 0xb5d6(%rip), %xmm1 # 0x29598
xorpd %xmm2, %xmm2
maxsd %xmm1, %xmm2
movsd 0xb5ce(%rip), %xmm0 # 0x295a0
cmpnlesd %xmm1, %xmm0
andpd %xmm0, %xmm2
movsd 0xb5c5(%rip), %xmm1 # 0x295a8
andnpd %xmm1, %xmm0
orpd %xmm2, %xmm0
addq $0x8, %rsp
retq
| /craigsapp[P]midifile/src/MidiMessage.cpp |
state_machine::state_machine::process_status state_machine::state_machine::StateMachine<state_machine::transition::Table<state_machine::transition::Row<state_machine::transition::Transition<state_machine::transition::State<(anonymous namespace)::s1>, state_machine::transition::Event<(anonymous namespace)::e2>, state_machine::transition::detail::guard_always, (anonymous namespace)::return_s2, state_machine::transition::State<(anonymous namespace)::s2>>, state_machine::transition::Transition<state_machine::transition::State<(anonymous namespace)::s1>, state_machine::transition::Event<(anonymous namespace)::e2>, state_machine::transition::detail::guard_always, (anonymous namespace)::return_s3<3>, state_machine::transition::State<(anonymous namespace)::s3>>>, state_machine::transition::Row<state_machine::transition::Transition<state_machine::transition::State<(anonymous namespace)::s1>, state_machine::transition::Event<(anonymous namespace)::e1>, state_machine::transition::detail::guard_always, state_machine::transition::detail::action_pass, state_machine::transition::State<void>>>, state_machine::transition::Row<state_machine::transition::Transition<state_machine::transition::State<(anonymous namespace)::s1>, state_machine::transition::Event<(anonymous namespace)::e3>, state_machine::transition::detail::guard_always, (anonymous namespace)::return_s3_e3, state_machine::transition::State<(anonymous namespace)::s3>>>, state_machine::transition::Row<state_machine::transition::Transition<state_machine::transition::State<(anonymous namespace)::s3>, state_machine::transition::Event<(anonymous namespace)::e3>, (anonymous namespace)::e3_greater_than<0>, (anonymous namespace)::return_s2, state_machine::transition::State<(anonymous namespace)::s2>>, state_machine::transition::Transition<state_machine::transition::State<(anonymous namespace)::s3>, state_machine::transition::Event<(anonymous namespace)::e3>, (anonymous namespace)::e3_less_than<1>, (anonymous namespace)::return_s3<0>, state_machine::transition::State<(anonymous namespace)::s3>>>>>::process_event<(anonymous namespace)::e1, 0>((anonymous namespace)::e1&&) | auto process_event(Event&& event) -> process_status {
static_assert(variant_type::template alternative_index<variant::empty>() == 0, "");
if (state_.index() == 0) {
throw bad_state_access{};
}
// Skip the first "empty" index when searching for the transition row.
return find_row(std::forward<Event>(event),
aux::make_index_range<1, 1 + variant_type::size>{});
} | pushq %rax
movzbl 0xc(%rdi), %ecx
cmpl $0x1, %ecx
je 0xb150
movb $0x3, %al
testl %ecx, %ecx
jne 0xb15b
movl $0x8, %edi
callq 0x8220
leaq 0x3fd99(%rip), %rcx # 0x4aed0
movq %rcx, (%rax)
leaq 0x3fd67(%rip), %rsi # 0x4aea8
movq 0x40e90(%rip), %rdx # 0x4bfd8
movq %rax, %rdi
callq 0x8920
addq $0x8, %rdi
callq 0xc3b2
movb $0x1, %al
popq %rcx
retq
nop
| /oliverlee[P]state-machine/include/state_machine/state_machine.h |
testing::Test::IsSkipped() | bool Test::IsSkipped() {
return internal::GetUnitTestImpl()->current_test_result()->Skipped();
} | pushq %rax
callq 0xd5ba
movq 0x36c4d(%rip), %rax # 0x4c6f0
movq 0x170(%rax), %rdi
testq %rdi, %rdi
je 0x15ab8
addq $0x90, %rdi
jmp 0x15ad6
movq 0x168(%rax), %rdi
testq %rdi, %rdi
je 0x15acd
addq $0x88, %rdi
jmp 0x15ad6
addq $0x178, %rax # imm = 0x178
movq %rax, %rdi
popq %rax
jmp 0x14fc2
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::Test::HasNonfatalFailure() | bool Test::HasNonfatalFailure() {
return internal::GetUnitTestImpl()->current_test_result()->
HasNonfatalFailure();
} | pushq %rax
callq 0xd5ba
movq 0x36c07(%rip), %rcx # 0x4c6f0
movq 0x170(%rcx), %rax
testq %rax, %rax
je 0x15afd
addq $0x90, %rax
jmp 0x15b1b
movq 0x168(%rcx), %rax
testq %rax, %rax
je 0x15b11
addq $0x88, %rax
jmp 0x15b1b
addq $0x178, %rcx # imm = 0x178
movq %rcx, %rax
movq 0x38(%rax), %rcx
movq 0x40(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x15b43
xorl %esi, %esi
cmpl $0x1, (%rcx)
sete %sil
addl %esi, %eax
addq $0x70, %rcx
cmpq %rdx, %rcx
jne 0x15b2a
testl %eax, %eax
setne %al
popq %rcx
retq
nop
| /oliverlee[P]state-machine/extern/googletest/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::TestFactoryBase* factory)
: test_suite_name_(a_test_suite_name),
name_(a_name),
type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
location_(a_code_location),
fixture_class_id_(fixture_class_id),
should_run_(false),
is_disabled_(false),
matches_filter_(false),
factory_(factory),
result_() {} | 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 0xc938
leaq 0x20(%rbx), %r14
leaq 0x30(%rbx), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x20(%rbx)
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xc938
testq %r13, %r13
je 0x15bd8
movl $0x20, %edi
callq 0x8470
movq %rax, %rbp
addq $0x10, %rax
movq %rax, (%rbp)
movq %r13, %rdi
callq 0x81f0
leaq (%rax,%r13), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x32d1e
jmp 0x15bda
xorl %ebp, %ebp
movq %rbp, 0x40(%rbx)
testq %r12, %r12
je 0x15c11
movl $0x20, %edi
callq 0x8470
movq %rax, %r13
addq $0x10, %rax
movq %rax, (%r13)
movq %r12, %rdi
callq 0x81f0
leaq (%rax,%r12), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x32d1e
jmp 0x15c14
xorl %r13d, %r13d
movq %r13, 0x48(%rbx)
leaq 0x50(%rbx), %r12
leaq 0x60(%rbx), %r13
movq %r13, 0x50(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0xc938
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rcx
movl 0x20(%r15), %edx
movl %edx, 0x70(%rbx)
movq %rcx, 0x78(%rbx)
movw $0x0, 0x80(%rbx)
movb $0x0, 0x82(%rbx)
movq %rax, 0x88(%rbx)
leaq 0x90(%rbx), %rdi
callq 0x2d666
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xd8(%rbx)
movups %xmm0, 0xc8(%rbx)
movl $0x0, 0xf8(%rbx)
movups %xmm0, 0x100(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x20, %esi
movq %r13, %rdi
callq 0x84a0
jmp 0x15d0e
movq %rax, %r15
jmp 0x15d0e
movq %rax, %r15
movl $0x20, %esi
movq %rbp, %rdi
callq 0x84a0
jmp 0x15d2b
movq %rax, %r15
jmp 0x15d2b
movq %rax, %r15
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x15cf1
movq (%r13), %rsi
incq %rsi
callq 0x84a0
jmp 0x15cf1
movq %rax, %r15
leaq 0x48(%rbx), %r12
movq (%r12), %rsi
testq %rsi, %rsi
je 0x15d06
movq %r12, %rdi
callq 0x34cbc
movq $0x0, (%r12)
leaq 0x40(%rbx), %r12
movq (%r12), %rsi
testq %rsi, %rsi
je 0x15d23
movq %r12, %rdi
callq 0x34cbc
movq $0x0, (%r12)
movq (%r14), %rdi
cmpq 0x8(%rsp), %rdi
je 0x15d4a
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x84a0
jmp 0x15d4a
movq %rax, %r15
movq (%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x15d64
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x84a0
movq %r15, %rdi
callq 0x8970
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::TestInfo::~TestInfo() | TestInfo::~TestInfo() { delete factory_; } | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
testq %rdi, %rdi
je 0x15d85
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x90(%rbx), %r14
leaq 0xe0(%rbx), %rdi
callq 0x2d6fc
leaq 0xc8(%rbx), %rdi
callq 0x2d72c
movq %r14, %rdi
callq 0x2d75c
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x15dc4
movq (%rax), %rsi
incq %rsi
callq 0x84a0
movq 0x48(%rbx), %rsi
testq %rsi, %rsi
je 0x15dd6
leaq 0x48(%rbx), %rdi
callq 0x34cbc
movq $0x0, 0x48(%rbx)
movq 0x40(%rbx), %rsi
testq %rsi, %rsi
je 0x15df0
leaq 0x40(%rbx), %rdi
callq 0x34cbc
movq $0x0, 0x40(%rbx)
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x15e10
movq (%rax), %rsi
incq %rsi
callq 0x84a0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x15e2e
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x84a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::MakeAndRegisterTestInfo(char const*, char const*, char const*, char const*, testing::internal::CodeLocation, void const*, void (*)(), void (*)(), testing::internal::TestFactoryBase*) | TestInfo* MakeAndRegisterTestInfo(
const char* test_suite_name, const char* name, const char* type_param,
const char* value_param, CodeLocation code_location,
TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
TestInfo* const test_info =
new TestInfo(test_suite_name, name, type_param, value_param,
code_location, fixture_class_id, factory);
GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
return test_info;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %r14
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
movl $0x110, %edi # imm = 0x110
callq 0x8470
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rbx, %rsi
callq 0x81d0
leaq 0x10(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %rbp, %rsi
callq 0x81d0
leaq 0x60(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0xc938
movq 0xc0(%rsp), %rax
movl 0x20(%r13), %ecx
leaq 0x50(%rsp), %r9
movl %ecx, 0x20(%r9)
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
pushq %rax
pushq %r14
callq 0x15b46
addq $0x10, %rsp
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x15ef7
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x84a0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15f12
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84a0
movq 0xb8(%rsp), %r14
movq 0xb0(%rsp), %r15
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15f3d
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x84a0
callq 0xd5ba
movq 0x367a7(%rip), %rdi # 0x4c6f0
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x2ddde
movq %r13, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x15f88
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x84a0
jmp 0x15f88
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15fa8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84a0
jmp 0x15fa8
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15fc8
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x84a0
jmp 0x15fc8
movq %rax, %r14
movl $0x110, %esi # imm = 0x110
movq 0x8(%rsp), %rdi
callq 0x84a0
movq %r14, %rdi
callq 0x8970
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::ReportInvalidTestSuiteType(char const*, testing::internal::CodeLocation) | void ReportInvalidTestSuiteType(const char* test_suite_name,
CodeLocation code_location) {
Message errors;
errors
<< "Attempted redefinition of test suite " << test_suite_name << ".\n"
<< "All tests in the same test suite must use the same test fixture\n"
<< "class. However, in test suite " << test_suite_name << ", you tried\n"
<< "to define a test using a fixture class different from the one\n"
<< "used earlier. This can happen if the two fixture classes are\n"
<< "from different namespaces and have the same name. You should\n"
<< "probably rename one of the classes to put the tests into different\n"
<< "test suites.";
GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),
code_location.line)
<< " " << errors.GetString();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x1104c
movq (%rbx), %rbx
leaq 0x10(%rbx), %r15
leaq 0x222d7(%rip), %rsi # 0x382e2
movl $0x25, %edx
movq %r15, %rdi
callq 0x8580
testq %r12, %r12
je 0x1602d
movq %r12, %rdi
callq 0x81f0
movq %rax, %rdx
movq %r12, %rsi
jmp 0x16039
movl $0x6, %edx
leaq 0x22023(%rip), %rsi # 0x3805c
movq %r15, %rdi
callq 0x8580
leaq 0x22556(%rip), %rsi # 0x3859e
movl $0x2, %edx
movq %r15, %rdi
callq 0x8580
leaq 0x2200a(%rip), %rsi # 0x38066
movl $0x40, %edx
movq %r15, %rdi
callq 0x8580
leaq 0x2211c(%rip), %rsi # 0x3818c
movl $0x1f, %edx
movq %r15, %rdi
callq 0x8580
testq %r12, %r12
je 0x1608f
movq %r12, %rdi
callq 0x81f0
movq %rax, %rdx
jmp 0x1609b
movl $0x6, %edx
leaq 0x21fc1(%rip), %r12 # 0x3805c
movq %r15, %rdi
movq %r12, %rsi
callq 0x8580
leaq 0x2225b(%rip), %rsi # 0x38308
movl $0xc, %edx
movq %r15, %rdi
callq 0x8580
leaq 0x22254(%rip), %rsi # 0x38315
movl $0x3e, %edx
movq %r15, %rdi
callq 0x8580
leaq 0x2227f(%rip), %rsi # 0x38354
movl $0x3d, %edx
movq %r15, %rdi
callq 0x8580
leaq 0x222a9(%rip), %rsi # 0x38392
movl $0x3d, %edx
movq %r15, %rdi
callq 0x8580
leaq 0x222d3(%rip), %rsi # 0x383d0
movl $0x43, %edx
movq %r15, %rdi
callq 0x8580
leaq 0x221a3(%rip), %rsi # 0x382b4
movl $0xc, %edx
movq %r15, %rdi
callq 0x8580
leaq 0x2192f(%rip), %rdx # 0x37a54
leaq 0xc(%rsp), %rdi
movl $0x2, %esi
movl $0xae2, %ecx # imm = 0xAE2
callq 0x296b6
movq (%r14), %rsi
movl 0x20(%r14), %edx
leaq 0x30(%rsp), %rdi
callq 0x1625c
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x35e95(%rip), %rdi # 0x4bff0
callq 0x8580
movq %rax, %r14
leaq 0x21dd8(%rip), %rsi # 0x37f42
movl $0x1, %edx
movq %rax, %rdi
callq 0x8580
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x112b5
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x8580
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x161b1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84a0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x161cc
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x84a0
leaq 0xc(%rsp), %rdi
callq 0x297f8
testq %rbx, %rbx
je 0x161e4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1621c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84a0
jmp 0x1621c
jmp 0x16219
movq %rax, %r14
jmp 0x16237
jmp 0x16243
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16237
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x84a0
leaq 0xc(%rsp), %rdi
callq 0x297f8
jmp 0x16246
movq %rax, %r14
testq %rbx, %rbx
je 0x16254
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x8970
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::FormatFileLocation[abi:cxx11](char const*, int) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
const std::string file_name(file == nullptr ? kUnknownFile : file);
if (line < 0) {
return file_name + ":";
}
#ifdef _MSC_VER
return file_name + "(" + StreamableToString(line) + "):";
#else
return file_name + ":" + StreamableToString(line) + ":";
#endif // _MSC_VER
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
testq %rsi, %rsi
leaq 0x20862(%rip), %rax # 0x36ae0
cmoveq %rax, %r14
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x81f0
leaq (%rax,%r14), %rdx
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
callq 0x32d1e
cmpl $0x0, 0x4(%rsp)
js 0x16341
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xc938
leaq 0x22811(%rip), %rsi # 0x38ae8
leaq 0x8(%rsp), %rdi
callq 0x8a40
leaq 0x48(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x2e3c4
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x50(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r12, %rcx
je 0x16312
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x16335
leaq 0x58(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x16330
movq 0x58(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x16371
leaq 0x8(%rsp), %rdi
callq 0x8150
jmp 0x1637f
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xc938
leaq 0x22784(%rip), %rsi # 0x38ae8
movq %rbx, %rdi
callq 0x8a40
jmp 0x16463
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8560
leaq 0x38(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x163a3
movq %rsi, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x163a9
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 0x2271b(%rip), %rsi # 0x38ae8
leaq 0x28(%rsp), %rdi
callq 0x8a40
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x163f9
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x163ff
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 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16431
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84a0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1644c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x84a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x16463
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x1647a
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x84a0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x16500
movq (%r12), %rsi
jmp 0x164f3
jmp 0x164fd
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x164c2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84a0
jmp 0x164c2
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x164e4
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x84a0
jmp 0x164e4
jmp 0x164e1
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x16500
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
jmp 0x16500
movq %rax, %r14
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x16517
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x84a0
movq %r14, %rdi
callq 0x8970
nop
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest-port.cc |
testing::internal::UnitTestImpl::RegisterParameterizedTests() | void UnitTestImpl::RegisterParameterizedTests() {
if (!parameterized_tests_registered_) {
parameterized_test_registry_.RegisterTests();
type_parameterized_test_registry_.CheckForInstantiations();
parameterized_tests_registered_ = true;
}
} | cmpb $0x0, 0x160(%rdi)
jne 0x1656b
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xe8(%rdi), %r14
movq 0xf0(%rdi), %r15
cmpq %r15, %r14
je 0x16553
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x8, %r14
jmp 0x1653f
leaq 0x100(%rbx), %rdi
callq 0xe704
movb $0x1, 0x160(%rbx)
popq %rbx
popq %r14
popq %r15
retq
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::TestInfo::Run() | void TestInfo::Run() {
if (!should_run_) return;
// Tells UnitTest where to store test result.
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->set_current_test_info(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
// Notifies the unit test event listeners that a test is about to start.
repeater->OnTestStart(*this);
const TimeInMillis start = internal::GetTimeInMillis();
impl->os_stack_trace_getter()->UponLeavingGTest();
// Creates the test object.
Test* const test = internal::HandleExceptionsInMethodIfSupported(
factory_, &internal::TestFactoryBase::CreateTest,
"the test fixture's constructor");
// Runs the test if the constructor didn't generate a fatal failure or invoke
// GTEST_SKIP().
// Note that the object will not be null
if (!Test::HasFatalFailure() && !Test::IsSkipped()) {
// This doesn't throw as all user code that can throw are wrapped into
// exception handling code.
test->Run();
}
if (test != nullptr) {
// Deletes the test object.
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(
test, &Test::DeleteSelf_, "the test fixture's destructor");
}
result_.set_start_timestamp(start);
result_.set_elapsed_time(internal::GetTimeInMillis() - start);
// Notifies the unit test event listener that a test has just finished.
repeater->OnTestEnd(*this);
// Tells UnitTest to stop associating assertion results to this
// test.
impl->set_current_test_info(nullptr);
} | cmpb $0x1, 0x80(%rdi)
jne 0x1671b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xd5ba
movq 0x3615a(%rip), %r13 # 0x4c6f0
movq %rbx, 0x170(%r13)
callq 0xd5ba
movq 0x36147(%rip), %rax # 0x4c6f0
movq 0x1f8(%rax), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x88c0
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%r12)
movq %rdx, %r15
imulq $0x3e8, (%r12), %rbp # imm = 0x3E8
movq %rdx, %r12
shrq $0x3f, %r12
sarq $0x7, %r15
movq 0x210(%r13), %rdi
testq %rdi, %rdi
je 0x16601
movq (%rdi), %rax
jmp 0x1661f
movl $0x8, %edi
callq 0x8470
movq %rax, %rdi
leaq 0x34c43(%rip), %rax # 0x4b258
movq %rax, (%rdi)
movq %rdi, 0x210(%r13)
addq %r12, %r15
callq *0x18(%rax)
movq 0x88(%rbx), %rdi
leaq 0x21de1(%rip), %rcx # 0x38414
movl $0x11, %esi
xorl %edx, %edx
callq 0x2df08
movq %rax, %r12
callq 0x15a2c
testb %al, %al
jne 0x1665c
callq 0x15a96
testb %al, %al
jne 0x1665c
movq %r12, %rdi
callq 0x15916
addq %rbp, %r15
testq %r12, %r12
je 0x166ae
movq 0x210(%r13), %rdi
testq %rdi, %rdi
je 0x16675
movq (%rdi), %rax
jmp 0x16693
movl $0x8, %edi
callq 0x8470
movq %rax, %rdi
leaq 0x34bcf(%rip), %rax # 0x4b258
movq %rax, (%rdi)
movq %rdi, 0x210(%r13)
callq *0x18(%rax)
leaq 0x179e5(%rip), %rsi # 0x2e082
leaq 0x21d8f(%rip), %rcx # 0x38433
movq %r12, %rdi
xorl %edx, %edx
callq 0x2dc59
movq %r15, 0x100(%rbx)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x88c0
imulq $0x3e8, (%r12), %rcx # imm = 0x3E8
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%r12)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
subq %r15, %rcx
addq %rdx, %rcx
movq %rcx, 0x108(%rbx)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x50(%rax)
movq $0x0, 0x170(%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::TestInfo::Skip() | void TestInfo::Skip() {
if (!should_run_) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->set_current_test_info(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
// Notifies the unit test event listeners that a test is about to start.
repeater->OnTestStart(*this);
const TestPartResult test_part_result =
TestPartResult(TestPartResult::kSkip, this->file(), this->line(), "");
impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(
test_part_result);
// Notifies the unit test event listener that a test has just finished.
repeater->OnTestEnd(*this);
impl->set_current_test_info(nullptr);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x1680c
movq %rdi, %rbx
callq 0xd5ba
movq 0x35fa5(%rip), %r15 # 0x4c6f0
movq %rbx, 0x170(%r15)
callq 0xd5ba
movq 0x35f92(%rip), %rax # 0x4c6f0
movq 0x1f8(%rax), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
movq 0x50(%rbx), %rdx
movl 0x70(%rbx), %ecx
leaq 0x21ed1(%rip), %r8 # 0x38650
movq %rsp, %rdi
movl $0x3, %esi
callq 0x2e088
leaq 0x90(%r15), %rdi
callq 0x335ce
movq (%rax), %rdi
movq (%rdi), %rax
movq %rsp, %rsi
callq *0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x50(%rax)
movq $0x0, 0x170(%r15)
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x167d6
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x84a0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x167f1
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x84a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1680c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2e13a
movq %rbx, %rdi
callq 0x8970
nop
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::TestSuite::TestSuite(char const*, char const*, void (*)(), void (*)()) | TestSuite::TestSuite(const char* a_name, const char* a_type_param,
internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc)
: name_(a_name),
type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
set_up_tc_(set_up_tc),
tear_down_tc_(tear_down_tc),
should_run_(false),
start_timestamp_(0),
elapsed_time_(0) {} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x3476e(%rip), %rax # 0x4afb8
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0xf(%rsp), %rdx
callq 0x81d0
testq %r12, %r12
je 0x1688e
movl $0x20, %edi
callq 0x8470
movq %rax, %r13
addq $0x10, %rax
movq %rax, (%r13)
movq %r12, %rdi
callq 0x81f0
leaq (%rax,%r12), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x32d1e
jmp 0x16891
xorl %r13d, %r13d
leaq 0x28(%rbx), %r12
movq %r13, 0x28(%rbx)
leaq 0x30(%rbx), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movq %r15, 0x60(%rbx)
movq %r14, 0x68(%rbx)
movb $0x0, 0x70(%rbx)
leaq 0x88(%rbx), %rdi
movups %xmm0, 0x78(%rbx)
callq 0x2d666
xorps %xmm0, %xmm0
movups %xmm0, 0xe0(%rbx)
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xc0(%rbx)
movl $0x0, 0xf0(%rbx)
movups %xmm0, 0xf8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x20, %esi
movq %r13, %rdi
callq 0x84a0
jmp 0x1693c
movq %rax, %r14
jmp 0x1693c
movq %rax, %r14
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x1692e
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x84a0
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x8a96
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x16954
movq (%rbx), %rsi
incq %rsi
callq 0x84a0
movq %r14, %rdi
callq 0x8970
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::TestSuite::~TestSuite() | TestSuite::~TestSuite() {
// Deletes every Test in the collection.
ForEach(test_info_list_, internal::Delete<TestInfo>);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3464a(%rip), %rax # 0x4afb8
movq %rax, (%rdi)
movq 0x30(%rdi), %r15
movq 0x38(%rdi), %r12
cmpq %r12, %r15
je 0x169a1
movq (%r15), %r14
testq %r14, %r14
je 0x1698e
movq %r14, %rdi
callq 0x15d6c
movl $0x110, %esi # imm = 0x110
movq %r14, %rdi
callq 0x84a0
addq $0x8, %r15
jmp 0x16979
leaq 0x88(%rbx), %r14
leaq 0xd8(%rbx), %rdi
callq 0x2d6fc
leaq 0xc0(%rbx), %rdi
callq 0x2d72c
movq %r14, %rdi
callq 0x2d75c
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x169dd
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x84a0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x169f2
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x84a0
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x16a04
leaq 0x28(%rbx), %rdi
callq 0x34cbc
movq $0x0, 0x28(%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x16a2f
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x84a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::TestSuite::GetTestInfo(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 0x16a7f
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %esi, %ecx
jle 0x16a7f
movl %esi, %ecx
movslq (%rax,%rcx,4), %rax
testq %rax, %rax
js 0x16a7f
movq 0x30(%rdi), %rcx
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest-internal-inl.h |
testing::TestSuite::GetMutableTestInfo(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 0x16aad
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %esi, %ecx
jle 0x16aad
movl %esi, %ecx
movslq (%rax,%rcx,4), %rax
testq %rax, %rax
js 0x16aad
movq 0x30(%rdi), %rcx
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest-internal-inl.h |
testing::TestSuite::AddTestInfo(testing::TestInfo*) | void TestSuite::AddTestInfo(TestInfo* test_info) {
test_info_list_.push_back(test_info);
test_indices_.push_back(static_cast<int>(test_indices_.size()));
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq 0x38(%rdi), %rsi
cmpq 0x40(%rdi), %rsi
je 0x16ad4
movq %rax, (%rsi)
addq $0x8, 0x38(%rbx)
jmp 0x16ae2
leaq 0x30(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x34cea
movq 0x50(%rbx), %rsi
movq %rsi, %rax
subq 0x48(%rbx), %rax
shrq $0x2, %rax
movl %eax, 0x4(%rsp)
cmpq 0x58(%rbx), %rsi
je 0x16b07
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%rbx)
jmp 0x16b18
addq $0x48, %rbx
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x34e26
addq $0x10, %rsp
popq %rbx
retq
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::TestSuite::Run() | void TestSuite::Run() {
if (!should_run_) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->set_current_test_suite(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
// Call both legacy and the new API
repeater->OnTestSuiteStart(*this);
// Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI
repeater->OnTestCaseStart(*this);
#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(
this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");
start_timestamp_ = internal::GetTimeInMillis();
for (int i = 0; i < total_test_count(); i++) {
GetMutableTestInfo(i)->Run();
if (GTEST_FLAG(fail_fast) && GetMutableTestInfo(i)->result()->Failed()) {
for (int j = i + 1; j < total_test_count(); j++) {
GetMutableTestInfo(j)->Skip();
}
break;
}
}
elapsed_time_ = internal::GetTimeInMillis() - start_timestamp_;
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(
this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");
// Call both legacy and the new API
repeater->OnTestSuiteEnd(*this);
// Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI
repeater->OnTestCaseEnd(*this);
#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI
impl->set_current_test_suite(nullptr);
} | cmpb $0x1, 0x70(%rdi)
jne 0x16d58
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0xd5ba
movq 0x35bac(%rip), %r12 # 0x4c6f0
movq %rbx, 0x168(%r12)
callq 0xd5ba
movq 0x35b98(%rip), %rax # 0x4c6f0
movq 0x1f8(%rax), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
movq 0x210(%r12), %rdi
testq %rdi, %rdi
je 0x16b89
movq (%rdi), %rax
jmp 0x16ba8
movl $0x8, %edi
callq 0x8470
movq %rax, %rdi
leaq 0x346bb(%rip), %rax # 0x4b258
movq %rax, (%rdi)
movq %rdi, 0x210(%r12)
callq *0x18(%rax)
leaq 0x17790(%rip), %rsi # 0x2e342
leaq 0x21898(%rip), %rcx # 0x38451
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2e1bd
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x88c0
imulq $0x3e8, (%r15), %rcx # imm = 0x3E8
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%r15)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
addq %rcx, %rdx
movq %rdx, 0x78(%rbx)
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x16c9d
movl $0x1, %r15d
movl $0x90, %r13d
movq 0x48(%rbx), %rcx
movl -0x4(%rcx,%r15,4), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1656c
cmpb $0x1, 0x3598c(%rip) # 0x4c5c2
jne 0x16c55
movq 0x30(%rbx), %rax
movq 0x48(%rbx), %rcx
movl -0x4(%rcx,%r15,4), %ecx
movq (%rax,%rcx,8), %rdi
addq %r13, %rdi
callq 0x14ffe
testb %al, %al
jne 0x16c89
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
leaq 0x1(%r15), %rdx
cmpq %rcx, %r15
movq %rdx, %r15
jl 0x16c1d
jmp 0x16c9d
movq 0x48(%rbx), %rcx
movl (%rcx,%r15,4), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x16726
incq %r15
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %ecx, %r15d
jl 0x16c75
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x88c0
imulq $0x3e8, (%r15), %rcx # imm = 0x3E8
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%r15)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
addq %rcx, %rdx
subq 0x78(%rbx), %rdx
movq %rdx, 0x80(%rbx)
movq 0x210(%r12), %rdi
testq %rdi, %rdi
je 0x16ced
movq (%rdi), %rax
jmp 0x16d0c
movl $0x8, %edi
callq 0x8470
movq %rax, %rdi
leaq 0x34557(%rip), %rax # 0x4b258
movq %rax, (%rdi)
movq %rdi, 0x210(%r12)
callq *0x18(%rax)
leaq 0x17638(%rip), %rsi # 0x2e34e
leaq 0x21745(%rip), %rcx # 0x38462
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2e1bd
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x58(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x60(%rax)
movq $0x0, 0x168(%r12)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::TestSuite::ClearResult() | void TestSuite::ClearResult() {
ad_hoc_test_result_.Clear();
ForEach(test_info_list_, TestInfo::ClearTestResult);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0xc0, %rdi
movq 0xc0(%rbx), %rsi
callq 0x341e2
leaq 0xd8(%rbx), %rdi
movq 0xd8(%rbx), %rsi
callq 0x34ae0
movl $0x0, 0xf0(%rbx)
movq $0x0, 0x100(%rbx)
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %rbx
cmpq %rbx, %r14
je 0x16eb3
movq (%r14), %r15
leaq 0xc8(%r15), %rdi
movq 0xc8(%r15), %rsi
callq 0x341e2
leaq 0xe0(%r15), %rdi
movq 0xe0(%r15), %rsi
callq 0x34ae0
movl $0x0, 0xf8(%r15)
movq $0x0, 0x108(%r15)
addq $0x8, %r14
jmp 0x16e69
popq %rbx
popq %r14
popq %r15
retq
nop
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(testing::UnitTest const&, int) | void PrettyUnitTestResultPrinter::OnTestIterationStart(
const UnitTest& unit_test, int iteration) {
if (GTEST_FLAG(repeat) != 1)
printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
const char* const filter = GTEST_FLAG(filter).c_str();
// Prints the filter if it's not *. This reminds the user that some
// tests may be skipped.
if (!String::CStringEquals(filter, kUniversalFilter)) {
ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_,
filter);
}
if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n",
static_cast<int>(shard_index) + 1,
internal::posix::GetEnv(kTestTotalShards));
}
if (GTEST_FLAG(shuffle)) {
ColoredPrintf(GTestColor::kYellow,
"Note: Randomizing tests' orders with a seed of %d .\n",
unit_test.random_seed());
}
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("Running %s from %s.\n",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
fflush(stdout);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
cmpl $0x1, 0x35514(%rip) # 0x4c638
je 0x17138
incl %edx
leaq 0x213cb(%rip), %rdi # 0x384fa
movl %edx, %esi
xorl %eax, %eax
callq 0x8080
movq 0x354a9(%rip), %rcx # 0x4c5e8
testq %rcx, %rcx
je 0x1714f
cmpb $0x2a, (%rcx)
jne 0x1714f
cmpb $0x0, 0x1(%rcx)
je 0x17169
leaq 0x213d0(%rip), %rsi # 0x38526
leaq 0x213df(%rip), %rdx # 0x3853c
movl $0x3, %edi
xorl %eax, %eax
callq 0x172e8
leaq 0x1f860(%rip), %rdi # 0x369d0
leaq 0x1f879(%rip), %rsi # 0x369f0
xorl %edx, %edx
callq 0x173d4
testb %al, %al
je 0x171ba
leaq 0x1f867(%rip), %rdi # 0x369f0
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x17779
leal 0x1(%rax), %ebp
leaq 0x1f833(%rip), %rdi # 0x369d0
callq 0x8640
leaq 0x2139f(%rip), %rsi # 0x38548
movl $0x3, %edi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x172e8
cmpb $0x1, 0x3547c(%rip) # 0x4c63d
jne 0x171e0
movq 0x40(%rbx), %rax
movl 0x21c(%rax), %edx
leaq 0x21398(%rip), %rsi # 0x3856c
movl $0x3, %edi
xorl %eax, %eax
callq 0x172e8
leaq 0x213ba(%rip), %rsi # 0x385a1
xorl %ebp, %ebp
movl $0x2, %edi
xorl %eax, %eax
callq 0x172e8
movq 0x40(%rbx), %rdi
callq 0x10dce
leaq 0x21e94(%rip), %rdx # 0x39099
leaq 0x213c6(%rip), %rcx # 0x385d2
movq %rsp, %rdi
movl %eax, %esi
callq 0x17988
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
cmpq %rcx, %rax
je 0x17241
xorl %ebp, %ebp
movq (%rax), %rdx
movzbl 0x70(%rdx), %edx
addl %edx, %ebp
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x1722f
movq (%rsp), %rbx
leaq 0x2259e(%rip), %rdx # 0x397ea
leaq 0x225a2(%rip), %rcx # 0x397f5
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0x17988
leaq 0x30(%rsp), %r14
movq -0x10(%r14), %rdx
leaq 0x21340(%rip), %rdi # 0x385af
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8080
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x1728f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84a0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x172aa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84a0
movq 0x34cc7(%rip), %rax # 0x4bf78
movq (%rax), %rdi
callq 0x85d0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x172e0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84a0
movq %rbx, %rdi
callq 0x8970
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::ColoredPrintf(testing::internal::(anonymous namespace)::GTestColor, char const*, ...) | void ColoredPrintf(GTestColor color, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
const bool use_color = AlwaysFalse();
#else
static const bool in_color_mode =
ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
const bool use_color = in_color_mode && (color != GTestColor::kDefault);
#endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS
if (!use_color) {
vprintf(fmt, args);
va_end(args);
return;
}
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
!GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
// Gets the current text color.
CONSOLE_SCREEN_BUFFER_INFO buffer_info;
GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
const WORD old_color_attrs = buffer_info.wAttributes;
const WORD new_color = GetNewColor(color, old_color_attrs);
// We need to flush the stream buffers into the console before each
// SetConsoleTextAttribute call lest it affect the text that is already
// printed but has not yet reached the console.
fflush(stdout);
SetConsoleTextAttribute(stdout_handle, new_color);
vprintf(fmt, args);
fflush(stdout);
// Restores the text color.
SetConsoleTextAttribute(stdout_handle, old_color_attrs);
#else
printf("\033[0;3%sm", GetAnsiColorCode(color));
vprintf(fmt, args);
printf("\033[m"); // Resets the terminal to default.
#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
va_end(args);
} | pushq %rbp
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x17346
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rsp)
movb 0x3541c(%rip), %al # 0x4c788
testb %al, %al
je 0x173cd
testl %ebp, %ebp
je 0x173b8
cmpb $0x0, 0x35405(%rip) # 0x4c780
je 0x173b8
movslq %ebp, %rax
leaq 0x2062d(%rip), %rcx # 0x379b4
movslq -0x4(%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x22443(%rip), %rdi # 0x397d9
xorl %eax, %eax
callq 0x8080
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x84b0
leaq 0x22433(%rip), %rdi # 0x397e2
xorl %eax, %eax
callq 0x8080
jmp 0x173c3
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x84b0
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
callq 0x8ac4
jmp 0x17370
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::ShouldShard(char const*, char const*, bool) | bool ShouldShard(const char* total_shards_env,
const char* shard_index_env,
bool in_subprocess_for_death_test) {
if (in_subprocess_for_death_test) {
return false;
}
const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1);
if (total_shards == -1 && shard_index == -1) {
return false;
} else if (total_shards == -1 && shard_index != -1) {
const Message msg = Message()
<< "Invalid environment variables: you have "
<< kTestShardIndex << " = " << shard_index
<< ", but have left " << kTestTotalShards << " unset.\n";
ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
fflush(stdout);
exit(EXIT_FAILURE);
} else if (total_shards != -1 && shard_index == -1) {
const Message msg = Message()
<< "Invalid environment variables: you have "
<< kTestTotalShards << " = " << total_shards
<< ", but have left " << kTestShardIndex << " unset.\n";
ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
fflush(stdout);
exit(EXIT_FAILURE);
} else if (shard_index < 0 || shard_index >= total_shards) {
const Message msg = Message()
<< "Invalid environment variables: we require 0 <= "
<< kTestShardIndex << " < " << kTestTotalShards
<< ", but you have " << kTestShardIndex << "=" << shard_index
<< ", " << kTestTotalShards << "=" << total_shards << ".\n";
ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
fflush(stdout);
exit(EXIT_FAILURE);
}
return total_shards > 1;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
testl %edx, %edx
jne 0x17441
movq %rsi, %r14
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x17779
movl %eax, %ebx
movq %r14, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x17779
movl %eax, %ebp
andl %ebx, %eax
cmpl $-0x1, %eax
je 0x17441
cmpl $-0x1, %ebx
setne %al
cmpl $-0x1, %ebp
sete %cl
orb %al, %cl
je 0x1744c
cmpl $-0x1, %ebp
setne %al
cmpl $-0x1, %ebx
sete %cl
orb %al, %cl
je 0x17515
testl %ebp, %ebp
js 0x17615
cmpl %ebx, %ebp
jge 0x17615
cmpl $0x2, %ebx
setge %al
jmp 0x17443
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x1104c
movq (%rbx), %rbx
addq $0x10, %rbx
leaq 0x2187c(%rip), %rsi # 0x38ce3
movl $0x28, %edx
movq %rbx, %rdi
callq 0x8580
leaq 0x1f575(%rip), %rsi # 0x369f0
movl $0x11, %edx
movq %rbx, %rdi
callq 0x8580
leaq 0x21908(%rip), %rsi # 0x38d97
movl $0x3, %edx
movq %rbx, %rdi
callq 0x8580
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8930
leaq 0x2185f(%rip), %rsi # 0x38d0c
movl $0x10, %edx
movq %rbx, %rdi
callq 0x8580
leaq 0x1f50f(%rip), %rsi # 0x369d0
movl $0x12, %edx
movq %rbx, %rdi
callq 0x8580
leaq 0x21848(%rip), %rsi # 0x38d1d
movl $0x8, %edx
movq %rbx, %rdi
callq 0x8580
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2ed22
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x17501
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x112b5
jmp 0x175d9
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1104c
movq (%r14), %r14
addq $0x10, %r14
leaq 0x217b3(%rip), %rsi # 0x38ce3
movl $0x28, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x1f48c(%rip), %rsi # 0x369d0
movl $0x12, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x2183f(%rip), %rsi # 0x38d97
movl $0x3, %edx
movq %r14, %rdi
callq 0x8580
movq %r14, %rdi
movl %ebx, %esi
callq 0x8930
leaq 0x21796(%rip), %rsi # 0x38d0c
movl $0x10, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x1f466(%rip), %rsi # 0x369f0
movl $0x11, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x2177f(%rip), %rsi # 0x38d1d
movl $0x8, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2ed22
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x175ca
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x112b5
leaq 0x10(%rsp), %rbx
movq (%rbx), %rdx
leaq 0x217b5(%rip), %rsi # 0x38d9d
movl $0x1, %edi
xorl %eax, %eax
callq 0x172e8
movq %rbx, %rdi
callq 0x8a78
movq 0x34975(%rip), %rax # 0x4bf78
movq (%rax), %rdi
callq 0x85d0
movl $0x1, %edi
callq 0x8630
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1104c
movq (%r14), %r14
addq $0x10, %r14
leaq 0x216f6(%rip), %rsi # 0x38d26
movl $0x2f, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x1f3ac(%rip), %rsi # 0x369f0
movl $0x11, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x216fe(%rip), %rsi # 0x38d56
movl $0x3, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x1f364(%rip), %rsi # 0x369d0
movl $0x12, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x216da(%rip), %rsi # 0x38d5a
movl $0xf, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x1f35c(%rip), %rsi # 0x369f0
movl $0x11, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x223d1(%rip), %rsi # 0x39a79
movl $0x1, %edx
movq %r14, %rdi
callq 0x8580
movq %r14, %rdi
movl %ebp, %esi
callq 0x8930
leaq 0x229f0(%rip), %rsi # 0x3a0b6
movl $0x2, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x1f2f6(%rip), %rsi # 0x369d0
movl $0x12, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x2238b(%rip), %rsi # 0x39a79
movl $0x1, %edx
movq %r14, %rdi
callq 0x8580
movq %r14, %rdi
movl %ebx, %esi
callq 0x8930
leaq 0x20e92(%rip), %rsi # 0x3859e
movl $0x2, %edx
movq %r14, %rdi
callq 0x8580
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2ed22
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x17738
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x112b5
jmp 0x175d9
jmp 0x17750
jmp 0x17750
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x17766
jmp 0x1775e
jmp 0x1775e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x17771
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8970
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::Int32FromEnvOrDie(char const*, int) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
const char* str_val = posix::GetEnv(var);
if (str_val == nullptr) {
return default_val;
}
int32_t result;
if (!ParseInt32(Message() << "The value of environment variable " << var,
str_val, &result)) {
exit(EXIT_FAILURE);
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r15
callq 0x8640
testq %rax, %rax
je 0x17813
movq %rax, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1104c
movq (%rbx), %rbx
leaq 0x10(%rbx), %r12
leaq 0x215b8(%rip), %rsi # 0x38d6a
movl $0x22, %edx
movq %r12, %rdi
callq 0x8580
testq %r15, %r15
je 0x177d1
movq %r15, %rdi
callq 0x81f0
movq %rax, %rdx
jmp 0x177dd
movl $0x6, %edx
leaq 0x2087f(%rip), %r15 # 0x3805c
movq %r12, %rdi
movq %r15, %rsi
callq 0x8580
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %r14, %rsi
callq 0x21b96
movl %eax, %ebp
testq %rbx, %rbx
je 0x1780a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
testb %bpl, %bpl
je 0x17822
movl 0x4(%rsp), %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x8630
movq %rax, %r14
testq %rbx, %rbx
je 0x1783d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x8970
nop
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::UnitTest::test_suite_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 0x17884
movq (%rcx), %rsi
movzbl 0x70(%rsi), %esi
addl %esi, %eax
addq $0x8, %rcx
jmp 0x17870
retq
nop
| /oliverlee[P]state-machine/extern/googletest/googletest/include/gtest/gtest.h |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestSuite const&) | void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(GTestColor::kGreen, "[----------] ");
printf("%s from %s", counts.c_str(), test_case.name());
if (test_case.type_param() == nullptr) {
printf("\n");
} else {
printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
}
fflush(stdout);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x178e1
movq (%rax), %rdx
movzbl 0x80(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x178ca
leaq 0x217b1(%rip), %rdx # 0x39099
leaq 0x20ce3(%rip), %rcx # 0x385d2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x17988
leaq 0x20cc1(%rip), %rsi # 0x385c4
movl $0x2, %edi
xorl %eax, %eax
callq 0x172e8
movq (%r14), %rsi
movq 0x8(%rbx), %rdx
leaq 0x20cbb(%rip), %rdi # 0x385d8
xorl %eax, %eax
callq 0x8080
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x1794c
movq (%rax), %rdx
testq %rdx, %rdx
je 0x1794c
leaq 0x20ca7(%rip), %rdi # 0x385e3
leaq 0x1f0bf(%rip), %rsi # 0x36a02
xorl %eax, %eax
callq 0x8080
jmp 0x17956
movl $0xa, %edi
callq 0x8750
movq 0x3461b(%rip), %rax # 0x4bf78
movq (%rax), %rdi
callq 0x85d0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17980
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void PrettyUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
switch (result.type()) {
// If the test part succeeded, we don't need to do anything.
case TestPartResult::kSuccess:
return;
default:
// Print failure message from the assertion
// (e.g. expected this and got that).
PrintTestPartResult(result);
fflush(stdout);
}
} | cmpl $0x0, (%rsi)
je 0x17b42
pushq %rax
movq %rsi, %rdi
callq 0x17b43
movq 0x3443f(%rip), %rax # 0x4bf78
movq (%rax), %rdi
popq %rax
jmp 0x85d0
retq
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::PrintTestPartResult(testing::TestPartResult const&) | static void PrintTestPartResult(const TestPartResult& test_part_result) {
const std::string& result =
PrintTestPartResultToString(test_part_result);
printf("%s\n", result.c_str());
fflush(stdout);
// If the test program runs in Visual Studio or a debugger, the
// following statements add the test part result message to the Output
// window such that the user can double-click on it to jump to the
// corresponding source code location; otherwise they do nothing.
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
// We don't call OutputDebugString*() on Windows Mobile, as printing
// to stdout is done by OutputDebugString() there already - we don't
// want the same message printed twice.
::OutputDebugStringA(result.c_str());
::OutputDebugStringA("\n");
#endif
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x157c7
movq (%rbx), %rdi
callq 0x8850
movq 0x34413(%rip), %rax # 0x4bf78
movq (%rax), %rdi
callq 0x85d0
movq (%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x17b87
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84a0
addq $0x20, %rsp
popq %rbx
retq
nop
| /oliverlee[P]state-machine/extern/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, 0x34903(%rip) # 0x4c631
jne 0x17e03
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x17d58
movq (%rax), %rdx
movzbl 0x80(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x17d41
leaq 0x2133a(%rip), %rdx # 0x39099
leaq 0x2086c(%rip), %rcx # 0x385d2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x17988
leaq 0x2084a(%rip), %rsi # 0x385c4
movl $0x2, %edi
xorl %eax, %eax
callq 0x172e8
movq (%r14), %r14
movq 0x8(%rbx), %r15
movq 0x80(%rbx), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x2e35a
leaq 0x40(%rsp), %rbx
movq -0x10(%rbx), %rcx
leaq 0x20880(%rip), %rdi # 0x38636
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8080
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x17dd9
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x84a0
movq 0x34198(%rip), %rax # 0x4bf78
movq (%rax), %rdi
callq 0x85d0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17e03
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17e2b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
movq %rbx, %rdi
callq 0x8970
nop
| /oliverlee[P]state-machine/extern/googletest/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_suite_count(); ++i) {
const TestSuite& test_suite = *unit_test.GetTestSuite(i);
if (!test_suite.should_run() || (test_suite.failed_test_count() == 0)) {
continue;
}
for (int j = 0; j < test_suite.total_test_count(); ++j) {
const TestInfo& test_info = *test_suite.GetTestInfo(j);
if (!test_info.should_run() || !test_info.result()->Failed()) {
continue;
}
ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
printf("%s.%s", test_suite.name(), test_info.name());
PrintFullTestCommentIfPresent(test_info);
printf("\n");
}
}
printf("\n%2d FAILED %s\n", failed_test_count,
failed_test_count == 1 ? "TEST" : "TESTS");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x40(%rdi), %rdi
callq 0x10aee
movl %eax, %ebx
leaq 0x20797(%rip), %rsi # 0x3861e
movl $0x1, %edi
xorl %eax, %eax
callq 0x172e8
leaq 0x211ff(%rip), %rdx # 0x39099
leaq 0x20731(%rip), %rcx # 0x385d2
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl %ebx, 0x4(%rsp)
movl %ebx, %esi
callq 0x17988
movq (%r15), %rsi
leaq 0x20793(%rip), %rdi # 0x38651
xorl %eax, %eax
callq 0x8080
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x17edf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
movq 0x40(%r14), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x1802e
leaq 0x2075d(%rip), %r12 # 0x38664
xorl %ebp, %ebp
movq 0xd0(%rcx), %rdx
movq 0xd8(%rcx), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbp
jge 0x17f32
cmpl $0x0, (%rdx,%rbp,4)
js 0x17f32
movq (%rax,%rbp,8), %r13
jmp 0x17f35
xorl %r13d, %r13d
cmpb $0x1, 0x70(%r13)
jne 0x18006
movq %r13, %rdi
callq 0x10b3e
testl %eax, %eax
je 0x18006
movq 0x30(%r13), %rax
movq 0x38(%r13), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x18006
xorl %ebx, %ebx
movq 0x48(%r13), %rcx
movq 0x50(%r13), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rdx
cmpq %rdx, %rbx
jge 0x17f8f
movslq (%rcx,%rbx,4), %rcx
testq %rcx, %rcx
js 0x17f8f
movq (%rax,%rcx,8), %r15
jmp 0x17f92
xorl %r15d, %r15d
cmpb $0x1, 0x80(%r15)
jne 0x17fe8
leaq 0x90(%r15), %rdi
callq 0x14ffe
testb %al, %al
je 0x17fe8
movl $0x1, %edi
leaq 0x20666(%rip), %rsi # 0x3861e
xorl %eax, %eax
callq 0x172e8
movq 0x8(%r13), %rsi
movq 0x20(%r15), %rdx
movq %r12, %rdi
xorl %eax, %eax
callq 0x8080
movq 0x40(%r15), %rdi
movq 0x48(%r15), %rsi
callq 0x17c8c
movl $0xa, %edi
callq 0x8750
incq %rbx
movq 0x30(%r13), %rax
movq 0x38(%r13), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbx
jl 0x17f69
incq %rbp
movq 0x40(%r14), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %rbp
jl 0x17f09
movl 0x4(%rsp), %esi
cmpl $0x1, %esi
leaq 0x2063e(%rip), %rax # 0x3867a
leaq 0x2063c(%rip), %rdx # 0x3867f
cmoveq %rax, %rdx
leaq 0x2061c(%rip), %rdi # 0x3866a
xorl %eax, %eax
callq 0x8080
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::UnitTest::GetTestSuite(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 0x180bb
movq 0x40(%rdi), %rax
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x180bb
movl %esi, %edx
cmpl $0x0, (%rcx,%rdx,4)
js 0x180bb
movq 0xb8(%rax), %rax
movq (%rax,%rdx,8), %rax
retq
xorl %eax, %eax
retq
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::PrettyUnitTestResultPrinter::PrintSkippedTests(testing::UnitTest const&) | void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) {
const int skipped_test_count = unit_test.skipped_test_count();
if (skipped_test_count == 0) {
return;
}
for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
const TestSuite& test_suite = *unit_test.GetTestSuite(i);
if (!test_suite.should_run() || (test_suite.skipped_test_count() == 0)) {
continue;
}
for (int j = 0; j < test_suite.total_test_count(); ++j) {
const TestInfo& test_info = *test_suite.GetTestInfo(j);
if (!test_info.should_run() || !test_info.result()->Skipped()) {
continue;
}
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
printf("%s.%s", test_suite.name(), test_info.name());
printf("\n");
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0x10a4e
testl %eax, %eax
je 0x1833d
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x1833d
leaq 0x2044b(%rip), %r15 # 0x38664
xorl %r13d, %r13d
movq 0xd0(%rcx), %rdx
movq 0xd8(%rcx), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r13
jge 0x18246
cmpl $0x0, (%rdx,%r13,4)
js 0x18246
movq (%rax,%r13,8), %r12
jmp 0x18249
xorl %r12d, %r12d
cmpb $0x1, 0x70(%r12)
jne 0x18315
movq %r12, %rdi
callq 0x10a9e
testl %eax, %eax
je 0x18315
movq 0x30(%r12), %rax
movq 0x38(%r12), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x18315
xorl %ebp, %ebp
movq 0x48(%r12), %rcx
movq 0x50(%r12), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rdx
cmpq %rdx, %rbp
jge 0x182a8
movslq (%rcx,%rbp,4), %rcx
testq %rcx, %rcx
js 0x182a8
movq (%rax,%rcx,8), %r14
jmp 0x182ab
xorl %r14d, %r14d
cmpb $0x1, 0x80(%r14)
jne 0x182f5
leaq 0x90(%r14), %rdi
callq 0x14fc2
testb %al, %al
je 0x182f5
movl $0x2, %edi
leaq 0x2033f(%rip), %rsi # 0x38610
xorl %eax, %eax
callq 0x172e8
movq 0x8(%r12), %rsi
movq 0x20(%r14), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x8080
movl $0xa, %edi
callq 0x8750
incq %rbp
movq 0x30(%r12), %rax
movq 0x38(%r12), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbp
jl 0x18280
incq %r13
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r13
jl 0x1821c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("%s from %s ran.",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
if (GTEST_FLAG(print_time)) {
printf(" (%s ms total)",
internal::StreamableToString(unit_test.elapsed_time()).c_str());
}
printf("\n");
ColoredPrintf(GTestColor::kGreen, "[ PASSED ] ");
printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
const int skipped_test_count = unit_test.skipped_test_count();
if (skipped_test_count > 0) {
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
printf("%s, listed below:\n", FormatTestCount(skipped_test_count).c_str());
PrintSkippedTests(unit_test);
}
if (!unit_test.Passed()) {
PrintFailedTests(unit_test);
PrintFailedTestSuites(unit_test);
}
int num_disabled = unit_test.reportable_disabled_test_count();
if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
if (unit_test.Passed()) {
printf("\n"); // Add a spacer if no FAILURE banner is displayed.
}
ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n",
num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
}
// Ensure that Google Test output is printed before, e.g., heapchecker output.
fflush(stdout);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x20237(%rip), %rsi # 0x385a1
xorl %ebp, %ebp
movl $0x2, %edi
xorl %eax, %eax
callq 0x172e8
movq 0x40(%rbx), %rdi
callq 0x10dce
leaq 0x20d11(%rip), %rdx # 0x39099
leaq 0x20243(%rip), %rcx # 0x385d2
leaq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x17988
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
cmpq %rcx, %rax
je 0x183c6
xorl %ebp, %ebp
movq (%rax), %rdx
movzbl 0x70(%rdx), %edx
addl %edx, %ebp
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x183b4
movq 0x8(%rsp), %r14
leaq 0x21418(%rip), %rdx # 0x397ea
leaq 0x2141c(%rip), %rcx # 0x397f5
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
callq 0x17988
leaq 0x38(%rsp), %r15
movq -0x10(%r15), %rdx
leaq 0x202db(%rip), %rdi # 0x386d0
movq %r14, %rsi
xorl %eax, %eax
callq 0x8080
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x18415
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84a0
leaq 0x18(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x18430
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
cmpb $0x1, 0x341fa(%rip) # 0x4c631
jne 0x1847f
movq 0x40(%rbx), %rax
movq 0x230(%rax), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2e35a
movq (%r14), %rsi
leaq 0x2027d(%rip), %rdi # 0x386e0
xorl %eax, %eax
callq 0x8080
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x1847f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
movl $0xa, %edi
callq 0x8750
leaq 0x2025f(%rip), %rsi # 0x386ef
movl $0x2, %edi
xorl %eax, %eax
callq 0x172e8
movq 0x40(%rbx), %rdi
callq 0x109c8
leaq 0x20bed(%rip), %rdx # 0x39099
leaq 0x2011f(%rip), %rcx # 0x385d2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x17988
movq (%r14), %rsi
leaq 0x2009b(%rip), %rdi # 0x38567
xorl %eax, %eax
callq 0x8080
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x184e8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
movq 0x40(%rbx), %rdi
callq 0x10a4e
testl %eax, %eax
jle 0x18555
movl %eax, %ebp
leaq 0x20112(%rip), %rsi # 0x38610
movl $0x2, %edi
xorl %eax, %eax
callq 0x172e8
leaq 0x20b88(%rip), %rdx # 0x39099
leaq 0x200ba(%rip), %rcx # 0x385d2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x17988
movq (%r14), %rsi
leaq 0x20120(%rip), %rdi # 0x38651
xorl %eax, %eax
callq 0x8080
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x1854d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
movq %rbx, %rdi
callq 0x181d2
movq 0x40(%rbx), %rdi
callq 0x2e42e
testb %al, %al
jne 0x18572
movq %rbx, %rdi
callq 0x17e64
movq %rbx, %rdi
callq 0x180be
movq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x10b8e
testl %eax, %eax
je 0x185cd
cmpb $0x0, 0x3403a(%rip) # 0x4c5c3
jne 0x185cd
movl %eax, %ebx
movq %r14, %rdi
callq 0x2e42e
testb %al, %al
je 0x185a3
movl $0xa, %edi
callq 0x8750
cmpl $0x1, %ebx
leaq 0x200cd(%rip), %rax # 0x3867a
leaq 0x200cb(%rip), %rcx # 0x3867f
cmoveq %rax, %rcx
leaq 0x2013e(%rip), %rsi # 0x386fd
movl $0x3, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x172e8
movq 0x339a4(%rip), %rax # 0x4bf78
movq (%rax), %rdi
callq 0x85d0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18605
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
movq %rbx, %rdi
callq 0x8970
nop
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void BriefUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
switch (result.type()) {
// If the test part succeeded, we don't need to do anything.
case TestPartResult::kSuccess:
return;
default:
// Print failure message from the assertion
// (e.g. expected this and got that).
PrintTestPartResult(result);
fflush(stdout);
}
} | cmpl $0x0, (%rsi)
je 0x18656
pushq %rax
movq %rsi, %rdi
callq 0x17b43
movq 0x3392b(%rip), %rax # 0x4bf78
movq (%rax), %rdi
popq %rax
jmp 0x85d0
retq
nop
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&) | void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
if (test_info.result()->Failed()) {
ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
PrintTestName(test_info.test_suite_name(), test_info.name());
PrintFullTestCommentIfPresent(test_info);
if (GTEST_FLAG(print_time)) {
printf(" (%s ms)\n",
internal::StreamableToString(test_info.result()->elapsed_time())
.c_str());
} else {
printf("\n");
}
fflush(stdout);
}
} | pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %rdi
callq 0x14ffe
testb %al, %al
je 0x18714
leaq 0x1ffa3(%rip), %rsi # 0x3861e
movl $0x1, %edi
xorl %eax, %eax
callq 0x172e8
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x1ffcf(%rip), %rdi # 0x38664
xorl %eax, %eax
callq 0x8080
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rsi
callq 0x17c8c
cmpb $0x1, 0x33f81(%rip) # 0x4c631
jne 0x186fb
movq 0x108(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2e35a
movq (%rbx), %rsi
leaq 0x1ff54(%rip), %rdi # 0x3862c
xorl %eax, %eax
callq 0x8080
movq (%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x18705
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84a0
jmp 0x18705
movl $0xa, %edi
callq 0x8750
movq 0x3386c(%rip), %rax # 0x4bf78
movq (%rax), %rdi
callq 0x85d0
addq $0x30, %rsp
popq %rbx
retq
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("%s from %s ran.",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
if (GTEST_FLAG(print_time)) {
printf(" (%s ms total)",
internal::StreamableToString(unit_test.elapsed_time()).c_str());
}
printf("\n");
ColoredPrintf(GTestColor::kGreen, "[ PASSED ] ");
printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
const int skipped_test_count = unit_test.skipped_test_count();
if (skipped_test_count > 0) {
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
printf("%s.\n", FormatTestCount(skipped_test_count).c_str());
}
int num_disabled = unit_test.reportable_disabled_test_count();
if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
if (unit_test.Passed()) {
printf("\n"); // Add a spacer if no FAILURE banner is displayed.
}
ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n",
num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
}
// Ensure that Google Test output is printed before, e.g., heapchecker output.
fflush(stdout);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x1fe73(%rip), %rsi # 0x385a1
xorl %ebp, %ebp
movl $0x2, %edi
xorl %eax, %eax
callq 0x172e8
movq 0x40(%rbx), %rdi
callq 0x10dce
leaq 0x2094d(%rip), %rdx # 0x39099
leaq 0x1fe7f(%rip), %rcx # 0x385d2
leaq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x17988
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
cmpq %rcx, %rax
je 0x1878a
xorl %ebp, %ebp
movq (%rax), %rdx
movzbl 0x70(%rdx), %edx
addl %edx, %ebp
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x18778
movq 0x8(%rsp), %r14
leaq 0x21054(%rip), %rdx # 0x397ea
leaq 0x21058(%rip), %rcx # 0x397f5
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
callq 0x17988
leaq 0x38(%rsp), %r15
movq -0x10(%r15), %rdx
leaq 0x1ff17(%rip), %rdi # 0x386d0
movq %r14, %rsi
xorl %eax, %eax
callq 0x8080
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x187d9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84a0
leaq 0x18(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x187f4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
cmpb $0x1, 0x33e36(%rip) # 0x4c631
jne 0x18843
movq 0x40(%rbx), %rax
movq 0x230(%rax), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2e35a
movq (%r14), %rsi
leaq 0x1feb9(%rip), %rdi # 0x386e0
xorl %eax, %eax
callq 0x8080
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x18843
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
movl $0xa, %edi
callq 0x8750
leaq 0x1fe9b(%rip), %rsi # 0x386ef
movl $0x2, %edi
xorl %eax, %eax
callq 0x172e8
movq 0x40(%rbx), %rdi
callq 0x109c8
leaq 0x20829(%rip), %rdx # 0x39099
leaq 0x1fd5b(%rip), %rcx # 0x385d2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x17988
movq (%r14), %rsi
leaq 0x1fcd7(%rip), %rdi # 0x38567
xorl %eax, %eax
callq 0x8080
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x188ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
movq 0x40(%rbx), %rdi
callq 0x10a4e
testl %eax, %eax
jle 0x18911
movl %eax, %ebp
leaq 0x1fd4e(%rip), %rsi # 0x38610
movl $0x2, %edi
xorl %eax, %eax
callq 0x172e8
leaq 0x207c4(%rip), %rdx # 0x39099
leaq 0x1fcf6(%rip), %rcx # 0x385d2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x17988
movq (%r14), %rsi
leaq 0x1fc72(%rip), %rdi # 0x38567
xorl %eax, %eax
callq 0x8080
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x18911
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
movq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x10b8e
testl %eax, %eax
je 0x1896c
cmpb $0x0, 0x33c9b(%rip) # 0x4c5c3
jne 0x1896c
movl %eax, %ebx
movq %r14, %rdi
callq 0x2e42e
testb %al, %al
je 0x18942
movl $0xa, %edi
callq 0x8750
cmpl $0x1, %ebx
leaq 0x1fd2e(%rip), %rax # 0x3867a
leaq 0x1fd2c(%rip), %rcx # 0x3867f
cmoveq %rax, %rcx
leaq 0x1fd9f(%rip), %rsi # 0x386fd
movl $0x3, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x172e8
movq 0x33605(%rip), %rax # 0x4bf78
movq (%rax), %rdi
callq 0x85d0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x189a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
movq %rbx, %rdi
callq 0x8970
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::~TestEventRepeater() | TestEventRepeater::~TestEventRepeater() {
ForEach(listeners_, Delete<TestEventListener>);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3261d(%rip), %rax # 0x4afd8
movq %rax, (%rdi)
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x189e6
movq (%r14), %rdi
testq %rdi, %rdi
je 0x189d9
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x189cb
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x189ff
movq 0x20(%rbx), %rsi
subq %r14, %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x84a0
popq %rbx
popq %r14
popq %r15
retq
nop
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::Release(testing::TestEventListener*) | TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
for (size_t i = 0; i < listeners_.size(); ++i) {
if (listeners_[i] == listener) {
listeners_.erase(listeners_.begin() + static_cast<int>(i));
return listener;
}
}
return nullptr;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq 0x18(%r14), %rdx
movq %rdx, %rax
subq %rdi, %rax
je 0x18a8e
movq %rsi, %rbx
sarq $0x3, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
movabsq $0x100000000, %rsi # imm = 0x100000000
xorl %ecx, %ecx
xorl %r8d, %r8d
cmpq %rbx, (%rdi,%r8,8)
je 0x18a92
incq %r8
addq %rsi, %rcx
cmpq %r8, %rax
jne 0x18a7d
xorl %ebx, %ebx
jmp 0x18aba
sarq $0x1d, %rcx
leaq (%rdi,%rcx), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x18ab2
addq %rcx, %rdi
subq %rsi, %rdx
callq 0x88d0
movq 0x18(%r14), %rdx
addq $-0x8, %rdx
movq %rdx, 0x18(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::OnTestIterationStart(testing::UnitTest const&, int) | void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
int iteration) {
if (forwarding_enabled_) {
for (size_t i = 0; i < listeners_.size(); i++) {
listeners_[i]->OnTestIterationStart(unit_test, iteration);
}
}
} | cmpb $0x1, 0x8(%rdi)
jne 0x18e7e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x18e73
movl %edx, %ebx
movq %rsi, %r14
xorl %r12d, %r12d
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x18(%rax)
incq %r12
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jb 0x18e4d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /oliverlee[P]state-machine/extern/googletest/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 0x18ec8
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x18(%rdi), %r12
subq 0x10(%rdi), %r12
je 0x18ebd
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(%rax)
decq %r12
jne 0x18ea4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(char const*) | XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
: output_file_(output_file) {
if (output_file_.empty()) {
GTEST_LOG_(FATAL) << "XML output file may not be null";
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x32198(%rip), %rax # 0x4b070
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x3(%rsp), %rdx
callq 0x81d0
cmpq $0x0, 0x10(%rbx)
jne 0x18f2d
leaq 0x1eb5d(%rip), %rdx # 0x37a54
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0xf80, %ecx # imm = 0xF80
callq 0x296b6
movq 0x330de(%rip), %rdi # 0x4bff0
leaq 0x1f800(%rip), %rsi # 0x38719
movl $0x1f, %edx
callq 0x8580
leaq 0x4(%rsp), %rdi
callq 0x297f8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x4(%rsp), %rdi
callq 0x297f8
jmp 0x18f47
movq %rax, %r14
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x18f5f
movq (%rbx), %rsi
incq %rsi
callq 0x84a0
movq %r14, %rdi
callq 0x8970
nop
| /oliverlee[P]state-machine/extern/googletest/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).c_str());
fclose(xmlout);
} | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x19028
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8330
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x19174
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x112b5
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x8550
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x18fcc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84a0
movq %rbx, %rdi
callq 0x8460
movq 0x32fa5(%rip), %rsi # 0x4bf80
leaq 0x20(%rsp), %rdi
callq 0x8370
leaq 0xa0(%rsp), %rdi
callq 0x8170
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x18fff
movq %rax, %rbx
movq 0x32f77(%rip), %rsi # 0x4bf80
leaq 0x20(%rsp), %rdi
callq 0x8370
leaq 0xa0(%rsp), %rdi
callq 0x8170
movq %rbx, %rdi
callq 0x8970
| /oliverlee[P]state-machine/extern/googletest/googletest/src/gtest.cc |
testing::internal::OpenFileForWriting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static FILE* OpenFileForWriting(const std::string& output_file) {
FILE* fileout = nullptr;
FilePath output_file_path(output_file);
FilePath output_dir(output_file_path.RemoveFileName());
if (output_dir.CreateDirectoriesRecursively()) {
fileout = posix::FOpen(output_file.c_str(), "w");
}
if (fileout == nullptr) {
GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
}
return fileout;
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c464
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x28afa
leaq 0x8(%rsp), %rdi
callq 0x28cf4
testb %al, %al
je 0x19074
movq (%rbx), %rdi
leaq 0x1fc1c(%rip), %rsi # 0x38c83
callq 0x85e0
movq %rax, %r14
testq %rax, %rax
jne 0x190db
leaq 0x1e9d9(%rip), %rdx # 0x37a54
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0xc7, %ecx
callq 0x296b6
movq 0x32f5a(%rip), %rdi # 0x4bff0
leaq 0x20775(%rip), %rsi # 0x39812
movl $0x15, %edx
callq 0x8580
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x32f3b(%rip), %rdi # 0x4bff0
callq 0x8580
leaq 0x1f924(%rip), %rsi # 0x389e5
movl $0x1, %edx
movq %rax, %rdi
callq 0x8580
leaq 0x4(%rsp), %rdi
callq 0x297f8
xorl %r14d, %r14d
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x190f6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19111
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84a0
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x1911e
movq %rax, %rbx
jmp 0x19135
movq %rax, %rbx
jmp 0x19150
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x297f8
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19150
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1916b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84a0
movq %rbx, %rdi
callq 0x8970
nop
| /oliverlee[P]state-machine/extern/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 0x1ff0d(%rip), %rax # 0x4b808
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x2b916
movq (%rax), %rsi
incq %rsi
callq 0x84a0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x2b92e
movq (%rax), %rsi
incq %rsi
callq 0x84a0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x2b947
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x84a0
popq %rbx
retq
nop
| /oliverlee[P]state-machine/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [3]>(char const (&) [3]) | 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 0x1104c
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x81f0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8580
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x30404
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2cd26
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 0x2cd46
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8970
| /oliverlee[P]state-machine/extern/googletest/googletest/include/gtest/gtest.h |
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 0x1104c
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x81f0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8580
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x30404
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2d43a
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 0x2d45a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8970
| /oliverlee[P]state-machine/extern/googletest/googletest/include/gtest/gtest.h |
datadog::Dogstatsd::flush() | int Dogstatsd::flush(){
int ret = 0;
std::ostringstream statd;
if(!buffered) {
return 0;
}
while (!cmd_buffer.empty()) {
if (static_cast<int>(statd.tellp()) + cmd_buffer.back().length() > optimal_payload) {
std::string buffer(statd.str());
ret += sendto( _sockfd, buffer.c_str(), buffer.length(),
0, (struct sockaddr *)&_server, sizeof(_server));
//clear the stringstream
statd.str("");
statd.clear();
}
statd << cmd_buffer.back() << std::endl;
cmd_buffer.pop_back();
}
std::string buffer(statd.str());
ret += sendto(_sockfd, buffer.c_str(), buffer.length(), 0, (struct sockaddr *)&_server, sizeof(_server));
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp # imm = 0x2A0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x8800
movq -0x228(%rbp), %rax
testb $0x1, 0x24(%rax)
jne 0x9380
movl $0x0, -0x4(%rbp)
movl $0x1, -0x194(%rbp)
jmp 0x96d9
jmp 0x9382
movq -0x228(%rbp), %rdi
addq $0x28, %rdi
callq 0x8aa0
xorb $-0x1, %al
testb $0x1, %al
jne 0x939d
jmp 0x960b
leaq -0x190(%rbp), %rdi
callq 0x8500
movq %rdx, -0x238(%rbp)
movq %rax, -0x230(%rbp)
jmp 0x93b9
movq -0x238(%rbp), %rax
movq -0x230(%rbp), %rcx
movq %rcx, -0x1a8(%rbp)
movq %rax, -0x1a0(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x8380
movq %rax, -0x240(%rbp)
jmp 0x93ea
movq -0x228(%rbp), %rdi
movq -0x240(%rbp), %rax
cltq
movq %rax, -0x248(%rbp)
addq $0x28, %rdi
callq 0x8420
movq %rax, %rdi
callq 0x88d0
movq %rax, %rcx
movq -0x248(%rbp), %rax
addq %rcx, %rax
cmpq $0xffbb, %rax # imm = 0xFFBB
jbe 0x95b9
leaq -0x1d8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x8680
jmp 0x9440
movq -0x228(%rbp), %rax
movl 0x78(%rax), %eax
movl %eax, -0x25c(%rbp)
leaq -0x1d8(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x8220
movq -0x268(%rbp), %rdi
movq %rax, -0x258(%rbp)
callq 0x88d0
movq -0x228(%rbp), %r8
movl -0x25c(%rbp), %edi
movq -0x258(%rbp), %rsi
movq %rax, %rdx
addq $0xa8, %r8
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x8070
movq %rax, -0x250(%rbp)
jmp 0x94aa
movq -0x250(%rbp), %rcx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
leaq -0x1f9(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0x8ae0
movq -0x270(%rbp), %rdx
leaq 0x3b6a(%rip), %rsi # 0xd044
leaq -0x1f8(%rbp), %rdi
callq 0x8830
jmp 0x94e8
leaq -0x190(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0x8270
jmp 0x94fd
leaq -0x1f8(%rbp), %rdi
callq 0x8c58
leaq -0x1f9(%rbp), %rdi
callq 0x8700
movq -0x190(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x190(%rbp,%rax), %rdi
xorl %esi, %esi
callq 0x8a30
jmp 0x9531
leaq -0x1d8(%rbp), %rdi
callq 0x8c58
jmp 0x95b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x96f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x95a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x959c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x8c58
leaq -0x1f9(%rbp), %rdi
callq 0x8700
leaq -0x1d8(%rbp), %rdi
callq 0x8c58
jmp 0x96f1
movq -0x228(%rbp), %rdi
addq $0x28, %rdi
callq 0x8420
movq %rax, %rsi
leaq -0x190(%rbp), %rdi
callq 0x8550
movq %rax, -0x278(%rbp)
jmp 0x95e1
movq -0x278(%rbp), %rdi
movq 0x69c9(%rip), %rsi # 0xffb8
callq 0x86c0
jmp 0x95f6
movq -0x228(%rbp), %rdi
addq $0x28, %rdi
callq 0x8780
jmp 0x9382
leaq -0x220(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x8680
jmp 0x9620
movq -0x228(%rbp), %rax
movl 0x78(%rax), %eax
movl %eax, -0x28c(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x298(%rbp)
callq 0x8220
movq -0x298(%rbp), %rdi
movq %rax, -0x288(%rbp)
callq 0x88d0
movq -0x228(%rbp), %r8
movl -0x28c(%rbp), %edi
movq -0x288(%rbp), %rsi
movq %rax, %rdx
addq $0xa8, %r8
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x8070
movq %rax, -0x280(%rbp)
jmp 0x968a
movq -0x280(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x194(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x8c58
jmp 0x96d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x8c58
jmp 0x96f1
leaq -0x190(%rbp), %rdi
callq 0x8120
movl -0x4(%rbp), %eax
addq $0x2a0, %rsp # imm = 0x2A0
popq %rbp
retq
leaq -0x190(%rbp), %rdi
callq 0x8120
movq -0x1b0(%rbp), %rdi
callq 0x8ad0
nopl (%rax)
| /truthbk[P]datadog-cpp/src/trace_dogstatsd.cpp |
datadog::Dogstatsd::format(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, double) | std::string Dogstatsd::format( std::string name, std::string value, std::vector<std::string> tags, double rate){
bool tagging = false;
std::ostringstream statd;
statd << name << ":" << value;
if (rate < 1) {
statd << "|@" << rate;
}
if (tags.size()) {
tagging = true;
// TODO: remove newlines from the tags.
std::vector<std::string>::iterator it = tags.begin();
statd << "|#" << *it++;
for( ; it != tags.end() ; ++it) {
statd << "," << *it;
}
}
if (!global_tags_str.empty()) {
if (!tagging) {
statd << "|#" ;
} else {
statd << "," ;
}
statd << global_tags_str;
}
return statd.str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %r8, -0x218(%rbp)
movq %rcx, -0x210(%rbp)
movq %rdx, -0x1e8(%rbp)
movq %rdi, -0x208(%rbp)
movq %rdi, %rax
movq %rax, -0x200(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movb $0x0, -0x31(%rbp)
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x8800
movq -0x1f0(%rbp), %rdi
movq -0x1e8(%rbp), %rsi
callq 0x8550
movq %rax, -0x1e0(%rbp)
jmp 0xa528
movq -0x1e0(%rbp), %rdi
leaq 0x2b1b(%rip), %rsi # 0xd051
callq 0x8640
movq %rax, -0x220(%rbp)
jmp 0xa544
movq -0x210(%rbp), %rsi
movq -0x220(%rbp), %rdi
callq 0x8550
jmp 0xa559
movsd 0x2a9f(%rip), %xmm0 # 0xd000
ucomisd -0x30(%rbp), %xmm0
jbe 0xa5bc
leaq 0x2ad6(%rip), %rsi # 0xd045
leaq -0x1b0(%rbp), %rdi
callq 0x8640
movq %rax, -0x228(%rbp)
jmp 0xa584
movq -0x228(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x8bc0
jmp 0xa597
jmp 0xa5bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x8120
jmp 0xa744
movq -0x218(%rbp), %rdi
callq 0x8b30
cmpq $0x0, %rax
je 0xa6b0
movq -0x218(%rbp), %rdi
movb $0x1, -0x31(%rbp)
callq 0x89c0
movq %rax, -0x1c8(%rbp)
leaq 0x2a58(%rip), %rsi # 0xd048
leaq -0x1b0(%rbp), %rdi
callq 0x8640
movq %rax, -0x230(%rbp)
jmp 0xa605
leaq -0x1c8(%rbp), %rdi
xorl %esi, %esi
callq 0x81d0
movq %rax, -0x1d0(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x8ba0
movq -0x230(%rbp), %rdi
movq %rax, %rsi
callq 0x8550
jmp 0xa637
jmp 0xa639
movq -0x218(%rbp), %rdi
callq 0x8a00
movq %rax, -0x1d8(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x87f0
testb $0x1, %al
jne 0xa665
jmp 0xa6ae
leaq 0x29ae(%rip), %rsi # 0xd01a
leaq -0x1b0(%rbp), %rdi
callq 0x8640
movq %rax, -0x238(%rbp)
jmp 0xa681
leaq -0x1c8(%rbp), %rdi
callq 0x8ba0
movq -0x238(%rbp), %rdi
movq %rax, %rsi
callq 0x8550
jmp 0xa69e
jmp 0xa6a0
leaq -0x1c8(%rbp), %rdi
callq 0x8750
jmp 0xa639
jmp 0xa6b0
movq -0x1f8(%rbp), %rdi
addq $0x40, %rdi
callq 0x89f0
testb $0x1, %al
jne 0xa713
testb $0x1, -0x31(%rbp)
jne 0xa6e1
leaq 0x2977(%rip), %rsi # 0xd048
leaq -0x1b0(%rbp), %rdi
callq 0x8640
jmp 0xa6df
jmp 0xa6f8
leaq 0x2932(%rip), %rsi # 0xd01a
leaq -0x1b0(%rbp), %rdi
callq 0x8640
jmp 0xa6f6
jmp 0xa6f8
movq -0x1f8(%rbp), %rsi
addq $0x40, %rsi
leaq -0x1b0(%rbp), %rdi
callq 0x8550
jmp 0xa711
jmp 0xa713
movq -0x208(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x8680
jmp 0xa728
leaq -0x1b0(%rbp), %rdi
callq 0x8120
movq -0x200(%rbp), %rax
addq $0x240, %rsp # imm = 0x240
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x8ad0
| /truthbk[P]datadog-cpp/src/trace_dogstatsd.cpp |
nn_print_option | static void nn_print_option (struct nn_parse_context *ctx, int opt_index,
FILE *stream)
{
char *ousage;
char *oend;
size_t olen;
struct nn_option *opt;
opt = &ctx->options[opt_index];
ousage = ctx->last_option_usage[opt_index];
if (*ousage == '-') { /* Long option */
oend = strchr (ousage, '=');
if (!oend) {
olen = strlen (ousage);
} else {
olen = (oend - ousage);
}
if (olen != strlen (opt->longname)+2) {
fprintf (stream, " %.*s[%s] ",
(int)olen, ousage, opt->longname + (olen-2));
} else {
fprintf (stream, " %s ", ousage);
}
} else if (ousage == ctx->argv[0]) { /* Binary name */
fprintf (stream, " %s (executable) ", ousage);
} else { /* Short option */
fprintf (stream, " -%c (--%s) ",
*ousage, opt->longname);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movslq %esi, %rax
imulq $0x58, %rax, %r12
addq 0x8(%rdi), %r12
movq 0x50(%rdi), %rcx
movq (%rcx,%rax,8), %r14
movsbl (%r14), %edx
cmpl $0x2d, %edx
jne 0x4912
movq %r14, %rdi
movl $0x3d, %esi
callq 0x31b0
testq %rax, %rax
je 0x493b
movq %rax, %r15
subq %r14, %r15
jmp 0x4946
movq 0x20(%rdi), %rax
cmpq (%rax), %r14
je 0x498e
movq (%r12), %rcx
leaq 0x223f(%rip), %rsi # 0x6b65
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3270
movq %r14, %rdi
callq 0x3110
movq %rax, %r15
movq (%r12), %r12
movq %r12, %rdi
callq 0x3110
addq $0x2, %rax
cmpq %rax, %r15
jne 0x4964
leaq 0x243c(%rip), %rsi # 0x6d9e
jmp 0x4995
leaq (%r12,%r15), %r8
addq $-0x2, %r8
leaq 0x21d5(%rip), %rsi # 0x6b48
movq %rbx, %rdi
movl %r15d, %edx
movq %r14, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3270
leaq 0x21be(%rip), %rsi # 0x6b53
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3270
| /Snaipe[P]nanomsg/tools/options.c |
nn_append_string | static void nn_append_string (struct nn_parse_context *ctx,
struct nn_option *opt, char *str)
{
struct nn_string_list *lst;
lst = (struct nn_string_list *)(
((char *)ctx->target) + opt->offset);
if (lst->items) {
lst->num += 1;
lst->items = realloc (lst->items, sizeof (char *) * lst->num);
} else {
lst->items = malloc (sizeof (char *));
lst->num = 1;
}
if (!lst->items) {
nn_memory_error (ctx);
}
lst->items[lst->num-1] = str;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
movslq 0x1c(%rsi), %r12
movq (%r15,%r12), %rdi
testq %rdi, %rdi
je 0x52e3
movslq 0x10(%r15,%r12), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x10(%r15,%r12)
leaq 0x8(,%rax,8), %rsi
callq 0x3260
movq %rax, (%r15,%r12)
jmp 0x52fa
movl $0x8, %edi
callq 0x30a0
movq %rax, (%r15,%r12)
movl $0x1, 0x10(%r15,%r12)
movq (%r15,%r12), %rax
testq %rax, %rax
je 0x5319
movslq 0x10(%r15,%r12), %rcx
movq %rbx, -0x8(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x374c
| /Snaipe[P]nanomsg/tools/options.c |
Buffer_peek_string_no_len_arg_Test::TestBody() | TEST(Buffer, peek_string_no_len_arg) {
auto buf = bfy_buffer_init();
bfy_buffer_add_readonly(&buf, std::data(str1), std::size(str1));
EXPECT_STREQ(std::data(str1), bfy_buffer_peek_string(&buf, nullptr));
bfy_buffer_destruct(&buf);
} | pushq %r14
pushq %rbx
subq $0xa8, %rsp
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x5fdcb
leaq 0x3fe73(%rip), %r14 # 0x617d1
movl $0x1a, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5eb21
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5f60c
leaq 0x403dd(%rip), %rsi # 0x61d5c
leaq 0x4094f(%rip), %rdx # 0x622d5
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
movq %rax, %r8
callq 0x3a30d
cmpb $0x0, (%rbx)
jne 0x219fd
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x219b5
movq (%rax), %r8
jmp 0x219bc
leaq 0x4676b(%rip), %r8 # 0x68127
leaq 0x3f6ca(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x2f5, %ecx # imm = 0x2F5
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x219fd
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x21a11
leaq 0x18(%rsp), %rdi
callq 0x2dd22
leaq 0x20(%rsp), %rdi
callq 0x5fe8e
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x21a38
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x21a47
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0x21a54
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x21a68
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_copyout_some_Test::TestBody() | TEST(Buffer, copyout_some) {
auto local = BufferWithReadonlyStrings {};
auto const n_readable = bfy_buffer_get_content_len(&local.buf);
auto const n_writable = bfy_buffer_get_space_len(&local.buf);
auto const n_pages = buffer_count_pages(&local.buf);
// copy out some of it
auto array = std::array<char, 128>{};
auto constexpr n_expected = std::size(str1) + 1;
auto const n_got = bfy_buffer_copyout(&local.buf, n_expected, std::data(array));
// confirm we got what we expected
EXPECT_EQ(n_expected, n_got);
auto const allstrs = local.allstrs;
EXPECT_TRUE(std::equal(std::data(array), std::data(array)+n_got, std::data(allstrs)));
// confirm that buffer is unchanged
EXPECT_EQ(n_readable, bfy_buffer_get_content_len(&local.buf));
EXPECT_EQ(n_writable, bfy_buffer_get_space_len(&local.buf));
EXPECT_EQ(n_pages, buffer_count_pages(&local.buf));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
callq 0x1da3c
movq %rbx, %rdi
callq 0x5e540
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x5e698
movq %rax, 0x80(%rsp)
leaq 0x90(%rsp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5e869
movq %rax, 0x78(%rsp)
xorps %xmm0, %xmm0
leaq 0x150(%rsp), %rdx
movaps %xmm0, 0x70(%rdx)
movaps %xmm0, 0x60(%rdx)
movaps %xmm0, 0x50(%rdx)
movaps %xmm0, 0x40(%rdx)
movaps %xmm0, 0x30(%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq $0x1b, 0x70(%rsp)
leaq 0x90(%rsp), %rdi
movl $0x1b, %esi
callq 0x5f545
leaq 0x68(%rsp), %r8
movq %rax, (%r8)
leaq 0x40625(%rip), %rsi # 0x62321
leaq 0x40629(%rip), %rdx # 0x6232c
leaq 0x48(%rsp), %rdi
leaq 0x70(%rsp), %rcx
callq 0x30cf4
cmpb $0x0, 0x48(%rsp)
jne 0x21d7d
leaq 0x20(%rsp), %rdi
callq 0x37e78
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x21d32
movq (%rax), %r8
jmp 0x21d39
leaq 0x463ee(%rip), %r8 # 0x68127
leaq 0x3f34d(%rip), %rdx # 0x6108d
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x30e, %ecx # imm = 0x30E
callq 0x341ce
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3426c
leaq 0x10(%rsp), %rdi
callq 0x3423a
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x21d7d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rsp), %rsi
testq %rsi, %rsi
je 0x21d91
leaq 0x50(%rsp), %rdi
callq 0x2dd22
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x118(%rsp), %rsi
movq 0x120(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x3078a
movq 0x68(%rsp), %rdx
testq %rdx, %rdx
je 0x21dda
movq 0x48(%rsp), %rsi
leaq 0x150(%rsp), %rdi
callq 0x104b0
testl %eax, %eax
sete %al
jmp 0x21ddc
movb $0x1, %al
leaq 0x18(%rsp), %r14
movb %al, -0x8(%r14)
movq $0x0, (%r14)
testb %al, %al
jne 0x21e86
leaq 0x8(%rsp), %rdi
callq 0x37e78
leaq 0x4052d(%rip), %rdx # 0x62332
leaq 0x3f757(%rip), %rcx # 0x61563
leaq 0x3f756(%rip), %r8 # 0x61569
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x394db
movq 0x20(%rsp), %r8
leaq 0x3f25f(%rip), %rdx # 0x6108d
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
movl $0x310, %ecx # imm = 0x310
callq 0x341ce
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3426c
leaq 0x40(%rsp), %rdi
callq 0x3423a
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21e76
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21e86
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x21e98
movq %r14, %rdi
callq 0x2dd22
leaq 0x90(%rsp), %rdi
callq 0x5e540
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
leaq 0x3fde5(%rip), %rsi # 0x61c99
leaq 0x3fbb7(%rip), %rdx # 0x61a72
leaq 0x20(%rsp), %rdi
leaq 0x88(%rsp), %rcx
callq 0x30cf4
cmpb $0x0, 0x20(%rsp)
jne 0x21f38
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x21eed
movq (%rax), %r8
jmp 0x21ef4
leaq 0x46233(%rip), %r8 # 0x68127
leaq 0x3f192(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x313, %ecx # imm = 0x313
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x21f38
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x21f4c
leaq 0x28(%rsp), %rdi
callq 0x2dd22
leaq 0x90(%rsp), %rdi
callq 0x5e698
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
leaq 0x48bdf(%rip), %rsi # 0x6ab47
leaq 0x3fb57(%rip), %rdx # 0x61ac6
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rcx
callq 0x30cf4
cmpb $0x0, 0x20(%rsp)
jne 0x21fec
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x21fa1
movq (%rax), %r8
jmp 0x21fa8
leaq 0x4617f(%rip), %r8 # 0x68127
leaq 0x3f0de(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x314, %ecx # imm = 0x314
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x21fec
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x22000
leaq 0x28(%rsp), %rdi
callq 0x2dd22
leaq 0x90(%rsp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5e869
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
leaq 0x40354(%rip), %rsi # 0x6237b
leaq 0x3fa25(%rip), %rdx # 0x61a53
leaq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rcx
callq 0x30cf4
cmpb $0x0, 0x20(%rsp)
jne 0x220a8
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x2205d
movq (%rax), %r8
jmp 0x22064
leaq 0x460c3(%rip), %r8 # 0x68127
leaq 0x3f022(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x315, %ecx # imm = 0x315
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x220a8
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x220bc
leaq 0x28(%rsp), %rdi
callq 0x2dd22
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x220d3
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x90(%rsp), %rdi
callq 0x1db1a
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x220f9
jmp 0x22108
jmp 0x22126
jmp 0x220f9
jmp 0x22108
jmp 0x22126
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x2210b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2211b
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x22129
movq %rax, %rbx
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x2213d
leaq 0x28(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x28(%rsp)
jmp 0x22214
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3423a
jmp 0x2215d
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2217d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x2217d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2218d
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x2219b
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x22214
movq %r14, %rdi
callq 0x2dd22
jmp 0x22214
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3423a
jmp 0x221c1
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x221d1
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x20(%rsp)
jmp 0x221df
movq %rax, %rbx
movq 0x50(%rsp), %rsi
testq %rsi, %rsi
je 0x221f3
leaq 0x50(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x50(%rsp)
jmp 0x2222b
jmp 0x22208
jmp 0x22208
jmp 0x22208
jmp 0x22208
jmp 0x22208
movq %rax, %rbx
jmp 0x2222b
jmp 0x22211
jmp 0x22211
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x2222b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0x90(%rsp), %rdi
callq 0x1db1a
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_copyout_range_all_but_first_and_last_char_Test::TestBody() | TEST(Buffer, copyout_range_all_but_first_and_last_char) {
auto local = BufferWithReadonlyStrings {};
auto array = std::array<char, 128>{};
auto const n_wanted = std::size(local.allstrs) - 2;
auto const begin = 1;
auto const end = begin + n_wanted;
auto const len = bfy_buffer_copyout_range(&local.buf, begin, end, std::data(array));
EXPECT_EQ(len, n_wanted);
EXPECT_EQ(0, memcmp(std::data(local.allstrs)+1, std::data(array), len));
} | pushq %rbx
subq $0x170, %rsp # imm = 0x170
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x1da3c
xorps %xmm0, %xmm0
leaq 0xf0(%rsp), %rcx
movaps %xmm0, 0x70(%rcx)
movaps %xmm0, 0x60(%rcx)
movaps %xmm0, 0x50(%rcx)
movaps %xmm0, 0x40(%rcx)
movaps %xmm0, 0x30(%rcx)
movaps %xmm0, 0x20(%rcx)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
movq 0x90(%rbx), %rdx
leaq -0x2(%rdx), %rax
movq %rax, 0x28(%rsp)
decq %rdx
movl $0x1, %esi
movq %rbx, %rdi
callq 0x5f3c0
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x3f0ae(%rip), %rsi # 0x62166
leaq 0x3edc3(%rip), %rdx # 0x61e82
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %r8
callq 0x30cf4
cmpb $0x0, 0x10(%rsp)
jne 0x23134
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x230ec
movq (%rax), %r8
jmp 0x230f3
leaq 0x45034(%rip), %r8 # 0x68127
leaq 0x3df93(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x35e, %ecx # imm = 0x35E
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x23134
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x23148
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq %rsp, %rbx
movl $0x0, (%rbx)
movq 0xb8(%rsp), %rdi
incq %rdi
movq 0x20(%rsp), %rdx
leaq 0xf0(%rsp), %rsi
callq 0x101c0
leaq 0x8(%rsp), %r8
movl %eax, (%r8)
leaq 0x466f9(%rip), %rsi # 0x69876
leaq 0x3f2f0(%rip), %rdx # 0x62474
leaq 0x10(%rsp), %rdi
movq %rbx, %rcx
callq 0x30dee
cmpb $0x0, 0x10(%rsp)
jne 0x231f7
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x231af
movq (%rax), %r8
jmp 0x231b6
leaq 0x44f71(%rip), %r8 # 0x68127
leaq 0x3ded0(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x35f, %ecx # imm = 0x35F
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x231f7
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x2320b
leaq 0x18(%rsp), %rdi
callq 0x2dd22
leaq 0x30(%rsp), %rdi
callq 0x1db1a
addq $0x170, %rsp # imm = 0x170
popq %rbx
retq
jmp 0x23224
jmp 0x23233
jmp 0x2324f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x23236
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x23245
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0x23252
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x23266
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x18(%rsp)
jmp 0x23278
jmp 0x23275
jmp 0x23275
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1db1a
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_endian_16_Test::TestBody() | ~BufferWithLocalArray() {
bfy_buffer_destruct(&buf);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
xorps %xmm0, %xmm0
leaq 0xb0(%rsp), %rsi
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
leaq 0x28(%rsp), %r14
movl $0x40, %edx
movq %r14, %rdi
callq 0x5fe03
leaq 0xf0(%rsp), %rbx
movl $0x88, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x103b0
movw $0x1, 0x1e(%rsp)
movl $0x0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5edcc
movq %rsp, %r8
movl %eax, (%r8)
leaq 0x46573(%rip), %rsi # 0x69876
leaq 0x3f1ae(%rip), %rdx # 0x624b8
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rcx
callq 0x30dee
cmpb $0x0, 0x28(%rsp)
jne 0x2337e
leaq 0x8(%rsp), %rdi
callq 0x37e78
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x23339
movq (%rax), %r8
jmp 0x23340
leaq 0x44de7(%rip), %r8 # 0x68127
leaq 0x3dd46(%rip), %rdx # 0x6108d
movq %rsp, %rdi
movl $0x1, %esi
movl $0x368, %ecx # imm = 0x368
callq 0x341ce
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x3426c
movq %rsp, %rdi
callq 0x3423a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2337e
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0x23392
leaq 0x30(%rsp), %rdi
callq 0x2dd22
movzwl 0xb0(%rsp), %eax
cmpl $0x100, %eax # imm = 0x100
leaq 0x10(%rsp), %r15
sete -0x8(%r15)
movq $0x0, (%r15)
cmpw $0x100, %ax # imm = 0x100
je 0x23447
movq %rsp, %rdi
callq 0x37e78
leaq 0x3f117(%rip), %rdx # 0x624e0
leaq 0x3e193(%rip), %rcx # 0x61563
leaq 0x3e192(%rip), %r8 # 0x61569
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x394db
movq 0x28(%rsp), %r8
leaq 0x3dc9b(%rip), %rdx # 0x6108d
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
movl $0x369, %ecx # imm = 0x369
callq 0x341ce
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x20(%rsp), %rdi
callq 0x3423a
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23438
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x23447
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x23459
movq %r15, %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x5f8eb
leaq 0x8(%rsp), %r8
movw %ax, (%r8)
leaq 0x3e811(%rip), %rsi # 0x61c82
leaq 0x3f0de(%rip), %rdx # 0x62556
leaq 0x28(%rsp), %rdi
leaq 0x1e(%rsp), %rcx
callq 0x32d29
cmpb $0x0, 0x28(%rsp)
jne 0x234ec
leaq 0x8(%rsp), %rdi
callq 0x37e78
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x234a7
movq (%rax), %r8
jmp 0x234ae
leaq 0x44c79(%rip), %r8 # 0x68127
leaq 0x3dbd8(%rip), %rdx # 0x6108d
movq %rsp, %rdi
movl $0x1, %esi
movl $0x36a, %ecx # imm = 0x36A
callq 0x341ce
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x3426c
movq %rsp, %rdi
callq 0x3423a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x234ec
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0x23500
leaq 0x30(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x5fe8e
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
jmp 0x23569
jmp 0x2358d
jmp 0x235ab
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x3423a
jmp 0x23530
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23550
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x23550
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2355f
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0x23579
movq %rax, %r14
movq %rsp, %rdi
callq 0x3423a
jmp 0x23590
movq %rax, %r14
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x235d4
movq %r15, %rdi
callq 0x2dd22
jmp 0x235d4
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x235a0
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x235ae
movq %rax, %r14
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0x235c2
leaq 0x30(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x30(%rsp)
jmp 0x235d4
jmp 0x235e4
jmp 0x235d1
movq %rax, %r14
movq %rbx, %rdi
callq 0x5fe8e
movq %r14, %rdi
callq 0x108a0
movq %rax, %rdi
callq 0x2dd16
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_add_buffer_Test::TestBody() | TEST(Buffer, add_buffer) {
auto a = BufferWithReadonlyStrings {};
auto b = BufferWithReadonlyStrings {};
auto const n_expected_vecs = buffer_count_pages(&a.buf) + buffer_count_pages(&b.buf);
auto const expected_size = std::size(a.allstrs) + std::size(b.allstrs);
auto buf = bfy_buffer_init();
EXPECT_EQ(0, bfy_buffer_add_buffer(&buf, &a.buf));
EXPECT_EQ(0, bfy_buffer_add_buffer(&buf, &b.buf));
EXPECT_EQ(n_expected_vecs, bfy_buffer_peek_all(&buf, NULL, 0));
EXPECT_EQ(expected_size, bfy_buffer_get_content_len(&buf));
auto const str = buffer_remove_string(&buf);
EXPECT_EQ(expected_size, std::size(str));
bfy_buffer_destruct(&buf);
} | pushq %rbx
subq $0x260, %rsp # imm = 0x260
leaq 0x1a0(%rsp), %rdi
callq 0x1da3c
leaq 0xe0(%rsp), %rdi
callq 0x1da3c
leaq 0x1a0(%rsp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5e869
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5e869
addq %rbx, %rax
movq %rax, 0x50(%rsp)
movq 0x170(%rsp), %rax
addq 0x230(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5fdcb
movl $0x0, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x1a0(%rsp), %rsi
callq 0x5ee79
leaq 0x8(%rsp), %r8
movl %eax, (%r8)
leaq 0x45b25(%rip), %rsi # 0x69876
leaq 0x3e8d7(%rip), %rdx # 0x6262f
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rcx
callq 0x30dee
cmpb $0x0, 0x20(%rsp)
jne 0x23dd2
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x23d87
movq (%rax), %r8
jmp 0x23d8e
leaq 0x44399(%rip), %r8 # 0x68127
leaq 0x3d2f8(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x386, %ecx # imm = 0x386
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23dd2
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x23de6
leaq 0x28(%rsp), %rdi
callq 0x2dd22
movl $0x0, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x5ee79
leaq 0x8(%rsp), %r8
movl %eax, (%r8)
leaq 0x45a67(%rip), %rsi # 0x69876
leaq 0x3e83d(%rip), %rdx # 0x62653
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rcx
callq 0x30dee
cmpb $0x0, 0x20(%rsp)
jne 0x23e90
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x23e45
movq (%rax), %r8
jmp 0x23e4c
leaq 0x442db(%rip), %r8 # 0x68127
leaq 0x3d23a(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x387, %ecx # imm = 0x387
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23e90
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x23ea4
leaq 0x28(%rsp), %rdi
callq 0x2dd22
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5e879
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
leaq 0x3d31d(%rip), %rsi # 0x611de
leaq 0x3e7af(%rip), %rdx # 0x62677
leaq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rcx
callq 0x30cf4
cmpb $0x0, 0x20(%rsp)
jne 0x23f42
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x23ef7
movq (%rax), %r8
jmp 0x23efe
leaq 0x44229(%rip), %r8 # 0x68127
leaq 0x3d188(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x388, %ecx # imm = 0x388
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23f42
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x23f56
leaq 0x28(%rsp), %rdi
callq 0x2dd22
leaq 0x58(%rsp), %rdi
callq 0x5e540
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
leaq 0x3e72d(%rip), %rsi # 0x6269c
leaq 0x3d173(%rip), %rdx # 0x610e9
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rcx
callq 0x30cf4
cmpb $0x0, 0x20(%rsp)
jne 0x23ff0
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x23fa5
movq (%rax), %r8
jmp 0x23fac
leaq 0x4417b(%rip), %r8 # 0x68127
leaq 0x3d0da(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x389, %ecx # imm = 0x389
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23ff0
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x24004
leaq 0x28(%rsp), %rdi
callq 0x2dd22
leaq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1bce6
movq 0x28(%rsp), %rax
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x3e675(%rip), %rsi # 0x6269c
leaq 0x3d20f(%rip), %rdx # 0x6123d
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rcx
callq 0x30cf4
cmpb $0x0, 0x10(%rsp)
jne 0x240a8
leaq 0x8(%rsp), %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x2405d
movq (%rax), %r8
jmp 0x24064
leaq 0x440c3(%rip), %r8 # 0x68127
leaq 0x3d022(%rip), %rdx # 0x6108d
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
movl $0x38c, %ecx # imm = 0x38C
callq 0x341ce
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3426c
leaq 0x40(%rsp), %rdi
callq 0x3423a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x240a8
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x240bc
leaq 0x18(%rsp), %rdi
callq 0x2dd22
leaq 0x58(%rsp), %rdi
callq 0x5fe8e
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x240e1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
leaq 0xe0(%rsp), %rdi
callq 0x1db1a
leaq 0x1a0(%rsp), %rdi
callq 0x1db1a
addq $0x260, %rsp # imm = 0x260
popq %rbx
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3423a
jmp 0x24116
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x24126
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x24134
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x24148
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x18(%rsp)
jmp 0x241b9
jmp 0x24165
jmp 0x24174
jmp 0x24192
jmp 0x24165
jmp 0x24174
jmp 0x24192
jmp 0x24165
jmp 0x24174
jmp 0x24192
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x24177
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x24187
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x24195
movq %rax, %rbx
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x241a9
leaq 0x28(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x28(%rsp)
jmp 0x241ea
jmp 0x241b6
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x241ea
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x241ea
jmp 0x241e7
jmp 0x241e7
movq %rax, %rbx
jmp 0x241f7
jmp 0x241e7
jmp 0x241e7
jmp 0x241e7
jmp 0x241e7
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x1db1a
leaq 0x1a0(%rsp), %rdi
callq 0x1db1a
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_reserve_space_never_returns_too_much_Test::TestBody() | ~BufferWithLocalArray() {
bfy_buffer_destruct(&buf);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
xorps %xmm0, %xmm0
leaq 0xc0(%rsp), %r14
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
leaq 0x38(%rsp), %r15
movl $0x40, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x5fe03
leaq 0x100(%rsp), %rbx
movl $0x88, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x103b0
movq %r14, (%r15)
movq $0x20, 0x8(%r15)
movq %r14, 0x28(%rsp)
movq $0x40, 0x30(%rsp)
movl $0x20, %esi
movq %rbx, %rdi
callq 0x5e8b5
leaq 0x18(%rsp), %r8
movq %rax, (%r8)
movq %rdx, 0x8(%r8)
leaq 0x3c440(%rip), %rsi # 0x629e8
leaq 0x3c44a(%rip), %rdx # 0x629f9
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rcx
callq 0x31296
cmpb $0x0, 0x8(%rsp)
jne 0x26623
leaq 0x18(%rsp), %rdi
callq 0x37e78
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x265de
movq (%rax), %r8
jmp 0x265e5
leaq 0x41b42(%rip), %r8 # 0x68127
leaq 0x3aaa1(%rip), %rdx # 0x6108d
movq %rsp, %rdi
movl $0x1, %esi
movl $0x422, %ecx # imm = 0x422
callq 0x341ce
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x3426c
movq %rsp, %rdi
callq 0x3423a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x26623
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x26637
leaq 0x10(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x5e88d
leaq 0x18(%rsp), %r8
movq %rax, (%r8)
movq %rdx, 0x8(%r8)
leaq 0x3c3d6(%rip), %rsi # 0x62a28
leaq 0x3c3dd(%rip), %rdx # 0x62a36
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x31296
cmpb $0x0, 0x8(%rsp)
jne 0x266cd
leaq 0x18(%rsp), %rdi
callq 0x37e78
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x26688
movq (%rax), %r8
jmp 0x2668f
leaq 0x41a98(%rip), %r8 # 0x68127
leaq 0x3a9f7(%rip), %rdx # 0x6108d
movq %rsp, %rdi
movl $0x1, %esi
movl $0x423, %ecx # imm = 0x423
callq 0x341ce
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x3426c
movq %rsp, %rdi
callq 0x3423a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x266cd
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x266e1
leaq 0x10(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x5fe8e
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
jmp 0x266fc
jmp 0x26709
jmp 0x26727
movq %rax, %r14
movq %rsp, %rdi
callq 0x3423a
jmp 0x2670c
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2671c
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rsp)
jmp 0x2672a
movq %rax, %r14
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x2673e
leaq 0x10(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x10(%rsp)
jmp 0x26750
jmp 0x26760
jmp 0x2674d
movq %rax, %r14
movq %rbx, %rdi
callq 0x5fe8e
movq %r14, %rdi
callq 0x108a0
movq %rax, %rdi
callq 0x2dd16
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_commit_space_Test::TestBody() | TEST(Buffer, commit_space) {
// setup pt 1: create a buffer
auto buf = bfy_buffer_init();
EXPECT_EQ(0, bfy_buffer_get_content_len(&buf));
// setup pt 2: reserve space and write into it
auto constexpr str = std::string_view { "Lorem ipsum dolor sit amet" };
auto const io = bfy_buffer_reserve_space(&buf, std::size(str));
auto const precommit_space = bfy_buffer_get_space_len(&buf);
EXPECT_NE(nullptr, io.iov_base);
EXPECT_LE(std::size(str), io.iov_len);
memcpy(io.iov_base, std::data(str), std::size(str));
// confirm that the space can be committed
EXPECT_EQ(0, bfy_buffer_commit_space(&buf, std::size(str)));
// confirm that the committed space is now readable content
EXPECT_EQ(std::size(str), bfy_buffer_get_content_len(&buf));
EXPECT_EQ(precommit_space - std::size(str), bfy_buffer_get_space_len(&buf));
EXPECT_EQ(str, buffer_remove_string(&buf));
bfy_buffer_destruct(&buf);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0x5fdcb
leaq 0x58(%rsp), %r14
movl $0x0, (%r14)
movq %rbx, %rdi
callq 0x5e540
leaq 0x40(%rsp), %r8
movq %rax, (%r8)
leaq 0x430d2(%rip), %rsi # 0x69876
leaq 0x3a93e(%rip), %rdx # 0x610e9
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x3081a
cmpb $0x0, (%rbx)
jne 0x26824
leaq 0x40(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x267d9
movq (%rax), %r8
jmp 0x267e0
leaq 0x41947(%rip), %r8 # 0x68127
leaq 0x3a8a6(%rip), %rdx # 0x6108d
leaq 0x58(%rsp), %rdi
movl $0x1, %esi
movl $0x429, %ecx # imm = 0x429
callq 0x341ce
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3426c
leaq 0x58(%rsp), %rdi
callq 0x3423a
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x26824
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x26838
leaq 0x28(%rsp), %rdi
callq 0x2dd22
movups 0x5ee21(%rip), %xmm0 # 0x85660
movaps %xmm0, 0x40(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0x5e8b5
leaq 0x58(%rsp), %r14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
movq %rbx, %rdi
callq 0x5e698
movq %rax, %rbx
leaq 0x10(%rsp), %rcx
movq $0x0, (%rcx)
leaq 0x3a8b6(%rip), %rsi # 0x61136
leaq 0x3c0fe(%rip), %rdx # 0x62985
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %r8
callq 0x2d356
cmpb $0x0, (%r15)
jne 0x26901
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x268b6
movq (%rax), %r8
jmp 0x268bd
leaq 0x4186a(%rip), %r8 # 0x68127
leaq 0x3a7c9(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x42f, %ecx # imm = 0x42F
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26901
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x60(%rsp), %r14
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x2691a
leaq 0x28(%rsp), %rdi
callq 0x2dd22
movq 0x40(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x3a90f(%rip), %rsi # 0x6123d
leaq 0x3c05c(%rip), %rdx # 0x62991
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %r8
callq 0x2d1f4
cmpb $0x0, (%r15)
jne 0x269af
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x26964
movq (%rax), %r8
jmp 0x2696b
leaq 0x417bc(%rip), %r8 # 0x68127
leaq 0x3a71b(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x430, %ecx # imm = 0x430
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x269af
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x269c3
leaq 0x28(%rsp), %rdi
callq 0x2dd22
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rsi
callq 0x103b0
leaq 0x10(%rsp), %r14
movl $0x0, (%r14)
movq 0x40(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x5ea31
leaq 0x8(%rsp), %r8
movl %eax, (%r8)
leaq 0x42e75(%rip), %rsi # 0x69876
leaq 0x3c05d(%rip), %rdx # 0x62a65
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
callq 0x30dee
cmpb $0x0, (%r15)
jne 0x26a82
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x26a37
movq (%rax), %r8
jmp 0x26a3e
leaq 0x416e9(%rip), %r8 # 0x68127
leaq 0x3a648(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x434, %ecx # imm = 0x434
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26a82
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x26a96
leaq 0x28(%rsp), %rdi
callq 0x2dd22
movq 0x40(%rsp), %rax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x68(%rsp), %rdi
callq 0x5e540
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x3a781(%rip), %rsi # 0x6123d
leaq 0x3a626(%rip), %rdx # 0x610e9
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
callq 0x30cf4
cmpb $0x0, (%r15)
jne 0x26b3d
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x26af2
movq (%rax), %r8
jmp 0x26af9
leaq 0x4162e(%rip), %r8 # 0x68127
leaq 0x3a58d(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x437, %ecx # imm = 0x437
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26b3d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x26b51
leaq 0x28(%rsp), %rdi
callq 0x2dd22
subq 0x40(%rsp), %rbx
leaq 0x10(%rsp), %r14
movq %rbx, (%r14)
leaq 0x68(%rsp), %rdi
callq 0x5e698
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x3bf1c(%rip), %rsi # 0x62a93
leaq 0x3a58c(%rip), %rdx # 0x6110a
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x30cf4
cmpb $0x0, (%rbx)
jne 0x26bf7
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x26bac
movq (%rax), %r8
jmp 0x26bb3
leaq 0x41574(%rip), %r8 # 0x68127
leaq 0x3a4d3(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x438, %ecx # imm = 0x438
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26bf7
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x26c0b
leaq 0x28(%rsp), %rdi
callq 0x2dd22
leaq 0x20(%rsp), %rbx
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x1bce6
leaq 0x3b627(%rip), %rsi # 0x6224b
leaq 0x3be89(%rip), %rdx # 0x62ab4
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rcx
movq %rbx, %r8
callq 0x31c7a
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26c58
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
cmpb $0x0, 0x10(%rsp)
jne 0x26cc3
leaq 0x20(%rsp), %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x26c78
movq (%rax), %r8
jmp 0x26c7f
leaq 0x414a8(%rip), %r8 # 0x68127
leaq 0x3a407(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x439, %ecx # imm = 0x439
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x26cc3
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x26cd7
leaq 0x18(%rsp), %rdi
callq 0x2dd22
leaq 0x68(%rsp), %rdi
callq 0x5fe8e
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x26d00
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x26d10
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x20(%rsp)
jmp 0x26d1e
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x26d32
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x18(%rsp)
jmp 0x26dcb
jmp 0x26d56
jmp 0x26d67
jmp 0x26d56
jmp 0x26db4
jmp 0x26d67
jmp 0x26d56
jmp 0x26db4
jmp 0x26d67
jmp 0x26d56
jmp 0x26db4
jmp 0x26d67
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x26d6a
jmp 0x26db4
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26d7a
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x26db7
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3423a
jmp 0x26d99
jmp 0x26db4
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x26da9
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x40(%rsp)
jmp 0x26db7
movq %rax, %rbx
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x26dcb
leaq 0x28(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x108a0
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26dcb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x26dcb
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_add_reference_callback_reached_in_buffer_dtor_Test::TestBody() | TEST(Buffer, add_reference_callback_reached_in_buffer_dtor) {
auto cb = [](void* data, size_t len, void* vdata) {
auto* iop = reinterpret_cast<bfy_iovec*>(vdata);
iop->iov_base = data;
iop->iov_len = len;
};
// setup: add the reference to the buffer
auto buf = bfy_buffer_init();
auto constexpr str = std::string_view { "Lorem ipsum dolor sit amet" };
auto io = bfy_iovec {};
EXPECT_EQ(0, bfy_buffer_add_reference(&buf, std::data(str), std::size(str), cb, &io));
// confirm that the callback was invoked in the destructor
bfy_buffer_destruct(&buf);
EXPECT_EQ(std::data(str), io.iov_base);
EXPECT_EQ(std::size(str), io.iov_len);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x5fdcb
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r8
movaps %xmm0, (%r8)
movq %rsp, %r15
movl $0x0, (%r15)
leaq 0x3a2d1(%rip), %rbx # 0x617d1
leaq 0x59fd(%rip), %rcx # 0x2cf04
movl $0x1a, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5eb8d
leaq 0x8(%rsp), %r8
movl %eax, (%r8)
leaq 0x42350(%rip), %rsi # 0x69876
leaq 0x3b677(%rip), %rdx # 0x62ba4
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r15, %rcx
callq 0x30dee
cmpb $0x0, (%r14)
jne 0x275a2
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x2755a
movq (%rax), %r8
jmp 0x27561
leaq 0x40bc6(%rip), %r8 # 0x68127
leaq 0x39b25(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x46e, %ecx # imm = 0x46E
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x275a2
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x275b6
leaq 0x18(%rsp), %rdi
callq 0x2dd22
leaq 0x38(%rsp), %rdi
callq 0x5fe8e
movq %rsp, %rcx
movq %rbx, (%rcx)
leaq 0x3b61f(%rip), %rsi # 0x62bec
leaq 0x3b3b1(%rip), %rdx # 0x62985
leaq 0x10(%rsp), %rbx
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
callq 0x310e7
cmpb $0x0, (%rbx)
jne 0x2764a
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x27602
movq (%rax), %r8
jmp 0x27609
leaq 0x40b1e(%rip), %r8 # 0x68127
leaq 0x39a7d(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x472, %ecx # imm = 0x472
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2764a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x2765e
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq %rsp, %rcx
movq $0x1a, (%rcx)
leaq 0x28(%rsp), %r8
leaq 0x39bc9(%rip), %rsi # 0x6123d
leaq 0x3b316(%rip), %rdx # 0x62991
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30cf4
cmpb $0x0, (%rbx)
jne 0x276ec
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x276a4
movq (%rax), %r8
jmp 0x276ab
leaq 0x40a7c(%rip), %r8 # 0x68127
leaq 0x399db(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x473, %ecx # imm = 0x473
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x276ec
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x27700
leaq 0x18(%rsp), %rdi
callq 0x2dd22
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x27717
jmp 0x27728
jmp 0x27717
jmp 0x27744
jmp 0x27728
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x2772b
jmp 0x27744
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2773a
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0x27747
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x2775b
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_add_reference_callback_reached_after_ownership_changed_Test::TestBody() | TEST(Buffer, add_reference_callback_reached_after_ownership_changed) {
auto cb = [](void* data, size_t len, void* vdata) {
auto* iop = reinterpret_cast<bfy_iovec*>(vdata);
iop->iov_base = data;
iop->iov_len = len;
};
// setup: add the reference to one buffer
auto src = bfy_buffer_init();
auto constexpr str = std::string_view { "Lorem ipsum dolor sit amet" };
auto io = bfy_iovec {};
EXPECT_EQ(0, bfy_buffer_add_reference(&src, std::data(str), std::size(str), cb, &io));
EXPECT_EQ(std::size(str), bfy_buffer_get_content_len(&src));
// transfer the contents to another buffer
auto tgt = bfy_buffer_init();
bfy_buffer_add_buffer(&tgt, &src);
EXPECT_EQ(0, bfy_buffer_get_content_len(&src));
EXPECT_EQ(std::size(str), bfy_buffer_get_content_len(&tgt));
// confirm that destroying the src buffer does not invoke the unref function
bfy_buffer_destruct(&src);
EXPECT_EQ(0, io.iov_len);
EXPECT_EQ(nullptr, io.iov_base);
// confirm that destroying the tgt buffer *does* invoke the callback
// since that is who owns the reference now
bfy_buffer_destruct(&tgt);
EXPECT_EQ(std::size(str), io.iov_len);
EXPECT_EQ(std::data(str), io.iov_base);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x140, %rsp # imm = 0x140
leaq 0xb8(%rsp), %r14
movq %r14, %rdi
callq 0x5fdcb
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r8
movaps %xmm0, (%r8)
leaq 0x10(%rsp), %r15
movl $0x0, (%r15)
leaq 0x3a032(%rip), %rbx # 0x617d1
leaq 0x5766(%rip), %rcx # 0x2cf0c
movl $0x1a, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5eb8d
movq %rsp, %r8
movl %eax, (%r8)
leaq 0x420b3(%rip), %rsi # 0x69876
leaq 0x3b468(%rip), %rdx # 0x62c32
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rcx
callq 0x30dee
cmpb $0x0, (%r14)
jne 0x2783e
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x277f9
movq (%rax), %r8
jmp 0x27800
leaq 0x40927(%rip), %r8 # 0x68127
leaq 0x39886(%rip), %rdx # 0x6108d
movq %rsp, %rdi
movl $0x1, %esi
movl $0x481, %ecx # imm = 0x481
callq 0x341ce
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
movq %rsp, %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2783e
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rsp), %rsi
testq %rsi, %rsi
je 0x27852
leaq 0x38(%rsp), %rdi
callq 0x2dd22
leaq 0x10(%rsp), %r14
movq $0x1a, (%r14)
leaq 0xb8(%rsp), %rdi
callq 0x5e540
movq %rsp, %r8
movq %rax, (%r8)
leaq 0x399c5(%rip), %rsi # 0x6123d
leaq 0x3b3fb(%rip), %rdx # 0x62c7a
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
callq 0x30cf4
cmpb $0x0, (%r15)
jne 0x278f3
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x278ae
movq (%rax), %r8
jmp 0x278b5
leaq 0x40872(%rip), %r8 # 0x68127
leaq 0x397d1(%rip), %rdx # 0x6108d
movq %rsp, %rdi
movl $0x1, %esi
movl $0x482, %ecx # imm = 0x482
callq 0x341ce
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
movq %rsp, %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x278f3
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rsp), %rsi
testq %rsi, %rsi
je 0x27907
leaq 0x38(%rsp), %rdi
callq 0x2dd22
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x5fdcb
leaq 0xb8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5ee79
leaq 0x8(%rsp), %r14
movl $0x0, (%r14)
movq %r15, %rdi
callq 0x5e540
movq %rsp, %r8
movq %rax, (%r8)
leaq 0x41f2e(%rip), %rsi # 0x69876
leaq 0x3b32b(%rip), %rdx # 0x62c7a
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
callq 0x3081a
cmpb $0x0, (%r15)
jne 0x279c4
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x2797c
movq (%rax), %r8
jmp 0x27983
leaq 0x407a4(%rip), %r8 # 0x68127
leaq 0x39703(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x487, %ecx # imm = 0x487
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x279c4
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x279d8
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq %rsp, %r14
movq $0x1a, (%r14)
leaq 0x30(%rsp), %rdi
callq 0x5e540
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x39842(%rip), %rsi # 0x6123d
leaq 0x3b299(%rip), %rdx # 0x62c9b
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
callq 0x30cf4
cmpb $0x0, (%r15)
jne 0x27a77
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x27a2f
movq (%rax), %r8
jmp 0x27a36
leaq 0x406f1(%rip), %r8 # 0x68127
leaq 0x39650(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x488, %ecx # imm = 0x488
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x27a77
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x27a8b
leaq 0x18(%rsp), %rdi
callq 0x2dd22
leaq 0xb8(%rsp), %rdi
callq 0x5fe8e
movq %rsp, %rcx
movl $0x0, (%rcx)
leaq 0x28(%rsp), %r14
leaq 0x41dc9(%rip), %rsi # 0x69876
leaq 0x3aedd(%rip), %rdx # 0x62991
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %r8
callq 0x3081a
cmpb $0x0, (%r15)
jne 0x27b29
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x27ae1
movq (%rax), %r8
jmp 0x27ae8
leaq 0x4063f(%rip), %r8 # 0x68127
leaq 0x3959e(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x48c, %ecx # imm = 0x48C
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x27b29
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x27b3d
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq 0x20(%rsp), %rax
movq %rsp, %r8
movq %rax, (%r8)
leaq 0x8(%rsp), %rcx
movq $0x0, (%rcx)
leaq 0x395db(%rip), %rsi # 0x61136
leaq 0x3ae23(%rip), %rdx # 0x62985
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x31e35
cmpb $0x0, (%r15)
jne 0x27bd4
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x27b8c
movq (%rax), %r8
jmp 0x27b93
leaq 0x40594(%rip), %r8 # 0x68127
leaq 0x394f3(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x48d, %ecx # imm = 0x48D
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x27bd4
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x27be8
leaq 0x18(%rsp), %rdi
callq 0x2dd22
leaq 0x30(%rsp), %rdi
callq 0x5fe8e
movq %rsp, %rcx
movq $0x1a, (%rcx)
leaq 0x3963a(%rip), %rsi # 0x6123d
leaq 0x3ad87(%rip), %rdx # 0x62991
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %r8
callq 0x30cf4
cmpb $0x0, (%r15)
jne 0x27c7f
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x27c37
movq (%rax), %r8
jmp 0x27c3e
leaq 0x404e9(%rip), %r8 # 0x68127
leaq 0x39448(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x492, %ecx # imm = 0x492
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x27c7f
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x27c93
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq %rsp, %rcx
movq %rbx, (%rcx)
leaq 0x3af4c(%rip), %rsi # 0x62bec
leaq 0x3acde(%rip), %rdx # 0x62985
leaq 0x10(%rsp), %rbx
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
callq 0x310e7
cmpb $0x0, (%rbx)
jne 0x27d1d
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x27cd5
movq (%rax), %r8
jmp 0x27cdc
leaq 0x4044b(%rip), %r8 # 0x68127
leaq 0x393aa(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x493, %ecx # imm = 0x493
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x27d1d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x27d31
leaq 0x18(%rsp), %rdi
callq 0x2dd22
addq $0x140, %rsp # imm = 0x140
popq %rbx
popq %r14
popq %r15
retq
jmp 0x27d5a
jmp 0x27d6b
jmp 0x27d5a
jmp 0x27d89
jmp 0x27d6b
jmp 0x27d5a
jmp 0x27d89
jmp 0x27d6b
jmp 0x27d5a
jmp 0x27d89
jmp 0x27d6b
jmp 0x27d5a
jmp 0x27d89
jmp 0x27d6b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x27d6e
jmp 0x27d89
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x27d7d
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0x27d8c
jmp 0x27d9f
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x27de3
leaq 0x18(%rsp), %rdi
jmp 0x27dde
jmp 0x27dae
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3423a
jmp 0x27db1
jmp 0x27dcc
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x27dc1
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x27dcf
movq %rax, %rbx
movq 0x38(%rsp), %rsi
testq %rsi, %rsi
je 0x27de3
leaq 0x38(%rsp), %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_search_not_present_Test::TestBody() | TEST(Buffer, search_not_present) {
BufferWithReadonlyStrings local;
auto constexpr expected_pos = size_t { 999 };
auto constexpr needle = std::string_view { "test" };
auto pos = expected_pos;
// confirm that the search fails and pos is unchanged
EXPECT_EQ(-1, bfy_buffer_search_all(&local.buf, std::data(needle), std::size(needle), &pos));
EXPECT_EQ(expected_pos, pos);
} | pushq %rbx
subq $0xf0, %rsp
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x1da3c
movl $0x3e7, %eax # imm = 0x3E7
movq %rax, 0x28(%rsp)
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movl $0xffffffff, (%rsp) # imm = 0xFFFFFFFF
leaq 0x40d6a(%rip), %rsi # 0x68b8b
movl $0x4, %edx
movq %rbx, %rdi
callq 0x5fdb4
leaq 0x8(%rsp), %r8
movl %eax, (%r8)
leaq 0x40de2(%rip), %rsi # 0x68c1f
leaq 0x3ae8b(%rip), %rdx # 0x62ccf
leaq 0x10(%rsp), %rdi
movq %rsp, %rcx
callq 0x30dee
cmpb $0x0, 0x10(%rsp)
jne 0x27eb7
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x27e6f
movq (%rax), %r8
jmp 0x27e76
leaq 0x402b1(%rip), %r8 # 0x68127
leaq 0x39210(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x49d, %ecx # imm = 0x49D
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x27eb7
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x27ecb
leaq 0x18(%rsp), %rdi
callq 0x2dd22
leaq 0x3ae4b(%rip), %rsi # 0x62d1d
leaq 0x3ae4d(%rip), %rdx # 0x62d26
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x30cf4
cmpb $0x0, 0x10(%rsp)
jne 0x27f53
movq %rsp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x27f0b
movq (%rax), %r8
jmp 0x27f12
leaq 0x40215(%rip), %r8 # 0x68127
leaq 0x39174(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x49e, %ecx # imm = 0x49E
callq 0x341ce
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x27f53
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x27f67
leaq 0x18(%rsp), %rdi
callq 0x2dd22
leaq 0x30(%rsp), %rdi
callq 0x1db1a
addq $0xf0, %rsp
popq %rbx
retq
jmp 0x27f80
jmp 0x27f8f
jmp 0x27fab
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x27f92
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x27fa1
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0x27fae
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x27fc2
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x18(%rsp)
jmp 0x27fd2
jmp 0x27fcf
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1db1a
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_make_contiguous_fires_no_change_events_Test::TestBody() | TEST(Buffer, make_contiguous_fires_no_change_events) {
BufferWithReadonlyStrings local;
local.start_listening_to_changes();
EXPECT_TRUE(bfy_buffer_make_all_contiguous(&local.buf));
EXPECT_EQ(0, std::size(local.changes));
} | pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x1da3c
leaq 0xf0(%rsp), %rdx
leaq 0x37b8(%rip), %rsi # 0x2cf14
movq %rbx, %rdi
callq 0x5e4a6
leaq 0x48(%rsp), %rdi
callq 0x5f6a6
leaq 0x18(%rsp), %rbx
testq %rax, %rax
setne -0x8(%rbx)
movq $0x0, (%rbx)
jne 0x29819
leaq 0x8(%rsp), %rdi
callq 0x37e78
leaq 0x398cb(%rip), %rdx # 0x63063
leaq 0x37dc4(%rip), %rcx # 0x61563
leaq 0x37dc3(%rip), %r8 # 0x61569
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x394db
movq 0x28(%rsp), %r8
leaq 0x378cc(%rip), %rdx # 0x6108d
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
movl $0x52f, %ecx # imm = 0x52F
callq 0x341ce
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3426c
leaq 0x20(%rsp), %rdi
callq 0x3423a
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29809
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x29819
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x2982b
movq %rbx, %rdi
callq 0x2dd22
leaq 0x8(%rsp), %rcx
movl $0x0, (%rcx)
movq 0xf8(%rsp), %rax
subq 0xf0(%rsp), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
leaq 0x10(%rsp), %r8
movq %rdx, (%r8)
leaq 0x4000f(%rip), %rsi # 0x69876
leaq 0x39820(%rip), %rdx # 0x6308e
leaq 0x28(%rsp), %rdi
callq 0x3081a
cmpb $0x0, 0x28(%rsp)
jne 0x298e3
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x29898
movq (%rax), %r8
jmp 0x2989f
leaq 0x3e888(%rip), %r8 # 0x68127
leaq 0x377e7(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x530, %ecx # imm = 0x530
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x298e3
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0x298f7
leaq 0x30(%rsp), %rdi
callq 0x2dd22
leaq 0x48(%rsp), %rdi
callq 0x1db1a
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x3423a
jmp 0x2991e
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2993e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10490
jmp 0x2993e
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2994e
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x2995c
movq %rax, %r14
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x2996e
movq %rbx, %rdi
callq 0x2dd22
movq $0x0, 0x18(%rsp)
jmp 0x299cf
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x2998b
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2999b
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x299a9
movq %rax, %r14
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0x299bd
leaq 0x30(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x30(%rsp)
jmp 0x299cf
jmp 0x299cc
jmp 0x299cc
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x1db1a
movq %r14, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_change_event_add_buffer_Test::TestBody() | TEST(Buffer, change_event_add_buffer) {
BufferWithReadonlyStrings local;
BufferWithReadonlyStrings donor;
auto const expected = bfy_changed_cb_info {
.orig_size = bfy_buffer_get_content_len(&local.buf),
.n_added = bfy_buffer_get_content_len(&donor.buf),
.n_deleted = 0
};
local.start_listening_to_changes();
EXPECT_EQ(0, bfy_buffer_add_buffer(&local.buf, &donor.buf));
EXPECT_EQ(changes_t{expected}, local.changes);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
leaq 0x50(%rsp), %rdi
callq 0x1da3c
leaq 0x110(%rsp), %rdi
callq 0x1da3c
leaq 0x50(%rsp), %rdi
callq 0x5e540
movq %rax, %r14
leaq 0x110(%rsp), %rdi
callq 0x5e540
movq %rax, %r15
leaq 0xf8(%rsp), %rbx
leaq 0x328f(%rip), %rsi # 0x2cf14
leaq 0x50(%rsp), %rdi
movq %rbx, %rdx
callq 0x5e4a6
movl $0x0, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0x5ee79
leaq 0x10(%rsp), %r8
movl %eax, (%r8)
leaq 0x3fbbb(%rip), %rsi # 0x69876
leaq 0x39424(%rip), %rdx # 0x630e6
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rcx
callq 0x30dee
cmpb $0x0, 0x20(%rsp)
jne 0x29d3c
leaq 0x38(%rsp), %rdi
callq 0x37e78
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x29cf1
movq (%rax), %r8
jmp 0x29cf8
leaq 0x3e42f(%rip), %r8 # 0x68127
leaq 0x3738e(%rip), %rdx # 0x6108d
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x54d, %ecx # imm = 0x54D
callq 0x341ce
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3426c
leaq 0x10(%rsp), %rdi
callq 0x3423a
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x29d3c
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x29d50
leaq 0x28(%rsp), %rdi
callq 0x2dd22
leaq 0x38(%rsp), %rsi
movq %r14, (%rsi)
movq %r15, 0x8(%rsi)
movq $0x0, 0x10(%rsi)
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x2d3ae
leaq 0x39395(%rip), %rsi # 0x63114
leaq 0x393a2(%rip), %rdx # 0x63128
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rcx
movq %rbx, %r8
callq 0x33a09
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x29daf
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x10490
cmpb $0x0, 0x10(%rsp)
jne 0x29e1a
leaq 0x20(%rsp), %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x29dcf
movq (%rax), %r8
jmp 0x29dd6
leaq 0x3e351(%rip), %r8 # 0x68127
leaq 0x372b0(%rip), %rdx # 0x6108d
leaq 0x38(%rsp), %rdi
movl $0x1, %esi
movl $0x54e, %ecx # imm = 0x54E
callq 0x341ce
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3426c
leaq 0x38(%rsp), %rdi
callq 0x3423a
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x29e1a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x29e2e
leaq 0x18(%rsp), %rdi
callq 0x2dd22
leaq 0x110(%rsp), %rdi
callq 0x1db1a
leaq 0x50(%rsp), %rdi
callq 0x1db1a
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3423a
jmp 0x29e64
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x29e74
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x20(%rsp)
jmp 0x29e82
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x29e96
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x18(%rsp)
jmp 0x29f18
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3423a
jmp 0x29eb3
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x29ec3
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x38(%rsp)
jmp 0x29ed1
movq %rax, %rbx
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x29ee5
leaq 0x28(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x28(%rsp)
jmp 0x29f18
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x29f18
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x10490
jmp 0x29f18
jmp 0x29f15
movq %rax, %rbx
jmp 0x29f25
jmp 0x29f15
movq %rax, %rbx
leaq 0x110(%rsp), %rdi
callq 0x1db1a
leaq 0x50(%rsp), %rdi
callq 0x1db1a
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_change_event_add_hton_u8_Test::TestBody() | TEST(Buffer, change_event_add_hton_u8) {
BufferWithReadonlyStrings local;
auto constexpr addme = uint8_t { 128 };
auto constexpr size = sizeof(addme);
auto const expected = bfy_changed_cb_info {
.orig_size = bfy_buffer_get_content_len(&local.buf),
.n_added = size,
.n_deleted = 0
};
local.start_listening_to_changes();
EXPECT_EQ(0, bfy_buffer_add_hton_u8(&local.buf, addme));
EXPECT_EQ(changes_t{expected}, local.changes);
} | pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x1da3c
movq %rbx, %rdi
callq 0x5e540
movq %rax, %r14
leaq 0xf0(%rsp), %rbx
leaq 0x2ce7(%rip), %rsi # 0x2cf14
leaq 0x48(%rsp), %rdi
movq %rbx, %rdx
callq 0x5e4a6
movl $0x0, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
movl $0x80, %esi
callq 0x5edb4
leaq 0x8(%rsp), %r8
movl %eax, (%r8)
leaq 0x3f616(%rip), %rsi # 0x69876
leaq 0x38f1f(%rip), %rdx # 0x63186
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rcx
callq 0x30dee
cmpb $0x0, 0x18(%rsp)
jne 0x2a2e1
leaq 0x30(%rsp), %rdi
callq 0x37e78
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2a296
movq (%rax), %r8
jmp 0x2a29d
leaq 0x3de8a(%rip), %r8 # 0x68127
leaq 0x36de9(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x569, %ecx # imm = 0x569
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2a2e1
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x2a2f5
leaq 0x20(%rsp), %rdi
callq 0x2dd22
leaq 0x30(%rsp), %rsi
movq %r14, (%rsi)
movq $0x1, 0x8(%rsi)
movq $0x0, 0x10(%rsi)
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x1, %edx
callq 0x2d3ae
leaq 0x38dec(%rip), %rsi # 0x63114
leaq 0x38df9(%rip), %rdx # 0x63128
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rcx
movq %rbx, %r8
callq 0x33a09
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2a358
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10490
cmpb $0x0, 0x8(%rsp)
jne 0x2a3c3
leaq 0x18(%rsp), %rdi
callq 0x37e78
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2a378
movq (%rax), %r8
jmp 0x2a37f
leaq 0x3dda8(%rip), %r8 # 0x68127
leaq 0x36d07(%rip), %rdx # 0x6108d
leaq 0x30(%rsp), %rdi
movl $0x1, %esi
movl $0x56a, %ecx # imm = 0x56A
callq 0x341ce
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3426c
leaq 0x30(%rsp), %rdi
callq 0x3423a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2a3c3
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x2a3d7
leaq 0x10(%rsp), %rdi
callq 0x2dd22
leaq 0x48(%rsp), %rdi
callq 0x1db1a
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3423a
jmp 0x2a3fe
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2a40e
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rsp)
jmp 0x2a41c
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x2a430
leaq 0x10(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x10(%rsp)
jmp 0x2a4ad
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x2a44d
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2a45d
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x30(%rsp)
jmp 0x2a46b
movq %rax, %rbx
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x2a47f
leaq 0x20(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x20(%rsp)
jmp 0x2a4ad
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2a4ad
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10490
jmp 0x2a4ad
jmp 0x2a4aa
jmp 0x2a4aa
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1db1a
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_change_event_add_hton_u32_Test::TestBody() | TEST(Buffer, change_event_add_hton_u32) {
BufferWithReadonlyStrings local;
auto constexpr addme = uint32_t { 128 };
auto constexpr size = sizeof(addme);
auto const expected = bfy_changed_cb_info {
.orig_size = bfy_buffer_get_content_len(&local.buf),
.n_added = size,
.n_deleted = 0
};
local.start_listening_to_changes();
EXPECT_EQ(0, bfy_buffer_add_hton_u32(&local.buf, addme));
EXPECT_EQ(changes_t{expected}, local.changes);
} | pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x1da3c
movq %rbx, %rdi
callq 0x5e540
movq %rax, %r14
leaq 0xf0(%rsp), %rbx
leaq 0x275f(%rip), %rsi # 0x2cf14
leaq 0x48(%rsp), %rdi
movq %rbx, %rdx
callq 0x5e4a6
movl $0x0, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
movl $0x80, %esi
callq 0x5ede8
leaq 0x8(%rsp), %r8
movl %eax, (%r8)
leaq 0x3f08e(%rip), %rsi # 0x69876
leaq 0x38a20(%rip), %rdx # 0x6320f
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rcx
callq 0x30dee
cmpb $0x0, 0x18(%rsp)
jne 0x2a869
leaq 0x30(%rsp), %rdi
callq 0x37e78
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2a81e
movq (%rax), %r8
jmp 0x2a825
leaq 0x3d902(%rip), %r8 # 0x68127
leaq 0x36861(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x587, %ecx # imm = 0x587
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2a869
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x2a87d
leaq 0x20(%rsp), %rdi
callq 0x2dd22
leaq 0x30(%rsp), %rsi
movq %r14, (%rsi)
movq $0x4, 0x8(%rsi)
movq $0x0, 0x10(%rsi)
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x1, %edx
callq 0x2d3ae
leaq 0x38864(%rip), %rsi # 0x63114
leaq 0x38871(%rip), %rdx # 0x63128
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rcx
movq %rbx, %r8
callq 0x33a09
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2a8e0
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10490
cmpb $0x0, 0x8(%rsp)
jne 0x2a94b
leaq 0x18(%rsp), %rdi
callq 0x37e78
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2a900
movq (%rax), %r8
jmp 0x2a907
leaq 0x3d820(%rip), %r8 # 0x68127
leaq 0x3677f(%rip), %rdx # 0x6108d
leaq 0x30(%rsp), %rdi
movl $0x1, %esi
movl $0x588, %ecx # imm = 0x588
callq 0x341ce
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3426c
leaq 0x30(%rsp), %rdi
callq 0x3423a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2a94b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x2a95f
leaq 0x10(%rsp), %rdi
callq 0x2dd22
leaq 0x48(%rsp), %rdi
callq 0x1db1a
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3423a
jmp 0x2a986
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2a996
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rsp)
jmp 0x2a9a4
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x2a9b8
leaq 0x10(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x10(%rsp)
jmp 0x2aa35
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x2a9d5
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2a9e5
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x30(%rsp)
jmp 0x2a9f3
movq %rax, %rbx
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x2aa07
leaq 0x20(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x20(%rsp)
jmp 0x2aa35
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2aa35
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10490
jmp 0x2aa35
jmp 0x2aa32
jmp 0x2aa32
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1db1a
movq %rbx, %rdi
callq 0x108a0
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_change_event_add_printf_Test::TestBody() | TEST(Buffer, change_event_add_printf) {
BufferWithReadonlyStrings local;
auto constexpr str = std::string_view { "Lorem ipsum dolor sit amet" };
auto constexpr size = std::size(str);
auto const expected = bfy_changed_cb_info {
.orig_size = bfy_buffer_get_content_len(&local.buf),
.n_added = size,
.n_deleted = 0
};
local.start_listening_to_changes();
EXPECT_EQ(0, bfy_buffer_add_printf(&local.buf, "%s", std::data(str)));
EXPECT_EQ(changes_t{expected}, local.changes);
} | pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x1da3c
movq %rbx, %rdi
callq 0x5e540
movq %rax, %r14
leaq 0xf0(%rsp), %rbx
leaq 0x2065(%rip), %rsi # 0x2cf14
leaq 0x48(%rsp), %rdi
movq %rbx, %rdx
callq 0x5e4a6
movl $0x0, 0x30(%rsp)
leaq 0x3d9ce(%rip), %rsi # 0x68899
leaq 0x368ff(%rip), %rdx # 0x617d1
leaq 0x48(%rsp), %rdi
xorl %eax, %eax
callq 0x5ec6d
leaq 0x8(%rsp), %r8
movl %eax, (%r8)
leaq 0x3e989(%rip), %rsi # 0x69876
leaq 0x383be(%rip), %rdx # 0x632b2
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rcx
callq 0x30dee
cmpb $0x0, 0x18(%rsp)
jne 0x2af6e
leaq 0x30(%rsp), %rdi
callq 0x37e78
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2af23
movq (%rax), %r8
jmp 0x2af2a
leaq 0x3d1fd(%rip), %r8 # 0x68127
leaq 0x3615c(%rip), %rdx # 0x6108d
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x5ad, %ecx # imm = 0x5AD
callq 0x341ce
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3426c
leaq 0x8(%rsp), %rdi
callq 0x3423a
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2af6e
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x2af82
leaq 0x20(%rsp), %rdi
callq 0x2dd22
leaq 0x30(%rsp), %rsi
movq %r14, (%rsi)
movq $0x1a, 0x8(%rsi)
movq $0x0, 0x10(%rsi)
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x1, %edx
callq 0x2d3ae
leaq 0x3815f(%rip), %rsi # 0x63114
leaq 0x3816c(%rip), %rdx # 0x63128
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rcx
movq %rbx, %r8
callq 0x33a09
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2afe5
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10490
cmpb $0x0, 0x8(%rsp)
jne 0x2b050
leaq 0x18(%rsp), %rdi
callq 0x37e78
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2b005
movq (%rax), %r8
jmp 0x2b00c
leaq 0x3d11b(%rip), %r8 # 0x68127
leaq 0x3607a(%rip), %rdx # 0x6108d
leaq 0x30(%rsp), %rdi
movl $0x1, %esi
movl $0x5ae, %ecx # imm = 0x5AE
callq 0x341ce
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3426c
leaq 0x30(%rsp), %rdi
callq 0x3423a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2b050
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x2b064
leaq 0x10(%rsp), %rdi
callq 0x2dd22
leaq 0x48(%rsp), %rdi
callq 0x1db1a
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3423a
jmp 0x2b08b
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2b09b
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rsp)
jmp 0x2b0a9
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x2b0bd
leaq 0x10(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x10(%rsp)
jmp 0x2b13a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3423a
jmp 0x2b0da
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2b0ea
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x30(%rsp)
jmp 0x2b0f8
movq %rax, %rbx
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x2b10c
leaq 0x20(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x20(%rsp)
jmp 0x2b13a
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2b13a
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10490
jmp 0x2b13a
jmp 0x2b137
jmp 0x2b137
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1db1a
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_change_event_remove_Test::TestBody() | TEST(Buffer, change_event_remove) {
auto array = std::array<char, 1024> {};
BufferWithReadonlyStrings const local;
// confirm this test exercises removing <1, ==1, and >1 pages
EXPECT_LT(1, buffer_count_pages(&local.buf));
for (size_t i=1, n=bfy_buffer_get_content_len(&local.buf); i < n; ++i) {
BufferWithReadonlyStrings mabel;
auto const expected = bfy_changed_cb_info {
.orig_size = n,
.n_added = 0,
.n_deleted = i
};
mabel.start_listening_to_changes();
EXPECT_EQ(i, bfy_buffer_remove(&mabel.buf, i, std::data(array)));
EXPECT_EQ(changes_t{expected}, mabel.changes);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5d8, %rsp # imm = 0x5D8
leaq 0x1d8(%rsp), %rdi
movl $0x400, %edx # imm = 0x400
xorl %esi, %esi
callq 0x10260
leaq 0x118(%rsp), %rbx
movq %rbx, %rdi
callq 0x1da3c
movl $0x1, 0x30(%rsp)
movq %rbx, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5e869
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
leaq 0x3d3bb(%rip), %rsi # 0x68c20
leaq 0x361e7(%rip), %rdx # 0x61a53
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rcx
callq 0x2d3f7
cmpb $0x0, 0x58(%rsp)
jne 0x2b8e6
leaq 0x10(%rsp), %rdi
callq 0x37e78
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x2b89b
movq (%rax), %r8
jmp 0x2b8a2
leaq 0x3c885(%rip), %r8 # 0x68127
leaq 0x357e4(%rip), %rdx # 0x6108d
leaq 0x30(%rsp), %rdi
movl $0x1, %esi
movl $0x5dc, %ecx # imm = 0x5DC
callq 0x341ce
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3426c
leaq 0x30(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2b8e6
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x60(%rsp), %rsi
testq %rsi, %rsi
je 0x2b8fa
leaq 0x60(%rsp), %rdi
callq 0x2dd22
movq $0x1, 0x28(%rsp)
leaq 0x118(%rsp), %rdi
callq 0x5e540
movq %rax, %rbx
cmpq %rax, 0x28(%rsp)
jae 0x2baf2
leaq 0x58(%rsp), %r13
leaq 0x10(%rsp), %r15
leaq 0x30(%rsp), %rbp
leaq 0x48(%rsp), %r12
movq %r13, %rdi
callq 0x1da3c
movq 0x28(%rsp), %r14
movq %r13, %rdi
leaq 0x15cb(%rip), %rsi # 0x2cf14
leaq 0x100(%rsp), %rdx
callq 0x5e4a6
movq 0x28(%rsp), %rsi
movq %r13, %rdi
leaq 0x1d8(%rsp), %rdx
callq 0x5f5ff
movq %rax, 0x30(%rsp)
movq %r15, %rdi
leaq 0x37a24(%rip), %rsi # 0x6339e
leaq 0x37a1f(%rip), %rdx # 0x633a0
leaq 0x28(%rsp), %rcx
movq %rbp, %r8
callq 0x30cf4
cmpb $0x0, 0x10(%rsp)
jne 0x2b9ed
movq %rbp, %rdi
callq 0x37e78
movq 0x18(%rsp), %rax
leaq 0x3c77e(%rip), %r8 # 0x68127
testq %rax, %rax
je 0x2b9b1
movq (%rax), %r8
movq %r12, %rdi
movl $0x1, %esi
leaq 0x356cd(%rip), %rdx # 0x6108d
movl $0x5e7, %ecx # imm = 0x5E7
callq 0x341ce
movq %r12, %rdi
movq %rbp, %rsi
callq 0x3426c
movq %r12, %rdi
callq 0x3423a
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2b9ed
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x2ba01
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq %rbx, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq %r14, 0x40(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %rbp, %rsi
leaq 0xf(%rsp), %rcx
callq 0x2d3ae
movq %r12, %rdi
leaq 0x376e1(%rip), %rsi # 0x63114
leaq 0x37999(%rip), %rdx # 0x633d3
movq %r15, %rcx
leaq 0x100(%rsp), %r8
callq 0x33a09
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2ba61
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10490
cmpb $0x0, 0x48(%rsp)
jne 0x2bac0
movq %r15, %rdi
callq 0x37e78
movq 0x50(%rsp), %rax
leaq 0x3c6ab(%rip), %r8 # 0x68127
testq %rax, %rax
je 0x2ba84
movq (%rax), %r8
movq %rbp, %rdi
movl $0x1, %esi
leaq 0x355fa(%rip), %rdx # 0x6108d
movl $0x5e8, %ecx # imm = 0x5E8
callq 0x341ce
movq %rbp, %rdi
movq %r15, %rsi
callq 0x3426c
movq %rbp, %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2bac0
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rsp), %rsi
testq %rsi, %rsi
je 0x2bad4
leaq 0x50(%rsp), %rdi
callq 0x2dd22
movq %r13, %rdi
callq 0x1db1a
movq 0x28(%rsp), %rax
incq %rax
movq %rax, 0x28(%rsp)
cmpq %rbx, %rax
jb 0x2b932
leaq 0x118(%rsp), %rdi
callq 0x1db1a
addq $0x5d8, %rsp # imm = 0x5D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3423a
jmp 0x2bb23
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2bb33
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x2bb41
movq %rax, %rbx
movq 0x60(%rsp), %rsi
testq %rsi, %rsi
je 0x2bb55
leaq 0x60(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x60(%rsp)
jmp 0x2bc3d
jmp 0x2bc0b
jmp 0x2bc0b
movq %rax, %rbx
jmp 0x2bba2
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3423a
jmp 0x2bb89
movq %rax, %rbx
jmp 0x2bbd3
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2bb99
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x30(%rsp)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x2bbb6
leaq 0x18(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x18(%rsp)
jmp 0x2bc33
movq %rax, %rbx
jmp 0x2bbec
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3423a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2bbe3
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
movq 0x50(%rsp), %rsi
testq %rsi, %rsi
je 0x2bc00
leaq 0x50(%rsp), %rdi
callq 0x2dd22
movq $0x0, 0x50(%rsp)
jmp 0x2bc33
movq %rax, %rbx
jmp 0x2bc3d
jmp 0x2bc30
jmp 0x2bc30
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2bc33
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10490
jmp 0x2bc33
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1db1a
leaq 0x118(%rsp), %rdi
callq 0x1db1a
movq %rbx, %rdi
callq 0x108a0
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_make_contiguous_when_only_one_page_Test::~Buffer_make_contiguous_when_only_one_page_Test() | TEST(Buffer, make_contiguous_when_only_one_page) {
BufferWithLocalArray<64> local;
bfy_buffer_add(&local.buf, std::data(str1), std::size(str1));
// confirm adding str1 fit inside the existing page
auto constexpr n_expected_vecs = 1;
auto vecs1 = std::array<bfy_iovec, n_expected_vecs>{};
EXPECT_EQ(n_expected_vecs, bfy_buffer_peek_all(&local.buf, std::data(vecs1), std::size(vecs1)));
EXPECT_EQ(std::data(local.array), vecs1[0].iov_base);
EXPECT_EQ(std::size(str1), vecs1[0].iov_len);
// confirm that making contiguous changes nothing
// because it was already a single page
auto* rv = bfy_buffer_make_all_contiguous(&local.buf);
auto vecs2 = std::array<bfy_iovec, n_expected_vecs>{};
EXPECT_EQ(n_expected_vecs, bfy_buffer_peek_all(&local.buf, std::data(vecs2), std::size(vecs2)));
EXPECT_EQ(vecs1[0].iov_base, vecs2[0].iov_base);
// confirm that make_contiguous() returned the right value
EXPECT_EQ(vecs1[0].iov_base, rv);
} | pushq %rbx
movq %rdi, %rbx
callq 0x3c17a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x10490
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_recycles_pages_Test::~Buffer_recycles_pages_Test() | TEST(Buffer, recycles_pages) {
auto constexpr str = std::string_view { "1234567890" };
auto array = std::array<char, 16> {};
bfy_buffer buf = bfy_buffer_init_unmanaged(std::data(array), std::size(array));
EXPECT_EQ(0, buffer_count_pages(&buf));
bfy_buffer_add(&buf, std::data(str), std::size(str));
EXPECT_EQ(10, bfy_buffer_get_content_len(&buf));
EXPECT_EQ(6, bfy_buffer_get_space_len(&buf));
EXPECT_EQ(1, buffer_count_pages(&buf));
bfy_buffer_remove(&buf, 5, std::data(array));
EXPECT_EQ(5, bfy_buffer_get_content_len(&buf));
EXPECT_EQ(6, bfy_buffer_get_space_len(&buf));
EXPECT_EQ(1, buffer_count_pages(&buf));
// now there's not enough space at the end of the page,
// but there will be if it realigns the content back to
// the front of the page...
bfy_buffer_add(&buf, std::data(str), std::size(str));
EXPECT_EQ(15, bfy_buffer_get_content_len(&buf));
EXPECT_EQ(1, bfy_buffer_get_space_len(&buf));
EXPECT_EQ(1, buffer_count_pages(&buf));
bfy_buffer_destruct(&buf);
} | pushq %rbx
movq %rdi, %rbx
callq 0x3c17a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x10490
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_make_contiguous_when_aligned_with_page_Test::~Buffer_make_contiguous_when_aligned_with_page_Test() | TEST(Buffer, make_contiguous_when_aligned_with_page) {
BufferWithReadonlyStrings local;
auto const n_expected_readable = std::size(local.allstrs);
auto constexpr n_pages_in = std::size(strs);
EXPECT_EQ(n_expected_readable, bfy_buffer_get_content_len(&local.buf));
EXPECT_EQ(n_pages_in, buffer_count_pages(&local.buf));
// try to make the first two pages contiguous
auto constexpr n_expected_vecs = n_pages_in - 1;
auto const n_bytes_contiguous = n_expected_readable - std::size(strs.back());
bfy_buffer_make_contiguous(&local.buf, n_bytes_contiguous);
// test that the pages look right
auto vecs = std::array<bfy_iovec, n_expected_vecs>{};
EXPECT_EQ(n_expected_vecs, bfy_buffer_peek_all(&local.buf, std::data(vecs), n_expected_vecs));
EXPECT_EQ(n_bytes_contiguous, vecs[0].iov_len);
EXPECT_NE(std::data(str1), vecs[0].iov_base);
EXPECT_EQ(std::size(strs.back()), vecs[1].iov_len);
EXPECT_EQ(std::data(strs.back()), vecs[1].iov_base);
EXPECT_EQ(n_expected_readable, bfy_buffer_get_content_len(&local.buf));
} | pushq %rbx
movq %rdi, %rbx
callq 0x3c17a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x10490
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_ensure_writable_when_readonly_Test::~Buffer_ensure_writable_when_readonly_Test() | TEST(Buffer, ensure_writable_when_readonly) {
auto buf = bfy_buffer_init();
bfy_buffer_add_readonly(&buf, std::data(str1), std::size(str1));
EXPECT_EQ(0, bfy_buffer_get_space_len(&buf));
EXPECT_EQ(std::size(str1), bfy_buffer_get_content_len(&buf));
auto const n_available = 10; // arbitrary
EXPECT_EQ(0, bfy_buffer_ensure_space(&buf, n_available));
EXPECT_EQ(std::size(str1), bfy_buffer_get_content_len(&buf));
EXPECT_LE(n_available, bfy_buffer_get_space_len(&buf));
bfy_buffer_destruct(&buf);
} | pushq %rbx
movq %rdi, %rbx
callq 0x3c17a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x10490
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_search_match_crossing_pages_Test::~Buffer_search_match_crossing_pages_Test() | TEST(Buffer, search_match_crossing_pages) {
BufferWithReadonlyStrings local;
size_t constexpr skip = 1;
auto const needle = std::string{str1.substr(skip)} + std::string{str2.substr(0, std::size(str2)-1)};
auto pos = size_t {};
EXPECT_EQ(0, bfy_buffer_search_all(&local.buf, std::data(needle), std::size(needle), &pos));
EXPECT_EQ(skip, pos);
} | pushq %rbx
movq %rdi, %rbx
callq 0x3c17a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x10490
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_search_match_crossing_multiple_pages_Test::~Buffer_search_match_crossing_multiple_pages_Test() | TEST(Buffer, search_match_crossing_multiple_pages) {
BufferWithReadonlyStrings local;
size_t constexpr skip = 1;
auto const needle = local.allstrs.substr(skip, std::size(local.allstrs)-(skip*2));
auto pos = size_t {};
EXPECT_EQ(0, bfy_buffer_search_all(&local.buf, std::data(needle), std::size(needle), &pos));
EXPECT_EQ(skip, pos);
} | pushq %rbx
movq %rdi, %rbx
callq 0x3c17a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x10490
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_search_almost_match_at_page_break_Test::~Buffer_search_almost_match_at_page_break_Test() | TEST(Buffer, search_almost_match_at_page_break) {
auto constexpr a = std::string_view { "The Beat" };
auto constexpr b = std::string_view { " were not the same band as T" };
auto constexpr c = std::string_view { "he Beatles" };
auto buf = bfy_buffer_init();
bfy_buffer_add_readonly(&buf, std::data(a), std::size(a));
bfy_buffer_add_readonly(&buf, std::data(b), std::size(b));
bfy_buffer_add_readonly(&buf, std::data(c), std::size(c));
auto constexpr needle = std::string_view { "The Beatles" };
auto constexpr expected_pos = std::size(a) + std::size(b) - 1;
auto pos = size_t {};
EXPECT_EQ(0, bfy_buffer_search_all(&buf, std::data(needle), std::size(needle), &pos));
EXPECT_EQ(expected_pos, pos);
bfy_buffer_destruct(&buf);
} | pushq %rbx
movq %rdi, %rbx
callq 0x3c17a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x10490
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_search_very_long_buffer_Test::~Buffer_search_very_long_buffer_Test() | TEST(Buffer, search_very_long_buffer) {
auto constexpr noise = std::string_view { "spam" };
auto constexpr needle = std::string_view { "eggs" };
auto constexpr n_noise = 20000;
auto buf = bfy_buffer_init();
for (size_t i = 0; i < n_noise; ++i) {
bfy_buffer_add_readonly(&buf, std::data(noise), std::size(noise));
}
bfy_buffer_add_readonly(&buf, std::data(needle), std::size(needle));
for (size_t i = 0; i < n_noise; ++i) {
bfy_buffer_add_readonly(&buf, std::data(noise), std::size(noise));
}
auto pos = size_t {};
auto constexpr expected_pos = std::size(noise) * n_noise;
EXPECT_EQ(0, bfy_buffer_search_all(&buf, std::data(needle), std::size(needle), &pos));
EXPECT_EQ(expected_pos, pos);
bfy_buffer_destruct(&buf);
} | pushq %rbx
movq %rdi, %rbx
callq 0x3c17a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x10490
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Buffer_change_event_add_ch_Test::~Buffer_change_event_add_ch_Test() | TEST(Buffer, change_event_add_ch) {
BufferWithReadonlyStrings local;
auto const expected = bfy_changed_cb_info {
.orig_size = bfy_buffer_get_content_len(&local.buf),
.n_added = 1,
.n_deleted = 0
};
local.start_listening_to_changes();
EXPECT_EQ(0, bfy_buffer_add_ch(&local.buf, 'x'));
EXPECT_EQ(changes_t{expected}, local.changes);
} | pushq %rbx
movq %rdi, %rbx
callq 0x3c17a
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x10490
nop
| /ckerr[P]buffy/tests/buffer-test.cc |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.