name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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/Math/MathML\">\n"
" <apply>\n"
" <eq/>\n"
" <ci>b2</ci>\n"
" <apply>\n"
" <times/>\n"
" <cn xmlns:cellml=\"http://www.cellml.org/cellml/2.0#\" cellml:units=\"dimensionless\">2.0</cn>\n"
" <ci>d</ci>\n"
" </apply>\n"
" </apply>\n"
" </math>\n"
" </component>\n"
"</model>\n";
libcellml::ParserPtr parser = libcellml::Parser::create();
parser->parseModel(in);
EXPECT_EQ(size_t(0), parser->issueCount());
}
|
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"
" <variable name=\"B\" initial_value=\"-1.0\"/>\n"
" <math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n"
" <apply>\n"
" <eq/>\n"
" <ci>C</ci>\n"
" <apply>\n"
" <plus/>\n"
" <ci>A</ci>\n"
" <ci>B</ci>\n"
" </apply>\n"
" </apply>\n"
" </math>\n"
" </component>\n"
"</model>\n";
libcellml::ParserPtr parser = libcellml::Parser::create();
libcellml::PrinterPtr printer = libcellml::Printer::create();
libcellml::ModelPtr model1 = parser->parseModel(in);
std::string output1 = printer->printModel(model1);
libcellml::ModelPtr model2 = parser->parseModel(output1);
std::string output2 = printer->printModel(model2);
EXPECT_EQ(in, output2);
}
|
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-model.xml\">\n"
" <units units_ref=\"a_units_in_that_model\" name=\"units1\"/>\n"
" <component component_ref=\"a_component_in_that_model\" name=\"component1\"/>\n"
" </import>\n"
"</model>\n";
auto parser = libcellml::Parser::create();
auto modelCombined = parser->parseModel(combinedInString);
auto printer = libcellml::Printer::create();
EXPECT_EQ(combinedInString, printer->printModel(modelCombined));
}
|
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"
" <component component_ref=\"myComponent\" name=\"myImportedComponent\"/>\n"
" </import>\n"
" <component name=\"myConcreteComponent\"/>\n"
" <encapsulation>\n"
" <component_ref component=\"myConcreteComponent\">\n"
" <component_ref component=\"myImportedComponent\"/>\n"
" </component_ref>\n"
" </encapsulation>\n"
"</model>";
auto parser = libcellml::Parser::create();
auto model = parser->parseModel(modelString);
EXPECT_TRUE(model->component("myImportedComponent")->isImport());
EXPECT_FALSE(model->component("myConcreteComponent")->isImport());
}
|
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, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
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, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xf500
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x391e1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x391fc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3922e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x3922e
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39249
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rdi
callq 0xf640
|
/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, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
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
xorl %r9d, %r9d
callq 0xf500
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39a63
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39a7e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39ab0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x39ab0
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39acb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rdi
callq 0xf640
|
/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, rhs);
}
|
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 0xf070
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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, rhs);
}
|
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 0xf070
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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, rhs);
}
|
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 0xf070
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
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
xorl %r9d, %r9d
callq 0xf500
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a406
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a421
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a453
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf390
jmp 0x3a453
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a46e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf390
movq %rbx, %rdi
callq 0xf640
|
/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 warnings.");
}
fprintf(stderr, "\n");
}
|
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 (%r14), %rcx
leaq 0xcee(%rip), %rdi # 0x2035
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
jmp 0x132b
|
/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_, sizeof(line_), stdin) != 0) {
if (ScanDeprecatedFormat() == 5) {
if (newFormat_) {
fprintf(stderr, "ERROR: Deprecated format used in line %d:\n%s\n",
lineno_, line_);
PrintErrorMessage();
}
} else if (ScanNewFormat() == 4) {
if (!newFormat_) {
fprintf(stderr, "ERROR: Missing interval type column in line %d:\n%s\n",
lineno_, line_);
PrintErrorMessage();
}
dbd_.interval_type = 0;
} else {
fprintf(stderr, "ERROR: Invalid data in line %d:\n%s\n", lineno_, line_);
PrintErrorMessage();
}
CheckContiguousBinIndices();
CheckInterpolationDamageValuesWithinRange();
StoreLine();
if (convertToBin) ConvertToBin();
}
}
|
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 # imm = 0x1000
callq 0x1130
testq %rax, %rax
je 0x1751
movq %r14, %rdi
callq 0x179c
cmpl $0x5, %eax
jne 0x16c1
cmpb $0x1, 0x2020(%r14)
jne 0x16e0
movq (%r12), %rdi
movl 0x1000(%r14), %edx
movq %r15, %rsi
jmp 0x1717
movq %r14, %rdi
callq 0x17d4
cmpl $0x4, %eax
jne 0x1709
cmpb $0x0, 0x2020(%r14)
je 0x172b
andl $0x0, 0x201c(%r14)
movq %r14, %rdi
callq 0x1970
movq %r14, %rdi
callq 0x17fe
movq %r14, %rdi
callq 0x1908
testb %bl, %bl
je 0x1680
movq %r14, %rdi
callq 0x1954
jmp 0x1680
movq (%r12), %rdi
movl 0x1000(%r14), %edx
movq %r13, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x1110
movq %r14, %rdi
callq 0x1354
jmp 0x16e0
movq (%r12), %rdi
movl 0x1000(%r14), %edx
leaq 0xb9e(%rip), %rsi # 0x22db
movq %r14, %rcx
xorl %eax, %eax
callq 0x1110
movq %r14, %rdi
callq 0x1354
jmp 0x16d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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
cmpl 0x48(%rbx), %ebp
sete %al
jmp 0x27936
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 0x282a8
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x279ab
movq %rdx, 0x28(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x38(%rsp)
jmp 0x279b1
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x28(%rsp), %rsi
movq %rcx, 0x8(%rsi)
movb $0x0, 0x18(%rsp)
movq %r14, 0x20(%rsi)
movq %rbx, %rdi
callq 0x28a4a
leaq 0x28(%rsp), %rdi
callq 0x27568
leaq 0x8(%rsp), %rdi
callq 0x27568
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x27568
jmp 0x27a1e
movq %rax, %rbx
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x272b0
jmp 0x27a1e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27568
movq %rbx, %rdi
callq 0x27490
|
/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_size_checker("type-phandle", string("phandle"), 4);
disabled_checkers.insert(std::make_pair(string("cells-attributes"),
new address_cells_checker("cells-attributes")));
checkers.insert(std::make_pair(string("deleted-nodes"),
new deleted_node_checker("deleted-nodes")));
}
|
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)
leaq 0x38(%rdi), %r13
leaq 0x68(%rdi), %rdx
movq %rdx, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movups %xmm0, 0x48(%rdi)
movl %ecx, 0x58(%rdi)
movups %xmm0, 0x60(%rdi)
leaq 0x1654d(%rip), %rsi # 0x3e049
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %r13, 0x60(%rsp)
callq 0x2826c
leaq 0x1652d(%rip), %rsi # 0x3e044
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x282d8
leaq 0x8(%rsp), %rdi
callq 0x27568
leaq 0x16524(%rip), %rsi # 0x3e059
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x2826c
leaq 0x16509(%rip), %rsi # 0x3e054
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x283c0
leaq 0x8(%rsp), %rdi
callq 0x27568
leaq 0x178f7(%rip), %rsi # 0x3f460
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x2826c
leaq 0x164e0(%rip), %rsi # 0x3e05f
leaq 0x8(%rsp), %rdx
pushq $0x4
popq %rcx
movq %rbx, %rdi
callq 0x27942
leaq 0x8(%rsp), %rdi
callq 0x27568
leaq 0x164cc(%rip), %r15 # 0x3e06c
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0x2826c
pushq $0x28
popq %rdi
callq 0x272a0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
movq %r15, 0x20(%rax)
leaq 0x273af(%rip), %rcx # 0x4ef80
movq %rcx, (%rax)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x40(%rsp), %rdx
movq -0x10(%rdx), %rcx
cmpq %rdx, %rcx
je 0x27bfc
movq %rcx, 0x8(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x18(%rsp)
jmp 0x27c03
movups (%rdx), %xmm0
movups %xmm0, (%r14)
movq 0x38(%rsp), %rcx
movq %rdx, 0x30(%rsp)
andq $0x0, 0x38(%rsp)
movq %rcx, 0x10(%rsp)
movb $0x0, 0x40(%rsp)
movq %rax, 0x28(%rsp)
movq %r13, 0x50(%rsp)
pushq $0x1
popq %rsi
movq %r13, %rdi
callq 0x28bc8
movq %rax, %r15
andq $0x0, (%rax)
leaq 0x8(%rax), %r12
addq $0x18, %rax
movq %rax, 0x8(%r15)
movq 0x8(%rsp), %rcx
cmpq %r14, %rcx
je 0x27c5d
movq %rcx, (%r12)
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x27c64
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r15)
movq %r14, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x28(%r15)
movq %r15, 0x58(%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x28c24
movq %r13, %rdi
movq %rax, %r13
xorl %edx, %edx
divq 0x40(%rbx)
movq %rdx, %rbp
movq %rdx, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x28af4
testq %rax, %rax
jne 0x27cd5
pushq $0x1
popq %r8
movq 0x60(%rsp), %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x28b08
andq $0x0, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x28b7e
leaq 0x8(%rsp), %rdi
callq 0x27568
leaq 0x30(%rsp), %rdi
callq 0x27568
leaq 0x16383(%rip), %r15 # 0x3e07d
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0x2826c
pushq $0x28
popq %rdi
callq 0x272a0
andq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %r15, 0x20(%rax)
leaq 0x2729d(%rip), %rcx # 0x4efc8
movq %rcx, (%rax)
movq %r14, 0x8(%rsp)
movq 0x30(%rsp), %rcx
leaq 0x40(%rsp), %rdx
cmpq %rdx, %rcx
je 0x27d53
movq %rcx, 0x8(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x18(%rsp)
jmp 0x27d5a
movups (%rdx), %xmm0
movups %xmm0, (%r14)
movq 0x38(%rsp), %rcx
movq %rdx, 0x30(%rsp)
andq $0x0, 0x38(%rsp)
movq %rcx, 0x10(%rsp)
movb $0x0, 0x40(%rsp)
movq %rax, 0x28(%rsp)
movq %rbx, 0x50(%rsp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x28bc8
movq %rax, %r15
andq $0x0, (%rax)
leaq 0x8(%rax), %r12
addq $0x18, %rax
movq %rax, 0x8(%r15)
movq 0x8(%rsp), %rcx
cmpq %r14, %rcx
je 0x27db4
movq %rcx, (%r12)
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x27dbb
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r15)
movq %r14, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x28(%r15)
movq %r15, 0x58(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x28c24
movq %rax, %r13
xorl %edx, %edx
divq 0x8(%rbx)
movq %rdx, %rbp
movq %rbx, %rdi
movq %rdx, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x28af4
testq %rax, %rax
jne 0x27e2a
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x28b08
andq $0x0, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x28b7e
leaq 0x8(%rsp), %rdi
callq 0x27568
leaq 0x30(%rsp), %rdi
callq 0x27568
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27e63
jmp 0x27e63
jmp 0x27e63
jmp 0x27e72
jmp 0x27e81
jmp 0x27ea4
movq %rax, %r15
leaq 0x50(%rsp), %rdi
callq 0x28b7e
jmp 0x27e75
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x27568
jmp 0x27e84
movq %rax, %r15
leaq 0x30(%rsp), %rdi
jmp 0x27e9d
jmp 0x27ea4
jmp 0x27e95
jmp 0x27ea4
jmp 0x27e95
jmp 0x27ea4
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x27568
jmp 0x27ea7
movq %rax, %r15
movq 0x60(%rsp), %rdi
callq 0x286ba
movq %rbx, %rdi
callq 0x286ba
movq %r15, %rdi
callq 0x27490
nop
|
/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/;"))
{
is_plugin = true;
}
input.next_token();
if (!read_header)
{
input.parse_error("Expected /dts-v1/; version string");
}
// Read any memory reservations
while (input.consume("/memreserve/"))
{
unsigned long long start, len;
input.next_token();
// Read the start and length.
if (!(input.consume_integer_expression(start) &&
(input.next_token(),
input.consume_integer_expression(len))))
{
input.parse_error("Expected size on /memreserve/ node.");
}
else
{
reservations.push_back(reservation(start, len));
}
input.next_token();
input.consume(';');
input.next_token();
}
while (valid && !input.finished())
{
node_ptr n;
if (input.consume("/delete-node/"))
{
// Top-level /delete-node/ directives refer to references that must
// be deleted later.
input.next_token();
auto expect = [&](auto token, const char *msg)
{
if (!input.consume(token))
{
input.parse_error(msg);
valid = false;
}
input.next_token();
return valid;
};
if (expect('&', "Expected reference after top-level /delete-node/."))
{
string ref = input.parse_node_name();
if (ref == string())
{
input.parse_error("Expected label name for top-level /delete-node/.");
valid = false;
}
else
{
deletions.push_back(std::move(ref));
}
expect(';', "Missing semicolon.");
}
continue;
}
else if (input.consume('/'))
{
input.next_token();
n = node::parse(input, *this, string(), string_set(), string(), &defines);
}
else if (input.consume('&'))
{
input.next_token();
string name;
bool name_is_path_reference = false;
// This is to deal with names intended as path references, e.g. &{/path}.
// While it may make sense in a non-plugin context, we don't support such
// usage at this time.
if (input.consume('{') && is_plugin)
{
name = input.parse_to('}');
input.consume('}');
name_is_path_reference = true;
}
else
{
name = input.parse_node_name();
}
input.next_token();
n = node::parse(input, *this, std::move(name), string_set(), string(), &defines);
if (n)
{
n->name_is_path_reference = name_is_path_reference;
}
}
else
{
input.parse_error("Failed to find root node /.");
}
if (n)
{
roots.push_back(std::move(n));
}
else
{
valid = false;
}
input.next_token();
}
}
|
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 0x2ffd5
leaq 0xf585(%rip), %rsi # 0x3f57d
movq %r14, %rdi
callq 0x328c4
testb %al, %al
movq 0x8(%rsp), %r15
je 0x30011
movb $0x1, 0x238(%r15)
movq %r14, %rdi
callq 0x3a670
cmpb $0x0, (%rbx)
jne 0x3002d
leaq 0xf562(%rip), %rsi # 0x3f587
movq %r14, %rdi
callq 0x3a81a
leaq 0x8(%r15), %rbx
leaq 0xf633(%rip), %r12 # 0x3f66b
leaq 0x10(%rsp), %r13
pushq $0x3b
popq %r15
leaq 0xf561(%rip), %rbp # 0x3f5a9
movq %r14, %rdi
movq %r12, %rsi
callq 0x328c4
testb %al, %al
je 0x300d5
movq %r14, %rdi
callq 0x3a670
movq %r14, %rdi
movq %r13, %rsi
callq 0x3afe2
testb %al, %al
je 0x300aa
movq %r14, %rdi
callq 0x3a670
movq %r14, %rdi
leaq 0x48(%rsp), %rsi
callq 0x3afe2
testb %al, %al
je 0x300aa
movq 0x10(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x78(%rsp)
movq %rbx, %rdi
leaq 0x70(%rsp), %rsi
callq 0x39a14
jmp 0x300b5
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3a81a
movq %r14, %rdi
callq 0x3a670
movq %r14, %rdi
movl %r15d, %esi
callq 0x326d2
movq %r14, %rdi
callq 0x3a670
jmp 0x30048
movq 0x8(%rsp), %r15
leaq 0x1f0(%r15), %rax
movq %rax, 0x68(%rsp)
leaq 0x108(%r15), %rax
movq %rax, 0xa8(%rsp)
leaq 0x48(%rsp), %r13
leaq 0x70(%rsp), %rbx
leaq 0x10(%rsp), %r12
pushq $0x7d
popq %rbp
cmpb $0x1, 0x4(%r15)
jne 0x30484
movq %r14, %rdi
callq 0x32d2e
testb %al, %al
jne 0x30484
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq %r14, %rdi
leaq 0xf228(%rip), %rsi # 0x3f35c
callq 0x328c4
testb %al, %al
je 0x301ca
movq %r14, %rdi
callq 0x3a670
movq %r14, 0x48(%rsp)
movq %r15, 0x50(%rsp)
movq %r13, %rdi
pushq $0x26
popq %rsi
leaq 0xf46d(%rip), %rdx # 0x3f5cd
callq 0x304e8
testb %al, %al
je 0x30475
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c2d0
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2823a
movl %eax, %r15d
movq %r12, %rdi
callq 0x27568
testb %r15b, %r15b
je 0x30333
movq %r14, %rdi
leaq 0xf449(%rip), %rsi # 0x3f5ff
callq 0x3a81a
movq 0x8(%rsp), %r15
movb $0x0, 0x4(%r15)
jmp 0x30348
movq %r14, %rdi
pushq $0x2f
popq %rsi
callq 0x326d2
testb %al, %al
je 0x302a3
movq %r14, %rdi
callq 0x3a670
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
andq $0x0, 0x90(%rsp)
xorl %ecx, %ecx
movb %cl, 0x20(%rsp)
leaq 0xa0(%rsp), %rax
movq %rax, 0x70(%rsp)
movq $0x1, 0x78(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, 0x90(%rsp) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
andq $0x0, 0x50(%rsp)
movb %cl, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
leaq 0xb8(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %rbx, %r8
movq %r13, %r9
callq 0x2e110
leaq 0x30(%rsp), %rdi
movq %rbp, %rsi
callq 0x379e0
leaq 0xc0(%rsp), %rdi
callq 0x28538
movq %r13, %rdi
callq 0x27568
movq %rbx, %rdi
callq 0x2b6fc
movq %r12, %rdi
callq 0x27568
jmp 0x30449
movq %r14, %rdi
pushq $0x26
popq %rsi
callq 0x326d2
testb %al, %al
je 0x3031f
movq %r14, %rdi
callq 0x3a670
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq %r14, %rdi
pushq $0x7b
popq %rsi
callq 0x326d2
testb %al, %al
je 0x30367
movq 0x8(%rsp), %rax
cmpb $0x1, 0x238(%rax)
jne 0x30367
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3a868
movq %r12, %rdi
movq %rbx, %rsi
callq 0x27350
movq %rbx, %rdi
callq 0x27568
movb $0x1, %r15b
movq %r14, %rdi
movl %ebp, %esi
callq 0x326d2
jmp 0x30388
movq %r14, %rdi
leaq 0xf31a(%rip), %rsi # 0x3f643
callq 0x3a81a
jmp 0x3044c
movq 0xa8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2b35c
movq 0x8(%rsp), %r15
movq %r13, %rdi
pushq $0x3b
popq %rsi
leaq 0xf2db(%rip), %rdx # 0x3f630
callq 0x304e8
movq %rbx, %rdi
callq 0x27568
jmp 0x30475
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c2d0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x27350
movq %rbx, %rdi
callq 0x27568
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x3a670
andq $0x0, 0x90(%rsp)
leaq 0xa0(%rsp), %rax
movq %rax, 0x70(%rsp)
movq $0x1, 0x78(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, 0x90(%rsp) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
andq $0x0, 0x50(%rsp)
movb $0x0, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
leaq 0xb8(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
movq %r12, %rcx
movq %rbx, %r8
movq %r13, %r9
callq 0x2e110
leaq 0x30(%rsp), %rdi
movq %rbp, %rsi
callq 0x379e0
leaq 0xc0(%rsp), %rdi
callq 0x28538
movq %r13, %rdi
callq 0x27568
movq %rbx, %rdi
callq 0x2b6fc
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x3043c
movb %r15b, 0x58(%rax)
movq %r12, %rdi
callq 0x27568
movq 0x8(%rsp), %r15
pushq $0x7d
popq %rbp
cmpq $0x0, 0x30(%rsp)
je 0x30468
movq 0xb0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3590e
jmp 0x3046d
movb $0x0, 0x4(%r15)
movq %r14, %rdi
callq 0x3a670
leaq 0x38(%rsp), %rdi
callq 0x28538
jmp 0x30107
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x304b7
jmp 0x304b7
jmp 0x3049c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x27568
leaq 0x70(%rsp), %rdi
callq 0x2b6fc
jmp 0x304ba
jmp 0x304d2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x304c9
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x27568
jmp 0x304d5
jmp 0x304d2
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x28538
movq %rbx, %rdi
callq 0x27490
nop
|
/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)
{
fprintf(file, " 0x%" PRIx64 " 0x%" PRIx64, i.first, i.second);
}
fputs(";\n\n", file);
}
putc('/', file);
putc(' ', file);
root->write_dts(file, 0);
fclose(file);
}
|
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 $0x2f657672657365, %rax # imm = 0x2F657672657365
movq %rsp, %rdi
movq %rax, 0x5(%rdi)
movabsq $0x657365726d656d2f, %rax # imm = 0x657365726D656D2F
movq %rax, (%rdi)
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x27530
movq 0x8(%r14), %r12
movq 0x10(%r14), %r13
leaq 0xf059(%rip), %r15 # 0x3f678
cmpq %r13, %r12
je 0x30640
movq (%r12), %rdx
movq 0x8(%r12), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x273c0
addq $0x10, %r12
jmp 0x3061f
leaq 0xf020(%rip), %rdi # 0x3f667
movq %rbx, %rsi
callq 0x27300
pushq $0x2f
popq %rdi
movq %rbx, %rsi
callq 0x27520
pushq $0x20
popq %rdi
movq %rbx, %rsi
callq 0x27520
movq 0x20(%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2e8a4
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x27290
|
/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 newroot = node::create_special_node("", symbols);
node_ptr wrapper = node::create_special_node("__overlay__", symbols);
// Generate the fragment with $propname = <&name>
property_value v;
std::string propname;
v.string_data = node->name;
if (!node->name_is_path_reference)
{
propname = "target";
v.type = property_value::PHANDLE;
}
else
{
propname = "target-path";
v.type = property_value::STRING;
}
auto prop = std::make_shared<property>(std::string(propname));
prop->add_value(v);
symbols.push_back(prop);
node_ptr fragment = node::create_special_node(fragment_address, symbols);
wrapper->merge_node(node);
fragment->add_child(std::move(wrapper));
newroot->add_child(std::move(fragment));
return newroot;
}
|
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
callq 0x27568
incl (%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0xebdc(%rip), %rsi # 0x3f66a
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x2826c
leaq 0x78(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x2d96c
leaq 0x78(%rsp), %rdi
callq 0x27568
leaq 0xec87(%rip), %rsi # 0x3f745
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x2826c
leaq 0x28(%rsp), %rdi
leaq 0x78(%rsp), %rsi
movq %rsp, %rdx
callq 0x2d96c
leaq 0x78(%rsp), %rdi
callq 0x27568
leaq 0xe8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x78(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x32630
leaq 0xd8(%rsp), %rdi
callq 0x27568
leaq 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%r14), %rsi
addq $0x38, %rsi
leaq 0x98(%rsp), %rdi
callq 0x27170
movq (%r14), %rax
cmpb $0x0, 0x58(%rax)
je 0x30b5f
leaq 0xec07(%rip), %rsi # 0x3f758
leaq 0x58(%rsp), %rdi
callq 0x27510
pushq $0x1
jmp 0x30b72
leaq 0xebeb(%rip), %rsi # 0x3f751
leaq 0x58(%rsp), %rdi
callq 0x27510
pushq $0x4
popq %rax
movl %eax, 0xd0(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x273a0
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x336d1
leaq 0x38(%rsp), %rdi
callq 0x27568
movq 0x18(%rsp), %r15
leaq 0x118(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x32c7e
addq $0x58, %r15
leaq 0x118(%rsp), %rsi
movq %r15, %rdi
callq 0x32714
leaq 0x118(%rsp), %rdi
callq 0x32740
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x32a92
leaq 0x38(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
movq %rsp, %rdx
callq 0x2d96c
movq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x2e2cc
movl $0xa0, %r14d
movq 0x38(%rsp), %rdi
addq %r14, %rdi
leaq 0x28(%rsp), %rsi
callq 0x3590e
addq (%rbx), %r14
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0x3590e
leaq 0x40(%rsp), %rdi
callq 0x28538
leaq 0x20(%rsp), %rdi
callq 0x28538
leaq 0x58(%rsp), %rdi
callq 0x27568
leaq 0x78(%rsp), %rdi
callq 0x32740
leaq 0x30(%rsp), %rdi
callq 0x28538
movq %rsp, %rdi
callq 0x32ae0
leaq 0xf8(%rsp), %rdi
callq 0x27568
movq %rbx, %rax
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x30cf3
movq %rax, %r14
leaq 0x118(%rsp), %rdi
callq 0x32740
jmp 0x30d0a
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x27568
jmp 0x30d14
jmp 0x30cf8
movq %rax, %r14
leaq 0xd8(%rsp), %rdi
callq 0x27568
jmp 0x30d28
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0x27568
jmp 0x30d32
movq %rax, %r14
jmp 0x30d32
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0x27568
jmp 0x30d3e
movq %rax, %r14
jmp 0x30d3e
movq %rax, %r14
leaq 0x78(%rsp), %rdi
jmp 0x30d4e
movq %rax, %r14
jmp 0x30d0a
movq %rax, %r14
jmp 0x30d14
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x28538
leaq 0x20(%rsp), %rdi
callq 0x28538
leaq 0x58(%rsp), %rdi
callq 0x27568
leaq 0x78(%rsp), %rdi
callq 0x32740
leaq 0x30(%rsp), %rdi
callq 0x28538
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x28538
movq %rsp, %rdi
callq 0x32ae0
leaq 0xf8(%rsp), %rdi
callq 0x27568
movq %r14, %rdi
callq 0x27490
nop
|
/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 hopped more than one somewhere, so just reset
// delta to the next in sequence.
delta = current_address + 1;
new_address << std::hex << current_address;
c->unit_address = new_address.str();
}
}
}
|
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 # 0x3f764
movq %r13, %rdx
callq 0x2826c
addq $0x38, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x2823a
movl %eax, %r14d
movq %r12, %rdi
callq 0x27568
testb %r14b, %r14b
je 0x30f01
movq (%rbp), %rdi
addq $0x60, %rdi
xorl %esi, %esi
pushq $0x10
popq %rdx
callq 0x336ef
movl %eax, %r14d
movq %r12, %rdi
callq 0x27390
movl (%rbx), %eax
leal (%rax,%r14), %esi
addl %r14d, %eax
incl %eax
movl %eax, (%rbx)
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x38(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x38(%rsp,%rax)
movq %r12, %rdi
callq 0x27480
movq %r13, %rdi
leaq 0x28(%rsp), %rsi
callq 0x27420
movq (%rbp), %rdi
addq $0x60, %rdi
movq %r13, %rsi
callq 0x27350
movq %r13, %rdi
callq 0x27568
movq %r12, %rdi
callq 0x27090
addq $0x10, %rbp
jmp 0x30e4d
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30f1e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27090
movq %rbx, %rdi
callq 0x27490
nop
|
/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(val, strlen(val)));
text_input_buffer in(std::move(raw),
std::unordered_set<string>(),
std::vector<string>(),
string(),
nullptr);
property_ptr p = property::parse(in, std::move(name_copy), string_set(), false);
if (p)
defines[name] = p;
return (bool)p;
}
|
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
leaq 0xa0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x273a0
pushq $0x18
popq %rdi
callq 0x272a0
movq %rax, %r15
incq %r14
movq %r14, %rdi
callq 0x27130
leaq 0x1d2e9(%rip), %rcx # 0x4f258
movq %rcx, (%r15)
movq %r14, 0x8(%r15)
movl %eax, 0x10(%r15)
andl $0x0, 0x14(%r15)
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
leaq 0x78(%rsp), %r15
andq $0x0, -0x10(%r15)
movq %r15, -0x30(%r15)
movq $0x1, -0x28(%r15)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%r15)
movl $0x3f800000, -0x10(%r15) # imm = 0x3F800000
movups %xmm0, -0x8(%r15)
leaq 0x90(%rsp), %rax
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0xc0(%rsp), %rdi
leaq 0x48(%rsp), %rdx
leaq 0x80(%rsp), %r8
xorl %r9d, %r9d
callq 0x33760
leaq 0x80(%rsp), %rdi
callq 0x27568
leaq 0x10(%rsp), %rdi
callq 0x2b452
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x2b6fc
andq $0x0, 0x20(%r14)
movq %r15, (%r14)
movq $0x1, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movups %xmm0, 0x28(%r14)
leaq 0x10(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
leaq 0x48(%rsp), %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2cedc
leaq 0x48(%rsp), %rdi
callq 0x2b6fc
cmpq $0x0, 0x10(%rsp)
je 0x320e4
addq $0x1f0, %rbx # imm = 0x1F0
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x39ed6
leaq 0x10(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x33e50
cmpq $0x0, (%rbx)
setne %bl
jmp 0x320e6
cmpb $0x0, (%r15)
je 0x32133
leaq 0xc0(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r15, %rsi
callq 0x2826c
addq $0x1f0, %rbx # imm = 0x1F0
leaq 0xc0(%rsp), %rsi
movq %rbx, %rdi
callq 0x39ed6
leaq 0xc0(%rsp), %rdi
callq 0x27568
movb $0x1, %bl
jmp 0x32124
xorl %ebx, %ebx
leaq 0x18(%rsp), %rdi
callq 0x28538
leaq 0xc0(%rsp), %rdi
callq 0x338e0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3210d
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0xa0(%rsp), %rdi
callq 0x27568
leaq 0x28(%rsp), %rdi
callq 0x27568
movl %ebx, %eax
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
xorl %ebx, %ebx
jmp 0x32124
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
jmp 0x321c7
jmp 0x321ce
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x28538
jmp 0x32168
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2b6fc
leaq 0xc0(%rsp), %rdi
callq 0x338e0
jmp 0x3219b
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x27568
leaq 0x10(%rsp), %rdi
callq 0x2b452
leaq 0x48(%rsp), %rdi
callq 0x2b6fc
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x321b0
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x321b0
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x27568
jmp 0x321c2
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x27568
jmp 0x321d1
movq %rax, %rbx
movq %rbx, %rdi
callq 0x27490
nop
|
/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_reserve_map"));
for (auto &i : reservations)
{
reservation_writer.write_comment(string("Reservation start"));
reservation_writer.write_data(i.first);
reservation_writer.write_comment(string("Reservation length"));
reservation_writer.write_data(i.second);
}
// Write n spare reserve map entries, plus the trailing 0.
for (uint32_t i=0 ; i<=spare_reserve_map_entries ; i++)
{
reservation_writer.write_data((uint64_t)0);
reservation_writer.write_data((uint64_t)0);
}
struct_writer.write_comment(string("Device tree"));
struct_writer.write_label(string("dt_struct_start"));
root->write(struct_writer, st);
struct_writer.write_token(dtb::FDT_END);
struct_writer.write_label(string("dt_struct_end"));
st.write(strings_writer);
// Find the strings size before we stick padding on the end.
// Note: We should possibly use a new writer for the padding.
head.size_dt_strings = strings_writer.size();
// Stick the padding in the strings writer, but after the
// marker indicating that it's the end.
// Note: We probably should add a padding call to the writer so
// that the asm back end can write padding directives instead
// of a load of 0 bytes.
for (uint32_t i=0 ; i<blob_padding ; i++)
{
strings_writer.write_data((uint8_t)0);
}
head.totalsize = sizeof(head) + strings_writer.size() +
struct_writer.size() + reservation_writer.size();
while (head.totalsize < minimum_blob_size)
{
head.totalsize++;
strings_writer.write_data((uint8_t)0);
}
head.off_dt_struct = sizeof(head) + reservation_writer.size();;
head.off_dt_strings = head.off_dt_struct + struct_writer.size();
head.off_mem_rsvmap = sizeof(head);
head.boot_cpuid_phys = boot_cpu;
head.size_dt_struct = struct_writer.size();
head.write(head_writer);
head_writer.write_to_file(fd);
reservation_writer.write_to_file(fd);
struct_writer.write_to_file(fd);
strings_writer.write_label(string("dt_blob_end"));
strings_writer.write_to_file(fd);
}
|
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, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andl $0x0, 0x40(%rax)
xorps %xmm0, %xmm0
andl $0x0, 0xc4(%rsp)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
leaq 0x1beeb(%rip), %rax # 0x4f0e0
addq $0x10, %rax
movq %rax, 0xd0(%rsp)
movups %xmm0, 0xd8(%rsp)
movups %xmm0, 0xe8(%rsp)
movq %rax, 0x80(%rsp)
movups %xmm0, 0x88(%rsp)
movups %xmm0, 0x98(%rsp)
movq %rax, 0x30(%rsp)
movups %xmm0, 0x38(%rsp)
movups %xmm0, 0x48(%rsp)
movq %rax, 0x58(%rsp)
movups %xmm0, 0x60(%rsp)
movups %xmm0, 0x70(%rsp)
leaq 0xc6fe(%rip), %rsi # 0x3f94c
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x2826c
leaq 0x80(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x296d6
leaq 0x10(%rsp), %rdi
callq 0x27568
leaq 0xc6e0(%rip), %rsi # 0x3f960
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x2826c
leaq 0x80(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x29620
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x27568
movq 0x8(%r14), %r12
movq 0x10(%r14), %rbx
leaq 0xb(%rsp), %r13
leaq 0x80(%rsp), %rbp
cmpq %rbx, %r12
je 0x33331
movq %r15, %rdi
leaq 0xc69d(%rip), %rsi # 0x3f96f
movq %r13, %rdx
callq 0x2826c
movq %rbp, %rdi
movq %r15, %rsi
callq 0x296d6
movq %r15, %rdi
callq 0x27568
movq (%r12), %rsi
movq %rbp, %rdi
callq 0x297dc
movq %r15, %rdi
leaq 0xc67e(%rip), %rsi # 0x3f981
movq %r13, %rdx
callq 0x2826c
movq %rbp, %rdi
movq %r15, %rsi
callq 0x296d6
movq %r15, %rdi
callq 0x27568
movq 0x8(%r12), %rsi
movq %rbp, %rdi
callq 0x297dc
addq $0x10, %r12
jmp 0x332c3
xorl %r15d, %r15d
leaq 0x80(%rsp), %rbx
cmpl 0x22c(%r14), %r15d
ja 0x3335e
movq %rbx, %rdi
xorl %esi, %esi
callq 0x297dc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x297dc
incl %r15d
jmp 0x3333c
leaq 0xc62f(%rip), %rsi # 0x3f994
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x2826c
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x296d6
leaq 0x10(%rsp), %rdi
callq 0x27568
leaq 0xc60c(%rip), %rsi # 0x3f9a0
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x2826c
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x29620
leaq 0x10(%rsp), %rdi
callq 0x27568
movq 0x20(%r14), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xf8(%rsp), %rdx
callq 0x2e6fc
leaq 0x30(%rsp), %rdi
pushq $0x9
popq %rsi
callq 0x32938
leaq 0xc5ca(%rip), %rsi # 0x3f9b0
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x2826c
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x29620
leaq 0x10(%rsp), %rdi
callq 0x27568
leaq 0xf8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x29d42
leaq 0x58(%rsp), %rdi
callq 0x2989e
movl %eax, 0xc8(%rsp)
xorl %ebp, %ebp
leaq 0x58(%rsp), %rbx
cmpl 0x234(%r14), %ebp
jae 0x3344f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2975a
incl %ebp
jmp 0x33438
leaq 0x58(%rsp), %rdi
callq 0x2989e
movl %eax, %ebx
leaq 0x30(%rsp), %rdi
callq 0x2989e
movl %eax, %ebp
leaq 0x80(%rsp), %rdi
callq 0x2989e
addl %ebp, %ebx
leal (%rax,%rbx), %ebp
addl $0x28, %ebp
movl %ebp, 0xac(%rsp)
leaq 0x58(%rsp), %rbx
cmpl 0x230(%r14), %ebp
jae 0x334a6
incl %ebp
movl %ebp, 0xac(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2975a
jmp 0x33488
leaq 0x80(%rsp), %rdi
callq 0x2989e
movl %eax, %ebx
addl $0x28, %ebx
movl %ebx, 0xb0(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2989e
addl %ebx, %eax
movl %eax, 0xb4(%rsp)
movl $0x28, 0xb8(%rsp)
movl 0x228(%r14), %eax
movl %eax, 0xc4(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2989e
leaq 0xa8(%rsp), %rdi
movl %eax, 0x24(%rdi)
leaq 0xd0(%rsp), %rsi
callq 0x298a2
leaq 0xd0(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x29894
leaq 0x80(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x29894
leaq 0x30(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x29894
leaq 0xc47a(%rip), %rsi # 0x3f9be
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x2826c
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x29620
leaq 0x10(%rsp), %rdi
callq 0x27568
leaq 0x58(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x29894
leaq 0x58(%rsp), %rdi
callq 0x39cdc
leaq 0x30(%rsp), %rdi
callq 0x39cdc
leaq 0x80(%rsp), %rdi
callq 0x39cdc
leaq 0xd0(%rsp), %rdi
callq 0x39cdc
leaq 0xf8(%rsp), %rdi
callq 0x39c7c
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x335eb
jmp 0x335fc
jmp 0x335eb
jmp 0x335fc
jmp 0x335eb
jmp 0x335fc
jmp 0x335eb
jmp 0x335fc
jmp 0x335eb
jmp 0x335fc
jmp 0x335eb
jmp 0x335fc
jmp 0x335fc
jmp 0x335fc
jmp 0x335fc
jmp 0x335fc
jmp 0x335eb
jmp 0x335fc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x27568
jmp 0x335ff
jmp 0x335fc
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x39cdc
leaq 0x30(%rsp), %rdi
callq 0x39cdc
leaq 0x80(%rsp), %rdi
callq 0x39cdc
leaq 0xd0(%rsp), %rdi
callq 0x39cdc
leaq 0xf8(%rsp), %rdi
callq 0x39c7c
movq %rbx, %rdi
callq 0x27490
|
/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_to<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>>>>&&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, _IO_FILE*)
|
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.push(std::move(b));
}
|
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
callq 0x3370c
leaq 0xa8(%rbx), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x273a0
movq %rbp, 0xc8(%rbx)
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x34cfe
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x34acc
leaq 0x10(%rsp), %rdi
callq 0x28538
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq 0x10(%rsp), %rdi
callq 0x28538
jmp 0x33806
movq %rax, %r12
movq %r13, %rdi
callq 0x27568
jmp 0x33813
movq %rax, %r12
movq (%rsp), %rdi
callq 0x2b452
jmp 0x33821
movq %rax, %r12
movq %r14, %rdi
callq 0x34e76
jmp 0x3382e
movq %rax, %r12
movq %rbx, %rdi
callq 0x2b6fc
movq %r12, %rdi
callq 0x27490
|
/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
{
c = *(*this);
}
}
// Skip C preprocessor leftovers
if ((c == '#') && ((cursor == 0) || last_nl))
{
skip_to('\n');
skip_spaces();
}
if (consume("/include/"))
{
handle_include();
skip_spaces();
}
}
|
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
sete %cl
cmpb $0xa, %al
sete %r15b
orb %cl, %r15b
movq %rbx, %rdi
callq 0x3268c
movq %rbx, %rdi
callq 0x32d2e
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x3a2b7
jmp 0x3a2af
cmpl $0x20, %ecx
je 0x3a2c2
cmpl $0x23, %ecx
jne 0x3a315
cmpl $0x0, 0x38(%rbx)
setne %al
notb %r15b
testb %al, %r15b
jne 0x3a315
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3a254
movq %rbx, %rdi
callq 0x3a288
movq %rbx, %rdi
movq %r14, %rsi
callq 0x328c4
testb %al, %al
je 0x3a331
movq %rbx, %rdi
callq 0x3a33c
jmp 0x3a29c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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 * of */
while ((*self != '\0') && (*self != '*') && !finished())
{
++self;
}
// Eat the *
++self;
} while ((*self != '\0') && (*self != '/') && !finished());
// Eat the /
++self;
}
// Parse // comments
if ((*self == '/' && peek() == '/'))
{
// eat the start of the comment
++self;
++self;
// Find the ending of the line
while (*self != '\n' && !finished())
{
++self;
}
// Eat the \n
++self;
}
} while (start != cursor);
return self;
}
|
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
callq 0x3268c
movq %rbx, %rdi
callq 0x32660
testb %al, %al
je 0x3a6dd
movq %rbx, %rdi
callq 0x32660
cmpb $0x2a, %al
je 0x3a6dd
movq %rbx, %rdi
callq 0x32d2e
testb %al, %al
je 0x3a6b1
movq %rbx, %rdi
callq 0x3268c
movq %rbx, %rdi
callq 0x32660
testb %al, %al
je 0x3a709
movq %rbx, %rdi
callq 0x32660
cmpb $0x2f, %al
je 0x3a709
movq %rbx, %rdi
callq 0x32d2e
testb %al, %al
je 0x3a6b9
movq %rbx, %rdi
callq 0x3268c
movq %rbx, %rdi
callq 0x32660
cmpb $0x2f, %al
jne 0x3a759
movq %rbx, %rdi
callq 0x3c120
cmpb $0x2f, %al
jne 0x3a759
movq %rbx, %rdi
callq 0x3268c
movq %rbx, %rdi
callq 0x3268c
movq %rbx, %rdi
callq 0x32660
cmpb $0xa, %al
je 0x3a751
movq %rbx, %rdi
callq 0x32d2e
testb %al, %al
je 0x3a731
movq %rbx, %rdi
callq 0x3268c
movl 0x38(%rbx), %eax
cmpl %eax, %ebp
movl %eax, %ebp
jne 0x3a679
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/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), %rdi
leaq 0x5f72(%rip), %rsi # 0x407cf
movq %rax, %rdx
xorl %eax, %eax
jmp 0x273c0
nop
|
/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'. %s\n", path.c_str(), strerror(errno));
}
return 0;
}
struct stat st;
if (fstat(source, &st) == 0 && S_ISDIR(st.st_mode))
{
if (warn)
{
fprintf(stderr, "File %s is a directory\n", path.c_str());
}
close(source);
return 0;
}
std::unique_ptr<input_buffer> b(new mmap_input_buffer(source, string(path)));
close(source);
return b;
}
|
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, %xmm0
movups %xmm0, 0x8(%rax)
leaq 0x15368(%rip), %rax # 0x4fcc8
movq %rax, (%r14)
andq $0x0, 0x28(%r14)
leaq 0x18(%r14), %r12
movups %xmm0, 0x18(%r14)
movq 0x15630(%rip), %r13 # 0x4ffa8
leaq 0x28(%rsp), %r15
movq (%r13), %rdi
callq 0x27410
cmpl $-0x1, %eax
je 0x3a9ee
movb %al, 0x28(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x3618a
jmp 0x3a97d
movq (%r15), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x27220
cmpl $-0x1, %eax
je 0x3aa96
movl %eax, %ebp
leaq 0xb8(%rsp), %rsi
movl %eax, %edi
callq 0x27460
testl %eax, %eax
jne 0x3aa08
movl $0xf000, %eax # imm = 0xF000
andl 0xd0(%rsp), %eax
cmpl $0x4000, %eax # imm = 0x4000
jne 0x3aa08
testb %r14b, %r14b
jne 0x3aaf4
movl %ebp, %edi
callq 0x27550
jmp 0x3aa9b
movq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
movl 0x20(%r14), %ecx
subl %eax, %ecx
movl %ecx, 0x10(%r14)
movq %r14, (%rbx)
jmp 0x3aa9f
pushq $0x38
popq %rdi
callq 0x272a0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x273a0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
leaq 0x152d9(%rip), %rax # 0x4fd08
movq %rax, (%r14)
movq %r14, %rdi
addq $0x18, %rdi
leaq 0x8(%rsp), %rsi
callq 0x273a0
leaq 0x28(%rsp), %rsi
movl %ebp, %edi
callq 0x27460
testl %eax, %eax
jne 0x3aab4
movq 0x58(%rsp), %rax
movl %eax, 0x10(%r14)
movslq %eax, %rsi
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
xorl %edi, %edi
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x274b0
movq %rax, 0x8(%r14)
cmpq $-0x1, %rax
je 0x3ab14
movq %r14, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0x27568
movl %ebp, %edi
callq 0x27550
jmp 0x3aa9f
testb %r14b, %r14b
jne 0x3aac2
andq $0x0, (%rbx)
movq %rbx, %rax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5e37(%rip), %rdi # 0x408f2
callq 0x27250
jmp 0x3aa53
movq 0x154ef(%rip), %rax # 0x4ffb8
movq (%rax), %r14
movq (%r15), %r15
callq 0x27040
movl (%rax), %edi
callq 0x270d0
leaq 0x5d23(%rip), %rsi # 0x40805
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x273c0
jmp 0x3aa9b
movq 0x154bd(%rip), %rax # 0x4ffb8
movq (%rax), %rdi
movq (%r15), %rdx
leaq 0x5d1c(%rip), %rsi # 0x40824
xorl %eax, %eax
callq 0x273c0
jmp 0x3a9e2
leaq 0x5deb(%rip), %rdi # 0x40906
callq 0x27250
pushq $0x1
popq %rdi
callq 0x27340
movq %rax, %r15
movq %rbx, %rdi
callq 0x2b6ce
jmp 0x3ab61
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x27568
jmp 0x3ab47
movq %rax, %r15
pushq $0x38
jmp 0x3ab58
movq %rax, %r15
movq %r12, %rdi
callq 0x35d7c
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x272b0
movq %r15, %rdi
callq 0x27490
nop
|
/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(%rsi), %rcx
leaq 0x14430(%rip), %rdx # 0x4f258
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movl %edi, 0x10(%rax)
andl $0x0, 0x14(%rax)
retq
nop
|
/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 %edx, %r8d
jge 0x3aef6
cmpl $-0x2, %ecx
jg 0x3aef9
andq $0x0, (%rsi)
addl $0x2, %ecx
movl %ecx, 0x14(%rdi)
xorl %eax, %eax
retq
movq 0x8(%rdi), %rdx
movl %r8d, %r8d
movzbl (%rdx,%r8), %edx
addl $0x2, %ecx
movq %rdx, (%rsi)
movl %ecx, 0x14(%rdi)
cmpl $0x27, %edx
je 0x3aef8
cmpl $0x30, %edx
je 0x3af39
cmpl $0x5c, %edx
je 0x3aef8
cmpl $0x6e, %edx
je 0x3af34
cmpl $0x74, %edx
je 0x3af30
cmpl $0x72, %edx
jne 0x3aef6
pushq $0xd
jmp 0x3af36
pushq $0x9
jmp 0x3af36
pushq $0xa
popq %rcx
jmp 0x3af3b
xorl %ecx, %ecx
movq %rcx, (%rsi)
retq
nop
|
/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'...'9':
return consume_integer(outInt);
default:
return false;
}
}
|
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 $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b076
movq (%r15), %r14
testq %r14, %r14
je 0x3b04f
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movl %edx, %ebp
testb $0x1, %dl
je 0x3b044
movq %rax, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
jmp 0x3b051
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x27490
|
/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
movsbl %al, %edi
callq 0x3d43b
testb %al, %al
je 0x3c0aa
movslq 0x14(%rbx), %rax
xorl %edi, %edi
testq %rax, %rax
js 0x3c080
cmpl 0x10(%rbx), %eax
jge 0x3c080
movq 0x8(%rbx), %rcx
movsbl (%rcx,%rax), %edi
callq 0x3c0b1
movl %eax, %ebp
shll $0x4, %ebp
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3d41c
movsbl %al, %edi
callq 0x3c0b1
orl %ebp, %eax
movb %al, (%r14)
addl $0x2, 0x14(%rbx)
movb $0x1, %al
jmp 0x3c0ac
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
/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')
{
line_count++;
if (line_start == 0)
{
line_start = i+1;
}
}
}
for (int i=loc+1 ; i<b.size ; ++i)
{
if (b.buffer[i] == '\n')
{
line_end = i;
break;
}
}
fprintf(stderr, "Error at %s:%d:%d: %s\n", b.filename().c_str(), line_count, loc - line_start, msg);
fwrite(&b.buffer[line_start], line_end-line_start, 1, stderr);
putc('\n', stderr);
for (int i=0 ; i<(loc-line_start) ; ++i)
{
char c = (b.buffer[i+line_start] == '\t') ? '\t' : ' ';
putc(c, stderr);
}
putc('^', stderr);
putc('\n', stderr);
}
|
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
pushq $0x1
popq %rbp
xorl %r13d, %r13d
movq %rdx, %rsi
testq %rsi, %rsi
jle 0x3c1a8
leal 0x1(%rsi), %edi
testl %r13d, %r13d
cmovnel %r13d, %edi
xorl %r8d, %r8d
cmpb $0xa, (%rcx,%rsi)
sete %r8b
cmovel %edi, %r13d
addl %r8d, %ebp
decq %rsi
jmp 0x3c182
addq %rdx, %rcx
incq %rcx
movl %ebx, %r12d
incl %r12d
cmpl %r12d, %eax
jle 0x3c1c4
cmpb $0xa, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x3c1b1
jmp 0x3c1c7
movl %ebx, %r12d
movq 0x13dea(%rip), %rax # 0x4ffb8
movq (%rax), %rax
movq %rax, (%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq (%rax), %rdx
subl %r13d, %ebx
leaq 0x45f0(%rip), %rsi # 0x407da
movq (%rsp), %rdi
movl %ebp, %ecx
movl %ebx, %r8d
movq %r15, %r9
xorl %eax, %eax
callq 0x273c0
movl %r13d, %edi
addq 0x8(%r14), %rdi
subl %r13d, %r12d
movslq %r12d, %rsi
movq 0x13da7(%rip), %r12 # 0x4ffb8
movq (%r12), %rcx
pushq $0x1
popq %rdx
callq 0x27530
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x27520
movslq %r13d, %r15
movq %r12, %r13
testl %ebx, %ebx
movl $0x0, %eax
cmovlel %eax, %ebx
pushq $0x9
popq %rbp
pushq $0x20
popq %r12
subq $0x1, %rbx
jb 0x3c263
movq 0x8(%r14), %rax
cmpb $0x9, (%rax,%r15)
movl %r12d, %edi
cmovel %ebp, %edi
movq (%r13), %rsi
callq 0x27520
incq %r15
jmp 0x3c240
movq (%r13), %rsi
pushq $0x5e
popq %rdi
callq 0x27520
movq (%r13), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x27520
nop
|
/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) ; c=*(++(*this)))
{
bytes.push_back(c);
is_property = true;
}
return string(bytes.begin(), bytes.end());
}
|
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), %r12
leaq 0xf(%rsp), %r13
movb %al, 0xf(%rsp)
movsbl %al, %edi
callq 0x3c486
testb %al, %al
je 0x3c3f2
movq %r12, %rdi
movq %r13, %rsi
callq 0x326fa
movq %r14, %rdi
callq 0x3268c
movq %rax, %rdi
callq 0x32660
jmp 0x3c3c5
movq %r14, %rdi
callq 0x32660
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %r13
movb %al, 0xf(%rsp)
movsbl %al, %edi
callq 0x3c4a4
testb %al, %al
je 0x3c435
movq %r12, %rdi
movq %r13, %rsi
callq 0x326fa
movb $0x1, (%r15)
movq %r14, %rdi
callq 0x3268c
movq %rax, %rdi
callq 0x32660
jmp 0x3c404
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x35eca
leaq 0x10(%rsp), %rdi
callq 0x35d7c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3c471
jmp 0x3c471
jmp 0x3c471
jmp 0x3c471
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x35d7c
movq %rbx, %rdi
callq 0x27490
|
/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
retq
|
/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 0x3cb68
xorl %eax, %eax
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/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 0x3cd2e
xorl %eax, %eax
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/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 0x3ceb2
xorl %eax, %eax
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/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 %al, %eax
movb $0x1, %dl
jmp 0x3cfc4
xorl %eax, %eax
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/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 0x3d201
testb $0x1, %dl
je 0x3d201
testb $0x1, %bpl
je 0x3d201
testq %r14, %r14
cmoveq %rax, %rbx
movzbl %dl, %eax
movzbl %r15b, %edx
cmovel %eax, %edx
jmp 0x3d205
xorl %ebx, %ebx
xorl %edx, %edx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 %r14, %rdi
callq 0x27280
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x20(%rax)
nop
|
/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 '"':
case '\'':
case '\\':
break;
case 'a':
c = '\a';
break;
case 'b':
c = '\b';
break;
case 't':
c = '\t';
break;
case 'n':
c = '\n';
break;
case 'v':
c = '\v';
break;
case 'f':
c = '\f';
break;
case 'r':
c = '\r';
break;
case '0'...'7':
{
int v = digittoint(c);
if (i+1 < length && s[i+1] <= '7' && s[i+1] >= '0')
{
v <<= 3;
v |= digittoint(s[i+1]);
i++;
if (i+1 < length && s[i+1] <= '7' && s[i+1] >= '0')
{
v <<= 3;
v |= digittoint(s[i+1]);
}
}
c = (uint8_t)v;
break;
}
case 'x':
{
++i;
if (i >= length)
{
break;
}
int v = digittoint(s[i]);
if (i+1 < length && ishexdigit(s[i+1]))
{
v <<= 4;
v |= digittoint(s[++i]);
}
c = (uint8_t)v;
break;
}
}
}
buffer.push_back(c);
}
}
|
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, %r14b
je 0x3d6ee
cmpb $0x5c, %al
jne 0x3d6ee
leaq 0x1(%r12), %rbx
cmpq %r13, %rbx
jae 0x3d6ee
movzbl (%r15,%rbx), %edi
movb %dil, 0xf(%rsp)
leal -0x30(%rdi), %eax
cmpl $0x8, %eax
jb 0x3d708
leal -0x6e(%rdi), %eax
cmpl $0xa, %eax
ja 0x3d768
leaq 0x323e(%rip), %rcx # 0x4091c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0xa, 0xf(%rsp)
jmp 0x3d6f1
movq %r12, %rbx
movq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rsi
callq 0x29e24
incq %rbx
movq %rbx, %r12
jmp 0x3d691
callq 0x3d821
movl %eax, %ebp
leaq 0x2(%r12), %r14
cmpq %r13, %r14
jae 0x3d757
movzbl (%r15,%r14), %edi
movl %edi, %eax
andb $-0x8, %al
cmpb $0x30, %al
jne 0x3d757
movl %ebp, %ebx
shll $0x3, %ebx
callq 0x3d821
movl %eax, %ebp
orl %ebx, %ebp
addq $0x3, %r12
cmpq %r13, %r12
jae 0x3d754
movzbl (%r15,%r12), %edi
movl %edi, %eax
andb $-0x8, %al
cmpb $0x30, %al
jne 0x3d754
shll $0x3, %ebp
callq 0x3d821
orl %eax, %ebp
movq %r14, %rbx
movb %bpl, 0xf(%rsp)
movl 0x1c(%rsp), %r14d
movq 0x10(%rsp), %rbp
jmp 0x3d6f1
cmpl $0x66, %edi
je 0x3d7fe
cmpl $0x62, %edi
je 0x3d808
cmpl $0x61, %edi
jne 0x3d6f1
movb $0x7, 0xf(%rsp)
jmp 0x3d6f1
leaq 0x2(%r12), %rbx
cmpq %r13, %rbx
jae 0x3d6f1
movsbl 0x2(%r15,%r12), %edi
callq 0x3d821
movl %eax, %ebp
addq $0x3, %r12
cmpq %r13, %r12
jae 0x3d7d9
movsbl (%r15,%r12), %edi
callq 0x3d43b
testb %al, %al
je 0x3d7d9
shll $0x4, %ebp
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbl (%rax,%r12), %edi
callq 0x3d821
orl %eax, %ebp
movq %r12, %rbx
movb %bpl, 0xf(%rsp)
jmp 0x3d761
movb $0xb, 0xf(%rsp)
jmp 0x3d6f1
movb $0x9, 0xf(%rsp)
jmp 0x3d6f1
movb $0xd, 0xf(%rsp)
jmp 0x3d6f1
movb $0xc, 0xf(%rsp)
jmp 0x3d6f1
movb $0x8, 0xf(%rsp)
jmp 0x3d6f1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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;
case 'b': return 11;
case 'c': return 12;
case 'd': return 13;
case 'e': return 14;
case 'f': return 15;
}
}
|
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 0x3d88b
pushq $0x5
jmp 0x3d88b
pushq $0xe
jmp 0x3d88b
pushq $0x3
jmp 0x3d88b
pushq $0xc
jmp 0x3d88b
pushq $0x4
jmp 0x3d88b
pushq $0x8
jmp 0x3d88b
pushq $0xd
jmp 0x3d88b
pushq $0x2
jmp 0x3d88b
pushq $0xb
jmp 0x3d88b
pushq $0x6
jmp 0x3d88b
pushq $0xf
jmp 0x3d88b
pushq $0x7
jmp 0x3d88b
pushq $0x9
popq %rax
retq
xorl %eax, %eax
retq
|
/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, %rdi
callq 0x338bc
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x338bc
movq %rbx, %rdi
callq 0x27490
|
/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 %bpl, %bpl
je 0x3d944
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x3d970
movq (%r14), %rdi
callq 0x274e0
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x3d9f4
movq %rsp, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2826c
movq %r14, %rdi
callq 0x27330
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3d982
movq %rax, %rbx
movq %r14, %rdi
callq 0x27330
movq %rbx, %rdi
callq 0x27490
|
/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, %rdi
callq 0x338bc
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x338bc
movq %rbx, %rdi
callq 0x27490
|
/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 += EbmlElementSize(libwebm::kMkvCueBlockNumber,
static_cast<uint64>(block_number_));
const uint64_t track_pos_size =
EbmlMasterElementSize(libwebm::kMkvCueTrackPositions, size) + size;
const uint64_t payload_size =
EbmlElementSize(libwebm::kMkvCueTime, static_cast<uint64>(time_)) +
track_pos_size;
return payload_size;
}
|
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 = 0x5378
callq 0x2215b
addq %rax, %r14
movl $0xb7, %edi
movq %r14, %rsi
callq 0x2200e
movq %rax, %r15
movq (%rbx), %rsi
movl $0xb3, %edi
callq 0x2215b
addq %r14, %rax
addq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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), %rax
cmpq %rax, %r12
jl 0x1ab28
jmp 0x1ab5b
xorl %ebx, %ebx
movl $0x1c53bb6b, %edi # imm = 0x1C53BB6B
movq %rbx, %rsi
callq 0x2200e
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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 %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x64(%rbx)
leaq 0x22d7d(%rip), %rax # 0x3fa38
movq %rax, (%rbx)
movq %r14, 0x78(%rbx)
movq $0x1, 0x80(%rbx)
movq %r14, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 (WriteEdition(writer) == 0) // error
return false;
const int64_t stop = writer->Position();
if (stop >= start && uint64_t(stop - start) != payload_size)
return false;
return true;
}
|
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
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %r15
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1d940
testq %rax, %rax
je 0x1d92d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
subq %r15, %rax
setl %cl
cmpq %r14, %rax
sete %r15b
orb %cl, %r15b
jmp 0x1d930
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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::kMkvEditionEntry, payload_size) +
payload_size;
if (writer == NULL) // return size only
return edition_size;
const int64_t start = writer->Position();
if (!WriteEbmlMasterElement(writer, libwebm::kMkvEditionEntry, payload_size))
return 0; // error
for (int idx = 0; idx < chapters_count_; ++idx) {
const Chapter& chapter = chapters_[idx];
const uint64_t chapter_size = chapter.WriteAtom(writer);
if (chapter_size == 0) // error
return 0;
}
const int64_t stop = writer->Position();
if (stop >= start && uint64_t(stop - start) != edition_size)
return 0;
return edition_size;
}
|
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 $0x30, %r15
cmpq %rax, %r12
jl 0x1d960
jmp 0x1d986
xorl %r13d, %r13d
movl $0x45b9, %edi # imm = 0x45B9
movq %r13, %rsi
callq 0x2200e
movq %rax, %r15
addq %r13, %r15
testq %rbx, %rbx
je 0x1da12
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %r12
movl $0x45b9, %esi # imm = 0x45B9
movq %rbx, %rdi
movq %r13, %rdx
callq 0x22791
testb %al, %al
je 0x1da0f
cmpl $0x0, 0x4(%r14)
jle 0x1d9ee
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%r14), %rdi
addq %r13, %rdi
movq %rbx, %rsi
callq 0x1d478
testq %rax, %rax
je 0x1da0f
incq %rbp
movslq 0x4(%r14), %rax
addq $0x30, %r13
cmpq %rax, %rbp
jl 0x1d9ca
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %rcx
subq %r12, %rcx
xorl %edx, %edx
cmpq %r15, %rcx
cmoveq %r15, %rdx
cmpq %r12, %rax
cmovgeq %rdx, %r15
jmp 0x1da12
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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) {
QTC::TC("libtests", "JSON 16 high high");
throw std::runtime_error(
"JSON: offset " + std::to_string(new_high_offset) +
": UTF-16 high surrogate found after previous high surrogate at offset " +
std::to_string(high_offset));
}
high_offset = new_high_offset;
high_surrogate = codepoint;
} else if ((codepoint & 0xFC00) == 0xDC00) {
// low surrogate
if (offset != (high_offset + 6)) {
QTC::TC("libtests", "JSON 16 low not after high");
throw std::runtime_error(
"JSON: offset " + std::to_string(offset) +
": UTF-16 low surrogate found not immediately after high surrogate");
}
high_offset = 0;
codepoint = 0x10000U + ((high_surrogate & 0x3FFU) << 10U) + (codepoint & 0x3FF);
result += QUtil::toUTF8(codepoint);
} else {
result += QUtil::toUTF8(codepoint);
}
}
|
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), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2d5dd
leaq 0x2e028d(%rip), %rdi # 0x30d6cf
leaq 0x2e0d52(%rip), %rsi # 0x30e19b
xorl %edx, %edx
callq 0x25230
movb $0x1, -0xe1(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x198(%rbp)
movq -0x30(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x242b0
jmp 0x2d47a
leaq 0x2e090a(%rip), %rsi # 0x30dd8b
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
callq 0x1ea00
jmp 0x2d496
leaq 0x2e0d10(%rip), %rdx # 0x30e1ad
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1e9b0
jmp 0x2d4af
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0xe0(%rbp), %rdi
callq 0x242b0
jmp 0x2d4c4
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0x1e8e0
jmp 0x2d4da
movq -0x198(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1b430
jmp 0x2d4ec
movq -0x198(%rbp), %rdi
movb $0x0, -0xe1(%rbp)
movq 0x463a8f(%rip), %rsi # 0x490f90
movq 0x463a58(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x2d85a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x2d5c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x2d5b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x2d5a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x2d5a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x2d594
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c1e8
leaq -0xe0(%rbp), %rdi
callq 0x1c1e8
leaq -0x70(%rbp), %rdi
callq 0x1c1e8
leaq -0x90(%rbp), %rdi
callq 0x1c1e8
leaq -0xb0(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0xe1(%rbp)
jne 0x2d5cc
jmp 0x2d5d8
movq -0x198(%rbp), %rdi
callq 0x1bcf0
jmp 0x2d84e
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2d845
movq -0x8(%rbp), %rax
andq $0xfc00, %rax # imm = 0xFC00
cmpq $0xdc00, %rax # imm = 0xDC00
jne 0x2d7ec
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
addq $0x6, %rcx
cmpq %rcx, %rax
je 0x2d766
leaq 0x2e00a2(%rip), %rdi # 0x30d6cf
leaq 0x2e0bc0(%rip), %rsi # 0x30e1f4
xorl %edx, %edx
callq 0x25230
movb $0x1, -0x149(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x1a0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x148(%rbp), %rdi
callq 0x242b0
jmp 0x2d665
leaq 0x2e071f(%rip), %rsi # 0x30dd8b
leaq -0x128(%rbp), %rdi
leaq -0x148(%rbp), %rdx
callq 0x1ea00
jmp 0x2d681
leaq 0x2e0b87(%rip), %rdx # 0x30e20f
leaq -0x108(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x1e9b0
jmp 0x2d69d
movq -0x1a0(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x1b430
jmp 0x2d6b2
movq -0x1a0(%rbp), %rdi
movb $0x0, -0x149(%rbp)
movq 0x4638c9(%rip), %rsi # 0x490f90
movq 0x463892(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x2d85a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x2d74a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x2d73e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x2d732
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x1c1e8
leaq -0x128(%rbp), %rdi
callq 0x1c1e8
leaq -0x148(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x149(%rbp)
jne 0x2d755
jmp 0x2d761
movq -0x1a0(%rbp), %rdi
callq 0x1bcf0
jmp 0x2d84e
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x3ff, %eax # imm = 0x3FF
shll $0xa, %eax
movq -0x8(%rbp), %rcx
andl $0x3ff, %ecx # imm = 0x3FF
leaq 0x10000(%rax,%rcx), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x2b1750
movq -0x1a8(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x1b0f0
jmp 0x2d7be
leaq -0x170(%rbp), %rdi
callq 0x1c1e8
jmp 0x2d843
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x1c1e8
jmp 0x2d84e
movq -0x8(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x2b1750
movq -0x1b0(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x1b0f0
jmp 0x2d815
leaq -0x190(%rbp), %rdi
callq 0x1c1e8
jmp 0x2d843
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x1c1e8
jmp 0x2d84e
jmp 0x2d845
addq $0x1b0, %rsp # imm = 0x1B0
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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 node in insertFirst");
error(qpdf, this->oh, "unable to find a valid items node");
}
items.insertItem(0, key);
items.insertItem(1, value);
iter.setItemNumber(iter.node, 0);
iter.resetLimits(iter.node, iter.lastPathElement());
iter.split(iter.node, iter.lastPathElement());
return iter;
}
|
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 $0x0, -0x21(%rbp)
callq 0x40080
leaq -0x38(%rbp), %rdi
callq 0x42ac0
movq -0xc0(%rbp), %rdi
addq $0x28, %rdi
callq 0x1c0130
movb %al, -0xb1(%rbp)
jmp 0x3f15f
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x3f16b
jmp 0x3f1da
movq -0xc8(%rbp), %rax
movq -0xc0(%rbp), %rcx
addq $0x28, %rcx
movq %rcx, -0xf0(%rbp)
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, -0xe8(%rbp)
jmp 0x3f198
movq -0xe8(%rbp), %rdx
movq -0xf0(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x231400
jmp 0x3f1b1
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x42b50
leaq -0x58(%rbp), %rdi
callq 0x23380
jmp 0x3f1da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3f3f1
leaq -0x38(%rbp), %rdi
callq 0x1c0100
movb %al, -0xf1(%rbp)
jmp 0x3f1eb
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x3f2b6
jmp 0x3f1fb
leaq 0x2f2d36(%rip), %rdi # 0x331f38
leaq 0x2cfcd9(%rip), %rsi # 0x30eee2
xorl %edx, %edx
callq 0x25230
jmp 0x3f212
movq -0xc8(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x110(%rbp)
addq $0x18, %rax
movq %rax, -0x108(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x1be40
movq -0x100(%rbp), %rdx
leaq 0x2cfcbf(%rip), %rsi # 0x30ef0c
leaq -0x78(%rbp), %rdi
callq 0x21b70
jmp 0x3f258
movq -0x108(%rbp), %rsi
movq -0x110(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x3b6a0
jmp 0x3f271
leaq -0x78(%rbp), %rdi
callq 0x1c1e8
leaq -0x79(%rbp), %rdi
callq 0x1c1d0
jmp 0x3f2b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3f2a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1c1e8
leaq -0x79(%rbp), %rdi
callq 0x1c1d0
jmp 0x3f3f1
movq -0xd8(%rbp), %rdx
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x22c270
jmp 0x3f2ca
movq -0xe0(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x22c270
jmp 0x3f2e1
movq -0xc0(%rbp), %rdi
movq %rdi, %rsi
addq $0x28, %rsi
xorl %edx, %edx
callq 0x3cee0
jmp 0x3f2f8
movq -0xc0(%rbp), %rsi
addq $0x28, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x42b80
movq -0xc0(%rbp), %rdi
callq 0x3eb70
movq -0xc0(%rbp), %rdi
movq -0x118(%rbp), %rsi
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdx
callq 0x3cf30
jmp 0x3f345
leaq -0x90(%rbp), %rdi
callq 0x23380
movq -0xc0(%rbp), %rsi
addq $0x28, %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x42b80
movq -0xc0(%rbp), %rdi
callq 0x3eb70
movq -0xc0(%rbp), %rdi
movq -0x120(%rbp), %rsi
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdx
callq 0x3de10
jmp 0x3f39e
leaq -0xa8(%rbp), %rdi
callq 0x23380
movb $0x1, -0x21(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x23380
testb $0x1, -0x21(%rbp)
jne 0x3f414
jmp 0x3f408
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x23380
jmp 0x3f3f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x23380
leaq -0x38(%rbp), %rdi
callq 0x23380
movq -0xc0(%rbp), %rdi
callq 0x42de0
jmp 0x3f424
movq -0xc0(%rbp), %rdi
callq 0x42de0
movq -0xd0(%rbp), %rax
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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,
this->oh,
("item at index " + std::to_string(2 * idx) + " is not the right type"));
}
return details.compareKeys(key, items.getArrayItem(2 * idx));
}
|
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 %al, -0xc9(%rbp)
jne 0x40913
jmp 0x4098a
movq -0x18(%rbp), %rdi
callq 0x22b1c0
movl %eax, %ecx
movl -0x1c(%rbp), %edx
shll %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0xc9(%rbp)
jle 0x4098a
movq -0xd8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xf0(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
addl %edx, %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x22b300
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movb $0x1, -0x31(%rbp)
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movb %al, -0xd9(%rbp)
jmp 0x4097c
movb -0xd9(%rbp), %al
movb %al, -0xc9(%rbp)
jmp 0x4098a
movb -0xc9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xf1(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x409a0
jmp 0x409a9
leaq -0x30(%rbp), %rdi
callq 0x23380
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x409b8
jmp 0x40ae3
leaq 0x2f1579(%rip), %rdi # 0x331f38
leaq 0x2ce3f6(%rip), %rsi # 0x30edbc
xorl %edx, %edx
callq 0x25230
movq -0xd8(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x110(%rbp)
addq $0x18, %rax
movq %rax, -0x108(%rbp)
movl -0x1c(%rbp), %esi
addl %esi, %esi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x243e0
movq -0x100(%rbp), %rdx
leaq 0x2ce3c6(%rip), %rsi # 0x30edd6
leaq -0x88(%rbp), %rdi
callq 0x1ea00
jmp 0x40a1e
leaq 0x2ce3c0(%rip), %rdx # 0x30ede5
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1e9b0
jmp 0x40a37
movq -0x108(%rbp), %rsi
movq -0x110(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x3b6a0
jmp 0x40a50
leaq -0x68(%rbp), %rdi
callq 0x1c1e8
leaq -0x88(%rbp), %rdi
callq 0x1c1e8
leaq -0xa8(%rbp), %rdi
callq 0x1c1e8
jmp 0x40ae3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x40a87
jmp 0x40a90
leaq -0x30(%rbp), %rdi
callq 0x23380
jmp 0x40b9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x40ad2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x40ac6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c1e8
leaq -0x88(%rbp), %rdi
callq 0x1c1e8
leaq -0xa8(%rbp), %rdi
callq 0x1c1e8
jmp 0x40b9a
movq -0xd8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x118(%rbp)
movq -0x10(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x42b80
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
addl %edx, %edx
leaq -0xc8(%rbp), %rdi
callq 0x22b300
jmp 0x40b1b
movq -0x118(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0xb8(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq *%rax
movl %eax, -0x11c(%rbp)
jmp 0x40b41
leaq -0xc8(%rbp), %rdi
callq 0x23380
leaq -0xb8(%rbp), %rdi
callq 0x23380
movl -0x11c(%rbp), %eax
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x40b8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x23380
leaq -0xb8(%rbp), %rdi
callq 0x23380
movq -0x40(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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
callq 0x21b70
jmp 0x42944
leaq -0x12(%rbp), %rdi
callq 0x1c1d0
movq -0x10(%rbp), %rdi
callq 0x1c1bf0
movb %al, -0xa1(%rbp)
jmp 0x4295e
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x4296d
jmp 0x42a63
movq -0x10(%rbp), %rdi
callq 0x1ca280
movl %eax, -0xa8(%rbp)
jmp 0x4297e
movl -0xa8(%rbp), %esi
leaq -0x88(%rbp), %rdi
callq 0x243e0
jmp 0x42992
leaq 0x2cc612(%rip), %rsi # 0x30efab
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x1ea00
jmp 0x429ab
leaq 0x2ebe8e(%rip), %rdx # 0x32e840
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1e9b0
jmp 0x429c1
movq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1b0f0
jmp 0x429d3
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x68(%rbp), %rdi
callq 0x1c1e8
leaq -0x88(%rbp), %rdi
callq 0x1c1e8
jmp 0x42a63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x1c1d0
jmp 0x42a95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x42a89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x42a55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x42a4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x68(%rbp), %rdi
callq 0x1c1e8
leaq -0x88(%rbp), %rdi
callq 0x1c1e8
jmp 0x42a89
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x42a79
movq -0x98(%rbp), %rdi
callq 0x1c1e8
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x1c1e8
movq -0x20(%rbp), %rdi
callq 0x1b960
nop
|
/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::numeric_limits<qpdf_offset_t>::max() - global_offset;
}
|
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 $0xa8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x45f80
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0xb8(%rax)
cmpq $0x0, -0x18(%rbp)
jge 0x45ac1
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x2c954a(%rip), %rsi # 0x30efc6
callq 0x1bbe0
jmp 0x45a83
movq -0x48(%rbp), %rdi
movq 0x44b552(%rip), %rsi # 0x490fe0
movq 0x44b523(%rip), %rdx # 0x490fb8
callq 0x1b920
jmp 0x45af9
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bcf0
jmp 0x45ade
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x45ade
callq 0x20df0
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq -0x18(%rbp), %rcx
movq %rcx, 0xc0(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x45fb0
movq -0x30(%rbp), %rdi
callq 0x20d90
movq -0x20(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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("Attempt to create Pl_AES_PDF with nullptr as next");
}
if (!(key_bytes == 32 || key_bytes == 16)) {
throw std::runtime_error("unsupported key length");
}
this->key = std::make_unique<unsigned char[]>(key_bytes);
std::memcpy(this->key.get(), key, key_bytes);
std::memset(this->inbuf, 0, this->buf_size);
std::memset(this->outbuf, 0, this->buf_size);
std::memset(this->cbc_block, 0, this->buf_size);
}
|
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 -0x58(%rbp), %rdi
leaq 0x44422d(%rip), %rax # 0x48af90
movq %rax, (%rdi)
addq $0x30, %rdi
movq %rdi, -0x50(%rbp)
callq 0xcef20
jmp 0x46d75
movq -0x58(%rbp), %rdi
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, 0x40(%rdi)
movb $0x1, 0x41(%rdi)
movb $0x1, 0x42(%rdi)
movq $0x0, 0x48(%rdi)
addq $0x50, %rdi
movq %rdi, -0x60(%rbp)
callq 0x476a0
movq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x58(%rax)
movb $0x0, 0xa0(%rax)
movb $0x0, 0xa1(%rax)
movb $0x0, 0xa2(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x46e40
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
leaq 0x2c82d9(%rip), %rsi # 0x30f0ba
callq 0x1bbe0
jmp 0x46de8
movq -0x68(%rbp), %rdi
movq 0x44a1ed(%rip), %rsi # 0x490fe0
movq 0x44a1be(%rip), %rdx # 0x490fb8
callq 0x1b920
jmp 0x46f55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x46f43
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x1bcf0
jmp 0x46f31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x46f31
cmpq $0x20, -0x30(%rbp)
je 0x46ea6
cmpq $0x10, -0x30(%rbp)
je 0x46ea6
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0x2c8283(%rip), %rsi # 0x30f0ec
callq 0x1b400
jmp 0x46e70
movq -0x70(%rbp), %rdi
movq 0x44a115(%rip), %rsi # 0x490f90
movq 0x44a0de(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x46f55
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x1bcf0
jmp 0x46f31
movq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x476d0
jmp 0x46eb5
movq -0x58(%rbp), %rdi
addq $0x50, %rdi
leaq -0x48(%rbp), %rsi
callq 0x47730
leaq -0x48(%rbp), %rdi
callq 0x47760
movq -0x58(%rbp), %rdi
addq $0x50, %rdi
callq 0x477b0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1b0d0
movq -0x58(%rbp), %rdi
addq $0x60, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1b4c0
movq -0x58(%rbp), %rdi
addq $0x70, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1b4c0
movq -0x58(%rbp), %rdi
addq $0x80, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1b4c0
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x47760
movq -0x50(%rbp), %rdi
callq 0x23540
movq -0x58(%rbp), %rdi
callq 0x1e230
movq -0x38(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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 = (bytes_left < available ? bytes_left : available);
bytes_left -= bytes;
std::memcpy(this->inbuf + this->offset, p, bytes);
this->offset += bytes;
p += 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, 0x48(%rax)
jne 0x4712d
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x471c0
movq -0x40(%rbp), %rcx
movl $0x10, %eax
subq 0x48(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x47152
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x4715a
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rcx
subq %rdx, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, %rdi
addq $0x60, %rdi
addq 0x48(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1b0d0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
addq 0x48(%rax), %rcx
movq %rcx, 0x48(%rax)
movq -0x38(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x4710c
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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 padding if the input was a multiple of 16 bytes.
unsigned char pad = QIntC::to_uchar(this->buf_size - this->offset);
memset(this->inbuf + this->offset, pad, pad);
this->offset = this->buf_size;
flush(false);
}
} else {
if (this->offset != this->buf_size) {
// This is never supposed to happen as the output is always supposed to be padded.
// However, we have encountered files for which the output is not a multiple of the
// block size. In this case, pad with zeroes and hope for the best.
if (this->offset >= this->buf_size) {
throw std::logic_error("buffer overflow in AES encryption pipeline");
}
std::memset(this->inbuf + this->offset, 0, this->buf_size - this->offset);
this->offset = this->buf_size;
}
flush(!this->disable_padding);
}
this->crypto->rijndael_finalize();
next()->finish();
}
|
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 -0x30(%rbp), %rcx
movl $0x10, %eax
subq 0x48(%rcx), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x477e0
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, -0x9(%rbp)
movq %rax, %rdi
addq $0x60, %rdi
addq 0x48(%rax), %rdi
movzbl -0x9(%rbp), %eax
movzbl -0x9(%rbp), %ecx
movl %ecx, %edx
movzbl %al, %esi
callq 0x1b4c0
movq -0x30(%rbp), %rdi
movq $0x10, 0x48(%rdi)
xorl %esi, %esi
callq 0x471c0
jmp 0x47581
movq -0x30(%rbp), %rax
cmpq $0x10, 0x48(%rax)
je 0x4756a
movq -0x30(%rbp), %rax
cmpq $0x10, 0x48(%rax)
jb 0x4753f
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x2c7c3c(%rip), %rsi # 0x30f146
callq 0x1bbe0
jmp 0x47511
movq -0x38(%rbp), %rdi
movq 0x449ac4(%rip), %rsi # 0x490fe0
movq 0x449a95(%rip), %rdx # 0x490fb8
callq 0x1b920
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bcf0
jmp 0x475b2
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x60, %rdi
addq 0x48(%rax), %rdi
movl $0x10, %edx
subq 0x48(%rax), %rdx
xorl %esi, %esi
callq 0x1b4c0
movq -0x30(%rbp), %rax
movq $0x10, 0x48(%rax)
movq -0x30(%rbp), %rdi
movb 0xa2(%rdi), %al
xorb $-0x1, %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x471c0
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x23520
movq %rax, %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq -0x30(%rbp), %rdi
callq 0x47800
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1b960
nopl (%rax,%rax)
|
/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 std::range_error(msg.str());
}
|
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), %rsi
leaq -0x188(%rbp), %rdi
callq 0x1b7a0
jmp 0x47e3f
leaq -0x188(%rbp), %rdi
callq 0x1be70
leaq 0x2c527f(%rip), %rsi # 0x30d0d1
leaq -0x180(%rbp), %rdi
callq 0x1b860
movq %rax, -0x1d8(%rbp)
jmp 0x47e67
movq -0x1d8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1bf60
movq %rax, -0x1e0(%rbp)
jmp 0x47e80
movq -0x1e0(%rbp), %rdi
leaq 0x2c5264(%rip), %rsi # 0x30d0f2
callq 0x1b860
movq %rax, -0x1e8(%rbp)
jmp 0x47e9c
movq -0x1e8(%rbp), %rdi
movl $0x8, %esi
callq 0x1bf60
movq %rax, -0x1f0(%rbp)
jmp 0x47eb6
movq -0x1f0(%rbp), %rdi
leaq 0x2c5237(%rip), %rsi # 0x30d0fb
callq 0x1b860
movq %rax, -0x1f8(%rbp)
jmp 0x47ed2
movq -0x1f8(%rbp), %rdi
movl $0x1, %esi
callq 0x1bf60
movq %rax, -0x200(%rbp)
jmp 0x47eec
movq -0x200(%rbp), %rdi
leaq 0x2c521b(%rip), %rsi # 0x30d115
callq 0x1b860
jmp 0x47f01
movb $0x1, -0x1b9(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x208(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x1c130
jmp 0x47f2e
movq -0x208(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x1c1c0
jmp 0x47f43
movq -0x208(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
movq 0x449080(%rip), %rsi # 0x490fd8
movq 0x448fa1(%rip), %rdx # 0x490f00
callq 0x1b920
jmp 0x47fdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x47fc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x47fac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x1b9(%rbp)
jne 0x47fb7
jmp 0x47fc3
movq -0x208(%rbp), %rdi
callq 0x1bcf0
jmp 0x47fc5
leaq -0x180(%rbp), %rdi
callq 0x1bd20
movq -0x190(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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_dest)));
auto* dest = reinterpret_cast<dct_pipeline_dest*>(cinfo->dest);
dest->pub.init_destination = init_pipeline_destination;
dest->pub.empty_output_buffer = empty_pipeline_output_buffer;
dest->pub.term_destination = term_pipeline_destination;
dest->pub.next_output_byte = dest->buffer = outbuffer;
dest->pub.free_in_buffer = dest->size = size;
dest->next = next;
}
|
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(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
leaq 0x34e(%rip), %rcx # 0x4c050
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
leaq 0x34f(%rip), %rcx # 0x4c060
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
leaq 0x3c0(%rip), %rcx # 0x4c0e0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
/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;
src->init_source = init_buffer_source;
src->fill_input_buffer = fill_buffer_input_buffer;
src->skip_input_data = skip_buffer_input_data;
src->resync_to_restart = jpeg_resync_to_restart; /* use default method */
src->term_source = term_buffer_source;
src->bytes_in_buffer = buffer->getSize();
src->next_input_byte = buffer->getBuffer();
}
|
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
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x396(%rip), %rcx # 0x4c140
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
leaq 0x397(%rip), %rcx # 0x4c150
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
leaq 0x3f8(%rip), %rcx # 0x4c1c0
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x445149(%rip), %rcx # 0x490f20
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
leaq 0x4da(%rip), %rcx # 0x4c2c0
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0x1fa60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x1faa0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%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";
longjmp(jerr->jmpbuf, 1);
}
}
|
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 # imm = 0x170
leaq 0x2c38d6(%rip), %rsi # 0x30f73b
callq 0x1b5c0
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
movl $0x1, %esi
callq 0x1ba00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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 <= cinfo->src->bytes_in_buffer)) {
cinfo->src->next_input_byte += to_skip;
cinfo->src->bytes_in_buffer -= to_skip;
} else if (to_skip != 0) {
cinfo->src->next_input_byte += cinfo->src->bytes_in_buffer;
cinfo->src->bytes_in_buffer = 0;
}
}
|
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), %rsi # 0x490f90
movq 0x444d55(%rip), %rdx # 0x490f60
callq 0x1b920
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1bcf0
jmp 0x4c2b4
leaq -0x10(%rbp), %rdi
callq 0x25250
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x4c27b
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpq 0x8(%rcx), %rax
ja 0x4c27b
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
jmp 0x4c2ae
cmpq $0x0, -0x28(%rbp)
je 0x4c2ac
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq $0x0, 0x8(%rax)
jmp 0x4c2ae
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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)
movl $0x1, 0x4c(%rax)
movq $0x0, 0x50(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%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 std::range_error(msg.str());
}
|
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), %rsi
leaq -0x188(%rbp), %rdi
callq 0x1b7a0
jmp 0x4d18e
leaq -0x188(%rbp), %rdi
callq 0x1be70
leaq 0x2bff30(%rip), %rsi # 0x30d0d1
leaq -0x180(%rbp), %rdi
callq 0x1b860
movq %rax, -0x1d8(%rbp)
jmp 0x4d1b6
movq -0x1d8(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x1bbb0
movq %rax, -0x1e0(%rbp)
jmp 0x4d1ce
movq -0x1e0(%rbp), %rdi
leaq 0x2bff16(%rip), %rsi # 0x30d0f2
callq 0x1b860
movq %rax, -0x1e8(%rbp)
jmp 0x4d1ea
movq -0x1e8(%rbp), %rdi
movl $0x4, %esi
callq 0x1bf60
movq %rax, -0x1f0(%rbp)
jmp 0x4d204
movq -0x1f0(%rbp), %rdi
leaq 0x2bfee9(%rip), %rsi # 0x30d0fb
callq 0x1b860
movq %rax, -0x1f8(%rbp)
jmp 0x4d220
movq -0x1f8(%rbp), %rdi
movl $0x8, %esi
callq 0x1bf60
movq %rax, -0x200(%rbp)
jmp 0x4d23a
movq -0x200(%rbp), %rdi
leaq 0x2bfecd(%rip), %rsi # 0x30d115
callq 0x1b860
jmp 0x4d24f
movb $0x1, -0x1b9(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x208(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x1c130
jmp 0x4d27c
movq -0x208(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x1c1c0
jmp 0x4d291
movq -0x208(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
movq 0x443d32(%rip), %rsi # 0x490fd8
movq 0x443c53(%rip), %rdx # 0x490f00
callq 0x1b920
jmp 0x4d32b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x4d313
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x4d2fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x1b9(%rbp)
jne 0x4d305
jmp 0x4d311
movq -0x208(%rbp), %rdi
callq 0x1bcf0
jmp 0x4d313
leaq -0x180(%rbp), %rdi
callq 0x1bd20
movq -0x190(%rbp), %rdi
callq 0x1b960
nopl (%rax,%rax)
|
/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 in
// Pl_Flate.hh. This means people using shared library versions of qpdf don't have to have zlib
// development files available, which particularly helps in a Windows environment.
this->zdata = new z_stream;
if (out_bufsize > UINT_MAX) {
throw std::runtime_error(
"Pl_Flate: zlib doesn't support buffer sizes larger than unsigned int");
}
z_stream& zstream = *(static_cast<z_stream*>(this->zdata));
zstream.zalloc = nullptr;
zstream.zfree = nullptr;
zstream.opaque = nullptr;
zstream.next_in = nullptr;
zstream.avail_in = 0;
zstream.next_out = this->outbuf.get();
zstream.avail_out = QIntC::to_uint(out_bufsize);
if (action == a_deflate && Pl_Flate::zopfli_enabled()) {
zopfli_buf = std::make_unique<std::string>();
}
}
|
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(%rdi)
movb $0x0, 0x1c(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
addq $0x30, %rdi
movq %rdi, -0x60(%rbp)
callq 0x4ec00
movq -0x58(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x50(%rbp)
callq 0x4ec40
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4ec70
jmp 0x4d69d
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movq %rsi, -0x78(%rbp)
callq 0x4ecb0
movq -0x78(%rbp), %rdi
callq 0x4ece0
movl $0x70, %edi
callq 0x1b250
movq %rax, -0x70(%rbp)
jmp 0x4d6c7
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, -0x10(%rbp)
jbe 0x4d747
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
leaq 0x2c2131(%rip), %rsi # 0x30f82a
callq 0x1b400
jmp 0x4d700
movq -0x80(%rbp), %rdi
movq 0x443885(%rip), %rsi # 0x490f90
movq 0x44384e(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x4d82c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x4d808
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x1bcf0
jmp 0x4d808
movq -0x68(%rbp), %rdi
movq 0x20(%rdi), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x40(%rbp), %rax
movq $0x0, (%rax)
movq -0x40(%rbp), %rax
movl $0x0, 0x8(%rax)
callq 0x4ed00
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq -0x10(%rbp), %rdi
callq 0x1e8a0
movl %eax, -0x84(%rbp)
jmp 0x4d7ae
movl -0x84(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x20(%rax)
cmpl $0x1, -0x14(%rbp)
jne 0x4d7ff
callq 0x4d830
movb %al, -0x85(%rbp)
jmp 0x4d7ce
movb -0x85(%rbp), %al
testb $0x1, %al
jne 0x4d7da
jmp 0x4d7ff
leaq -0x48(%rbp), %rdi
callq 0x4ed20
jmp 0x4d7e5
movq -0x68(%rbp), %rdi
addq $0x50, %rdi
leaq -0x48(%rbp), %rsi
callq 0x4ed70
leaq -0x48(%rbp), %rdi
callq 0x4eda0
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4eda0
movq -0x60(%rbp), %rdi
callq 0x4edf0
movq -0x58(%rbp), %rdi
callq 0x4ece0
movq -0x30(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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 0x1be40
movq -0x68(%rbp), %rdx
leaq 0x2c2185(%rip), %rsi # 0x30fa0e
leaq -0x48(%rbp), %rdi
callq 0x21b70
jmp 0x4d894
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2b0430
movb %al, -0x69(%rbp)
jmp 0x4d8a6
movb -0x69(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x6a(%rbp)
jne 0x4d8b5
jmp 0x4d8d2
leaq 0x2c215e(%rip), %rsi # 0x30fa1a
leaq -0x28(%rbp), %rdi
callq 0x385e0
movb %al, -0x6b(%rbp)
jmp 0x4d8ca
movb -0x6b(%rbp), %al
movb %al, -0x6a(%rbp)
jmp 0x4d8d2
movb -0x6a(%rbp), %al
movb %al, -0x6c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x49(%rbp), %rdi
callq 0x1c1d0
movb -0x6c(%rbp), %al
andb $0x1, %al
movb %al, 0x444bdb(%rip) # 0x4924d0
leaq 0x444bdc(%rip), %rdi # 0x4924d8
callq 0x1b840
movb 0x444bc9(%rip), %al # 0x4924d0
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1c1e8
jmp 0x4d95e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x4d93a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x49(%rbp), %rdi
callq 0x1c1d0
leaq 0x444b8e(%rip), %rdi # 0x4924d8
callq 0x1b5f0
leaq -0x28(%rbp), %rdi
callq 0x1c1e8
jmp 0x4d969
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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 to by next_in but doesn't declare the field
// value const unless compiled to do so.
zstream.next_in = const_cast<unsigned char*>(data);
zstream.avail_in = QIntC::to_uint(len);
if (!m->initialized) {
int err = Z_OK;
// deflateInit and inflateInit are macros that use old-style casts.
#if ((defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 406) || defined(__clang__))
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
if (m->action == a_deflate) {
err = deflateInit(&zstream, compression_level);
} else {
err = inflateInit(&zstream);
}
#if ((defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 406) || defined(__clang__))
# pragma GCC diagnostic pop
#endif
checkError("Init", err);
m->initialized = true;
}
int err = Z_OK;
bool done = false;
while (!done) {
if (m->action == a_deflate) {
err = deflate(&zstream, flush);
} else {
err = inflate(&zstream, flush);
}
if ((m->action == a_inflate) && (err != Z_OK) && zstream.msg &&
(strcmp(zstream.msg, "incorrect data check") == 0)) {
// Other PDF readers ignore this specific error. Combining this with Z_SYNC_FLUSH
// enables qpdf to handle some broken zlib streams without losing data.
err = Z_STREAM_END;
}
switch (err) {
case Z_BUF_ERROR:
// Probably shouldn't be able to happen, but possible as a boundary condition: if the
// last call to inflate exactly filled the output buffer, it's possible that the next
// call to inflate could have nothing to do. There are PDF files in the wild that have
// this error (including at least one in qpdf's test suite). In some cases, we want to
// know about this, because it indicates incorrect compression, so call a callback if
// provided.
this->warn("input stream is complete but output may still be valid", err);
done = true;
break;
case Z_STREAM_END:
done = true;
// fall through
case Z_OK:
{
if ((zstream.avail_in == 0) && (zstream.avail_out > 0)) {
// There is nothing left to read, and there was sufficient buffer space to write
// everything we needed, so we're done for now.
done = true;
}
uLong ready = QIntC::to_ulong(m->out_bufsize - zstream.avail_out);
if (ready > 0) {
if (memory_limit_ && m->action != a_deflate) {
m->written += ready;
if (m->written > memory_limit_) {
throw std::runtime_error("PL_Flate memory limit exceeded");
}
}
next()->write(m->outbuf.get(), ready);
zstream.next_out = m->outbuf.get();
zstream.avail_out = QIntC::to_uint(m->out_bufsize);
}
}
break;
default:
this->checkError("data", err);
break;
}
}
}
|
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, %rax
movq %rax, -0x68(%rbp)
leaq 0x2c1a28(%rip), %rsi # 0x30f8d0
callq 0x1b400
jmp 0x4deaf
movq -0x68(%rbp), %rdi
movq 0x4430d6(%rip), %rsi # 0x490f90
movq 0x44309f(%rip), %rdx # 0x490f60
callq 0x1b920
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1bcf0
jmp 0x4e210
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
callq 0x4ef00
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
leaq -0x18(%rbp), %rdi
callq 0x1e8a0
movq -0x60(%rbp), %rdi
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x30, %rdi
callq 0x4ef00
testb $0x1, 0x1c(%rax)
jne 0x4df9b
movq -0x60(%rbp), %rdi
movl $0x0, -0x3c(%rbp)
addq $0x30, %rdi
callq 0x4ef00
cmpl $0x1, 0x18(%rax)
jne 0x4df5f
movq -0x38(%rbp), %rdi
movl 0x4439ef(%rip), %esi # 0x491938
leaq 0x2c19bb(%rip), %rdx # 0x30f90b
movl $0x70, %ecx
callq 0x1bc40
movl %eax, -0x3c(%rbp)
jmp 0x4df77
movq -0x38(%rbp), %rdi
leaq 0x2c19a1(%rip), %rsi # 0x30f90b
movl $0x70, %edx
callq 0x1bae0
movl %eax, -0x3c(%rbp)
movq -0x60(%rbp), %rdi
movl -0x3c(%rbp), %edx
leaq 0x2c198d(%rip), %rsi # 0x30f912
callq 0x4e220
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
callq 0x4ef00
movb $0x1, 0x1c(%rax)
movl $0x0, -0x40(%rbp)
movb $0x0, -0x41(%rbp)
movb -0x41(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4dfb4
jmp 0x4e207
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
callq 0x4ef00
cmpl $0x1, 0x18(%rax)
jne 0x4dfd8
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1bee0
movl %eax, -0x40(%rbp)
jmp 0x4dfe7
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1b8e0
movl %eax, -0x40(%rbp)
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
callq 0x4ef00
cmpl $0x0, 0x18(%rax)
jne 0x4e02b
cmpl $0x0, -0x40(%rbp)
je 0x4e02b
movq -0x38(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x4e02b
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rdi
leaq 0x2c18fd(%rip), %rsi # 0x30f917
callq 0x1bbf0
cmpl $0x0, %eax
jne 0x4e02b
movl $0x1, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x6c(%rbp)
subl $-0x5, %eax
je 0x4e04e
jmp 0x4e038
movl -0x6c(%rbp), %eax
testl %eax, %eax
je 0x4e06e
jmp 0x4e041
movl -0x6c(%rbp), %eax
subl $0x1, %eax
je 0x4e06a
jmp 0x4e1ef
movq -0x60(%rbp), %rdi
movl -0x40(%rbp), %edx
leaq 0x2c18d0(%rip), %rsi # 0x30f92c
callq 0x4dc20
movb $0x1, -0x41(%rbp)
jmp 0x4e202
movb $0x1, -0x41(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x4e086
movq -0x38(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jbe 0x4e086
movb $0x1, -0x41(%rbp)
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
callq 0x4ef00
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movl 0x20(%rcx), %ecx
subq %rcx, %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4f070
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jbe 0x4e1ed
cmpq $0x0, 0x444403(%rip) # 0x4924c8
je 0x4e172
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
callq 0x4ef00
cmpl $0x1, 0x18(%rax)
je 0x4e172
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x30, %rdi
callq 0x4ef00
movq -0x78(%rbp), %rcx
movq -0x60(%rbp), %rdi
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
addq $0x30, %rdi
callq 0x4ef00
movq 0x28(%rax), %rax
cmpq 0x4443ad(%rip), %rax # 0x4924c8
jbe 0x4e170
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
leaq 0x2c182b(%rip), %rsi # 0x30f963
callq 0x1b400
jmp 0x4e13f
movq -0x80(%rbp), %rdi
movq 0x442e46(%rip), %rsi # 0x490f90
movq 0x442e0f(%rip), %rdx # 0x490f60
callq 0x1b920
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1bcf0
jmp 0x4e210
jmp 0x4e172
movq -0x60(%rbp), %rdi
callq 0x47800
movq -0x60(%rbp), %rdi
movq %rax, -0x88(%rbp)
addq $0x30, %rdi
callq 0x4ef00
movq %rax, %rdi
callq 0x4ed00
movq -0x88(%rbp), %rdi
movq %rax, %rsi
movq -0x50(%rbp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
callq 0x4ef00
movq %rax, %rdi
callq 0x4ed00
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rdi
callq 0x4ef00
movq %rax, %rdi
addq $0x10, %rdi
callq 0x1e8a0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x20(%rax)
jmp 0x4e202
movq -0x60(%rbp), %rdi
movl -0x40(%rbp), %edx
leaq 0x2c1034(%rip), %rsi # 0x30f231
callq 0x4e220
jmp 0x4dfa6
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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 # 0x48b3e0
addq $0x10, %rax
movq %rax, (%rdi)
movb $0x0, 0x30(%rdi)
movb $0x0, 0x31(%rdi)
movb $0x0, 0x32(%rdi)
movl $0x9, 0x34(%rdi)
movl $0x0, 0x38(%rdi)
movl $0x0, 0x3c(%rdi)
movl $0x0, 0x40(%rdi)
movl $0x0, 0x44(%rdi)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, 0x48(%rdi)
movb $0x0, 0x49(%rdi)
addq $0x50, %rdi
movq %rdi, -0x40(%rbp)
callq 0x52ac0
movq -0x38(%rbp), %rax
movl $0x100, 0x68(%rax) # imm = 0x100
cmpq $0x0, -0x18(%rbp)
jne 0x51fac
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x2bdcac(%rip), %rsi # 0x30fc13
callq 0x1bbe0
jmp 0x51f6e
movq -0x48(%rbp), %rdi
movq 0x43f067(%rip), %rsi # 0x490fe0
movq 0x43f038(%rip), %rdx # 0x490fb8
callq 0x1b920
jmp 0x51fcd
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1bcf0
jmp 0x51fb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x51fb2
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x52ae0
movq -0x38(%rbp), %rdi
callq 0x1e230
movq -0x28(%rbp), %rdi
callq 0x1b960
nopl (%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_from_low = 0;
if (bits_from_med > 8) {
bits_from_low = bits_from_med - 8;
bits_from_med = 8;
}
unsigned int high_mask = (1U << bits_from_high) - 1U;
unsigned int med_mask = 0xff - ((1U << (8 - bits_from_med)) - 1U);
unsigned int low_mask = 0xff - ((1U << (8 - bits_from_low)) - 1U);
unsigned int code = 0;
code += (this->buf[high] & high_mask) << bits_from_med;
code += ((this->buf[med] & med_mask) >> (8 - bits_from_med));
if (bits_from_low) {
code <<= bits_from_low;
code += ((this->buf[low] & low_mask) >> (8 - bits_from_low));
this->byte_pos = low;
this->bit_pos = bits_from_low;
} else {
this->byte_pos = med;
this->bit_pos = bits_from_med;
}
if (this->bit_pos == 8) {
this->bit_pos = 0;
++this->byte_pos;
this->byte_pos %= 3;
}
this->bits_available -= this->code_size;
handleCode(code);
}
|
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
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
movq -0x38(%rbp), %rax
movl %edx, -0x14(%rbp)
movl $0x8, %ecx
subl 0x40(%rax), %ecx
movl %ecx, -0x18(%rbp)
movl 0x34(%rax), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x8, -0x1c(%rbp)
jbe 0x520e7
movl -0x1c(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x20(%rbp)
movl $0x8, -0x1c(%rbp)
movq -0x38(%rbp), %rax
movl -0x18(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movl $0x8, %ecx
subl -0x1c(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
subl $0x1, %edx
movl $0xff, %ecx
subl %edx, %ecx
movl %ecx, -0x28(%rbp)
movl $0x8, %ecx
subl -0x20(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
subl $0x1, %edx
movl $0xff, %ecx
subl %edx, %ecx
movl %ecx, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0xc(%rbp), %ecx
movzbl 0x30(%rax,%rcx), %edx
andl -0x24(%rbp), %edx
movl -0x1c(%rbp), %ecx
shll %cl, %edx
movl %edx, %ecx
addl -0x30(%rbp), %ecx
movl %ecx, -0x30(%rbp)
movl -0x10(%rbp), %ecx
movzbl 0x30(%rax,%rcx), %eax
andl -0x28(%rbp), %eax
movl $0x8, %ecx
subl -0x1c(%rbp), %ecx
shrl %cl, %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x521b1
movq -0x38(%rbp), %rax
movl -0x20(%rbp), %ecx
movl -0x30(%rbp), %edx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movzbl 0x30(%rax,%rcx), %edx
andl -0x2c(%rbp), %edx
movl $0x8, %ecx
subl -0x20(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
addl -0x30(%rbp), %ecx
movl %ecx, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, 0x3c(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x40(%rax)
jmp 0x521c1
movq -0x38(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, 0x3c(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x40(%rax)
movq -0x38(%rbp), %rax
cmpl $0x8, 0x40(%rax)
jne 0x521f2
movq -0x38(%rbp), %rax
movl $0x0, 0x40(%rax)
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movl 0x3c(%rax), %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
movq -0x38(%rbp), %rax
movl %edx, 0x3c(%rax)
movq -0x38(%rbp), %rdi
movl 0x34(%rdi), %ecx
movl 0x44(%rdi), %eax
subl %ecx, %eax
movl %eax, 0x44(%rdi)
movl -0x30(%rbp), %esi
callq 0x52240
addq $0x40, %rsp
popq %rbp
retq
nop
|
/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]);
next()->write(&ch, 1);
}
} else {
next()->write(this->cur_row, this->bytes_per_row);
}
}
|
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 -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x34(%rcx), %eax
jae 0x5494e
movq -0x18(%rbp), %rdi
movq 0x40(%rdi), %rax
movl -0x10(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movq 0x48(%rdi), %rcx
movl -0x10(%rbp), %edx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movb %al, -0x9(%rbp)
callq 0x47800
movq %rax, %rdi
movq (%rdi), %rax
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq *0x10(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x54901
jmp 0x5496f
movq -0x18(%rbp), %rdi
callq 0x47800
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rsi
movl 0x34(%rax), %eax
movl %eax, %edx
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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 = buffer[i - bpp];
}
buffer[i] = static_cast<unsigned char>(buffer[i] + left);
}
}
|
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), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x34(%rcx), %eax
jae 0x54ac8
movb $0x0, -0x19(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jb 0x54aa0
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl -0x14(%rbp), %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movzbl -0x19(%rbp), %ecx
addl %ecx, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x54a76
addq $0x30, %rsp
popq %rbp
retq
nop
|
/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 = 0;
int up = 0;
if (i >= bpp) {
left = buffer[i - bpp];
}
up = above_buffer[i];
buffer[i] = static_cast<unsigned char>(buffer[i] + (left + up) / 2);
}
}
|
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), %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movl 0x38(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x34(%rcx), %eax
jae 0x54c3f
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jb 0x54bf7
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
subl -0x1c(%rbp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x34(%rbp), %eax
addl %ecx, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x54bc2
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%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];
switch (m->state) {
case st_top:
if (ch < 128) {
// length represents remaining number of bytes to copy
m->length = 1U + ch;
m->state = st_copying;
} else if (ch > 128) {
// length represents number of copies of next byte
m->length = 257U - ch;
m->state = st_run;
} else // ch == 128
{
// EOD; stay in this state
}
break;
case st_copying:
m->out.append(1, static_cast<char>(ch));
if (--m->length == 0) {
m->state = st_top;
}
break;
case st_run:
m->out.append(m->length, static_cast<char>(ch));
m->state = st_top;
break;
}
}
}
|
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, %rdi
addq $0x90, %rdi
callq 0x1b480
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
cmpq 0x43bea9(%rip), %rax # 0x4924f8
jbe 0x566a4
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x2b9a7a(%rip), %rsi # 0x3100e6
callq 0x1b400
jmp 0x56673
movq -0x50(%rbp), %rdi
movq 0x43a912(%rip), %rsi # 0x490f90
movq 0x43a8db(%rip), %rdx # 0x490f60
callq 0x1b920
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bcf0
jmp 0x56887
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x56d10
movq %rax, %rdi
addq $0x90, %rdi
movq -0x18(%rbp), %rsi
callq 0x1bba0
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x56881
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
addq $0x30, %rdi
callq 0x56d10
movl 0x4(%rax), %eax
movl %eax, -0x54(%rbp)
testl %eax, %eax
je 0x56721
jmp 0x56702
movl -0x54(%rbp), %eax
subl $0x1, %eax
je 0x567bc
jmp 0x56710
movl -0x54(%rbp), %eax
subl $0x2, %eax
je 0x5681e
jmp 0x5686e
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0x56768
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
addq $0x30, %rdi
callq 0x56d10
movl -0x58(%rbp), %ecx
movq -0x40(%rbp), %rdi
movl %ecx, 0x88(%rax)
addq $0x30, %rdi
callq 0x56d10
movl $0x1, 0x4(%rax)
jmp 0x567b7
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jle 0x567b3
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movzbl (%rax), %ecx
movl $0x101, %eax # imm = 0x101
subl %ecx, %eax
movl %eax, -0x5c(%rbp)
addq $0x30, %rdi
callq 0x56d10
movl -0x5c(%rbp), %ecx
movq -0x40(%rbp), %rdi
movl %ecx, 0x88(%rax)
addq $0x30, %rdi
callq 0x56d10
movl $0x2, 0x4(%rax)
jmp 0x567b5
jmp 0x567b5
jmp 0x567b7
jmp 0x5686e
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x56d10
movq %rax, %rdi
addq $0x90, %rdi
movq -0x38(%rbp), %rax
movl $0x1, %esi
movsbl (%rax), %edx
callq 0x1bb10
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x56d10
movq %rax, %rcx
movl 0x88(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x88(%rcx)
cmpl $0x0, %eax
jne 0x5681c
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x56d10
movl $0x0, 0x4(%rax)
jmp 0x5686e
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x56d10
movq -0x40(%rbp), %rdi
addq $0x90, %rax
movq %rax, -0x68(%rbp)
addq $0x30, %rdi
callq 0x56d10
movq -0x68(%rbp), %rdi
movl 0x88(%rax), %eax
movl %eax, %esi
movq -0x38(%rbp), %rax
movsbl (%rax), %edx
callq 0x1bb10
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x56d10
movl $0x0, 0x4(%rax)
jmp 0x56870
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x566cc
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1b960
|
/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)
leaq 0x2b8daf(%rip), %rsi # 0x3101c3
callq 0x1bbe0
jmp 0x5741b
movq -0x40(%rbp), %rdi
movq 0x439bba(%rip), %rsi # 0x490fe0
movq 0x439b8b(%rip), %rdx # 0x490fb8
callq 0x1b920
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1bcf0
jmp 0x5746d
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x23520
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq (%rsi), %rax
callq *0x50(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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)
leaq 0x2b8cff(%rip), %rsi # 0x3101c3
callq 0x1bbe0
jmp 0x574cb
movq -0x60(%rbp), %rdi
movq 0x439b0a(%rip), %rsi # 0x490fe0
movq 0x439adb(%rip), %rdx # 0x490fb8
callq 0x1b920
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1bcf0
jmp 0x57541
movq -0x48(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x573d0
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x2b00e0
jmp 0x57519
leaq -0x40(%rbp), %rdi
callq 0x1c1e8
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1c1e8
movq -0x18(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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 += bytes_per_row;
processRow();
// Prepare for next row
cur_row.clear();
}
cur_row.insert(cur_row.end(), data, end);
}
|
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)
addq $0x48, %rdi
callq 0x58db0
movq -0x68(%rbp), %rcx
movq %rax, %rdx
movq -0x60(%rbp), %rax
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x58784
movq -0x70(%rbp), %rdi
movq %rdi, %rax
addq $0x48, %rax
movq %rax, -0x78(%rbp)
addq $0x48, %rdi
callq 0x58e70
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x58ea0
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rsi
callq 0x58dd0
movq -0x70(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x38(%rdi), %ecx
movq -0x28(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
callq 0x587d0
movq -0x70(%rbp), %rdi
addq $0x48, %rdi
callq 0x58ee0
jmp 0x58708
movq -0x70(%rbp), %rdi
movq %rdi, %rax
addq $0x48, %rax
movq %rax, -0x80(%rbp)
addq $0x48, %rdi
callq 0x58e70
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x58ea0
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x48(%rbp), %rsi
callq 0x58dd0
movq %rax, -0x58(%rbp)
addq $0x80, %rsp
popq %rbp
retq
nop
|
/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; col < this->columns; ++col) {
for (auto& prev: previous) {
long long sample = in.getBitsSigned(this->bits_per_sample);
long long new_sample = sample;
if (action == a_encode) {
new_sample -= prev;
prev = sample;
} else {
new_sample += prev;
prev = new_sample;
}
bw.writeBitsSigned(new_sample, this->bits_per_sample);
}
}
bw.flush();
} else {
out.clear();
auto next_it = cur_row.begin();
auto cr_end = cur_row.end();
auto pr_end = previous.end();
while (next_it != cr_end) {
for (auto prev = previous.begin(); prev != pr_end && next_it != cr_end;
++prev, ++next_it) {
long long sample = *next_it;
long long new_sample = sample;
if (action == a_encode) {
new_sample -= *prev;
*prev = sample;
} else {
new_sample += *prev;
*prev = new_sample;
}
out.push_back(static_cast<unsigned char>(255U & new_sample));
}
}
next()->write(out.data(), out.size());
}
}
|
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
movq -0xc8(%rbp), %rax
movq %rax, %rdi
addq $0x60, %rdi
movl 0x3c(%rax), %eax
movl %eax, %esi
movq $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rdx
callq 0x58f00
movq -0xc8(%rbp), %rax
cmpl $0x8, 0x40(%rax)
je 0x589c1
movq -0xc8(%rbp), %rdi
callq 0x47800
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x1f240
movq -0xc8(%rbp), %rdi
addq $0x48, %rdi
callq 0x58f30
movq -0xc8(%rbp), %rdi
movq %rax, -0xd0(%rbp)
addq $0x48, %rdi
callq 0x58db0
movq -0xd0(%rbp), %rsi
movq %rax, %rdx
leaq -0x50(%rbp), %rdi
callq 0x1e270
movl $0x0, -0x54(%rbp)
movq -0xc8(%rbp), %rcx
movl -0x54(%rbp), %eax
cmpl 0x34(%rcx), %eax
jae 0x589b3
movq -0xc8(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x58f50
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x58f80
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x58fb0
testb $0x1, %al
jne 0x588ed
jmp 0x589a3
leaq -0x68(%rbp), %rdi
callq 0x58ff0
movq %rax, %rcx
movq -0xc8(%rbp), %rax
movq %rcx, -0x78(%rbp)
movl 0x40(%rax), %eax
movl %eax, %esi
leaq -0x50(%rbp), %rdi
callq 0x1e700
movq %rax, %rcx
movq -0xc8(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq -0x80(%rbp), %rcx
movq %rcx, -0x88(%rbp)
cmpl $0x0, 0x30(%rax)
jne 0x58956
movq -0x78(%rbp), %rax
movq (%rax), %rcx
movq -0x88(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rcx
movq -0x78(%rbp), %rax
movq %rcx, (%rax)
jmp 0x58979
movq -0x78(%rbp), %rax
movq (%rax), %rax
addq -0x88(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rcx
movq -0x78(%rbp), %rax
movq %rcx, (%rax)
movq -0xc8(%rbp), %rax
movq -0x88(%rbp), %rsi
movl 0x40(%rax), %eax
movl %eax, %edx
leaq -0x28(%rbp), %rdi
callq 0x1f410
leaq -0x68(%rbp), %rdi
callq 0x59010
jmp 0x588d7
jmp 0x589a5
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x5889b
leaq -0x28(%rbp), %rdi
callq 0x1f4a0
jmp 0x58bed
movq -0xc8(%rbp), %rdi
addq $0x78, %rdi
callq 0x58ee0
movq -0xc8(%rbp), %rdi
addq $0x48, %rdi
callq 0x59030
movq -0xc8(%rbp), %rdi
movq %rax, -0x90(%rbp)
addq $0x48, %rdi
callq 0x58e70
movq -0xc8(%rbp), %rdi
movq %rax, -0x98(%rbp)
addq $0x60, %rdi
callq 0x58f80
movq %rax, -0xa0(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x59060
testb $0x1, %al
jne 0x58a32
jmp 0x58b9c
movq -0xc8(%rbp), %rdi
addq $0x60, %rdi
callq 0x58f50
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x58fb0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xd1(%rbp)
jne 0x58a6d
jmp 0x58a86
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x59060
movb %al, -0xd1(%rbp)
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x58a95
jmp 0x58b97
leaq -0x90(%rbp), %rdi
callq 0x590a0
movq %rax, %rcx
movq -0xc8(%rbp), %rax
movzbl (%rcx), %ecx
movq %rcx, -0xb0(%rbp)
movq -0xb0(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
cmpl $0x0, 0x30(%rax)
jne 0x58b0f
leaq -0xa8(%rbp), %rdi
callq 0x58ff0
movq (%rax), %rcx
movq -0xb8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x58ff0
movq -0xe0(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x58b50
leaq -0xa8(%rbp), %rdi
callq 0x58ff0
movq (%rax), %rax
addq -0xb8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x58ff0
movq -0xe8(%rbp), %rcx
movq %rcx, (%rax)
movq -0xc8(%rbp), %rdi
addq $0x78, %rdi
movq -0xb8(%rbp), %rax
andq $0xff, %rax
movb %al, -0xb9(%rbp)
leaq -0xb9(%rbp), %rsi
callq 0x590c0
leaq -0xa8(%rbp), %rdi
callq 0x59010
leaq -0x90(%rbp), %rdi
callq 0x590f0
jmp 0x58a49
jmp 0x58a16
movq -0xc8(%rbp), %rdi
callq 0x47800
movq -0xc8(%rbp), %rdi
movq %rax, -0xf8(%rbp)
addq $0x78, %rdi
callq 0x58f30
movq -0xc8(%rbp), %rdi
movq %rax, -0xf0(%rbp)
addq $0x78, %rdi
callq 0x58db0
movq -0xf8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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 object cache, which is those objects that we read from the file, and break all
// resolved indirect references by replacing them with an internal object type representing that
// they have been destroyed. Note that we can't break references like this at any time when the
// QPDF object is active. The call to reset also causes all direct QPDFObjectHandle objects that
// are reachable from this object to release their association with this QPDF. Direct objects
// are not destroyed since they can be moved to other QPDF objects safely.
// At this point, obviously no one is still using the QPDF object, but we'll explicitly clear
// the xref table anyway just to prevent any possibility of resolve() succeeding.
m->xref_table.clear();
for (auto const& iter: m->obj_cache) {
Disconnect(iter.second.object).disconnect();
}
}
|
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), %rdi
callq 0x63710
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63740
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x63770
testb $0x1, %al
jne 0x5cd58
jmp 0x5cd97
leaq -0x18(%rbp), %rdi
callq 0x637a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
callq 0x637c0
jmp 0x5cd78
leaq -0x38(%rbp), %rdi
callq 0x637f0
jmp 0x5cd83
leaq -0x38(%rbp), %rdi
callq 0x63840
leaq -0x18(%rbp), %rdi
callq 0x63860
jmp 0x5cd45
movq -0x40(%rbp), %rdi
callq 0x63690
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e220
nop
|
/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 (util::is_digit(*p)) {
version.append(1, *p++);
}
} else {
valid = false;
}
}
return valid;
}
|
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
testb $0x1, %al
jne 0x5d615
jmp 0x5d639
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movl $0x1, %esi
movsbl (%rax), %edx
callq 0x1bb10
jmp 0x5d600
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x5d6bb
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %edi
callq 0x63ce0
testb $0x1, %al
jne 0x5d65e
jmp 0x5d6bb
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movl $0x1, %esi
movsbl (%rax), %edx
callq 0x1bb10
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x63ce0
testb $0x1, %al
jne 0x5d695
jmp 0x5d6b9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movl $0x1, %esi
movsbl (%rax), %edx
callq 0x1bb10
jmp 0x5d680
jmp 0x5d6bf
movb $0x0, -0x11(%rbp)
jmp 0x5d6c1
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
/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
// foreign QPDF into the local QPDF, we have to replace all indirect object references with
// references to the corresponding object in the local file.
//
// To do this, we maintain mappings from foreign object IDs to local object IDs for each foreign
// QPDF that we are copying from. The mapping is stored in an ObjCopier, which contains a
// mapping from the foreign ObjGen to the local QPDFObjectHandle.
//
// To copy, we do a deep traversal of the foreign object with loop detection to discover all
// indirect objects that are encountered, stopping at page boundaries. Whenever we encounter an
// indirect object, we check to see if we have already created a local copy of it. If not, we
// allocate a "reserved" object (or, for a stream, just a new stream) and store in the map the
// mapping from the foreign object ID to the new object. While we
// do this, we keep a list of objects to copy.
//
// Once we are done with the traversal, we copy all the objects that we need to copy. However,
// the copies will contain indirect object IDs that refer to objects in the foreign file. We
// need to replace them with references to objects in the local file. This is what
// replaceForeignIndirectObjects does. Once we have created a copy of the foreign object with
// all the indirect references replaced with new ones in the local context, we can replace the
// local reserved object with the copy. This mechanism allows us to copy objects with circular
// references in any order.
// For streams, rather than copying the objects, we set up the stream data to pull from the
// original stream by using a stream data provider. This is done in a manner that doesn't
// require the original QPDF object but may require the original source of the stream data with
// special handling for immediate_copy_from. This logic is also in
// replaceForeignIndirectObjects.
// Note that we explicitly allow use of copyForeignObject on page objects. It is a documented
// use case to copy pages this way if the intention is to not update the pages tree.
if (!foreign.isIndirect()) {
QTC::TC("qpdf", "QPDF copyForeign direct");
throw std::logic_error("QPDF::copyForeign called with direct object handle");
}
QPDF& other = foreign.getQPDF();
if (&other == this) {
QTC::TC("qpdf", "QPDF copyForeign not foreign");
throw std::logic_error("QPDF::copyForeign called with object from this QPDF");
}
ObjCopier& obj_copier = m->object_copiers[other.m->unique_id];
if (!obj_copier.visiting.empty()) {
throw std::logic_error(
"obj_copier.visiting is not empty at the beginning of copyForeignObject");
}
// Make sure we have an object in this file for every referenced object in the old file.
// obj_copier.object_map maps foreign QPDFObjGen to local objects. For everything new that we
// have to copy, the local object will be a reservation, unless it is a stream, in which case
// the local object will already be a stream.
reserveObjects(foreign, obj_copier, true);
if (!obj_copier.visiting.empty()) {
throw std::logic_error("obj_copier.visiting is not empty after reserving objects");
}
// Copy any new objects and replace the reservations.
for (auto& to_copy: obj_copier.to_copy) {
QPDFObjectHandle copy = replaceForeignIndirectObjects(to_copy, obj_copier, true);
if (!to_copy.isStream()) {
QPDFObjGen og(to_copy.getObjGen());
replaceReserved(obj_copier.object_map[og], copy);
}
}
obj_copier.to_copy.clear();
auto og = foreign.getObjGen();
if (!obj_copier.object_map.count(og)) {
warn(damagedPDF(
other.getFilename() + " object " + og.unparse(' '),
foreign.getParsedOffset(),
"unexpected reference to /Pages object while copying foreign object; replacing with "
"null"));
return QPDFObjectHandle::newNull();
}
return obj_copier.object_map[foreign.getObjGen()];
}
|
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 0x1c1bf0
testb $0x1, %al
jne 0x5e33e
leaq 0x2d3c64(%rip), %rdi # 0x331f38
leaq 0x2b23f6(%rip), %rsi # 0x3106d1
xorl %edx, %edx
callq 0x25230
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x238(%rbp)
leaq 0x2b23e9(%rip), %rsi # 0x3106e9
callq 0x1bbe0
jmp 0x5e307
movq -0x238(%rbp), %rdi
movq 0x432ccb(%rip), %rsi # 0x490fe0
movq 0x432c9c(%rip), %rdx # 0x490fb8
callq 0x1b920
movq -0x238(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bcf0
jmp 0x5ea36
leaq -0x51(%rbp), %rdi
movq %rdi, -0x240(%rbp)
callq 0x1be40
movq -0x240(%rbp), %rdx
leaq 0x2d1664(%rip), %rsi # 0x32f9c0
leaq -0x50(%rbp), %rdi
callq 0x21b70
jmp 0x5e367
movq -0x230(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1c49a0
movq %rax, -0x248(%rbp)
jmp 0x5e380
leaq -0x50(%rbp), %rdi
callq 0x1c1e8
leaq -0x51(%rbp), %rdi
callq 0x1c1d0
movq -0x248(%rbp), %rcx
movq -0x218(%rbp), %rax
movq %rcx, -0x30(%rbp)
cmpq %rax, -0x30(%rbp)
jne 0x5e450
leaq 0x2d3b83(%rip), %rdi # 0x331f38
leaq 0x2b2360(%rip), %rsi # 0x31071c
xorl %edx, %edx
callq 0x25230
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x250(%rbp)
leaq 0x2b2358(%rip), %rsi # 0x310739
callq 0x1bbe0
jmp 0x5e3e8
movq -0x250(%rbp), %rdi
movq 0x432bea(%rip), %rsi # 0x490fe0
movq 0x432bbb(%rip), %rdx # 0x490fb8
callq 0x1b920
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5e425
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c1e8
leaq -0x51(%rbp), %rdi
callq 0x1c1d0
jmp 0x5ea36
movq -0x250(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bcf0
jmp 0x5ea36
movq -0x218(%rbp), %rdi
callq 0x63670
addq $0x288, %rax # imm = 0x288
movq %rax, -0x258(%rbp)
movq -0x30(%rbp), %rdi
callq 0x63670
movq -0x258(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rsi
callq 0x63f60
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
addq $0x48, %rdi
callq 0x64040
testb $0x1, %al
jne 0x5e4f6
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x260(%rbp)
leaq 0x2b22b5(%rip), %rsi # 0x31076d
callq 0x1bbe0
jmp 0x5e4bf
movq -0x260(%rbp), %rdi
movq 0x432b13(%rip), %rsi # 0x490fe0
movq 0x432ae4(%rip), %rdx # 0x490fb8
callq 0x1b920
movq -0x260(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bcf0
jmp 0x5ea36
movq -0x230(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x42b80
movq -0x218(%rbp), %rdi
movq -0x268(%rbp), %rsi
movq -0x60(%rbp), %rdx
movl $0x1, %ecx
callq 0x5ea40
jmp 0x5e52b
leaq -0x70(%rbp), %rdi
callq 0x23380
movq -0x60(%rbp), %rdi
addq $0x48, %rdi
callq 0x64040
testb $0x1, %al
jne 0x5e5bb
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x270(%rbp)
leaq 0x2b2251(%rip), %rsi # 0x3107b4
callq 0x1bbe0
jmp 0x5e56a
movq -0x270(%rbp), %rdi
movq 0x432a68(%rip), %rsi # 0x490fe0
movq 0x432a39(%rip), %rdx # 0x490fb8
callq 0x1b920
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x23380
jmp 0x5ea36
movq -0x270(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bcf0
jmp 0x5ea36
movq -0x60(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x64060
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x64090
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x640c0
testb $0x1, %al
jne 0x5e5fd
jmp 0x5e79f
leaq -0x80(%rbp), %rdi
callq 0x64100
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x278(%rbp)
callq 0x42b80
movq -0x218(%rbp), %rsi
movq -0x278(%rbp), %rdx
movq -0x60(%rbp), %rcx
leaq -0xa0(%rbp), %rdi
movl $0x1, %r8d
callq 0x5f0a0
jmp 0x5e64d
leaq -0xb0(%rbp), %rdi
callq 0x23380
movq -0x90(%rbp), %rdi
callq 0x1c0160
movb %al, -0x279(%rbp)
jmp 0x5e66d
movb -0x279(%rbp), %al
testb $0x1, %al
jne 0x5e774
jmp 0x5e67d
movq -0x90(%rbp), %rdi
callq 0x1c2e70
movq %rax, -0x288(%rbp)
jmp 0x5e692
movq -0x288(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x60(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x63050
movq %rax, -0x290(%rbp)
jmp 0x5e6b9
movq -0x290(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x2a0(%rbp)
callq 0x42b80
leaq -0xd8(%rbp), %rdi
movq %rdi, -0x298(%rbp)
leaq -0xa0(%rbp), %rsi
callq 0x42b80
movq -0x218(%rbp), %rdi
movq -0x2a0(%rbp), %rsi
movq -0x298(%rbp), %rdx
callq 0x289d40
jmp 0x5e709
leaq -0xd8(%rbp), %rdi
callq 0x23380
leaq -0xc8(%rbp), %rdi
callq 0x23380
jmp 0x5e774
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x23380
jmp 0x5ea36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5e78e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x23380
leaq -0xc8(%rbp), %rdi
callq 0x23380
jmp 0x5e78e
leaq -0xa0(%rbp), %rdi
callq 0x23380
leaq -0x80(%rbp), %rdi
callq 0x64120
jmp 0x5e5e4
leaq -0xa0(%rbp), %rdi
callq 0x23380
jmp 0x5ea36
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
callq 0x64140
movq -0x230(%rbp), %rdi
callq 0x1c2e70
movq %rax, -0xe0(%rbp)
movq -0x60(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x64160
cmpq $0x0, %rax
jne 0x5e9e6
movq -0x30(%rbp), %rsi
leaq -0x1c0(%rbp), %rdi
movq %rdi, -0x2a8(%rbp)
callq 0x5dd30
movq -0x2a8(%rbp), %rsi
leaq 0x2cd22b(%rip), %rdx # 0x32ba29
leaq -0x1a0(%rbp), %rdi
callq 0x1e9b0
jmp 0x5e80c
leaq -0x1e0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
movl $0x20, %edx
callq 0x641c0
jmp 0x5e826
leaq -0x180(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
leaq -0x1e0(%rbp), %rdx
callq 0x1e8e0
jmp 0x5e842
movq -0x230(%rbp), %rdi
callq 0x1c6ed0
movq %rax, -0x2b0(%rbp)
jmp 0x5e857
leaq -0x201(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
callq 0x1be40
movq -0x2b8(%rbp), %rdx
leaq 0x2b1f75(%rip), %rsi # 0x3107ed
leaq -0x200(%rbp), %rdi
callq 0x21b70
jmp 0x5e886
movq -0x2b0(%rbp), %rcx
movq -0x218(%rbp), %rsi
leaq -0x160(%rbp), %rdi
leaq -0x180(%rbp), %rdx
leaq -0x200(%rbp), %r8
callq 0x5fab0
jmp 0x5e8b0
movq -0x218(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x5d9a0
jmp 0x5e8c5
leaq -0x160(%rbp), %rdi
callq 0x24500
leaq -0x200(%rbp), %rdi
callq 0x1c1e8
leaq -0x201(%rbp), %rdi
callq 0x1c1d0
leaq -0x180(%rbp), %rdi
callq 0x1c1e8
leaq -0x1e0(%rbp), %rdi
callq 0x1c1e8
leaq -0x1a0(%rbp), %rdi
callq 0x1c1e8
leaq -0x1c0(%rbp), %rdi
callq 0x1c1e8
movq -0x228(%rbp), %rdi
callq 0x1c4c30
jmp 0x5ea26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5e9d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5e9cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5e9c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5e9b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5e9a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5e99c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x24500
leaq -0x200(%rbp), %rdi
callq 0x1c1e8
leaq -0x201(%rbp), %rdi
callq 0x1c1d0
leaq -0x180(%rbp), %rdi
callq 0x1c1e8
leaq -0x1e0(%rbp), %rdi
callq 0x1c1e8
leaq -0x1a0(%rbp), %rdi
callq 0x1c1e8
leaq -0x1c0(%rbp), %rdi
callq 0x1c1e8
jmp 0x5ea36
movq -0x230(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x2c0(%rbp)
callq 0x1c2e70
movq -0x2c0(%rbp), %rdi
movq %rax, -0x20c(%rbp)
leaq -0x20c(%rbp), %rsi
callq 0x642d0
movq -0x228(%rbp), %rdi
movq %rax, %rsi
callq 0x42b80
movq -0x220(%rbp), %rax
addq $0x2c0, %rsp # imm = 0x2C0
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1b960
nop
|
/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 -0x28(%rbp), %rdi
movq 0x42f751(%rip), %rsi # 0x490fe0
movq 0x42f722(%rip), %rdx # 0x490fb8
callq 0x1b920
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x1bcf0
jmp 0x618c7
movq -0x20(%rbp), %rdi
callq 0x63670
addq $0x138, %rax # imm = 0x138
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x1b960
|
/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 0x626b5
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x231d00
jmp 0x626c4
leaq -0x38(%rbp), %rdi
callq 0x1c1e8
leaq -0x39(%rbp), %rdi
callq 0x1c1d0
leaq -0x81(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x1be40
movq -0xf8(%rbp), %rdx
leaq 0x2af9eb(%rip), %rsi # 0x3120e2
leaq -0x80(%rbp), %rdi
callq 0x21b70
jmp 0x62702
leaq -0x60(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x231400
jmp 0x62715
leaq -0x80(%rbp), %rdi
callq 0x1c1e8
leaq -0x81(%rbp), %rdi
callq 0x1c1d0
movb $0x0, -0xaa(%rbp)
movb $0x0, -0xab(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1c0130
movb %al, -0xf9(%rbp)
jmp 0x62749
movb -0xf9(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xfa(%rbp)
jne 0x6275e
jmp 0x627c1
leaq -0xa9(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x1be40
movq -0x108(%rbp), %rdx
movb $0x1, -0xaa(%rbp)
leaq 0x2ae4f0(%rip), %rsi # 0x310c76
leaq -0xa8(%rbp), %rdi
callq 0x21b70
jmp 0x62794
movb $0x1, -0xab(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x2312c0
movb %al, -0x109(%rbp)
jmp 0x627b3
movb -0x109(%rbp), %al
movb %al, -0xfa(%rbp)
jmp 0x627c1
movb -0xfa(%rbp), %al
movb %al, -0x10a(%rbp)
testb $0x1, -0xab(%rbp)
jne 0x627d8
jmp 0x627e4
leaq -0xa8(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0xaa(%rbp)
jne 0x627ef
jmp 0x627fb
leaq -0xa9(%rbp), %rdi
callq 0x1c1d0
movb -0x10a(%rbp), %al
testb $0x1, %al
jne 0x6280a
jmp 0x6299d
leaq -0xd1(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x1be40
movq -0x118(%rbp), %rdx
leaq 0x2ae44b(%rip), %rsi # 0x310c76
leaq -0xd0(%rbp), %rdi
callq 0x21b70
jmp 0x62839
xorl %eax, %eax
movl %eax, %esi
leaq -0xe8(%rbp), %rdi
callq 0x1c44d0
jmp 0x6284b
leaq -0x60(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
leaq -0xe8(%rbp), %rdx
callq 0x231990
jmp 0x62864
leaq -0xe8(%rbp), %rdi
callq 0x23380
leaq -0xd0(%rbp), %rdi
callq 0x1c1e8
leaq -0xd1(%rbp), %rdi
callq 0x1c1d0
jmp 0x6299d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x628b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c1e8
leaq -0x39(%rbp), %rdi
callq 0x1c1d0
jmp 0x629c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x628e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1c1e8
leaq -0x81(%rbp), %rdi
callq 0x1c1d0
jmp 0x629c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x629b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x62936
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0xab(%rbp)
jne 0x62928
jmp 0x62934
leaq -0xa8(%rbp), %rdi
callq 0x1c1e8
jmp 0x62936
testb $0x1, -0xaa(%rbp)
jne 0x62941
jmp 0x6294d
leaq -0xa9(%rbp), %rdi
callq 0x1c1d0
jmp 0x629b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x6298f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x62983
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x23380
leaq -0xd0(%rbp), %rdi
callq 0x1c1e8
leaq -0xd1(%rbp), %rdi
callq 0x1c1d0
jmp 0x629b8
leaq -0x60(%rbp), %rdi
callq 0x23380
leaq -0x18(%rbp), %rdi
callq 0x23380
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x23380
leaq -0x18(%rbp), %rdi
callq 0x23380
movq -0x48(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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);
}
return qpdf::Stream(std::shared_ptr<QPDFObject>());
}
|
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), %rdi
callq 0x69fe0
cmpl $0xa, %eax
je 0x649ac
movzbl -0x11(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x649bb
movq -0x40(%rbp), %rdi
callq 0x69fe0
cmpl $0x2, %eax
jne 0x649bb
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x6aa20
jmp 0x64a17
movzbl -0x11(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x649d9
movq -0x40(%rbp), %rdi
leaq 0x2addbe(%rip), %rsi # 0x312790
xorl %edx, %edx
callq 0x1c8ca0
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x433b0
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x6aa50
jmp 0x649f5
leaq -0x28(%rbp), %rdi
callq 0x23410
jmp 0x64a17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x23410
jmp 0x64a21
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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::resolved(obj->qpdf, obj->og)).as<T>();
}
if (std::holds_alternative<QPDF_Reference>(obj->value)) {
// see comment in QPDF_Reference.
return BaseHandle(std::get<QPDF_Reference>(obj->value).obj).as<T>();
}
return nullptr;
}
|
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
callq 0x65ef0
movq %rax, %rdi
callq 0x6a830
movq %rax, -0x8(%rbp)
jmp 0x6a78c
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq %rax, %rdi
callq 0x6a850
testb $0x1, %al
jne 0x6a695
jmp 0x6a713
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq -0x50(%rbp), %rdi
movq 0x48(%rax), %rax
movq %rax, -0x68(%rbp)
callq 0x65ef0
movq -0x68(%rbp), %rdi
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x6a130
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x6a880
movq -0x60(%rbp), %rdi
callq 0x6a620
movq %rax, -0x58(%rbp)
jmp 0x6a6e3
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x233f0
jmp 0x6a78c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x233f0
jmp 0x6a799
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq %rax, %rdi
callq 0x6a8b0
testb $0x1, %al
jne 0x6a72a
jmp 0x6a784
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq %rax, %rdi
callq 0x6a180
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6a880
movq -0x78(%rbp), %rdi
callq 0x6a620
movq %rax, -0x70(%rbp)
jmp 0x6a75a
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x233f0
jmp 0x6a78c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x233f0
jmp 0x6a799
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
nopl (%rax)
|
/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::resolved(obj->qpdf, obj->og)).as<T>();
}
if (std::holds_alternative<QPDF_Reference>(obj->value)) {
// see comment in QPDF_Reference.
return BaseHandle(std::get<QPDF_Reference>(obj->value).obj).as<T>();
}
return nullptr;
}
|
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
callq 0x65ef0
movq %rax, %rdi
callq 0x6ad60
movq %rax, -0x8(%rbp)
jmp 0x6acdc
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq %rax, %rdi
callq 0x6a850
testb $0x1, %al
jne 0x6abe5
jmp 0x6ac63
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq -0x50(%rbp), %rdi
movq 0x48(%rax), %rax
movq %rax, -0x68(%rbp)
callq 0x65ef0
movq -0x68(%rbp), %rdi
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x6a130
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x6a880
movq -0x60(%rbp), %rdi
callq 0x6ab70
movq %rax, -0x58(%rbp)
jmp 0x6ac33
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x233f0
jmp 0x6acdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x233f0
jmp 0x6ace9
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq %rax, %rdi
callq 0x6a8b0
testb $0x1, %al
jne 0x6ac7a
jmp 0x6acd4
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq %rax, %rdi
callq 0x6a180
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6a880
movq -0x78(%rbp), %rdi
callq 0x6ab70
movq %rax, -0x70(%rbp)
jmp 0x6acaa
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x233f0
jmp 0x6acdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x233f0
jmp 0x6ace9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
nopl (%rax)
|
/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 acroform;
}
|
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), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x1be40
movq -0xd0(%rbp), %rdx
leaq 0x272074(%rip), %rsi # 0x3120e2
leaq -0x48(%rbp), %rdi
callq 0x21b70
jmp 0xa0079
movq -0xe8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x231400
jmp 0xa008f
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x49(%rbp), %rdi
callq 0x1c1d0
leaq -0x28(%rbp), %rdi
callq 0x23380
movq -0xe8(%rbp), %rdi
callq 0x1c0130
movb %al, -0xe9(%rbp)
jmp 0xa00be
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0xa027f
jmp 0xa00ce
movq -0xd8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x80(%rbp), %rdi
callq 0x610c0
jmp 0xa00e4
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x1be40
movq -0xf8(%rbp), %rdx
leaq 0x271fdd(%rip), %rsi # 0x3120e2
leaq -0xa0(%rbp), %rdi
callq 0x21b70
jmp 0xa0113
movq -0xd8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x100(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x1c7a80
jmp 0xa0133
movq -0x100(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x289570
jmp 0xa014f
leaq -0x70(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
leaq -0xb8(%rbp), %rcx
callq 0x231b30
jmp 0xa016c
movq -0xe8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x42b50
leaq -0x70(%rbp), %rdi
callq 0x23380
leaq -0xb8(%rbp), %rdi
callq 0x23380
leaq -0xc8(%rbp), %rdi
callq 0x23380
leaq -0xa0(%rbp), %rdi
callq 0x1c1e8
leaq -0xa1(%rbp), %rdi
callq 0x1c1d0
leaq -0x80(%rbp), %rdi
callq 0x23380
jmp 0xa027f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa01e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x49(%rbp), %rdi
callq 0x1c1d0
leaq -0x28(%rbp), %rdi
callq 0x23380
jmp 0xa02b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa02a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa025c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0250
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x23380
leaq -0xc8(%rbp), %rdi
callq 0x23380
leaq -0xa0(%rbp), %rdi
callq 0x1c1e8
leaq -0xa1(%rbp), %rdi
callq 0x1c1d0
leaq -0x80(%rbp), %rdi
callq 0x23380
jmp 0xa02a5
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xa0295
movq -0xe8(%rbp), %rdi
callq 0x23380
movq -0xe0(%rbp), %rax
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq -0xe8(%rbp), %rdi
callq 0x23380
movq -0x58(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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.getObjectHandle());
QPDFObjGen::set visited;
traverseField(ff.getObjectHandle(), QPDFObjectHandle::newNull(), 0, visited);
}
|
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(%rip), %rsi # 0x311e6f
leaq -0x50(%rbp), %rdi
callq 0x21b70
jmp 0xa0317
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x231400
jmp 0xa032a
leaq -0x50(%rbp), %rdi
callq 0x1c1e8
leaq -0x51(%rbp), %rdi
callq 0x1c1d0
leaq -0x30(%rbp), %rdi
callq 0x1c0100
movb %al, -0x129(%rbp)
jmp 0xa034d
movb -0x129(%rbp), %al
testb $0x1, %al
jne 0xa0489
jmp 0xa035d
leaq -0x99(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x1be40
movq -0x138(%rbp), %rdx
leaq 0x271af1(%rip), %rsi # 0x311e6f
leaq -0x98(%rbp), %rdi
callq 0x21b70
jmp 0xa038c
leaq -0xb0(%rbp), %rdi
callq 0x1c50b0
jmp 0xa039a
leaq -0x78(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x98(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
callq 0x231b30
jmp 0xa03b7
leaq -0x30(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x42b50
leaq -0x78(%rbp), %rdi
callq 0x23380
leaq -0xb0(%rbp), %rdi
callq 0x23380
leaq -0x98(%rbp), %rdi
callq 0x1c1e8
leaq -0x99(%rbp), %rdi
callq 0x1c1d0
jmp 0xa0489
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa0419
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c1e8
leaq -0x51(%rbp), %rdi
callq 0x1c1d0
jmp 0xa05be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa05b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa0478
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa046c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x23380
leaq -0x98(%rbp), %rdi
callq 0x1c1e8
leaq -0x99(%rbp), %rdi
callq 0x1c1d0
jmp 0xa05b5
movq -0x128(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0xa9bb0
jmp 0xa049e
leaq -0x30(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x22c4c0
jmp 0xa04b0
leaq -0xc0(%rbp), %rdi
callq 0x23380
leaq -0xf0(%rbp), %rdi
callq 0x43070
movq -0x128(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0xa9bb0
jmp 0xa04dd
leaq -0x110(%rbp), %rdi
callq 0x1c4c30
jmp 0xa04eb
movq -0x120(%rbp), %rdi
leaq -0x100(%rbp), %rsi
leaq -0x110(%rbp), %rdx
xorl %ecx, %ecx
leaq -0xf0(%rbp), %r8
callq 0xa05d0
jmp 0xa0510
leaq -0x110(%rbp), %rdi
callq 0x23380
leaq -0x100(%rbp), %rdi
callq 0x23380
leaq -0xf0(%rbp), %rdi
callq 0x431b0
leaq -0x30(%rbp), %rdi
callq 0x23380
leaq -0x20(%rbp), %rdi
callq 0x23380
addq $0x140, %rsp # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x23380
jmp 0xa05b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa05a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa059d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x23380
leaq -0x100(%rbp), %rdi
callq 0x23380
leaq -0xf0(%rbp), %rdi
callq 0x431b0
leaq -0x30(%rbp), %rdi
callq 0x23380
leaq -0x20(%rbp), %rdi
callq 0x23380
movq -0x60(%rbp), %rdi
callq 0x1b960
|
/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;
}
if (!field.isIndirect()) {
QTC::TC("qpdf", "QPDFAcroFormDocumentHelper direct field");
field.warnIfPossible(
"encountered a direct object as a field or annotation while "
"traversing /AcroForm; ignoring field or annotation");
return;
}
if (!field.isDictionary()) {
QTC::TC("qpdf", "QPDFAcroFormDocumentHelper non-dictionary field");
field.warnIfPossible(
"encountered a non-dictionary as a field or annotation while"
" traversing /AcroForm; ignoring field or annotation");
return;
}
QPDFObjGen og(field.getObjGen());
if (!visited.add(og)) {
QTC::TC("qpdf", "QPDFAcroFormDocumentHelper loop");
field.warnIfPossible("loop detected while traversing /AcroForm");
return;
}
// A dictionary encountered while traversing the /AcroForm field may be a form field, an
// annotation, or the merger of the two. A field that has no fields below it is a terminal. If a
// terminal field looks like an annotation, it is an annotation because annotation dictionary
// fields can be merged with terminal field dictionaries. Otherwise, the annotation fields might
// be there to be inherited by annotations below it.
bool is_annotation = false;
bool is_field = (0 == depth);
if (auto a = field.getKey("/Kids").as_array(strict)) {
is_field = true;
for (auto const& item: a) {
traverseField(item, field, 1 + depth, visited);
}
} else {
if (field.hasKey("/Parent")) {
is_field = true;
}
if (field.hasKey("/Subtype") || field.hasKey("/Rect") || field.hasKey("/AP")) {
is_annotation = true;
}
}
QTC::TC("qpdf", "QPDFAcroFormDocumentHelper field found", (depth == 0) ? 0 : 1);
QTC::TC("qpdf", "QPDFAcroFormDocumentHelper annotation found", (is_field ? 0 : 1));
if (is_annotation) {
QPDFObjectHandle our_field = (is_field ? field : parent);
m->field_to_annotations[our_field.getObjGen()].emplace_back(field);
m->annotation_to_field[og] = QPDFFormFieldObjectHelper(our_field);
}
if (is_field && (field.hasKey("/T"))) {
QPDFFormFieldObjectHelper foh(field);
auto f_og = field.getObjGen();
std::string name = foh.getFullyQualifiedName();
auto old = m->field_to_name.find(f_og);
if (old != m->field_to_name.end()) {
// We might be updating after a name change, so remove any old information
std::string old_name = old->second;
m->name_to_fields[old_name].erase(f_og);
}
m->field_to_name[f_og] = name;
m->name_to_fields[name].insert(f_og);
}
}
|
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 0xa13ee
movq -0x340(%rbp), %rdi
callq 0x1c1bf0
testb $0x1, %al
jne 0xa06be
leaq 0x29190b(%rip), %rdi # 0x331f38
leaq 0x27193a(%rip), %rsi # 0x311f6e
xorl %edx, %edx
callq 0x25230
leaq -0x49(%rbp), %rdi
movq %rdi, -0x348(%rbp)
callq 0x1be40
movq -0x348(%rbp), %rdx
leaq 0x27193d(%rip), %rsi # 0x311f96
leaq -0x48(%rbp), %rdi
callq 0x21b70
jmp 0xa0664
movq -0x340(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c0ae0
jmp 0xa0676
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x49(%rbp), %rdi
callq 0x1c1d0
jmp 0xa13ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa06b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x49(%rbp), %rdi
callq 0x1c1d0
jmp 0xa13f7
movq -0x340(%rbp), %rdi
callq 0x1c0130
testb $0x1, %al
jne 0xa0773
leaq 0x29185f(%rip), %rdi # 0x331f38
leaq 0x271924(%rip), %rsi # 0x312004
xorl %edx, %edx
callq 0x25230
leaq -0x81(%rbp), %rdi
movq %rdi, -0x350(%rbp)
callq 0x1be40
movq -0x350(%rbp), %rdx
leaq 0x27192c(%rip), %rsi # 0x312034
leaq -0x80(%rbp), %rdi
callq 0x21b70
jmp 0xa0713
movq -0x340(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1c0ae0
jmp 0xa0725
leaq -0x80(%rbp), %rdi
callq 0x1c1e8
leaq -0x81(%rbp), %rdi
callq 0x1c1d0
jmp 0xa13ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0762
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1c1e8
leaq -0x81(%rbp), %rdi
callq 0x1c1d0
jmp 0xa13f7
movq -0x340(%rbp), %rdi
callq 0x1c2e70
movq %rax, -0x8c(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8c(%rbp), %rax
movq %rax, -0x94(%rbp)
movq -0x94(%rbp), %rsi
callq 0x430e0
testb $0x1, %al
jne 0xa0859
leaq 0x291785(%rip), %rdi # 0x331f38
leaq 0x2718e9(%rip), %rsi # 0x3120a3
xorl %edx, %edx
callq 0x25230
leaq -0xb9(%rbp), %rdi
movq %rdi, -0x358(%rbp)
callq 0x1be40
movq -0x358(%rbp), %rdx
leaq 0x2718e1(%rip), %rsi # 0x3120c3
leaq -0xb8(%rbp), %rdi
callq 0x21b70
jmp 0xa07f0
movq -0x340(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x1c0ae0
jmp 0xa0805
leaq -0xb8(%rbp), %rdi
callq 0x1c1e8
leaq -0xb9(%rbp), %rdi
callq 0x1c1d0
jmp 0xa13ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0848
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x1c1e8
leaq -0xb9(%rbp), %rdi
callq 0x1c1d0
jmp 0xa13f7
movb $0x0, -0xba(%rbp)
movl -0x1c(%rbp), %eax
testl %eax, %eax
sete -0xbb(%rbp)
leaq -0x109(%rbp), %rdi
movq %rdi, -0x360(%rbp)
callq 0x1be40
movq -0x360(%rbp), %rdx
leaq 0x26e4fb(%rip), %rsi # 0x30ed88
leaq -0x108(%rbp), %rdi
callq 0x21b70
jmp 0xa089b
movq -0x340(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
leaq -0x108(%rbp), %rdx
callq 0x231400
jmp 0xa08b7
leaq -0xd8(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
xorl %edx, %edx
callq 0x64460
jmp 0xa08ce
leaq -0xe8(%rbp), %rdi
callq 0x23380
leaq -0x108(%rbp), %rdi
callq 0x1c1e8
leaq -0x109(%rbp), %rdi
callq 0x1c1d0
leaq -0xd8(%rbp), %rdi
callq 0x42cb0
movb %al, -0x361(%rbp)
jmp 0xa0906
movb -0x361(%rbp), %al
testb $0x1, %al
jne 0xa0915
jmp 0xa0ab1
movb $0x1, -0xbb(%rbp)
leaq -0xd8(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rdi
callq 0x22a010
movq %rax, -0x370(%rbp)
jmp 0xa093f
movq -0x370(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x118(%rbp), %rdi
callq 0x22a270
movq %rax, -0x378(%rbp)
jmp 0xa0962
movq -0x378(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x120(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x640c0
testb $0x1, %al
jne 0xa098c
jmp 0xa0aac
leaq -0x120(%rbp), %rdi
callq 0x64100
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rsi
leaq -0x140(%rbp), %rdi
movq %rdi, -0x388(%rbp)
callq 0x42b80
movq -0x340(%rbp), %rsi
leaq -0x150(%rbp), %rdi
movq %rdi, -0x380(%rbp)
callq 0x42b80
movq -0x330(%rbp), %rdi
movq -0x388(%rbp), %rsi
movq -0x380(%rbp), %rdx
movl -0x1c(%rbp), %ecx
incl %ecx
movq -0x28(%rbp), %r8
callq 0xa05d0
jmp 0xa09f8
leaq -0x150(%rbp), %rdi
callq 0x23380
leaq -0x140(%rbp), %rdi
callq 0x23380
leaq -0x120(%rbp), %rdi
callq 0x64120
jmp 0xa0970
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0a61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0a55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x23380
leaq -0x108(%rbp), %rdi
callq 0x1c1e8
leaq -0x109(%rbp), %rdi
callq 0x1c1d0
jmp 0xa13f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0fcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x150(%rbp), %rdi
callq 0x23380
leaq -0x140(%rbp), %rdi
callq 0x23380
jmp 0xa0fcf
jmp 0xa0e27
leaq -0x171(%rbp), %rdi
movq %rdi, -0x390(%rbp)
callq 0x1be40
movq -0x390(%rbp), %rdx
leaq 0x2713a8(%rip), %rsi # 0x311e7a
leaq -0x170(%rbp), %rdi
callq 0x21b70
jmp 0xa0ae0
movq -0x340(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0x2312c0
movb %al, -0x391(%rbp)
jmp 0xa0afb
leaq -0x170(%rbp), %rdi
callq 0x1c1e8
leaq -0x171(%rbp), %rdi
callq 0x1c1d0
movb -0x391(%rbp), %al
testb $0x1, %al
jne 0xa0b1f
jmp 0xa0b5f
movb $0x1, -0xbb(%rbp)
jmp 0xa0b5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0b4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x1c1e8
leaq -0x171(%rbp), %rdi
callq 0x1c1d0
jmp 0xa0fcf
leaq -0x199(%rbp), %rdi
movq %rdi, -0x3a0(%rbp)
callq 0x1be40
movq -0x3a0(%rbp), %rdx
movb $0x0, -0x1c2(%rbp)
movb $0x0, -0x1c3(%rbp)
movb $0x0, -0x1ea(%rbp)
movb $0x0, -0x1eb(%rbp)
leaq 0x271550(%rip), %rsi # 0x3120ec
leaq -0x198(%rbp), %rdi
callq 0x21b70
jmp 0xa0baa
movq -0x340(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x2312c0
movb %al, -0x3a1(%rbp)
jmp 0xa0bc5
movb -0x3a1(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x3a2(%rbp)
jne 0xa0cb1
jmp 0xa0bde
leaq -0x1c1(%rbp), %rdi
movq %rdi, -0x3b0(%rbp)
callq 0x1be40
movq -0x3b0(%rbp), %rdx
movb $0x1, -0x1c2(%rbp)
leaq 0x2714ef(%rip), %rsi # 0x3120f5
leaq -0x1c0(%rbp), %rdi
callq 0x21b70
jmp 0xa0c14
movq -0x340(%rbp), %rdi
movb $0x1, -0x1c3(%rbp)
leaq -0x1c0(%rbp), %rsi
callq 0x2312c0
movb %al, -0x3b1(%rbp)
jmp 0xa0c36
movb -0x3b1(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x3a2(%rbp)
jne 0xa0cb1
jmp 0xa0c4b
leaq -0x1e9(%rbp), %rdi
movq %rdi, -0x3c0(%rbp)
callq 0x1be40
movq -0x3c0(%rbp), %rdx
movb $0x1, -0x1ea(%rbp)
leaq 0x271488(%rip), %rsi # 0x3120fb
leaq -0x1e8(%rbp), %rdi
callq 0x21b70
jmp 0xa0c81
movq -0x340(%rbp), %rdi
movb $0x1, -0x1eb(%rbp)
leaq -0x1e8(%rbp), %rsi
callq 0x2312c0
movb %al, -0x3c1(%rbp)
jmp 0xa0ca3
movb -0x3c1(%rbp), %al
movb %al, -0x3a2(%rbp)
jmp 0xa0cb1
movb -0x3a2(%rbp), %al
movb %al, -0x3c2(%rbp)
testb $0x1, -0x1eb(%rbp)
jne 0xa0cc8
jmp 0xa0cd4
leaq -0x1e8(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x1ea(%rbp)
jne 0xa0cdf
jmp 0xa0ceb
leaq -0x1e9(%rbp), %rdi
callq 0x1c1d0
testb $0x1, -0x1c3(%rbp)
jne 0xa0cf6
jmp 0xa0d02
leaq -0x1c0(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x1c2(%rbp)
jne 0xa0d0d
jmp 0xa0d19
leaq -0x1c1(%rbp), %rdi
callq 0x1c1d0
leaq -0x198(%rbp), %rdi
callq 0x1c1e8
leaq -0x199(%rbp), %rdi
callq 0x1c1d0
movb -0x3c2(%rbp), %al
testb $0x1, %al
jne 0xa0d40
jmp 0xa0e25
movb $0x1, -0xba(%rbp)
jmp 0xa0e25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0e14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0e08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0def
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0dd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0dbd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
testb $0x1, -0x1eb(%rbp)
jne 0xa0daf
jmp 0xa0dbb
leaq -0x1e8(%rbp), %rdi
callq 0x1c1e8
jmp 0xa0dbd
testb $0x1, -0x1ea(%rbp)
jne 0xa0dc8
jmp 0xa0dd4
leaq -0x1e9(%rbp), %rdi
callq 0x1c1d0
jmp 0xa0dd6
testb $0x1, -0x1c3(%rbp)
jne 0xa0de1
jmp 0xa0ded
leaq -0x1c0(%rbp), %rdi
callq 0x1c1e8
jmp 0xa0def
testb $0x1, -0x1c2(%rbp)
jne 0xa0dfa
jmp 0xa0e06
leaq -0x1c1(%rbp), %rdi
callq 0x1c1d0
jmp 0xa0e08
leaq -0x198(%rbp), %rdi
callq 0x1c1e8
leaq -0x199(%rbp), %rdi
callq 0x1c1d0
jmp 0xa0fcf
jmp 0xa0e27
leaq -0xd8(%rbp), %rdi
callq 0x64540
movl -0x1c(%rbp), %ecx
movl $0x1, %edx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovel %eax, %edx
leaq 0x2910ee(%rip), %rdi # 0x331f38
leaq 0x2712ae(%rip), %rsi # 0x3120ff
callq 0x25230
movb -0xbb(%rbp), %cl
movl $0x1, %edx
xorl %eax, %eax
testb $0x1, %cl
cmovnel %eax, %edx
leaq 0x2910c8(%rip), %rdi # 0x331f38
leaq 0x2712af(%rip), %rsi # 0x312126
callq 0x25230
testb $0x1, -0xba(%rbp)
je 0xa1031
testb $0x1, -0xbb(%rbp)
je 0xa0ea2
movq -0x340(%rbp), %rax
movq %rax, -0x3d0(%rbp)
jmp 0xa0eb2
movq -0x338(%rbp), %rax
movq %rax, -0x3d0(%rbp)
jmp 0xa0eb2
movq -0x3d0(%rbp), %rsi
leaq -0x200(%rbp), %rdi
movq %rdi, -0x3e8(%rbp)
callq 0x42b80
movq -0x330(%rbp), %rdi
addq $0x10, %rdi
callq 0xa9b50
movq -0x3e8(%rbp), %rdi
addq $0x8, %rax
movq %rax, -0x3e0(%rbp)
callq 0x1c2e70
movq %rax, -0x3d8(%rbp)
jmp 0xa0efc
movq -0x3e0(%rbp), %rdi
movq -0x3d8(%rbp), %rax
movq %rax, -0x208(%rbp)
leaq -0x208(%rbp), %rsi
callq 0xab000
movq %rax, -0x3f0(%rbp)
jmp 0xa0f26
movq -0x340(%rbp), %rsi
movq -0x3f0(%rbp), %rdi
callq 0xaaf00
jmp 0xa0f3b
leaq -0x250(%rbp), %rdi
movq %rdi, -0x3f8(%rbp)
leaq -0x200(%rbp), %rsi
callq 0x42b80
movq -0x3f8(%rbp), %rsi
leaq -0x240(%rbp), %rdi
callq 0xdad40
jmp 0xa0f6a
movq -0x330(%rbp), %rdi
addq $0x10, %rdi
callq 0xa9b50
movq %rax, %rdi
addq $0x38, %rdi
leaq -0x8c(%rbp), %rsi
callq 0xaacb0
movq %rax, -0x400(%rbp)
jmp 0xa0f96
movq -0x400(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0xaad90
leaq -0x240(%rbp), %rdi
callq 0xa9dd0
leaq -0x250(%rbp), %rdi
callq 0x23380
leaq -0x200(%rbp), %rdi
callq 0x23380
jmp 0xa1031
leaq -0xd8(%rbp), %rdi
callq 0x64540
jmp 0xa13f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa1020
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa1014
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0xa9dd0
leaq -0x250(%rbp), %rdi
callq 0x23380
leaq -0x200(%rbp), %rdi
callq 0x23380
jmp 0xa13f7
movb -0xbb(%rbp), %cl
movb $0x0, -0x272(%rbp)
movb $0x0, -0x273(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x401(%rbp)
je 0xa10b8
leaq -0x271(%rbp), %rdi
movq %rdi, -0x410(%rbp)
callq 0x1be40
movq -0x410(%rbp), %rdx
movb $0x1, -0x272(%rbp)
leaq 0x270dfd(%rip), %rsi # 0x311e77
leaq -0x270(%rbp), %rdi
callq 0x21b70
jmp 0xa1088
movq -0x340(%rbp), %rdi
movb $0x1, -0x273(%rbp)
leaq -0x270(%rbp), %rsi
callq 0x2312c0
movb %al, -0x411(%rbp)
jmp 0xa10aa
movb -0x411(%rbp), %al
movb %al, -0x401(%rbp)
jmp 0xa10b8
movb -0x401(%rbp), %al
movb %al, -0x412(%rbp)
testb $0x1, -0x273(%rbp)
jne 0xa10cf
jmp 0xa10db
leaq -0x270(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x272(%rbp)
jne 0xa10e6
jmp 0xa10f2
leaq -0x271(%rbp), %rdi
callq 0x1c1d0
movb -0x412(%rbp), %al
testb $0x1, %al
jne 0xa1101
jmp 0xa13ee
movq -0x340(%rbp), %rsi
leaq -0x2c0(%rbp), %rdi
movq %rdi, -0x420(%rbp)
callq 0x42b80
movq -0x420(%rbp), %rsi
leaq -0x2b0(%rbp), %rdi
callq 0xdad40
jmp 0xa1130
leaq -0x2c0(%rbp), %rdi
callq 0x23380
movq -0x340(%rbp), %rdi
callq 0x1c2e70
movq %rax, -0x428(%rbp)
jmp 0xa1151
movq -0x428(%rbp), %rax
movq %rax, -0x2c8(%rbp)
leaq -0x2e8(%rbp), %rdi
leaq -0x2b0(%rbp), %rsi
callq 0xdbbf0
jmp 0xa1174
movq -0x330(%rbp), %rdi
addq $0x10, %rdi
callq 0xa9b50
movq %rax, %rdi
addq $0x68, %rdi
leaq -0x2c8(%rbp), %rsi
callq 0xaa2c0
movq %rax, -0x430(%rbp)
jmp 0xa11a0
movq -0x330(%rbp), %rdi
movq -0x430(%rbp), %rax
movq %rax, -0x2f0(%rbp)
addq $0x10, %rdi
callq 0xa9b50
movq %rax, %rdi
addq $0x68, %rdi
callq 0xaa320
movq %rax, -0x2f8(%rbp)
leaq -0x2f0(%rbp), %rdi
leaq -0x2f8(%rbp), %rsi
callq 0xaa2f0
testb $0x1, %al
jne 0xa11ed
jmp 0xa130e
leaq -0x2f0(%rbp), %rdi
callq 0xaa430
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x318(%rbp), %rdi
callq 0x1b1c0
jmp 0xa120e
movq -0x330(%rbp), %rdi
addq $0x10, %rdi
callq 0xa9b50
movq %rax, %rdi
addq $0x98, %rdi
leaq -0x318(%rbp), %rsi
callq 0xaa350
movq %rax, -0x438(%rbp)
jmp 0xa123d
movq -0x438(%rbp), %rdi
leaq -0x2c8(%rbp), %rsi
callq 0x69a40
jmp 0xa1252
leaq -0x318(%rbp), %rdi
callq 0x1c1e8
jmp 0xa130e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa1296
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
testb $0x1, -0x273(%rbp)
jne 0xa1288
jmp 0xa1294
leaq -0x270(%rbp), %rdi
callq 0x1c1e8
jmp 0xa1296
testb $0x1, -0x272(%rbp)
jne 0xa12a1
jmp 0xa12ad
leaq -0x271(%rbp), %rdi
callq 0x1c1d0
jmp 0xa13f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x2c0(%rbp), %rdi
callq 0x23380
jmp 0xa13f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa13e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa13d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x318(%rbp), %rdi
callq 0x1c1e8
jmp 0xa13d4
movq -0x330(%rbp), %rdi
addq $0x10, %rdi
callq 0xa9b50
movq %rax, %rdi
addq $0x68, %rdi
leaq -0x2c8(%rbp), %rsi
callq 0xab0e0
movq %rax, -0x440(%rbp)
jmp 0xa133a
movq -0x440(%rbp), %rdi
leaq -0x2e8(%rbp), %rsi
callq 0x1c110
jmp 0xa134f
movq -0x330(%rbp), %rdi
addq $0x10, %rdi
callq 0xa9b50
movq %rax, %rdi
addq $0x98, %rdi
leaq -0x2e8(%rbp), %rsi
callq 0xaa350
movq %rax, -0x448(%rbp)
jmp 0xa137e
movq -0x448(%rbp), %rdi
leaq -0x2c8(%rbp), %rsi
callq 0xab1c0
movb %dl, -0x451(%rbp)
movq %rax, -0x450(%rbp)
jmp 0xa13a0
movb -0x451(%rbp), %al
movq -0x450(%rbp), %rcx
movq %rcx, -0x328(%rbp)
movb %al, -0x320(%rbp)
leaq -0x2e8(%rbp), %rdi
callq 0x1c1e8
leaq -0x2b0(%rbp), %rdi
callq 0xa9dd0
jmp 0xa13ee
leaq -0x2e8(%rbp), %rdi
callq 0x1c1e8
leaq -0x2b0(%rbp), %rdi
callq 0xa9dd0
jmp 0xa13f7
addq $0x460, %rsp # imm = 0x460
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x1b960
|
/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& obj = queue.front();
if (seen.add(obj)) {
auto kids = obj.getKey("/Kids");
if (kids.isArray()) {
for (auto const& kid: kids.aitems()) {
queue.push_back(kid);
}
}
if (obj.hasKey("/T")) {
// Find something we can append to the partial name that makes the fully qualified
// name unique. When we find something, reuse the same suffix for all fields in this
// group with the same name. We can only change the name of fields that have /T, and
// this field's /T is always at the end of the fully qualified name, appending to /T
// has the effect of appending the same thing to the fully qualified name.
std::string old_name = QPDFFormFieldObjectHelper(obj).getFullyQualifiedName();
if (renames.count(old_name) == 0) {
std::string new_name = old_name;
int suffix = 0;
std::string append;
while (!getFieldsWithQualifiedName(new_name).empty()) {
++suffix;
append = "+" + std::to_string(suffix);
new_name = old_name + append;
}
renames[old_name] = append;
}
std::string append = renames[old_name];
if (!append.empty()) {
obj.replaceKey(
"/T",
QPDFObjectHandle::newUnicodeString(
obj.getKey("/T").getUTF8Value() + append));
}
}
}
}
for (auto const& i: fields) {
addFormField(i);
}
}
|
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 -0x418(%rbp), %rdi
movq %rax, -0x90(%rbp)
callq 0x64090
movq %rax, -0x98(%rbp)
leaq -0x99(%rbp), %rdi
movq %rdi, -0x410(%rbp)
callq 0x657a0
movq -0x410(%rbp), %rcx
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0xa9c00
jmp 0xa1498
leaq -0x99(%rbp), %rdi
callq 0x67860
leaq -0x88(%rbp), %rdi
callq 0xa9cb0
xorb $-0x1, %al
testb $0x1, %al
jne 0xa14f4
movl $0x2, -0xb0(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xa9f80
jmp 0xa1e27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x99(%rbp), %rdi
callq 0x67860
jmp 0xa1f52
leaq -0x88(%rbp), %rdi
callq 0xa9cd0
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rdi
callq 0x1bc050
movq %rax, -0x428(%rbp)
jmp 0xa151c
movq -0x428(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x430e0
movb %al, -0x429(%rbp)
jmp 0xa1542
movb -0x429(%rbp), %al
testb $0x1, %al
jne 0xa1551
jmp 0xa1e03
movq -0xb8(%rbp), %rax
movq %rax, -0x440(%rbp)
leaq -0xf1(%rbp), %rdi
movq %rdi, -0x438(%rbp)
callq 0x1be40
movq -0x438(%rbp), %rdx
leaq 0x26d808(%rip), %rsi # 0x30ed88
leaq -0xf0(%rbp), %rdi
callq 0x21b70
jmp 0xa158e
movq -0x440(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
leaq -0xf0(%rbp), %rdx
callq 0x231400
jmp 0xa15aa
leaq -0xf0(%rbp), %rdi
callq 0x1c1e8
leaq -0xf1(%rbp), %rdi
callq 0x1c1d0
leaq -0xd0(%rbp), %rdi
callq 0x1c0100
movb %al, -0x441(%rbp)
jmp 0xa15d6
movb -0x441(%rbp), %al
testb $0x1, %al
jne 0xa15e5
jmp 0xa17ba
leaq -0x110(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x1c17f0
jmp 0xa15fa
leaq -0x110(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x100(%rbp), %rsi
leaq -0x138(%rbp), %rdi
callq 0x1c3110
jmp 0xa161d
movq -0x100(%rbp), %rsi
leaq -0x160(%rbp), %rdi
callq 0x1c3140
jmp 0xa1632
jmp 0xa1634
leaq -0x138(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0xa9d00
movb %al, -0x442(%rbp)
jmp 0xa164f
movb -0x442(%rbp), %al
testb $0x1, %al
jne 0xa174e
jmp 0xa165f
movl $0x5, -0xb0(%rbp)
leaq -0x160(%rbp), %rdi
callq 0xa9d70
leaq -0x138(%rbp), %rdi
callq 0xa9d70
leaq -0x110(%rbp), %rdi
callq 0xa9db0
jmp 0xa17b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa1e16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa16db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x1c1e8
leaq -0xf1(%rbp), %rdi
callq 0x1c1d0
jmp 0xa1e16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa1df5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa17a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa179b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x160(%rbp), %rdi
callq 0xa9d70
jmp 0xa179b
leaq -0x138(%rbp), %rdi
callq 0x1c3170
movq %rax, -0x450(%rbp)
jmp 0xa1763
movq -0x450(%rbp), %rax
movq %rax, -0x168(%rbp)
movq -0x168(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0xa9d30
jmp 0xa1786
jmp 0xa1788
leaq -0x138(%rbp), %rdi
callq 0x1c31a0
jmp 0xa1796
jmp 0xa1634
leaq -0x138(%rbp), %rdi
callq 0xa9d70
leaq -0x110(%rbp), %rdi
callq 0xa9db0
jmp 0xa1df5
jmp 0xa17ba
movq -0xb8(%rbp), %rax
movq %rax, -0x460(%rbp)
leaq -0x189(%rbp), %rdi
movq %rdi, -0x458(%rbp)
callq 0x1be40
movq -0x458(%rbp), %rdx
leaq 0x27068e(%rip), %rsi # 0x311e77
leaq -0x188(%rbp), %rdi
callq 0x21b70
jmp 0xa17f7
movq -0x460(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x2312c0
movb %al, -0x461(%rbp)
jmp 0xa1812
leaq -0x188(%rbp), %rdi
callq 0x1c1e8
leaq -0x189(%rbp), %rdi
callq 0x1c1d0
movb -0x461(%rbp), %al
testb $0x1, %al
jne 0xa1839
jmp 0xa1de7
movq -0xb8(%rbp), %rsi
leaq -0x1f8(%rbp), %rdi
movq %rdi, -0x470(%rbp)
callq 0x42b80
movq -0x470(%rbp), %rsi
leaq -0x1e8(%rbp), %rdi
callq 0xdad40
jmp 0xa1868
leaq -0x1b0(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0xdbbf0
jmp 0xa187d
leaq -0x1e8(%rbp), %rdi
callq 0xa9dd0
leaq -0x1f8(%rbp), %rdi
callq 0x23380
leaq -0x40(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xa9e10
movq %rax, -0x478(%rbp)
jmp 0xa18ae
movq -0x478(%rbp), %rax
cmpq $0x0, %rax
jne 0xa1b22
leaq -0x218(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x1b1c0
jmp 0xa18d4
movl $0x0, -0x21c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x1b510
movq -0x420(%rbp), %rsi
leaq -0x270(%rbp), %rdi
leaq -0x218(%rbp), %rdx
callq 0xa1f70
jmp 0xa1906
leaq -0x270(%rbp), %rdi
callq 0x64040
xorb $-0x1, %al
movb %al, -0x479(%rbp)
leaq -0x270(%rbp), %rdi
callq 0x447e0
movb -0x479(%rbp), %al
testb $0x1, %al
jne 0xa1935
jmp 0xa1abd
movl -0x21c(%rbp), %eax
incl %eax
movl %eax, -0x21c(%rbp)
movl -0x21c(%rbp), %esi
leaq -0x2b0(%rbp), %rdi
callq 0x243e0
jmp 0xa1957
leaq 0x28d358(%rip), %rsi # 0x32ecb6
leaq -0x290(%rbp), %rdi
leaq -0x2b0(%rbp), %rdx
callq 0x1ea00
jmp 0xa1973
leaq -0x240(%rbp), %rdi
movq %rdi, -0x488(%rbp)
leaq -0x290(%rbp), %rsi
movq %rsi, -0x490(%rbp)
callq 0x1b790
movq -0x490(%rbp), %rdi
callq 0x1c1e8
leaq -0x2b0(%rbp), %rdi
callq 0x1c1e8
movq -0x488(%rbp), %rdx
leaq -0x2d0(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x3a780
jmp 0xa19c8
leaq -0x218(%rbp), %rdi
leaq -0x2d0(%rbp), %rsi
callq 0x1b790
leaq -0x2d0(%rbp), %rdi
callq 0x1c1e8
jmp 0xa18ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa1a1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x1c1e8
leaq -0x189(%rbp), %rdi
callq 0x1c1d0
jmp 0xa1df5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa1a61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0xa9dd0
leaq -0x1f8(%rbp), %rdi
callq 0x23380
jmp 0xa1df5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa1dd9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa1b05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x2b0(%rbp), %rdi
callq 0x1c1e8
jmp 0xa1b05
leaq -0x40(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xa9e70
movq %rax, -0x498(%rbp)
jmp 0xa1ad6
movq -0x498(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x1c110
jmp 0xa1aeb
leaq -0x240(%rbp), %rdi
callq 0x1c1e8
leaq -0x218(%rbp), %rdi
callq 0x1c1e8
jmp 0xa1b22
leaq -0x240(%rbp), %rdi
callq 0x1c1e8
leaq -0x218(%rbp), %rdi
callq 0x1c1e8
jmp 0xa1dd9
leaq -0x40(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xa9e70
movq %rax, -0x4a0(%rbp)
jmp 0xa1b3b
movq -0x4a0(%rbp), %rsi
leaq -0x2f0(%rbp), %rdi
callq 0x1b1c0
jmp 0xa1b50
leaq -0x2f0(%rbp), %rdi
callq 0x1b450
testb $0x1, %al
jne 0xa1dbf
movq -0xb8(%rbp), %rax
movq %rax, -0x4b0(%rbp)
leaq -0x311(%rbp), %rdi
movq %rdi, -0x4a8(%rbp)
callq 0x1be40
movq -0x4a8(%rbp), %rdx
leaq 0x2702e4(%rip), %rsi # 0x311e77
leaq -0x310(%rbp), %rdi
callq 0x21b70
jmp 0xa1ba1
movq -0xb8(%rbp), %rax
movq %rax, -0x4c0(%rbp)
leaq -0x399(%rbp), %rdi
movq %rdi, -0x4b8(%rbp)
callq 0x1be40
movq -0x4b8(%rbp), %rdx
leaq 0x2702a7(%rip), %rsi # 0x311e77
leaq -0x398(%rbp), %rdi
callq 0x21b70
jmp 0xa1bde
movq -0x4c0(%rbp), %rsi
leaq -0x378(%rbp), %rdi
leaq -0x398(%rbp), %rdx
callq 0x231400
jmp 0xa1bfa
leaq -0x368(%rbp), %rdi
leaq -0x378(%rbp), %rsi
callq 0x1c1310
jmp 0xa1c0f
leaq -0x348(%rbp), %rdi
leaq -0x368(%rbp), %rsi
leaq -0x2f0(%rbp), %rdx
callq 0x24260
jmp 0xa1c2b
leaq -0x328(%rbp), %rdi
leaq -0x348(%rbp), %rsi
callq 0x1c7160
jmp 0xa1c40
movq -0x4b0(%rbp), %rdi
leaq -0x310(%rbp), %rsi
leaq -0x328(%rbp), %rdx
callq 0x231990
jmp 0xa1c5c
leaq -0x328(%rbp), %rdi
callq 0x23380
leaq -0x348(%rbp), %rdi
callq 0x1c1e8
leaq -0x368(%rbp), %rdi
callq 0x1c1e8
leaq -0x378(%rbp), %rdi
callq 0x23380
leaq -0x398(%rbp), %rdi
callq 0x1c1e8
leaq -0x399(%rbp), %rdi
callq 0x1c1d0
leaq -0x310(%rbp), %rdi
callq 0x1c1e8
leaq -0x311(%rbp), %rdi
callq 0x1c1d0
jmp 0xa1dbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa1da5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa1d8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa1d81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa1d75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa1d69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa1d5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x328(%rbp), %rdi
callq 0x23380
leaq -0x348(%rbp), %rdi
callq 0x1c1e8
leaq -0x368(%rbp), %rdi
callq 0x1c1e8
leaq -0x378(%rbp), %rdi
callq 0x23380
leaq -0x398(%rbp), %rdi
callq 0x1c1e8
leaq -0x399(%rbp), %rdi
callq 0x1c1d0
leaq -0x310(%rbp), %rdi
callq 0x1c1e8
leaq -0x311(%rbp), %rdi
callq 0x1c1d0
leaq -0x2f0(%rbp), %rdi
callq 0x1c1e8
jmp 0xa1dd9
leaq -0x2f0(%rbp), %rdi
callq 0x1c1e8
leaq -0x1b0(%rbp), %rdi
callq 0x1c1e8
jmp 0xa1de7
leaq -0x1b0(%rbp), %rdi
callq 0x1c1e8
jmp 0xa1df5
leaq -0xd0(%rbp), %rdi
callq 0x23380
jmp 0xa1e03
leaq -0xd0(%rbp), %rdi
callq 0x23380
jmp 0xa1e16
jmp 0xa1e05
leaq -0x88(%rbp), %rdi
callq 0xa9f50
jmp 0xa14a4
leaq -0x88(%rbp), %rdi
callq 0xa9f80
jmp 0xa1f52
movq -0x418(%rbp), %rax
movq %rax, -0x3a8(%rbp)
movq -0x3a8(%rbp), %rdi
callq 0x64060
movq %rax, -0x3b0(%rbp)
movq -0x3a8(%rbp), %rdi
callq 0x64090
movq %rax, -0x3b8(%rbp)
leaq -0x3b0(%rbp), %rdi
leaq -0x3b8(%rbp), %rsi
callq 0x640c0
testb $0x1, %al
jne 0xa1e77
jmp 0xa1f37
leaq -0x3b0(%rbp), %rdi
callq 0x64100
movq %rax, -0x3c0(%rbp)
movq -0x3c0(%rbp), %rsi
leaq -0x408(%rbp), %rdi
movq %rdi, -0x4c8(%rbp)
callq 0x42b80
movq -0x4c8(%rbp), %rsi
leaq -0x3f8(%rbp), %rdi
callq 0xdad40
jmp 0xa1eb9
movq -0x420(%rbp), %rdi
leaq -0x3f8(%rbp), %rsi
callq 0xa02c0
jmp 0xa1ece
leaq -0x3f8(%rbp), %rdi
callq 0xa9dd0
leaq -0x408(%rbp), %rdi
callq 0x23380
leaq -0x3b0(%rbp), %rdi
callq 0x64120
jmp 0xa1e5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa1f29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x3f8(%rbp), %rdi
callq 0xa9dd0
leaq -0x408(%rbp), %rdi
callq 0x23380
jmp 0xa1f52
leaq -0x70(%rbp), %rdi
callq 0x431b0
leaq -0x40(%rbp), %rdi
callq 0xa9fa0
addq $0x4d0, %rsp # imm = 0x4D0
popq %rbp
retq
leaq -0x70(%rbp), %rdi
callq 0x431b0
leaq -0x40(%rbp), %rdi
callq 0xa9fa0
movq -0xa8(%rbp), %rdi
callq 0x1b960
|
/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
movq -0x18(%rbp), %rsi
callq 0xaa660
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
callq 0xa9b50
movq %rax, %rdi
addq $0x98, %rdi
callq 0xaa6c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaa690
testb $0x1, %al
jne 0xa1ff3
jmp 0xa200e
leaq -0x20(%rbp), %rdi
callq 0xaa6f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0xaa710
jmp 0xa2027
movq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1b4c0
movq -0x40(%rbp), %rdi
callq 0x43980
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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_annotations[og];
}
return result;
}
|
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
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xa9bb0
jmp 0xa2abf
leaq -0x38(%rbp), %rdi
callq 0x1c2e70
movq %rax, -0x70(%rbp)
jmp 0xa2ace
movq -0x70(%rbp), %rax
movq %rax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x23380
movq -0x60(%rbp), %rdi
addq $0x10, %rdi
callq 0xa9b50
movq %rax, %rdi
addq $0x8, %rdi
leaq -0x24(%rbp), %rsi
callq 0xaa760
movq %rax, -0x78(%rbp)
jmp 0xa2b02
movq -0x78(%rbp), %rax
cmpq $0x0, %rax
je 0xa2b65
movq -0x60(%rbp), %rdi
addq $0x10, %rdi
callq 0xa9b50
movq %rax, %rdi
addq $0x8, %rdi
leaq -0x24(%rbp), %rsi
callq 0xaa7c0
movq %rax, -0x80(%rbp)
jmp 0xa2b2f
movq -0x80(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0xaa8a0
jmp 0xa2b3e
jmp 0xa2b65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa2b85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x23380
jmp 0xa2b85
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xa2b78
movq -0x58(%rbp), %rdi
callq 0xaaaf0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xaaaf0
movq -0x40(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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).getTopLevelField();
if (todo.add(field) && field.getObjectHandle().isDictionary()) {
result.push_back(field);
}
}
return result;
}
|
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 0x43070
movq -0x1b8(%rbp), %rdi
movb $0x0, -0x49(%rbp)
callq 0xaa4e0
movq -0x1b0(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0xaab50
movq -0x1a8(%rbp), %rsi
movq -0x1a0(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0xa2ba0
jmp 0xa2cdb
leaq -0xa8(%rbp), %rdi
callq 0xaaba0
leaq -0x70(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0xaa0f0
movq %rax, -0xc0(%rbp)
movq -0x58(%rbp), %rdi
callq 0xaa120
movq %rax, -0xc8(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xaa150
testb $0x1, %al
jne 0xa2d57
leaq -0x70(%rbp), %rdi
callq 0xaaaf0
jmp 0xa2f62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xaaba0
jmp 0xa2f91
leaq -0xc0(%rbp), %rdi
callq 0xaa190
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rsi
leaq -0x178(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0xaa1b0
movq -0x1a8(%rbp), %rsi
movq -0x1c8(%rbp), %rdx
leaq -0x140(%rbp), %rdi
callq 0xa2fc0
jmp 0xa2da0
xorl %eax, %eax
movl %eax, %edx
leaq -0x108(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0xdb000
jmp 0xa2db9
leaq -0x140(%rbp), %rdi
callq 0xa9dd0
leaq -0x178(%rbp), %rdi
callq 0xaa230
leaq -0x100(%rbp), %rdi
movb $0x0, -0x191(%rbp)
callq 0x1bc050
movq %rax, -0x1d0(%rbp)
jmp 0xa2ded
movq -0x1d0(%rbp), %rax
movq %rax, -0x180(%rbp)
movq -0x180(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x430e0
movb %al, -0x1d1(%rbp)
jmp 0xa2e13
movb -0x1d1(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1d2(%rbp)
jne 0xa2e28
jmp 0xa2e66
leaq -0x190(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0xa9bb0
jmp 0xa2e3d
movb $0x1, -0x191(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x1c0130
movb %al, -0x1d3(%rbp)
jmp 0xa2e58
movb -0x1d3(%rbp), %al
movb %al, -0x1d2(%rbp)
jmp 0xa2e66
movb -0x1d2(%rbp), %al
movb %al, -0x1d4(%rbp)
testb $0x1, -0x191(%rbp)
jne 0xa2e7d
jmp 0xa2e89
leaq -0x190(%rbp), %rdi
callq 0x23380
movb -0x1d4(%rbp), %al
testb $0x1, %al
jne 0xa2e98
jmp 0xa2f2e
movq -0x1b8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0xaabe0
jmp 0xa2ead
jmp 0xa2f2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0xa2ee1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x140(%rbp), %rdi
callq 0xa9dd0
leaq -0x178(%rbp), %rdi
callq 0xaa230
jmp 0xa2f57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0xa2f4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
testb $0x1, -0x191(%rbp)
jne 0xa2f20
jmp 0xa2f2c
leaq -0x190(%rbp), %rdi
callq 0x23380
jmp 0xa2f4b
leaq -0x108(%rbp), %rdi
callq 0xa9dd0
leaq -0xc0(%rbp), %rdi
callq 0xaa270
jmp 0xa2d0f
leaq -0x108(%rbp), %rdi
callq 0xa9dd0
leaq -0x70(%rbp), %rdi
callq 0xaaaf0
jmp 0xa2f91
movb $0x1, -0x49(%rbp)
testb $0x1, -0x49(%rbp)
jne 0xa2f78
movq -0x1b8(%rbp), %rdi
callq 0xaa600
leaq -0x48(%rbp), %rdi
callq 0x431b0
movq -0x1c0(%rbp), %rax
addq $0x1e0, %rsp # imm = 0x1E0
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0xaa600
leaq -0x48(%rbp), %rdi
callq 0x431b0
movq -0xb0(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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 result;
}
|
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
leaq -0x50(%rbp), %rdi
callq 0x21b70
jmp 0xa32ed
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x231400
jmp 0xa3300
leaq -0x50(%rbp), %rdi
callq 0x1c1e8
leaq -0x51(%rbp), %rdi
callq 0x1c1d0
leaq -0x30(%rbp), %rdi
callq 0x23380
movb $0x0, -0x9a(%rbp)
movb $0x0, -0x9b(%rbp)
movb $0x0, -0x9c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1c0130
movb %al, -0xe1(%rbp)
jmp 0xa3341
movb -0xe1(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xe2(%rbp)
jne 0xa3356
jmp 0xa33cf
leaq -0x99(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x1be40
movq -0xf0(%rbp), %rdx
movb $0x1, -0x9a(%rbp)
leaq 0x26edd4(%rip), %rsi # 0x312152
leaq -0x98(%rbp), %rdi
callq 0x21b70
jmp 0xa338c
movb $0x1, -0x9b(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x231400
jmp 0xa33a9
movb $0x1, -0x9c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1bf770
movb %al, -0xf1(%rbp)
jmp 0xa33c1
movb -0xf1(%rbp), %al
movb %al, -0xe2(%rbp)
jmp 0xa33cf
movb -0xe2(%rbp), %al
movb %al, -0xf2(%rbp)
testb $0x1, -0x9c(%rbp)
jne 0xa33e6
jmp 0xa33ef
leaq -0x78(%rbp), %rdi
callq 0x23380
testb $0x1, -0x9b(%rbp)
jne 0xa33fa
jmp 0xa3406
leaq -0x98(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x9a(%rbp)
jne 0xa3411
jmp 0xa341d
leaq -0x99(%rbp), %rdi
callq 0x1c1d0
movb -0xf2(%rbp), %al
testb $0x1, %al
jne 0xa342c
jmp 0xa35c5
leaq -0xd1(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x1be40
movq -0x100(%rbp), %rdx
leaq 0x26ed05(%rip), %rsi # 0x312152
leaq -0xd0(%rbp), %rdi
callq 0x21b70
jmp 0xa345b
leaq -0xb0(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
callq 0x231400
jmp 0xa3474
leaq -0xb0(%rbp), %rdi
callq 0x1c07c0
movb %al, -0x101(%rbp)
jmp 0xa3488
movb -0x101(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x23380
leaq -0xd0(%rbp), %rdi
callq 0x1c1e8
leaq -0xd1(%rbp), %rdi
callq 0x1c1d0
jmp 0xa35c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa34df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c1e8
leaq -0x51(%rbp), %rdi
callq 0x1c1d0
leaq -0x30(%rbp), %rdi
callq 0x23380
jmp 0xa35f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa35e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa355e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa3545
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
testb $0x1, -0x9c(%rbp)
jne 0xa353a
jmp 0xa3543
leaq -0x78(%rbp), %rdi
callq 0x23380
jmp 0xa3545
testb $0x1, -0x9b(%rbp)
jne 0xa3550
jmp 0xa355c
leaq -0x98(%rbp), %rdi
callq 0x1c1e8
jmp 0xa355e
testb $0x1, -0x9a(%rbp)
jne 0xa3569
jmp 0xa3575
leaq -0x99(%rbp), %rdi
callq 0x1c1d0
jmp 0xa35e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa35b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa35ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x23380
leaq -0xd0(%rbp), %rdi
callq 0x1c1e8
leaq -0xd1(%rbp), %rdi
callq 0x1c1d0
jmp 0xa35e8
movb -0x9(%rbp), %al
movb %al, -0x102(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x23380
movb -0x102(%rbp), %al
andb $0x1, %al
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x23380
movq -0x60(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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(aoh);
if (ffh.getFieldType() == "/Btn") {
// Rather than generating appearances for button fields, rely on what's already
// there. Just make sure /AS is consistent with /V, which we can do by resetting the
// value of the field back to itself. This code is referenced in a comment in
// QPDFFormFieldObjectHelper::generateAppearance.
if (ffh.isRadioButton() || ffh.isCheckbox()) {
ffh.setV(ffh.getValue());
}
} else {
ffh.generateAppearance(aoh);
}
}
}
setNeedAppearances(false);
}
|
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), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1e0e60
jmp 0xa39b5
leaq -0x48(%rbp), %rdi
callq 0xaadd0
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaae10
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaae40
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xaae70
testb $0x1, %al
jne 0xa3a20
movl $0x2, -0x6c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xaafa0
jmp 0xa3ccd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xaadd0
jmp 0xa3ce4
leaq -0x60(%rbp), %rdi
callq 0xaaeb0
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0xaab50
movq -0x190(%rbp), %rsi
movq -0x1a0(%rbp), %rdx
leaq -0x98(%rbp), %rdi
callq 0xa2ba0
jmp 0xa3a60
leaq -0xd0(%rbp), %rdi
callq 0xaaba0
leaq -0x98(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0xaa0f0
movq %rax, -0xd8(%rbp)
movq -0x80(%rbp), %rdi
callq 0xaa120
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0xaa150
testb $0x1, %al
jne 0xa3ae3
movl $0x4, -0x6c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xaaaf0
jmp 0xa3cb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0xaaba0
jmp 0xa3cc2
leaq -0xd8(%rbp), %rdi
callq 0xaa190
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rsi
leaq -0x158(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0xaa1b0
movq -0x190(%rbp), %rsi
movq -0x1a8(%rbp), %rdx
leaq -0x120(%rbp), %rdi
callq 0xa2fc0
jmp 0xa3b2c
leaq -0x158(%rbp), %rdi
callq 0xaa230
leaq -0x178(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0xdbb40
jmp 0xa3b4d
leaq 0x26e67c(%rip), %rsi # 0x3121d0
leaq -0x178(%rbp), %rdi
callq 0x315c0
movb %al, -0x1a9(%rbp)
jmp 0xa3b68
leaq -0x178(%rbp), %rdi
callq 0x1c1e8
movb -0x1a9(%rbp), %al
testb $0x1, %al
jne 0xa3b83
jmp 0xa3c64
leaq -0x120(%rbp), %rdi
callq 0xdd370
movb %al, -0x1aa(%rbp)
jmp 0xa3b97
movb -0x1aa(%rbp), %al
testb $0x1, %al
jne 0xa3bc6
jmp 0xa3ba3
leaq -0x120(%rbp), %rdi
callq 0xdd160
movb %al, -0x1ab(%rbp)
jmp 0xa3bb7
movb -0x1ab(%rbp), %al
testb $0x1, %al
jne 0xa3bc6
jmp 0xa3c62
leaq -0x188(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0xdc7c0
jmp 0xa3bdb
leaq -0x120(%rbp), %rdi
leaq -0x188(%rbp), %rsi
movl $0x1, %edx
callq 0xdd8d0
jmp 0xa3bf5
leaq -0x188(%rbp), %rdi
callq 0x23380
jmp 0xa3c62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xaa230
jmp 0xa3ca4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xa3c98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x1c1e8
jmp 0xa3c98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x23380
jmp 0xa3c98
jmp 0xa3c7b
movq -0xe8(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0xdfe30
jmp 0xa3c79
jmp 0xa3c7b
leaq -0x120(%rbp), %rdi
callq 0xa9dd0
leaq -0xd8(%rbp), %rdi
callq 0xaa270
jmp 0xa3a97
leaq -0x120(%rbp), %rdi
callq 0xa9dd0
leaq -0x98(%rbp), %rdi
callq 0xaaaf0
jmp 0xa3cc2
jmp 0xa3cb4
leaq -0x60(%rbp), %rdi
callq 0xaaf80
jmp 0xa39e0
leaq -0x28(%rbp), %rdi
callq 0xaafa0
jmp 0xa3ce4
movq -0x190(%rbp), %rdi
xorl %esi, %esi
callq 0xa3600
addq $0x1b0, %rsp # imm = 0x1B0
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.