name string | code string | asm string | file string |
|---|---|---|---|
smf::Binasc::getVLV(std::istream&, int&) | int Binasc::getVLV(std::istream& infile, int& trackbytes) {
int output = 0;
uchar ch;
infile.read((char*)&ch, 1);
trackbytes++;
output = (output << 7) | (0x7f & ch);
while (ch >= 0x80) {
infile.read((char*)&ch, 1);
trackbytes++;
output = (output << 7) | (0x7f & ch);
}
return output;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
callq 0x25410
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
shll $0x7, ... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::writeLittleEndianDouble(std::ostream&, double) | std::ostream& Binasc::writeLittleEndianDouble(std::ostream& out, double value) {
union { char bytes[8]; double d; } data;
data.d = value;
out << data.bytes[0];
out << data.bytes[1];
out << data.bytes[2];
out << data.bytes[3];
out << data.bytes[4];
out << data.bytes[5];
out << data.bytes[6];
out << data.bytes[... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movsbl -0x18(%rbp), %esi
callq 0x253a0
movq -0x8(%rbp), %rdi
movsbl -0x17(%rbp), %esi
callq 0x253a0
movq -0x8(%rbp), %rdi
movsbl -0x16(%rbp), %esi
callq 0x25... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::MidiEvent::operator=(smf::MidiEvent const&) | MidiEvent& MidiEvent::operator=(const MidiEvent& mfevent) {
if (this == &mfevent) {
return *this;
}
tick = mfevent.tick;
track = mfevent.track;
seconds = mfevent.seconds;
seq = mfevent.seq;
m_eventlink = NULL;
this->resize(mfevent.size());
for (int i=0; i<(int)this->size(); i++) {
(*this)[i] = mfe... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x4c92b
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4c9cf
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
mo... | /dean-deng[P]midifile/src-library/MidiEvent.cpp |
smf::MidiEvent::operator=(std::vector<unsigned char, std::allocator<unsigned char>> const&) | MidiEvent& MidiEvent::operator=(const vector<uchar>& bytes) {
clearVariables();
this->resize(bytes.size());
for (int i=0; i<(int)this->size(); i++) {
(*this)[i] = bytes[i];
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4c5f0
movq -0x10(%rbp), %rdi
callq 0x3e950
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3eb10
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0... | /dean-deng[P]midifile/src-library/MidiEvent.cpp |
main | int main(int argc, char** argv) {
uint8_t res[64], num[64];
uint8_t from = 0, to = 0;
char raw[65];
raw[0] = '\n';
while (raw[0] == '\n') {
printf("Please enter a number: ");
if (fgets(raw, sizeof raw, stdin) == NULL) {
printf("\n");
return 0;
}
}
for (size_t n = 0; n < 64; n++)... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x91(%rbp)
movb $0x0, -0x92(%rbp)
movb $0xa, -0xe0(%rbp)
movsbl -0xe0(%rbp), %eax
cmpl $0xa, %eax
jne 0x11e5
leaq 0xe63(%rip), %rdi # 0x2004
movb $0x0, %al
callq 0x1... | /adri326[P]ife-exs/src/10/10.1/main.c |
ReallocUnittest_Basics_Test::TestBody() | TEST(ReallocUnittest, Basics) {
for (int src_size = 0; src_size >= 0; src_size = NextSize(src_size)) {
for (int dst_size = 0; dst_size >= 0; dst_size = NextSize(dst_size)) {
unsigned char* src = (unsigned char*) malloc(src_size);
Fill(src, src_size);
unsigned char* dst = (unsigned char*) realloc... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq -0x40(%rbp), %rbx
xorl %r15d, %r15d
testl %r15d, %r15d
js 0x8430
movl %r15d, %r12d
xorl %r13d, %r13d
testl %r13d, %r13d
js 0x831d
movq %r12, %rdi
callq 0x75d0
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x... | /alk[P]gperftools/src/tests/realloc_unittest.cc |
testing::AssertionFailure(testing::Message const&) | AssertionResult AssertionFailure(const Message& message) {
return AssertionFailure() << message;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq -0x18(%rbp), %rbx
movb $0x0, -0x8(%rbx)
andq $0x0, (%rbx)
leaq -0x20(%rbp), %rdi
callq 0x8cac
movq %r14, %rdi
movq %rax, %rsi
callq 0x8b18
movq %rbx, %rdi
callq 0x889c
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
re... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-assertion-result.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xc8c8
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x7470
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x8d1a
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x8c84... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<testing::Message>(testing::Message const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xc8c8
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x8de3
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x8d1a
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x8cf2... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-assertion-result.h |
testing::internal::SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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>>>>*) | void SplitString(const ::std::string& str, char delimiter,
::std::vector< ::std::string>* dest) {
::std::vector< ::std::string> parsed;
::std::string::size_type pos = 0;
while (::testing::internal::AlwaysTrue()) {
const ::std::string::size_type colon = str.find(delimiter, pos);
if (colon ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, -0x30(%rbp)
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
andq $0x0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %r15d, %r15d
movsbl %sil, %r12d
leaq -0x70(%rbp), %r13
movq %r14, %rdi
movl %r12d, %esi
movq... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::Message::operator<<(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) | Message& Message::operator<<(const ::std::wstring& wstr) {
internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
xorl %r13d, %r13d
leaq -0x48(%rbp), %r14
cmpq %r13, %r12
je 0xca71
cmpl $0x0, (%r15,%r13,4)
je 0xca58
leaq (%r15,%r13,4), %rsi
movl %r12d, %edx
subl %r13d, %edx
movq ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<wchar_t const*>(bool, char const*, char const*, wchar_t const* const&, wchar_t const* const&) | AssertionResult IsSubstringImpl(bool expected_to_be_substring,
const char* needle_expr,
const char* haystack_expr,
const StringType& needle,
const StringType& haystack) {
if (IsSubstringPred... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r14
movq %r8, %r12
movl %esi, %r15d
movq %rdi, %rbx
movq %rdx, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
movq (%r8), %rsi
movq (%r9), %rdi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %cl, %al
jne 0xe36... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::TestSuite::TestSuite(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void (*)(), void (*)()) | TestSuite::TestSuite(const std::string& 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_u... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x2ecba(%rip), %rax # 0x3f088
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x7790
leaq 0x28(%r14), %rax
testq %rbx, %rbx
movq %rax,... | /alk[P]gperftools/vendor/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 0x10577
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %esi, %ecx
jle 0x10577
movl %esi, %ecx
movslq (%rax,%rcx,4), %rax
testq %rax, %rax
js 0x10577
movq 0x30(%rdi), %rcx
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
| /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::ColoredPrintf(testing::internal::(anonymous namespace)::GTestColor, char const*, ...) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
static const bool in_color_mode =
// We don't condition this on GTEST_HAS_FILE_SYSTEM because we still need
// to be able to detect terminal I/O regardless.
ShouldUseColor(posix::IsATTY(posix:... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movl %edi, %r14d
leaq -0xe0(%rbp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x10d55
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream*, testing::UnitTest const&) | void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
const UnitTest& unit_test) {
const std::string kTestsuites = "testsuites";
*stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
*stream << "<" << kTestsuites;
OutputXmlAttribute(stream, ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x19f25(%rip), %rsi # 0x2c63f
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x8696
leaq 0x19f1c(%rip), %rsi # 0x2c64a
movq %rbx, %rdi
callq 0x74e0
leaq 0x19f5a(%rip), %rsi # 0x2c697
movq %... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::ListTestsMatchingFilter(std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
const std::vector<TestSuite*>& test_suites) {
FILE* xmlout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintXmlTestsList(&stream, test_suites);
fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
fclose(xmlout);
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
addq $0x8, %rdi
callq 0x125f4
movq %rax, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x7370
leaq -0x1a8(%rbp), %rdi
movq %r14, %rsi
callq 0x12bb8
leaq -0x30(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xcab3
leaq -0x30(%rbp... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
const std::string& str) {
std::string output;
output.reserve(str.size());
for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
if (IsValidXmlCharacter(static_cast<unsigned char>(*it)))
output.push_back(*it);
re... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x78b0
movq (%r14), %rax
movl $0x2600, %r15d # imm = 0x2600
movq %rax, %r12
movq 0x8(%r14), %rcx
a... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*) | void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
const char* data) {
const char* segment = data;
*stream << "<![CDATA[";
for (;;) {
const char* const next_segment = strstr(segment, "]]>");
if (next_segment != nullptr) {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18f66(%rip), %rsi # 0x2c487
callq 0x74e0
leaq 0x18f4d(%rip), %r15 # 0x2c47a
leaq 0x18f4a(%rip), %r12 # 0x2c47e
movq %r14, %rdi
movq %r15, %rsi
callq 0x7100
testq %rax, %rax
je ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream*, testing::TestSuite const&) | void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
const TestSuite& test_suite) {
const std::string kTestsuite = "testsuite";
*stream << " <" << kTestsuite;
OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
OutputXmlAttribute... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x17b78(%rip), %rsi # 0x2c526
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x8696
leaq 0x17cd0(%rip), %rsi # 0x2c695
movq %rbx, %rdi
callq 0x74e0
leaq -0x88(%rbp), %rsi
movq %rax, ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream*, testing::UnitTest const&) | void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
const UnitTest& unit_test) {
const std::string kTestsuites = "testsuites";
const std::string kIndent = Indent(2);
*stream << "{\n";
OutputJsonKey(stream, kTestsuites, "tests", unit_test.rep... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x175de(%rip), %rsi # 0x2c63f
leaq -0xb8(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0x8696
leaq -0x98(%rbp), %rdi
pushq $0x2
popq %rsi
callq 0x16344
leaq 0x176c1(%rip), %rsi # 0x... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::EscapeJson(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '\\':
case '"':
case '/':
m << '\\' << ch;
break;
case '\b':
m << "\\b";
break;... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, -0x40(%rbp)
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0xc8c8
movq (%rbx), %rax
movq %rax, -0x38(%rbp)
addq $0x10, %rax
movq %rax, -0x30(%rbp)
xorl %r13d, %r13d
leaq -0x68(%rbp), %r12
cmpq 0x8... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ConfigureXmlOutput() | void UnitTestImpl::ConfigureXmlOutput() {
const std::string& output_format = UnitTestOptions::GetOutputFormat();
#if GTEST_HAS_FILE_SYSTEM
if (output_format == "xml") {
listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
} else if... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0xb4e4
leaq 0x11c73(%rip), %rsi # 0x2a79c
movq %r14, %rdi
callq 0x1d80f
testb %al, %al
je 0x18b6f
pushq $0x28
popq %rdi
callq 0x72c0
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::GetTestSuite(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void (*)(), void (*)()) | TestSuite* UnitTestImpl::GetTestSuite(
const std::string& test_suite_name, const char* type_param,
internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc) {
// During initialization, all TestInfos for a given suite are added in
// sequence. To optimize this case, see if the... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0xc0(%rdi), %rax
cmpq %rax, 0xb8(%rdi)
je 0x18ea3
movq -0x8(%rax), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x1d8ba
testb %al, %al
je 0... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::GetDirFromEnv[abi:cxx11](std::initializer_list<char const*>, char const*, char) | static std::string GetDirFromEnv(
std::initializer_list<const char*> environment_variables,
const char* fallback, char separator) {
for (const char* variable_name : environment_variables) {
const char* value = internal::posix::GetEnv(variable_name);
if (value != nullptr && value[0] != '\0') {
if... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, -0x38(%rbp)
shlq $0x3, %r15
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0x19a2c
movq (%r12,%rbx), %rdi
callq 0x7670
testq %rax, %rax
je 0x19a26
movq %rax, %r13
cmpb $0x0, ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::TestInfo* testing::RegisterTest<testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::InsertSynthetic... | Test* CreateTest() override { return factory_(); } | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %r15
pushq $0x60
popq %rdi
callq 0x72c0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x7790
addq $0x28, %r14
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19ed2
leaq -0x38(%rbp),... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest.h |
testing::internal::LoadFlagsFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void LoadFlagsFromFile(const std::string& path) {
FILE* flagfile = posix::FOpen(path.c_str(), "r");
if (!flagfile) {
GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG_GET(flagfile)
<< "\"";
}
std::string contents(ReadEntireFile(flagfile));
posix::FClose(flagfile);
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq (%rdi), %rdi
leaq 0x11733(%rip), %rsi # 0x2c6e1
callq 0x7630
movq %rax, %rbx
testq %rax, %rax
jne 0x1b00d
leaq 0x107c1(%rip), %rdx # 0x2b783
leaq -0x50(%rbp), %rdi
pushq $0x3
popq %rsi
movl $0x1a08, %ecx # imm = 0x1A08
callq 0x93ba... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::Message& testing::Message::operator<<<char [11]>(char const (&) [11]) | 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 g... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x74e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-message.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [2]>(char const (&) [2]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xc8c8
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x74e0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x8d1a
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1bd2... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-assertion-result.h |
testing::Message& testing::Message::operator<<<char [65]>(char const (&) [65]) | 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 g... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x74e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-message.h |
testing::TestPartResult::TestPartResult(testing::TestPartResult::Type, char const*, int, char const*) | TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
const char* a_message)
: type_(a_type),
file_name_(a_file_name == nullptr ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
message_(a_message) {} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movl %ecx, %r12d
movq %rdi, %r15
movl %esi, (%rdi)
leaq 0x8(%rdi), %rbx
testq %rdx, %rdx
leaq 0xf597(%rip), %rsi # 0x2c36f
cmovneq %rdx, %rsi
leaq -0x22(%rbp), %rdx
movq %rbx, %rdi
callq 0x8696
movl %r12d, 0x28(%... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-test-part.h |
testing::Message& testing::Message::operator<<<char>(char const&) | 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 g... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
movsbl (%rsi), %esi
callq 0x7600
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
: premature_exit_filepath_(
premature_exit_filepath ? premature_exit_filepath : "") {
// If a path to the premature-exit file is specified...
if (!premature_exit_filepath_.empty()) {
// create the file with a single "0... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0xf016(%rip), %rax # 0x2c36f
cmoveq %rax, %rsi
leaq -0x9(%rbp), %rdx
callq 0x8696
cmpq $0x0, 0x8(%rbx)
je 0x1d392
movq (%rbx), %rdi
leaq 0xf690(%rip), %rsi # 0x2ca07
callq 0x7630
movq %rax, %rbx
pushq $0x30
popq %rdi
movq %... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
bool testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl, bool>(testing::internal::UnitTestImpl*, bool (testing::internal::UnitTestImpl::*)(), char const*) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*method)(),
const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. I... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x1b36c
addq %r15, %r14
cmpb $0x1, 0x2c8(%rax)
jne 0x1d3e6
testb $0x1, %r12b
je 0x1d3d3
movq (%r14), %rax
movq -0x1(%rax,%r12), %r12
movq %r14, %rdi
callq *%r12
a... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::ParameterizedTestSuiteRegistry::~ParameterizedTestSuiteRegistry() | ~ParameterizedTestSuiteRegistry() {
for (auto& test_suite_info : test_suite_infos_) {
delete test_suite_info;
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x1d733
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1d72d
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x1d71a
leaq 0x18(%rbx), %rdi
callq 0x1f8f2
movq %rbx, %rdi
addq $... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/internal/gtest-param-util.h |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<char>(int*, char**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
std::string flagfile_value;
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseFlag;
bool remove_flag = false;
if (ParseGo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
pushq $0x1
popq %r13
cmpl (%r14), %r13d
jge 0x1ddda
movslq %r13d, %r15
leaq (%rbx,%r15,8), %rsi
leaq -0... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
_cxx_global_var_init | std::string
QPDFObject::getDescription()
{
qpdf_offset_t shift = (getTypeCode() == ::ot_dictionary) ? 2
: (getTypeCode() == ::ot_array) ? 1
: 0;
if (object_description) {
switch (object_description->index()) {
... | pushq %rbp
movq %rsp, %rbp
leaq 0x47b79d(%rip), %rdi # 0x4986f8
callq 0x1bec0
movq 0x479fe1(%rip), %rdi # 0x496f48
leaq 0x47b78a(%rip), %rsi # 0x4986f8
leaq 0x47a993(%rip), %rdx # 0x497908
callq 0x1bcf0
popq %rbp
retq
nopl (%rax)
| /qpdf[P]qpdf/libqpdf/QPDFObject.cc |
GLOBAL__sub_I_QPDFObject.cc | std::string
QPDFObject::getDescription()
{
qpdf_offset_t shift = (getTypeCode() == ::ot_dictionary) ? 2
: (getTypeCode() == ::ot_array) ? 1
: 0;
if (object_description) {
switch (object_description->index()) {
... | pushq %rbp
movq %rsp, %rbp
callq 0x1cf50
popq %rbp
retq
nopl (%rax,%rax)
| /qpdf[P]qpdf/libqpdf/QPDFObject.cc |
main | int
main()
{
uint32_t u1 = 3141592653U; // Too big for signed type
int32_t i1 = -1153374643; // Same bit pattern as u1
uint64_t ul1 = 1099511627776LL; // Too big for 32-bit
uint64_t ul2 = 12345; // Fits into 32-bit
int32_t i2 = 81;... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl $0x0, -0x4(%rbp)
movl $0xbb40e64d, -0x8(%rbp) # imm = 0xBB40E64D
movl $0xbb40e64d, -0xc(%rbp) # imm = 0xBB40E64D
movabsq $0x10000000000, %rax # imm = 0x10000000000
movq %rax, -0x18(%rbp)
movq $0x3039, -0x20(%rbp) # imm = 0x3039
movl $0x51, -0x24(%rbp)
movb $-0x9, -... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<int, int>(char const*, bool, int (*)(int const&), int const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movl %eax, -0x44(%rbp)
jmp 0x1e5b2
movl -0x44(%rbp), %eax
movl %eax, -0x28(%... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<unsigned int, unsigned int>(char const*, bool, unsigned int (*)(unsigned int const&), unsigned int const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movl %eax, -0x44(%rbp)
jmp 0x1e752
movl -0x44(%rbp), %eax
movl %eax, -0x28(%... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<unsigned int, int>(char const*, bool, int (*)(unsigned int const&), unsigned int const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movl %eax, -0x44(%rbp)
jmp 0x1e8f2
movl -0x44(%rbp), %eax
movl %eax, -0x28(%... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<int, unsigned int>(char const*, bool, unsigned int (*)(int const&), int const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movl %eax, -0x44(%rbp)
jmp 0x1ea92
movl -0x44(%rbp), %eax
movl %eax, -0x28(%... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<unsigned long, int>(char const*, bool, int (*)(unsigned long const&), unsigned long const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movl %eax, -0x44(%rbp)
jmp 0x1ec32
movl -0x44(%rbp), %eax
movl %eax, -0x28(%... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<unsigned long, unsigned int>(char const*, bool, unsigned int (*)(unsigned long const&), unsigned long const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movl %eax, -0x44(%rbp)
jmp 0x1edd2
movl -0x44(%rbp), %eax
movl %eax, -0x28(%... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<unsigned int, long long>(char const*, bool, long long (*)(unsigned int const&), unsigned int const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movq %rax, -0x50(%rbp)
jmp 0x1ef73
movq -0x50(%rbp), %rax
movq %rax, -0x30(%... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<int, long long>(char const*, bool, long long (*)(int const&), int const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movq %rax, -0x50(%rbp)
jmp 0x1f123
movq -0x50(%rbp), %rax
movq %rax, -0x30(%... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<int, unsigned long long>(char const*, bool, unsigned long long (*)(int const&), int const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movq %rax, -0x50(%rbp)
jmp 0x1f2d3
movq -0x50(%rbp), %rax
movq %rax, -0x30(%... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<int, char>(char const*, bool, char (*)(int const&), int const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movb %al, -0x41(%rbp)
jmp 0x1f482
movb -0x41(%rbp), %al
movb %al, -0x22(%rbp... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<int, unsigned char>(char const*, bool, unsigned char (*)(int const&), int const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movb %al, -0x41(%rbp)
jmp 0x1f622
movb -0x41(%rbp), %al
movb %al, -0x22(%rbp... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<signed char, unsigned char>(char const*, bool, unsigned char (*)(signed char const&), signed char const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movb %al, -0x41(%rbp)
jmp 0x1f7c2
movb -0x41(%rbp), %al
movb %al, -0x22(%rbp... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<char, unsigned char>(char const*, bool, unsigned char (*)(char const&), char const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movb %al, -0x41(%rbp)
jmp 0x1f962
movb -0x41(%rbp), %al
movb %al, -0x22(%rbp... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_convert_real<char, char>(char const*, bool, char (*)(char const&), char const&) | static void
try_convert_real(char const* description, bool exp_pass, To (*fn)(From const&), From const& i)
{
bool passed = false;
try {
To result = fn(i);
passed = true;
std::cout << description << ": " << i << " " << result;
} catch (std::range_error& e) {
std::cout << descr... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movb %al, -0x41(%rbp)
jmp 0x1fb02
movb -0x41(%rbp), %al
movb %al, -0x22(%rbp... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_range_check_real<int>(char const*, bool, int const&, int const&) | static void
try_range_check_real(char const* description, bool exp_pass, T const& a, T const& b)
{
bool passed = false;
try {
QIntC::range_check(a, b);
std::cout << description << ": okay";
passed = true;
} catch (std::range_error& e) {
std::cout << description << ": " << e.w... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22880
jmp 0x1fc9f
movq -0x8(%rbp), %rsi
movq 0x47726e(%rip), %rdi # 0x496f18
... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_range_check_real<long long>(char const*, bool, long long const&, long long const&) | static void
try_range_check_real(char const* description, bool exp_pass, T const& a, T const& b)
{
bool passed = false;
try {
QIntC::range_check(a, b);
std::cout << description << ": okay";
passed = true;
} catch (std::range_error& e) {
std::cout << description << ": " << e.w... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22cb0
jmp 0x1fdef
movq -0x8(%rbp), %rsi
movq 0x47711e(%rip), %rdi # 0x496f18
... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_range_check_real<unsigned long long>(char const*, bool, unsigned long long const&, unsigned long long const&) | static void
try_range_check_real(char const* description, bool exp_pass, T const& a, T const& b)
{
bool passed = false;
try {
QIntC::range_check(a, b);
std::cout << description << ": okay";
passed = true;
} catch (std::range_error& e) {
std::cout << description << ": " << e.w... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x230f0
jmp 0x1ff3f
movq -0x8(%rbp), %rsi
movq 0x476fce(%rip), %rdi # 0x496f18
... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_range_check_real<signed char>(char const*, bool, signed char const&, signed char const&) | static void
try_range_check_real(char const* description, bool exp_pass, T const& a, T const& b)
{
bool passed = false;
try {
QIntC::range_check(a, b);
std::cout << description << ": okay";
passed = true;
} catch (std::range_error& e) {
std::cout << description << ": " << e.w... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x23540
jmp 0x2008f
movq -0x8(%rbp), %rsi
movq 0x476e7e(%rip), %rdi # 0x496f18
... | /qpdf[P]qpdf/libtests/qintc.cc |
void try_range_check_real<char>(char const*, bool, char const&, char const&) | static void
try_range_check_real(char const* description, bool exp_pass, T const& a, T const& b)
{
bool passed = false;
try {
QIntC::range_check(a, b);
std::cout << description << ": okay";
passed = true;
} catch (std::range_error& e) {
std::cout << description << ": " << e.w... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x239b0
jmp 0x201df
movq -0x8(%rbp), %rsi
movq 0x476d2e(%rip), %rdi # 0x496f18
... | /qpdf[P]qpdf/libtests/qintc.cc |
QIntC::IntConverter<int, int, true, true>::error(int) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte signed type";
throw std... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movl %edi, -0x4(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be10
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x20832
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<unsigned int, int, false, true>::error(unsigned int) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte unsigned type to a " << sizeof(To) << "-byte signed type";
throw s... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movl %edi, -0x4(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be10
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x20cc2
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<int, unsigned int, true, false>::convert(int const&) | inline static To
convert(From const& i)
{
// From is signed, and To is unsigned. If i > 0, it's safe to
// convert it to the corresponding unsigned type and to
// compare with To's max.
auto ii = static_cast<typename to_u<From>::type>(i);
if ((... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x20eb2
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
callq 0x20a30
movl %eax, %ecx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jbe 0x20ebd
movq -0x8(%rbp)... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<int, unsigned int, true, false>::error(int) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte unsigned type";
throw s... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movl %edi, -0x4(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be10
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x20f12
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<unsigned long, int, false, true>::convert(unsigned long const&) | inline static To
convert(From const& i)
{
// From is unsigned, and to is signed. Convert To's max to the
// unsigned version of To and compare i against that.
auto maxval = static_cast<typename to_u<To>::type>(std::numeric_limits<To>::max());
if (i > maxva... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x207e0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x210ff
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x21110
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
no... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<unsigned long, unsigned int, false, false>::error(unsigned long) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte unsigned type to a " << sizeof(To) << "-byte unsigned type";
throw... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be10
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x213a3
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<unsigned int, long long, false, true>::convert(unsigned int const&) | inline static To
convert(From const& i)
{
// From is unsigned, and to is signed. Convert To's max to the
// unsigned version of To and compare i against that.
auto maxval = static_cast<typename to_u<To>::type>(std::numeric_limits<To>::max());
if (i > maxva... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x215a0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpq -0x10(%rbp), %rax
jbe 0x2158c
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x215b0
movq -0x8(%rbp), %rax
movl (%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
BufferInputSource::seek(long long, int) | void
BufferInputSource::seek(qpdf_offset_t offset, int whence)
{
switch (whence) {
case SEEK_SET:
this->cur_offset = offset;
break;
case SEEK_END:
QIntC::range_check(this->max_offset, offset);
this->cur_offset = this->max_offset + offset;
break;
case SEEK_CUR:
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x50(%rbp)
testl %eax, %eax
je 0x26a7b
jmp 0x26a67
movl -0x50(%rbp), %eax
subl $0x1, %eax
je 0x26abb
jmp 0x26a71
movl -0x50(%rbp... | /qpdf[P]qpdf/libqpdf/BufferInputSource.cc |
QIntC::IntConverter<unsigned long, long long, false, true>::convert(unsigned long const&) | inline static To
convert(From const& i)
{
// From is unsigned, and to is signed. Convert To's max to the
// unsigned version of To and compare i against that.
auto maxval = static_cast<typename to_u<To>::type>(std::numeric_limits<To>::max());
if (i > maxva... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x215a0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jbe 0x26f0e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x26f20
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<unsigned long, long long, false, true>::error(unsigned long) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte unsigned type to a " << sizeof(To) << "-byte signed type";
throw s... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be10
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x26f63
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<long long, unsigned long, true, false>::convert(long long const&) | inline static To
convert(From const& i)
{
// From is signed, and To is unsigned. If i > 0, it's safe to
// convert it to the corresponding unsigned type and to
// compare with To's max.
auto ii = static_cast<typename to_u<From>::type>(i);
if ((... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jl 0x2715a
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x27180
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jbe 0x27166
movq -0x8(%rb... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<long long, unsigned long, true, false>::error(long long) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte unsigned type";
throw s... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be10
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x271d3
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
ClosedFileInputSource::ClosedFileInputSource(char const*) | ClosedFileInputSource::ClosedFileInputSource(char const* filename) :
filename(filename),
offset(0),
stay_open(false)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x26db0
movq -0x48(%rbp), %rax
leaq 0x469590(%rip), %rcx # 0x490948
movq %rcx, (%rax)
addq $0xa8, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq ... | /qpdf[P]qpdf/libqpdf/ClosedFileInputSource.cc |
ContentNormalizer::handleToken(QPDFTokenizer::Token const&) | void
ContentNormalizer::handleToken(QPDFTokenizer::Token const& token)
{
QPDFTokenizer::token_type_e token_type = token.getType();
if (token_type == QPDFTokenizer::tt_bad) {
this->any_bad_tokens = true;
this->last_token_was_bad = true;
} else if (token_type != QPDFTokenizer::tt_eof) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29050
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x28b91
movq -0x120(%rbp), %rax
movb $0x1, 0x10(%rax)
movb $0x1, 0x11(%r... | /qpdf[P]qpdf/libqpdf/ContentNormalizer.cc |
FileInputSource::seek(long long, int) | void
FileInputSource::seek(qpdf_offset_t offset, int whence)
{
if (QUtil::seek(this->file, offset, whence) == -1) {
QUtil::throw_system_error(
std::string("seek to ") + this->filename + ", offset " + std::to_string(offset) + " (" +
std::to_string(whence) + ")");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
movq 0xd0(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2b4940
cmpl $-0x1, %eax
jne 0x29ba4
leaq -0xf9(%rbp), %rdi
m... | /qpdf[P]qpdf/libqpdf/FileInputSource.cc |
FileInputSource::read(char*, unsigned long) | size_t
FileInputSource::read(char* buffer, size_t length)
{
this->last_offset = QUtil::tell(this->file);
size_t len = fread(buffer, 1, length, this->file);
if (len == 0) {
if (ferror(this->file)) {
throw QPDFExc(
qpdf_e_system,
this->filename,
... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq 0xd0(%rax), %rdi
callq 0x2b4980
movq %rax, %rcx
movq -0xf0(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp),... | /qpdf[P]qpdf/libqpdf/FileInputSource.cc |
InputSource::findLast(char const*, long long, unsigned long, InputSource::Finder&) | bool
InputSource::findLast(char const* start_chars, qpdf_offset_t offset, size_t len, Finder& finder)
{
bool found = false;
qpdf_offset_t after_found_offset = 0;
qpdf_offset_t cur_offset = offset;
size_t cur_len = len;
while (this->findFirst(start_chars, cur_offset, cur_len, finder)) {
if (f... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x29(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
mov... | /qpdf[P]qpdf/libqpdf/InputSource.cc |
InsecureRandomDataProvider::random() | long
InsecureRandomDataProvider::random()
{
if (!this->seeded_random) {
// Seed the random number generator with something simple, but just to be interesting, don't
// use the unmodified current time. It would be better if this were a more secure seed.
auto seed = static_cast<unsigned int>(... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x8(%rax)
jne 0x2b348
callq 0x2b5690
xorq $0xcccc, %rax # imm = 0xCCCC
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x1c020
movq -0x18(%rbp), %rax
movb $0x1, 0x8(%rax)
callq 0x1c0a0
... | /qpdf[P]qpdf/libqpdf/InsecureRandomDataProvider.cc |
JSON::writeClose(Pipeline*, bool, unsigned long, char const*) | void
JSON::writeClose(Pipeline* p, bool first, size_t depth, char const* delimiter)
{
if (first) {
*p << delimiter;
} else {
std::string s{"\n"};
s.append(2 * depth, ' ');
*p << s + delimiter;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0x2b597
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4c410
jmp 0x2b663
leaq -0x41(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq ... | /qpdf[P]qpdf/libqpdf/JSON.cc |
JSON::writeNext(Pipeline*, bool&, unsigned long) | void
JSON::writeNext(Pipeline* p, bool& first, size_t depth)
{
if (first) {
first = false;
std::string s{"\n"};
s.append(2 * depth, ' ');
*p << s;
} else {
std::string s{",\n"};
s.append(2 * depth, ' ');
*p << s;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x2b73f
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1be50
movq -0x80(%rbp), %rdx
leaq 0x3096b2(%rip), %rsi # ... | /qpdf[P]qpdf/libqpdf/JSON.cc |
JSON::JSON_dictionary::write(Pipeline*, unsigned long) const | void
JSON::JSON_dictionary::write(Pipeline* p, size_t depth) const
{
bool first = true;
writeDictionaryOpen(p, first, depth);
for (auto const& iter: members) {
writeDictionaryItem(p, first, iter.first, iter.second, 1 + depth);
}
writeDictionaryClose(p, first, depth);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x19(%rbp), %rsi
callq 0x2b7f0
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(... | /qpdf[P]qpdf/libqpdf/JSON.cc |
JSON::JSON_array::write(Pipeline*, unsigned long) const | void
JSON::JSON_array::write(Pipeline* p, size_t depth) const
{
bool first = true;
writeArrayOpen(p, first, depth);
for (auto const& element: elements) {
writeArrayItem(p, first, element, 1 + depth);
}
writeArrayClose(p, first, depth);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x19(%rbp), %rsi
callq 0x2b830
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(... | /qpdf[P]qpdf/libqpdf/JSON.cc |
JSON::JSON_blob::write(Pipeline*, unsigned long) const | void
JSON::JSON_blob::write(Pipeline* p, size_t) const
{
*p << "\"";
Pl_Concatenate cat("blob concatenate", p);
Pl_Base64 base64("blob base64", &cat, Pl_Base64::a_encode);
fn(&base64);
base64.finish();
*p << "\"";
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2f16e6(%rip), %rsi # 0x31db83
callq 0x4c410
movq -0x10(%rbp), %rdx
leaq 0x2e6940(%rip), %rsi # 0x312ded
leaq -0x50(%rbp), %rdi
... | /qpdf[P]qpdf/libqpdf/JSON.cc |
JSON::unparse[abi:cxx11]() const | std::string
JSON::unparse() const
{
if (!m) {
return "null";
}
std::string s;
Pl_String p("unparse", nullptr, s);
write(&p, 0);
return s;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x34ab0
testb $0x1, %al
jne 0x2c5fa
leaq -0x11(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1be50
movq -0x78(%rbp), %rd... | /qpdf[P]qpdf/libqpdf/JSON.cc |
JSON::addDictionaryMember(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, JSON const&) | JSON
JSON::addDictionaryMember(std::string const& key, JSON const& val)
{
if (auto* obj = m ? dynamic_cast<JSON_dictionary*>(m->value.get()) : nullptr) {
return obj->members[Writer::encode_string(key)] = val.m ? val : makeNull();
} else {
throw std::runtime_error("JSON::addDictionaryMember calle... | 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 %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x34ab0
testb $0x1, %al
jne 0x2c769
jmp 0x2c7c9
movq -0x70(%rbp), %rdi
... | /qpdf[P]qpdf/libqpdf/JSON.cc |
MD5::encodeFile(char const*, long long) | void
MD5::encodeFile(char const* filename, qpdf_offset_t up_to_offset)
{
char buffer[1024];
FILE* file = QUtil::safe_fopen(filename, "rb");
size_t len;
size_t so_far = 0;
size_t to_try = 1024;
size_t up_to_size = 0;
if (up_to_offset >= 0) {
up_to_size = QIntC::to_size(up_to_offset);... | pushq %rbp
movq %rsp, %rbp
subq $0x4b0, %rsp # imm = 0x4B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x4a8(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2d1f97(%rip), %rsi # 0x312804
callq 0x2b4790
movq %rax, -0x428(%rbp)
movq $0x0, -0x438(%rbp)
movq $0x40... | /qpdf[P]qpdf/libqpdf/MD5.cc |
NNTreeIterator::increment(bool) | void
NNTreeIterator::increment(bool backward)
{
if (this->item_number < 0) {
QTC::TC("qpdf", "NNTree increment end()");
deepen(impl.oh, !backward, true);
return;
}
bool found_valid_key = false;
while (valid() && (!found_valid_key)) {
this->item_number += backward ? -2 : 2... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
cmpl $0x0, 0x38(%rax)
jge 0x41aed
leaq 0x2f5869(%rip), %rdi # 0x3372dc
leaq 0x2d20c1(%rip), %rsi # 0x313b3b
xorl %edx, %edx
c... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::resetLimits(QPDFObjectHandle, std::_List_iterator<NNTreeIterator::PathElement>) | void
NNTreeIterator::resetLimits(QPDFObjectHandle node, std::list<PathElement>::iterator parent)
{
bool done = false;
while (!done) {
if (parent == this->path.end()) {
QTC::TC("qpdf", "NNTree remove limits from root");
node.removeKey("/Limits");
done = true;
... | pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp # imm = 0x420
movq %rsi, -0x300(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2f8(%rbp)
movb $0x0, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x42ccb
jmp 0x43bb6
movq -0x2f... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::repair() | void
NNTreeImpl::repair()
{
auto new_node = QPDFObjectHandle::newDictionary();
new_node.replaceKey(details.itemsKey(), QPDFObjectHandle::newArray());
NNTreeImpl repl(details, qpdf, new_node, false);
for (auto const& i: *this) {
repl.insert(i.first, i.second);
}
this->oh.replaceKey("/Kids... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x238(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1ccf30
movq -0x238(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, -0x230(%rbp)
jmp 0x46c1e
leaq -0x38(%rbp), ... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::findInternal(QPDFObjectHandle, bool) | NNTreeImpl::iterator
NNTreeImpl::findInternal(QPDFObjectHandle key, bool return_prev_if_not_found)
{
auto first_item = begin();
auto last_item = end();
if (first_item == end()) {
// Empty
return end();
} else if (
first_item.valid() && details.keyValid(first_item->first) &&
... | pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp # imm = 0x4E0
movq %rdx, -0x398(%rbp)
movq %rdi, -0x390(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x388(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x380(%r... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
Pl_AES_PDF::setIV(unsigned char const*, unsigned long) | void
Pl_AES_PDF::setIV(unsigned char const* iv, size_t bytes)
{
if (bytes != this->buf_size) {
throw std::logic_error(
"Pl_AES_PDF: specified initialization vector"
" size in bytes must be " +
std::to_string(bytes));
}
this->use_specified_iv = true;
memcpy(thi... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x10, -0x18(%rbp)
je 0x4ce3a
movb $0x1, -0x65(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq... | /qpdf[P]qpdf/libqpdf/Pl_AES_PDF.cc |
Pl_AES_PDF::initializeVector() | void
Pl_AES_PDF::initializeVector()
{
if (use_zero_iv) {
for (unsigned int i = 0; i < this->buf_size; ++i) {
this->cbc_block[i] = 0;
}
} else if (use_specified_iv) {
std::memcpy(this->cbc_block, this->specified_iv, this->buf_size);
} else if (use_static_iv) {
for ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0xa0(%rax)
je 0x4d3c9
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jae 0x4d3c4
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movb $0x0, 0x80(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %ea... | /qpdf[P]qpdf/libqpdf/Pl_AES_PDF.cc |
QIntC::IntConverter<unsigned long, unsigned char, false, false>::error(unsigned long) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte unsigned type to a " << sizeof(To) << "-byte unsigned type";
throw... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be10
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x4dbd3
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
Pl_ASCII85Decoder::Pl_ASCII85Decoder(char const*, Pipeline*) | Pl_ASCII85Decoder::Pl_ASCII85Decoder(char const* identifier, Pipeline* next) :
Pipeline(identifier, next)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_ASCII85Decoder with nullptr as next");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4c1b0
movq -0x30(%rbp), %rax
leaq 0x443204(%rip), %rcx # 0x490fc8
addq $0x10, %rcx
movq %rcx, (%rax)
movb ... | /qpdf[P]qpdf/libqpdf/Pl_ASCII85Decoder.cc |
Pl_ASCIIHexDecoder::Pl_ASCIIHexDecoder(char const*, Pipeline*) | Pl_ASCIIHexDecoder::Pl_ASCIIHexDecoder(char const* identifier, Pipeline* next) :
Pipeline(identifier, next)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_ASCIIHexDecoder with nullptr as next");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4c1b0
movq -0x30(%rbp), %rax
leaq 0x442cbc(%rip), %rcx # 0x491010
addq $0x10, %rcx
movq %rcx, (%rax)
movb ... | /qpdf[P]qpdf/libqpdf/Pl_ASCIIHexDecoder.cc |
Pl_Base64::Pl_Base64(char const*, Pipeline*, Pl_Base64::action_e) | Pl_Base64::Pl_Base64(char const* identifier, Pipeline* next, action_e action) :
Pipeline(identifier, next),
action(action)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_Base64 with nullptr as next");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4c1b0
movq -0x38(%rbp), %rax
leaq 0x4427f1(%rip), %rcx # 0x491058
addq $0x10, %rcx
... | /qpdf[P]qpdf/libqpdf/Pl_Base64.cc |
Pl_Base64::flush_encode() | void
Pl_Base64::flush_encode()
{
int outval = ((this->buf[0] << 16) | (this->buf[1] << 8) | (this->buf[2]));
unsigned char out[4] = {
to_uc(outval >> 18),
to_uc(0x3f & (outval >> 12)),
to_uc(0x3f & (outval >> 6)),
to_uc(0x3f & outval),
};
for (size_t i = 0; i < 4; ++i) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movzbl 0x34(%rcx), %eax
shll $0x10, %eax
movzbl 0x35(%rcx), %edx
shll $0x8, %edx
orl %edx, %eax
movzbl 0x36(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
sarl $0x12, %edi
callq 0x4f0c0... | /qpdf[P]qpdf/libqpdf/Pl_Base64.cc |
Pl_Buffer::write(unsigned char const*, unsigned long) | void
Pl_Buffer::write(unsigned char const* buf, size_t len)
{
if (!len) {
return;
}
m->data.append(reinterpret_cast<char const*>(buf), len);
m->ready = false;
if (next()) {
next()->write(buf, len);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4f575
jmp 0x4f5cf
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x4fa50
movq %rax, %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0... | /qpdf[P]qpdf/libqpdf/Pl_Buffer.cc |
Pl_DCT::Members::Members(unsigned int, unsigned int, int, J_COLOR_SPACE, Pl_DCT::CompressConfig*) | Members(
JDIMENSION image_width,
JDIMENSION image_height,
int components,
J_COLOR_SPACE color_space,
CompressConfig* config_callback) :
action(a_compress),
buf("DCT uncompressed image"),
image_width(image_width),
image_height(image_height),
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x0, (%rdi)
addq $0x8, %rdi
leaq 0x2c1f93(%rip), %rsi # 0x314ae9
xorl %eax, %eax
movl %... | /qpdf[P]qpdf/libqpdf/Pl_DCT.cc |
Pl_Flate::write(unsigned char const*, unsigned long) | void
Pl_Flate::write(unsigned char const* data, size_t len)
{
if (m->outbuf == nullptr) {
throw std::logic_error(
this->identifier + ": Pl_Flate: write() called after finish() called");
}
if (m->zopfli_buf) {
m->zopfli_buf->append(reinterpret_cast<char const*>(data), len);
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x30, %rdi
callq 0x54a60
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x54b50
testb $0x1, %al
jne 0x5381d
jmp 0x538b1
movb $0x1, -0x45(%rbp)
movl $0... | /qpdf[P]qpdf/libqpdf/Pl_Flate.cc |
Pl_Flate::finish_zopfli() | void
Pl_Flate::finish_zopfli()
{
#ifdef ZOPFLI
if (!m->zopfli_buf) {
return;
}
auto buf = std::move(*m->zopfli_buf.release());
ZopfliOptions z_opt;
ZopfliInitOptions(&z_opt);
unsigned char* out{nullptr};
size_t out_size{0};
ZopfliCompress(
&z_opt,
ZOPFLI_FORMAT_ZL... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| /qpdf[P]qpdf/libqpdf/Pl_Flate.cc |
Pl_LZWDecoder::Pl_LZWDecoder(char const*, Pipeline*, bool) | Pl_LZWDecoder::Pl_LZWDecoder(char const* identifier, Pipeline* next, bool early_code_change) :
Pipeline(identifier, next),
code_change_delta(early_code_change)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_LZWDecoder with nullptr as next");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4c1b0
movq -0x38(%rbp), %rdi
leaq 0x439995(%rip), %rax ... | /qpdf[P]qpdf/libqpdf/Pl_LZWDecoder.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.