name string | code string | asm string | file string |
|---|---|---|---|
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... | /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 glob... | 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 glob... | 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(%... | /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
... | /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... | /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(... | 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 ... | /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 != beginS... | 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
m... | /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(); ... | 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, %eb... | /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
{
... | 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... | /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), %r... | /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.memor... | 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... | /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... | 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(%... | /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... | 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
... | /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_in... | 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 -0x3... | /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), %... | /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
... | /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(%... | /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
mov... | /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 %... | /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)
... | /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)
mov... | /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... | /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 0x1d9... | /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;
}
... | 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 0xb98... | /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;
}
ret... | 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 # 0... | /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_ma... | 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.
re... | 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 0x... | /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),... | /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::Tes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0xc938
leaq 0x20(%rb... | /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... | /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_inf... | 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 0... | /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.... | 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 ... | /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 + ":" + StreamableToStri... | 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, %r... | /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... | /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 even... | 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
mov... | /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.
re... | 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)
mo... | /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),
... | 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... | /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
mo... | /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... | /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);
// ... | 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, %rs... | /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... | /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 remin... | 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, 0... | /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... | 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, 0... | /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 = Int32FromE... | 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 $-0x... | /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_FAILUR... | 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, %... | /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_para... | 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)... | /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... | 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 r... | 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
... | /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", coun... | 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 #... | /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_suit... | 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 0... | /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... | 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 # 0x386... | /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(),
FormatTest... | 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 %e... | /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 ... | 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)) {
pri... | 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... | /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(),
FormatTestSu... | 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 %e... | /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), %... | /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
i... | /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 0x1... | /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(... | /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 0x296... | /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)... | 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... | /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 == ... | 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... | /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(%rb... | /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(%r... | /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(%r... | /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... | 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 0... | /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... | 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:... | 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)
mo... | /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 opti... | 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
su... | /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-... | 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)
... | /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
lea... | /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::arr... | 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 0x5e8... | /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... | 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... | /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... | /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();
EX... | 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 %... | /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... | /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_spa... | 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,... | /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();... | 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, %r... | /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_buffe... | 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, %e... | /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, s... | 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
le... | /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)
jn... | /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
};
loc... | 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 ... | /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
... | 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
... | /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 = ... | 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
... | /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_adde... | 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), %r... | /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) {
... | 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 %e... | /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... | 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));
... | 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_p... | 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
EXP... | 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::... | 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(need... | 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... | 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... | 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... | 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
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.