name string | code string | asm string | file string |
|---|---|---|---|
Catch::ReusableStringStream::~ReusableStringStream() | ReusableStringStream::~ReusableStringStream() {
static_cast<std::ostringstream*>( m_oss )->str("");
m_oss->clear();
Singleton<StringStreams>::getMutable().release( m_index );
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x11f63d(%rip), %rcx # 0x14a008
movq %rcx, (%rax)
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x158e0
movq -0x38(%rbp), %rdx
leaq 0xb35cd(%rip), %rs... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::trim(Catch::StringRef)::$_0::operator()(char) const | StringRef trim(StringRef ref) {
const auto is_ws = [](char c) {
return c == ' ' || c == '\t' || c == '\n' || c == '\r';
};
size_t real_begin = 0;
while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
size_t real_end = ref.size();
while (r... | pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0xa(%rbp)
je 0x2abd5
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0xa(%rbp)
je 0x2abd5
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb ... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::replaceInPlace(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
bool replaced = false;
std::size_t i = str.find( replaceThis );
while( i != std::string::npos ) {
replaced = true;
str = str.substr( 0, i ) + withThis + str.substr( i+re... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x57d40
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x2ae7e
movb $0x1,... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::StringRef::c_str() const | auto StringRef::c_str() const -> char const* {
CATCH_ENFORCE(isNullTerminated(), "Called StringRef::c_str() on a non-null-terminated instance");
return m_start;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x58020
testb $0x1, %al
jne 0x2afac
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2a8f0
movq -0x68(%rbp), %rdi
leaq 0xb3906(%rip), %rsi # 0xde85f
callq 0x58050
movq %ra... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::RegistrarForTagAliases::RegistrarForTagAliases(char const*, char const*, Catch::SourceLineInfo const&) | RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
CATCH_TRY {
getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x250c0
movq %rax, -0x88(%rbp)
jmp 0x2b069
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x158e0
movq -0x98(%rbp), %rsi
movq -0... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::TagAliasRegistry::expandAliases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
std::string expandedTestSpec = unexpandedTestSpec;
for( auto const& registryKvp : m_registry ) {
std::size_t pos = expandedTestSpec.find( registryKvp.first );
if( pos != std::string::npos... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
callq 0x51710
movq -0xe0(%rb... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::TagAliasRegistry::add(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&, Catch::SourceLineInfo const&) | void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
"error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
CATCH_ENFORCE( ... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x180(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x190(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x188(%rbp)
callq 0x158e0
movq ... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::makeTestCase(Catch::ITestInvoker*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::NameAndTags const&, Catch::SourceLineInfo const&) | TestCase makeTestCase( ITestInvoker* _testCase,
std::string const& _className,
NameAndTags const& nameAndTags,
SourceLineInfo const& _lineInfo )
{
bool isHidden = false;
// Parse out tags
std::vector<std::s... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x218(%rbp)
movq %rdi, %rax
movq %rax, -0x210(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x58390
leaq -0x68(%r... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::(anonymous namespace)::parseSpecialTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
if( startsWith( tag, '.' ) ||
tag == "!hide" )
return TestCaseInfo::IsHidden;
else if( tag == "!throws" )
return TestCaseInfo::Throws;
else if( tag == "!shouldf... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x20c30
testb $0x1, %al
jne 0x2bf74
movq -0x10(%rbp), %rdi
leaq 0xb29a6(%rip), %rsi # 0xde90f
callq 0x54f30
testb $0x1, %al
jne 0x2bf74
jmp 0x2bf80
movl $0x2, -0x4(%rbp)
jmp 0x2c025
movq -0x10(%rbp), %rd... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::TablePrinter::TablePrinter(std::ostream&, std::vector<Catch::(anonymous namespace)::ColumnInfo, std::allocator<Catch::(anonymous namespace)::ColumnInfo>>) | TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
: m_os( os ),
m_columnInfos( std::move( columnInfos ) ) {} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, %rax
movq -0x40(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x452b0
movq -0... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::ConsoleReporter::assertionEnded(Catch::AssertionStats const&) | bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
AssertionResult const& result = _assertionStats.assertionResult;
bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
// Drop out if result was successful but we're not printing them.
if (!includeRes... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x513f0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movb %al, %cl
movb $0x1, %al
testb $0x1,... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::(anonymous namespace)::ConsoleAssertionPrinter::ConsoleAssertionPrinter(std::ostream&, Catch::AssertionStats const&, bool) | ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
: stream(_stream),
stats(_stats),
result(_stats.assertionResult),
colour(Colour::None),
message(result.getMessage()),
messages(_stats.infoMessages),
printInfoMess... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %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, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x18(%rbp), %rax
addq... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::(anonymous namespace)::ConsoleAssertionPrinter::print() const | void print() const {
printSourceInfo();
if (stats.totals.assertions.total() > 0) {
printResultType();
printOriginalExpression();
printReconstructedExpression();
} else {
stream << '\n';
}
printMessage();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x453b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0xb0, %rdi
addq $0x8, %rdi
callq 0x27130
cmpq $0x0, %rax
jbe 0x350d4
movq -0x10(%rbp), %rdi
callq 0x45440
movq -0x10(%rbp), %rdi
callq 0x454d0
mo... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::ConsoleReporter::sectionEnded(Catch::SectionStats const&) | void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
m_tablePrinter->close();
if (_sectionStats.missingAssertions) {
lazyPrint();
Colour colour(Colour::ResultError);
if (m_sectionStack.size() > 1)
stream << "\nNo assertions in section";
else
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x168, %rdi # imm = 0x168
callq 0x5bcc0
movq %rax, %rdi
callq 0x5bce0
movq -0x10(%rbp), %rax
testb $0x1, 0x78(%rax)
je 0x352b6
movq -0x58(%rbp), %rdi
callq 0x34b60
leaq ... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::ConsoleReporter::testGroupEnded(Catch::TestGroupStats const&) | void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
if (currentGroupInfo.used) {
printSummaryDivider();
stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
printTotals(_testGroupStats.totals);
stream << '\n' << std::endl;
}
S... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x88(%rax)
je 0x354af
movq -0x18(%rbp), %rdi
callq 0x354d0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0xa981a(%rip), %rsi # 0xdec73
callq 0x15510
movq %rax, %rdi
m... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::ConsoleReporter::printTotalsDivider(Catch::Totals const&) | void ConsoleReporter::printTotalsDivider(Totals const& totals) {
if (totals.testCases.total() > 0) {
std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
std::... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x27130
cmpq $0x0, %rax
jbe 0x364c9
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x128(%rbp)
movq -0x... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::ConsoleReporter::printTestFilters() | void ConsoleReporter::printTestFilters() {
if (m_config->testSpec().hasFilters()) {
Colour guard(Colour::BrightYellow);
stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x513f0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
callq 0x2ce30
testb $0x1, %al
jne 0x36657
jmp 0x36712
leaq -0x9(%rbp), %rdi
movl $0x16, %esi
callq 0x1d9d0
movq... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::XmlReporter::sectionEnded(Catch::SectionStats const&) | void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
StreamingReporterBase::sectionEnded( sectionStats );
if( --m_sectionDepth > 0 ) {
XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
e.writeAttribute( "successes", sectionStats.assertions.pass... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x100(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5dff0
movq -0x100(%rbp), %rcx
movl 0x1b8(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x1b8(%rcx)
cmpl $0x0, %eax
jle 0x3cc84
movq -0... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
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 %rbx
leaq 0x198dd7(%rip), %rbx # 0x1b3340
movq %rbx, %rdi
callq 0x19c00
movq 0x1979e8(%rip), %rdi # 0x1b1f60
leaq 0x1981b9(%rip), %rdx # 0x1b2738
movq %rbx, %rsi
popq %rbx
jmp 0x19a80
| /jberkenbilt[P]qpdf/libqpdf/QPDFObject.cc |
Table::test() | void
test()
{
for (int i = 0; i < 10; ++i) {
(*this)[i].value = 2 * i;
(*this)[1000 + i].value = 2 * (1000 + i);
}
for (int i: {50, 60, 70, 98, 99, 100, 101, 150, 198, 199, 200, 201}) {
(*this)[i].value = 2 * i;
}
resize(100);
f... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
cmpl $0x14, %r15d
je 0x1afd6
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1b42a
movl %r15d, (%rax)
leal 0x3e8(%r14), %esi
leal 0x7d0(%r15), %ebp
movq %rbx, %rdi
callq 0x1b42a
movl %ebp, (%rax)
incl %r14d
addl $0... | /jberkenbilt[P]qpdf/libtests/obj_table.cc |
read_bits(unsigned char const*&, unsigned long&, unsigned long&, unsigned long) | static unsigned long long
read_bits(unsigned char const*& p, size_t& bit_offset, size_t& bits_available, size_t bits_wanted)
{
// View p as a stream of bits:
// 76543210 76543210 ....
// bit_offset is the bit number within the first byte that marks
// the first bit that we would read.
if (bits_wa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rcx, %r15
movq %rdx, %r14
cmpq %rcx, (%rdx)
jb 0x1bf31
cmpq $0x20, %r15
ja 0x1bfc0
movq (%rdi), %r9
xorl %eax, %eax
pushq $-0x1
popq %r10
pushq $0x7
popq %r11
testq %r15, %r15
je 0x1bf21
movq (%rsi), %rbx
leal 0x1(%rbx), %ecx
movl %r10d, %r8d... | /jberkenbilt[P]qpdf/libqpdf/qpdf/bits_functions.hh |
BitWriter::writeBitsSigned(long long, unsigned long) | void
BitWriter::writeBitsSigned(long long val, size_t bits)
{
unsigned long long uval = 0;
if (val < 0) {
uval = (1ULL << bits) + static_cast<unsigned long long>(val);
} else {
uval = static_cast<unsigned long long>(val);
}
writeBits(uval, bits);
} | pushq $0x1
popq %rax
movl %edx, %ecx
shlq %cl, %rax
movq %rsi, %rcx
sarq $0x3f, %rcx
andq %rax, %rcx
addq %rcx, %rsi
jmp 0x1c540
| /jberkenbilt[P]qpdf/libqpdf/BitWriter.cc |
Buffer::Buffer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | Buffer::Buffer(std::string& content) :
m(new Members(content.size(), reinterpret_cast<unsigned char*>(content.data()), false))
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x38
popq %rdi
callq 0x191a0
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
leaq 0x10(%rax), %rsi
movq %rsi, (%rax)
andq $0x0, 0x8(%rax)
xorl %esi, %esi
movb %sil, 0x10(%rax)
movb %sil, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq %rax, (%r1... | /jberkenbilt[P]qpdf/libqpdf/Buffer.cc |
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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
cmpl $0x2, %edx
je 0x1cca0
cmpl $0x1, %edx
je 0x1cc80
testl %edx, %edx
je 0x1ccbe
pushq $0x10
popq %rdi
callq 0x19400
movq %rax, %rbx
leaq 0xef7b8(%rip), %rsi # 0x10c41a
movq %rax, %rdi
callq 0x199a0
movq 0x195377(%rip), %rsi ... | /jberkenbilt[P]qpdf/libqpdf/BufferInputSource.cc |
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
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x19b70
movq (%r14), %rax
movq -0x18(%rax), %r14
callq 0x19150
leaq (%rsp,%r14), %rsi
addq $0x28, %rsi
movq %rsp, %rdi
movq %rax, %rdx
callq 0x19610
movq %rsp, %rdi
callq 0x19bc0
leaq ... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
NNTreeIterator::NNTreeIterator(NNTreeImpl&) | NNTreeIterator::NNTreeIterator(NNTreeImpl& impl) :
impl(impl),
item_number(-1)
{
} | leaq 0x186a59(%rip), %rax # 0x1ac098
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
leaq 0x10(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
orl $-0x1, 0x38(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
Pl_Function::Pl_Function(char const*, Pipeline*, int (*)(char const*, unsigned long, void*), void*) | Pl_Function::Pl_Function(char const* identifier, Pipeline* next, writer_c_char_t fn, void* udata) :
Pipeline(identifier, next),
m(new Members(nullptr))
{
m->fn = [identifier, fn, udata](unsigned char const* data, size_t len) {
int code = fn(reinterpret_cast<char const*>(data), len, udata);
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x2a238
leaq 0x17e8fc(%rip), %rax # 0x1ac508
movq %rax, (%rbx)
pushq $0x20
popq %rdi
callq 0x191a0
movq %rax, %r13
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %x... | /jberkenbilt[P]qpdf/libqpdf/Pl_Function.cc |
QPDF::copyStreamData(QPDFObjectHandle, QPDFObjectHandle) | void
QPDF::copyStreamData(QPDFObjectHandle result, QPDFObjectHandle foreign)
{
// This method was originally written for copying foreign streams, but it is used by
// QPDFObjectHandle to copy streams from the same QPDF object as well.
QPDFObjectHandle dict = result.getDict();
QPDFObjectHandle old_dict ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x140, %rsp # imm = 0x140
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x88(%rsp), %r12
movq %r12, %rdi
callq 0xc577a
leaq 0xd0(%rsp), %rdi
movq %r15, %rsi
callq 0xc577a
movq (%r14), %rax
cmpq $0x0, 0x2c8(%rax)
jne 0x3327c
pushq $0x78
popq ... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDFAcroFormDocumentHelper::generateAppearancesIfNeeded() | void
QPDFAcroFormDocumentHelper::generateAppearancesIfNeeded()
{
if (!getNeedAppearances()) {
return;
}
for (auto const& page: QPDFPageDocumentHelper(qpdf).getAllPages()) {
for (auto& aoh: getWidgetAnnotationsForPage(page)) {
QPDFFormFieldObjectHelper ffh = getFieldForAnnotation... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %r12
callq 0x45a70
testb %al, %al
je 0x45f2a
movq 0x8(%r12), %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0xa4000
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0xa4016
leaq 0x60(%rsp), %r14
movq %r1... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFJob::processFile(std::unique_ptr<QPDF, std::default_delete<QPDF>>&, char const*, char const*, bool, bool) | void
QPDFJob::processFile(
std::unique_ptr<QPDF>& pdf,
char const* filename,
char const* password,
bool used_for_input,
bool main_input)
{
auto f1 = std::mem_fn<void(char const*, char const*)>(&QPDF::processFile);
auto fn = std::bind(f1, std::placeholders::_1, filename, std::placeholders::_2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebx
movl %r8d, 0xc(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq -0x2c6b9(%rip), %rax # 0x318fe
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
andq $0x0, 0x8(%rsi)
movq %rdx, 0x10(%rsi)
leaq 0x10(%rsp... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::validateUnderOverlay(QPDF&, QPDFJob::UnderOverlay*) | void
QPDFJob::validateUnderOverlay(QPDF& pdf, UnderOverlay* uo)
{
QPDFPageDocumentHelper main_pdh(pdf);
int main_npages = QIntC::to_int(main_pdh.getAllPages().size());
processFile(uo->pdf, uo->filename.c_str(), uo->password.get(), true, false);
QPDFPageDocumentHelper uo_pdh(*(uo->pdf));
int uo_npage... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %rbx
movq %rdi, %r15
leaq 0xc8(%rsp), %r14
movq %r14, %rdi
callq 0xa4000
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xa4016
movq 0x30(%rsp), %rax
subq 0x28(%rsp), %rax
pushq $0x38
popq %r13
cqto
idivq %r13
leaq 0x8(%rsp), %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::EncConfig::endEncrypt() | QPDFJob::Config*
QPDFJob::EncConfig::endEncrypt()
{
if (config->o.m->keylen == 0) {
usage("encryption key length is required");
}
config->o.m->encrypt = true;
config->o.m->decrypt = false;
config->o.m->copy_encryption = false;
return this->config;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
movq (%rax), %rcx
movq (%rcx), %rcx
cmpl $0x0, 0x110(%rcx)
jne 0x85de2
movq %rdi, %rbx
leaq 0x9e7b3(%rip), %rsi # 0x124568
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x1d5b8
movq %r14, %rdi
callq 0x5d02a
leaq 0x8(%rsp), %rdi
callq 0x19e78... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFNameTreeObjectHelper::last() const | QPDFNameTreeObjectHelper::iterator
QPDFNameTreeObjectHelper::last() const
{
return {std::make_shared<NNTreeIterator>(m->impl->last())};
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x28(%rsi), %rax
movq (%rax), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x27e04
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x94a76
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x941ac
leaq 0x10(%rsp), %rdi
callq 0x1d612
leaq 0x18(%rsp), %rdi
callq 0x294d8... | /jberkenbilt[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFObjectHandle::getUTF8Value[abi:cxx11]() const | std::string
QPDFObjectHandle::getUTF8Value() const
{
if (auto str = as<QPDF_String>()) {
return str->getUTF8Val();
} else {
typeWarning("string", "returning empty string");
QTC::TC("qpdf", "QPDFObjectHandle string returning empty utf8");
return "";
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x9edd6
testq %rax, %rax
je 0x99507
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc9272
jmp 0x99550
leaq 0x8e5dc(%rip), %rsi # 0x127aea
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x1d5b8
leaq 0x92... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFOutlineDocumentHelper::QPDFOutlineDocumentHelper(QPDF&) | QPDFOutlineDocumentHelper::QPDFOutlineDocumentHelper(QPDF& qpdf) :
QPDFDocumentHelper(qpdf),
m(new Members())
{
QPDFObjectHandle root = qpdf.getRoot();
if (!root.hasKey("/Outlines")) {
return;
}
QPDFObjectHandle outlines = root.getKey("/Outlines");
if (!(outlines.isDictionary() && ou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
leaq 0x10c12e(%rip), %rax # 0x1adba0
movq %rax, (%rdi)
movl $0x98, %edi
callq 0x191a0
movq %rax, %r15
leaq 0x10(%rbx), %r12
movl $0x98, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFOutlineDocumentHelper.cc |
QPDFPageObjectHelper::placeFormXObject(QPDFObjectHandle, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle::Rectangle, QPDFMatrix&, bool, bool, bool) | std::string
QPDFPageObjectHelper::placeFormXObject(
QPDFObjectHandle fo,
std::string const& name,
QPDFObjectHandle::Rectangle rect,
QPDFMatrix& cm,
bool invert_transformations,
bool allow_shrink,
bool allow_expand)
{
cm = getMatrixForFormXObjectPlacement(
fo, rect, invert_transfo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %r9d, %ebp
movq %r8, %r15
movq %rcx, 0x28(%rsp)
movq %rsi, %r12
movq %rdi, 0x30(%rsp)
movb 0x158(%rsp), %bl
movb 0x150(%rsp), %r14b
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x296ae
movaps 0x130(%rsp), %xmm0
movaps... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
void QPDFParser::addScalar<QPDF_Real, 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&) | void
QPDFParser::addScalar(Args&&... args)
{
if (bad_count && (frame->olist.size() > 5'000 || frame->dict.size() > 5'000)) {
// Stop adding scalars. We are going to abort when the close token or a bad token is
// encountered.
max_bad_count = 0;
return;
}
auto obj = QPDFObject... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x68(%rdi)
je 0xaefac
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq $0x13880, %rcx # imm = 0x13880
ja 0xaefa6
cmpq $0x1389, 0x40(%rax) # imm = 0x1389
jb 0xaefac
andl $0x0, 0x6c(%rbx)
jmp 0xaefed
movq %rsp, %r14... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
qpdf::Tokenizer::getToken(QPDFTokenizer::Token&, bool&, char&) | bool
Tokenizer::getToken(Token& token, bool& unread_char, char& ch)
{
bool ready = (state == st_token_ready);
unread_char = !in_token && !before_token;
ch = char_to_unread;
if (ready) {
token = (!(type == tt::tt_name || type == tt::tt_string))
? Token(type, raw_val, raw_val, error_me... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movl (%rdi), %r13d
movb 0x70(%rdi), %al
xorb $0x1, %al
movzbl %al, %eax
xorl %esi, %esi
cmpb $0x0, 0x71(%rdi)
cmovel %eax, %esi
movb %sil, (%rdx)
movb 0x72(%rdi), %al
movb %al, (%rcx)
cmpl $0x15, %r13d
jne 0xb1358
movq %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
QPDF::EncryptionData::EncryptionData(int, int, int, int, 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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, st... | EncryptionData(
int V,
int R,
int Length_bytes,
int P,
std::string const& O,
std::string const& U,
std::string const& OE,
std::string const& UE,
std::string const& Perms,
std::string const& id1,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movq 0x40(%rsp), %r15
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
movq %r9, %rsi
callq 0x19670
leaq 0x30(%r12), %r14
movq %r14, %rdi
movq %r15, %rsi
cal... | /jberkenbilt[P]qpdf/include/qpdf/QPDF.hh |
QPDF::createFromJSON(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
QPDF::createFromJSON(std::string const& json_file)
{
createFromJSON(std::make_shared<FileInputSource>(json_file.c_str()));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r15
movq (%rsi), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x1d5f3
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %rbx
movaps -0x8(%rbx), %xmm0
movaps %xmm0, -0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rbx)
leaq 0x10(%rsp), %rsi
movq %r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::updateObjectMaps(QPDF::ObjUser const&, QPDFObjectHandle, std::function<int (QPDFObjectHandle&)>) | void
QPDF::updateObjectMaps(
ObjUser const& first_ou,
QPDFObjectHandle first_oh,
std::function<int(QPDFObjectHandle&)> skip_stream_parameters)
{
QPDFObjGen::set visited;
std::vector<UpdateObjectMapsFrame> pending;
pending.emplace_back(first_ou, first_oh, true);
// Traverse the object tree fr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, 0x60(%rsp)
movq %rdi, 0x68(%rsp)
leaq 0xc0(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x40(%rsp), %rdi
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDF_optimization.cc |
QUtil::toUTF8[abi:cxx11](unsigned long) | std::string
QUtil::toUTF8(unsigned long uval)
{
std::string result;
// A UTF-8 encoding of a Unicode value is a single byte for Unicode values <= 127. For larger
// values, the first byte of the UTF-8 encoding has '1' as each of its n highest bits and '0'
// for its (n+1)th highest bit where n is the ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rax
shrq $0x1f, %rax
jne 0xf4756
movq %rsi, %r14
cmpq $0x7f, %rsi
ja 0xf46be
movsbl %r14b, %esi
movq %rbx, %rdi
callq 0x19dd0
jmp 0xf4717
leaq 0xa(%rsp), %r15
... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
getRandomDataProviderProvider() | static RandomDataProviderProvider*
getRandomDataProviderProvider()
{
// Thread-safe static initializer
static RandomDataProviderProvider rdpp;
return &rdpp;
} | pushq %rbx
movb 0xbed46(%rip), %al # 0x1b3608
testb %al, %al
je 0xf48c8
popq %rbx
retq
leaq 0xbed39(%rip), %rdi # 0x1b3608
callq 0x193c0
testl %eax, %eax
je 0xf48c6
callq 0x1dba2
movq %rax, 0xbed14(%rip) # 0x1b35f8
movq %rax, 0xbed15(%rip) # 0x1b3600
leaq 0xbed16(%rip), %rdi # 0x1b3608
popq %rbx
jm... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::read_lines_from_file(std::function<bool (char&)>, std::__cxx11::list<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>>>>&, bool) | void
QUtil::read_lines_from_file(
std::function<bool(char&)> next_char, std::list<std::string>& lines, bool preserve_eol)
{
std::string* buf = nullptr;
char c;
while (next_char(c)) {
if (buf == nullptr) {
lines.emplace_back("");
buf = &(lines.back());
buf->res... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
leaq 0x3(%rsp), %r12
pushq $0xf
popq %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0xf7bde
testb %al, %al
je 0xf5433
movq %rbx, %rbp
testq %rbx, %rbx
jne 0xf539f
movq %r14, %rdi... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
SF_FlateLzwDecode::setDecodeParms(QPDFObjectHandle) | bool
SF_FlateLzwDecode::setDecodeParms(QPDFObjectHandle decode_parms)
{
if (decode_parms.isNull()) {
return true;
}
auto memory_limit = Pl_Flate::memory_limit();
std::set<std::string> keys = decode_parms.getKeys();
for (auto const& key: keys) {
QPDFObjectHandle value = decode_parms... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x9873e
movb $0x1, %bl
testb %al, %al
jne 0xfc59e
callq 0x2cf3e
movq %rax, (%rsp)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc3090
movq 0x18(%rbx), %r13
leaq 0x18(%... | /jberkenbilt[P]qpdf/libqpdf/SF_FlateLzwDecode.cc |
select_wrapper | int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset... | testl %edi, %edi
jns 0x1090
pushq %rax
callq 0x1030
movl $0x16, (%rax)
pushq $-0x1
popq %rax
popq %rcx
retq
| /komeilkma[P]curl/tests/libtest/first.c |
main | int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xbfa(%rip), %rsi # 0x201e
pushq $0x6
popq %rdi
callq 0x1080
cmpl $0x1, %ebp
jg 0x1453
movq 0x2ba8(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xc15(%rip), %rsi # 0x2057
xorl %eax, %eax
callq 0x10b0
pushq $0x1
popq %rax
addq $0x8, %r... | /komeilkma[P]curl/tests/libtest/first.c |
project::get_apple_osx_config[abi:cxx11]() | std::string project::get_apple_osx_config()
{
std::stringstream ss;
project::buildExport b;
get_export("XCODE_MAC", b);
if(!b.valid)
{
return "";
}
std::cout << "Using XCode Config" << std::endl;
if(!b.debug.headerPath.empty())
{
ss << " target_include_di... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movq %rsi, %rbp
movq %rdi, 0x8(%rsp)
leaq 0x2b0(%rsp), %rdi
callq 0x41e0
leaq 0x68(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0xb8(%rsp), %rcx
xorps %xmm0, %xm... | /jwinarske[P]jucer2cmake/project.cpp |
project::gen_cmake() | void project::gen_cmake()
{
std::ofstream outfile (get_cmake_file(), std::ofstream::binary);
outfile << get_header();
outfile << get_dependencies();
outfile << get_cpp_standard();
outfile << get_defines();
outfile << get_include_dirs();
outfile << get_autogen_vars();
outfile << get_reso... | pushq %r14
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe4c8
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x46b0
leaq 0x18(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0xe63a
callq 0x42a0
leaq 0x8(%rsp), %rdi
m... | /jwinarske[P]jucer2cmake/project.cpp |
module::listFilesRecursively(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void module::listFilesRecursively(std::string basePath, std::string filename)
{
DIR *dir = opendir(basePath.c_str());
if (!dir)
{
return;
}
std::string path;
struct dirent *dp;
while ((dp = readdir(dir)) != NULL)
{
if (strcmp(dp->d_name, ".") != 0 && strcmp(dp->d_name, "... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x44b0
testq %rax, %rax
je 0x110c4
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %r14, 0x40(%rsp)
leaq 0x... | /jwinarske[P]jucer2cmake/module.cpp |
module::module(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | module::module(std::string basePath, std::string module)
{
base_path = basePath;
sepd = (base_path.find("\\") != std::string::npos) ? "\\" : "/";
#if defined(DEBUG)
std::cout << "looking for module: " << module << std::endl;
#endif
listFilesRecursively(basePath, module + ".h");
if(!module_header.e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq... | /jwinarske[P]jucer2cmake/module.cpp |
module::getVersion[abi:cxx11]() | std::string module::getVersion()
{
return metaData [ META_VERSION ];
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x14d1e(%rip), %rsi # 0x266b4
leaq 0x14d1e(%rip), %rdx # 0x266bb
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6cac
addq $0x60, %r14
movq %r14, %rdi
movq %r15, %rsi
callq... | /jwinarske[P]jucer2cmake/module.cpp |
module::getDependencies[abi:cxx11]() | std::string module::getDependencies()
{
return metaData [ META_DEPENDENCIES ];
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15e33(%rip), %rsi # 0x27ab7
leaq 0x15e38(%rip), %rdx # 0x27ac3
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6cac
addq $0x60, %r14
movq %r14, %rdi
movq %r15, %rsi
callq... | /jwinarske[P]jucer2cmake/module.cpp |
module::getOSXFrameworks[abi:cxx11]() | std::string module::getOSXFrameworks()
{
return metaData [ META_OSX_FRAMEWORKS ];
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15daa(%rip), %rsi # 0x27ac4
leaq 0x15db0(%rip), %rdx # 0x27ad1
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6cac
addq $0x60, %r14
movq %r14, %rdi
movq %r15, %rsi
callq... | /jwinarske[P]jucer2cmake/module.cpp |
module::getiOSFrameworks[abi:cxx11]() | std::string module::getiOSFrameworks()
{
return metaData [ META_IOS_FRAMEWORKS ];
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15d22(%rip), %rsi # 0x27ad2
leaq 0x15d28(%rip), %rdx # 0x27adf
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6cac
addq $0x60, %r14
movq %r14, %rdi
movq %r15, %rsi
callq... | /jwinarske[P]jucer2cmake/module.cpp |
module::getLinuxLibs[abi:cxx11]() | std::string module::getLinuxLibs()
{
return metaData [ META_LINUX_LIBS ];
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15c9a(%rip), %rsi # 0x27ae0
leaq 0x15c9c(%rip), %rdx # 0x27ae9
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6cac
addq $0x60, %r14
movq %r14, %rdi
movq %r15, %rsi
callq... | /jwinarske[P]jucer2cmake/module.cpp |
module::getMingwLibs[abi:cxx11]() | std::string module::getMingwLibs()
{
return metaData [ META_MINGW_LIBS ];
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15b86(%rip), %rsi # 0x27af8
leaq 0x15b88(%rip), %rdx # 0x27b01
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6cac
addq $0x60, %r14
movq %r14, %rdi
movq %r15, %rsi
callq... | /jwinarske[P]jucer2cmake/module.cpp |
utilities::ltrim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string ltrim(const std::string& s)
{
size_t start = s.find_first_not_of(WHITESPACE);
return (start == std::string::npos) ? "" : s.substr(start);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x21427(%rip), %rsi # 0x344a8
movq 0x21428(%rip), %rcx # 0x344b0
movq %r14, %rdi
xorl %edx, %edx
callq 0x45d0
cmpq $-0x1, %rax
je 0x130af
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x4310
jmp 0x130c8
leaq 0x10(%rbx... | /jwinarske[P]jucer2cmake/utilities.cpp |
utilities::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string trim(const std::string& s)
{
return rtrim(ltrim(s));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x13070
movq %rbx, %rdi
movq %r14, %rsi
callq 0x130d3
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1316e
callq 0x42a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18... | /jwinarske[P]jucer2cmake/utilities.cpp |
utilities::replace(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool replace(std::string& str, const std::string& from, const std::string& to)
{
size_t start_pos = str.find(from);
if(start_pos == std::string::npos)
{
return false;
}
str.replace(start_pos, from.length(), to);
return true;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r15), %rcx
xorl %edx, %edx
callq 0x4620
movq %rax, %r12
cmpq $-0x1, %rax
je 0x132cf
movq 0x8(%r15), %rdx
movq (%r14), %rcx
movq 0x8(%r14), %r8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4340
c... | /jwinarske[P]jucer2cmake/utilities.cpp |
utilities::normalizePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | std::string normalizePath(std::string &path)
{
std::string sep = (path.find("\\") != std::string::npos) ? "\\" : "/";
std::stack<std::string> st;
std::string dir;
std::string res = sep;
size_t len_path = path.length();
for (size_t i = 0; i < len_path; i++)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x130c3(%rip), %r15 # 0x2650d
movl $0x1, %ecx
movq %rsi, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4620
cmpq $-0x1, %rax
leaq 0x12e4d(%rip), %rsi # 0x262b4
cmovneq... | /jwinarske[P]jucer2cmake/utilities.cpp |
bool pugi::impl::(anonymous namespace)::strcpy_insitu<char*, unsigned long>(char*&, unsigned long&, unsigned long, char const*, unsigned long) | PUGI__FN bool strcpy_insitu(String& dest, Header& header, uintptr_t header_mask, const char_t* source, size_t source_length)
{
if (source_length == 0)
{
// empty string and null pointer are equivalent, so just deallocate old memory
xml_allocator* alloc = PUGI__GETPAGE_IMPL(header)->allocator;
if (header ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %r8, %r8
je 0x146ba
movq %r8, %r12
movq %r15, (%rsp)
movq (%r15), %r15
testq %r15, %r15
setne %al
movq (%rbx), %r13
testb $0x40, %r13b
sete %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x1460... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
bool pugi::impl::(anonymous namespace)::set_value_integer<unsigned int, char*, unsigned long>(char*&, unsigned long&, unsigned long, unsigned int, bool) | PUGI__FN bool set_value_integer(String& dest, Header& header, uintptr_t header_mask, U value, bool negative)
{
char_t buf[64];
char_t* end = buf + sizeof(buf) / sizeof(buf[0]);
char_t* begin = integer_to_string(buf, end, value, negative);
return strcpy_insitu(dest, header, header_mask, begin, end - begin);
} | subq $0x48, %rsp
movl %edx, %r8d
negl %r8d
testl %ecx, %ecx
cmovel %edx, %r8d
xorl %eax, %eax
movl $0xcccccccd, %edx # imm = 0xCCCCCCCD
movl %r8d, %r9d
imulq %rdx, %r9
shrq $0x23, %r9
leal (%r9,%r9), %r10d
leal (%r10,%r10,4), %r10d
movl %r8d, %r11d
subl %r10d, %r11d
orb $0x30, %r11b
movb %r11b, 0x3f(%rsp,%rax)
de... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xml_node::previous_sibling(char const*) const | PUGI__FN xml_node xml_node::previous_sibling(const char_t* name_) const
{
if (!_root) return xml_node();
for (xml_node_struct* i = _root->prev_sibling_c; i->next_sibling; i = i->prev_sibling_c)
if (i->name && impl::strequal(name_, i->name)) return xml_node(i);
return xml_node();
} | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x14c44
movq 0x28(%rax), %rbx
cmpq $0x0, 0x30(%rbx)
je 0x14c44
movq %rsi, %r14
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x14c39
movq %r14, %rdi
callq 0x4420
testl %eax, %eax
je 0x14c46
movq 0x28(%rbx), %rbx
cmpq $0x0, 0x30(%rbx)
jne 0x14c24
xorl %eb... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xml_node::prepend_copy(pugi::xml_attribute const&) | PUGI__FN bool xml_attribute::operator!() const
{
return !_attr;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, (%rsi)
je 0x154a2
movq %rdi, %r15
movq (%rdi), %rax
testq %rax, %rax
je 0x154a2
movq %rsi, %rbx
movl (%rax), %ecx
andl $0xf, %ecx
cmpl $0x7, %ecx
je 0x15406
cmpl $0x2, %ecx
jne 0x154a2
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rdi
movq 0x... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xml_node::append_child(pugi::xml_node_type) | PUGI__FN xml_node_type xml_node::type() const
{
return _root ? PUGI__NODETYPE(_root) : node_null;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x157f2
movl %esi, %ebx
xorl %r14d, %r14d
cmpl $0x2, %esi
jb 0x157f5
movq (%rax), %rcx
movl %ecx, %edx
andl $0xf, %edx
leal -0x3(%rdx), %esi
cmpl $-0x2, %esi
jb 0x157f5
cmpl $0x1, %edx
setne %dl
leal -0x9(%rbx), %esi
cmpl $-0x2, %es... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xml_node::prepend_child(pugi::xml_node_type) | PUGI__FN xml_node_type xml_node::type() const
{
return _root ? PUGI__NODETYPE(_root) : node_null;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x1591a
movl %esi, %ebx
xorl %r14d, %r14d
cmpl $0x2, %esi
jb 0x1591d
movq (%rax), %rcx
movl %ecx, %edx
andl $0xf, %edx
leal -0x3(%rdx), %esi
cmpl $-0x2, %esi
jb 0x1591d
cmpl $0x1, %edx
setne %dl
leal -0x9(%rbx), %esi
cmpl $-0x2, %es... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xml_node::insert_child_before(pugi::xml_node_type, pugi::xml_node const&) | PUGI__FN xml_node_type xml_node::type() const
{
return _root ? PUGI__NODETYPE(_root) : node_null;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x1597b
movl %esi, %ebx
xorl %r14d, %r14d
cmpl $0x2, %esi
jb 0x1597e
movq %rdx, %r15
movq (%rax), %rcx
movl %ecx, %edx
andl $0xf, %edx
leal -0x3(%rdx), %esi
cmpl $-0x2, %esi
jb 0x1597e
cmpl $0x1, %edx
setne %dl
leal -0x9(%rbx), %esi... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xml_node::append_move(pugi::xml_node const&) | PUGI__FN xml_node xml_node::append_move(const xml_node& moved)
{
if (!impl::allow_move(*this, moved)) return xml_node();
impl::xml_allocator& alloc = impl::get_allocator(_root);
if (!alloc.reserve()) return xml_node();
// disable document_buffer_order optimization since moving nodes around changes document o... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
movq (%rsi), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x16284
testb %al, %al
je 0x16266
movq (%r12), %rax
shrq $0x8, %rax
negq %rax
movq (%r12,%rax), %rax
orq $0x40, -0x40(%rax)
movq 0x18(%r15), %rcx
movq 0x28(%r1... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xml_node::prepend_move(pugi::xml_node const&) | PUGI__FN xml_node xml_node::prepend_move(const xml_node& moved)
{
if (!impl::allow_move(*this, moved)) return xml_node();
impl::xml_allocator& alloc = impl::get_allocator(_root);
if (!alloc.reserve()) return xml_node();
// disable document_buffer_order optimization since moving nodes around changes document ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
movq (%rsi), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x16284
testb %al, %al
je 0x163a0
movq (%r12), %rax
shrq $0x8, %rax
negq %rax
movq (%r12,%rax), %rax
orq $0x40, -0x40(%rax)
movq 0x18(%r15), %rcx
movq 0x28(%r1... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xml_node::remove_child(pugi::xml_node const&) | PUGI__FN bool xml_node::remove_child(const xml_node& n)
{
if (!_root || !n._root || n._root->parent != _root) return false;
impl::xml_allocator& alloc = impl::get_allocator(_root);
if (!alloc.reserve()) return false;
impl::remove_node(n._root);
impl::destroy_node(n._root, alloc);
return true;
} | movq (%rdi), %rax
testq %rax, %rax
je 0x166e7
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x166e7
movq 0x18(%rcx), %rdx
cmpq %rax, %rdx
je 0x166ea
xorl %eax, %eax
retq
movq (%rax), %rdi
shrq $0x8, %rdi
negq %rdi
movq (%rax,%rdi), %rax
movq 0x28(%rcx), %r9
movq 0x30(%rcx), %r8
leaq 0x28(%rcx), %rdi
movq %r8, %r10
testq %r8, %... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::impl::(anonymous namespace)::destroy_node(pugi::xml_node_struct*, pugi::impl::(anonymous namespace)::xml_allocator&) | inline void destroy_node(xml_node_struct* n, xml_allocator& alloc)
{
if (n->header & impl::xml_memory_page_name_allocated_mask)
alloc.deallocate_string(n->name);
if (n->header & impl::xml_memory_page_value_allocated_mask)
alloc.deallocate_string(n->value);
for (xml_attribute_struct* attr = n->first_attri... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testb $0x20, %al
je 0x16791
movq 0x8(%r14), %rax
leaq -0x4(%rax), %rdx
movzwl -0x4(%rax), %ecx
shll $0x3, %ecx
subq %rcx, %rdx
addq $-0x28, %rdx
movzwl -0x2(%rax), %esi
testq %rsi, %rsi
je 0x16782
shll $0x3, %esi
jm... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xml_node::append_buffer(void const*, unsigned long, unsigned int, pugi::xml_encoding) | PUGI__FN xml_parse_result xml_node::append_buffer(const void* contents, size_t size, unsigned int options, xml_encoding encoding)
{
// append_buffer is only valid for elements/documents
if (!impl::allow_insert_child(type(), node_element)) return impl::make_parse_result(status_append_invalid_root);
// get docume... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %r15
testq %r15, %r15
je 0x168d8
movq %rcx, %r12
movq (%r15), %rax
movl %eax, %ecx
andl $0xf, %ecx
addl $-0x3, %ecx
cmpl $-0x3, %ecx
ja 0x168ef
movl $0x0, 0x10(%rbx)
movl $0xf, (%rbx)
movq $0x0, 0x8(%rbx)
jmp... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xml_node::find_child_by_attribute(char const*, char const*, char const*) const | PUGI__FN xml_node xml_node::find_child_by_attribute(const char_t* name_, const char_t* attr_name, const char_t* attr_value) const
{
if (!_root) return xml_node();
for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
if (i->name && impl::strequal(name_, i->name))
{
for (xml_attribute_str... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x1817f
movq 0x20(%rax), %rbx
testq %rbx, %rbx
je 0x1817f
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0xf634(%rip), %r13 # 0x27758
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x18139
movq %r12, ... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xml_node::path[abi:cxx11](char) const | PUGI__FN string_t xml_node::path(char_t delimiter) const
{
if (!_root) return string_t();
size_t offset = 0;
for (xml_node_struct* i = _root; i; i = i->parent)
{
offset += (i != _root);
offset += i->name ? impl::strlength(i->name) : 0;
}
string_t result;
result.resize(offset);
for (xml_node_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %r12
testq %r12, %r12
je 0x182d8
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
xorl %r15d, %r15d
movq %r12, %r13
xorl %ebp, %ebp
cmpq %r12, %r13
setne %r14b
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0x18253
callq... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xml_node::traverse(pugi::xml_tree_walker&) | PUGI__FN bool xml_node::traverse(xml_tree_walker& walker)
{
walker._depth = -1;
xml_node arg_begin(_root);
if (!walker.begin(arg_begin)) return false;
xml_node_struct* cur = _root ? _root->first_child + 0 : 0;
if (cur)
{
++walker._depth;
do
{
xml_node arg_for_each(cur);
if (!walker.for... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffffff, 0x8(%rsi) # imm = 0xFFFFFFFF
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x18525
movq (%r14), %rax
testq %rax, %rax
je 0x185... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xml_node::print(pugi::xml_writer&, char const*, unsigned int, pugi::xml_encoding, unsigned int) const | PUGI__FN void xml_node::print(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const
{
if (!_root) return;
impl::xml_buffered_writer buffered_writer(writer, encoding);
impl::node_output(buffered_writer, _root, indent, flags, depth);
buffered_writer.flu... | movq %rsi, %rax
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x185cb
pushq %rbx
subq $0x2820, %rsp # imm = 0x2820
movq %rax, 0x2808(%rsp)
movq $0x0, 0x2810(%rsp)
cmpl $0x8, %r8d
ja 0x1859a
movl $0x191, %eax # imm = 0x191
btl %r8d, %eax
jae 0x1859a
movl %r8d, %eax
leaq 0xfe4e(%rip), %rdi # 0x283e4
mov... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::impl::(anonymous namespace)::open_file_wide(wchar_t const*, wchar_t const*) | PUGI__FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode)
{
// there is no standard function to open wide paths, so our best bet is to try utf8 path
char* path_utf8 = convert_path_heap(path);
if (!path_utf8) return 0;
// convert mode to ASCII (we mirror _wfopen interface)
char mode_ascii[4] = ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $-0x4, %rax
cmpl $0x0, 0x4(%r14,%rax)
leaq 0x4(%rax), %rax
jne 0x1a2d8
movq %rax, %r15
sarq $0x2, %r15
testq %rax, %rax
je 0x1a332
xorl %eax, %eax
movl $0x1, %ecx
xorl %r13d, %r13d
movl (%r14,%rax,4), %edx
cmpl ... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::xpath_query::evaluate_number(pugi::xpath_node const&) const | PUGI__FN double xpath_query::evaluate_number(const xpath_node& n) const
{
if (!_impl) return impl::gen_nan();
impl::xpath_context c(n, 1, 1);
impl::xpath_stack_data sd;
double r = static_cast<impl::xpath_query_impl*>(_impl)->root->eval_number(c, sd.stack);
if (sd.oom)
{
#ifdef PUGIXML_NO_EXCEPTIONS
... | pushq %rbx
subq $0x20a0, %rsp # imm = 0x20A0
movq (%rdi), %rax
testq %rax, %rax
je 0x1ce6c
movups (%rsi), %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x1, %ecx
movq %rcx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
leaq 0x2058(%rsp), %rcx
leaq 0x2098(%rsp), %rdx
leaq 0x38(%rsp), %rdi
movq %rdi, -0x40(%rdx)
xo... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
unsigned int pugi::impl::(anonymous namespace)::string_to_integer<unsigned int>(char const*, unsigned int, unsigned int) | PUGI__FN PUGI__UNSIGNED_OVERFLOW U string_to_integer(const char_t* value, U minv, U maxv)
{
U result = 0;
const char_t* s = value;
while (PUGI__IS_CHARTYPE(*s, ct_space))
s++;
bool negative = (*s == '-');
s += (*s == '+' || *s == '-');
bool overflow = false;
if (s[0] == '0' && (s[1] | ' ') == 'x'... | xorl %ecx, %ecx
leaq 0x9568(%rip), %r8 # 0x281a0
movzbl (%rdi,%rcx), %eax
incq %rcx
testb $0x8, (%rax,%r8)
jne 0x1ec38
leal -0x2b(%rax), %r9d
xorl %r8d, %r8d
testb $-0x3, %r9b
sete %r8b
leaq (%rdi,%r8), %r9
cmpb $0x30, -0x1(%rcx,%r9)
jne 0x1ecbf
movb (%rcx,%r9), %r10b
andb $-0x21, %r10b
cmpb $0x58, %r10b
jne 0x1e... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
unsigned long long pugi::impl::(anonymous namespace)::string_to_integer<unsigned long long>(char const*, unsigned long long, unsigned long long) | PUGI__FN PUGI__UNSIGNED_OVERFLOW U string_to_integer(const char_t* value, U minv, U maxv)
{
U result = 0;
const char_t* s = value;
while (PUGI__IS_CHARTYPE(*s, ct_space))
s++;
bool negative = (*s == '-');
s += (*s == '+' || *s == '-');
bool overflow = false;
if (s[0] == '0' && (s[1] | ' ') == 'x'... | xorl %ecx, %ecx
leaq 0x942d(%rip), %r8 # 0x281a0
movzbl (%rdi,%rcx), %eax
incq %rcx
testb $0x8, (%rax,%r8)
jne 0x1ed73
leal -0x2b(%rax), %r9d
xorl %r8d, %r8d
testb $-0x3, %r9b
sete %r8b
leaq (%rdi,%r8), %r9
cmpb $0x30, -0x1(%rcx,%r9)
jne 0x1ee04
movb (%rcx,%r9), %r10b
andb $-0x21, %r10b
cmpb $0x58, %r10b
jne 0x1e... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::impl::(anonymous namespace)::node_copy_contents(pugi::xml_node_struct*, pugi::xml_node_struct*, pugi::impl::(anonymous namespace)::xml_allocator*) | PUGI__FN void node_copy_contents(xml_node_struct* dn, xml_node_struct* sn, xml_allocator* shared_alloc)
{
node_copy_string(dn->name, dn->header, xml_memory_page_name_allocated_mask, sn->name, sn->header, shared_alloc);
node_copy_string(dn->value, dn->header, xml_memory_page_value_allocated_mask, sn->value, sn->hea... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
addq $0x8, %rdi
movq 0x8(%rsi), %rcx
movl $0x20, %edx
movq %r14, %rsi
movq %r15, %r8
movq %rbx, %r9
callq 0x1eebd
leaq 0x10(%r14), %rdi
movq 0x10(%r15), %rcx
movl $0x10, %edx
movq %r14, %rsi
movq %r15, %r8
movq %rbx, ... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
bool pugi::impl::(anonymous namespace)::xpath_ast_node::compare_rel<pugi::impl::(anonymous namespace)::less_equal>(pugi::impl::(anonymous namespace)::xpath_ast_node*, pugi::impl::(anonymous namespace)::xpath_ast_node*, pugi::impl::(anonymous namespace)::xpath_context const&, pugi::impl::(anonymous namespace)::xpath_sta... | static bool compare_rel(xpath_ast_node* lhs, xpath_ast_node* rhs, const xpath_context& c, const xpath_stack& stack, const Comp& comp)
{
xpath_value_type lt = lhs->rettype(), rt = rhs->rettype();
if (lt != xpath_type_node_set && rt != xpath_type_node_set)
return comp(lhs->eval_number(c, stack), rhs->eval_nu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
movb 0x1(%rdi), %cl
movb 0x1(%r15), %al
cmpb $0x1, %cl
sete %dl
cmpb $0x1, %al
sete %dil
orb %dl, %dil
jne 0x23630
movq %rsi, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1c... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::impl::(anonymous namespace)::xpath_node_set_raw pugi::impl::(anonymous namespace)::xpath_ast_node::step_do<pugi::impl::(anonymous namespace)::axis_to_type<(pugi::impl::(anonymous namespace)::axis_t)3>>(pugi::impl::(anonymous namespace)::xpath_context const&, pugi::impl::(anonymous namespace)::xpath_stack const&, ... | xpath_node_set_raw step_do(const xpath_context& c, const xpath_stack& stack, nodeset_eval_t eval, T v)
{
const axis_t axis = T::axis;
const bool axis_reverse = (axis == axis_ancestor || axis == axis_ancestor_or_self || axis == axis_preceding || axis == axis_preceding_sibling);
const xpath_node_set::type_t ax... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x24a0a
cmpq $0x0, 0x18(%rax)
je 0x24a12
xorl %ebp, %ebp
jmp 0x24a1a
testl %ebx, %ebx
setne %bpl
jmp 0x24a1a
cmpb $0x3, 0x3(%rax)
s... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
pugi::impl::(anonymous namespace)::xpath_ast_node::step_push(pugi::impl::(anonymous namespace)::xpath_node_set_raw&, pugi::xml_node_struct*, pugi::impl::(anonymous namespace)::xpath_allocator*) | bool step_push(xpath_node_set_raw& ns, xml_node_struct* n, xpath_allocator* alloc)
{
assert(n);
xml_node_type type = PUGI__NODETYPE(n);
switch (_test)
{
case nodetest_name:
if (type == node_element && n->name && strequal(n->name, _data.nodetest))
{
ns.push_back(xml_node(n), alloc);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movzbl %dil, %ecx
decl %ecx
cmpl $0x7, %ecx
ja 0x25615
movq %r8, %rbx
movq %rdx, %r14
movl (%r15), %eax
andl $0xf, %eax
leaq 0x2b4a(%rip), %rdx # 0x280f8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpl $0x2, %eax
je 0x25603
jmp 0x25615
ad... | /jwinarske[P]jucer2cmake/build_O3/pugixml-prefix/src/pugixml/src/pugixml.cpp |
set_trace_config | static CURLcode set_trace_config(struct GlobalConfig *global,
const char *config)
{
CURLcode result = CURLE_OK;
char *token, *tmp, *name;
bool toggle;
tmp = strdup(config);
if(!tmp)
return CURLE_OUT_OF_MEMORY;
/* Allow strtok() here since this is not used threaded */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, %rdi
callq 0xa820
testq %rax, %rax
je 0x124a7
leaq 0x10b18(%rip), %rsi # 0x22f09
movq %rax, (%rsp)
movq %rax, %rdi
callq 0xa720
testq %rax, %rax
je 0x124af
movq %rax, %r13
leaq 0x25c18(%rip), %r15 # 0x38028
l... | /Unity-Technologies[P]curl/src/tool_getparam.c |
EXRLayers | int EXRLayers(const char *filename, const char **layer_names[], int *num_layers,
const char **err) {
EXRVersion exr_version;
EXRHeader exr_header;
InitEXRHeader(&exr_header);
{
int ret = ParseEXRVersionFromFile(&exr_version, filename);
if (ret != TINYEXR_SUCCESS) {
tinyexr::SetError... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x38(%rsp), %rdi
movl $0x188, %edx # imm = 0x188
xorl %esi, %esi
callq 0x3140
leaq 0x24(%rsp), %rdi
movq %r12, %rsi
callq 0x39a8
testl %eax, %... | /syoyo[P]tinyexr/tinyexr.h |
tinyexr::ConvertHeader(TEXRHeader*, tinyexr::HeaderInfo const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | static bool ConvertHeader(EXRHeader *exr_header, const HeaderInfo &info, std::string *warn, std::string *err) {
exr_header->pixel_aspect_ratio = info.pixel_aspect_ratio;
exr_header->screen_window_center[0] = info.screen_window_center[0];
exr_header->screen_window_center[1] = info.screen_window_center[1];
exr_he... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movss 0x60(%rsi), %xmm0
movss %xmm0, (%rdi)
movss 0x54(%rsi), %xmm0
movss %xmm0, 0x28(%rdi)
movss 0x58(%rsi), %xmm0
movss %xmm0, 0x2c(%rdi)
movss 0... | /syoyo[P]tinyexr/tinyexr.h |
tinyexr::HeaderInfo::clear() | void clear() {
channels.clear();
attributes.clear();
data_window.min_x = 0;
data_window.min_y = 0;
data_window.max_x = 0;
data_window.max_y = 0;
line_order = 0;
display_window.min_x = 0;
display_window.min_y = 0;
display_window.max_x = 0;
display_window.max_y = 0;
screen... | pushq %rbx
movq %rdi, %rbx
callq 0x1321a
movq 0x18(%rbx), %rax
cmpq %rax, 0x20(%rbx)
je 0x125d9
movq %rax, 0x20(%rbx)
xorl %eax, %eax
movq %rax, 0x90(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movl $0x0, 0x80(%rbx... | /syoyo[P]tinyexr/tinyexr.h |
tdefl_compress | tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush)
{
if (!d)
{
if (pIn_buf_size)
*pIn_buf_size = 0;
if (pOut_buf_size)
*pOut_buf_size = 0;
return TDEFL_STATUS_BAD_PA... | testq %rdi, %rdi
je 0x165c0
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x88(%rdi)
movq %rdx, 0x98(%rdi)
movq %rcx, 0x90(%rdi)
movq %r8, 0xa0(%rdi)
movq %rsi, 0xb0(%rdi)
testq %rdx, %rdx
je 0x165de
movq (%rdx), %rax
jmp 0x165e0
testq %rdx, %rdx
je 0x... | /syoyo[P]tinyexr/deps/miniz/miniz.c |
mz_zip_reader_init_mem | mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags)
{
if (!pMem)
return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
if (size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
if (!mz_zip_reade... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1ac4a
movq %rdx, %r14
cmpq $0x15, %rdx
ja 0x1ac5a
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x1acc3
movl $0x8, 0x1c(%rbx)
jmp 0x1acc3
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x1acc3
movl $0x18, 0x1c(%rbx)
jmp 0x1acc3
movl %ecx, %ebp
movq... | /syoyo[P]tinyexr/deps/miniz/miniz.c |
mz_zip_reader_extract_to_file | mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags)
{
mz_bool status;
mz_zip_archive_file_stat file_stat;
MZ_FILE *pFile;
if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
return MZ_FALSE;
if ((file_stat.m_is_d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x468, %rsp # imm = 0x468
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r14
leaq 0x10(%rsp), %rdx
callq 0x1bad0
xorl %ebx, %ebx
testl %eax, %eax
je 0x1c7b2
cmpl $0x0, 0x54(%rsp)
jne 0x1c77d
cmpl $0x0, 0x5c(%rsp)
je 0x1c77d... | /syoyo[P]tinyexr/deps/miniz/miniz.c |
mz_zip_validate_file | mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
{
mz_zip_archive_file_stat file_stat;
mz_zip_internal_state *pState;
const mz_uint8 *pCentral_dir_header;
mz_bool found_zip64_ext_data_in_cdir = MZ_FALSE;
mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE;
mz_uin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x528, %rsp # imm = 0x528
xorl %ebx, %ebx
movl %ebx, 0x64(%rsp)
movl %ebx, 0x60(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movl $0x1, 0x88(%rsp)
testq %rdi, %rdi
je 0x1c93f
movq %rdi, %r14
movq 0x68(%rdi),... | /syoyo[P]tinyexr/deps/miniz/miniz.c |
mz_zip_validate_archive | mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags)
{
mz_zip_internal_state *pState;
mz_uint32 i;
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead))
return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
pState = pZip->m_pState;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x468, %rsp # imm = 0x468
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x1d330
movq %rdi, %r14
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x1d328
cmpq $0x0, 0x28(%r14)
je 0x1d328
cmpq $0x0, 0x30(%r14)
je 0x1d328
cmpq $0x0, 0x48(%r14)
je 0x1d328
mo... | /syoyo[P]tinyexr/deps/miniz/miniz.c |
mz_zip_writer_end_internal | static mz_bool mz_zip_writer_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)
{
mz_zip_internal_state *pState;
mz_bool status = MZ_TRUE;
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && (pZip->m_zip_mode != MZ_ZIP_MODE_WRIT... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x1d91a
movl %esi, %r15d
movq %rdi, %rbx
movq 0x68(%rdi), %r14
testq %r14, %r14
je 0x1d90e
cmpq $0x0, 0x28(%rbx)
je 0x1d90e
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x1d90e
movl 0x14(%rbx), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
... | /syoyo[P]tinyexr/deps/miniz/miniz.c |
mz_zip_writer_add_from_zip_reader | mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index)
{
mz_uint n, bit_flags, num_alignment_padding_bytes, src_central_dir_following_data_size;
mz_uint64 src_archive_bytes_remaining, local_dir_header_ofs;
mz_uint64 cur_src_file_ofs, cur_dst_file... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x538, %rsp # imm = 0x538
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x1fce8
movq %rdi, %rbx
movq 0x68(%rdi), %r15
testq %r15, %r15
je 0x1fce1
cmpl $0x2, 0x14(%rbx)
jne 0x1fce1
movq %rsi, %rbp
cmpq $0x0, 0x48(%rsi)
je 0x1fce1
movq 0x68(%rbp),... | /syoyo[P]tinyexr/deps/miniz/miniz.c |
mz_zip_extract_archive_file_to_heap_v2 | void *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr)
{
mz_uint32 file_index;
mz_zip_archive zip_archive;
void *p = NULL;
if (pSize)
*pSize = 0;
if ((!pZip_filename) || (!pA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rsi
testq %rcx, %rcx
je 0x20f09
movq $0x0, (%r14)
testq %rsi, %rsi
setne %al
testq %r12, %r12
setne %cl
testb %cl, %al
je 0x20f85
xorps %xmm0, %xmm0
leaq 0x1... | /syoyo[P]tinyexr/deps/miniz/miniz.c |
mz_zip_clear_last_error | mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num)
{
mz_zip_error prev_err;
if (!pZip)
return MZ_ZIP_INVALID_PARAMETER;
prev_err = pZip->m_last_error;
pZip->m_last_error = err_num;
return prev_err;
} | testq %rdi, %rdi
je 0x21034
movl 0x1c(%rdi), %eax
movl $0x0, 0x1c(%rdi)
retq
movl $0x18, %eax
retq
| /syoyo[P]tinyexr/deps/miniz/miniz.c |
mz_zip_get_error_string | const char *mz_zip_get_error_string(mz_zip_error mz_err)
{
switch (mz_err)
{
case MZ_ZIP_NO_ERROR:
return "no error";
case MZ_ZIP_UNDEFINED_ERROR:
return "undefined error";
case MZ_ZIP_TOO_MANY_FILES:
return "too many files";
case MZ_ZIP_FILE_T... | cmpl $0x20, %edi
ja 0x21066
movl %edi, %eax
leaq 0x43a2(%rip), %rcx # 0x25400
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x4bce(%rip), %rax # 0x25c3b
retq
| /syoyo[P]tinyexr/deps/miniz/miniz.c |
bsp_init | void bsp_init( void (*spmd_part)(void), int argc, char *argv[])
{
int pid = -1;
int mpi_init = 0;
MPI_Initialized(&mpi_init);
if (!mpi_init) {
MPI_Init(&argc, &argv);
atexit( bsp_check_exit );
}
if (s_spmd)
bsp_abort( "bsp_init: May be called only once\n" );
if (!sp... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movq %rdx, 0x8(%rsp)
orl $-0x1, (%rsp)
leaq 0x14(%rsp), %r14
andl $0x0, (%r14)
movq %r14, %rdi
callq 0x8160
cmpl $0x0, (%r14)
jne 0x8943
leaq 0x4(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8410
leaq 0xb9(%rip), %rdi # 0x89f7
callq 0x11660
... | /wijnand-suijlen[P]bsponmpi/src/bsp.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.