name string | code string | asm string | file string |
|---|---|---|---|
QPDF::readStream(QPDFObjectHandle&, QPDFObjGen, long long) | void
QPDF::readStream(QPDFObjectHandle& object, QPDFObjGen og, qpdf_offset_t offset)
{
validateStreamLineEnd(object, og, offset);
// Must get offset before accessing any additional objects since resolving a previously
// unresolved indirect object will change file position.
qpdf_offset_t stream_offset ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r13
movq %rdx, 0x18(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
callq 0x12c6ae
movq (%r15), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %r12
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3970b(%r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::tableSize() | size_t
QPDF::tableSize()
{
// If obj_cache is dense, accommodate all object in tables,else accommodate only original
// objects.
auto max_xref = m->xref_table.size() ? m->xref_table.crbegin()->first.getObj() : 0;
auto max_obj = m->obj_cache.size() ? m->obj_cache.crbegin()->first.getObj() : 0;
auto m... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
xorl %r12d, %r12d
cmpq $0x0, 0x160(%r15)
movl $0x0, %r13d
je 0x1308c2
leaq 0x140(%r15), %rdi
callq 0x19c20
movl 0x20(%rax), %r13d
movq 0x1d0(%r15), %r14
testq %r14, %r14
je 0x1308e1
addq $0x1b0, %r15 # i... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDFObject::move_to(std::shared_ptr<QPDFObject>&, bool) | void
move_to(std::shared_ptr<QPDFObject>& o, bool destroy)
{
o->value = std::move(value);
o->qpdf = qpdf;
o->og = og;
o->object_description = object_description;
o->parsed_offset = parsed_offset;
if (!destroy) {
value = QPDF_Reference(o);
}
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movsbq 0x30(%rbx), %rax
leaq 0xbdf11(%rip), %rcx # 0x1eec08
movq %rbx, %rsi
callq *0x8(%rcx,%rax,8)
movq 0x48(%rbx), %rax
movq (%r14), %rcx
movq %rax, 0x48(%rcx)
movq... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObject_private.hh |
QPDF::optimize(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>> const&, bool, std::function<int (QPDFObjectHandle&)>) | void
QPDF::optimize(
std::map<int, int> const& object_stream_data,
bool allow_changes,
std::function<int(QPDFObjectHandle&)> skip_stream_parameters)
{
optimize_internal(object_stream_data, allow_changes, skip_stream_parameters);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0xf5d46
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0x136c64
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x135312
leaq 0x8(%rsp)... | /jberkenbilt[P]qpdf/libqpdf/QPDF_optimization.cc |
QUtil::safe_fopen(char const*, char const*) | FILE*
QUtil::safe_fopen(char const* filename, char const* mode)
{
FILE* f = nullptr;
#ifdef _WIN32
std::shared_ptr<wchar_t> wfilenamep = win_convert_filename(filename);
wchar_t* wfilename = wfilenamep.get();
auto wmodep = QUtil::make_shared_array<wchar_t>(strlen(mode) + 1);
wchar_t* wmode = wmodep.g... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x427e1(%rip), %rsi # 0x18070b
leaq 0x427df(%rip), %rdx # 0x180710
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x1edc8
movq %r15, %rdi
movq %r14, %rsi
callq 0x19730
leaq... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::same_file(char const*, char const*) | bool
QUtil::same_file(char const* name1, char const* name2)
{
if ((name1 == nullptr) || (strlen(name1) == 0) || (name2 == nullptr) || (strlen(name2) == 0)) {
return false;
}
#ifdef _WIN32
bool same = false;
# ifndef AVOID_WINDOWS_HANDLE
HANDLE fh1 = CreateFile(
name1, GENERIC_READ, FILE_... | testq %rdi, %rdi
je 0x13e0d5
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rsi, %rbx
xorl %eax, %eax
testq %rsi, %rsi
je 0x13e0cc
cmpb $0x0, (%rdi)
je 0x13e0cc
cmpb $0x0, (%rbx)
je 0x13e0ca
leaq 0x90(%rsp), %rsi
callq 0x190b0
testl %eax, %eax
jne 0x13e0ca
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x190b0
test... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::hex_decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QUtil::hex_decode(std::string const& input)
{
std::string result;
// We know result.size() <= 0.5 * input.size() + 1. However, reserving string space for this
// upper bound has a negative impact.
bool first = true;
char decoded;
for (auto ch: input) {
ch = util::hex_decode_c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x13e993
movq (%rsi), %r12
movb $0x1, %r15b
xorl %r13d, %r13d
movb (%r12,%r13), %cl
l... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::toUTF8[abi:cxx11](unsigned long) | std::string
QUtil::toUTF8(unsigned long uval)
{
std::string result;
// A UTF-8 encoding of a Unicode value is a single byte for Unicode values <= 127. For larger
// values, the first byte of the UTF-8 encoding has '1' as each of its n highest bits and '0'
// for its (n+1)th highest bit where n is the ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rax
shrq $0x1f, %rax
jne 0x140e04
cmpq $0x7f, %rsi
ja 0x140d6f
movsbl %sil, %esi
movq %rbx, %rdi
callq 0x19d90
jmp 0x140dc1
leaq 0x6(%rsp), %rax
movb $0x0... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::read_file_into_string[abi:cxx11](_IO_FILE*, std::basic_string_view<char, std::char_traits<char>>) | std::string
QUtil::read_file_into_string(FILE* f, std::string_view filename)
{
fseek(f, 0, SEEK_END);
auto o_size = QUtil::tell(f);
if (o_size >= 0) {
// Seekable file
auto size = QIntC::to_size(o_size);
fseek(f, 0, SEEK_SET);
std::string result(size, '\0');
if (auto ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, 0x68(%rsp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x19da0
movq %r14, %rdi
callq 0x198d0
testq %rax, %rax
js 0x14181d
movq %rax, %r15
movq... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::parse_numrange(char const*, int) | std::vector<int>
QUtil::parse_numrange(char const* range, int max)
{
// Performance note: this implementation aims to be straightforward, not efficient. Numeric
// range parsing is used only during argument processing. It is not used during processing of
// PDF files.
static std::regex group_re(R"((x)?... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, %rbx
movq %rdi, 0xf0(%rsp)
movl %edx, 0xec(%rsp)
movb 0xaf2bb(%rip), %al # 0x1f1578
testb %al, %al
je 0x142ae2
leaq 0xec(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %rbx, %rdi
callq 0x19420
movq %rax... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::pdf_doc_to_utf8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QUtil::pdf_doc_to_utf8(std::string const& val)
{
std::string result;
size_t len = val.length();
for (unsigned int i = 0; i < len; ++i) {
unsigned char ch = static_cast<unsigned char>(val.at(i));
unsigned short ch_short = ch;
if ((ch >= 127) && (ch <= 160)) {
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x1440b0
movq %rsi, %r14
movl $0x1, %r12d
leaq 0x18(%rsp), %rbp
xorl %esi, %esi... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::call_main_from_wmain(int, wchar_t const* const*, std::function<int (int, char const* const*)>) | int
QUtil::call_main_from_wmain(
int argc, wchar_t const* const argv[], std::function<int(int, char const* const[])> realmain)
{
return ::call_main_from_wmain(true, argc, argv, [realmain](int new_argc, char* new_argv[]) {
return realmain(new_argc, new_argv);
});
} | pushq %rbp
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x145848
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x20, %edi
callq 0x19180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%r... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
ResourceFinder::ResourceFinder() | ResourceFinder::ResourceFinder() :
last_name_offset(0)
{
} | leaq 0xa6105(%rip), %rax # 0x1eedd8
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq %rax, 0x28(%rdi)
leaq 0x38(%rdi), %rcx
movl %eax, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
leaq ... | /jberkenbilt[P]qpdf/libqpdf/ResourceFinder.cc |
qpdf_read | QPDF_ERROR_CODE
qpdf_read(qpdf_data qpdf, char const* filename, char const* password)
{
QPDF_ERROR_CODE status = QPDF_SUCCESS;
qpdf->filename = filename;
qpdf->password = password;
status = trap_errors(qpdf, &call_read);
// We no longer have a good way to exercise a file with both warnings and error... | pushq %rbx
subq $0x20, %rsp
movq %rsi, 0x78(%rdi)
movq %rdx, 0x90(%rdi)
movq %rsp, %rsi
movq $0x0, 0x8(%rsi)
leaq 0x6b(%rip), %rax # 0x14ae55
movq %rax, (%rsi)
leaq 0xee48(%rip), %rax # 0x159c3c
movq %rax, 0x18(%rsi)
leaq 0xee45(%rip), %rax # 0x159c44
movq %rax, 0x10(%rsi)
callq 0x14aa1a
movl %eax, %eb... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_set_info_key | void
qpdf_set_info_key(qpdf_data qpdf, char const* key, char const* value)
{
if ((key == nullptr) || (std::strlen(key) == 0) || (key[0] != '/')) {
return;
}
QPDFObjectHandle value_object;
if (value) {
QTC::TC("qpdf", "qpdf-c set_info_key to value");
value_object = QPDFObjectHandl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
testq %rsi, %rsi
je 0x14b456
movq %rsi, %rbx
cmpb $0x2f, (%rsi)
jne 0x14b456
movq %rdx, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
testq %rdx, %rdx
je 0x14b2bb
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_replace_object | void
qpdf_replace_object(qpdf_data qpdf, int objid, int generation, qpdf_oh oh)
{
do_with_oh_void(qpdf, oh, [qpdf, objid, generation](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_replace_object");
qpdf->qpdf->replaceObject(objid, generation, o);
});
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rdi, (%rax)
movl %esi, 0x8(%rax)
movl %edx, 0xc(%rax)
leaq 0x83ed(%rip), %rdx # 0x154812
movq %rdx, 0x18(%rax)
leaq 0x8458(%rip), %rdx # 0x154888
movq %rdx, 0x10(%rax)
movl %ecx, %esi
movq %rax, %rdx
callq 0x14c487
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_null | QPDF_BOOL
qpdf_oh_is_null(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_null");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isNull(); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0xf5(%rip), %rax # 0x14cf4e
movq %rax, (%rdx)
leaq 0xd0e9(%rip), %rax # 0x15a136
movq %rax, 0x18(%rdx)
leaq 0xd0e0(%rip), %rax # 0x15a138
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x7c42... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_operator | QPDF_BOOL
qpdf_oh_is_operator(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_operator");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isOperator(); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0x532(%rip), %rax # 0x14cf4e
movq %rax, (%rdx)
leaq 0xccac(%rip), %rax # 0x15a136
movq %rax, 0x18(%rdx)
leaq 0xcca3(%rip), %rax # 0x15a138
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x78c3... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_number | QPDF_BOOL
qpdf_oh_is_number(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_number");
return o.isNumber();
});
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0xb21(%rip), %rax # 0x14cf4e
movq %rax, (%rdx)
leaq 0xc6bd(%rip), %rax # 0x15a136
movq %rax, 0x18(%rdx)
leaq 0xc6b4(%rip), %rax # 0x15a138
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x73de... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
char const* do_with_oh<char const*>(_qpdf_data*, unsigned int, std::function<char const* ()>, std::function<char const* (QPDFObjectHandle&)>) | static RET
do_with_oh(
qpdf_data qpdf,
qpdf_oh oh,
std::function<RET()> fallback,
std::function<RET(QPDFObjectHandle&)> fn)
{
return trap_oh_errors<RET>(qpdf, fallback, [fn, oh](qpdf_data q) {
auto i = q->oh_cache.find(oh);
bool result = ((i != q->oh_cache.end()) && (i->second).get()... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xb0(%rsp), %rdi
movq %rdx, %rsi
callq 0x15a274
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x15a2d2
movl %ebp, 0x68(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x80(%rsp)
movl $0x28, %edi
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_bool | QPDF_BOOL
qpdf_oh_get_value_as_bool(qpdf_data qpdf, qpdf_oh oh, QPDF_BOOL* value)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [value](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_bool");
bool v = *value;
QPDF_BOOL result = o.getValueAsBool(v);
... | pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x1bc5(%rip), %rcx # 0x14cf4e
movq %rcx, (%rax)
leaq 0xb619(%rip), %rcx # 0x15a136
movq %rcx, 0x18(%rax)
leaq 0xb610(%rip), %rcx # 0x15a138
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_longlong | QPDF_BOOL
qpdf_oh_get_value_as_longlong(qpdf_data qpdf, qpdf_oh oh, long long* value)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [value](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_longlong");
return o.getValueAsInt(*value);
});
} | pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x21be(%rip), %rcx # 0x14cf4e
movq %rcx, (%rax)
leaq 0xb020(%rip), %rcx # 0x15a136
movq %rcx, 0x18(%rax)
leaq 0xb017(%rip), %rcx # 0x15a138
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_int | QPDF_BOOL
qpdf_oh_get_value_as_int(qpdf_data qpdf, qpdf_oh oh, int* value)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [value](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_int");
return o.getValueAsInt(*value);
});
} | pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x237d(%rip), %rcx # 0x14cf4e
movq %rcx, (%rax)
leaq 0xae61(%rip), %rcx # 0x15a136
movq %rcx, 0x18(%rax)
leaq 0xae58(%rip), %rcx # 0x15a138
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_number | QPDF_BOOL
qpdf_oh_get_value_as_number(qpdf_data qpdf, qpdf_oh oh, double* value)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [value](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_number");
return o.getValueAsNumber(*value);
});
} | pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x333d(%rip), %rcx # 0x14cf4e
movq %rcx, (%rax)
leaq 0x9ea1(%rip), %rcx # 0x15a136
movq %rcx, 0x18(%rax)
leaq 0x9e98(%rip), %rcx # 0x15a138
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_binary_string_value | char const*
qpdf_oh_get_binary_string_value(qpdf_data qpdf, qpdf_oh oh, size_t* length)
{
return do_with_oh<char const*>(
qpdf, oh, return_T<char const*>(""), [qpdf, length](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_binary_string_value");
qpdf->tmp_string = o.... | pushq %rbx
subq $0x50, %rsp
leaq 0x2a32d(%rip), %rax # 0x17aca6
leaq 0x48(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
movq %rcx, (%rax)
leaq 0x4a9a(%rip), %rcx # 0x155432
movq %rcx, 0x18(%rax)
leaq 0x4a97(%rip), %rcx # 0x15543a
movq %rcx, 0x10(%rax)
leaq 0x8(%rsp), %rcx
movq %... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_has_key | QPDF_BOOL
qpdf_oh_has_key(qpdf_data qpdf, qpdf_oh oh, char const* key)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [key](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_has_key");
return o.hasKey(key);
});
} | pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x447d(%rip), %rcx # 0x14cf4e
movq %rcx, (%rax)
leaq 0x8d61(%rip), %rcx # 0x15a136
movq %rcx, 0x18(%rax)
leaq 0x8d58(%rip), %rcx # 0x15a138
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_key_if_dict | qpdf_oh
qpdf_oh_get_key_if_dict(qpdf_data qpdf, qpdf_oh oh, char const* key)
{
return do_with_oh<qpdf_oh>(qpdf, oh, return_null(qpdf), [qpdf, key](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_key_if_dict");
return new_object(qpdf, o.getKeyIfDict(key));
});
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
movq %rdi, (%rax)
leaq 0x2c3b(%rip), %rcx # 0x1541bc
movq %rcx, 0x18(%rax)
leaq 0x2c38(%rip), %rcx # 0x1541c4
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %rdi, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x6271(%rip), %rdx # 0x157812
movq %rdx, 0... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_uninitialized | qpdf_oh
qpdf_oh_new_uninitialized(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_uninitialized");
return new_object(qpdf, QPDFObjectHandle());
} | pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
callq 0x14be97
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x15173b
callq 0x1ed58
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x151755
callq 0x1ed58
movq %rbx, %r... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_real_from_double | qpdf_oh
qpdf_oh_new_real_from_double(qpdf_data qpdf, double value, int decimal_places)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_real_from_double");
return new_object(qpdf, QPDFObjectHandle::newReal(value, decimal_places));
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %edx
callq 0xc7cfc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14be97
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x151949
callq 0x1ed58
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_array | qpdf_oh
qpdf_oh_new_array(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_array");
return new_object(qpdf, QPDFObjectHandle::newArray());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc6376
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14be97
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x151cdc
callq 0x1ed58
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%r... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_set_array_item | void
qpdf_oh_set_array_item(qpdf_data qpdf, qpdf_oh oh, int at, qpdf_oh item)
{
do_with_oh_void(qpdf, oh, [qpdf, at, item](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_set_array_item");
o.setArrayItem(at, qpdf_oh_item_internal(qpdf, item));
});
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rdi, (%rax)
movl %edx, 0x8(%rax)
movl %ecx, 0xc(%rax)
leaq 0x5b6e(%rip), %rcx # 0x157a7a
movq %rcx, 0x18(%rax)
leaq 0x5bc1(%rip), %rcx # 0x157ad8
movq %rcx, 0x10(%rax)
movq %rax, %rdx
callq 0x14c487
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x151f3a
movq %rsp,... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_push_inherited_attributes_to_page | QPDF_ERROR_CODE
qpdf_push_inherited_attributes_to_page(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_push_inherited_attributes_to_page");
return trap_errors(qpdf, [](qpdf_data q) { q->qpdf->pushInheritedAttributesToPage(); });
} | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x5940(%rip), %rax # 0x1587ce
movq %rax, 0x18(%rsi)
leaq 0x5941(%rip), %rax # 0x1587da
movq %rax, 0x10(%rsi)
callq 0x14aa1a
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x152ebb
movq %rsp, %rdi
movq %rdi, %rs... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdfjob_initialize_from_argv | int
qpdfjob_initialize_from_argv(qpdfjob_handle j, char const* const argv[])
{
return wrap_qpdfjob(j, [argv](qpdfjob_handle jh) {
jh->j.initializeFromArgv(argv);
return 0;
});
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rsi, (%rax)
leaq 0x848(%rip), %rcx # 0x15b4cc
movq %rcx, 0x18(%rax)
leaq 0x853(%rip), %rcx # 0x15b4e2
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0x15ace8
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x15acb4
movq %rsp, %rdi... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdflogger_default_logger | qpdflogger_handle
qpdflogger_default_logger()
{
return new _qpdflogger_handle(QPDFLogger::defaultLogger());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl $0x10, %edi
callq 0x19180
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb937a
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rbx)
testq %rdi, %rdi
je 0x15b984
movq 0x94619(%rip), %rax # 0x1eff80
cmpb $0x0, (%rax)
je 0x15b971
incl 0x8(%rdi)
jmp... | /jberkenbilt[P]qpdf/libqpdf/qpdflogger-c.cc |
(anonymous namespace)::RC4Loader::getRC4() | EVP_CIPHER const*
RC4Loader::getRC4()
{
static auto loader = std::shared_ptr<RC4Loader>(new RC4Loader());
return loader->rc4;
} | pushq %r14
pushq %rbx
pushq %rax
movb 0x94f94(%rip), %al # 0x1f16f8
testb %al, %al
je 0x15c77b
movq 0x94f79(%rip), %rax # 0x1f16e8
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x94f76(%rip), %rdi # 0x1f16f8
callq 0x193a0
testl %eax, %eax
je 0x15c768
movl $0x18, %edi
callq 0x19180
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
Utils::ArgumentParser::make_flag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::_... | inline ArgFlag& ArgumentParser::make_flag( const std::string& name,
const std::string& description, const std::vector<std::string>& flg) {
assert(used_name.find(name) == used_name.end());
used_name.insert(name);
auto f = new ArgFlag(name,description,flg);
flags.push_back(f);
for ( auto i :... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x31c30
movq -0xf0(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x31c70
movq %rax, -0x30(... | /GiuMaz[P]satyricon/include/ArgumentParser.hpp |
Utils::ArgOption<unsigned int>& Utils::ArgumentParser::make_option<unsigned int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<cha... | ArgOption<T>& ArgumentParser::make_option( const std::string& name,
const std::string& description, const std::vector<std::string>& opts) {
assert(used_name.find(name) == used_name.end());
used_name.insert(name);
auto o = new ArgOption<T>(name,description,opts);
options.push_back(o);
for (... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x31c30
movq -0xf8(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x31c70
movq %rax, -0x30(... | /GiuMaz[P]satyricon/include/ArgumentParser.hpp |
Utils::ArgOption<float>::get_message[abi:cxx11]() | const std::string get_message() {
std::string opt("\e[1m");
for (auto o : opts) {
if (o.size() == 1) opt += "-" + o + " ";
else opt += "--" + o + " ";
}
opt += "<" + this->get_name() + ">\e[0m";
return this->argument_message(opt,8,80);
} | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x2a640
movq -0x148(%rbp), %rdx
leaq 0x15... | /GiuMaz[P]satyricon/include/ArgumentParser.hpp |
Utils::ArgOption<unsigned int>::get_message[abi:cxx11]() | const std::string get_message() {
std::string opt("\e[1m");
for (auto o : opts) {
if (o.size() == 1) opt += "-" + o + " ";
else opt += "--" + o + " ";
}
opt += "<" + this->get_name() + ">\e[0m";
return this->argument_message(opt,8,80);
} | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x2a640
movq -0x148(%rbp), %rdx
leaq 0x14... | /GiuMaz[P]satyricon/include/ArgumentParser.hpp |
Satyricon::SATSolver::propagation() | SATSolver::ClausePtr SATSolver::propagation() {
while ( propagation_starting_pos < trail.size() ) {
PRINT_VERBOSE("propagate " << trail[propagation_starting_pos] << endl);
// extract the list of the opposite literal
// (they are false now, their watcher must be moved)
auto failed... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
movq 0x98(%rdi), %rax
movq %rax, -0xb0(%rbp)
addq $0xa0, %rdi
callq 0x3af10
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0x3c430
movq -0xa8(%rbp... | /GiuMaz[P]satyricon/src/sat_solver.cpp |
Satyricon::SATSolver::cancel_until(int) | void SATSolver::cancel_until( int level ) {
PRINT_VERBOSE("backtrack from " << current_level() <<
" to " << level << endl);
while ( current_level() > level )
cancel();
propagation_starting_pos = trail.size();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x2, 0xd0(%rax)
jl 0x3cc34
movq 0x223e1(%rip), %rdi # 0x5efc8
leaq 0x118de(%rip), %rsi # 0x4e4cc
callq 0x2a370
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x3ff30
mo... | /GiuMaz[P]satyricon/src/sat_solver.cpp |
Satyricon::SATSolver::simplify_clause(Satyricon::Clause*) | bool SATSolver::simplify_clause( ClausePtr c ) {
size_t j = 0;
for ( const auto & l : *c ) {
if ( get_asigned_value(l) == LIT_TRUE )
return true; // useless
if ( get_asigned_value(l) == LIT_UNASIGNED )
c->at(j++) = l;
}
c->shrink(j);
return false; // still use... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x40130
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x40150
movq %rax, -0x38(%... | /GiuMaz[P]satyricon/src/sat_solver.cpp |
Satyricon::Literal_Heap::initialize() | void initialize() {
value.clear();
value.reserve(map_position.size());
for ( int i = 0; i < static_cast<int>(map_position.size()/2); ++i ) {
Literal l(i,false);
value.push_back(l);
map_position[l.index()] = value.size()-1;
l = Literal(i,true);
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
callq 0x3a6c0
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
addq $0x20, %rdi
callq 0x421a0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x420a0
movl $0x0, -0xc(%... | /GiuMaz[P]satyricon/include/solver_types.hpp |
main | int main(void)
{
GLFWwindow* window;
memset(joysticks, 0, sizeof(joysticks));
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
find_joysticks();
glfwSetJoystickCallback(joystick_callback);
window = glfwCreateWindow(640, 480, "Joystick Test", NULL, NULL)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x1c9ec(%rip) # 0x2d590
movaps %xmm0, 0x1c9d5(%rip) # 0x2d580
movaps %xmm0, 0x1c9be(%rip) # 0x2d570
movaps %xmm0, 0x1c9a7(%rip) # 0x2d560
leaq -0x140(%rip), %rdi # 0x10a80
callq 0x14c1f
c... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/tests/joysticks.c |
joystick_callback | static void joystick_callback(int joy, int event)
{
if (event == GLFW_CONNECTED)
{
int axis_count, button_count;
glfwGetJoystickAxes(joy, &axis_count);
glfwGetJoystickButtons(joy, &button_count);
printf("Found joystick %i named \'%s\' with %i axes, %i buttons\n",
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpl $0x40001, %esi # imm = 0x40001
je 0x10fd5
cmpl $0x40002, %esi # imm = 0x40002
jne 0x1102e
movl 0x1c624(%rip), %eax # 0x2d5a0
leaq 0x1c5dd(%rip), %rcx # 0x2d560
xorl %edx, %edx
testl %eax, %eax
jle 0x10f9e
movq %rcx, %r... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/tests/joysticks.c |
gladLoadGLLoader | int gladLoadGLLoader(GLADloadproc load) {
GLVersion.major = 0; GLVersion.minor = 0;
glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
if(glGetString == NULL) return 0;
if(glGetString(GL_VERSION) == NULL) return 0;
find_coreGL();
load_GL_VERSION_1_0(load);
load_GL_VERSION_1_1(load);
load_GL_VERSION_1_2(load... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x1c53f(%rip) # 0x2d5a8
leaq 0x10016(%rip), %rdi # 0x21086
callq *%rbx
movq %rax, 0x1c537(%rip) # 0x2d5b0
xorl %ebp, %ebp
testq %rax, %rax
je 0x13e19
movl $0x1f02, %edi # imm = 0x1F02
callq *%rax
te... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/deps/glad.c |
glfwIsValidContextConfig | GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
{
if (ctxconfig->source != GLFW_NATIVE_CONTEXT_API &&
ctxconfig->source != GLFW_EGL_CONTEXT_API)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context creation API %i",
ctxconfig->... | pushq %rbx
movl 0x4(%rdi), %edx
leal -0x36001(%rdx), %eax
cmpl $0x2, %eax
jae 0x13f93
movl (%rdi), %edx
testl %edx, %edx
je 0x14071
cmpl $0x30001, %edx # imm = 0x30001
je 0x13fad
cmpl $0x30002, %edx # imm = 0x30002
jne 0x13fef
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
testl %edx, %edx
setle %al
testl ... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c |
glfwChooseFBConfig | const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
const _GLFWfbconfig* alternatives,
unsigned int count)
{
unsigned int i;
unsigned int missing, leastMissing = UINT_MAX;
unsigned int colorDiff, leastColorD... | testl %edx, %edx
je 0x142a7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x2c(%rdi), %ecx
movl %edx, %edx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
xorl %eax, %eax
movl $0xffffffff, %r11d # imm = 0xFFFFFFFF
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testl %ecx, %ecx
jle 0x14103... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c |
glfwRefreshContextAttribs | GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
{
int i;
_GLFWwindow* window;
const char* version;
const char* prefixes[] =
{
"OpenGL ES-CM ",
"OpenGL ES-CL ",
"OpenGL ES ",
NULL
};
window = _glfwPlatformGetCurrentContext();
window->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0x1e42e
movq %rax, %rbx
movl 0x4(%r14), %eax
movl %eax, 0x1f4(%rbx)
movl $0x30001, 0x1f0(%rbx) # imm = 0x30001
leaq 0xcfa6(%rip), %rdi # 0x21284
callq *0x258(%rbx)
movq %rax, 0x228(%rbx)
leaq 0xcd94(%rip), %r... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c |
glfwExtensionSupported | GLFWAPI int glfwExtensionSupported(const char* extension)
{
_GLFWwindow* window;
assert(extension != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
window = _glfwPlatformGetCurrentContext();
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
return GLFW_FALSE;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1473c
leaq 0x1a533(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x146b4
movq %rdi, %rbx
callq 0x1e42e
testq %rax, %rax
je 0x146be
cmpb $0x0, (%rbx)
je 0x146dd
movq %rax, %r14
cmpl $0x3, 0x1f8(%rax)
jl 0x146ee
leaq 0x4(%rsp), %r15
movl $0x821... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c |
glfwStringInExtensionString | GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions)
{
const char* start = extensions;
for (;;)
{
const char* where;
const char* terminator;
where = strstr(start, string);
if (!where)
return GLFW_FALSE;
terminator = where + ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x10590
xorl %ebx, %ebx
testq %rax, %rax
je 0x147bf
movq %rax, %r13
movq %r14, %rdi
callq 0x10460
movq %rax, %r12
movq %r15, %rax
leaq (%r12,%r13), %r15
cmpq %rax, %r13
je 0x1479d
cmpb $0x20, -0x... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c |
glfwMakeContextCurrent | GLFWAPI void glfwMakeContextCurrent(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFWwindow* previous = _glfwPlatformGetCurrentContext();
_GLFW_REQUIRE_INIT();
if (window && window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
... | pushq %rbx
movq %rdi, %rbx
callq 0x1e42e
leaq 0x1a38d(%rip), %rcx # 0x2eb68
cmpl $0x0, (%rcx)
je 0x1481c
testq %rbx, %rbx
je 0x14823
movq %rbx, %rdx
cmpl $0x0, 0x1f0(%rbx)
je 0x14831
testq %rax, %rax
je 0x14812
movl 0x1f4(%rdx), %ecx
cmpl 0x1f4(%rax), %ecx
je 0x14812
xorl %edi, %edi
movq %rdx, %rbx
callq *0x238(%ra... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c |
glfwSwapInterval | GLFWAPI void glfwSwapInterval(int interval)
{
_GLFWwindow* window;
_GLFW_REQUIRE_INIT();
window = _glfwPlatformGetCurrentContext();
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
return;
}
window->context.swapInterval(interval);
} | pushq %rbx
leaq 0x1a2a6(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x148dc
movl %edi, %ebx
callq 0x1e42e
testq %rax, %rax
je 0x148e3
movl %ebx, %edi
popq %rbx
jmpq *0x248(%rax)
movl $0x10001, %edi # imm = 0x10001
jmp 0x148e8
movl $0x10002, %edi # imm = 0x10002
xorl %esi, %esi
xorl %eax, %eax
popq ... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c |
glfwGetProcAddress | GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
{
_GLFWwindow* window;
assert(procname != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
window = _glfwPlatformGetCurrentContext();
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
return NULL;
}
ret... | pushq %rbx
testq %rdi, %rdi
je 0x14934
leaq 0x1a269(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x1491b
movq %rdi, %rbx
callq 0x1e42e
testq %rax, %rax
je 0x14922
movq %rbx, %rdi
popq %rbx
jmpq *0x258(%rax)
movl $0x10001, %edi # imm = 0x10001
jmp 0x14927
movl $0x10002, %edi # imm = 0x10002
xorl %esi... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/context.c |
glfwInputError | void _glfwInputError(int error, const char* format, ...)
{
if (_glfwErrorCallback)
{
char buffer[8192];
const char* description;
if (format)
{
int count;
va_list vl;
va_start(vl, format);
count = vsnprintf(buffer, sizeof(buffer), ... | pushq %r14
pushq %rbx
subq $0x20d8, %rsp # imm = 0x20D8
testb %al, %al
je 0x14999
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdx, 0x30(%rsp)
movq %... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/init.c |
glfwInit | GLFWAPI int glfwInit(void)
{
if (_glfwInitialized)
return GLFW_TRUE;
memset(&_glfw, 0, sizeof(_glfw));
if (!_glfwPlatformInit())
{
_glfwPlatformTerminate();
return GLFW_FALSE;
}
_glfw.monitors = _glfwPlatformGetMonitors(&_glfw.monitorCount);
_glfwInitialized = GLFW... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x1a0b3(%rip), %r15 # 0x2eb68
movl $0x1, %ebx
cmpl $0x0, (%r15)
jne 0x14b18
leaq 0x1a0b1(%rip), %r14 # 0x2eb78
xorl %ebx, %ebx
movl $0xdb8, %edx # imm = 0xDB8
movq %r14, %rdi
xorl %esi, %esi
callq 0x10110
callq 0x18157
testl %eax, %eax
je 0x14b13
leaq 0xc8(%r14),... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/init.c |
glfwTerminate | GLFWAPI void glfwTerminate(void)
{
int i;
if (!_glfwInitialized)
return;
memset(&_glfw.callbacks, 0, sizeof(_glfw.callbacks));
while (_glfw.windowListHead)
glfwDestroyWindow((GLFWwindow*) _glfw.windowListHead);
while (_glfw.cursorListHead)
glfwDestroyCursor((GLFWcursor*) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x1a03a(%rip), %r14 # 0x2eb68
cmpl $0x0, (%r14)
je 0x14bed
xorps %xmm0, %xmm0
leaq 0x1a036(%rip), %rbx # 0x2eb78
movups %xmm0, 0x120(%rbx)
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x14b61
callq 0x16fc5
jmp 0x14b49
callq 0x153eb
movq 0xb0(%rbx), %rdi
t... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/init.c |
glfwGetVersion | GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev)
{
if (major != NULL)
*major = GLFW_VERSION_MAJOR;
if (minor != NULL)
*minor = GLFW_VERSION_MINOR;
if (rev != NULL)
*rev = GLFW_VERSION_REVISION;
} | testq %rdi, %rdi
je 0x14c03
movl $0x3, (%rdi)
testq %rsi, %rsi
je 0x14c0e
movl $0x2, (%rsi)
testq %rdx, %rdx
je 0x14c19
movl $0x1, (%rdx)
retq
| /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/init.c |
glfwInputKey | void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (key >= 0 && key <= GLFW_KEY_LAST)
{
GLFWbool repeated = GLFW_FALSE;
if (action == GLFW_RELEASE && window->keys[key] == GLFW_RELEASE)
return;
if (action == GLFW_PRESS && window->keys[k... | cmpl $0x15c, %esi # imm = 0x15C
ja 0x14c6e
movl %esi, %eax
cmpl $0x1, %ecx
je 0x14c57
testl %ecx, %ecx
jne 0x14c6a
cmpb $0x0, 0x7c(%rdi,%rax)
je 0x14c81
cmpl $0x0, 0x68(%rdi)
je 0x14c82
movb $0x3, 0x7c(%rdi,%rax)
jmp 0x14c6e
cmpb $0x1, 0x7c(%rdi,%rax)
movb $0x1, 0x7c(%rdi,%rax)
movl $0x2, %eax
jne 0x14c6e
jm... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/input.c |
glfwInputChar | void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, GLFWbool plain)
{
if (codepoint < 32 || (codepoint > 126 && codepoint < 160))
return;
if (window->callbacks.charmods)
window->callbacks.charmods((GLFWwindow*) window, codepoint, mods);
if (plain)
{
if (w... | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %esi, %ebx
cmpl $0x20, %esi
setb %al
leal -0x7f(%rbx), %ecx
cmpl $0x21, %ecx
setb %cl
orb %al, %cl
jne 0x14cd5
movq %rdi, %r14
movq 0x300(%rdi), %rax
testq %rax, %rax
je 0x14cba
movq %r14, %rdi
movl %ebx, %esi
callq *%rax
testl %ebp, %ebp
je 0x14cd5
movq 0x2f8(%r14)... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/input.c |
glfwInputCursorPos | void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos)
{
if (window->virtualCursorPosX == xpos && window->virtualCursorPosY == ypos)
return;
window->virtualCursorPosX = xpos;
window->virtualCursorPosY = ypos;
if (window->callbacks.cursorPos)
window->callbacks.cursorPos... | movsd 0x1e0(%rdi), %xmm2
ucomisd %xmm0, %xmm2
jne 0x14d35
jp 0x14d35
movsd 0x1e8(%rdi), %xmm2
ucomisd %xmm1, %xmm2
jne 0x14d35
jnp 0x14d53
movsd %xmm0, 0x1e0(%rdi)
movsd %xmm1, 0x1e8(%rdi)
movq 0x2d8(%rdi), %rax
testq %rax, %rax
je 0x14d53
jmpq *%rax
retq
| /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/input.c |
glfwGetInputMode | GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(0);
switch (mode)
{
case GLFW_CURSOR:
return window->cursorMode;
case GLFW_STICKY_KEYS:
return wind... | pushq %rbx
testq %rdi, %rdi
je 0x14e14
leaq 0x19dad(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x14ddf
movl %esi, %edx
cmpl $0x33003, %esi # imm = 0x33003
je 0x14df6
cmpl $0x33002, %edx # imm = 0x33002
je 0x14df1
cmpl $0x33001, %edx # imm = 0x33001
jne 0x14dfb
movl 0x70(%rdi), %ebx
jmp 0x... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/input.c |
glfwSetInputMode | GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
switch (mode)
{
case GLFW_CURSOR:
{
if (value != GLFW_CURSOR_NORMAL &&
value != GLFW_CURSO... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15088
leaq 0x19d21(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x14e95
movl %edx, %ebx
movl %esi, %edx
movq %rdi, %r14
cmpl $0x33003, %esi # imm = 0x33003
je 0x14ee4
cmpl $0x33002, %edx # imm = 0x33002
je 0x14eaa
cmpl $0x33001, %edx # ... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/input.c |
glfwGetKey | GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (key < GLFW_KEY_SPACE || key > GLFW_KEY_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid key %i", key);
retur... | pushq %rbx
testq %rdi, %rdi
je 0x1512e
leaq 0x19a91(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x15102
movl %esi, %edx
leal -0x15d(%rdx), %eax
cmpl $0xfffffec2, %eax # imm = 0xFFFFFEC2
ja 0x15114
leaq 0xf19e(%rip), %rsi # 0x24290
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %ea... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/input.c |
glfwDestroyCursor | GLFWAPI void glfwDestroyCursor(GLFWcursor* handle)
{
_GLFWcursor* cursor = (_GLFWcursor*) handle;
_GLFW_REQUIRE_INIT();
if (cursor == NULL)
return;
// Make sure the cursor is not being used by any window
{
_GLFWwindow* window;
for (window = _glfw.windowListHead; window; ... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x19772(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x1545f
movq %rdi, %rbx
testq %rdi, %rdi
je 0x15474
leaq 0x1976e(%rip), %rax # 0x2eb78
movq 0xb8(%rax), %r14
testq %r14, %r14
je 0x1542b
cmpq %rbx, 0x48(%r14)
jne 0x15426
movq %r14, %rdi
xorl %esi, %esi
callq 0x15515
movq (... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/input.c |
glfwGetJoystickAxes | GLFWAPI const float* glfwGetJoystickAxes(int joy, int* count)
{
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
return NULL;
}
return _glfwPlat... | pushq %rax
testq %rsi, %rsi
je 0x1589e
movl $0x0, (%rsi)
leaq 0x19305(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x15884
movl %edi, %edx
cmpl $0x10, %edi
jb 0x15896
leaq 0xeda7(%rip), %rsi # 0x2461d
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x14954
jmp 0x15892
movl $0x10001, %edi ... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/input.c |
glfwSetTime | GLFWAPI void glfwSetTime(double time)
{
_GLFW_REQUIRE_INIT();
if (time != time || time < 0.0 || time > 18446744073.0)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", time);
return;
}
_glfw.timerOffset = _glfwPlatformGetTimerValue() -
(uint64_t) (time * _glfwPlatfor... | leaq 0x19077(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x15b8b
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x15b99
ucomisd 0xe660(%rip), %xmm0 # 0x24170
ja 0x15b99
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
callq 0x1e359
movq %rax, %rbx
callq 0x1e3a5
movq %rax, %xmm0
punpckldq 0xe605(%rip), %xmm0 # xmm0... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/input.c |
glfwFreeMonitor | void _glfwFreeMonitor(_GLFWmonitor* monitor)
{
if (monitor == NULL)
return;
_glfwFreeGammaArrays(&monitor->originalRamp);
_glfwFreeGammaArrays(&monitor->currentRamp);
free(monitor->modes);
free(monitor->name);
free(monitor);
} | testq %rdi, %rdi
je 0x15dfc
pushq %rbx
movq %rdi, %rbx
addq $0x40, %rdi
callq 0x15e73
leaq 0x60(%rbx), %rdi
callq 0x15e73
movq 0x18(%rbx), %rdi
callq 0x10430
movq (%rbx), %rdi
callq 0x10430
movq %rbx, %rdi
popq %rbx
jmp 0x10430
retq
| /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/monitor.c |
refreshVideoModes | static GLFWbool refreshVideoModes(_GLFWmonitor* monitor)
{
int modeCount;
GLFWvidmode* modes;
if (monitor->modes)
return GLFW_TRUE;
modes = _glfwPlatformGetVideoModes(monitor, &modeCount);
if (!modes)
return GLFW_FALSE;
qsort(modes, modeCount, sizeof(GLFWvidmode), compareVideo... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x1, %ebx
cmpq $0x0, 0x18(%rdi)
jne 0x1606a
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
callq 0x1a263
testq %rax, %rax
je 0x16068
movq %rax, %r15
movslq 0xc(%rsp), %rsi
leaq 0x34(%rip), %rcx # 0x16078
movl $0x18, %edx
movq %rax, %rdi
callq 0x10690
movq 0x18(%r14),... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/monitor.c |
glfwGetMonitorPos | GLFWAPI void glfwGetMonitorPos(GLFWmonitor* handle, int* xpos, int* ypos)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (xpos)
*xpos = 0;
if (ypos)
*ypos = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetMonitorPos(monitor, xpos, ypos);
} | testq %rdi, %rdi
je 0x161c0
testq %rsi, %rsi
je 0x16196
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x161a1
movl $0x0, (%rdx)
leaq 0x189c0(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x161b2
jmp 0x1a1d1
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x14954
pushq %rax
leaq 0xe612(%rip), %... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/monitor.c |
glfwGetVideoModes | GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!refreshVideoModes(monitor))
return NULL;
*count = m... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16329
movq %rsi, %r14
testq %rsi, %rsi
je 0x16348
movl $0x0, (%r14)
leaq 0x1887b(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x1630a
movq %rdi, %rbx
callq 0x1600e
testl %eax, %eax
je 0x1631c
movl 0x20(%rbx), %eax
movl %eax, (%r14)
movq 0x18(%rbx), %rbx
jmp 0x163... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/monitor.c |
glfwSetWindowSize | GLFWAPI void glfwSetWindowSize(GLFWwindow* handle, int width, int height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
window->videoMode.width = width;
window->videoMode.height = height;
_glfwPlatformSetWindowSize(window, width, height);
} | testq %rdi, %rdi
je 0x1760a
leaq 0x1757c(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x175fc
movl %esi, 0x28(%rdi)
movl %edx, 0x2c(%rdi)
jmp 0x1b6cc
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x14954
pushq %rax
leaq 0xc7bd(%rip), %rdi # 0x23dcf
leaq 0xdc5d(%rip), %rsi ... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c |
glfwSetWindowSizeLimits | GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* handle,
int minwidth, int minheight,
int maxwidth, int maxheight)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (minwidth != GLFW... | testq %rdi, %rdi
je 0x176df
movl %edx, %eax
movl %esi, %edx
leaq 0x1752a(%rip), %rsi # 0x2eb68
cmpl $0x0, (%rsi)
je 0x1769a
cmpl $-0x1, %edx
sete %sil
cmpl $-0x1, %eax
sete %r9b
orb %sil, %r9b
movl %eax, %esi
orl %edx, %esi
setns %sil
orb %r9b, %sil
je 0x176a8
cmpl $-0x1, %ecx
sete %sil
cmpl $-0x1, %r8d
sete %r9b
o... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c |
glfwSetWindowAspectRatio | GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* handle, int numer, int denom)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (numer != GLFW_DONT_CARE && denom != GLFW_DONT_CARE)
{
if (numer <= 0 || denom <= 0)
{
_glfwIn... | testq %rdi, %rdi
je 0x17774
leaq 0x1745d(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x17757
movl %edx, %ecx
movl %esi, %edx
cmpl $-0x1, %esi
sete %al
cmpl $-0x1, %ecx
sete %sil
orb %al, %sil
jne 0x17749
testl %edx, %edx
setg %al
testl %ecx, %ecx
setg %sil
testb %sil, %al
jne 0x17749
leaq 0xde95(%rip), %rsi # 0... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c |
glfwGetFramebufferSize | GLFWAPI void glfwGetFramebufferSize(GLFWwindow* handle, int* width, int* height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (width)
*width = 0;
if (height)
*height = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetFramebufferSize(window, width, height);
... | testq %rdi, %rdi
je 0x177ce
testq %rsi, %rsi
je 0x177a4
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x177af
movl $0x0, (%rdx)
leaq 0x173b2(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x177c0
jmp 0x1b8dd
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x14954
pushq %rax
leaq 0xc5f9(%rip), %... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c |
glfwGetWindowFrameSize | GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* handle,
int* left, int* top,
int* right, int* bottom)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (left)
*left = 0;
if (top)
*top = 0;
... | testq %rdi, %rdi
je 0x1783f
testq %rsi, %rsi
je 0x177fe
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x17809
movl $0x0, (%rdx)
testq %rcx, %rcx
je 0x17814
movl $0x0, (%rcx)
testq %r8, %r8
je 0x17820
movl $0x0, (%r8)
leaq 0x17341(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x17831
jmp 0x1b8e2
movl $0x10001, %edi # ... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c |
glfwShowWindow | GLFWAPI void glfwShowWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformShowWindow(window);
_glfwPlatformFocusWindow(window);
} | pushq %rbx
testq %rdi, %rdi
je 0x17969
leaq 0x17230(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x17949
movq %rdi, %rbx
cmpq $0x0, 0x40(%rdi)
je 0x17958
popq %rbx
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rbx
jmp 0x14954
movq %rbx, %rdi
callq 0x1ac27
movq %rbx, %rdi
popq... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c |
glfwGetWindowAttrib | GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(0);
switch (attrib)
{
case GLFW_FOCUSED:
return _glfwPlatformWindowFocused(window);
case GLFW_ICONIFIED:
... | pushq %rbx
testq %rdi, %rdi
je 0x17b22
leaq 0x17140(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x17a52
movl %esi, %edx
leal -0x22001(%rdx), %eax
cmpl $0xa, %eax
ja 0x17a66
leaq 0xd7fb(%rip), %rcx # 0x2523c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x1f0(%rdi), %ebx
jmp 0x17a62
xorl %ebx, %ebx
... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c |
glfwSetWindowMonitor | GLFWAPI void glfwSetWindowMonitor(GLFWwindow* wh,
GLFWmonitor* mh,
int xpos, int ypos,
int width, int height,
int refreshRate)
{
_GLFWwindow* window = (_GLFWwindow*) wh;
_GLFWm... | pushq %rax
testq %rdi, %rdi
je 0x17c0b
leaq 0x16fce(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x17bcc
testl %r8d, %r8d
setg %al
testl %r9d, %r9d
setg %r10b
testb %r10b, %al
jne 0x17bdb
leaq 0xd77c(%rip), %rsi # 0x25334
movl $0x10004, %edi # imm = 0x10004
movl %r8d, %edx
movl %r9d, %ecx
xorl %eax, %ea... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/window.c |
glfwPlatformGetVideoMode | void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_glfw.... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x14f17(%rip), %r12 # 0x2eb78
cmpl $0x0, 0x7c8(%r12)
movq 0x130(%r12), %rdi
je 0x19d0e
cmpl $0x0, 0x7e0(%r12)
jne 0x19d0e
movq 0x140(%r12), %rsi
callq 0x10a00
movq %rax, %r14
movq 0x130(%r12), %rdi
movq 0x88(%r15), %rd... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_monitor.c |
glfwPlatformSetWindowIcon | void _glfwPlatformSetWindowIcon(_GLFWwindow* window,
int count, const GLFWimage* images)
{
if (count)
{
int i, j, longCount = 0;
for (i = 0; i < count; i++)
longCount += 2 + images[i].width * images[i].height;
long* icon = calloc(longCount,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x1b476
jle 0x1b499
movq %rdx, %r14
movl %esi, %ebp
movl %esi, %r13d
movq %r13, %rax
shlq $0x4, %rax
xorl %ecx, %ecx
xorl %r12d, %r12d
movl 0x4(%r14,%rcx), %edx
imull (%r14,%rcx), %edx
addl %edx, %r12d
addl ... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c |
glfwPlatformSetWindowPos | void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos)
{
// HACK: Explicitly setting PPosition to any value causes some WMs, notably
// Compiz and Metacity, to honor the position of unmapped windows
if (!_glfwPlatformWindowVisible(window))
{
long supplied;
XSizeHin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x135e8(%rip), %r12 # 0x2eb78
movq 0x130(%r12), %rdi
movq 0x318(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x108b0
cmpl $0x2, 0x5c(%r15)
je 0x1b606
callq 0x108f0
movq %rax, %r15
m... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c |
glfwPlatformSetWindowSizeLimits | void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
int minwidth, int minheight,
int maxwidth, int maxheight)
{
int width, height;
_glfwPlatformGetWindowSize(window, &width, &height);
updateNormalHints(window, width, height);... | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x13339(%rip), %r15 # 0x2eb78
movq 0x130(%r15), %rdi
movq 0x318(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x108b0
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
movq %rbx, %rdi
callq 0x1b738
movq 0x130(%r15), %rdi
callq 0x10680
addq $0x9... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c |
isFrameExtentsEvent | static Bool isFrameExtentsEvent(Display* display, XEvent* event, XPointer pointer)
{
_GLFWwindow* window = (_GLFWwindow*) pointer;
return event->type == PropertyNotify &&
event->xproperty.state == PropertyNewValue &&
event->xproperty.window == window->x11.handle &&
event->xprope... | xorl %eax, %eax
cmpl $0x1c, (%rsi)
jne 0x1bac7
cmpl $0x0, 0x38(%rsi)
je 0x1bac8
retq
movq 0x20(%rsi), %rcx
cmpq 0x318(%rdx), %rcx
jne 0x1bac7
movq 0x28(%rsi), %rcx
leaq 0x13098(%rip), %rdx # 0x2eb78
xorl %eax, %eax
cmpq 0x718(%rdx), %rcx
sete %al
retq
| /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c |
glfwPlatformIconifyWindow | void _glfwPlatformIconifyWindow(_GLFWwindow* window)
{
if (window->x11.overrideRedirect)
{
// Override-redirect windows cannot be iconified or restored, as those
// tasks are performed by the window manager
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Iconification ... | cmpl $0x0, 0x328(%rdi)
je 0x1bcf8
leaq 0xa82d(%rip), %rsi # 0x26519
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
jmp 0x14954
pushq %rbx
leaq 0x12e78(%rip), %rbx # 0x2eb78
movq 0x130(%rbx), %rax
movq 0x318(%rdi), %rsi
movl 0x138(%rbx), %edx
movq %rax, %rdi
callq 0x10350
movq 0x130(%rbx), %rdi
po... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c |
glfwPlatformRestoreWindow | void _glfwPlatformRestoreWindow(_GLFWwindow* window)
{
if (window->x11.overrideRedirect)
{
// Override-redirect windows cannot be iconified or restored, as those
// tasks are performed by the window manager
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Iconification ... | cmpl $0x0, 0x328(%rdi)
je 0x1bd45
leaq 0xa7e0(%rip), %rsi # 0x26519
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
jmp 0x14954
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq 0x318(%rdi), %rdi
callq 0x1c217
cmpl $0x3, %eax
jne 0x1bd91
leaq 0x12e... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c |
glfwPlatformWindowMaximized | int _glfwPlatformWindowMaximized(_GLFWwindow* window)
{
Atom* states;
unsigned long i;
GLFWbool maximized = GLFW_FALSE;
const unsigned long count =
_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_STATE,
XA_ATOM,
... | pushq %r14
pushq %rbx
pushq %rax
movq 0x318(%rdi), %rdi
leaq 0x1290c(%rip), %r14 # 0x2eb78
movq 0x6d8(%r14), %rsi
movq %rsp, %rbx
movl $0x4, %edx
movq %rbx, %rcx
callq 0x1a66c
movq (%rbx), %rdi
testq %rax, %rax
je 0x1c2b6
movq 0x6f0(%r14), %rcx
movq 0x6f8(%r14), %rdx
xorl %esi, %esi
movl $0x1, %ebx
movq (%rdi,%rsi,... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c |
glfwPlatformPollEvents | void _glfwPlatformPollEvents(void)
{
_glfwPollJoystickEvents();
int count = XPending(_glfw.x11.display);
while (count--)
{
XEvent event;
XNextEvent(_glfw.x11.display, &event);
processEvent(&event);
}
if (_glfw.x11.disabledCursorWindow)
centerCursor(_glfw.x11.dis... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
callq 0x1e071
leaq 0x12894(%rip), %r14 # 0x2eb78
movq 0x130(%r14), %rdi
callq 0x10a20
testl %eax, %eax
je 0x1cec3
movl %eax, %ebx
leaq 0x30(%rsp), %r13
movq 0x130(%r14), %rdi
movq %r13, %rsi
callq 0x10560
mo... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c |
glfwPlatformGetCursorPos | void _glfwPlatformGetCursorPos(_GLFWwindow* window, double* xpos, double* ypos)
{
Window root, child;
int rootX, rootY, childX, childY;
unsigned int mask;
XQueryPointer(_glfw.x11.display, window->x11.handle,
&root, &child,
&rootX, &rootY, &childX, &childY,
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x11b74(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rax
movq 0x318(%rdi), %rsi
subq $0x8, %rsp
leaq 0x1c(%rsp), %r10
leaq 0x14(%rsp), %r11
leaq 0x18(%rsp), %r15
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x24(%rsp), %r8
leaq 0... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c |
glfwPlatformSetCursorMode | void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
{
if (mode == GLFW_CURSOR_DISABLED)
{
_glfw.x11.disabledCursorWindow = window;
_glfwPlatformGetCursorPos(window,
&_glfw.x11.restoreCursorPosX,
&_glfw.x11.restoreCurs... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x11a8e(%rip), %r14 # 0x2eb78
cmpl $0x34003, %esi # imm = 0x34003
jne 0x1d154
movq %rbx, 0x680(%r14)
leaq 0x670(%r14), %rsi
leaq 0x678(%r14), %rdx
movq %rbx, %rdi
callq 0x1cfee
movq %rbx, %rdi
callq 0x1b01c
movq 0x318(%rbx), %rsi
movq 0x130(%r14), %rdi
... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c |
glfwPlatformGetKeyName | const char* _glfwPlatformGetKeyName(int key, int scancode)
{
KeySym keysym;
int extra;
if (!_glfw.x11.xkb.available)
return NULL;
if (key != GLFW_KEY_UNKNOWN)
scancode = _glfw.x11.nativeKeys[key];
if (!_glfwIsPrintable(_glfw.x11.publicKeys[scancode]))
return NULL;
key... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x1195a(%rip), %r15 # 0x2eb78
cmpl $0x0, 0x7e4(%r15)
je 0x1d2a4
movl %esi, %ebx
cmpl $-0x1, %edi
je 0x1d23b
movslq %edi, %rax
movswl 0x3b0(%r15,%rax,2), %ebx
movslq %ebx, %rax
movswl 0x1b0(%r15,%rax,2), %edi
callq 0x14d88
testl %eax, %eax
je 0x1d2a4
movq 0x130(... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/x11_window.c |
glfwInitJoysticksLinux | GLFWbool _glfwInitJoysticksLinux(void)
{
#if defined(__linux__)
DIR* dir;
int count = 0;
const char* dirname = "/dev/input";
_glfw.linux_js.inotify = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
if (_glfw.linux_js.inotify == -1)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x80800, %edi # imm = 0x80800
callq 0x10610
leaq 0x10f29(%rip), %rbx # 0x2eb78
movl %eax, 0xcc0(%rbx)
cmpl $-0x1, %eax
je 0x1dcd9
leaq 0x9853(%rip), %rsi # 0x274b4
movl %eax, %edi
movl $0x104, %edx # im... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/linux_joystick.c |
openJoystickDevice | static GLFWbool openJoystickDevice(const char* path)
{
char axisCount, buttonCount;
char name[256] = "";
int joy, fd, version;
_GLFWjoystickLinux* js;
for (joy = GLFW_JOYSTICK_1; joy <= GLFW_JOYSTICK_LAST; joy++)
{
if (!_glfw.linux_js.js[joy].present)
continue;
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
xorl %ebx, %ebx
movl $0x100, %edx # imm = 0x100
xorl %esi, %esi
callq 0x10110
leaq 0x10d3b(%rip), %r15 # 0x2eb78
cmpl $0x0, 0x940(%r15,%rbx)
je 0x1de5c
movq 0... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/linux_joystick.c |
destroyContextGLX | static void destroyContextGLX(_GLFWwindow* window)
{
if (window->context.glx.window)
{
glXDestroyWindow(_glfw.x11.display, window->context.glx.window);
window->context.glx.window = None;
}
if (window->context.glx.handle)
{
glXDestroyContext(_glfw.x11.display, window->context... | pushq %rbx
movq %rdi, %rbx
movq 0x270(%rdi), %rsi
testq %rsi, %rsi
je 0x1f25a
leaq 0xf936(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rdi
callq *0x8c8(%rax)
movq $0x0, 0x270(%rbx)
movq 0x268(%rbx), %rsi
testq %rsi, %rsi
je 0x1f285
leaq 0xf90b(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rdi
callq *0x890(%rax)
movq $... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/glx_context.c |
glfwChooseVisualGLX | GLFWbool _glfwChooseVisualGLX(const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig,
Visual** visual, int* depth)
{
GLXFBConfig native;
XVisualInfo* result;
if (!chooseGLXFBConfig(fbconfig, &native))
{
_glfwInputError(GLFW_FOR... | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rdi
movq %rsp, %rsi
callq 0x1ed94
testl %eax, %eax
je 0x1f2d7
leaq 0xf8d1(%rip), %rax # 0x2eb78
movq 0x130(%rax), %rdi
movq (%rsp), %rsi
callq *0x8b8(%rax)
testq %rax, %rax
je 0x1f2e7
movq (%rax), %rcx
movq %rcx, (%r14)
movl 0x14(%rax), %... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/glx_context.c |
glfwGetGLXContext | GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return NULL;
}
return window->context.glx.hand... | pushq %rbx
leaq 0xf85a(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x1f325
cmpl $0x0, 0x1f0(%rdi)
je 0x1f32e
movq 0x268(%rdi), %rbx
jmp 0x1f33e
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x1f335
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/glx_context.c |
glfwGetGLXWindow | GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(None);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return None;
}
return window->context.glx.window... | pushq %rbx
leaq 0xf81d(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x1f362
cmpl $0x0, 0x1f0(%rdi)
je 0x1f36b
movq 0x270(%rdi), %rbx
jmp 0x1f37b
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x1f372
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/glx_context.c |
glfwInitEGL | GLFWbool _glfwInitEGL(void)
{
int i;
const char* sonames[] =
{
#if defined(_GLFW_WIN32)
"libEGL.dll",
"EGL.dll",
#elif defined(_GLFW_COCOA)
"libEGL.dylib",
#else
"libEGL.so.1",
#endif
NULL
};
if (_glfw.egl.handle)
return GLFW_TRUE;
for (i = 0; s... | pushq %r14
pushq %rbx
pushq %rax
leaq 0xf7ed(%rip), %r14 # 0x2eb78
movl $0x1, %ebx
cmpq $0x0, 0xd30(%r14)
jne 0x1f741
leaq 0x875d(%rip), %rdi # 0x27b02
movl $0x1, %esi
callq 0x105b0
movq %rax, 0xd30(%r14)
testq %rax, %rax
je 0x1f66f
movl $0x1, 0xd20(%r14)
leaq 0x8754(%rip), %rsi # 0x27b25
movq %rax, %rdi... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/egl_context.c |
glfwTerminateEGL | void _glfwTerminateEGL(void)
{
if (_glfw.egl.display)
{
eglTerminate(_glfw.egl.display);
_glfw.egl.display = EGL_NO_DISPLAY;
}
if (_glfw.egl.handle)
{
_glfw_dlclose(_glfw.egl.handle);
_glfw.egl.handle = NULL;
}
} | pushq %rbx
leaq 0xf425(%rip), %rbx # 0x2eb78
movq 0xd10(%rbx), %rdi
testq %rdi, %rdi
je 0x1f770
callq *0xd60(%rbx)
movq $0x0, 0xd10(%rbx)
movq 0xd30(%rbx), %rdi
testq %rdi, %rdi
je 0x1f78c
callq 0x10a60
movq $0x0, 0xd30(%rbx)
popq %rbx
retq
| /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/egl_context.c |
getEGLErrorString | static const char* getEGLErrorString(EGLint error)
{
switch (error)
{
case EGL_SUCCESS:
return "Success";
case EGL_NOT_INITIALIZED:
return "EGL is not or could not be initialized";
case EGL_BAD_ACCESS:
return "EGL cannot access a requested resource";
... | addl $0xffffd000, %edi # imm = 0xFFFFD000
cmpl $0xe, %edi
ja 0x1f7aa
movl %edi, %eax
leaq 0x8ac6(%rip), %rcx # 0x28268
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x89e1(%rip), %rax # 0x28192
retq
| /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/egl_context.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.