name string | code string | asm string | file string |
|---|---|---|---|
Parser_mathWithNamespacesDefinedOnTheNodeThatUsesNamespace_Test::~Parser_mathWithNamespacesDefinedOnTheNodeThatUsesNamespace_Test() | TEST(Parser, mathWithNamespacesDefinedOnTheNodeThatUsesNamespace)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"model_name\">\n"
" <component name=\"\">\n"
" <math xmlns=\"http://www.w3.org/1998/Ma... | pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
| /cellml[P]libcellml/tests/parser/parser.cpp |
Parser_repeatedMathParsePrintBehaviour_Test::~Parser_repeatedMathParsePrintBehaviour_Test() | TEST(Parser, repeatedMathParsePrintBehaviour)
{
const std::string in =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\">\n"
" <component name=\"component\">\n"
" <variable name=\"A\" initial_value=\"1.0\"/>\n"
" <variab... | pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
| /cellml[P]libcellml/tests/parser/parser.cpp |
Parser_parseAndPrintCombinedImportsInString_Test::~Parser_parseAndPrintCombinedImportsInString_Test() | TEST(Parser, parseAndPrintCombinedImportsInString)
{
const std::string combinedInString =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\" name=\"everything\">\n"
" <import xmlns:xlink=\"http://www.w3.org/1999/xlink\" xlink:href=\"some-other... | pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
| /cellml[P]libcellml/tests/parser/parser.cpp |
Parser_incorrectNumberOfImportSources_Test::~Parser_incorrectNumberOfImportSources_Test() | TEST(Parser, incorrectNumberOfImportSources)
{
const std::string modelString =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\">\n"
" <import xmlns:xlink=\"http://www.w3.org/1999/xlink\" xlink:href=\"import.cellml\">\n"
" <compone... | pushq %rbx
movq %rdi, %rbx
callq 0xf710
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf390
nop
| /cellml[P]libcellml/tests/parser/parser.cpp |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [5], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [5], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x1b0c7
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1af19
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %... | /cellml[P]libcellml/tests/gtest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<std::shared_ptr<libcellml::ImportSource>, std::shared_ptr<libcellml::ImportSource>>(char const*, char const*, std::shared_ptr<libcellml::ImportSource> const&, std::shared_ptr<libcellml::ImportSource> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x39ad3
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x39ad3
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xor... | /cellml[P]libcellml/tests/gtest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQ<char [9], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [9], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs,... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0xf0d0
movq %rbx, %rdi
testl %eax, %eax
je 0x39d91
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x39da3
jmp 0x39d96
callq 0xf... | /cellml[P]libcellml/tests/gtest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQ<char [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs,... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0xf0d0
movq %rbx, %rdi
testl %eax, %eax
je 0x39fe7
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x39ff9
jmp 0x39fec
callq 0xf... | /cellml[P]libcellml/tests/gtest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQ<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs,... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0xf0d0
movq %rbx, %rdi
testl %eax, %eax
je 0x3a28e
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x3a2a0
jmp 0x3a293
callq 0xf... | /cellml[P]libcellml/tests/gtest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<std::shared_ptr<libcellml::Reset>, std::shared_ptr<libcellml::Reset>>(char const*, char const*, std::shared_ptr<libcellml::Reset> const&, std::shared_ptr<libcellml::Reset> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x3a476
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x3a476
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xor... | /cellml[P]libcellml/tests/gtest/include/gtest/gtest.h |
Validate::PrintSuccessMessage() | void Validate::PrintSuccessMessage() {
/* Only print message regarding warnings if relevant. Some validation checks do
* not produce any warning messages. */
fprintf(stderr, "INFO: All %s file validation checks have passed.",
fileDescription_);
if (warnings_) {
fprintf(stderr, " Please take note of any war... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2cce(%rip), %r14 # 0x3fd8
movq (%r14), %rdi
leaq 0x1004(%rbx), %rdx
leaq 0xce9(%rip), %rsi # 0x2004
xorl %eax, %eax
callq 0x1110
cmpb $0x1, 0x2004(%rbx)
je 0x133d
movq (%r14), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10e0
movq... | /OasisLMF[P]ktools/src/include/validate.cpp |
ValidateDamageBin::ReadDamageBinDictFile(bool) | void ValidateDamageBin::ReadDamageBinDictFile(const bool convertToBin) {
/* After reading in a line from the csv file and checking for data integrity,
* this method calls other methods to check for contiguous bin indices and
* whether the interpolation value lies within the defined range. */
while (fgets(line_, si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x2965(%rip), %rbp # 0x3fd0
movq 0x2966(%rip), %r12 # 0x3fd8
leaq 0xc34(%rip), %r15 # 0x22ad
leaq 0xb7a(%rip), %r13 # 0x21fa
movq (%rbp), %rdx
movq %r14, %rdi
movl $0x1000, %esi ... | /OasisLMF[P]ktools/src/validatedamagebin/validatedamagebin.cpp |
dtc::fdt::checking::property_size_checker::check(dtc::fdt::device_tree*, std::shared_ptr<dtc::fdt::node> const&, std::shared_ptr<dtc::fdt::property>) | bool
property_size_checker::check(device_tree *, const node_ptr &, property_ptr p)
{
uint32_t psize = 0;
for (property::value_iterator i=p->begin(),e=p->end() ; i!=e ; ++i)
{
if (!i->is_binary())
{
return false;
}
psize += i->byte_data.size();
}
return psize == size;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rcx), %rax
movq 0x58(%rax), %r14
movq 0x60(%rax), %r15
xorl %ebp, %ebp
cmpq %r15, %r14
je 0x2792c
movq %r14, %rdi
callq 0x28264
testb %al, %al
je 0x27934
movl 0x48(%r14), %eax
subl 0x40(%r14), %eax
addl %eax, %ebp
addq $0x60, %r14
jmp 0x2790b... | /davidchisnall[P]dtc/checking.cc |
dtc::fdt::checking::check_manager::add_property_size_checker(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int) | void
check_manager::add_property_size_checker(const char *name,
const string &prop,
uint32_t size)
{
checkers.insert(std::make_pair(string(name),
new property_size_checker(name, prop, size)));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2826c
pushq $0x50
popq %rdi
callq 0x272a0
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x282a... | /davidchisnall[P]dtc/checking.cc |
dtc::fdt::checking::check_manager::check_manager() | check_manager::check_manager()
{
// NOTE: All checks listed here MUST have a corresponding line
// in the man page!
add_property_type_checker<property_value::STRING_LIST>(
"type-compatible", string("compatible"));
add_property_type_checker<property_value::STRING>(
"type-model", string("model"));
add_property... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
pushq $0x1
popq %rax
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, %ecx # imm = 0x3F800000
movl %ecx, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
... | /davidchisnall[P]dtc/checking.cc |
dtc::fdt::device_tree::parse_file(dtc::text_input_buffer&, std::vector<std::shared_ptr<dtc::fdt::node>, std::allocator<std::shared_ptr<dtc::fdt::node>>>&, bool&) | void
device_tree::parse_file(text_input_buffer &input,
std::vector<node_ptr> &roots,
bool &read_header)
{
input.next_token();
// Read the header
while (input.consume("/dts-v1/;"))
{
read_header = true;
input.next_token();
}
if (input.consume("/plugin/;"))
{
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %rbx
movq %rdx, 0xb0(%rsp)
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0xf59e(%rip), %r15 # 0x3f573
movq %r14, %rdi
callq 0x3a670
movq %r14, %rdi
movq %r15, %rsi
callq 0x328c4
testb %al, %al
je 0x2fff1
movb $0x1, (%rbx)
jmp... | /davidchisnall[P]dtc/fdt.cc |
dtc::fdt::device_tree::write_dts(int) | void
device_tree::write_dts(int fd)
{
FILE *file = fdopen(fd, "w");
fputs("/dts-v1/;\n\n", file);
if (!reservations.empty())
{
const char msg[] = "/memreserve/";
// Exclude the null byte when we're writing it out to the file.
fwrite(msg, sizeof(msg) - 1, 1, file);
for (auto &i : reservations)
{
fprint... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %eax
movq %rdi, %r14
leaq 0xe103(%rip), %rsi # 0x3e6c4
movl %eax, %edi
callq 0x272e0
movq %rax, %rbx
leaq 0xf08d(%rip), %rdi # 0x3f65f
movq %rax, %rsi
callq 0x27300
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x3064f
movabsq ... | /davidchisnall[P]dtc/fdt.cc |
dtc::fdt::device_tree::create_fragment_wrapper(std::shared_ptr<dtc::fdt::node>&, int&) | node_ptr
device_tree::create_fragment_wrapper(node_ptr &node, int &fragnum)
{
// In a plugin, we can massage these non-/ root nodes into into a fragment
std::string fragment_address = "fragment@" + std::to_string(fragnum);
++fragnum;
std::vector<property_ptr> symbols;
// Intentionally left empty
node_ptr newroo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movl (%rcx), %esi
leaq 0x78(%rsp), %r12
movq %r12, %rdi
callq 0x327de
leaq 0xecde(%rip), %rsi # 0x3f73b
leaq 0xf8(%rsp), %rdi
movq %r12, %rdx
callq 0x327ba
leaq 0x78(%rsp), %rdi
ca... | /davidchisnall[P]dtc/fdt.cc |
dtc::fdt::device_tree::reassign_fragment_numbers(std::shared_ptr<dtc::fdt::node>&, int&) | void
device_tree::reassign_fragment_numbers(node_ptr &node, int &delta)
{
for (auto &c : node->child_nodes())
{
if (c->name == std::string("fragment"))
{
int current_address = std::stoi(c->unit_address, nullptr, 16);
std::ostringstream new_address;
current_address += delta;
// It's possible that we h... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %rbx
movq (%rsi), %rax
movq 0xa0(%rax), %rbp
movq 0xa8(%rax), %r15
leaq 0x20(%rsp), %r12
movq %rsp, %r13
cmpq %r15, %rbp
je 0x30f0a
movq (%rbp), %r14
movq %r12, %rdi
leaq 0xe900(%rip), %rsi # 0x3... | /davidchisnall[P]dtc/fdt.cc |
dtc::fdt::device_tree::parse_define(char const*) | bool device_tree::parse_define(const char *def)
{
const char *val = strchr(def, '=');
if (!val)
{
if (strlen(def) != 0)
{
string name(def);
defines[name];
return true;
}
return false;
}
string name(def, val-def);
string name_copy = name;
val++;
std::unique_ptr<input_buffer> raw(new input_buffer... | pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x3d
popq %rsi
movq %r15, %rdi
callq 0x27100
testq %rax, %rax
je 0x3209d
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x287b6
lea... | /davidchisnall[P]dtc/fdt.cc |
void dtc::fdt::device_tree::write<dtc::dtb::asm_writer>(int) | void
device_tree::write(int fd)
{
dtb::string_table st;
dtb::header head;
writer head_writer;
writer reservation_writer;
writer struct_writer;
writer strings_writer;
// Build the reservation table
reservation_writer.write_comment(string("Memory reservations"));
reservation_writer.write_label(string("dt_reserv... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl %esi, 0xc(%rsp)
movq %rdi, %r14
movl $0xd00dfeed, 0xa8(%rsp) # imm = 0xD00DFEED
movabsq $0x1000000011, %rax # imm = 0x1000000011
movq %rax, 0xbc(%rsp)
leaq 0x100(%rsp), %rax
andl $0x0, (%rax)
andq $0x0,... | /davidchisnall[P]dtc/fdt.cc |
dtc::text_input_buffer::text_input_buffer(std::unique_ptr<dtc::input_buffer, std::default_delete<dtc::input_buffer>>&&, std::unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal... | text_input_buffer(std::unique_ptr<input_buffer> &&b,
std::unordered_set<std::string> &&d,
std::vector<std::string> &&i,
const std::string directory,
FILE *deps)
: defines(d), include_paths(i), dir(directory), depfile(deps)
{
input_stack.pu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbp
movq %r8, %r15
movq %rcx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x33a80
andl $0x0, 0x38(%rbx)
leaq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x348a4
leaq 0x90(%rbx), %rdi
movq %rdi, (%rsp)
movq %r13, %rsi... | /davidchisnall[P]dtc/input_buffer.hh |
dtc::text_input_buffer::skip_spaces() | void
text_input_buffer::skip_spaces()
{
if (finished()) { return; }
char c = *(*this);
bool last_nl = false;
while ((c == ' ') || (c == '\t') || (c == '\n') || (c == '\f')
|| (c == '\v') || (c == '\r'))
{
last_nl = ((c == '\n') || (c == '\r'));
++(*this);
if (finished())
{
c = '\0';
}
else
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0xa
popq %rbp
leaq 0x64f0(%rip), %r14 # 0x4078c
movq %rbx, %rdi
callq 0x32d2e
testb %al, %al
jne 0x3a331
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x32660
movzbl %al, %ecx
leal -0x9(%rcx), %edx
cmpl $0x5, %edx
jae 0x3a2ea
cmpb $0xd, %al
se... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::text_input_buffer::next_token() | text_input_buffer&
text_input_buffer::next_token()
{
auto &self = *this;
int start;
do {
start = cursor;
skip_spaces();
if (finished())
{
return self;
}
// Parse /* comments
if (*self == '/' && peek() == '*')
{
// eat the start of the comment
++self;
++self;
do {
// Find the ending... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x38(%rdi), %ebp
movq %rbx, %rdi
callq 0x3a288
movq %rbx, %rdi
callq 0x32d2e
testb %al, %al
jne 0x3a766
movq %rbx, %rdi
callq 0x32660
cmpb $0x2f, %al
jne 0x3a711
movq %rbx, %rdi
callq 0x3c120
cmpb $0x2a, %al
jne 0x3a711
movq %rbx, %rdi
callq 0x3268c
movq %rbx, %rdi
... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::text_input_buffer::parse_error(char const*) | void
text_input_buffer::parse_error(const char *msg)
{
if (input_stack.empty())
{
fprintf(stderr, "Error: %s\n", msg);
return;
}
input_buffer &b = *input_stack.top();
parse_error(msg, b, b.cursor);
} | movq %rsi, %rax
movq 0x70(%rdi), %rcx
cmpq 0x50(%rdi), %rcx
je 0x3a84c
cmpq 0x78(%rdi), %rcx
jne 0x3a83d
movq 0x88(%rdi), %rdx
movl $0x200, %ecx # imm = 0x200
addq -0x8(%rdx), %rcx
movq -0x10(%rcx), %rdx
movl 0x14(%rdx), %ecx
movq %rax, %rsi
jmp 0x3c146
movq 0x15765(%rip), %rcx # 0x4ffb8
movq (%rcx), %rd... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::input_buffer::buffer_for_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::unique_ptr<input_buffer>
input_buffer::buffer_for_file(const string &path, bool warn)
{
if (path == "-")
{
std::unique_ptr<input_buffer> b(new stream_input_buffer());
return b;
}
int source = open(path.c_str(), O_RDONLY);
if (source == -1)
{
if (warn)
{
fprintf(stderr, "Unable to open file '%s'. ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3ce1(%rip), %rsi # 0x3e61c
movq %r15, %rdi
callq 0x28777
testb %al, %al
je 0x3a99c
pushq $0x30
popq %rdi
callq 0x272a0
movq %rax, %r14
xorps %xmm0, %x... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::input_buffer::buffer_from_offset(int, int) | input_buffer
input_buffer::buffer_from_offset(int offset, int s)
{
if (offset < 0)
{
return input_buffer();
}
if (s == 0)
{
s = size - offset;
}
if (offset > size)
{
return input_buffer();
}
if (s > (size-offset))
{
return input_buffer();
}
return input_buffer(&buffer[offset], s);
} | movq %rdi, %rax
testl %edx, %edx
js 0x3ae09
movl 0x10(%rsi), %r8d
movl %r8d, %edi
subl %edx, %edi
testl %ecx, %ecx
cmovnel %ecx, %edi
subl %edx, %r8d
jl 0x3ae09
cmpl %r8d, %edi
jle 0x3ae1b
leaq 0x14448(%rip), %rcx # 0x4f258
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
retq
movl %edx, %ecx
addq 0x8(%... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::input_buffer::consume_char_literal(unsigned long long&) | inline char operator[](int offset)
{
if (cursor + offset >= size) { return '\0'; }
if (cursor + offset < 0) { return '\0'; }
return buffer[cursor + offset];
} | movl 0x10(%rdi), %edx
movl 0x14(%rdi), %ecx
cmpl %edx, %ecx
setge %al
testl %ecx, %ecx
sets %r8b
orb %al, %r8b
je 0x3aec4
xorl %eax, %eax
jmp 0x3aecb
movq 0x8(%rdi), %rax
movb (%rax,%rcx), %al
movzbl %al, %r9d
movq %r9, (%rsi)
leal 0x1(%rcx), %r8d
movl %r8d, 0x14(%rdi)
movb $0x1, %al
cmpb $0x5c, %r9b
jne 0x3aef8
cmpl %... | /davidchisnall[P]dtc/input_buffer.hh |
dtc::text_input_buffer::consume_integer_expression(unsigned long long&) | bool
text_input_buffer::consume_integer_expression(unsigned long long &outInt)
{
switch (*(*this))
{
case '(':
{
expression_ptr e(parse_expression(true));
if (!e)
{
return false;
}
auto r = (*e)();
if (r.second)
{
outInt = r.first;
return true;
}
return false;
}
case '0'... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x32660
movzbl %al, %eax
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jae 0x3b014
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3290c
cmpl $0x28, %eax
jne 0x3b04f
movq %rsp, %r15
pushq ... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::input_buffer::consume_hex_byte(unsigned char&) | bool
input_buffer::consume_hex_byte(uint8_t &outByte)
{
if (!ishexdigit((*this)[0]) && !ishexdigit((*this)[1]))
{
return false;
}
outByte = (digittoint((*this)[0]) << 4) | digittoint((*this)[1]);
cursor += 2;
return true;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x14(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
js 0x3c045
cmpl 0x10(%rbx), %ecx
jge 0x3c045
movq 0x8(%rbx), %rax
movb (%rax,%rcx), %al
movsbl %al, %edi
callq 0x3d43b
testb %al, %al
jne 0x3c068
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3d41c
m... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::text_input_buffer::parse_error(char const*, dtc::input_buffer&, int) | void
text_input_buffer::parse_error(const char *msg,
input_buffer &b,
int loc)
{
int line_count = 1;
int line_start = 0;
int line_end = loc;
if (loc < 0 || loc > b.size)
{
return;
}
for (int i=loc ; i>0 ; --i)
{
if (b.buffer[i] == '\n')
{
li... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %ecx, %ecx
js 0x3c161
movl %ecx, %ebx
movq %rdx, %r14
movl 0x10(%rdx), %eax
cmpl %ecx, %eax
jge 0x3c170
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
movq 0x8(%r14), %rcx
movl %ebx, %edx... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::text_input_buffer::parse_node_or_property_name[abi:cxx11](bool&) | string
text_input_buffer::parse_node_or_property_name(bool &is_property)
{
if (is_property)
{
return parse_property_name();
}
std::vector<char> bytes;
for (char c=*(*this) ; is_node_name_character::check(c) ; c=*(++(*this)))
{
bytes.push_back(c);
}
for (char c=*(*this) ; is_property_name_character::check(c)... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rdx)
jne 0x3c3a2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a770
jmp 0x3c458
movq %rdx, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %r14, %rdi
callq 0x32660
leaq 0x10(%rsp),... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::(anonymous namespace)::is_property_name_character::check(char) | static inline bool check(const char c)
{
switch(c)
{
default:
return false;
case 'a'...'z': case 'A'...'Z': case '0'...'9':
case ',': case '.': case '+': case '-':
case '_': case '#':
return true;
}
} | xorl %eax, %eax
addl $-0x23, %edi
cmpl $0x57, %edi
ja 0x3c4c0
leaq 0x3b33(%rip), %rcx # 0x3ffe8
movslq (%rcx,%rdi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movb $0x1, %al
retq
nop
| /davidchisnall[P]dtc/input_buffer.cc |
dtc::(anonymous namespace)::binary_operator<6, std::plus<unsigned long long>>::operator()() | result operator()() override
{
Op op;
result l = (*lhs)();
result r = (*rhs)();
if (!(l.second && r.second))
{
return {0, false};
}
return {op(l.first, r.first), true};
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movl %edx, %ebp
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
addq %r14, %rax
andb %bpl, %dl
xorl %ecx, %ecx
andb $0x1, %dl
cmoveq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
| /davidchisnall[P]dtc/input_buffer.cc |
dtc::(anonymous namespace)::divmod<std::modulus<unsigned long long>>::operator()() | result operator()() override
{
result r = (*binary_operator_base::rhs)();
if (r.second && (r.first == 0))
{
expression::loc.report_error("Division by zero");
return {0, false};
}
return binary_operator<5, T>::operator()();
} | pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
testq %rax, %rax
sete %al
andb %dl, %al
cmpb $0x1, %al
jne 0x3c9a2
addq $0x8, %rbx
leaq 0x3f34(%rip), %rsi # 0x408c8
movq %rbx, %rdi
callq 0x328f0
xorl %eax, %eax
xorl %edx, %edx
jmp 0x3c9aa
movq %rbx, %rdi
callq 0x3c9f0
popq %rbx
ret... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::(anonymous namespace)::binary_operator<5, std::divides<unsigned long long>>::operator()() | result operator()() override
{
Op op;
result l = (*lhs)();
result r = (*rhs)();
if (!(l.second && r.second))
{
return {0, false};
}
return {op(l.first, r.first), true};
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rbx
movl %edx, %ebp
movq 0x30(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %bpl
je 0x3cb64
testb $0x1, %dl
je 0x3cb64
movq %rax, %rcx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
movb $0x1, %dl
jmp... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::(anonymous namespace)::binary_operator<7, dtc::(anonymous namespace)::lshift<unsigned long long>>::operator()() | result operator()() override
{
Op op;
result l = (*lhs)();
result r = (*rhs)();
if (!(l.second && r.second))
{
return {0, false};
}
return {op(l.first, r.first), true};
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movl %edx, %ebp
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ecx
shlq %cl, %r14
andb %bpl, %dl
xorl %eax, %eax
andb $0x1, %dl
cmovneq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
| /davidchisnall[P]dtc/input_buffer.cc |
dtc::(anonymous namespace)::binary_operator<8, std::greater<unsigned long long>>::operator()() | result operator()() override
{
Op op;
result l = (*lhs)();
result r = (*rhs)();
if (!(l.second && r.second))
{
return {0, false};
}
return {op(l.first, r.first), true};
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rbx
movl %edx, %ebp
movq 0x30(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %bpl
je 0x3cd2a
testb $0x1, %dl
je 0x3cd2a
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rbx
seta %al
movb $0x1, %dl
jmp ... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::(anonymous namespace)::binary_operator<7, dtc::(anonymous namespace)::rshift<unsigned long long>>::operator()() | result operator()() override
{
Op op;
result l = (*lhs)();
result r = (*rhs)();
if (!(l.second && r.second))
{
return {0, false};
}
return {op(l.first, r.first), true};
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movl %edx, %ebp
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ecx
shrq %cl, %r14
andb %bpl, %dl
xorl %eax, %eax
andb $0x1, %dl
cmovneq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
| /davidchisnall[P]dtc/input_buffer.cc |
dtc::(anonymous namespace)::binary_operator<9, std::equal_to<unsigned long long>>::operator()() | result operator()() override
{
Op op;
result l = (*lhs)();
result r = (*rhs)();
if (!(l.second && r.second))
{
return {0, false};
}
return {op(l.first, r.first), true};
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rbx
movl %edx, %ebp
movq 0x30(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %bpl
je 0x3ceae
testb $0x1, %dl
je 0x3ceae
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rbx
sete %al
movb $0x1, %dl
jmp ... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::(anonymous namespace)::binary_operator<13, std::logical_and<unsigned long long>>::operator()() | result operator()() override
{
Op op;
result l = (*lhs)();
result r = (*rhs)();
if (!(l.second && r.second))
{
return {0, false};
}
return {op(l.first, r.first), true};
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rbx
movl %edx, %ebp
movq 0x30(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %bpl
je 0x3cfc0
testb $0x1, %dl
je 0x3cfc0
testq %rbx, %rbx
setne %cl
testq %rax, %rax
setne %al
andb %cl, %al
movzbl %... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::(anonymous namespace)::binary_operator<10, std::bit_and<unsigned long long>>::operator()() | result operator()() override
{
Op op;
result l = (*lhs)();
result r = (*rhs)();
if (!(l.second && r.second))
{
return {0, false};
}
return {op(l.first, r.first), true};
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movl %edx, %ebp
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
andq %r14, %rax
andb %bpl, %dl
xorl %ecx, %ecx
andb $0x1, %dl
cmoveq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
| /davidchisnall[P]dtc/input_buffer.cc |
dtc::(anonymous namespace)::binary_operator<14, std::bit_or<unsigned long long>>::operator()() | result operator()() override
{
Op op;
result l = (*lhs)();
result r = (*rhs)();
if (!(l.second && r.second))
{
return {0, false};
}
return {op(l.first, r.first), true};
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movl %edx, %ebp
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
orq %r14, %rax
andb %bpl, %dl
xorl %ecx, %ecx
andb $0x1, %dl
cmoveq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
| /davidchisnall[P]dtc/input_buffer.cc |
dtc::(anonymous namespace)::ternary_conditional_operator::operator()() | result operator()() override
{
result c = (*cond)();
result l = (*lhs)();
result r = (*rhs)();
if (!(l.second && r.second && c.second))
{
return {0, false};
}
return c.first ? l : r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r12
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movl %edx, %ebp
movq 0x30(%r12), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rbx
movl %edx, %r15d
movq 0x38(%r12), %rdi
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %r15b
je 0... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::(anonymous namespace)::ternary_conditional_operator::dump_impl() | void dump_impl() override
{
cond->dump();
std::cerr << " ? ";
lhs->dump();
std::cerr << " : ";
rhs->dump();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x12d7a(%rip), %r14 # 0x4fff0
leaq 0x365c(%rip), %rsi # 0x408d9
movq %r14, %rdi
callq 0x27280
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x3647(%rip), %rsi # 0x408dd
movq %r1... | /davidchisnall[P]dtc/input_buffer.cc |
dtc::push_string(std::vector<unsigned char, std::allocator<unsigned char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | void
push_string(byte_buffer &buffer, const string &s, bool escapes)
{
size_t length = s.size();
for (size_t i=0 ; i<length ; ++i)
{
uint8_t c = s[i];
if (escapes && c == '\\' && i+1 < length)
{
c = s[++i];
switch (c)
{
// For now, we just ignore invalid escape sequences.
default:
case '"'... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rsi, %rbp
movq %rdi, 0x20(%rsp)
movq 0x8(%rsi), %r13
xorl %r12d, %r12d
movq %rsi, 0x10(%rsp)
movl %edx, 0x1c(%rsp)
cmpq %r13, %r12
jae 0x3d812
movq (%rbp), %r15
movb (%r15,%r12), %al
movb %al, 0xf(%rsp)
testb %r14b... | /davidchisnall[P]dtc/string.cc |
(anonymous namespace)::digittoint(int) | inline int digittoint(int c)
{
switch (c)
{
default:
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
case 'a': return 10;
ca... | leal -0x31(%rdi), %eax
cmpl $0x8, %eax
ja 0x3d83d
leaq 0x3118(%rip), %rcx # 0x40948
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x1
jmp 0x3d88b
addl $-0x61, %edi
cmpl $0x5, %edi
ja 0x3d88d
leaq 0x3120(%rip), %rax # 0x4096c
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
pushq $0xa
jmp 0... | /davidchisnall[P]dtc/util.hh |
dtc::dirname(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string dirname(const string &s)
{
return dirbasename(::dirname, s);
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
andq $0x0, 0x8(%rax)
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x126d6(%rip), %rcx # 0x4ff80
movq %rcx, (%rax)
leaq 0x15a(%rip), %rcx # 0x3da0e
movq %rcx, 0x18(%rax)
leaq 0x157(%rip), %rcx # 0x3da16
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0x3d8ef
movq %rsp, %rd... | /davidchisnall[P]dtc/string.cc |
dtc::(anonymous namespace)::dirbasename(std::function<char* (char*)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string
dirbasename(std::function<char*(char*)> fn, const string &s)
{
if (s == string())
{
return string();
}
std::unique_ptr<char, decltype(free)*> str = {strdup(s.c_str()), free};
string dn(fn(str.get()));
return dn;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %r12
movq %rdx, %rdi
movq %r12, %rsi
callq 0x2823a
movl %eax, %ebp
movq %r12, %rdi
callq 0x27568
testb %... | /davidchisnall[P]dtc/string.cc |
dtc::__xpg_basename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string basename(const string &s)
{
return dirbasename(::basename, s);
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
andq $0x0, 0x8(%rax)
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x12621(%rip), %rcx # 0x4ffd0
movq %rcx, (%rax)
leaq 0x55(%rip), %rcx # 0x3da0e
movq %rcx, 0x18(%rax)
leaq 0x52(%rip), %rcx # 0x3da16
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0x3d8ef
movq %rsp, %rd... | /davidchisnall[P]dtc/string.cc |
mkvmuxer::CuePoint::PayloadSize() const | uint64_t CuePoint::PayloadSize() const {
uint64_t size = EbmlElementSize(libwebm::kMkvCueClusterPosition,
static_cast<uint64>(cluster_pos_));
size += EbmlElementSize(libwebm::kMkvCueTrack, static_cast<uint64>(track_));
if (output_block_number_ && block_number_ > 1)
size += Eb... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movl $0xf1, %edi
callq 0x2215b
movq %rax, %r15
movq 0x8(%rbx), %rsi
movl $0xf7, %edi
callq 0x2215b
movq %rax, %r14
addq %r15, %r14
cmpb $0x1, 0x20(%rbx)
jne 0x1a9b2
movq 0x18(%rbx), %rsi
cmpq $0x2, %rsi
jb 0x1a9b2
movl $0x5378, %edi # imm ... | /webmproject[P]libwebm/mkvmuxer/mkvmuxer.cc |
mkvmuxer::Cues::Size() | uint64_t Cues::Size() {
uint64_t size = 0;
for (int32_t i = 0; i < cue_entries_size_; ++i)
size += GetCueByIndex(i)->Size();
size += EbmlMasterElementSize(libwebm::kMkvCues, size);
return size;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x4(%rdi)
jle 0x1ab59
movq %rdi, %r14
xorl %r12d, %r12d
xorl %ebx, %ebx
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0x1a968
movq %rax, %r15
movl $0xbb, %edi
movq %rax, %rsi
callq 0x2200e
addq %r15, %rbx
addq %rax, %rbx
incq %r12
movslq 0x4(%r14),... | /webmproject[P]libwebm/mkvmuxer/mkvmuxer.cc |
mkvmuxer::AudioTrack::AudioTrack(unsigned int*) | AudioTrack::AudioTrack(unsigned int* seed)
: Track(seed), bit_depth_(0), channels_(1), sample_rate_(0.0) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x22d38(%rip), %rax # 0x3f9b8
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
xorl %r14d, %r14d
movq %r14, 0x38(%rdi)
movq %rsi, %rdi
callq 0x233c8
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xm... | /webmproject[P]libwebm/mkvmuxer/mkvmuxer.cc |
mkvmuxer::Chapters::Write(mkvmuxer::IMkvWriter*) const | bool Chapters::Write(IMkvWriter* writer) const {
if (writer == NULL)
return false;
const uint64_t payload_size = WriteEdition(NULL); // return size only
if (!WriteEbmlMasterElement(writer, libwebm::kMkvChapters, payload_size))
return false;
const int64_t start = writer->Position();
if (WriteEditi... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1d92d
movq %rsi, %rbx
movq %rdi, %r12
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x1d940
movq %rax, %r14
movl $0x1043a770, %esi # imm = 0x1043A770
movq %rbx, %rdi
movq %rax, %rdx
callq 0x22791
testb %al, %al
je 0x1d930
movq (%rbx), %rax
mov... | /webmproject[P]libwebm/mkvmuxer/mkvmuxer.cc |
mkvmuxer::Chapters::WriteEdition(mkvmuxer::IMkvWriter*) const | uint64_t Chapters::WriteEdition(IMkvWriter* writer) const {
uint64_t payload_size = 0;
for (int idx = 0; idx < chapters_count_; ++idx) {
const Chapter& chapter = chapters_[idx];
payload_size += chapter.WriteAtom(NULL);
}
const uint64_t edition_size =
EbmlMasterElementSize(libwebm::kMkvEditionEnt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x4(%rdi)
jle 0x1d983
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r14), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x1d478
addq %rax, %r13
incq %r12
movslq 0x4(%r14), %rax
addq $0x... | /webmproject[P]libwebm/mkvmuxer/mkvmuxer.cc |
(anonymous namespace)::JSONParser::handle_u_code(unsigned long, long long, unsigned long&, long long&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void
JSONParser::handle_u_code(
unsigned long codepoint,
qpdf_offset_t offset,
unsigned long& high_surrogate,
qpdf_offset_t& high_offset,
std::string& result)
{
if ((codepoint & 0xFC00) == 0xD800) {
// high surrogate
qpdf_offset_t new_high_offset = offset;
if (high_offset... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
andq $0xfc00, %rax # imm = 0xFC00
cmpq $0xd800, %rax # imm = 0xD800
jne 0x2d5f8
movq -0x10(%rbp... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
NNTreeImpl::insertFirst(QPDFObjectHandle, QPDFObjectHandle) | NNTreeImpl::iterator
NNTreeImpl::insertFirst(QPDFObjectHandle key, QPDFObjectHandle value)
{
auto iter = begin();
QPDFObjectHandle items;
if (iter.node.isDictionary()) {
items = iter.node.getKey(details.itemsKey());
}
if (!(items.isArray())) {
QTC::TC("qpdf", "NNTree no valid items n... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rcx, -0xe0(%rbp)
movq %rdx, -0xd8(%rbp)
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
movb ... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::compareKeyItem(QPDFObjectHandle&, QPDFObjectHandle&, int) | int
NNTreeImpl::compareKeyItem(QPDFObjectHandle& key, QPDFObjectHandle& items, int idx)
{
if (!((items.isArray() && (items.getArrayNItems() > (2 * idx)) &&
details.keyValid(items.getArrayItem(2 * idx))))) {
QTC::TC("qpdf", "NNTree item is wrong type");
error(
qpdf,
... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c0100
movb %al, %cl
movb $0x0, -0x31(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %a... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
get_description[abi:cxx11](QPDFObjectHandle&) | static std::string
get_description(QPDFObjectHandle& node)
{
std::string result("Name/Number tree node");
if (node.isIndirect()) {
result += " (object " + std::to_string(node.getObjectID()) + ")";
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1be40
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0x2cc658(%rip), %rsi # 0x30ef95
... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
OffsetInputSource::OffsetInputSource(std::shared_ptr<InputSource>, long long) | OffsetInputSource::OffsetInputSource(
std::shared_ptr<InputSource> proxied, qpdf_offset_t global_offset) :
proxied(proxied),
global_offset(global_offset)
{
if (global_offset < 0) {
throw std::logic_error("OffsetInputSource constructed with negative offset");
}
this->max_safe_offset = std... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x20c30
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdi
leaq 0x4454dc(%rip), %rax # 0x48af10
addq $0x10, %rax
movq %rax, (%rdi)
addq ... | /jberkenbilt[P]qpdf/libqpdf/OffsetInputSource.cc |
Pl_AES_PDF::Pl_AES_PDF(char const*, Pipeline*, bool, unsigned char const*, unsigned long) | Pl_AES_PDF::Pl_AES_PDF(
char const* identifier,
Pipeline* next,
bool encrypt,
unsigned char const* key,
size_t key_bytes) :
Pipeline(identifier, next),
crypto(QPDFCryptoProvider::getImpl()),
encrypt(encrypt),
key_bytes(key_bytes)
{
if (!next) {
throw std::logic_error("Att... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x463f0
movq -0x... | /jberkenbilt[P]qpdf/libqpdf/Pl_AES_PDF.cc |
Pl_AES_PDF::write(unsigned char const*, unsigned long) | void
Pl_AES_PDF::write(unsigned char const* data, size_t len)
{
size_t bytes_left = len;
unsigned char const* p = data;
while (bytes_left > 0) {
if (this->offset == this->buf_size) {
flush(false);
}
size_t available = this->buf_size - this->offset;
size_t bytes ... | 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, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x471ae
movq -0x40(%rbp), %rax
cmpq $0x10, 0... | /jberkenbilt[P]qpdf/libqpdf/Pl_AES_PDF.cc |
Pl_AES_PDF::finish() | void
Pl_AES_PDF::finish()
{
if (this->encrypt) {
if (this->offset == this->buf_size) {
flush(false);
}
if (!this->disable_padding) {
// Pad as described in section 3.5.1 of version 1.7 of the PDF specification, including
// providing an entire block of pad... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x40(%rax)
je 0x474d5
movq -0x30(%rbp), %rax
cmpq $0x10, 0x48(%rax)
jne 0x47470
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x471c0
movq -0x30(%rbp), %rax
testb $0x1, 0xa2(%rax)
jne 0x474d0
movq -... | /jberkenbilt[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 0x1be00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x47e23
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
jpeg_pipeline_dest(jpeg_compress_struct*, unsigned char*, unsigned long, Pipeline*) | static void
jpeg_pipeline_dest(j_compress_ptr cinfo, unsigned char* outbuffer, size_t size, Pipeline* next)
{
cinfo->dest = static_cast<struct jpeg_destination_mgr*>(
// line-break
(*cinfo->mem->alloc_small)(
reinterpret_cast<j_common_ptr>(cinfo), JPOOL_PERMANENT, sizeof(dct_pipeline_des... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%ra... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
jpeg_buffer_src(jpeg_decompress_struct*, Buffer*) | static void
jpeg_buffer_src(j_decompress_ptr cinfo, Buffer* buffer)
{
cinfo->src = reinterpret_cast<jpeg_source_mgr*>(
// line-break
(*cinfo->mem->alloc_small)(
reinterpret_cast<j_common_ptr>(cinfo), JPOOL_PERMANENT, sizeof(jpeg_source_mgr)));
jpeg_source_mgr* src = cinfo->src;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
progress_monitor(jpeg_common_struct*) | static void
progress_monitor(j_common_ptr cinfo)
{
if (cinfo->is_decompressor &&
reinterpret_cast<jpeg_decompress_struct*>(cinfo)->input_scan_number > scan_limit) {
auto* jerr = reinterpret_cast<qpdf_jpeg_error_mgr*>(cinfo->err);
jerr->msg = "Pl_DCT::decompress: JPEG data has too many scans"... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x4be7f
movq -0x8(%rbp), %rax
movl 0xac(%rax), %eax
cmpl 0x446672(%rip), %eax # 0x4924b8
jle 0x4be7f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x170, %rdi... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
skip_buffer_input_data(jpeg_decompress_struct*, long) | static void
skip_buffer_input_data(j_decompress_ptr cinfo, long num_bytes)
{
if (num_bytes < 0) {
throw std::runtime_error(
"reading jpeg: jpeg library requested skipping a negative number of bytes");
}
size_t to_skip = QIntC::to_size(num_bytes);
if ((to_skip > 0) && (to_skip <= cinf... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x4c22a
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x2c3500(%rip), %rsi # 0x30f6f2
callq 0x1b400
jmp 0x4c1f9
movq -0x30(%rbp), %rdi
movq 0x444d8c(%rip), ... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
Pl_DCT::Members::Members() | Members() :
action(a_decompress),
buf("DCT compressed image")
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x1, (%rdi)
addq $0x8, %rdi
leaq 0x2c2d37(%rip), %rsi # 0x30f76c
xorl %eax, %eax
movl %eax, %edx
callq 0x496a0
movq -0x10(%rbp), %rax
movl $0x0, 0x40(%rax)
movl $0x0, 0x44(%rax)
movl $0x1, 0x48(%rax)
... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
QIntC::IntConverter<unsigned int, unsigned long, false, false>::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 unsigned type";
throw... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movl %edi, -0x4(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x4d172
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
Pl_Flate::Members::Members(unsigned long, Pl_Flate::action_e) | Pl_Flate::Members::Members(size_t out_bufsize, action_e action) :
out_bufsize(out_bufsize),
action(action),
initialized(false),
zdata(nullptr)
{
this->outbuf = QUtil::make_shared_array<unsigned char>(out_bufsize);
// Indirect through zdata to reach the z_stream so we don't have to include zlib.h... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x4ebe0
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x10(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x18(%rd... | /jberkenbilt[P]qpdf/libqpdf/Pl_Flate.cc |
Pl_Flate::zopfli_enabled() | bool
Pl_Flate::zopfli_enabled()
{
if (zopfli_supported()) {
std::string value;
static bool enabled = QUtil::get_env("QPDF_ZOPFLI", &value) && value != "disabled";
return enabled;
} else {
return false;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
callq 0x4e9a0
testb $0x1, %al
jne 0x4d846
jmp 0x4d95a
leaq -0x28(%rbp), %rdi
callq 0x1b510
cmpb $0x0, 0x444c82(%rip) # 0x4924d8
jne 0x4d901
leaq 0x444c75(%rip), %rdi # 0x4924d8
callq 0x1b530
cmpl $0x0, %eax
je 0x4d901
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq ... | /jberkenbilt[P]qpdf/libqpdf/Pl_Flate.cc |
Pl_Flate::handleData(unsigned char const*, unsigned long, int) | void
Pl_Flate::handleData(unsigned char const* data, size_t len, int flush)
{
if (len > UINT_MAX) {
throw std::runtime_error("Pl_Flate: zlib doesn't support data blocks larger than int");
}
z_stream& zstream = *(static_cast<z_stream*>(m->zdata));
// zlib is known not to modify the data pointed t... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
jbe 0x4dee0
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi,... | /jberkenbilt[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 0x463f0
movq -0x38(%rbp), %rdi
leaq 0x4394f5(%rip), %rax ... | /jberkenbilt[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_LZWDecoder::sendNextCode() | void
Pl_LZWDecoder::sendNextCode()
{
unsigned int high = this->byte_pos;
unsigned int med = (this->byte_pos + 1) % 3;
unsigned int low = (this->byte_pos + 2) % 3;
unsigned int bits_from_high = 8 - this->bit_pos;
unsigned int bits_from_med = this->code_size - bits_from_high;
unsigned int bits_fr... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x3c(%rax), %ecx
movl %ecx, -0xc(%rbp)
movl 0x3c(%rax), %eax
addl $0x1, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
movq -0x38(%rbp), %rax
movl %edx, -0x10(%rbp)
movl 0x3c(%rax), %eax
addl $0x2, %eax
m... | /jberkenbilt[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_PNGFilter::encodeRow() | void
Pl_PNGFilter::encodeRow()
{
// For now, hard-code to using UP filter.
unsigned char ch = 2;
next()->write(&ch, 1);
if (this->prev_row) {
for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
ch = static_cast<unsigned char>(this->cur_row[i] - this->prev_row[i]);
ne... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movb $0x2, -0x9(%rbp)
callq 0x47800
movq %rax, %rdi
movq (%rdi), %rax
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq *0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x54950
movl $0x0, -0x10(%rbp)
movq... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::decodeSub() | void
Pl_PNGFilter::decodeSub()
{
QTC::TC("libtests", "Pl_PNGFilter decodeSub");
unsigned char* buffer = this->cur_row + 1;
unsigned int bpp = this->bytes_per_pixel;
for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
unsigned char left = 0;
if (i >= bpp) {
left = buffe... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x2b8c84(%rip), %rdi # 0x30d6cf
leaq 0x2bb500(%rip), %rsi # 0x30ff52
xorl %edx, %edx
callq 0x25230
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movl 0x38(%rax)... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::decodeAverage() | void
Pl_PNGFilter::decodeAverage()
{
QTC::TC("libtests", "Pl_PNGFilter decodeAverage");
unsigned char* buffer = this->cur_row + 1;
unsigned char* above_buffer = this->prev_row + 1;
unsigned int bpp = this->bytes_per_pixel;
for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
int left = ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x2b8b44(%rip), %rdi # 0x30d6cf
leaq 0x2bb3ed(%rip), %rsi # 0x30ff7f
xorl %edx, %edx
callq 0x25230
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movq 0x48(%rax)... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_RunLength::decode(unsigned char const*, unsigned long) | void
Pl_RunLength::decode(unsigned char const* data, size_t len)
{
if (memory_limit && (len + m->out.size()) > memory_limit) {
throw std::runtime_error("Pl_RunLength memory limit exceeded");
}
m->out.reserve(len);
for (size_t i = 0; i < len; ++i) {
unsigned char const& ch = data[i];
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, 0x43bee4(%rip) # 0x4924f8
je 0x566a4
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x30, %rdi
callq 0x56d10
movq %rax, %... | /jberkenbilt[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_SHA2::getRawDigest[abi:cxx11]() | std::string
Pl_SHA2::getRawDigest()
{
if (this->in_progress) {
throw std::logic_error("digest requested for in-progress SHA2 Pipeline");
}
return this->crypto->SHA2_digest();
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x30(%rax)
je 0x57449
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
lea... | /jberkenbilt[P]qpdf/libqpdf/Pl_SHA2.cc |
Pl_SHA2::getHexDigest[abi:cxx11]() | std::string
Pl_SHA2::getHexDigest()
{
if (this->in_progress) {
throw std::logic_error("digest requested for in-progress SHA2 Pipeline");
}
return QUtil::hex_encode(getRawDigest());
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, 0x30(%rax)
je 0x574f9
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
lea... | /jberkenbilt[P]qpdf/libqpdf/Pl_SHA2.cc |
Pl_TIFFPredictor::write(unsigned char const*, unsigned long) | void
Pl_TIFFPredictor::write(unsigned char const* data, size_t len)
{
auto end = data + len;
auto row_end = data + (bytes_per_row - cur_row.size());
while (row_end <= end) {
// finish off current row
cur_row.insert(cur_row.end(), data, row_end);
data = row_end;
row_end += byt... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl 0x38(%rdi), %eax
movq %rax, -0x68(%rbp)
add... | /jberkenbilt[P]qpdf/libqpdf/Pl_TIFFPredictor.cc |
Pl_TIFFPredictor::processRow() | void
Pl_TIFFPredictor::processRow()
{
QTC::TC("libtests", "Pl_TIFFPredictor processRow", (action == a_decode ? 0 : 1));
previous.assign(samples_per_pixel, 0);
if (bits_per_sample != 8) {
BitWriter bw(next());
BitStream in(cur_row.data(), cur_row.size());
for (unsigned int col = 0; co... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl 0x30(%rax), %ecx
movl $0x1, %edx
xorl %eax, %eax
cmpl $0x1, %ecx
cmovel %eax, %edx
leaq 0x2b4ece(%rip), %rdi # 0x30d6cf
leaq 0x2b7b54(%rip), %rsi # 0x31035c
callq 0x25230
m... | /jberkenbilt[P]qpdf/libqpdf/Pl_TIFFPredictor.cc |
QPDF::~QPDF() | QPDF::~QPDF()
{
// If two objects are mutually referential (through each object having an array or dictionary
// that contains an indirect reference to the other), the circular references in the
// std::shared_ptr objects will prevent the objects from being deleted. Walk through all objects
// in the ob... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x63670
movq %rax, %rdi
addq $0x138, %rdi # imm = 0x138
callq 0x636f0
movq -0x40(%rbp), %rdi
callq 0x63670
addq $0x1a8, %rax # imm = 0x1A8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::validatePDFVersion(char const*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool
QPDF::validatePDFVersion(char const*& p, std::string& version)
{
bool valid = util::is_digit(*p);
if (valid) {
while (util::is_digit(*p)) {
version.append(1, *p++);
}
if ((*p == '.') && util::is_digit(*(p + 1))) {
version.append(1, *p++);
while (u... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x63ce0
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x5d6c1
jmp 0x5d600
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x63ce0... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::copyForeignObject(QPDFObjectHandle) | QPDFObjectHandle
QPDF::copyForeignObject(QPDFObjectHandle foreign)
{
// Here's an explanation of what's going on here.
//
// A QPDFObjectHandle that is an indirect object has an owning QPDF. The object ID and
// generation refers to an object in the owning QPDF. When we copy the QPDFObjectHandle from a
... | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdx, -0x230(%rbp)
movq %rdi, %rax
movq -0x230(%rbp), %rdi
movq %rax, -0x228(%rbp)
movq %rax, %rcx
movq %rcx, -0x220(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x218(%rbp)
callq 0... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::getXRefTableInternal() | std::map<QPDFObjGen, QPDFXRefEntry> const&
QPDF::getXRefTableInternal()
{
if (!m->parsed) {
throw std::logic_error("QPDF::getXRefTable called before parsing.");
}
return m->xref_table;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x63670
testb $0x1, 0x2d4(%rax)
jne 0x618b2
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x2af2fe(%rip), %rsi # 0x310b7b
callq 0x1bbe0
jmp 0x61884
movq -0... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::removeSecurityRestrictions() | void
QPDF::removeSecurityRestrictions()
{
auto root = getRoot();
root.removeKey("/Perms");
auto acroform = root.getKey("/AcroForm");
if (acroform.isDictionary() && acroform.hasKey("/SigFlags")) {
acroform.replaceKey("/SigFlags", QPDFObjectHandle::newInteger(0));
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x610c0
leaq -0x39(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x1be40
movq -0xf0(%rbp), %rdx
leaq 0x2ae5c5(%rip), %rsi # 0x310c6f
leaq -0x38(%rbp), %rdi
callq 0x21b70
jmp 0x626... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDFObjectHandle::as_stream(qpdf::typed) const | inline qpdf::Stream
QPDFObjectHandle::as_stream(qpdf::typed options) const
{
if (options & qpdf::any_flag || type_code() == ::ot_stream ||
(options & qpdf::optional && type_code() == ::ot_null)) {
return qpdf::Stream(obj);
}
if (options & qpdf::error) {
assertType("stream", false);
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movzbl -0x11(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x649ac
movq -0x40(%rbp), ... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDF_Dictionary* qpdf::BaseHandle::as<QPDF_Dictionary>() const | T*
BaseHandle::as() const
{
if (!obj) {
return nullptr;
}
if (std::holds_alternative<T>(obj->value)) {
return &std::get<T>(obj->value);
}
if (std::holds_alternative<QPDF_Unresolved>(obj->value)) {
return BaseHandle(QPDF::Resolver::resol... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x43890
testb $0x1, %al
jne 0x6a64d
movq $0x0, -0x8(%rbp)
jmp 0x6a78c
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq %rax, %rdi
callq 0x6a800
testb $0x1, %al
jne 0x6a664
jmp 0x6a67e
movq -0x50(%rbp), %rdi
c... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDF_Stream* qpdf::BaseHandle::as<QPDF_Stream>() const | T*
BaseHandle::as() const
{
if (!obj) {
return nullptr;
}
if (std::holds_alternative<T>(obj->value)) {
return &std::get<T>(obj->value);
}
if (std::holds_alternative<QPDF_Unresolved>(obj->value)) {
return BaseHandle(QPDF::Resolver::resol... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x43890
testb $0x1, %al
jne 0x6ab9d
movq $0x0, -0x8(%rbp)
jmp 0x6acdc
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq %rax, %rdi
callq 0x6ad30
testb $0x1, %al
jne 0x6abb4
jmp 0x6abce
movq -0x50(%rbp), %rdi
c... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDFAcroFormDocumentHelper::getOrCreateAcroForm() | QPDFObjectHandle
QPDFAcroFormDocumentHelper::getOrCreateAcroForm()
{
auto acroform = qpdf.getRoot().getKey("/AcroForm");
if (!acroform.isDictionary()) {
acroform = qpdf.getRoot().replaceKeyAndGetNew(
"/AcroForm", qpdf.makeIndirectObject(QPDFObjectHandle::newDictionary()));
}
return a... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movb $0x0, -0x11(%rbp)
movq 0x8(%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x610c0
leaq -0x49(%rbp)... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::addFormField(QPDFFormFieldObjectHelper) | void
QPDFAcroFormDocumentHelper::addFormField(QPDFFormFieldObjectHelper ff)
{
auto acroform = getOrCreateAcroForm();
auto fields = acroform.getKey("/Fields");
if (!fields.isArray()) {
fields = acroform.replaceKeyAndGetNew("/Fields", QPDFObjectHandle::newArray());
}
fields.appendItem(ff.getOb... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rsi, -0x128(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x120(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa0010
leaq -0x51(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x1be40
movq -0x118(%rbp), %rdx
leaq 0x271b63... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::traverseField(QPDFObjectHandle, QPDFObjectHandle, int, QPDFObjGen::set&) | void
QPDFAcroFormDocumentHelper::traverseField(
QPDFObjectHandle field, QPDFObjectHandle parent, int depth, QPDFObjGen::set& visited)
{
if (depth > 100) {
// Arbitrarily cut off recursion at a fixed depth to avoid specially crafted files that
// could cause stack overflow.
return;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rsi, -0x340(%rbp)
movq %rdx, -0x338(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x330(%rbp)
cmpl $0x64, -0x1c(%rbp)
jle 0xa0612
jmp 0xa... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::addAndRenameFormFields(std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>) | void
QPDFAcroFormDocumentHelper::addAndRenameFormFields(std::vector<QPDFObjectHandle> fields)
{
analyze();
std::map<std::string, std::string> renames;
QPDFObjGen::set seen;
for (std::list<QPDFObjectHandle> queue{fields.begin(), fields.end()}; !queue.empty();
queue.pop_front()) {
auto& o... | pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp # imm = 0x4D0
movq %rsi, -0x418(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x420(%rbp)
callq 0x9f4b0
leaq -0x40(%rbp), %rdi
callq 0xa9be0
leaq -0x70(%rbp), %rdi
callq 0x43070
movq -0x418(%rbp), %rdi
callq 0x64060
movq -0x4... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::getFieldsWithQualifiedName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::set<QPDFObjGen>
QPDFAcroFormDocumentHelper::getFieldsWithQualifiedName(std::string const& name)
{
analyze();
// Keep from creating an empty entry
auto iter = m->name_to_fields.find(name);
if (iter != m->name_to_fields.end()) {
return iter->second;
}
return {};
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x9f4b0
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
callq 0xa9b50
movq %rax, %rdi
addq $0x98, %rdi... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::getAnnotationsForField(QPDFFormFieldObjectHelper) | std::vector<QPDFAnnotationObjectHelper>
QPDFAcroFormDocumentHelper::getAnnotationsForField(QPDFFormFieldObjectHelper h)
{
analyze();
std::vector<QPDFAnnotationObjectHelper> result;
QPDFObjGen og(h.getObjectHandle().getObjGen());
if (m->field_to_annotations.count(og)) {
result = m->field_to_annot... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x9f4b0
movq -0x58(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0xaa740
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::getFormFieldsForPage(QPDFPageObjectHelper) | std::vector<QPDFFormFieldObjectHelper>
QPDFAcroFormDocumentHelper::getFormFieldsForPage(QPDFPageObjectHelper ph)
{
analyze();
QPDFObjGen::set todo;
std::vector<QPDFFormFieldObjectHelper> result;
for (auto& annot: getWidgetAnnotationsForPage(ph)) {
auto field = getFieldForAnnotation(annot).getTop... | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdx, -0x1b0(%rbp)
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x9f4b0
leaq -0x48(%rbp), %rdi
callq 0x43... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::getNeedAppearances() | bool
QPDFAcroFormDocumentHelper::getNeedAppearances()
{
bool result = false;
QPDFObjectHandle acroform = qpdf.getRoot().getKey("/AcroForm");
if (acroform.isDictionary() && acroform.getKey("/NeedAppearances").isBool()) {
result = acroform.getKey("/NeedAppearances").getBoolValue();
}
return re... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, -0x9(%rbp)
movq 0x8(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x610c0
leaq -0x51(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x1be40
movq -0xe0(%rbp), %rdx
leaq 0x26ee00(%rip), %rsi # 0x3120e2
lea... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.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
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x190(%rbp)
callq 0xa32a0
testb $0x1, %al
jne 0xa3988
jmp 0xa3cdb
movq -0x190(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x1e0e10
movq -0x198(%rbp), %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.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.