name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
qpdf::Array::at(int) const | std::pair<bool, QPDFObjectHandle>
Array::at(int n) const
{
auto a = array();
if (n < 0 || n >= size()) {
return {false, {}};
}
if (!a->sp) {
return {true, a->elements[size_t(n)]};
}
auto const& iter = a->sp->elements.find(n);
return {true, iter == a->sp->elements.end() ? null() : iter->second};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xf84f8
testl %ebp, %ebp
js 0xf8b95
movq %rax, %r14
movq %r15, %rdi
callq 0xf84f8
movq (%rax), %rcx
testq %rcx, %rcx
je 0xf8b24
movl (%rcx), %ecx
jmp 0xf8b30
movq 0x10(%rax), %rcx
subq 0x8(%rax), %rcx
shrq $0x4, %rcx
cmpl %ebp, %ecx
jle 0xf8b95
movq (%r14), %rax
testq %rax, %rax
je 0xf8ba1
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0xf8b71
addq $0x10, %rax
movq %rax, %rcx
xorl %esi, %esi
cmpl %ebp, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0xf8b4c
cmpq %rax, %rcx
je 0xf8b71
cmpl %ebp, 0x20(%rcx)
jle 0xf8bf6
movq 0xf8800(%rip), %rax # 0x1f1378
movq 0xf8801(%rip), %rcx # 0x1f1380
testq %rcx, %rcx
je 0xf8bd5
movq 0xf73f5(%rip), %rdx # 0x1eff80
cmpb $0x0, (%rdx)
je 0xf8bd9
incl 0x8(%rcx)
jmp 0xf8bdd
movb $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0xf8be8
movl %ebp, %eax
movq 0x8(%r14), %rcx
shlq $0x4, %rax
movb $0x1, (%rbx)
movq (%rcx,%rax), %rdx
movq %rdx, 0x8(%rbx)
movq 0x8(%rcx,%rax), %rax
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0xf8be8
movq 0xf73b5(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0xf8c03
incl 0x8(%rax)
jmp 0xf8be8
xorl %ecx, %ecx
jmp 0xf8bdd
lock
incl 0x8(%rcx)
movb $0x1, (%rbx)
movq %rax, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rcx), %rax
movq 0x30(%rcx), %rcx
jmp 0xf8b7f
lock
incl 0x8(%rax)
jmp 0xf8be8
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::getArrayItem(int) const | QPDFObjectHandle
QPDFObjectHandle::getArrayItem(int n) const
{
if (auto array = as_array(strict)) {
if (auto const [success, oh] = array.at(n); success) {
return oh;
} else {
objectWarning("returning null for out of bounds array access");
QTC::TC("qpdf", "QPDFObjectHandle array bounds");
}
} else {
typeWarning("array", "returning null");
QTC::TC("qpdf", "QPDFObjectHandle array null for non-array");
}
static auto constexpr msg = " -> null returned from invalid array access"sv;
return QPDF_Null::create(obj, msg, "");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xf953a
movl %edx, %ebp
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xf94f9
cmpl $0xd, %eax
jne 0xf9504
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12b162
jmp 0xf94fe
callq 0x3f39f
movq (%rax), %rax
movb 0x30(%rax), %al
cmpb $0x8, %al
jne 0xf953a
movq (%r14), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%r14), %rcx
movq %rcx, 0x28(%rsp)
testq %rcx, %rcx
je 0xf966c
movq 0xf6a57(%rip), %rdx # 0x1eff80
cmpb $0x0, (%rdx)
je 0xf9663
incl 0x8(%rcx)
jmp 0xf966c
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x81ccc(%rip), %rsi # 0x17b227
leaq 0x81cd3(%rip), %rdx # 0x17b235
movq %rsp, %rdi
callq 0x1ef84
leaq 0x83723(%rip), %rsi # 0x17cc94
movq %rsp, %rdx
movq %r14, %rdi
callq 0xc1e78
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xf9592
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
movb $0x1, %bpl
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x3f402
movq -0x8(%r15), %rdi
testq %rdi, %rdi
je 0xf95b0
callq 0x1ef14
testb %bpl, %bpl
je 0xf9652
movq (%r14), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0xf95e4
movq 0xf69aa(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0xf95e0
incl 0x8(%rax)
jmp 0xf95e4
lock
incl 0x8(%rax)
leaq 0x78(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x816f2(%rip), %rdx # 0x17ace6
leaq 0x68(%rsp), %rdi
movq %rdx, %rsi
callq 0x1ef84
leaq 0xf4de8(%rip), %rdx # 0x1ee3f0
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
leaq 0x68(%rsp), %rcx
callq 0xfaab2
movaps (%rsp), %xmm0
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movups %xmm0, (%rbx)
movq %rax, (%rsp)
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0xf9643
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0xf9652
callq 0x1ef14
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
lock
incl 0x8(%rcx)
movq 0x20(%rsp), %rax
movq $0x0, 0x30(%rsp)
testq %rax, %rax
je 0xf954b
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl %ebp, %edx
callq 0xf8aee
movb 0x50(%rsp), %bpl
cmpb $0x1, %bpl
jne 0xf96c1
movq 0x58(%rsp), %rax
movq %rax, (%rbx)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xf9707
movq 0xf68c9(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0xf9703
incl 0x8(%rax)
jmp 0xf9707
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x81b28(%rip), %rsi # 0x17b1f9
leaq 0x81b4e(%rip), %rdx # 0x17b226
movq %rsp, %rdi
callq 0x1ef84
movq %rsp, %rsi
movq %r14, %rdi
callq 0xc900c
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xf9707
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0xf9707
lock
incl 0x8(%rax)
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xf9716
callq 0x1ef14
testb %bpl, %bpl
je 0xf9592
xorl %ebp, %ebp
jmp 0xf9595
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xf9744
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0xf9744
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xf97a5
callq 0x1ef14
jmp 0xf97a5
jmp 0xf97a2
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0xf9776
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0xf9776
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0xf97af
callq 0x1ef14
jmp 0xf97af
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xf97a5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0xf97a5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3ed06
movq %rbx, %rdi
callq 0x19710
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::getArrayAsVector() const | std::vector<QPDFObjectHandle>
QPDFObjectHandle::getArrayAsVector() const
{
if (auto array = as_array(strict)) {
return array.getAsVector();
}
typeWarning("array", "treating as empty");
QTC::TC("qpdf", "QPDFObjectHandle array treating as empty vector");
return {};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xf9eb4
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xf9e74
cmpl $0xd, %eax
jne 0xf9e7f
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12b162
jmp 0xf9e79
callq 0x3f39f
movq (%rax), %rax
movb 0x30(%rax), %al
cmpb $0x8, %al
jne 0xf9eb4
movq (%r14), %rax
movq %rax, (%rsp)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
je 0xf9f4b
movq 0xf60dd(%rip), %rdx # 0x1eff80
cmpb $0x0, (%rdx)
je 0xf9f43
incl 0x8(%rcx)
jmp 0xf9f4b
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x3f402
movq -0x8(%r15), %rdi
testq %rdi, %rdi
je 0xf9ee1
callq 0x1ef14
testb %bpl, %bpl
jne 0xf9f35
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x812f4(%rip), %rsi # 0x17b1e7
leaq 0x812fe(%rip), %rdx # 0x17b1f8
callq 0x1ef84
leaq 0x82d8e(%rip), %rsi # 0x17cc94
movq %rsp, %rdx
movq %r14, %rdi
callq 0xc1e78
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xf9f27
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
lock
incl 0x8(%rcx)
movq (%rsp), %rax
movq $0x0, 0x10(%rsp)
testq %rax, %rax
je 0xf9ec4
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xf8602
jmp 0xf9ec6
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3ed06
jmp 0xf9f9b
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xf9f9b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0xf9f9b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x19710
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDF::decryptString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, QPDFObjGen) | void
QPDF::decryptString(std::string& str, QPDFObjGen og)
{
if (!og.isIndirect()) {
return;
}
bool use_aes = false;
if (m->encp->encryption_V >= 4) {
switch (m->encp->cf_string) {
case e_none:
return;
case e_aes:
use_aes = true;
break;
case e_aesv3:
use_aes = true;
break;
case e_rc4:
break;
default:
warn(damagedPDF(
"unknown encryption filter for strings (check /StrF in "
"/Encrypt dictionary); strings may be decrypted improperly"));
// To avoid repeated warnings, reset cf_string. Assume we'd want to use AES if V == 4.
m->encp->cf_string = e_aes;
use_aes = true;
break;
}
}
std::string key = getKeyForObject(m->encp, og, use_aes);
try {
if (use_aes) {
QTC::TC("qpdf", "QPDF_encryption aes decode string");
Pl_Buffer bufpl("decrypted string");
Pl_AES_PDF pl(
"aes decrypt string",
&bufpl,
false,
QUtil::unsigned_char_pointer(key),
key.length());
pl.writeString(str);
pl.finish();
str = bufpl.getString();
} else {
QTC::TC("qpdf", "QPDF_encryption rc4 decode string");
size_t vlen = str.length();
// Using std::shared_ptr guarantees that tmp will be freed even if rc4.process throws an
// exception.
auto tmp = QUtil::make_unique_cstr(str);
RC4 rc4(QUtil::unsigned_char_pointer(key), toI(key.length()));
auto data = QUtil::unsigned_char_pointer(tmp.get());
rc4.process(data, vlen, data);
str = std::string(tmp.get(), vlen);
}
} catch (QPDFExc&) {
throw;
} catch (std::runtime_error& e) {
throw damagedPDF("error decrypting string for object " + og.unparse() + ": " + e.what());
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdx, 0x58(%rsp)
testl %edx, %edx
je 0x107e17
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x108(%rax), %rcx
cmpl $0x4, 0x4(%rcx)
jl 0x107ba1
movl 0x44(%rcx), %edx
cmpq $0x4, %rdx
ja 0x107ba5
leaq 0x744b8(%rip), %rsi # 0x17c050
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
xorl %ebp, %ebp
jmp 0x107c23
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x74746(%rip), %rsi # 0x17c2fb
leaq 0x747ae(%rip), %rdx # 0x17c36a
leaq 0x20(%rsp), %rdi
callq 0x1ef84
leaq 0xb0(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
callq 0x3e110
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0x3a51e
leaq 0xb0(%rsp), %rdi
callq 0x201d4
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x107c0f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x190e0
movq (%rbx), %rax
movq 0x108(%rax), %rcx
movl $0x3, 0x44(%rcx)
movb $0x1, %bpl
movq %rcx, 0x60(%rsp)
movq 0x110(%rax), %rax
movq %rax, 0x68(%rsp)
testq %rax, %rax
je 0x107c4e
movq 0xe8340(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0x107c4a
incl 0x8(%rax)
jmp 0x107c4e
lock
incl 0x8(%rax)
movq 0x58(%rsp), %rdx
movzbl %bpl, %ecx
leaq 0x70(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x107a4c
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x107c75
callq 0x1ef14
testb %bpl, %bpl
je 0x107d2c
leaq 0x746e6(%rip), %rsi # 0x17c36b
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
callq 0x32a4c
leaq 0x70(%rsp), %rdi
callq 0x13e05f
movq 0x78(%rsp), %r9
leaq 0x746d5(%rip), %rsi # 0x17c37c
leaq 0xb0(%rsp), %rdi
leaq 0x20(%rsp), %rdx
xorl %ecx, %ecx
movq %rax, %r8
callq 0x31514
leaq 0xb0(%rsp), %rdi
movq %r14, %rsi
callq 0x30d38
leaq 0xb0(%rsp), %rdi
callq 0x3195c
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x32c30
movq %rsp, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x195c0
movq (%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x107d10
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0xb0(%rsp), %rdi
callq 0x31aae
leaq 0x20(%rsp), %rdi
callq 0x32ac6
jmp 0x107df6
movq 0x8(%r14), %r15
movq %rsp, %rdi
movq %r14, %rsi
callq 0x13e9b5
leaq 0x70(%rsp), %rdi
callq 0x13e05f
movq %rax, %r12
movq 0x78(%rsp), %r13
testq $-0x80000000, %r13 # imm = 0x80000000
je 0x107d5e
movq %r13, %rdi
callq 0x6271e
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x148e3c
movq (%rsp), %rdi
callq 0x13e063
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x148e7a
movq (%rsp), %rsi
leaq 0xc0(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rsi, %r15
leaq 0xb0(%rsp), %rdi
movq %r15, %rdx
callq 0x1ef84
leaq 0xb0(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x195c0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x107dd9
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x107de8
callq 0x1ef14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x107df6
callq 0x193d0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x107e17
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x190e0
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0xb0(%rsp), %rdi
callq 0x201d4
jmp 0x107e3e
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x108114
movq 0x30(%rsp), %rsi
jmp 0x10810c
movq %rax, %r14
jmp 0x108114
jmp 0x107e76
jmp 0x107e9b
jmp 0x107e6e
jmp 0x107e66
movq %rdx, %r15
movq %rax, %r14
jmp 0x107ec0
movq %rdx, %r15
movq %rax, %r14
jmp 0x107e8b
movq %rdx, %r15
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x107e8b
callq 0x1ef14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x107ec0
callq 0x193d0
jmp 0x107ec0
movq %rdx, %r15
movq %rax, %r14
leaq 0xb0(%rsp), %rdi
callq 0x31aae
jmp 0x107eb6
movq %rdx, %r15
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x32ac6
cmpl $0x2, %r15d
jne 0x107ed8
movq %r14, %rdi
callq 0x19060
callq 0x19900
jmp 0x108015
cmpl $0x1, %r15d
jne 0x1080f3
movq %r14, %rdi
callq 0x19060
movq %rax, %r14
movl $0x80, %edi
callq 0x193f0
movq %rax, %r15
leaq 0x90(%rsp), %rdi
leaq 0x58(%rsp), %rsi
movl $0x2c, %edx
callq 0x3e91a
leaq 0x74477(%rip), %rsi # 0x17c38f
movq %rsp, %rdi
leaq 0x90(%rsp), %rdx
callq 0x1d725
leaq 0x75178(%rip), %rsi # 0x17d0a7
movq %rsp, %rdi
callq 0x19730
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x107f59
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x107f66
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %r12
movq %rdx, 0x8(%r12)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x19730
leaq 0xc0(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x107fbd
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x107fd0
movq %rdx, 0xb0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xc0(%rsp)
movq 0x8(%rax), %rsi
leaq 0xb0(%rsp), %rdx
movq %rsi, 0x8(%rdx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3e110
xorl %ebp, %ebp
leaq 0xe1dfa(%rip), %rsi # 0x1e9e00
leaq -0xe7e39(%rip), %rdx # 0x201d4
movq %r15, %rdi
callq 0x196e0
movq %rax, %r14
movq 0xb0(%rsp), %rdi
cmpq %r12, %rdi
je 0x10803d
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x10803d
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x10805c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x10805c
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x108077
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x108098
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x1080c8
jmp 0x1080d0
movq %rax, %r14
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1080c8
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x1080c8
movq %rax, %r14
movq %r15, %rdi
callq 0x19a40
callq 0x19890
jmp 0x1080f3
movq %rax, %r14
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x108114
callq 0x1ef14
jmp 0x108114
movq %rax, %r14
callq 0x19890
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x108114
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %r14, %rdi
callq 0x19710
movq %rax, %rdi
callq 0x1d236
| /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
compute_U_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | static std::string
compute_U_value(std::string const& user_password, QPDF::EncryptionData const& data)
{
if (data.getR() >= 3) {
return compute_U_value_R3(user_password, data);
}
return compute_U_value_R2(user_password, data);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x3, 0x4(%rdx)
jl 0x109a88
movq %rsp, %rdi
movq %r14, %rdx
callq 0x10364e
leaq 0x40(%rsp), %rdi
callq 0x29c08
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x103818
movq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl $0x20, %edx
callq 0x29cf0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10998f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x1099a6
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0xb0(%r14), %rsi
movq 0xb8(%r14), %rdx
leaq 0x40(%rsp), %rdi
callq 0x29cf0
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x29f46
movslq 0x8(%r14), %r15
testq %r15, %r15
jns 0x1099de
movl %r15d, %edi
callq 0x328ee
movq 0x8(%rsp), %rsi
subq %rsi, %r15
jbe 0x1099f8
movq %rsp, %rdi
xorl %edx, %edx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x19640
movq %rsp, %rdi
callq 0x13e05f
movl 0x8(%r14), %ecx
leaq 0x20(%rsp), %rdi
movl $0x10, %esi
movq %rax, %rdx
movl $0x14, %r8d
xorl %r9d, %r9d
callq 0x10b17a
movaps 0x20(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x78(%rsp), %rsi
movq $0x20, (%rsi)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x19760
movq %rax, (%rbx)
movq 0x78(%rsp), %rcx
movq %rcx, 0x10(%rbx)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rax)
movaps 0x725df(%rip), %xmm0 # 0x17c040
movups %xmm0, 0x10(%rax)
movq %rcx, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax,%rcx)
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x109b4d
callq 0x1ef14
jmp 0x109b4d
movq %rsp, %rdi
movq %r14, %rdx
callq 0x10364e
movaps 0x725e6(%rip), %xmm0 # 0x17c080
movaps %xmm0, 0x30(%rsp)
movaps 0x725ca(%rip), %xmm0 # 0x17c070
movaps %xmm0, 0x20(%rsp)
movslq 0x8(%r14), %r15
testq %r15, %r15
jns 0x109abc
movl %r15d, %edi
callq 0x328ee
movq 0x8(%rsp), %rsi
subq %rsi, %r15
jbe 0x109ad6
movq %rsp, %rdi
xorl %edx, %edx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x19640
leaq 0x20(%rsp), %rdi
callq 0x13e063
movq %rax, %r15
movq %rsp, %rdi
callq 0x13e05f
movl 0x8(%r14), %ecx
movl $0x20, %esi
movq %r15, %rdi
movq %rax, %rdx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x10b17a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x50(%rsp), %rsi
movq $0x20, (%rsi)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x19760
movq %rax, (%rbx)
movq 0x50(%rsp), %rcx
movq %rcx, 0x10(%rbx)
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq %rcx, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax,%rcx)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x109b68
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x109bbd
jmp 0x109bd1
jmp 0x109bbd
jmp 0x109bd1
jmp 0x109bbd
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x109ba2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x109ba2
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x109bc0
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x109bc0
jmp 0x109bd1
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x109bd4
callq 0x1ef14
jmp 0x109bd4
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x109bef
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
callq 0x19710
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::allowAccessibility() | bool
QPDF::allowAccessibility()
{
int R = 0;
int P = 0;
bool status = true;
if (isEncrypted(R, P)) {
if (R < 3) {
status = is_bit_set(P, 5);
} else {
status = is_bit_set(P, 10);
}
}
return status;
} | subq $0x28, %rsp
xorl %eax, %eax
leaq 0x14(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x10(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x24(%rsp), %rcx
leaq 0x20(%rsp), %r8
leaq 0x1c(%rsp), %r9
callq 0x10a9ce
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
je 0x10ad44
cmpl $0x2, 0x14(%rsp)
movl 0x10(%rsp), %eax
jg 0x10ad3e
andl $0x10, %eax
shrl $0x4, %eax
jmp 0x10ad44
shrl $0x9, %eax
andl $0x1, %eax
addq $0x28, %rsp
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::allowModifyForm() | bool
QPDF::allowModifyForm()
{
int R = 0;
int P = 0;
bool status = true;
if (isEncrypted(R, P)) {
if (R < 3) {
status = is_bit_set(P, 6);
} else {
status = is_bit_set(P, 9);
}
}
return status;
} | subq $0x28, %rsp
xorl %eax, %eax
leaq 0x14(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x10(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x24(%rsp), %rcx
leaq 0x20(%rsp), %r8
leaq 0x1c(%rsp), %r9
callq 0x10a9ce
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
je 0x10aee0
cmpl $0x2, 0x14(%rsp)
movl 0x10(%rsp), %eax
jg 0x10aeda
andl $0x20, %eax
shrl $0x5, %eax
jmp 0x10aee0
shrl $0x8, %eax
andl $0x1, %eax
addq $0x28, %rsp
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
is_obj_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&, int&) | static bool
is_obj_key(std::string const& v, int& obj, int& gen)
{
if (v.substr(0, 4) != "obj:") {
return false;
}
return is_indirect_object(v.substr(4), obj, gen);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movl $0x4, %ecx
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x19b70
leaq 0x58bfa(%rip), %rsi # 0x1658a9
movq %r12, %rdi
callq 0x19a80
movl %eax, %ebp
movq (%r12), %rdi
leaq 0x18(%rsp), %r13
cmpq %r13, %rdi
je 0x10ccd4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
testl %ebp, %ebp
je 0x10ccdc
xorl %ebx, %ebx
jmp 0x10cd20
leaq 0x8(%rsp), %r12
movl $0x4, %edx
movq %r12, %rdi
movq %r15, %rsi
movq $-0x1, %rcx
callq 0x19b70
movq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10cb03
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x10cd20
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x10cd4b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
callq 0x19710
| /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::JSONReactor::containerStart() | void
QPDF::JSONReactor::containerStart()
{
if (next_obj) {
stack.emplace_back(next_state, std::move(next_obj));
next_obj = QPDFObjectHandle();
} else {
stack.emplace_back(next_state);
}
} | pushq %rbx
movq %rdi, %rbx
addq $0x68, %rdi
leaq 0x90(%rbx), %rsi
cmpq $0x0, 0x80(%rbx)
je 0x10d0ad
leaq 0x80(%rbx), %rdx
callq 0x110882
xorps %xmm0, %xmm0
movq 0x88(%rbx), %rdi
movups %xmm0, 0x80(%rbx)
testq %rdi, %rdi
je 0x10d0b3
popq %rbx
jmp 0x1ef14
popq %rbx
jmp 0x1108e6
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
void write_vector_int<QPDF::HPageOffsetEntry, int>(BitWriter&, int, std::vector<QPDF::HPageOffsetEntry, std::allocator<QPDF::HPageOffsetEntry>>&, int, int QPDF::HPageOffsetEntry::*) | static void
write_vector_int(BitWriter& w, int nitems, std::vector<T>& vec, int bits, int_type T::* field)
{
// nitems times, write bits bits from the given field of the ith vector to the given bit writer.
for (size_t i = 0; i < QIntC::to_size(nitems); ++i) {
w.writeBits(QIntC::to_ulonglong(vec.at(i).*field), QIntC::to_size(bits));
}
// The PDF spec says that each hint table starts at a byte boundary. Each "row" actually must
// start on a byte boundary.
w.flush();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, 0x10(%rsp)
movslq %esi, %rax
movq %rax, 0x20(%rsp)
movl %ecx, 0xc(%rsp)
movslq %ecx, %rax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
testl %r13d, %r13d
jns 0x11af3f
movl %r13d, %edi
callq 0x328ee
cmpq %r14, 0x20(%rsp)
je 0x11afa9
movq (%r15), %rbp
movq 0x8(%r15), %rdx
subq %rbp, %rdx
sarq $0x3, %rdx
movabsq $0x2e8ba2e8ba2e8ba3, %rax # imm = 0x2E8BA2E8BA2E8BA3
imulq %rax, %rdx
cmpq %r14, %rdx
jbe 0x11afc1
movl (%rbp,%rbx), %r12d
testl %r12d, %r12d
jns 0x11af7e
movl %r12d, %edi
callq 0xf7dfe
movl (%rbp,%rbx), %r12d
cmpl $0x0, 0xc(%rsp)
jns 0x11af8e
movl 0xc(%rsp), %edi
callq 0x328ee
movslq %r12d, %rsi
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
callq 0x1db70
incq %r14
addq $0x58, %rbx
jmp 0x11af32
movq 0x10(%rsp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1dcac
leaq 0x42f64(%rip), %rdi # 0x15df2c
movq %r14, %rsi
xorl %eax, %eax
callq 0x19030
| /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::reconstruct_xref(QPDFExc&, bool) | void
QPDF::reconstruct_xref(QPDFExc& e, bool found_startxref)
{
if (m->reconstructed_xref) {
// Avoid xref reconstruction infinite loops. This is getting very hard to reproduce because
// qpdf is throwing many fewer exceptions while parsing. Most situations are warnings now.
throw e;
}
// If recovery generates more than 1000 warnings, the file is so severely damaged that there
// probably is no point trying to continue.
const auto max_warnings = m->warnings.size() + 1000U;
auto check_warnings = [this, max_warnings]() {
if (m->warnings.size() > max_warnings) {
throw damagedPDF("", -1, "too many errors while reconstructing cross-reference table");
}
};
m->reconstructed_xref = true;
// We may find more objects, which may contain dangling references.
m->fixed_dangling_refs = false;
warn(damagedPDF("", -1, "file is damaged"));
warn(e);
warn(damagedPDF("", -1, "Attempting to reconstruct cross-reference table"));
// Delete all references to type 1 (uncompressed) objects
std::vector<QPDFObjGen> to_delete;
for (auto const& iter: m->xref_table) {
if (iter.second.getType() == 1) {
to_delete.emplace_back(iter.first);
}
}
for (auto const& iter: to_delete) {
m->xref_table.erase(iter);
}
std::vector<std::tuple<int, int, qpdf_offset_t>> found_objects;
std::vector<qpdf_offset_t> trailers;
std::vector<qpdf_offset_t> startxrefs;
m->file->seek(0, SEEK_END);
qpdf_offset_t eof = m->file->tell();
m->file->seek(0, SEEK_SET);
// Don't allow very long tokens here during recovery. All the interesting tokens are covered.
static size_t const MAX_LEN = 10;
while (m->file->tell() < eof) {
QPDFTokenizer::Token t1 = readToken(*m->file, MAX_LEN);
qpdf_offset_t token_start = m->file->tell() - toO(t1.getValue().length());
if (t1.isInteger()) {
auto pos = m->file->tell();
auto t2 = readToken(*m->file, MAX_LEN);
if (t2.isInteger() && readToken(*m->file, MAX_LEN).isWord("obj")) {
int obj = QUtil::string_to_int(t1.getValue().c_str());
int gen = QUtil::string_to_int(t2.getValue().c_str());
if (obj <= m->xref_table_max_id) {
found_objects.emplace_back(obj, gen, token_start);
} else {
warn(damagedPDF(
"", -1, "ignoring object with impossibly large id " + std::to_string(obj)));
}
}
m->file->seek(pos, SEEK_SET);
} else if (!m->trailer && t1.isWord("trailer")) {
trailers.emplace_back(m->file->tell());
} else if (!found_startxref && t1.isWord("startxref")) {
startxrefs.emplace_back(m->file->tell());
}
check_warnings();
m->file->findAndSkipNextEOL();
}
if (!found_startxref && !startxrefs.empty() && !found_objects.empty() &&
startxrefs.back() > std::get<2>(found_objects.back())) {
try {
m->file->seek(startxrefs.back(), SEEK_SET);
if (auto offset = QUtil::string_to_ll(readToken(*m->file).getValue().data())) {
read_xref(offset);
if (getRoot().getKey("/Pages").isDictionary()) {
QTC::TC("qpdf", "QPDF startxref more than 1024 before end");
warn(damagedPDF(
"", -1, "startxref was more than 1024 bytes before end of file"));
initializeEncryption();
m->parsed = true;
m->reconstructed_xref = false;
return;
}
}
} catch (...) {
// ok, bad luck. Do recovery.
}
}
auto rend = found_objects.rend();
for (auto it = found_objects.rbegin(); it != rend; it++) {
auto [obj, gen, token_start] = *it;
insertXrefEntry(obj, 1, token_start, gen);
check_warnings();
}
m->deleted_objects.clear();
for (auto it = trailers.rbegin(); it != trailers.rend(); it++) {
m->file->seek(*it, SEEK_SET);
auto t = readTrailer();
if (!t.isDictionary()) {
// Oh well. It was worth a try.
} else {
if (t.hasKey("/Root")) {
m->trailer = t;
break;
}
warn(damagedPDF("trailer", *it, "recovered trailer has no /Root entry"));
}
check_warnings();
}
if (!m->trailer) {
qpdf_offset_t max_offset{0};
size_t max_size{0};
// If there are any xref streams, take the last one to appear.
for (auto const& iter: m->xref_table) {
auto entry = iter.second;
if (entry.getType() != 1) {
continue;
}
auto oh = getObject(iter.first);
try {
if (!oh.isStreamOfType("/XRef")) {
continue;
}
} catch (std::exception&) {
continue;
}
auto offset = entry.getOffset();
auto size = oh.getDict().getKey("/Size").getUIntValueAsUInt();
if (size > max_size || (size == max_size && offset > max_offset)) {
max_offset = offset;
setTrailer(oh.getDict());
}
check_warnings();
}
if (max_offset > 0) {
try {
read_xref(max_offset);
} catch (std::exception&) {
warn(damagedPDF(
"", -1, "error decoding candidate xref stream while recovering damaged file"));
}
QTC::TC("qpdf", "QPDF recover xref stream");
}
}
if (!m->trailer || (!m->parsed && !m->trailer.getKey("/Root").isDictionary())) {
// Try to find a Root dictionary. As a quick fix try the one with the highest object id.
QPDFObjectHandle root;
for (auto const& iter: m->obj_cache) {
try {
if (QPDFObjectHandle(iter.second.object).isDictionaryOfType("/Catalog")) {
root = iter.second.object;
}
} catch (std::exception&) {
continue;
}
}
if (root) {
if (!m->trailer) {
warn(damagedPDF(
"", -1, "unable to find trailer dictionary while recovering damaged file"));
m->trailer = QPDFObjectHandle::newDictionary();
}
m->trailer.replaceKey("/Root", root);
}
}
if (!m->trailer) {
// We could check the last encountered object to see if it was an xref stream. If so, we
// could try to get the trailer from there. This may make it possible to recover files with
// bad startxref pointers even when they have object streams.
throw damagedPDF("", -1, "unable to find trailer dictionary while recovering damaged file");
}
if (m->xref_table.empty()) {
// We cannot check for an empty xref table in parse because empty tables are valid when
// creating QPDF objects from JSON.
throw damagedPDF("", -1, "unable to find objects while recovering damaged file");
}
check_warnings();
if (!m->parsed) {
m->parsed = true;
getAllPages();
check_warnings();
if (m->all_pages.empty()) {
m->parsed = false;
throw damagedPDF("", -1, "unable to find any pages while recovering damaged file");
}
}
// We could iterate through the objects looking for streams and try to find objects inside of
// them, but it's probably not worth the trouble. Acrobat can't recover files with any errors
// in an xref stream, and this would be a real long shot anyway. If we wanted to do anything
// that involved looking at stream contents, we'd also have to call initializeEncryption() here.
// It's safe to call it more than once.
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rsi, %r14
movq (%rdi), %rax
cmpb $0x1, 0x2d0(%rax)
je 0x124b94
movl %edx, %r15d
movq %rdi, %rbx
movq 0x278(%rax), %rbp
subq 0x270(%rax), %rbp
movw $0x1, 0x2d0(%rax)
leaq 0xc8(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x56e06(%rip), %rdx # 0x17ace6
leaq 0xb8(%rsp), %rdi
movq %rdx, %rsi
callq 0x1ef84
leaq 0x140(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x5a61b(%rip), %rsi # 0x17e51e
leaq 0x5a623(%rip), %rdx # 0x17e52d
leaq 0x130(%rsp), %rdi
callq 0x1ef84
leaq 0x10(%rsp), %rdi
leaq 0xb8(%rsp), %rdx
leaq 0x130(%rsp), %r8
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x3bf60
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3a51e
leaq 0x10(%rsp), %rdi
callq 0x201d4
movq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
cmpq %rax, %rdi
je 0x123f77
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x123f9c
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a51e
leaq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x56d25(%rip), %rdx # 0x17ace6
movq %rdx, %rsi
callq 0x1ef84
leaq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
movq %rax, (%rdi)
leaq 0x5a54b(%rip), %rsi # 0x17e52e
leaq 0x5a573(%rip), %rdx # 0x17e55d
callq 0x1ef84
leaq 0x10(%rsp), %rdi
leaq 0xb8(%rsp), %rdx
leaq 0x130(%rsp), %r8
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x3bf60
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3a51e
leaq 0x10(%rsp), %rdi
callq 0x201d4
movq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
cmpq %rax, %rdi
je 0x12404f
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x190e0
movl %r15d, 0x19c(%rsp)
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x12407c
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
xorps %xmm0, %xmm0
movaps %xmm0, 0x220(%rsp)
movq $0x0, 0x230(%rsp)
movq (%rbx), %r12
movq 0x150(%r12), %r14
addq $0x140, %r12 # imm = 0x140
cmpq %r12, %r14
je 0x12411c
leaq 0x220(%rsp), %r15
leaq 0x28(%r14), %rdi
callq 0xf82c6
cmpl $0x1, %eax
jne 0x1240cc
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x130be4
movq %r14, %rdi
callq 0x19b30
movq %rax, %r14
cmpq %r12, %rax
jne 0x1240b2
movq 0x220(%rsp), %r14
movq 0x228(%rsp), %r12
cmpq %r12, %r14
je 0x12411c
movl $0x138, %r13d # imm = 0x138
movq (%rbx), %r15
addq %r13, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x133c30
movq %r15, %rdi
movq %rax, %rsi
callq 0x133cfe
addq $0x8, %r14
cmpq %r12, %r14
jne 0x1240f7
xorps %xmm0, %xmm0
movaps %xmm0, 0x200(%rsp)
xorl %eax, %eax
movq %rax, 0x210(%rsp)
movq %rax, 0x1b0(%rsp)
movaps %xmm0, 0x1a0(%rsp)
movq %rax, 0x1d0(%rsp)
movaps %xmm0, 0x1c0(%rsp)
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
xorl %esi, %esi
movl $0x2, %edx
callq *0x28(%rax)
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x8(%rsp)
movl 0x19c(%rsp), %r13d
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
callq *0x28(%rax)
sarq $0x7, %rbp
addq $0x3e8, %rbp # imm = 0x3E8
movq %rbp, 0x128(%rsp)
leaq 0x10(%rsp), %r12
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpq 0x8(%rsp), %rax
jge 0x124915
movq (%rbx), %rcx
movq 0xb0(%rcx), %rdx
leaq 0x18(%rcx), %rsi
addq $0xc0, %rcx
movl $0xa, %r9d
leaq 0xb8(%rsp), %rdi
movl $0x1, %r8d
callq 0xe2db6
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %r14
movq %r12, %r15
movq 0xc8(%rsp), %r12
testq %r12, %r12
jns 0x124225
movq %r12, %rdi
callq 0x1e6dc
subq %r12, %r14
movq %r14, 0x270(%rsp)
cmpl $0x7, 0xb8(%rsp)
movq (%rbx), %rax
jne 0x124325
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %rbp
movq %r15, %r12
movq (%rbx), %rcx
movq 0xb0(%rcx), %rdx
leaq 0x18(%rcx), %rsi
addq $0xc0, %rcx
movl $0xa, %r9d
leaq 0x130(%rsp), %rdi
movl $0x1, %r8d
callq 0xe2db6
cmpl $0x7, 0x130(%rsp)
jne 0x1247f9
movq (%rbx), %rcx
movq 0xb0(%rcx), %rdx
leaq 0x18(%rcx), %rsi
addq $0xc0, %rcx
movl $0xa, %r9d
movq %r12, %rdi
movl $0x1, %r8d
callq 0xe2db6
leaq 0xa0(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x5ac02(%rip), %rsi # 0x17eeda
leaq 0x5abfe(%rip), %rdx # 0x17eedd
callq 0x1ef84
cmpl $0xd, 0x10(%rsp)
jne 0x12439d
movq 0x20(%rsp), %rdx
cmpq 0x98(%rsp), %rdx
jne 0x12439d
testq %rdx, %rdx
je 0x12467b
movq 0x90(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x19790
testl %eax, %eax
sete %r14b
jmp 0x1243a0
cmpq $0x0, 0x208(%rax)
movq %r15, %r12
jne 0x124560
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r12, %rdi
leaq 0x5a9d4(%rip), %rsi # 0x17ed1e
leaq 0x5a9d4(%rip), %rdx # 0x17ed25
callq 0x1ef84
cmpl $0xd, 0xb8(%rsp)
jne 0x1244fe
movq 0xc8(%rsp), %rdx
cmpq 0x18(%rsp), %rdx
jne 0x1244fe
testq %rdx, %rdx
je 0x12468b
movq 0x10(%rsp), %rsi
movq 0xc0(%rsp), %rdi
callq 0x19790
testl %eax, %eax
sete %bpl
jmp 0x124500
xorl %r14d, %r14d
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x1243c5
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x1243e1
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x1243fd
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x124419
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %r14b, %r14b
je 0x1247f9
movq 0xc0(%rsp), %rdi
callq 0x13dcb6
movl %eax, 0x124(%rsp)
movq 0x138(%rsp), %rdi
callq 0x13dcb6
movl %eax, 0x1fc(%rsp)
movl 0x124(%rsp), %eax
movq (%rbx), %rcx
cmpl 0x168(%rcx), %eax
jle 0x124627
leaq 0xa0(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x56867(%rip), %rdx # 0x17ace6
movq %rdx, %rsi
callq 0x1ef84
movl 0x124(%rsp), %r14d
movl %r14d, %r13d
negl %r13d
cmovsl %r14d, %r13d
movl $0x1, %r12d
cmpl $0xa, %r13d
leaq 0x240(%rsp), %rdx
jb 0x12469c
movl $0x4, %r12d
movl %r13d, %eax
movl $0xd1b71759, %esi # imm = 0xD1B71759
cmpl $0x63, %eax
jbe 0x124693
cmpl $0x3e7, %eax # imm = 0x3E7
jbe 0x124699
cmpl $0x2710, %eax # imm = 0x2710
jb 0x12469c
movl %eax, %ecx
imulq %rsi, %rcx
shrq $0x2d, %rcx
addl $0x4, %r12d
cmpl $0x1869f, %eax # imm = 0x1869F
movl %ecx, %eax
ja 0x1244bf
addl $-0x3, %r12d
jmp 0x12469c
xorl %ebp, %ebp
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x12451c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
je 0x124560
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x10(%rsp)
movq 0x1a8(%rsp), %rsi
cmpq 0x1b0(%rsp), %rsi
je 0x124666
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x1a8(%rsp)
jmp 0x12487d
testb %r13b, %r13b
jne 0x12487d
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r12, %rdi
leaq 0x59efc(%rip), %rsi # 0x17e479
leaq 0x59efe(%rip), %rdx # 0x17e482
callq 0x1ef84
cmpl $0xd, 0xb8(%rsp)
jne 0x1245c5
movq 0xc8(%rsp), %rdx
cmpq 0x18(%rsp), %rdx
jne 0x1245c5
testq %rdx, %rdx
je 0x124683
movq 0x10(%rsp), %rsi
movq 0xc0(%rsp), %rdi
callq 0x19790
testl %eax, %eax
sete %bpl
jmp 0x1245c7
xorl %ebp, %ebp
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x1245e3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
je 0x12487d
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x10(%rsp)
movq 0x1c8(%rsp), %rsi
cmpq 0x1d0(%rsp), %rsi
je 0x124651
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x1c8(%rsp)
jmp 0x12487d
leaq 0x200(%rsp), %rdi
leaq 0x124(%rsp), %rsi
leaq 0x1fc(%rsp), %rdx
leaq 0x270(%rsp), %rcx
callq 0x130c1c
jmp 0x1247f9
leaq 0x1c0(%rsp), %rdi
movq %r12, %rdx
callq 0xf7140
jmp 0x12487d
leaq 0x1a0(%rsp), %rdi
movq %r12, %rdx
callq 0xf7140
jmp 0x12487d
movb $0x1, %r14b
jmp 0x1243a0
movb $0x1, %bpl
jmp 0x1245c7
movb $0x1, %bpl
jmp 0x124500
addl $-0x2, %r12d
jmp 0x12469c
decl %r12d
shrl $0x1f, %r14d
leal (%r12,%r14), %esi
leaq 0x250(%rsp), %rax
movq %rax, 0x240(%rsp)
movq %rdx, %rdi
movl $0x2d, %edx
callq 0x19670
addq 0x240(%rsp), %r14
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x202ae
movl $0x29, %r8d
leaq 0x240(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
leaq 0x59e6e(%rip), %rcx # 0x17e55e
callq 0x191c0
leaq 0x1e8(%rsp), %rsi
movq %rsi, 0x1d8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
movl 0x19c(%rsp), %r13d
movq %r15, %r12
je 0x124734
movq %rdx, 0x1d8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x1e8(%rsp)
jmp 0x12473a
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x1e0(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r12, %rdi
movq %rbx, %rsi
leaq 0x90(%rsp), %rdx
movq $-0x1, %rcx
leaq 0x1d8(%rsp), %r8
callq 0x3bf60
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3a51e
movq %r12, %rdi
callq 0x201d4
movq 0x1d8(%rsp), %rdi
leaq 0x1e8(%rsp), %rax
cmpq %rax, %rdi
je 0x1247af
movq 0x1e8(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x240(%rsp), %rdi
leaq 0x250(%rsp), %rax
cmpq %rax, %rdi
je 0x1247d4
movq 0x250(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x1247f9
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x190e0
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
movq %rbp, %rsi
xorl %edx, %edx
callq *0x28(%rax)
movq 0x178(%rsp), %rdi
leaq 0x188(%rsp), %rax
cmpq %rax, %rdi
je 0x124833
movq 0x188(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x158(%rsp), %rdi
leaq 0x168(%rsp), %rax
cmpq %rax, %rdi
je 0x124858
movq 0x168(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x138(%rsp), %rdi
leaq 0x148(%rsp), %rax
cmpq %rax, %rdi
je 0x12487d
movq 0x148(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
movq 0x128(%rsp), %rsi
callq 0x125f50
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x100(%rsp), %rdi
leaq 0x110(%rsp), %rax
cmpq %rax, %rdi
je 0x1248c2
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0xe0(%rsp), %rdi
leaq 0xf0(%rsp), %rax
cmpq %rax, %rdi
je 0x1248e7
movq 0xf0(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x1241b1
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x1241b1
testb %r13b, %r13b
jne 0x124c9b
movq 0x1c8(%rsp), %rax
cmpq %rax, 0x1c0(%rsp)
je 0x124c9b
movq 0x208(%rsp), %rcx
cmpq %rcx, 0x200(%rsp)
je 0x124c9b
movq -0x8(%rax), %rsi
cmpq -0x10(%rcx), %rsi
jle 0x124c9b
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
xorl %edx, %edx
callq *0x28(%rax)
movq (%rbx), %rcx
movq 0xb0(%rcx), %rdx
leaq 0x18(%rcx), %rsi
addq $0xc0, %rcx
leaq 0x10(%rsp), %rdi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0xe2db6
movq 0x18(%rsp), %rdi
callq 0x13daed
movq %rax, %r14
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x1249bb
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x1249d7
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1249f3
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x190e0
testq %r14, %r14
je 0x124c9b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x123332
leaq 0x130(%rsp), %rdi
movq %rbx, %rsi
callq 0x3d0d4
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x427ae(%rip), %rsi # 0x1671d9
leaq 0x427ad(%rip), %rdx # 0x1671df
callq 0x1ef84
leaq 0xb8(%rsp), %rdi
leaq 0x130(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0xfbc92
leaq 0xb8(%rsp), %rdi
callq 0xc25ae
movl %eax, %ebp
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0x124a72
callq 0x1ef14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x124a8e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x138(%rsp), %rdi
testq %rdi, %rdi
je 0x124aa0
callq 0x1ef14
testb %bpl, %bpl
je 0x124c9b
leaq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x56223(%rip), %rdx # 0x17ace6
movq %rdx, %rsi
callq 0x1ef84
leaq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
movq %rax, (%rdi)
leaq 0x59aa3(%rip), %rsi # 0x17e588
leaq 0x59ad1(%rip), %rdx # 0x17e5bd
callq 0x1ef84
leaq 0x10(%rsp), %rdi
leaq 0xb8(%rsp), %rdx
leaq 0x130(%rsp), %r8
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x3bf60
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3a51e
leaq 0x10(%rsp), %rdi
callq 0x201d4
movq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
cmpq %rax, %rdi
je 0x124b51
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x124b76
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
callq 0x10490a
movq (%rbx), %rax
movb $0x1, 0x2d4(%rax)
movb $0x0, 0x2d0(%rax)
jmp 0x12566f
movl $0x80, %edi
callq 0x193f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x40a68
leaq 0xc524d(%rip), %rsi # 0x1e9e00
leaq -0x1049e6(%rip), %rdx # 0x201d4
movq %rbx, %rdi
callq 0x196e0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x201d4
jmp 0x124bd4
movq %rax, %r14
movq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
cmpq %rax, %rdi
je 0x124bfe
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x124bfe
movq %rax, %r14
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x124c8e
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x124c8e
jmp 0x124c8b
movq %rax, %r14
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0x124c41
callq 0x1ef14
jmp 0x124c41
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x124c62
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x124c62
movq %rax, %r14
movq 0x138(%rsp), %rdi
testq %rdi, %rdi
je 0x124c8e
callq 0x1ef14
jmp 0x124c8e
jmp 0x124c8b
jmp 0x124c8b
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x374fc
jmp 0x124c8e
jmp 0x124c8b
movq %rax, %r14
movq %r14, %rdi
callq 0x19060
callq 0x19890
movq 0x200(%rsp), %r14
movq 0x208(%rsp), %r15
cmpq %r14, %r15
je 0x124cdf
movq -0x10(%r15), %rcx
movl -0x8(%r15), %r8d
movl -0x4(%r15), %esi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x12606a
addq $-0x10, %r15
movq %rbx, %rdi
movq 0x128(%rsp), %rsi
callq 0x125f50
jmp 0x124cab
movl $0x178, %edi # imm = 0x178
addq (%rbx), %rdi
callq 0xf62e2
movq 0x1a8(%rsp), %r14
cmpq 0x1a0(%rsp), %r14
je 0x124ed3
leaq 0x90(%rsp), %r15
leaq 0x10(%rsp), %rbp
leaq 0x130(%rsp), %r12
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
movq -0x8(%r14), %rsi
movq (%rdi), %rax
xorl %edx, %edx
callq *0x28(%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x12648c
movq %r15, %rdi
callq 0xc25ae
addq $-0x8, %r14
testb %al, %al
je 0x124e69
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rbp, %rdi
leaq 0x3ad9b(%rip), %rsi # 0x15fafb
leaq 0x3ad99(%rip), %rdx # 0x15fb00
callq 0x1ef84
movq %r15, %rdi
movq %rbp, %rsi
callq 0xfbb62
movl %eax, %r13d
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x124d96
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %r13b, %r13b
jne 0x124e9b
leaq 0xc8(%rsp), %rax
movq %rax, 0xb8(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x59f60(%rip), %rsi # 0x17ed1e
leaq 0x59f60(%rip), %rdx # 0x17ed25
callq 0x1ef84
movq (%r14), %r13
leaq 0x140(%rsp), %rax
movq %rax, 0x130(%rsp)
movq %r12, %rdi
leaq 0x597d7(%rip), %rsi # 0x17e5be
leaq 0x597f4(%rip), %rdx # 0x17e5e2
callq 0x1ef84
movq %rbp, %rdi
movq %rbx, %rsi
leaq 0xb8(%rsp), %rdx
movq %r13, %rcx
movq %r12, %r8
callq 0x3bf60
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a51e
movq %rbp, %rdi
callq 0x201d4
movq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
cmpq %rax, %rdi
je 0x124e44
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x124e69
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
movq 0x128(%rsp), %rsi
callq 0x125f50
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x124e8b
callq 0x1ef14
cmpq 0x1a0(%rsp), %r14
jne 0x124d17
jmp 0x124ed3
movq (%rbx), %rdi
movq 0x90(%rsp), %rax
movq %rax, 0x208(%rdi)
addq $0x210, %rdi # imm = 0x210
leaq 0x98(%rsp), %rsi
callq 0x276aa
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x124ed3
callq 0x1ef14
movq (%rbx), %r13
cmpq $0x0, 0x208(%r13)
je 0x125188
movq (%rbx), %r15
cmpq $0x0, 0x208(%r15)
je 0x124f88
cmpb $0x0, 0x2d4(%r15)
jne 0x125601
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x3abe4(%rip), %rsi # 0x15fafb
leaq 0x3abe2(%rip), %rdx # 0x15fb00
callq 0x1ef84
addq $0x208, %r15 # imm = 0x208
leaq 0xb8(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r15, %rsi
callq 0xfbc92
leaq 0xb8(%rsp), %rdi
callq 0xc25ae
movl %eax, %ebp
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0x124f60
callq 0x1ef14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x124f7c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
movq (%rbx), %r15
testb %bpl, %bpl
jne 0x125601
xorps %xmm0, %xmm0
movaps %xmm0, 0x90(%rsp)
movq 0x1c0(%r15), %r12
addq $0x1b0, %r15 # imm = 0x1B0
cmpq %r15, %r12
je 0x1255ec
leaq 0x55d35(%rip), %rbp # 0x17ace6
leaq 0xb8(%rsp), %r14
movq 0x28(%r12), %rax
movq %rax, 0x130(%rsp)
movq 0x30(%r12), %rax
movq %rax, 0x138(%rsp)
testq %rax, %rax
je 0x124fed
movq 0xcafa1(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0x124fe9
incl 0x8(%rax)
jmp 0x124fed
lock
incl 0x8(%rax)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x3ab24(%rip), %rsi # 0x15fb27
leaq 0x3ab25(%rip), %rdx # 0x15fb2f
callq 0x1ef84
leaq 0xc8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq %r14, %rdi
movq %rbp, %rsi
movq %rbp, %rdx
callq 0x1ef84
leaq 0x130(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0xc2824
movl %eax, %r13d
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x12506a
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x125086
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x138(%rsp), %rdi
testq %rdi, %rdi
je 0x125098
callq 0x1ef14
testb %r13b, %r13b
je 0x1250e3
movq 0x28(%r12), %rcx
movq 0x30(%r12), %rax
testq %rax, %rax
je 0x1250c1
movq 0xcaecd(%rip), %rdx # 0x1eff80
cmpb $0x0, (%rdx)
je 0x1250bd
incl 0x8(%rax)
jmp 0x1250c1
lock
incl 0x8(%rax)
movq %rcx, 0x90(%rsp)
movq 0x98(%rsp), %rdi
movq %rax, 0x98(%rsp)
testq %rdi, %rdi
je 0x1250e3
callq 0x1ef14
movq %r12, %rdi
callq 0x19b30
movq %rax, %r12
cmpq %r15, %rax
jne 0x124fb9
jmp 0x125463
movq %rdx, 0x8(%rsp)
movq %rax, %r13
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x125133
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125133
movq %rdx, 0x8(%rsp)
movq %rax, %r13
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x125159
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125159
movq %rdx, 0x8(%rsp)
movq %rax, %r13
movq 0x138(%rsp), %rdi
testq %rdi, %rdi
je 0x12516b
callq 0x1ef14
cmpl $0x2, 0x8(%rsp)
jne 0x125ac5
movq %r13, %rdi
callq 0x19060
callq 0x19890
jmp 0x1250e3
movq 0x150(%r13), %r12
addq $0x140, %r13 # imm = 0x140
cmpq %r13, %r12
je 0x124ee4
movq $0x0, 0x8(%rsp)
leaq 0xb8(%rsp), %rbp
movq 0x38(%r12), %rax
movq %rax, 0x140(%rsp)
movups 0x28(%r12), %xmm0
movaps %xmm0, 0x130(%rsp)
leaq 0x130(%rsp), %rdi
callq 0xf82c6
cmpl $0x1, %eax
jne 0x1253d7
movq 0x20(%r12), %rdx
leaq 0x90(%rsp), %rdi
movq %rbx, %rsi
callq 0x1268a8
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x55b49(%rip), %rsi # 0x17ad55
leaq 0x55b47(%rip), %rdx # 0x17ad5a
callq 0x1ef84
leaq 0xc8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq %rbp, %rdi
leaq 0x55ab4(%rip), %rdx # 0x17ace6
movq %rdx, %rsi
callq 0x1ef84
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbp, %rdx
callq 0xc29d8
movl %eax, %r14d
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x125277
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x125293
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %r14b, %r14b
je 0x1253c5
leaq 0x130(%rsp), %rdi
callq 0xf82ca
movq %rax, %r14
leaq 0x1d8(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xff4ee
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
leaq 0x3ccef(%rip), %rsi # 0x161fc9
leaq 0x3cced(%rip), %rdx # 0x161fce
callq 0x1ef84
movq %rbp, %rdi
leaq 0x1d8(%rsp), %rsi
movq %r15, %rdx
callq 0xfbc92
movq %rbp, %rdi
callq 0xc2e88
movl %eax, %r15d
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0x125316
callq 0x1ef14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x125332
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x1e0(%rsp), %rdi
testq %rdi, %rdi
je 0x125344
callq 0x1ef14
testl %r15d, %r15d
setne %al
cmpq 0x8(%rsp), %r14
setg %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1253b5
leaq 0x260(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xff4ee
movq (%rbx), %rdi
cmpq $0x0, 0x208(%rdi)
jne 0x12539e
movq 0x260(%rsp), %rax
movq %rax, 0x208(%rdi)
addq $0x210, %rdi # imm = 0x210
leaq 0x268(%rsp), %rsi
callq 0x276aa
movq 0x268(%rsp), %rdi
testq %rdi, %rdi
je 0x1253b0
callq 0x1ef14
movq %r14, 0x8(%rsp)
movq %rbx, %rdi
movq 0x128(%rsp), %rsi
callq 0x125f50
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x1253d7
callq 0x1ef14
movq %r12, %rdi
callq 0x19b30
movq %rax, %r12
cmpq %r13, %rax
jne 0x1251b0
jmp 0x1256f5
movq %rdx, %r14
movq %rax, %r15
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x125423
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125423
movq %rdx, %r14
movq %rax, %r15
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x125447
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125447
movq %rdx, %r14
movq %rax, %r15
cmpl $0x2, %r14d
jne 0x125e16
movq %r15, %rdi
callq 0x19060
callq 0x19890
jmp 0x1253c5
cmpq $0x0, 0x90(%rsp)
je 0x1255ec
movq (%rbx), %r14
cmpq $0x0, 0x208(%r14)
jne 0x125594
leaq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x55849(%rip), %rdx # 0x17ace6
movq %rdx, %rsi
callq 0x1ef84
leaq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
movq %rax, (%rdi)
leaq 0x59167(%rip), %rsi # 0x17e626
leaq 0x5919f(%rip), %rdx # 0x17e665
callq 0x1ef84
leaq 0x10(%rsp), %rdi
leaq 0xb8(%rsp), %rdx
leaq 0x130(%rsp), %r8
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x3bf60
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3a51e
leaq 0x10(%rsp), %rdi
callq 0x201d4
movq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
cmpq %rax, %rdi
je 0x12552b
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x125550
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x10(%rsp), %rdi
callq 0xc83f6
movq (%rbx), %rax
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x210(%rax), %rdi
movups %xmm0, 0x208(%rax)
testq %rdi, %rdi
je 0x125591
callq 0x1ef14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x125591
callq 0x1ef14
movq (%rbx), %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x3a553(%rip), %rsi # 0x15fafb
leaq 0x3a551(%rip), %rdx # 0x15fb00
callq 0x1ef84
addq $0x208, %r14 # imm = 0x208
leaq 0x10(%rsp), %rsi
leaq 0x90(%rsp), %rdx
movq %r14, %rdi
callq 0xfc1ac
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x1255ec
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x1255fe
callq 0x1ef14
movq (%rbx), %r15
cmpq $0x0, 0x208(%r15)
je 0x125710
cmpq $0x0, 0x160(%r15)
je 0x12579e
movq %rbx, %rdi
movq 0x128(%rsp), %rsi
callq 0x125f50
movq (%rbx), %rax
cmpb $0x0, 0x2d4(%rax)
jne 0x12566f
movb $0x1, 0x2d4(%rax)
movq %rbx, %rdi
callq 0x1398a0
movq %rbx, %rdi
movq 0x128(%rsp), %rsi
callq 0x125f50
movq (%rbx), %rax
movq 0x218(%rax), %rcx
cmpq 0x220(%rax), %rcx
je 0x12582c
movq 0x1c0(%rsp), %rdi
testq %rdi, %rdi
je 0x12568c
movq 0x1d0(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movq 0x1a0(%rsp), %rdi
testq %rdi, %rdi
je 0x1256a9
movq 0x1b0(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movq 0x200(%rsp), %rdi
testq %rdi, %rdi
je 0x1256c6
movq 0x210(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movq 0x220(%rsp), %rdi
testq %rdi, %rdi
je 0x1256e3
movq 0x230(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
addq $0x278, %rsp # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
jle 0x124ee4
movq %rbx, %rdi
callq 0x123332
jmp 0x124ee4
movl $0x80, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x555b5(%rip), %rdx # 0x17ace6
movq %rdx, %rsi
callq 0x1ef84
leaq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x58ed3(%rip), %rsi # 0x17e626
leaq 0x58f0b(%rip), %rdx # 0x17e665
callq 0x1ef84
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
leaq 0xb8(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x3bf60
xorl %ebp, %ebp
leaq 0xc4676(%rip), %rsi # 0x1e9e00
leaq -0x1055bd(%rip), %rdx # 0x201d4
movq %r14, %rdi
callq 0x196e0
jmp 0x1258bc
movl $0x80, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x55527(%rip), %rdx # 0x17ace6
movq %rdx, %rsi
callq 0x1ef84
leaq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x58e85(%rip), %rsi # 0x17e666
leaq 0x58eb2(%rip), %rdx # 0x17e69a
callq 0x1ef84
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
leaq 0xb8(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x3bf60
xorl %ebp, %ebp
leaq 0xc45e8(%rip), %rsi # 0x1e9e00
leaq -0x10564b(%rip), %rdx # 0x201d4
movq %r14, %rdi
callq 0x196e0
jmp 0x1258bc
movb $0x0, 0x2d4(%rax)
movl $0x80, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x55492(%rip), %rdx # 0x17ace6
movq %rdx, %rsi
callq 0x1ef84
leaq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x58e25(%rip), %rsi # 0x17e69b
leaq 0x58e54(%rip), %rdx # 0x17e6d1
callq 0x1ef84
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
leaq 0xb8(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x3bf60
xorl %ebp, %ebp
leaq 0xc4553(%rip), %rsi # 0x1e9e00
leaq -0x1056e0(%rip), %rdx # 0x201d4
movq %r14, %rdi
callq 0x196e0
jmp 0x125e13
jmp 0x125ac2
jmp 0x125ac2
movq %rax, %r13
leaq 0x10(%rsp), %rdi
callq 0x201d4
jmp 0x1258dd
movq %rax, %r13
movq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
cmpq %rax, %rdi
je 0x125907
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125907
movq %rax, %r13
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x125ac5
movq 0xc8(%rsp), %rsi
jmp 0x125ab8
jmp 0x125ac2
jmp 0x125ae8
jmp 0x125b36
cmpl $0x2, %edx
jne 0x125e33
movq %rax, %rdi
callq 0x19060
leaq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x5537f(%rip), %rdx # 0x17ace6
movq %rdx, %rsi
callq 0x1ef84
leaq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
movq %rax, (%rdi)
leaq 0x58c5a(%rip), %rsi # 0x17e5e3
leaq 0x58c95(%rip), %rdx # 0x17e625
callq 0x1ef84
leaq 0x10(%rsp), %rdi
leaq 0xb8(%rsp), %rdx
leaq 0x130(%rsp), %r8
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x3bf60
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3a51e
leaq 0x10(%rsp), %rdi
callq 0x201d4
movq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
cmpq %rax, %rdi
je 0x1259f5
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x125a1a
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
callq 0x19890
jmp 0x124ee4
jmp 0x125e33
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x201d4
jmp 0x125a3b
movq %rax, %r15
movq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
cmpq %rax, %rdi
je 0x125a65
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125a65
movq %rax, %r15
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x125a8f
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125a8f
movq %rax, %r15
callq 0x19890
jmp 0x125e48
movq %rax, %rdi
callq 0x1d236
movq %rax, %r13
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x125ac5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125ac5
movq %rax, %r13
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x125ad7
callq 0x1ef14
movq %r13, %r15
jmp 0x125e48
jmp 0x125b9d
jmp 0x125ae8
jmp 0x125b36
movq %rax, %r15
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x125b10
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x125b2c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x125ba0
jmp 0x125e48
movq %rax, %r15
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x125ba0
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125ba0
movq %rax, %r15
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0x125b71
callq 0x1ef14
jmp 0x125b71
movq %rax, %r15
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x125e48
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125e48
jmp 0x125e33
jmp 0x125b9d
movq %rax, %r15
movq %r14, %rdi
callq 0x19a40
jmp 0x125e48
movq %rax, %r15
movq %rbx, %rdi
callq 0x19a40
jmp 0x125ebc
jmp 0x125e33
jmp 0x125bca
jmp 0x125bd9
jmp 0x125c03
jmp 0x125c2f
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x201d4
jmp 0x125bdc
movq %rax, %r15
movq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
cmpq %rax, %rdi
je 0x125c06
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125c06
movq %rax, %r15
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x125ebc
movq 0xc8(%rsp), %rsi
incq %rsi
jmp 0x125eb7
movq %rax, %r15
jmp 0x125ebc
movq %rax, %r15
jmp 0x125c7c
jmp 0x125e13
jmp 0x125e13
movq %rax, %r15
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0x125c60
callq 0x1ef14
jmp 0x125c60
movq %rax, %r15
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x125c7c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x1e0(%rsp), %rdi
testq %rdi, %rdi
je 0x125e16
callq 0x1ef14
jmp 0x125e16
movq %rax, %r15
jmp 0x125cb8
movq %rax, %r15
jmp 0x125d02
jmp 0x125dfd
movq %rax, %r15
jmp 0x125cdd
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x201d4
movq 0x1d8(%rsp), %rdi
leaq 0x1e8(%rsp), %rax
cmpq %rax, %rdi
je 0x125cdd
movq 0x1e8(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x240(%rsp), %rdi
leaq 0x250(%rsp), %rax
cmpq %rax, %rdi
je 0x125d02
movq 0x250(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x125e00
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125e00
jmp 0x125e33
jmp 0x125e33
jmp 0x125e13
jmp 0x125e33
jmp 0x125dfd
jmp 0x125e38
jmp 0x125e38
jmp 0x125e38
jmp 0x125dfd
jmp 0x125e38
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x201d4
jmp 0x125d74
movq %rax, %r15
movq 0x130(%rsp), %rdi
leaq 0x140(%rsp), %rax
cmpq %rax, %rdi
je 0x125d9e
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125d9e
movq %rax, %r15
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x125e16
movq 0xc8(%rsp), %rsi
jmp 0x125dd6
jmp 0x125e13
movq %rax, %r15
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x125e16
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x125e16
jmp 0x125e13
jmp 0x125e33
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x374fc
jmp 0x125e00
jmp 0x125dfd
jmp 0x125e38
jmp 0x125e33
jmp 0x125e33
jmp 0x125e38
movq %rax, %r15
leaq 0x130(%rsp), %rdi
callq 0x374fc
jmp 0x125e3b
jmp 0x125e38
jmp 0x125e2a
movq %rax, %r15
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x125e48
callq 0x1ef14
jmp 0x125e48
movq %rax, %r15
jmp 0x125e9f
jmp 0x125e33
jmp 0x125e33
movq %rax, %r15
jmp 0x125e48
movq %rax, %r15
leaq 0xb8(%rsp), %rdi
callq 0x374fc
movq 0x1c0(%rsp), %rdi
testq %rdi, %rdi
je 0x125e65
movq 0x1d0(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movq 0x1a0(%rsp), %rdi
testq %rdi, %rdi
je 0x125e82
movq 0x1b0(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movq 0x200(%rsp), %rdi
testq %rdi, %rdi
je 0x125e9f
movq 0x210(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movq 0x220(%rsp), %rdi
testq %rdi, %rdi
je 0x125ebc
movq 0x230(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movq %r15, %rdi
callq 0x19710
| /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
qpdf_oh_is_initialized | QPDF_BOOL
qpdf_oh_is_initialized(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_initialized");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return static_cast<bool>(o); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq 0x4e0(%rip), %rax # 0x14d10a
movq %rax, (%rdx)
leaq 0xd6be(%rip), %rax # 0x15a2f2
movq %rax, 0x18(%rdx)
leaq 0xd6b5(%rip), %rax # 0x15a2f4
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x81cf(%rip), %rax # 0x154e22
movq %rax, 0x18(%rcx)
leaq 0x81ce(%rip), %rax # 0x154e2c
movq %rax, 0x10(%rcx)
callq 0x14ccea
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14cc80
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14cc99
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x14cce2
jmp 0x14cce2
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14ccbf
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14ccd8
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x14cce2
movq %rax, %rdi
callq 0x1d236
| /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_array | QPDF_BOOL
qpdf_oh_is_array(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_array");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isArray(); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0x6e4(%rip), %rax # 0x14d10a
movq %rax, (%rdx)
leaq 0xcafa(%rip), %rax # 0x15a2f2
movq %rax, 0x18(%rdx)
leaq 0xcaf1(%rip), %rax # 0x15a2f4
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x775d(%rip), %rax # 0x154f74
movq %rax, 0x18(%rcx)
leaq 0x7760(%rip), %rax # 0x154f82
movq %rax, 0x10(%rcx)
callq 0x14ccea
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14d844
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14d85d
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x14d8a6
jmp 0x14d8a6
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14d883
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x14d89c
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x14d8a6
movq %rax, %rdi
callq 0x1d236
| /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_array_n_items | int
qpdf_oh_get_array_n_items(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<int>(qpdf, oh, return_T<int>(0), [](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_array_n_items");
return o.getArrayNItems();
});
} | pushq %rbx
subq $0x50, %rsp
leaq 0xc(%rsp), %rax
movl $0x0, (%rax)
leaq 0x30(%rsp), %rdx
movq $0x0, 0x8(%rdx)
movq %rax, (%rdx)
leaq 0x5724(%rip), %rax # 0x15644e
movq %rax, 0x18(%rdx)
leaq 0x571f(%rip), %rax # 0x156454
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
leaq 0x65e9(%rip), %rax # 0x157334
movq %rax, 0x18(%rcx)
leaq 0x65e6(%rip), %rax # 0x15733c
movq %rax, 0x10(%rcx)
callq 0x14ccea
movl %eax, %ebx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x150d7a
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x150d93
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x150dde
jmp 0x150dde
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x150dbb
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x150dd4
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19710
jmp 0x150dde
movq %rax, %rdi
callq 0x1d236
| /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_data::_qpdf_data() | _qpdf_data() = default; | leaq 0x40(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x40(%rdi)
xorl %eax, %eax
movq %rax, 0x50(%rdi)
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0xc0(%rdi), %rcx
movl %eax, 0xc0(%rdi)
movq %rax, 0xc8(%rdi)
movups %xmm0, 0x78(%rdi)
movups %xmm0, 0x88(%rdi)
movb %al, 0x98(%rdi)
movups %xmm0, 0xa0(%rdi)
movw $0x0, 0xb0(%rdi)
movq %rcx, 0xd0(%rdi)
movq %rcx, 0xd8(%rdi)
movq %rax, 0xe0(%rdi)
movl %eax, 0xe8(%rdi)
leaq 0xf8(%rdi), %rcx
movl %eax, 0xf8(%rdi)
movq %rax, 0x100(%rdi)
movq %rcx, 0x108(%rdi)
movq %rcx, 0x110(%rdi)
leaq 0x138(%rdi), %rcx
movups %xmm0, 0x118(%rdi)
movq %rcx, 0x128(%rdi)
movq %rax, 0x130(%rdi)
movb %al, 0x138(%rdi)
retq
| /jberkenbilt[P]qpdf/libqpdf/qpdf/qpdf-c_impl.hh |
wrap_qpdfjob(_qpdfjob_handle*, std::function<int (_qpdfjob_handle*)>) | static int
wrap_qpdfjob(qpdfjob_handle j, std::function<int(qpdfjob_handle j)> fn)
{
try {
return fn(j);
} catch (std::exception& e) {
*j->j.getLogger()->getError() << j->j.getMessagePrefix() << ": " << e.what() << "\n";
}
return QPDFJob::EXIT_ERROR;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
movq %rdi, 0x28(%rsp)
cmpq $0x0, 0x10(%rsi)
je 0x15aed4
movq %rsi, %rax
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq *0x18(%rax)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x19ce0
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x15affa
movq %rbx, %rdi
callq 0x19060
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6f6dc
movq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
callq 0xb987a
movq 0x18(%rsp), %r15
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x6f6b8
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x30d78
leaq 0x22173(%rip), %rsi # 0x17d0a7
movq %rax, %rdi
callq 0x30d4c
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x30d4c
leaq 0x1fd8b(%rip), %rsi # 0x17ace5
movq %rax, %rdi
callq 0x30d4c
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15af7d
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x15af8c
callq 0x1ef14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x15af9b
callq 0x1ef14
callq 0x19890
movl $0x2, %eax
jmp 0x15aeca
movq %rax, %rbx
jmp 0x15afd7
movq %rax, %rbx
jmp 0x15afe6
movq %rax, %rbx
jmp 0x15aff5
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15afd7
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x15afe6
callq 0x1ef14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x15aff5
callq 0x1ef14
callq 0x19890
movq %rbx, %rdi
callq 0x19710
movq %rax, %rdi
callq 0x1d236
| /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
run_with_handle(std::function<int (_qpdfjob_handle*)>) | static int
run_with_handle(std::function<int(qpdfjob_handle)> fn)
{
auto j = qpdfjob_init();
int status = fn(j);
if (status == 0) {
status = qpdfjob_run(j);
}
qpdfjob_cleanup(&j);
return status;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
callq 0x15acd4
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%r14)
je 0x15b4d9
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *0x18(%r14)
movl %eax, %ebp
testl %eax, %eax
jne 0x15b4c6
movq %rbx, %rdi
callq 0x15b11d
movl %eax, %ebp
movq %rsp, %rdi
callq 0x15ad10
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x19ce0
| /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
set_log_dest(QPDFLogger*, std::function<void (std::shared_ptr<Pipeline>)>, qpdf_log_dest_e, char const*, int (*)(char const*, unsigned long, void*), void*) | static void
set_log_dest(
QPDFLogger* l,
std::function<void(std::shared_ptr<Pipeline>)> method,
qpdf_log_dest_e dest,
char const* identifier,
qpdf_log_fn_t fn,
void* udata)
{
switch (dest) {
case qpdf_log_dest_default:
method(nullptr);
break;
case qpdf_log_dest_stdout:
method(l->standardOutput());
break;
case qpdf_log_dest_stderr:
method(l->standardError());
break;
case qpdf_log_dest_discard:
method(l->discard());
break;
case qpdf_log_dest_custom:
method(std::make_shared<Pl_Function>(identifier, nullptr, fn, udata));
break;
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rcx, 0x80(%rsp)
movq %r8, 0x78(%rsp)
movq %r9, 0x70(%rsp)
cmpl $0x4, %edx
ja 0x15bf61
movq %rsi, %rbx
movq %rdi, %rsi
movl %edx, %eax
leaq 0x26a4b(%rip), %rcx # 0x182890
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
cmpq $0x0, 0x10(%rbx)
je 0x15bf7d
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq *0x18(%rbx)
movq 0x38(%rsp), %rdi
jmp 0x15bf57
xorl %r15d, %r15d
leaq 0x88(%rsp), %r8
movq %r15, (%r8)
leaq 0x18(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x70(%rsp), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
leaq 0x80(%rsp), %rcx
leaq 0x78(%rsp), %r9
movq %r14, %rsi
callq 0x15c0f4
movaps (%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
cmpq %r15, 0x10(%rbx)
je 0x15bf6e
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq *0x18(%rbx)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x15bee9
callq 0x1ef14
movq 0x18(%rsp), %rdi
jmp 0x15bf57
leaq 0x50(%rsp), %rdi
callq 0xb9a4e
cmpq $0x0, 0x10(%rbx)
je 0x15bf73
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq *0x18(%rbx)
movq 0x58(%rsp), %rdi
jmp 0x15bf57
leaq 0x40(%rsp), %rdi
callq 0xb9a7e
cmpq $0x0, 0x10(%rbx)
je 0x15bf78
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq *0x18(%rbx)
movq 0x48(%rsp), %rdi
jmp 0x15bf57
leaq 0x60(%rsp), %rdi
callq 0xb9a1e
cmpq $0x0, 0x10(%rbx)
je 0x15bf82
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq *0x18(%rbx)
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x15bf61
callq 0x1ef14
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x19ce0
callq 0x19ce0
callq 0x19ce0
callq 0x19ce0
callq 0x19ce0
movq %rax, %rbx
movq 0x68(%rsp), %rdi
jmp 0x15bfc6
movq %rax, %rbx
movq 0x38(%rsp), %rdi
jmp 0x15bfc6
movq %rax, %rbx
movq 0x48(%rsp), %rdi
jmp 0x15bfc6
movq %rax, %rbx
movq 0x58(%rsp), %rdi
jmp 0x15bfc6
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x15bfc1
callq 0x1ef14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x15bfd0
callq 0x1ef14
movq %rbx, %rdi
callq 0x19710
| /jberkenbilt[P]qpdf/libqpdf/qpdflogger-c.cc |
QPDFCrypto_openssl::rijndael_init(bool, unsigned char const*, unsigned long, bool, unsigned char*) | void
QPDFCrypto_openssl::rijndael_init(
bool encrypt,
unsigned char const* key_data,
size_t key_len,
bool cbc_mode,
unsigned char* cbc_block)
{
const EVP_CIPHER* cipher = nullptr;
switch (key_len) {
case 32:
cipher = cbc_mode ? EVP_aes_256_cbc() : EVP_aes_256_ecb();
break;
case 24:
cipher = cbc_mode ? EVP_aes_192_cbc() : EVP_aes_192_ecb();
break;
default:
cipher = cbc_mode ? EVP_aes_128_cbc() : EVP_aes_128_ecb();
break;
}
check_openssl(EVP_CIPHER_CTX_reset(cipher_ctx));
check_openssl(
// line-break
EVP_CipherInit_ex(cipher_ctx, cipher, nullptr, key_data, cbc_block, encrypt));
check_openssl(EVP_CIPHER_CTX_set_padding(cipher_ctx, 0));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x18, %rcx
je 0x15c9e1
cmpq $0x20, %rcx
jne 0x15c9ed
testb %r8b, %r8b
je 0x15c9f9
callq 0x196f0
jmp 0x15ca0c
testb %r8b, %r8b
je 0x15ca00
callq 0x193c0
jmp 0x15ca0c
testb %r8b, %r8b
je 0x15ca07
callq 0x19590
jmp 0x15ca0c
callq 0x19cf0
jmp 0x15ca0c
callq 0x19320
jmp 0x15ca0c
callq 0x192e0
movq %rax, %r12
movq 0x10(%rbx), %rdi
callq 0x19dd0
movl %eax, %edi
callq 0x15c356
movq 0x10(%rbx), %rdi
movzbl %bpl, %r9d
movq %r12, %rsi
xorl %edx, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x19ac0
movl %eax, %edi
callq 0x15c356
movq 0x10(%rbx), %rdi
xorl %esi, %esi
callq 0x194b0
movl %eax, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x15c356
| /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
AggressiveBotStrategy::AggressiveBotStrategy(AggressiveBotStrategy const&) | AggressiveBotStrategy::AggressiveBotStrategy(const AggressiveBotStrategy& toCopy) : PlayerStrategy(toCopy) {
this->exchangingCardType = toCopy.exchangingCardType;
this->armiesToPlace = toCopy.armiesToPlace;
this->player = toCopy.player;
this->from = toCopy.from;
this->to = toCopy.to;
this->strategyName = new std::string("AGGRESSIVE");
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8d8c
leaq 0x33615(%rip), %rax # 0x3c8c0
movq %rax, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movl $0x20, %edi
callq 0x6480
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x24eaa(%rip), %rsi # 0x2e19b
leaq 0x24ead(%rip), %rdx # 0x2e1a5
movq %r14, %rdi
callq 0xb834
movq %r14, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0x20, %esi
movq %r14, %rdi
callq 0x6490
jmp 0x931f
movq %rax, %r15
movq %rbx, %rdi
callq 0xb3d6
movq %r15, %rdi
callq 0x67f0
nop
| /WillTarte[P]COMP-345-RISK/src/PlayerStrategy.cpp |
BenevolentBotStrategy::BenevolentBotStrategy(Player const&) | BenevolentBotStrategy::BenevolentBotStrategy(const Player& player) {
this->armiesToPlace = new int(0);
this->player = new Player(player);
this->from = nullptr;
this->to = nullptr;
this->strategyName = new std::string("BENEVOLENT");
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8c3c
leaq 0x334cf(%rip), %rax # 0x3c910
movq %rax, (%rbx)
movl $0x4, %edi
callq 0x6480
movl $0x0, (%rax)
movq %rax, 0x8(%rbx)
movl $0x38, %edi
callq 0x6480
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xd60a
movq %r15, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movl $0x20, %edi
callq 0x6480
movq %rax, %r15
addq $0x10, %rax
movq %rax, (%r15)
leaq 0x24d10(%rip), %rsi # 0x2e1a6
leaq 0x24d13(%rip), %rdx # 0x2e1b0
movq %r15, %rdi
callq 0xb834
movq %r15, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x20, %esi
jmp 0x94c1
movq %rax, %r14
movl $0x38, %esi
movq %r15, %rdi
callq 0x6490
jmp 0x94ce
movq %rax, %r14
movq %rbx, %rdi
callq 0xb3d6
movq %r14, %rdi
callq 0x67f0
| /WillTarte[P]COMP-345-RISK/src/PlayerStrategy.cpp |
BenevolentBotStrategy::operator=(BenevolentBotStrategy const&) | BenevolentBotStrategy& BenevolentBotStrategy::operator=(const BenevolentBotStrategy& rhs) {
this->exchangingCardType = rhs.exchangingCardType;
this->armiesToPlace = rhs.armiesToPlace;
this->player = rhs.player;
this->from = rhs.from;
this->to = rhs.to;
this->strategyName = new std::string("BENEVOLENT");
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
movq 0x30(%rsi), %rax
movq %rax, 0x30(%rdi)
movl $0x20, %edi
callq 0x6480
movq %rax, %rbx
leaq 0x24bec(%rip), %rsi # 0x2e1a6
leaq 0x7(%rsp), %rdx
movq %rax, %rdi
callq 0xb49a
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x6490
movq %r14, %rdi
callq 0x67f0
nop
| /WillTarte[P]COMP-345-RISK/src/PlayerStrategy.cpp |
RandomBotStrategy::RandomBotStrategy() | RandomBotStrategy::RandomBotStrategy() {
this->armiesToPlace = new int(0);
this->player = nullptr;
this->from = nullptr;
this->to = nullptr;
this->strategyName = new std::string("RANDOM");
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x8c3c
leaq 0x3336c(%rip), %rax # 0x3c960
movq %rax, (%rbx)
movl $0x4, %edi
callq 0x6480
movl $0x0, (%rax)
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq $0x0, 0x30(%rbx)
movl $0x20, %edi
callq 0x6480
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x24b7c(%rip), %rsi # 0x2e1b1
leaq 0x24b7b(%rip), %rdx # 0x2e1b7
movq %r14, %rdi
callq 0xb834
movq %r14, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0x20, %esi
movq %r14, %rdi
callq 0x6490
jmp 0x9663
movq %rax, %r15
movq %rbx, %rdi
callq 0xb3d6
movq %r15, %rdi
callq 0x67f0
nop
| /WillTarte[P]COMP-345-RISK/src/PlayerStrategy.cpp |
RandomBotStrategy::RandomBotStrategy(Player const&) | RandomBotStrategy::RandomBotStrategy(const Player& player) {
this->armiesToPlace = new int(0);
this->player = new Player(player);
this->from = nullptr;
this->to = nullptr;
this->strategyName = new std::string("RANDOM");
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8c3c
leaq 0x332d5(%rip), %rax # 0x3c960
movq %rax, (%rbx)
movl $0x4, %edi
callq 0x6480
movl $0x0, (%rax)
movq %rax, 0x8(%rbx)
movl $0x38, %edi
callq 0x6480
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xd60a
movq %r15, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movl $0x20, %edi
callq 0x6480
movq %rax, %r15
addq $0x10, %rax
movq %rax, (%r15)
leaq 0x24ad1(%rip), %rsi # 0x2e1b1
leaq 0x24ad0(%rip), %rdx # 0x2e1b7
movq %r15, %rdi
callq 0xb834
movq %r15, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x20, %esi
jmp 0x970b
movq %rax, %r14
movl $0x38, %esi
movq %r15, %rdi
callq 0x6490
jmp 0x9718
movq %rax, %r14
movq %rbx, %rdi
callq 0xb3d6
movq %r14, %rdi
callq 0x67f0
| /WillTarte[P]COMP-345-RISK/src/PlayerStrategy.cpp |
RandomBotStrategy::operator=(RandomBotStrategy const&) | RandomBotStrategy& RandomBotStrategy::operator=(const RandomBotStrategy& rhs) {
this->exchangingCardType = rhs.exchangingCardType;
this->armiesToPlace = rhs.armiesToPlace;
this->player = rhs.player;
this->from = rhs.from;
this->to = rhs.to;
this->strategyName = new std::string("RANDOM");
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
movq 0x30(%rsi), %rax
movq %rax, 0x30(%rdi)
movl $0x20, %edi
callq 0x6480
movq %rax, %rbx
leaq 0x249ad(%rip), %rsi # 0x2e1b1
leaq 0x7(%rsp), %rdx
movq %rax, %rdi
callq 0xb49a
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x6490
movq %r14, %rdi
callq 0x67f0
nop
| /WillTarte[P]COMP-345-RISK/src/PlayerStrategy.cpp |
CheaterBotStrategy::operator=(CheaterBotStrategy const&) | CheaterBotStrategy& CheaterBotStrategy::operator=(const CheaterBotStrategy& rhs) {
this->exchangingCardType = rhs.exchangingCardType;
this->armiesToPlace = rhs.armiesToPlace;
this->player = rhs.player;
this->from = rhs.from;
this->to = rhs.to;
this->strategyName = new std::string("CHEATER");
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
movq 0x30(%rsi), %rax
movq %rax, 0x30(%rdi)
movl $0x20, %edi
callq 0x6480
movq %rax, %rbx
leaq 0x2476a(%rip), %rsi # 0x2e1b8
leaq 0x7(%rsp), %rdx
movq %rax, %rdi
callq 0xb49a
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x6490
movq %r14, %rdi
callq 0x67f0
nop
| /WillTarte[P]COMP-345-RISK/src/PlayerStrategy.cpp |
AggressiveBotStrategy::yesOrNo(StrategyContext) | signed char AggressiveBotStrategy::yesOrNo(StrategyContext context) {
char botChoice = 0;
switch ((int) context) {
case StrategyContext::ATTACK:
botChoice = canAttack() ? 'y' : 'n';
break;
case StrategyContext::FORTIFY:
botChoice = canFortify() ? 'y' : 'n';
break;
case StrategyContext::REINFORCE:
botChoice = 'y';
break;
default: {
// Should never occur
botChoice = 'n';
}
}
std::cout << botChoice << std::endl;
return botChoice;
} | pushq %r14
pushq %rbx
pushq %rax
cmpl $0xa, %esi
je 0x9b1b
cmpl $0x6, %esi
je 0x9b05
testl %esi, %esi
jne 0x9b1f
callq 0x9b6e
jmp 0x9b0a
callq 0x9d14
testb %al, %al
movl $0x79, %eax
movl $0x6e, %ebx
cmovnel %eax, %ebx
jmp 0x9b21
movb $0x79, %bl
jmp 0x9b21
movb $0x6e, %bl
leaq 0x7(%rsp), %rsi
movb %bl, (%rsi)
movq 0x33479(%rip), %rdi # 0x3cfa8
movl $0x1, %edx
callq 0x6500
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6460
movsbl %al, %esi
movq %r14, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6340
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /WillTarte[P]COMP-345-RISK/src/PlayerStrategy.cpp |
AggressiveBotStrategy::canFortify() | bool AggressiveBotStrategy::canFortify() {
bool canFortify = false;
Map::Country* biggestCountry = nullptr;
for (auto* country: *player->getOwnedCountries()) {
if (biggestCountry == nullptr || biggestCountry->getNumberOfTroops() < country->getNumberOfTroops()) {
biggestCountry = country;
}
}
for (auto* neighbour : *biggestCountry->getAdjCountries()) {
if (neighbour->getPlayerOwnerID() == biggestCountry->getPlayerOwnerID() && neighbour->getNumberOfTroops() > 1) {
canFortify = true;
}
}
return canFortify;
} | movq 0x20(%rdi), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
xorl %eax, %eax
movq (%rcx), %rsi
testq %rax, %rax
je 0x9d3b
movq 0x20(%rax), %rdi
movl (%rdi), %edi
movq 0x20(%rsi), %r8
cmpl (%r8), %edi
jge 0x9d3e
movq %rsi, %rax
addq $0x8, %rcx
cmpq %rdx, %rcx
jne 0x9d24
movq 0x28(%rax), %rdx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
cmpq %rdx, %rcx
je 0x9d89
movq 0x18(%rax), %rax
movl (%rax), %esi
xorl %eax, %eax
movl $0x1, %edi
movq (%rcx), %r8
movq 0x18(%r8), %r9
cmpl %esi, (%r9)
jne 0x9d7e
movq 0x20(%r8), %r8
cmpl $0x2, (%r8)
movzbl %al, %eax
cmovgel %edi, %eax
addq $0x8, %rcx
cmpq %rdx, %rcx
jne 0x9d64
jmp 0x9d8b
xorl %eax, %eax
andb $0x1, %al
retq
| /WillTarte[P]COMP-345-RISK/src/PlayerStrategy.cpp |
Deck::Deck(int) | Deck::Deck(int amountCountries) {
deckSize = new int(amountCountries); //store value on the heap to avoid losing it
deckPointer = new std::vector<CardType>;
discardPointer = new std::vector<CardType>;
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x4, %edi
callq 0x6480
movl %ebx, (%rax)
movq %rax, (%r14)
movl $0x18, %edi
callq 0x6480
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %ebx, %ebx
movq %rbx, 0x10(%rax)
movq %rax, 0x8(%r14)
movl $0x18, %edi
callq 0x6480
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, 0x10(%rax)
movq %rax, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /WillTarte[P]COMP-345-RISK/src/Cards.cpp |
Hand::Hand(Hand&) | Hand::Hand(Hand &toCopy) {
handPointer = new std::vector<CardType>(toCopy.getHand()->size());
*handPointer = *toCopy.handPointer;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x6480
movq %rax, %rbx
movq (%r14), %rax
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x2, %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x16022
movq %rbx, (%r15)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x15f4c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x6490
movq %r14, %rdi
callq 0x67f0
nop
| /WillTarte[P]COMP-345-RISK/src/Cards.cpp |
Deck::populateDeck() | std::vector<CardType> Deck::populateDeck() {
std::vector<CardType> deck = {};
for (int i = 0; i < *Deck::getNumberOfCards() / 3; i++) {
deck.emplace_back(CardType::INFANTRY);
deck.emplace_back(CardType::ARTILLERY);
deck.emplace_back(CardType::CAVALRY);
}
Deck::setNumberOfCards(deck.size());
return deck;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
cmpl $0x3, (%rax)
jl 0x15ada
xorl %ebp, %ebp
leaq 0x14(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
movl $0x0, 0x14(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x15a51
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x15a5c
movq %rbx, %rdi
movq %r15, %rdx
callq 0x10682
movq 0x8(%rbx), %rsi
movl $0x1, 0x10(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x15a7e
movl $0x1, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x15a89
movq %rbx, %rdi
movq %r12, %rdx
callq 0x10682
movq 0x8(%rbx), %rsi
movl $0x2, 0xc(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x15aab
movl $0x2, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x15ab6
movq %rbx, %rdi
movq %r13, %rdx
callq 0x10682
incl %ebp
movq (%r14), %rax
movslq (%rax), %rax
imulq $0x55555556, %rax, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
cmpl %eax, %ebp
jl 0x15a2f
movq (%rbx), %r12
movq 0x8(%rbx), %r15
movl $0x4, %edi
callq 0x6480
subq %r12, %r15
shrq $0x2, %r15
movl %r15d, (%rax)
movq %rax, (%r14)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15b10
jmp 0x15b10
jmp 0x15b10
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x15b27
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x6490
movq %r14, %rdi
callq 0x67f0
nop
| /WillTarte[P]COMP-345-RISK/src/Cards.cpp |
DiceRoller::~DiceRoller() | DiceRoller::~DiceRoller() {
delete diceRolled;
delete history;
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x16396
movl $0x4, %esi
callq 0x6490
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x163c1
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x163b3
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x6490
movl $0x18, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x6490
popq %rbx
retq
nop
| /WillTarte[P]COMP-345-RISK/src/Dice.cpp |
glfwIsValidContextConfig | GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
{
if (ctxconfig->share)
{
if (ctxconfig->client == GLFW_NO_API ||
ctxconfig->share->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return GLFW_FALSE;
}
}
if (ctxconfig->source != GLFW_NATIVE_CONTEXT_API &&
ctxconfig->source != GLFW_EGL_CONTEXT_API &&
ctxconfig->source != GLFW_OSMESA_CONTEXT_API)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context creation API 0x%08X",
ctxconfig->source);
return GLFW_FALSE;
}
if (ctxconfig->client != GLFW_NO_API &&
ctxconfig->client != GLFW_OPENGL_API &&
ctxconfig->client != GLFW_OPENGL_ES_API)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid client API 0x%08X",
ctxconfig->client);
return GLFW_FALSE;
}
if (ctxconfig->client == GLFW_OPENGL_API)
{
if ((ctxconfig->major < 1 || ctxconfig->minor < 0) ||
(ctxconfig->major == 1 && ctxconfig->minor > 5) ||
(ctxconfig->major == 2 && ctxconfig->minor > 1) ||
(ctxconfig->major == 3 && ctxconfig->minor > 3))
{
// OpenGL 1.0 is the smallest valid version
// OpenGL 1.x series ended with version 1.5
// OpenGL 2.x series ended with version 2.1
// OpenGL 3.x series ended with version 3.3
// For now, let everything else through
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid OpenGL version %i.%i",
ctxconfig->major, ctxconfig->minor);
return GLFW_FALSE;
}
if (ctxconfig->profile)
{
if (ctxconfig->profile != GLFW_OPENGL_CORE_PROFILE &&
ctxconfig->profile != GLFW_OPENGL_COMPAT_PROFILE)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid OpenGL profile 0x%08X",
ctxconfig->profile);
return GLFW_FALSE;
}
if (ctxconfig->major <= 2 ||
(ctxconfig->major == 3 && ctxconfig->minor < 2))
{
// Desktop OpenGL context profiles are only defined for version 3.2
// and above
_glfwInputError(GLFW_INVALID_VALUE,
"Context profiles are only defined for OpenGL version 3.2 and above");
return GLFW_FALSE;
}
}
if (ctxconfig->forward && ctxconfig->major <= 2)
{
// Forward-compatible contexts are only defined for OpenGL version 3.0 and above
_glfwInputError(GLFW_INVALID_VALUE,
"Forward-compatibility is only defined for OpenGL version 3.0 and above");
return GLFW_FALSE;
}
}
else if (ctxconfig->client == GLFW_OPENGL_ES_API)
{
if (ctxconfig->major < 1 || ctxconfig->minor < 0 ||
(ctxconfig->major == 1 && ctxconfig->minor > 1) ||
(ctxconfig->major == 2 && ctxconfig->minor > 0))
{
// OpenGL ES 1.0 is the smallest valid version
// OpenGL ES 1.x series ended with version 1.1
// OpenGL ES 2.x series ended with version 2.0
// For now, let everything else through
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid OpenGL ES version %i.%i",
ctxconfig->major, ctxconfig->minor);
return GLFW_FALSE;
}
}
if (ctxconfig->robustness)
{
if (ctxconfig->robustness != GLFW_NO_RESET_NOTIFICATION &&
ctxconfig->robustness != GLFW_LOSE_CONTEXT_ON_RESET)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context robustness mode 0x%08X",
ctxconfig->robustness);
return GLFW_FALSE;
}
}
if (ctxconfig->release)
{
if (ctxconfig->release != GLFW_RELEASE_BEHAVIOR_NONE &&
ctxconfig->release != GLFW_RELEASE_BEHAVIOR_FLUSH)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context release behavior 0x%08X",
ctxconfig->release);
return GLFW_FALSE;
}
}
return GLFW_TRUE;
} | pushq %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1e340
cmpl $0x0, (%rdi)
je 0x1e3b6
cmpl $0x0, 0x200(%rax)
je 0x1e3b6
movl 0x4(%rdi), %edx
leal -0x36001(%rdx), %eax
cmpl $0x3, %eax
jae 0x1e3cb
movl (%rdi), %edx
testl %edx, %edx
je 0x1e4a5
cmpl $0x30001, %edx # imm = 0x30001
je 0x1e3e5
cmpl $0x30002, %edx # imm = 0x30002
jne 0x1e427
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
testl %edx, %edx
setle %al
testl %ecx, %ecx
sets %sil
orb %al, %sil
jne 0x1e3ad
cmpl $0x1, %edx
sete %al
cmpl $0x2, %ecx
setae %sil
testb %sil, %al
jne 0x1e3ad
cmpl $0x2, %edx
setne %al
testl %ecx, %ecx
sete %sil
orb %al, %sil
jne 0x1e4a5
leaq 0x24139(%rip), %rsi # 0x424ed
jmp 0x1e414
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq 0x1eed8
jmp 0x1e4cc
leaq 0x24018(%rip), %rsi # 0x423ea
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x1eed8
jmp 0x1e4cc
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
testl %edx, %edx
setle %al
testl %ecx, %ecx
sets %sil
orb %al, %sil
jne 0x1e40d
cmpl $0x1, %edx
sete %al
cmpl $0x6, %ecx
setae %sil
testb %sil, %al
je 0x1e437
leaq 0x24014(%rip), %rsi # 0x42428
xorl %ebx, %ebx
movl $0x10004, %edi # imm = 0x10004
xorl %eax, %eax
callq 0x1eed8
jmp 0x1e4cc
leaq 0x23fe0(%rip), %rsi # 0x4240e
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
jmp 0x1e3d9
cmpl $0x3, %edx
je 0x1e44a
cmpl $0x2, %edx
jne 0x1e446
cmpl $0x1, %ecx
ja 0x1e40d
xorl %esi, %esi
jmp 0x1e452
movb $0x1, %sil
cmpl $0x4, %ecx
jae 0x1e40d
movl 0x1c(%rdi), %eax
leal -0x32001(%rax), %r8d
cmpl $0x2, %r8d
jae 0x1e483
cmpl $0x3, %edx
setae %al
cmpl $0x2, %ecx
setae %cl
xorb $0x1, %sil
orb %cl, %sil
testb %sil, %al
jne 0x1e487
leaq 0x23fe2(%rip), %rsi # 0x42463
jmp 0x1e499
testl %eax, %eax
jne 0x1e4e8
cmpl $0x2, %edx
ja 0x1e4a5
cmpl $0x0, 0x10(%rdi)
je 0x1e4a5
leaq 0x2400d(%rip), %rsi # 0x424a6
xorl %ebx, %ebx
movl $0x10004, %edi # imm = 0x10004
jmp 0x1e3bf
movl 0x20(%rdi), %edx
leal -0x31001(%rdx), %eax
cmpl $0x2, %eax
jb 0x1e4b7
testl %edx, %edx
jne 0x1e4d0
movl 0x24(%rdi), %edx
pushq $0x1
popq %rbx
leal -0x35001(%rdx), %eax
cmpl $0x2, %eax
jb 0x1e4cc
testl %edx, %edx
jne 0x1e4dc
movl %ebx, %eax
popq %rbx
retq
leaq 0x24036(%rip), %rsi # 0x4250d
jmp 0x1e3d2
leaq 0x24051(%rip), %rsi # 0x42534
jmp 0x1e3d2
leaq 0x23f56(%rip), %rsi # 0x42445
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
movl %eax, %edx
jmp 0x1e3d9
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/context.c |
glfw_fmaxf | float _glfw_fmaxf(float a, float b)
{
if (a != a)
return b;
else if (b != b)
return a;
else if (a > b)
return a;
else
return b;
} | ucomiss %xmm0, %xmm0
jp 0x1eed4
ucomiss %xmm1, %xmm1
jp 0x1eed1
maxss %xmm1, %xmm0
movaps %xmm0, %xmm1
movaps %xmm1, %xmm0
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/init.c |
glfwInputError | void _glfwInputError(int code, const char* format, ...)
{
_GLFWerror* error;
char description[_GLFW_MESSAGE_SIZE];
if (format)
{
va_list vl;
va_start(vl, format);
vsnprintf(description, sizeof(description), format, vl);
va_end(vl);
description[sizeof(description) - 1] = '\0';
}
else
{
if (code == GLFW_NOT_INITIALIZED)
strcpy(description, "The GLFW library is not initialized");
else if (code == GLFW_NO_CURRENT_CONTEXT)
strcpy(description, "There is no current context");
else if (code == GLFW_INVALID_ENUM)
strcpy(description, "Invalid argument for enum parameter");
else if (code == GLFW_INVALID_VALUE)
strcpy(description, "Invalid value for parameter");
else if (code == GLFW_OUT_OF_MEMORY)
strcpy(description, "Out of memory");
else if (code == GLFW_API_UNAVAILABLE)
strcpy(description, "The requested API is unavailable");
else if (code == GLFW_VERSION_UNAVAILABLE)
strcpy(description, "The requested API version is unavailable");
else if (code == GLFW_PLATFORM_ERROR)
strcpy(description, "A platform-specific error occurred");
else if (code == GLFW_FORMAT_UNAVAILABLE)
strcpy(description, "The requested format is unavailable");
else if (code == GLFW_NO_WINDOW_CONTEXT)
strcpy(description, "The specified window has no context");
else
strcpy(description, "ERROR: UNKNOWN GLFW ERROR");
}
if (_glfw.initialized)
{
error = _glfwPlatformGetTls(&_glfw.errorSlot);
if (!error)
{
error = calloc(1, sizeof(_GLFWerror));
_glfwPlatformSetTls(&_glfw.errorSlot, error);
_glfwPlatformLockMutex(&_glfw.errorLock);
error->next = _glfw.errorListHead;
_glfw.errorListHead = error;
_glfwPlatformUnlockMutex(&_glfw.errorLock);
}
}
else
error = &_glfwMainThreadError;
error->code = code;
strcpy(error->description, description);
if (_glfwErrorCallback)
_glfwErrorCallback(code, description);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4d8, %rsp # imm = 0x4D8
movl %edi, %ebx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x1ef37
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)
testq %rsi, %rsi
je 0x1f004
movq %rsi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x500(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %r14
movl $0x400, %esi # imm = 0x400
movq %r14, %rdi
movq %r10, %rdx
callq 0x7320
movb $0x0, 0x3ff(%r14)
leaq 0x51e29(%rip), %r12 # 0x70db8
cmpl $0x0, (%r12)
je 0x1f051
movl $0x20594, %edi # imm = 0x20594
addq 0x4a032(%rip), %rdi # 0x68fd8
callq 0x2aee2
movq %rax, %r14
testq %rax, %rax
jne 0x1f058
pushq $0x1
popq %rdi
movl $0x410, %esi # imm = 0x410
callq 0x7350
movq %rax, %r14
leaq 0x20594(%r12), %rdi
movq %rax, %rsi
callq 0x2af0d
leaq 0x205a8(%r12), %r15
movq %r15, %rdi
callq 0x2afbd
movq 0x3e0(%r12), %rax
movq %rax, (%r14)
movq %r14, 0x3e0(%r12)
movq %r15, %rdi
callq 0x2afe9
jmp 0x1f058
leal -0x10001(%rbx), %eax
cmpl $0x9, %eax
ja 0x1f1cf
leaq 0x2394a(%rip), %rcx # 0x42964
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movups 0x23972(%rip), %xmm0 # 0x4299c
movaps %xmm0, 0xe0(%rsp)
movups 0x23953(%rip), %xmm0 # 0x4298c
movaps %xmm0, 0xd0(%rsp)
movl $0x64657a, 0xf0(%rsp) # imm = 0x64657A
jmp 0x1ef88
leaq 0x73568(%rip), %r14 # 0x925c0
movl %ebx, 0x8(%r14)
addq $0xc, %r14
leaq 0xd0(%rsp), %rsi
movq %r14, %rdi
callq 0x7500
movq 0x73959(%rip), %rax # 0x929d0
testq %rax, %rax
je 0x1f088
leaq 0xd0(%rsp), %rsi
movl %ebx, %edi
callq *%rax
addq $0x4d8, %rsp # imm = 0x4D8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movabsq $0x79726f6d656d20, %rax # imm = 0x79726F6D656D20
movq %rax, 0xd6(%rsp)
movabsq $0x6d20666f2074754f, %rax # imm = 0x6D20666F2074754F
movq %rax, 0xd0(%rsp)
jmp 0x1ef88
movups 0x239f4(%rip), %xmm0 # 0x42abb
movaps %xmm0, 0xe0(%rsp)
movups 0x239d5(%rip), %xmm0 # 0x42aab
movaps %xmm0, 0xd0(%rsp)
movl $0x747865, 0xf0(%rsp) # imm = 0x747865
jmp 0x1ef88
movups 0x238e7(%rip), %xmm0 # 0x429dc
movaps %xmm0, 0xe0(%rsp)
movups 0x238c8(%rip), %xmm0 # 0x429cc
movaps %xmm0, 0xd0(%rsp)
movl $0x726574, 0xf0(%rsp) # imm = 0x726574
jmp 0x1ef88
movups 0x238d9(%rip), %xmm0 # 0x429fc
movups %xmm0, 0xdc(%rsp)
movups 0x238be(%rip), %xmm0 # 0x429f0
jmp 0x1f1e5
movups 0x23936(%rip), %xmm0 # 0x42a74
movaps %xmm0, 0xe0(%rsp)
movups 0x23917(%rip), %xmm0 # 0x42a64
movaps %xmm0, 0xd0(%rsp)
movl $0x646572, 0xef(%rsp) # imm = 0x646572
jmp 0x1ef88
movups 0x23850(%rip), %xmm0 # 0x429bc
movups %xmm0, 0xdc(%rsp)
movups 0x23835(%rip), %xmm0 # 0x429b0
jmp 0x1f1e5
movups 0x238a6(%rip), %xmm0 # 0x42a2a
movaps %xmm0, 0xe0(%rsp)
movups 0x23887(%rip), %xmm0 # 0x42a1a
movaps %xmm0, 0xd0(%rsp)
movb $0x0, 0xf0(%rsp)
jmp 0x1ef88
movups 0x238a5(%rip), %xmm0 # 0x42a54
movups %xmm0, 0xe9(%rsp)
movups 0x2388d(%rip), %xmm0 # 0x42a4b
movaps %xmm0, 0xe0(%rsp)
movups 0x2386e(%rip), %xmm0 # 0x42a3b
jmp 0x1f1e5
movups 0x23903(%rip), %xmm0 # 0x42ad9
movups %xmm0, 0xda(%rsp)
movups 0x238ea(%rip), %xmm0 # 0x42acf
movaps %xmm0, 0xd0(%rsp)
jmp 0x1ef88
movups 0x2389e(%rip), %xmm0 # 0x42a97
movaps %xmm0, 0xe0(%rsp)
movups 0x2387f(%rip), %xmm0 # 0x42a87
movaps %xmm0, 0xd0(%rsp)
movl $0x656c62, 0xf0(%rsp) # imm = 0x656C62
jmp 0x1ef88
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/init.c |
glfwInit | GLFWAPI int glfwInit(void)
{
if (_glfw.initialized)
return GLFW_TRUE;
memset(&_glfw, 0, sizeof(_glfw));
_glfw.hints.init = _glfwInitHints;
if (!_glfwPlatformInit())
{
terminate();
return GLFW_FALSE;
}
if (!_glfwPlatformCreateMutex(&_glfw.errorLock) ||
!_glfwPlatformCreateTls(&_glfw.errorSlot) ||
!_glfwPlatformCreateTls(&_glfw.contextSlot))
{
terminate();
return GLFW_FALSE;
}
_glfwPlatformSetTls(&_glfw.errorSlot, &_glfwMainThreadError);
_glfwInitGamepadMappings();
_glfw.initialized = GLFW_TRUE;
_glfw.timer.offset = _glfwPlatformGetTimerValue();
glfwDefaultWindowHints();
return GLFW_TRUE;
} | pushq %rbp
pushq %r14
pushq %rbx
leaq 0x51b8d(%rip), %rbx # 0x70db8
pushq $0x1
popq %r14
cmpl $0x0, (%rbx)
je 0x1f23c
movl %r14d, %ebp
jmp 0x1f2eb
xorl %ebp, %ebp
movl $0x21808, %edx # imm = 0x21808
movq %rbx, %rdi
xorl %esi, %esi
callq 0x72c0
movq 0x4a310(%rip), %rax # 0x69564
movq %rax, 0x8(%rbx)
movl 0x4a30e(%rip), %eax # 0x6956c
movl %eax, 0x10(%rbx)
callq 0x24398
testl %eax, %eax
je 0x1f2e6
movl $0x205a8, %edi # imm = 0x205A8
addq 0x49d62(%rip), %rdi # 0x68fd8
callq 0x2af38
testl %eax, %eax
je 0x1f2dd
movl $0x20594, %edi # imm = 0x20594
addq 0x49d4d(%rip), %rdi # 0x68fd8
callq 0x2ae68
testl %eax, %eax
je 0x1f2dd
movl $0x2059c, %edi # imm = 0x2059C
addq 0x49d38(%rip), %rdi # 0x68fd8
callq 0x2ae68
testl %eax, %eax
je 0x1f2dd
leaq 0x20594(%rbx), %rdi
leaq 0x73309(%rip), %rsi # 0x925c0
callq 0x2af0d
callq 0x1f70a
movl $0x1, (%rbx)
callq 0x2ae0f
movq %rax, 0x205d8(%rbx)
callq 0x22dbd
jmp 0x1f234
callq 0x1f2f2
xorl %ebp, %ebp
jmp 0x1f2eb
callq 0x1f2f2
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/init.c |
terminate | static void terminate(void)
{
int i;
memset(&_glfw.callbacks, 0, sizeof(_glfw.callbacks));
while (_glfw.windowListHead)
glfwDestroyWindow((GLFWwindow*) _glfw.windowListHead);
while (_glfw.cursorListHead)
glfwDestroyCursor((GLFWcursor*) _glfw.cursorListHead);
for (i = 0; i < _glfw.monitorCount; i++)
{
_GLFWmonitor* monitor = _glfw.monitors[i];
if (monitor->originalRamp.size)
_glfwPlatformSetGammaRamp(monitor, &monitor->originalRamp);
_glfwFreeMonitor(monitor);
}
free(_glfw.monitors);
_glfw.monitors = NULL;
_glfw.monitorCount = 0;
free(_glfw.mappings);
_glfw.mappings = NULL;
_glfw.mappingCount = 0;
_glfwTerminateVulkan();
_glfwPlatformTerminate();
_glfw.initialized = GLFW_FALSE;
while (_glfw.errorListHead)
{
_GLFWerror* error = _glfw.errorListHead;
_glfw.errorListHead = error->next;
free(error);
}
_glfwPlatformDestroyTls(&_glfw.contextSlot);
_glfwPlatformDestroyTls(&_glfw.errorSlot);
_glfwPlatformDestroyMutex(&_glfw.errorLock);
memset(&_glfw, 0, sizeof(_glfw));
} | pushq %r15
pushq %r14
pushq %rbx
xorps %xmm0, %xmm0
leaq 0x51ab7(%rip), %rbx # 0x70db8
movups %xmm0, 0x20630(%rbx)
movq 0x3f0(%rbx), %rdi
testq %rdi, %rdi
je 0x1f320
callq 0x22d39
jmp 0x1f308
callq 0x204a9
movq 0x3e8(%rbx), %rdi
testq %rdi, %rdi
jne 0x1f31b
xorl %r15d, %r15d
movslq 0x400(%rbx), %rax
movq 0x3f8(%rbx), %rdi
cmpq %rax, %r15
jge 0x1f36c
movq (%rdi,%r15,8), %r14
cmpl $0x0, 0xd8(%r14)
je 0x1f35f
leaq 0xc0(%r14), %rsi
movq %r14, %rdi
callq 0x26cbb
movq %r14, %rdi
callq 0x218e6
incq %r15
jmp 0x1f32f
callq 0x7630
andq $0x0, 0x3f8(%rbx)
andl $0x0, 0x400(%rbx)
movq 0x20588(%rbx), %rdi
callq 0x7630
andq $0x0, 0x20588(%rbx)
andl $0x0, 0x20590(%rbx)
callq 0x22569
callq 0x25cc4
andl $0x0, (%rbx)
movq 0x3e0(%rbx), %rdi
testq %rdi, %rdi
je 0x1f3c5
movq (%rdi), %rax
movq %rax, 0x3e0(%rbx)
callq 0x7630
jmp 0x1f3a8
leaq 0x2059c(%rbx), %rdi
callq 0x2aecb
leaq 0x20594(%rbx), %rdi
callq 0x2aecb
leaq 0x205a8(%rbx), %rdi
callq 0x2af9b
movl $0x21808, %edx # imm = 0x21808
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x72c0
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/init.c |
glfwInitHint | GLFWAPI void glfwInitHint(int hint, int value)
{
switch (hint)
{
case GLFW_JOYSTICK_HAT_BUTTONS:
_glfwInitHints.hatButtons = value;
return;
case GLFW_COCOA_CHDIR_RESOURCES:
_glfwInitHints.ns.chdir = value;
return;
case GLFW_COCOA_MENUBAR:
_glfwInitHints.ns.menubar = value;
return;
}
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid init hint 0x%08X", hint);
} | cmpl $0x51002, %edi # imm = 0x51002
je 0x1f436
movl %edi, %edx
cmpl $0x51001, %edi # imm = 0x51001
je 0x1f42f
cmpl $0x50001, %edx # imm = 0x50001
jne 0x1f43d
movl %esi, 0x4a136(%rip) # 0x69564
retq
movl %esi, 0x4a137(%rip) # 0x6956c
retq
movl %esi, 0x4a12c(%rip) # 0x69568
retq
leaq 0x236a5(%rip), %rsi # 0x42ae9
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
jmp 0x1eed8
| /apitrace[P]apitrace-tests/thirdparty/glfw/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 0x1f45b
movl $0x3, (%rdi)
testq %rsi, %rsi
je 0x1f466
movl $0x3, (%rsi)
testq %rdx, %rdx
je 0x1f471
movl $0x7, (%rdx)
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/init.c |
glfwGetError | GLFWAPI int glfwGetError(const char** description)
{
_GLFWerror* error;
int code = GLFW_NO_ERROR;
if (description)
*description = NULL;
if (_glfw.initialized)
error = _glfwPlatformGetTls(&_glfw.errorSlot);
else
error = &_glfwMainThreadError;
if (error)
{
code = error->code;
error->code = GLFW_NO_ERROR;
if (description && code)
*description = error->description;
}
return code;
} | pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1f484
andq $0x0, (%rbx)
leaq 0x5192d(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x1f4aa
movl $0x20594, %edi # imm = 0x20594
addq 0x49b3c(%rip), %rdi # 0x68fd8
callq 0x2aee2
testq %rax, %rax
jne 0x1f4b1
xorl %ecx, %ecx
jmp 0x1f4d4
leaq 0x7310f(%rip), %rax # 0x925c0
testq %rbx, %rbx
setne %dl
movl 0x8(%rax), %ecx
andl $0x0, 0x8(%rax)
testl %ecx, %ecx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x1f4d4
addq $0xc, %rax
movq %rax, (%rbx)
movl %ecx, %eax
popq %rbx
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/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[key] == GLFW_PRESS)
repeated = GLFW_TRUE;
if (action == GLFW_RELEASE && window->stickyKeys)
window->keys[key] = _GLFW_STICK;
else
window->keys[key] = (char) action;
if (repeated)
action = GLFW_REPEAT;
}
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (window->callbacks.key)
window->callbacks.key((GLFWwindow*) window, key, scancode, action, mods);
} | cmpl $0x15c, %esi # imm = 0x15C
ja 0x1f533
movl %esi, %eax
cmpl $0x1, %ecx
je 0x1f515
testl %ecx, %ecx
jne 0x1f52c
cmpb $0x0, 0x88(%rdi,%rax)
je 0x1f553
cmpl $0x0, 0x70(%rdi)
je 0x1f554
movb $0x3, 0x88(%rdi,%rax)
jmp 0x1f533
cmpb $0x1, 0x88(%rdi,%rax)
movb $0x1, 0x88(%rdi,%rax)
jne 0x1f533
pushq $0x2
popq %rcx
jmp 0x1f533
movb %cl, 0x88(%rdi,%rax)
movq 0x328(%rdi), %r9
testq %r9, %r9
je 0x1f553
movl %r8d, %eax
andl $-0x31, %eax
cmpl $0x0, 0x78(%rdi)
cmovnel %r8d, %eax
movl %eax, %r8d
jmpq *%r9
retq
movb $0x0, 0x88(%rdi,%rax)
jmp 0x1f533
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwInputMouseClick | void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
{
if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
return;
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (action == GLFW_RELEASE && window->stickyMouseButtons)
window->mouseButtons[button] = _GLFW_STICK;
else
window->mouseButtons[button] = (char) action;
if (window->callbacks.mouseButton)
window->callbacks.mouseButton((GLFWwindow*) window, button, action, mods);
} | cmpl $0x7, %esi
ja 0x1f607
movl %ecx, %eax
andl $-0x31, %ecx
cmpl $0x0, 0x78(%rdi)
cmovnel %eax, %ecx
testl %edx, %edx
je 0x1f5e6
movl %edx, %eax
jmp 0x1f5ee
movb $0x3, %al
cmpl $0x0, 0x74(%rdi)
je 0x1f5e2
movl %esi, %r8d
movb %al, 0x80(%rdi,%r8)
movq 0x308(%rdi), %rax
testq %rax, %rax
je 0x1f607
jmpq *%rax
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwInputJoystickHat | void _glfwInputJoystickHat(_GLFWjoystick* js, int hat, char value)
{
const int base = js->buttonCount + hat * 4;
js->buttons[base + 0] = (value & 0x01) ? GLFW_PRESS : GLFW_RELEASE;
js->buttons[base + 1] = (value & 0x02) ? GLFW_PRESS : GLFW_RELEASE;
js->buttons[base + 2] = (value & 0x04) ? GLFW_PRESS : GLFW_RELEASE;
js->buttons[base + 3] = (value & 0x08) ? GLFW_PRESS : GLFW_RELEASE;
js->hats[hat] = value;
} | movslq 0x20(%rdi), %rax
movslq %esi, %rcx
leaq (%rax,%rcx,4), %rax
movl %edx, %esi
andb $0x1, %sil
movq 0x18(%rdi), %r8
movb %sil, (%r8,%rax)
movl %edx, %esi
shrb %sil
andb $0x1, %sil
movq 0x18(%rdi), %r8
movb %sil, 0x1(%r8,%rax)
movl %edx, %esi
shrb $0x2, %sil
andb $0x1, %sil
movq 0x18(%rdi), %r8
movb %sil, 0x2(%r8,%rax)
movl %edx, %esi
shrb $0x3, %sil
andb $0x1, %sil
movq 0x18(%rdi), %r8
movb %sil, 0x3(%r8,%rax)
movq 0x28(%rdi), %rax
movb %dl, (%rax,%rcx)
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
parseMapping | static GLFWbool parseMapping(_GLFWmapping* mapping, const char* string)
{
const char* c = string;
size_t i, length;
struct
{
const char* name;
_GLFWmapelement* element;
} fields[] =
{
{ "platform", NULL },
{ "a", mapping->buttons + GLFW_GAMEPAD_BUTTON_A },
{ "b", mapping->buttons + GLFW_GAMEPAD_BUTTON_B },
{ "x", mapping->buttons + GLFW_GAMEPAD_BUTTON_X },
{ "y", mapping->buttons + GLFW_GAMEPAD_BUTTON_Y },
{ "back", mapping->buttons + GLFW_GAMEPAD_BUTTON_BACK },
{ "start", mapping->buttons + GLFW_GAMEPAD_BUTTON_START },
{ "guide", mapping->buttons + GLFW_GAMEPAD_BUTTON_GUIDE },
{ "leftshoulder", mapping->buttons + GLFW_GAMEPAD_BUTTON_LEFT_BUMPER },
{ "rightshoulder", mapping->buttons + GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER },
{ "leftstick", mapping->buttons + GLFW_GAMEPAD_BUTTON_LEFT_THUMB },
{ "rightstick", mapping->buttons + GLFW_GAMEPAD_BUTTON_RIGHT_THUMB },
{ "dpup", mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_UP },
{ "dpright", mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_RIGHT },
{ "dpdown", mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_DOWN },
{ "dpleft", mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_LEFT },
{ "lefttrigger", mapping->axes + GLFW_GAMEPAD_AXIS_LEFT_TRIGGER },
{ "righttrigger", mapping->axes + GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER },
{ "leftx", mapping->axes + GLFW_GAMEPAD_AXIS_LEFT_X },
{ "lefty", mapping->axes + GLFW_GAMEPAD_AXIS_LEFT_Y },
{ "rightx", mapping->axes + GLFW_GAMEPAD_AXIS_RIGHT_X },
{ "righty", mapping->axes + GLFW_GAMEPAD_AXIS_RIGHT_Y }
};
length = strcspn(c, ",");
if (length != 32 || c[length] != ',')
{
_glfwInputError(GLFW_INVALID_VALUE, NULL);
return GLFW_FALSE;
}
memcpy(mapping->guid, c, length);
c += length + 1;
length = strcspn(c, ",");
if (length >= sizeof(mapping->name) || c[length] != ',')
{
_glfwInputError(GLFW_INVALID_VALUE, NULL);
return GLFW_FALSE;
}
memcpy(mapping->name, c, length);
c += length + 1;
while (*c)
{
// TODO: Implement output modifiers
if (*c == '+' || *c == '-')
return GLFW_FALSE;
for (i = 0; i < sizeof(fields) / sizeof(fields[0]); i++)
{
length = strlen(fields[i].name);
if (strncmp(c, fields[i].name, length) != 0 || c[length] != ':')
continue;
c += length + 1;
if (fields[i].element)
{
_GLFWmapelement* e = fields[i].element;
int8_t minimum = -1;
int8_t maximum = 1;
if (*c == '+')
{
minimum = 0;
c += 1;
}
else if (*c == '-')
{
maximum = 0;
c += 1;
}
if (*c == 'a')
e->type = _GLFW_JOYSTICK_AXIS;
else if (*c == 'b')
e->type = _GLFW_JOYSTICK_BUTTON;
else if (*c == 'h')
e->type = _GLFW_JOYSTICK_HATBIT;
else
break;
if (e->type == _GLFW_JOYSTICK_HATBIT)
{
const unsigned long hat = strtoul(c + 1, (char**) &c, 10);
const unsigned long bit = strtoul(c + 1, (char**) &c, 10);
e->index = (uint8_t) ((hat << 4) | bit);
}
else
e->index = (uint8_t) strtoul(c + 1, (char**) &c, 10);
if (e->type == _GLFW_JOYSTICK_AXIS)
{
e->axisScale = 2 / (maximum - minimum);
e->axisOffset = -(maximum + minimum);
if (*c == '~')
{
e->axisScale = -e->axisScale;
e->axisOffset = -e->axisOffset;
}
}
}
else
{
length = strlen(_GLFW_PLATFORM_MAPPING_NAME);
if (strncmp(c, _GLFW_PLATFORM_MAPPING_NAME, length) != 0)
return GLFW_FALSE;
}
break;
}
c += strcspn(c, ",");
c += strspn(c, ",");
}
for (i = 0; i < 32; i++)
{
if (mapping->guid[i] >= 'A' && mapping->guid[i] <= 'F')
mapping->guid[i] += 'a' - 'A';
}
_glfwPlatformUpdateGamepadGUID(mapping->guid);
return GLFW_TRUE;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, (%rsp)
leaq 0x3defa(%rip), %rax # 0x5d6c8
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
leaq 0x208ad(%rip), %rax # 0x4008d
movq %rax, 0x20(%rsp)
leaq 0xa1(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0xeeb2(%rip), %rax # 0x2e6aa
movq %rax, 0x30(%rsp)
leaq 0xa5(%rdi), %rax
movq %rax, 0x38(%rsp)
leaq 0x22632(%rip), %rax # 0x41e42
movq %rax, 0x40(%rsp)
leaq 0xa9(%rdi), %rax
movq %rax, 0x48(%rsp)
leaq 0x420cb(%rip), %rax # 0x618f3
movq %rax, 0x50(%rsp)
leaq 0xad(%rdi), %rax
movq %rax, 0x58(%rsp)
leaq 0x109af(%rip), %rax # 0x301ef
movq %rax, 0x60(%rsp)
leaq 0xb9(%rdi), %rax
movq %rax, 0x68(%rsp)
leaq 0x13f30(%rip), %rax # 0x33788
movq %rax, 0x70(%rsp)
leaq 0xbd(%rdi), %rax
movq %rax, 0x78(%rsp)
leaq 0x3de61(%rip), %rax # 0x5d6d1
movq %rax, 0x80(%rsp)
leaq 0xc1(%rdi), %rax
movq %rax, 0x88(%rsp)
leaq 0x3de49(%rip), %rax # 0x5d6d7
movq %rax, 0x90(%rsp)
leaq 0xb1(%rdi), %rax
movq %rax, 0x98(%rsp)
leaq 0x3de38(%rip), %rax # 0x5d6e4
movq %rax, 0xa0(%rsp)
leaq 0xb5(%rdi), %rax
movq %rax, 0xa8(%rsp)
leaq 0x3de28(%rip), %rax # 0x5d6f2
movq %rax, 0xb0(%rsp)
leaq 0xc5(%rdi), %rax
movq %rax, 0xb8(%rsp)
leaq 0x3de14(%rip), %rax # 0x5d6fc
movq %rax, 0xc0(%rsp)
leaq 0xc9(%rdi), %rax
movq %rax, 0xc8(%rsp)
leaq 0x3de01(%rip), %rax # 0x5d707
movq %rax, 0xd0(%rsp)
leaq 0xcd(%rdi), %rax
movq %rax, 0xd8(%rsp)
leaq 0x3dde8(%rip), %rax # 0x5d70c
movq %rax, 0xe0(%rsp)
leaq 0xd1(%rdi), %rax
movq %rax, 0xe8(%rsp)
leaq 0x3ddd2(%rip), %rax # 0x5d714
movq %rax, 0xf0(%rsp)
leaq 0xd5(%rdi), %rax
movq %rax, 0xf8(%rsp)
leaq 0x3ddbb(%rip), %rax # 0x5d71b
movq %rax, 0x100(%rsp)
leaq 0xd9(%rdi), %rax
movq %rax, 0x108(%rsp)
leaq 0x3dda4(%rip), %rax # 0x5d722
movq %rax, 0x110(%rsp)
leaq 0xdd(%rdi), %rax
leaq 0xed(%rdi), %rcx
movq %rcx, 0x118(%rsp)
leaq 0x3dd8b(%rip), %rcx # 0x5d72e
movq %rcx, 0x120(%rsp)
leaq 0xf1(%rdi), %rcx
movq %rcx, 0x128(%rsp)
leaq 0x3dd7a(%rip), %rcx # 0x5d73b
movq %rcx, 0x130(%rsp)
movq %rax, 0x138(%rsp)
leaq 0x3dd69(%rip), %rax # 0x5d741
movq %rax, 0x140(%rsp)
leaq 0xe1(%rdi), %rax
movq %rax, 0x148(%rsp)
leaq 0x3dd51(%rip), %rax # 0x5d747
movq %rax, 0x150(%rsp)
leaq 0xe5(%rdi), %rax
movq %rax, 0x158(%rsp)
leaq 0x3dd3a(%rip), %rax # 0x5d74e
movq %rax, 0x160(%rsp)
leaq 0xe9(%rdi), %rax
movq %rax, 0x168(%rsp)
leaq 0x2fe44(%rip), %rsi # 0x4f876
movq %r14, %rdi
callq 0x7070
cmpq $0x20, %rax
jne 0x1fc68
cmpb $0x2c, 0x20(%r14)
jne 0x1fc68
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x90(%r12)
movups %xmm0, 0x80(%r12)
addq $0x21, %r14
leaq 0x2fe01(%rip), %rsi # 0x4f876
movq %r14, %rdi
callq 0x7070
cmpq $0x7f, %rax
ja 0x1fc68
cmpb $0x2c, (%r14,%rax)
jne 0x1fc68
leaq 0x80(%r12), %rbx
movq %rax, %r15
addq %r14, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x73f0
incq %r15
movq %r15, (%rsp)
movzbl (%r15), %eax
testl %eax, %eax
je 0x1fc8e
xorl %r13d, %r13d
cmpl $0x2b, %eax
je 0x1fc79
cmpl $0x2d, %eax
je 0x1fc79
pushq $0x8
popq %r14
cmpq $0x168, %r14 # imm = 0x168
je 0x1fb12
movq 0x8(%rsp,%r14), %r12
movq %r12, %rdi
callq 0x7240
movq %rax, %rbp
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x7260
testl %eax, %eax
jne 0x1fb0c
cmpb $0x3a, (%r15,%rbp)
je 0x1fb47
addq $0x10, %r14
jmp 0x1fada
movq %r15, %r12
movq %r12, %rdi
leaq 0x2fd57(%rip), %r14 # 0x4f876
movq %r14, %rsi
callq 0x7070
movq %rax, %r13
addq %r12, %r13
movq %r13, (%rsp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x7200
movq %rax, %r15
addq %r13, %r15
jmp 0x1fab1
leaq (%r15,%rbp), %r12
incq %r12
movq %r12, (%rsp)
movq 0x10(%rsp,%r14), %r14
testq %r14, %r14
je 0x1fb77
movzbl (%r12), %eax
cmpl $0x2b, %eax
je 0x1fb92
pushq $-0x1
popq %rcx
pushq $0x1
popq %r13
cmpl $0x2d, %eax
jne 0x1fba7
xorl %r13d, %r13d
jmp 0x1fb98
movq %r12, %rdi
leaq 0x3dbd4(%rip), %rsi # 0x5d755
pushq $0x5
popq %rdx
callq 0x7260
testl %eax, %eax
je 0x1fb15
jmp 0x1fc79
xorl %ecx, %ecx
pushq $0x1
popq %r13
addq %rbp, %r15
leaq 0x2(%r15), %r12
movq %r12, (%rsp)
movb 0x2(%r15), %al
cmpb $0x61, %al
je 0x1fbff
movzbl %al, %eax
cmpl $0x68, %eax
je 0x1fbc4
cmpl $0x62, %eax
jne 0x1fb15
movl %ecx, 0xc(%rsp)
movb $0x2, %al
jmp 0x1fc05
movl %ecx, 0xc(%rsp)
movb $0x3, (%r14)
incq %r12
movq %r12, %rdi
movq %rsp, %r12
movq %r12, %rsi
pushq $0xa
popq %rbp
movl %ebp, %edx
callq 0x7150
movq %rax, %r15
movq (%rsp), %rdi
incq %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x7150
shlq $0x4, %r15
orq %rax, %r15
jmp 0x1fc1c
movl %ecx, 0xc(%rsp)
movb $0x1, %al
movb %al, (%r14)
incq %r12
movq %r12, %rdi
movq %rsp, %rsi
pushq $0xa
popq %rdx
callq 0x7150
movq %rax, %r15
movb %r15b, 0x1(%r14)
cmpb $0x1, (%r14)
movq (%rsp), %r12
jne 0x1fb15
movl %r13d, %ecx
movl 0xc(%rsp), %edx
subl %edx, %ecx
movb $0x2, %al
movzbl %al, %eax
divb %cl
movb %al, 0x2(%r14)
addl %edx, %r13d
movl %r13d, %ecx
negb %cl
movb %cl, 0x3(%r14)
cmpb $0x7e, (%r12)
jne 0x1fb15
negb %al
movb %al, 0x2(%r14)
movb %r13b, 0x3(%r14)
jmp 0x1fb15
xorl %r13d, %r13d
movl $0x10004, %edi # imm = 0x10004
xorl %esi, %esi
xorl %eax, %eax
callq 0x1eed8
movl %r13d, %eax
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
cmpq $0x20, %rax
je 0x1fcac
movb (%rbx,%rax), %cl
leal -0x41(%rcx), %edx
cmpb $0x5, %dl
ja 0x1fca7
orb $0x20, %cl
movb %cl, (%rbx,%rax)
incq %rax
jmp 0x1fc90
movq %rbx, %rdi
callq 0x2dea2
pushq $0x1
popq %r13
jmp 0x1fc79
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwGetMouseButton | GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (button < GLFW_MOUSE_BUTTON_1 || button > GLFW_MOUSE_BUTTON_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid mouse button %i", button);
return GLFW_RELEASE;
}
if (window->mouseButtons[button] == _GLFW_STICK)
{
// Sticky mode: release mouse button now
window->mouseButtons[button] = GLFW_RELEASE;
return GLFW_PRESS;
}
return (int) window->mouseButtons[button];
} | pushq %rbx
testq %rdi, %rdi
je 0x20275
leaq 0x50b96(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x20245
movl %esi, %edx
cmpl $0x8, %esi
jb 0x20257
leaq 0x3cea0(%rip), %rsi # 0x5d0d5
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x1eed8
jmp 0x20271
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x1eed8
jmp 0x20271
movl %edx, %eax
movsbl 0x80(%rdi,%rax), %ebx
cmpl $0x3, %ebx
jne 0x20271
movb $0x0, 0x80(%rdi,%rax)
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
leaq 0x22468(%rip), %rdi # 0x426e4
leaq 0x3ccd3(%rip), %rsi # 0x5cf56
leaq 0x3ce21(%rip), %rcx # 0x5d0ab
movl $0x29a, %edx # imm = 0x29A
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwSetCursor | GLFWAPI void glfwSetCursor(GLFWwindow* windowHandle, GLFWcursor* cursorHandle)
{
_GLFWwindow* window = (_GLFWwindow*) windowHandle;
_GLFWcursor* cursor = (_GLFWcursor*) cursorHandle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
window->cursor = cursor;
_glfwPlatformSetCursor(window, cursor);
} | testq %rdi, %rdi
je 0x205ef
leaq 0x507e5(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x205e1
movq %rsi, 0x50(%rdi)
jmp 0x2a3eb
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1eed8
pushq %rax
leaq 0x220ed(%rip), %rdi # 0x426e4
leaq 0x3c958(%rip), %rsi # 0x5cf56
leaq 0x3cbd9(%rip), %rcx # 0x5d1de
movl $0x33f, %edx # imm = 0x33F
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwGetJoystickName | GLFWAPI const char* glfwGetJoystickName(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
return NULL;
}
js = _glfw.joysticks + jid;
if (!js->present)
return NULL;
if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_PRESENCE))
return NULL;
return js->name;
} | pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x20c73
cmpl $0x10, %edi
jae 0x20c92
leaq 0x5019f(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x20c54
movl %edi, %ecx
imulq $0x2018, %rcx, %rcx # imm = 0x2018
cmpl $0x0, 0x408(%rax,%rcx)
je 0x20c66
leaq (%rax,%rcx), %r14
addq $0x408, %r14 # imm = 0x408
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2dc9f
addq $0x34, %r14
testl %eax, %eax
cmovneq %r14, %rbx
jmp 0x20c68
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x1eed8
jmp 0x20c68
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3c7b3(%rip), %rdi # 0x5d42d
leaq 0x3c2d5(%rip), %rsi # 0x5cf56
leaq 0x3c89b(%rip), %rcx # 0x5d523
movl $0x411, %edx # imm = 0x411
callq 0x7340
leaq 0x3c7c8(%rip), %rdi # 0x5d461
leaq 0x3c2b6(%rip), %rsi # 0x5cf56
leaq 0x3c87c(%rip), %rcx # 0x5d523
movl $0x412, %edx # imm = 0x412
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwGetGamepadState | GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state)
{
int i;
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
assert(state != NULL);
memset(state, 0, sizeof(GLFWgamepadstate));
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
return GLFW_FALSE;
}
js = _glfw.joysticks + jid;
if (!js->present)
return GLFW_FALSE;
if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_ALL))
return GLFW_FALSE;
if (!js->mapping)
return GLFW_FALSE;
for (i = 0; i <= GLFW_GAMEPAD_BUTTON_LAST; i++)
{
const _GLFWmapelement* e = js->mapping->buttons + i;
if (e->type == _GLFW_JOYSTICK_AXIS)
{
const float value = js->axes[e->index] * e->axisScale + e->axisOffset;
// HACK: This should be baked into the value transform
// TODO: Bake into transform when implementing output modifiers
if (e->axisOffset < 0 || (e->axisOffset == 0 && e->axisScale > 0))
{
if (value >= 0.f)
state->buttons[i] = GLFW_PRESS;
}
else
{
if (value <= 0.f)
state->buttons[i] = GLFW_PRESS;
}
}
else if (e->type == _GLFW_JOYSTICK_HATBIT)
{
const unsigned int hat = e->index >> 4;
const unsigned int bit = e->index & 0xf;
if (js->hats[hat] & bit)
state->buttons[i] = GLFW_PRESS;
}
else if (e->type == _GLFW_JOYSTICK_BUTTON)
state->buttons[i] = js->buttons[e->index];
}
for (i = 0; i <= GLFW_GAMEPAD_AXIS_LAST; i++)
{
const _GLFWmapelement* e = js->mapping->axes + i;
if (e->type == _GLFW_JOYSTICK_AXIS)
{
const float value = js->axes[e->index] * e->axisScale + e->axisOffset;
state->axes[i] = _glfw_fminf(_glfw_fmaxf(value, -1.f), 1.f);
}
else if (e->type == _GLFW_JOYSTICK_HATBIT)
{
const unsigned int hat = e->index >> 4;
const unsigned int bit = e->index & 0xf;
if (js->hats[hat] & bit)
state->axes[i] = 1.f;
else
state->axes[i] = -1.f;
}
else if (e->type == _GLFW_JOYSTICK_BUTTON)
state->axes[i] = js->buttons[e->index] * 2.f - 1.f;
}
return GLFW_TRUE;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x2148f
cmpl $0x10, %edi
jae 0x214ae
movq %rsi, %rbx
testq %rsi, %rsi
je 0x214cd
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movups %xmm0, (%rbx)
leaq 0x4fb2f(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x21388
movl %edi, %ecx
imulq $0x2018, %rcx, %rcx # imm = 0x2018
xorl %r15d, %r15d
cmpl $0x0, 0x408(%rax,%rcx)
je 0x21399
leaq (%rax,%rcx), %r14
addq $0x408, %r14 # imm = 0x408
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x2dc9f
testl %eax, %eax
je 0x21399
cmpq $0x0, 0xe8(%r14)
je 0x21399
xorl %eax, %eax
xorps %xmm0, %xmm0
cmpq $0xf, %rax
je 0x213a8
movq 0xe8(%r14), %rcx
movzbl 0xa1(%rcx,%rax,4), %edx
cmpl $0x3, %edx
je 0x21356
cmpl $0x2, %edx
je 0x21345
cmpl $0x1, %edx
jne 0x21377
movq 0x8(%r14), %rsi
movzbl 0xa2(%rcx,%rax,4), %edi
movsbl 0xa3(%rcx,%rax,4), %edx
cvtsi2ss %edx, %xmm1
movsbl 0xa4(%rcx,%rax,4), %ecx
cvtsi2ss %ecx, %xmm2
mulss (%rsi,%rdi,4), %xmm1
addss %xmm2, %xmm1
testb %cl, %cl
js 0x2133c
jne 0x2137f
testb %dl, %dl
jle 0x2137f
movb $0x1, %cl
ucomiss %xmm0, %xmm1
jae 0x21374
jmp 0x21377
movq 0x18(%r14), %rdx
movzbl 0xa2(%rcx,%rax,4), %ecx
movb (%rdx,%rcx), %cl
jmp 0x21374
movzbl 0xa2(%rcx,%rax,4), %ecx
movl %ecx, %edx
shrl $0x4, %edx
movq 0x28(%r14), %rsi
movzbl (%rsi,%rdx), %edx
andl %ecx, %edx
movb $0x1, %cl
testb $0xf, %dl
je 0x21377
movb %cl, (%rbx,%rax)
incq %rax
jmp 0x212dd
movb $0x1, %cl
ucomiss %xmm1, %xmm0
jae 0x21374
jmp 0x21377
xorl %r15d, %r15d
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x1eed8
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
pushq $0x1
popq %r15
movss 0x217a1(%rip), %xmm1 # 0x42b58
cmpq $0x6, %r12
je 0x21399
movq 0xe8(%r14), %rax
movzbl 0xdd(%rax,%r12,4), %ecx
cmpl $0x3, %ecx
je 0x21456
cmpl $0x2, %ecx
je 0x21430
cmpl $0x1, %ecx
jne 0x21487
movq 0x8(%r14), %rcx
movsbl 0xdf(%rax,%r12,4), %edx
cvtsi2ss %edx, %xmm0
movsbl 0xe0(%rax,%r12,4), %edx
cvtsi2ss %edx, %xmm2
movzbl 0xde(%rax,%r12,4), %eax
mulss (%rcx,%rax,4), %xmm0
addss %xmm2, %xmm0
callq 0x1eec3
movss 0xcbeb(%rip), %xmm1 # 0x2e00c
callq 0x1eeae
movss 0x2172a(%rip), %xmm1 # 0x42b58
jmp 0x2144d
movq 0x18(%r14), %rcx
movzbl 0xde(%rax,%r12,4), %eax
movzbl (%rcx,%rax), %eax
cvtsi2ss %eax, %xmm0
addss %xmm0, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x10(%rbx,%r12,4)
jmp 0x21487
movzbl 0xde(%rax,%r12,4), %eax
movl %eax, %ecx
shrl $0x4, %ecx
movq 0x28(%r14), %rdx
movzbl (%rdx,%rcx), %ecx
andl %eax, %ecx
testb $0xf, %cl
je 0x2147e
movl $0x3f800000, 0x10(%rbx,%r12,4) # imm = 0x3F800000
jmp 0x21487
movl $0xbf800000, 0x10(%rbx,%r12,4) # imm = 0xBF800000
incq %r12
jmp 0x213b7
leaq 0x3bf97(%rip), %rdi # 0x5d42d
leaq 0x3bab9(%rip), %rsi # 0x5cf56
leaq 0x3c19d(%rip), %rcx # 0x5d641
movl $0x4dc, %edx # imm = 0x4DC
callq 0x7340
leaq 0x3bfac(%rip), %rdi # 0x5d461
leaq 0x3ba9a(%rip), %rsi # 0x5cf56
leaq 0x3c17e(%rip), %rcx # 0x5d641
movl $0x4dd, %edx # imm = 0x4DD
callq 0x7340
leaq 0x3c19e(%rip), %rdi # 0x5d672
leaq 0x3ba7b(%rip), %rsi # 0x5cf56
leaq 0x3c15f(%rip), %rcx # 0x5d641
movl $0x4de, %edx # imm = 0x4DE
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/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.timer.offset = _glfwPlatformGetTimerValue() -
(uint64_t) (time * _glfwPlatformGetTimerFrequency());
} | pushq %r14
pushq %rbx
pushq %rax
leaq 0x4f7cb(%rip), %r14 # 0x70db8
cmpl $0x0, (%r14)
je 0x21678
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2168d
ucomisd 0x21513(%rip), %xmm0 # 0x42b20
ja 0x2168d
movsd %xmm0, (%rsp)
callq 0x2ae0f
movq %rax, %rbx
callq 0x2ae59
movq %rax, %xmm0
punpckldq 0x21532(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2153a(%rip), %xmm0 # 0x42b70
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd (%rsp), %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x214cd(%rip), %xmm1 # 0x42b28
cvttsd2si %xmm1, %rdx
andq %rcx, %rdx
orq %rax, %rdx
subq %rdx, %rbx
movq %rbx, 0x205d8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1eed8
leaq 0x3c024(%rip), %rsi # 0x5d6b8
movl $0x10004, %edi # imm = 0x10004
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1eed8
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwChooseVideoMode | const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
const GLFWvidmode* desired)
{
int i;
unsigned int sizeDiff, leastSizeDiff = UINT_MAX;
unsigned int rateDiff, leastRateDiff = UINT_MAX;
unsigned int colorDiff, leastColorDiff = UINT_MAX;
const GLFWvidmode* current;
const GLFWvidmode* closest = NULL;
if (!refreshVideoModes(monitor))
return NULL;
for (i = 0; i < monitor->modeCount; i++)
{
current = monitor->modes + i;
colorDiff = 0;
if (desired->redBits != GLFW_DONT_CARE)
colorDiff += abs(current->redBits - desired->redBits);
if (desired->greenBits != GLFW_DONT_CARE)
colorDiff += abs(current->greenBits - desired->greenBits);
if (desired->blueBits != GLFW_DONT_CARE)
colorDiff += abs(current->blueBits - desired->blueBits);
sizeDiff = abs((current->width - desired->width) *
(current->width - desired->width) +
(current->height - desired->height) *
(current->height - desired->height));
if (desired->refreshRate != GLFW_DONT_CARE)
rateDiff = abs(current->refreshRate - desired->refreshRate);
else
rateDiff = UINT_MAX - current->refreshRate;
if ((colorDiff < leastColorDiff) ||
(colorDiff == leastColorDiff && sizeDiff < leastSizeDiff) ||
(colorDiff == leastColorDiff && sizeDiff == leastSizeDiff && rateDiff < leastRateDiff))
{
closest = current;
leastSizeDiff = sizeDiff;
leastRateDiff = rateDiff;
leastColorDiff = colorDiff;
}
}
return closest;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x21af8
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x21aed
movl 0xa0(%r14), %ecx
testl %ecx, %ecx
cmovlel %eax, %ecx
imulq $0x18, %rcx, %rcx
pushq $-0x1
popq %rsi
xorl %edx, %edx
movl %esi, %edi
movl %esi, %r8d
cmpq %rdx, %rcx
je 0x21aed
movq 0x98(%r14), %r9
movl 0x8(%rbx), %r10d
cmpl $-0x1, %r10d
je 0x21a40
movl 0x8(%r9,%rdx), %r11d
subl %r10d, %r11d
movl %r11d, %r10d
negl %r10d
cmovsl %r11d, %r10d
jmp 0x21a43
xorl %r10d, %r10d
movl 0xc(%rbx), %r11d
cmpl $-0x1, %r11d
je 0x21a62
movl 0xc(%r9,%rdx), %ebp
subl %r11d, %ebp
movl %ebp, %r11d
negl %r11d
cmovsl %ebp, %r11d
addl %r11d, %r10d
movl 0x10(%rbx), %r11d
cmpl $-0x1, %r11d
je 0x21a81
movl 0x10(%r9,%rdx), %ebp
subl %r11d, %ebp
movl %ebp, %r11d
negl %r11d
cmovsl %ebp, %r11d
addl %r11d, %r10d
movl 0x14(%rbx), %r11d
movl 0x14(%r9,%rdx), %ebp
cmpl $-0x1, %r11d
je 0x21a9f
subl %r11d, %ebp
movl %ebp, %r11d
negl %r11d
cmovsl %ebp, %r11d
jmp 0x21aa4
notl %ebp
movl %ebp, %r11d
movl (%r9,%rdx), %r15d
movl 0x4(%r9,%rdx), %ebp
subl (%rbx), %r15d
subl 0x4(%rbx), %ebp
imull %r15d, %r15d
imull %ebp, %ebp
addl %r15d, %ebp
cmpl %r8d, %r10d
jb 0x21ad6
jne 0x21ac8
cmpl %esi, %ebp
jb 0x21ad6
cmpl %r8d, %r10d
jne 0x21ae4
cmpl %esi, %ebp
jne 0x21ae4
cmpl %edi, %r11d
jae 0x21ae4
addq %rdx, %r9
movl %ebp, %esi
movl %r11d, %edi
movl %r10d, %r8d
movq %r9, %rax
addq $0x18, %rdx
jmp 0x21a12
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/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), compareVideoModes);
free(monitor->modes);
monitor->modes = modes;
monitor->modeCount = modeCount;
return GLFW_TRUE;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $0x1
popq %rbx
cmpq $0x0, 0x98(%rdi)
jne 0x21b5c
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
callq 0x269ea
testq %rax, %rax
je 0x21b5a
movq %rax, %r15
movslq 0xc(%rsp), %rsi
leaq 0x3b(%rip), %rcx # 0x21b6a
pushq $0x18
popq %rdx
movq %rax, %rdi
callq 0x7a00
movq 0x98(%r14), %rdi
callq 0x7630
movq %r15, 0x98(%r14)
movl 0xc(%rsp), %eax
movl %eax, 0xa0(%r14)
jmp 0x21b5c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/monitor.c |
compareVideoModes | static int compareVideoModes(const void* fp, const void* sp)
{
const GLFWvidmode* fm = fp;
const GLFWvidmode* sm = sp;
const int fbpp = fm->redBits + fm->greenBits + fm->blueBits;
const int sbpp = sm->redBits + sm->greenBits + sm->blueBits;
const int farea = fm->width * fm->height;
const int sarea = sm->width * sm->height;
// First sort on color bits per pixel
if (fbpp != sbpp)
return fbpp - sbpp;
// Then sort on screen area
if (farea != sarea)
return farea - sarea;
// Then sort on width
if (fm->width != sm->width)
return fm->width - sm->width;
// Lastly sort on refresh rate
return fm->refreshRate - sm->refreshRate;
} | movl 0xc(%rdi), %eax
addl 0x8(%rdi), %eax
addl 0x10(%rdi), %eax
movl 0xc(%rsi), %ecx
addl 0x8(%rsi), %ecx
addl 0x10(%rsi), %ecx
subl %ecx, %eax
jne 0x21ba1
movl (%rdi), %ecx
movl (%rsi), %edx
movl 0x4(%rdi), %eax
imull %ecx, %eax
movl 0x4(%rsi), %r8d
imull %edx, %r8d
subl %r8d, %eax
jne 0x21ba1
subl %edx, %ecx
jne 0x21ba2
movl 0x14(%rdi), %eax
subl 0x14(%rsi), %eax
retq
movl %ecx, %eax
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/monitor.c |
glfwSplitBPP | void _glfwSplitBPP(int bpp, int* red, int* green, int* blue)
{
int delta;
// We assume that by 32 the user really meant 24
if (bpp == 32)
bpp = 24;
// Convert "bits per pixel" to red, green & blue sizes
*red = *green = *blue = bpp / 3;
delta = bpp - (*red * 3);
if (delta >= 1)
*green = *green + 1;
if (delta == 2)
*red = *red + 1;
} | movq %rdx, %r8
cmpl $0x20, %edi
pushq $0x18
popq %r9
cmovnel %edi, %r9d
pushq $0x3
popq %rdi
movl %r9d, %eax
cltd
idivl %edi
movl %eax, (%rcx)
movl %eax, (%r8)
movl %eax, (%rsi)
imull $-0x3, %eax, %eax
addl %r9d, %eax
testl %eax, %eax
jle 0x21bd7
incl (%r8)
cmpl $0x2, %eax
jne 0x21bd7
incl (%rsi)
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/monitor.c |
glfwGetMonitors | GLFWAPI GLFWmonitor** glfwGetMonitors(int* count)
{
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
*count = _glfw.monitorCount;
return (GLFWmonitor**) _glfw.monitors;
} | pushq %rbx
testq %rdi, %rdi
je 0x21c13
andl $0x0, (%rdi)
leaq 0x4f1d0(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x21bfe
movl 0x400(%rax), %ecx
movl %ecx, (%rdi)
movq 0x3f8(%rax), %rbx
jmp 0x21c0e
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x1eed8
movq %rbx, %rax
popq %rbx
retq
leaq 0x3b88e(%rip), %rdi # 0x5d4a8
leaq 0x3bb47(%rip), %rsi # 0x5d768
leaq 0x3bbaa(%rip), %rcx # 0x5d7d2
movl $0x12e, %edx # imm = 0x12E
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/monitor.c |
glfwGetMonitorContentScale | GLFWAPI void glfwGetMonitorContentScale(GLFWmonitor* handle,
float* xscale, float* yscale)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (xscale)
*xscale = 0.f;
if (yscale)
*yscale = 0.f;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetMonitorContentScale(monitor, xscale, yscale);
} | testq %rdi, %rdi
je 0x21dc4
testq %rsi, %rsi
je 0x21d9d
andl $0x0, (%rsi)
testq %rdx, %rdx
je 0x21da5
andl $0x0, (%rdx)
leaq 0x4f00c(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x21db6
jmp 0x26716
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1eed8
pushq %rax
leaq 0x3ba2b(%rip), %rdi # 0x5d7f7
leaq 0x3b995(%rip), %rsi # 0x5d768
leaq 0x3bae5(%rip), %rcx # 0x5d8bf
movl $0x17c, %edx # imm = 0x17C
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/monitor.c |
glfwGetInstanceProcAddress | GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance,
const char* procname)
{
GLFWvkproc proc;
assert(procname != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
return NULL;
proc = (GLFWvkproc) vkGetInstanceProcAddr(instance, procname);
#if defined(_GLFW_VULKAN_STATIC)
if (!proc)
{
if (strcmp(procname, "vkGetInstanceProcAddr") == 0)
return (GLFWvkproc) vkGetInstanceProcAddr;
}
#else
if (!proc)
proc = (GLFWvkproc) _glfw_dlsym(_glfw.vk.handle, procname);
#endif
return proc;
} | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x227ab
leaq 0x4e66d(%rip), %r15 # 0x70db8
cmpl $0x0, (%r15)
je 0x2278c
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x2
popq %rdi
callq 0x22360
testl %eax, %eax
je 0x2279f
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20618(%r15)
movq %rax, %r14
testq %rax, %rax
jne 0x227a2
movq 0x205f8(%r15), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7520
xorl %r14d, %r14d
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x1eed8
jmp 0x227a2
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2012b(%rip), %rdi # 0x428dd
leaq 0x3b9ad(%rip), %rsi # 0x5e166
leaq 0x3ba4a(%rip), %rcx # 0x5e20a
movl $0xff, %edx
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/vulkan.c |
glfwInputWindowFocus | void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused)
{
if (window->callbacks.focus)
window->callbacks.focus((GLFWwindow*) window, focused);
if (!focused)
{
int key, button;
for (key = 0; key <= GLFW_KEY_LAST; key++)
{
if (window->keys[key] == GLFW_PRESS)
{
const int scancode = _glfwPlatformGetKeyScancode(key);
_glfwInputKey(window, key, scancode, GLFW_RELEASE, 0);
}
}
for (button = 0; button <= GLFW_MOUSE_BUTTON_LAST; button++)
{
if (window->mouseButtons[button] == GLFW_PRESS)
_glfwInputMouseClick(window, button, GLFW_RELEASE, 0);
}
}
} | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x2e0(%rdi), %rax
testq %rax, %rax
je 0x229d0
movq %rbx, %rdi
movl %ebp, %esi
callq *%rax
testl %ebp, %ebp
je 0x229d9
popq %rbx
popq %r14
popq %rbp
retq
xorl %r14d, %r14d
cmpq $0x15d, %r14 # imm = 0x15D
je 0x22a0f
cmpb $0x1, 0x88(%rbx,%r14)
jne 0x22a0a
movl %r14d, %edi
callq 0x2a33d
movq %rbx, %rdi
movl %r14d, %esi
movl %eax, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1f4e8
incq %r14
jmp 0x229dc
xorl %r14d, %r14d
cmpq $0x8, %r14
je 0x229d4
cmpb $0x1, 0x80(%rbx,%r14)
jne 0x22a32
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1f5cd
incq %r14
jmp 0x22a12
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwWindowHintString | GLFWAPI void glfwWindowHintString(int hint, const char* value)
{
assert(value != NULL);
_GLFW_REQUIRE_INIT();
switch (hint)
{
case GLFW_COCOA_FRAME_NAME:
strncpy(_glfw.hints.window.ns.frameName, value,
sizeof(_glfw.hints.window.ns.frameName) - 1);
return;
case GLFW_X11_CLASS_NAME:
strncpy(_glfw.hints.window.x11.className, value,
sizeof(_glfw.hints.window.x11.className) - 1);
return;
case GLFW_X11_INSTANCE_NAME:
strncpy(_glfw.hints.window.x11.instanceName, value,
sizeof(_glfw.hints.window.x11.instanceName) - 1);
return;
}
_glfwInputError(GLFW_INVALID_ENUM, "Invalid window hint string 0x%08X", hint);
} | testq %rsi, %rsi
je 0x230d1
leaq 0x4dd4b(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x23093
movl %edi, %edx
cmpl $0x24002, %edi # imm = 0x24002
je 0x230a8
cmpl $0x24001, %edx # imm = 0x24001
je 0x230a1
cmpl $0x23002, %edx # imm = 0x23002
jne 0x230be
movl $0x9c, %edi
jmp 0x230ad
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1eed8
movl $0x19c, %edi # imm = 0x19C
jmp 0x230ad
movl $0x29c, %edi # imm = 0x29C
addq 0x45f24(%rip), %rdi # 0x68fd8
movl $0xff, %edx
jmp 0x72a0
leaq 0x3b5bf(%rip), %rsi # 0x5e684
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
jmp 0x1eed8
pushq %rax
leaq 0x3b570(%rip), %rdi # 0x5e649
leaq 0x3b462(%rip), %rsi # 0x5e542
leaq 0x3b570(%rip), %rcx # 0x5e657
movl $0x1a4, %edx # imm = 0x1A4
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwSetWindowPos | GLFWAPI void glfwSetWindowPos(GLFWwindow* handle, int xpos, int ypos)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformSetWindowPos(window, xpos, ypos);
} | testq %rdi, %rdi
je 0x232fc
leaq 0x4dadb(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x232ee
cmpq $0x0, 0x48(%rdi)
je 0x27faf
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1eed8
pushq %rax
leaq 0x1f3e0(%rip), %rdi # 0x426e4
leaq 0x3b237(%rip), %rsi # 0x5e542
leaq 0x3b4b8(%rip), %rcx # 0x5e7ca
movl $0x215, %edx # imm = 0x215
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwGetWindowSize | GLFWAPI void glfwGetWindowSize(GLFWwindow* handle, int* width, int* height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (width)
*width = 0;
if (height)
*height = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetWindowSize(window, width, height);
} | testq %rdi, %rdi
je 0x23350
testq %rsi, %rsi
je 0x23329
andl $0x0, (%rsi)
testq %rdx, %rdx
je 0x23331
andl $0x0, (%rdx)
leaq 0x4da80(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x23342
jmp 0x28098
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1eed8
pushq %rax
leaq 0x1f38c(%rip), %rdi # 0x426e4
leaq 0x3b1e3(%rip), %rsi # 0x5e542
leaq 0x3b492(%rip), %rcx # 0x5e7f8
movl $0x222, %edx # imm = 0x222
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwMaximizeWindow | GLFWAPI void glfwMaximizeWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformMaximizeWindow(window);
} | testq %rdi, %rdi
je 0x238b8
leaq 0x4d51f(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x238aa
cmpq $0x0, 0x48(%rdi)
je 0x286c3
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1eed8
pushq %rax
leaq 0x1ee24(%rip), %rdi # 0x426e4
leaq 0x3ac7b(%rip), %rsi # 0x5e542
leaq 0x3b227(%rip), %rcx # 0x5eaf5
movl $0x2e8, %edx # imm = 0x2E8
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/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);
if (window->focusOnShow)
_glfwPlatformFocusWindow(window);
} | pushq %rbx
testq %rdi, %rdi
je 0x2391c
leaq 0x4d4d3(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x238f6
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x23905
popq %rbx
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rbx
jmp 0x1eed8
movq %rbx, %rdi
callq 0x27930
cmpl $0x0, 0x18(%rbx)
je 0x238f4
movq %rbx, %rdi
popq %rbx
jmp 0x2884c
leaq 0x1edc1(%rip), %rdi # 0x426e4
leaq 0x3ac18(%rip), %rsi # 0x5e542
leaq 0x3b1ea(%rip), %rcx # 0x5eb1b
movl $0x2f5, %edx # imm = 0x2F5
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/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:
return _glfwPlatformWindowIconified(window);
case GLFW_VISIBLE:
return _glfwPlatformWindowVisible(window);
case GLFW_MAXIMIZED:
return _glfwPlatformWindowMaximized(window);
case GLFW_HOVERED:
return _glfwPlatformWindowHovered(window);
case GLFW_FOCUS_ON_SHOW:
return window->focusOnShow;
case GLFW_TRANSPARENT_FRAMEBUFFER:
return _glfwPlatformFramebufferTransparent(window);
case GLFW_RESIZABLE:
return window->resizable;
case GLFW_DECORATED:
return window->decorated;
case GLFW_FLOATING:
return window->floating;
case GLFW_AUTO_ICONIFY:
return window->autoIconify;
case GLFW_CLIENT_API:
return window->context.client;
case GLFW_CONTEXT_CREATION_API:
return window->context.source;
case GLFW_CONTEXT_VERSION_MAJOR:
return window->context.major;
case GLFW_CONTEXT_VERSION_MINOR:
return window->context.minor;
case GLFW_CONTEXT_REVISION:
return window->context.revision;
case GLFW_CONTEXT_ROBUSTNESS:
return window->context.robustness;
case GLFW_OPENGL_FORWARD_COMPAT:
return window->context.forward;
case GLFW_OPENGL_DEBUG_CONTEXT:
return window->context.debug;
case GLFW_OPENGL_PROFILE:
return window->context.profile;
case GLFW_CONTEXT_RELEASE_BEHAVIOR:
return window->context.release;
case GLFW_CONTEXT_NO_ERROR:
return window->context.noerror;
}
_glfwInputError(GLFW_INVALID_ENUM, "Invalid window attribute 0x%08X", attrib);
return 0;
} | pushq %rbx
testq %rdi, %rdi
je 0x23b31
leaq 0x4d399(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x23a54
movl %esi, %edx
leal -0x20001(%rdx), %eax
cmpl $0xb, %eax
jbe 0x23a68
leal -0x22001(%rdx), %eax
cmpl $0xa, %eax
ja 0x23a7e
leaq 0x3aa9d(%rip), %rcx # 0x5e4e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x200(%rdi), %ebx
jmp 0x23a64
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x1eed8
movl %ebx, %eax
popq %rbx
retq
leaq 0x3aa41(%rip), %rcx # 0x5e4b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
popq %rbx
jmp 0x28b8b
leaq 0x3b156(%rip), %rsi # 0x5ebdb
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x1eed8
jmp 0x23a64
popq %rbx
jmp 0x28ca1
popq %rbx
jmp 0x28d66
popq %rbx
jmp 0x28c1b
movl 0x8(%rdi), %ebx
jmp 0x23a64
movl 0x14(%rdi), %ebx
jmp 0x23a64
movl 0xc(%rdi), %ebx
jmp 0x23a64
movl 0x18(%rdi), %ebx
jmp 0x23a64
popq %rbx
jmp 0x28645
popq %rbx
jmp 0x28059
movl 0x10(%rdi), %ebx
jmp 0x23a64
movl 0x224(%rdi), %ebx
jmp 0x23a64
movl 0x21c(%rdi), %ebx
jmp 0x23a64
movl 0x20c(%rdi), %ebx
jmp 0x23a64
movl 0x210(%rdi), %ebx
jmp 0x23a64
movl 0x220(%rdi), %ebx
jmp 0x23a64
movl 0x208(%rdi), %ebx
jmp 0x23a64
movl 0x214(%rdi), %ebx
jmp 0x23a64
movl 0x218(%rdi), %ebx
jmp 0x23a64
movl 0x204(%rdi), %ebx
jmp 0x23a64
movl 0x228(%rdi), %ebx
jmp 0x23a64
leaq 0x1ebac(%rip), %rdi # 0x426e4
leaq 0x3aa03(%rip), %rsi # 0x5e542
leaq 0x3b06a(%rip), %rcx # 0x5ebb0
movl $0x326, %edx # imm = 0x326
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwWaitEventsTimeout | GLFWAPI void glfwWaitEventsTimeout(double timeout)
{
_GLFW_REQUIRE_INIT();
assert(timeout == timeout);
assert(timeout >= 0.0);
assert(timeout <= DBL_MAX);
if (timeout != timeout || timeout < 0.0 || timeout > DBL_MAX)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", timeout);
return;
}
_glfwPlatformWaitEventsTimeout(timeout);
} | pushq %rax
leaq 0x4cc8d(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x2416c
ucomisd %xmm0, %xmm0
jp 0x24181
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x241a0
movsd 0x1e9c8(%rip), %xmm1 # 0x42b10
ucomisd %xmm0, %xmm1
jb 0x241bf
ucomisd 0x1e9ba(%rip), %xmm0 # 0x42b10
jbe 0x2417b
leaq 0x39559(%rip), %rsi # 0x5d6b8
movl $0x10004, %edi # imm = 0x10004
movb $0x1, %al
popq %rcx
jmp 0x1eed8
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rcx
jmp 0x1eed8
popq %rax
jmp 0x2a019
leaq 0x3ae9a(%rip), %rdi # 0x5f022
leaq 0x3a3b3(%rip), %rsi # 0x5e542
leaq 0x3ae9f(%rip), %rcx # 0x5f035
movl $0x43e, %edx # imm = 0x43E
callq 0x7340
leaq 0x3aeb1(%rip), %rdi # 0x5f058
leaq 0x3a394(%rip), %rsi # 0x5e542
leaq 0x3ae80(%rip), %rcx # 0x5f035
movl $0x43f, %edx # imm = 0x43F
callq 0x7340
leaq 0x3aea1(%rip), %rdi # 0x5f067
leaq 0x3a375(%rip), %rsi # 0x5e542
leaq 0x3ae61(%rip), %rcx # 0x5f035
movl $0x440, %edx # imm = 0x440
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwPlatformTerminate | void _glfwPlatformTerminate(void)
{
if (_glfw.x11.helperWindowHandle)
{
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) ==
_glfw.x11.helperWindowHandle)
{
_glfwPushSelectionToManagerX11();
}
XDestroyWindow(_glfw.x11.display, _glfw.x11.helperWindowHandle);
_glfw.x11.helperWindowHandle = None;
}
if (_glfw.x11.hiddenCursorHandle)
{
XFreeCursor(_glfw.x11.display, _glfw.x11.hiddenCursorHandle);
_glfw.x11.hiddenCursorHandle = (Cursor) 0;
}
free(_glfw.x11.primarySelectionString);
free(_glfw.x11.clipboardString);
if (_glfw.x11.im)
{
XCloseIM(_glfw.x11.im);
_glfw.x11.im = NULL;
}
if (_glfw.x11.display)
{
XCloseDisplay(_glfw.x11.display);
_glfw.x11.display = NULL;
}
if (_glfw.x11.x11xcb.handle)
{
_glfw_dlclose(_glfw.x11.x11xcb.handle);
_glfw.x11.x11xcb.handle = NULL;
}
if (_glfw.x11.xcursor.handle)
{
_glfw_dlclose(_glfw.x11.xcursor.handle);
_glfw.x11.xcursor.handle = NULL;
}
if (_glfw.x11.randr.handle)
{
_glfw_dlclose(_glfw.x11.randr.handle);
_glfw.x11.randr.handle = NULL;
}
if (_glfw.x11.xinerama.handle)
{
_glfw_dlclose(_glfw.x11.xinerama.handle);
_glfw.x11.xinerama.handle = NULL;
}
if (_glfw.x11.xrender.handle)
{
_glfw_dlclose(_glfw.x11.xrender.handle);
_glfw.x11.xrender.handle = NULL;
}
if (_glfw.x11.vidmode.handle)
{
_glfw_dlclose(_glfw.x11.vidmode.handle);
_glfw.x11.vidmode.handle = NULL;
}
if (_glfw.x11.xi.handle)
{
_glfw_dlclose(_glfw.x11.xi.handle);
_glfw.x11.xi.handle = NULL;
}
// NOTE: These need to be unloaded after XCloseDisplay, as they register
// cleanup callbacks that get called by that function
_glfwTerminateEGL();
_glfwTerminateGLX();
#if defined(__linux__)
_glfwTerminateJoysticksLinux();
#endif
if (_glfw.x11.emptyEventPipe[0] || _glfw.x11.emptyEventPipe[1])
{
close(_glfw.x11.emptyEventPipe[0]);
close(_glfw.x11.emptyEventPipe[1]);
}
} | pushq %rbx
leaq 0x4b0ec(%rip), %rbx # 0x70db8
cmpq $0x0, 0x20660(%rbx)
je 0x25d15
movq 0x20640(%rbx), %rdi
movq 0x21390(%rbx), %rsi
callq 0x79f0
movq 0x20660(%rbx), %rsi
cmpq %rsi, %rax
jne 0x25d01
callq 0x26ed4
movq 0x20660(%rbx), %rsi
movq 0x20640(%rbx), %rdi
callq 0x7880
andq $0x0, 0x20660(%rbx)
movq 0x20668(%rbx), %rsi
testq %rsi, %rsi
je 0x25d35
movq 0x20640(%rbx), %rdi
callq 0x7580
andq $0x0, 0x20668(%rbx)
movq 0x20688(%rbx), %rdi
callq 0x7630
movq 0x20690(%rbx), %rdi
callq 0x7630
movq 0x20678(%rbx), %rdi
testq %rdi, %rdi
je 0x25d66
callq 0x7570
andq $0x0, 0x20678(%rbx)
movq 0x20640(%rbx), %rdi
testq %rdi, %rdi
je 0x25d7f
callq 0x7a10
andq $0x0, 0x20640(%rbx)
movq 0x21528(%rbx), %rdi
testq %rdi, %rdi
je 0x25d98
callq 0x73d0
andq $0x0, 0x21528(%rbx)
movq 0x214d8(%rbx), %rdi
testq %rdi, %rdi
je 0x25db1
callq 0x73d0
andq $0x0, 0x214d8(%rbx)
movq 0x213e0(%rbx), %rdi
testq %rdi, %rdi
je 0x25dca
callq 0x73d0
andq $0x0, 0x213e0(%rbx)
movq 0x21500(%rbx), %rdi
testq %rdi, %rdi
je 0x25de3
callq 0x73d0
andq $0x0, 0x21500(%rbx)
movq 0x215b0(%rbx), %rdi
testq %rdi, %rdi
je 0x25dfc
callq 0x73d0
andq $0x0, 0x215b0(%rbx)
movq 0x21540(%rbx), %rdi
testq %rdi, %rdi
je 0x25e15
callq 0x73d0
andq $0x0, 0x21540(%rbx)
movq 0x21578(%rbx), %rdi
testq %rdi, %rdi
je 0x25e2e
callq 0x73d0
andq $0x0, 0x21578(%rbx)
callq 0x2c2dd
callq 0x2b559
callq 0x2dac7
movl 0x21240(%rbx), %edi
movl 0x21244(%rbx), %eax
orl %edi, %eax
je 0x25e5e
callq 0x7a50
movl 0x21244(%rbx), %edi
popq %rbx
jmp 0x7a50
popq %rbx
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_init.c |
glfwPlatformGetVideoMode | void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
if (ci)
{
const XRRModeInfo* mi = getModeInfo(sr, ci->mode);
if (mi) // mi can be NULL if the monitor has been disconnected
*mode = vidmodeFromModeInfo(mi, ci);
XRRFreeCrtcInfo(ci);
}
XRRFreeScreenResources(sr);
}
else
{
mode->width = DisplayWidth(_glfw.x11.display, _glfw.x11.screen);
mode->height = DisplayHeight(_glfw.x11.display, _glfw.x11.screen);
mode->refreshRate = 0;
_glfwSplitBPP(DefaultDepth(_glfw.x11.display, _glfw.x11.screen),
&mode->redBits, &mode->greenBits, &mode->blueBits);
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0x4aa0e(%rip), %r13 # 0x70db8
cmpl $0x0, 0x213d8(%r13)
je 0x26458
cmpl $0x0, 0x213fc(%r13)
jne 0x26458
movq %rdi, %r15
movq 0x20640(%r13), %rdi
movq 0x20650(%r13), %rsi
callq *0x21450(%r13)
movq %rax, %r14
movq 0x20640(%r13), %rdi
movq 0x108(%r15), %rdx
movq %rax, %rsi
callq *0x21438(%r13)
testq %rax, %rax
je 0x26440
movq %rax, %r15
movq 0x18(%rax), %rsi
movq %r14, %rdi
callq 0x264a2
testq %rax, %rax
je 0x26436
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x264d1
movq 0x10(%r12), %rax
movq %rax, 0x10(%rbx)
movups (%r12), %xmm0
movups %xmm0, (%rbx)
movq %r15, %rdi
callq *0x21408(%r13)
movq %r14, %rdi
callq *0x21420(%r13)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x20640(%r13), %rax
movq 0xe8(%rax), %rax
movslq 0x20648(%r13), %rcx
shlq $0x7, %rcx
movq 0x18(%rax,%rcx), %rdx
movq %rdx, (%rbx)
andl $0x0, 0x14(%rbx)
movl 0x38(%rax,%rcx), %edi
leaq 0x8(%rbx), %rsi
leaq 0xc(%rbx), %rdx
addq $0x10, %rbx
movq %rbx, %rcx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21ba5
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_monitor.c |
vidmodeFromModeInfo | static GLFWvidmode vidmodeFromModeInfo(const XRRModeInfo* mi,
const XRRCrtcInfo* ci)
{
GLFWvidmode mode;
if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
{
mode.width = mi->height;
mode.height = mi->width;
}
else
{
mode.width = mi->width;
mode.height = mi->height;
}
mode.refreshRate = calculateRefreshRate(mi);
_glfwSplitBPP(DefaultDepth(_glfw.x11.display, _glfw.x11.screen),
&mode.redBits, &mode.greenBits, &mode.blueBits);
return mode;
} | pushq %rbx
movq %rdi, %rbx
movzwl 0x20(%rdx), %eax
cmpl $0x8, %eax
je 0x264e3
cmpl $0x2, %eax
jne 0x264eb
leaq 0xc(%rsi), %rax
pushq $0x8
jmp 0x264f1
leaq 0x8(%rsi), %rax
pushq $0xc
popq %rcx
movl (%rax), %eax
movl %eax, (%rbx)
movl (%rsi,%rcx), %eax
movl %eax, 0x4(%rbx)
movl 0x20(%rsi), %eax
xorl %edx, %edx
testl %eax, %eax
je 0x2654b
movl 0x30(%rsi), %ecx
testl %ecx, %ecx
je 0x2654b
movsd 0x10(%rsi), %xmm1
unpcklps 0x1c648(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1c650(%rip), %xmm1 # 0x42b70
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movl %eax, %eax
cvtsi2sd %rax, %xmm1
movl %ecx, %eax
cvtsi2sd %rax, %xmm2
mulsd %xmm1, %xmm2
divsd %xmm2, %xmm0
callq 0x7220
cvttsd2si %xmm0, %edx
movl %edx, 0x14(%rbx)
leaq 0x4a863(%rip), %rax # 0x70db8
movq 0x20640(%rax), %rcx
movq 0xe8(%rcx), %rcx
movslq 0x20648(%rax), %rax
shlq $0x7, %rax
movl 0x38(%rcx,%rax), %edi
leaq 0x8(%rbx), %rsi
leaq 0xc(%rbx), %rdx
movq %rbx, %rcx
addq $0x10, %rcx
callq 0x21ba5
movq %rbx, %rax
popq %rbx
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_monitor.c |
glfwRestoreVideoModeX11 | void _glfwRestoreVideoModeX11(_GLFWmonitor* monitor)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
if (monitor->x11.oldMode == None)
return;
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
XRRSetCrtcConfig(_glfw.x11.display,
sr, monitor->x11.crtc,
CurrentTime,
ci->x, ci->y,
monitor->x11.oldMode,
ci->rotation,
ci->outputs,
ci->noutput);
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
monitor->x11.oldMode = None;
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x4a81e(%rip), %r12 # 0x70db8
cmpl $0x0, 0x213d8(%r12)
je 0x2665c
cmpl $0x0, 0x213fc(%r12)
jne 0x2665c
movq %rdi, %rbx
cmpq $0x0, 0x110(%rdi)
je 0x2665c
movq 0x20640(%r12), %rdi
movq 0x20650(%r12), %rsi
callq *0x21450(%r12)
movq %rax, %r14
movq 0x20640(%r12), %rdi
movq 0x108(%rbx), %rdx
movq %rax, %rsi
callq *0x21438(%r12)
movq %rax, %r15
movq 0x20640(%r12), %rdi
movl 0x8(%rax), %r8d
movl 0xc(%rax), %r9d
movq 0x108(%rbx), %rdx
movzwl 0x20(%rax), %eax
movl 0x24(%r15), %r10d
movq %r14, %rsi
xorl %ecx, %ecx
pushq %r10
pushq 0x28(%r15)
pushq %rax
pushq 0x110(%rbx)
callq *0x21470(%r12)
addq $0x20, %rsp
movq %r15, %rdi
callq *0x21408(%r12)
movq %r14, %rdi
callq *0x21420(%r12)
andq $0x0, 0x110(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_monitor.c |
handleSelectionRequest | static void handleSelectionRequest(XEvent* event)
{
const XSelectionRequestEvent* request = &event->xselectionrequest;
XEvent reply = { SelectionNotify };
reply.xselection.property = writeTargetToProperty(request);
reply.xselection.display = request->display;
reply.xselection.requestor = request->requestor;
reply.xselection.selection = request->selection;
reply.xselection.target = request->target;
reply.xselection.time = request->time;
XSendEvent(_glfw.x11.display, request->requestor, False, 0, &reply);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %rbp
leaq 0x48(%rsp), %r14
xorl %ebx, %ebx
movl $0xc0, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x72c0
movl $0x1f, (%r14)
leaq 0x49dd6(%rip), %r14 # 0x70db8
movq 0x30(%rbp), %rcx
movq 0x40(%rbp), %r15
xorl %eax, %eax
cmpq 0x21398(%r14), %rcx
setne %cl
testq %r15, %r15
je 0x2714f
movq 0x213b8(%r14), %r13
movq 0x38(%rbp), %r12
cmpq 0x21378(%r14), %r12
jne 0x27059
leaq 0x20(%rsp), %rax
movq %r12, (%rax)
movq 0x21380(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %r13, 0x10(%rax)
movq $0x1f, 0x18(%rax)
movq 0x20640(%r14), %rdi
movq 0x28(%rbp), %rsi
pushq $0x4
popq %rcx
pushq $0x20
popq %r8
movq %r15, %rdx
xorl %r9d, %r9d
pushq $0x4
pushq %rax
callq 0x7460
popq %rcx
popq %rdx
jmp 0x2714b
movb %cl, %al
movq 0x20688(%r14,%rax,8), %rax
movq %rax, (%rsp)
cmpq 0x21380(%r14), %r12
jne 0x2719f
movq 0x28(%rbp), %rdi
movq 0x213c8(%r14), %rdx
leaq 0x20(%rsp), %rcx
movq %r15, %rsi
callq 0x26e38
xorl %ebx, %ebx
movq %r13, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq (%rsp), %r15
cmpq %rax, %rbx
jae 0x27118
movq 0x20(%rsp), %rsi
movq (%rsi,%rbx,8), %r12
cmpq %r13, %r12
setne %cl
cmpq $0x1f, %r12
setne %dl
testb %dl, %cl
jne 0x2710c
movq 0x20640(%r14), %r13
movq 0x28(%rbp), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rsi,%rbx,8), %r14
movq %r15, %rdi
callq 0x7240
movq %r13, %rdi
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %rsi
movq %r14, %rdx
leaq 0x49cc9(%rip), %r14 # 0x70db8
movq %r12, %rcx
pushq $0x8
popq %r8
xorl %r9d, %r9d
pushq %rax
pushq %r15
callq 0x7460
movq 0x18(%rsp), %rax
addq $0x10, %rsp
jmp 0x27112
andq $0x0, 0x8(%rsi,%rbx,8)
addq $0x2, %rbx
jmp 0x2709c
movq 0x20640(%r14), %rdi
movq 0x28(%rbp), %rsi
movq 0x40(%rbp), %rdx
movq 0x213c8(%r14), %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq %rax
pushq 0x28(%rsp)
callq 0x7460
popq %rcx
popq %rdx
movq 0x20(%rsp), %rdi
callq 0x7680
movq 0x40(%rbp), %rbx
leaq 0x48(%rsp), %r8
movq %rbx, 0x38(%r8)
movq 0x18(%rbp), %rax
movq %rax, 0x18(%r8)
movq 0x28(%rbp), %rsi
movups 0x28(%rbp), %xmm0
movups %xmm0, 0x20(%r8)
movq 0x38(%rbp), %rax
movq %rax, 0x30(%r8)
movq 0x48(%rbp), %rax
movq %rax, 0x40(%r8)
movq 0x20640(%r14), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x7100
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq 0x213a8(%r14), %r12
jne 0x271d7
movq 0x20640(%r14), %rdi
movq 0x28(%rbp), %rsi
movq 0x213b0(%r14), %rcx
subq $0x10, %rsp
andl $0x0, 0x8(%rsp)
andq $0x0, (%rsp)
pushq $0x20
popq %r8
movq %r15, %rdx
xorl %r9d, %r9d
jmp 0x2704d
cmpq %r13, %r12
sete %al
cmpq $0x1f, %r12
sete %cl
orb %al, %cl
je 0x27227
leaq 0x49bc9(%rip), %rax # 0x70db8
movq 0x20640(%rax), %r14
movq 0x28(%rbp), %r13
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x7240
pushq $0x8
popq %r8
movq %r14, %rdi
leaq 0x49ba4(%rip), %r14 # 0x70db8
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r9d, %r9d
pushq %rax
pushq %rbx
jmp 0x2704d
xorl %ebx, %ebx
jmp 0x2714f
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
handleSelectionClear | static void handleSelectionClear(XEvent* event)
{
if (event->xselectionclear.selection == _glfw.x11.PRIMARY)
{
free(_glfw.x11.primarySelectionString);
_glfw.x11.primarySelectionString = NULL;
}
else
{
free(_glfw.x11.clipboardString);
_glfw.x11.clipboardString = NULL;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
leaq 0x49b7b(%rip), %rbx # 0x70db8
xorl %r14d, %r14d
cmpq 0x21398(%rbx), %rax
setne %r14b
movq 0x20688(%rbx,%r14,8), %rdi
callq 0x7630
andq $0x0, 0x20688(%rbx,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformCreateWindow | int _glfwPlatformCreateWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
Visual* visual = NULL;
int depth;
if (ctxconfig->client != GLFW_NO_API)
{
if (ctxconfig->source == GLFW_NATIVE_CONTEXT_API)
{
if (!_glfwInitGLX())
return GLFW_FALSE;
if (!_glfwChooseVisualGLX(wndconfig, ctxconfig, fbconfig, &visual, &depth))
return GLFW_FALSE;
}
else if (ctxconfig->source == GLFW_EGL_CONTEXT_API)
{
if (!_glfwInitEGL())
return GLFW_FALSE;
if (!_glfwChooseVisualEGL(wndconfig, ctxconfig, fbconfig, &visual, &depth))
return GLFW_FALSE;
}
else if (ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
{
if (!_glfwInitOSMesa())
return GLFW_FALSE;
}
}
if (!visual)
{
visual = DefaultVisual(_glfw.x11.display, _glfw.x11.screen);
depth = DefaultDepth(_glfw.x11.display, _glfw.x11.screen);
}
if (!createNativeWindow(window, wndconfig, visual, depth))
return GLFW_FALSE;
if (ctxconfig->client != GLFW_NO_API)
{
if (ctxconfig->source == GLFW_NATIVE_CONTEXT_API)
{
if (!_glfwCreateContextGLX(window, ctxconfig, fbconfig))
return GLFW_FALSE;
}
else if (ctxconfig->source == GLFW_EGL_CONTEXT_API)
{
if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig))
return GLFW_FALSE;
}
else if (ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
{
if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig))
return GLFW_FALSE;
}
}
if (window->monitor)
{
_glfwPlatformShowWindow(window);
updateWindowMode(window);
acquireMonitor(window);
}
XFlush(_glfw.x11.display);
return GLFW_TRUE;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r15
movq %rdx, %r13
andq $0x0, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
cmpl $0x0, (%rdx)
je 0x27396
movl 0x4(%r13), %eax
cmpl $0x36003, %eax # imm = 0x36003
je 0x27373
cmpl $0x36002, %eax # imm = 0x36002
je 0x27343
cmpl $0x36001, %eax # imm = 0x36001
jne 0x27380
callq 0x2b018
xorl %ebp, %ebp
testl %eax, %eax
je 0x2791c
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %r8
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2bd7c
jmp 0x2736a
callq 0x2bea8
xorl %ebp, %ebp
testl %eax, %eax
je 0x2791c
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %r8
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2cc4e
testl %eax, %eax
jne 0x27380
jmp 0x2791c
callq 0x2ce00
testl %eax, %eax
je 0x2791a
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x27396
movq %r15, 0x10(%rsp)
movl 0x4(%rsp), %r15d
jmp 0x273cf
movq %r15, 0x10(%rsp)
leaq 0x49a16(%rip), %rax # 0x70db8
movq 0x20640(%rax), %rcx
movq 0xe8(%rcx), %rcx
movslq 0x20648(%rax), %rax
shlq $0x7, %rax
movq 0x40(%rcx,%rax), %r14
movq %r14, 0x8(%rsp)
movl 0x38(%rcx,%rax), %r15d
movl %r15d, 0x4(%rsp)
movsd (%r12), %xmm0
cmpl $0x0, 0x34(%r12)
leaq 0x499d6(%rip), %rbp # 0x70db8
movq %r13, 0x38(%rsp)
je 0x273fb
cvtdq2ps %xmm0, %xmm0
movsd 0x20658(%rbp), %xmm1
mulps %xmm0, %xmm1
cvttps2dq %xmm1, %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x20640(%rbp), %rdi
movq 0x20650(%rbp), %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x7330
movq %rax, 0x348(%rbx)
movq %r14, %rdi
callq 0x26e9e
movl %eax, 0x374(%rbx)
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r13
movaps %xmm0, 0x60(%r13)
movaps %xmm0, 0x50(%r13)
movaps %xmm0, 0x40(%r13)
movaps %xmm0, 0x30(%r13)
movaps %xmm0, 0x20(%r13)
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
movq 0x348(%rbx), %rax
movq %rax, 0x60(%r13)
movq $0x63807f, 0x48(%r13) # imm = 0x63807F
callq 0x241fc
movq 0x20650(%rbp), %rsi
movq %rsi, 0x358(%rbx)
movq 0x20640(%rbp), %rdi
movdqa 0x40(%rsp), %xmm0
movd %xmm0, %r8d
pshufd $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movd %xmm0, %r9d
xorl %edx, %edx
xorl %ecx, %ecx
movl %r8d, 0x40(%rsp)
movl %r9d, 0x1c(%rsp)
pushq %r13
pushq $0x2808 # imm = 0x2808
pushq %r14
pushq $0x1
pushq %r15
pushq $0x0
callq 0x7830
addq $0x30, %rsp
movq %rax, 0x350(%rbx)
callq 0x24233
movq 0x350(%rbx), %rsi
testq %rsi, %rsi
je 0x2758c
movq 0x20640(%rbp), %rdi
movl 0x20670(%rbp), %edx
movq %rbx, %rcx
callq 0x7440
cmpl $0x0, 0x18(%r12)
jne 0x27503
movq %rbx, %rdi
xorl %esi, %esi
callq 0x289e5
movq 0x212a8(%rbp), %rdx
testq %rdx, %rdx
je 0x275d0
cmpq $0x0, 0x48(%rbx)
jne 0x275d0
cmpl $0x0, 0x24(%r12)
sete %dil
movq 0x212b0(%rbp), %rsi
testq %rsi, %rsi
sete %cl
xorl %eax, %eax
orb %dil, %cl
jne 0x27544
pushq $0x1
popq %rax
movq %rsi, 0x20(%rsp)
cmpl $0x0, 0x28(%r12)
je 0x275a2
movq 0x212c0(%rbp), %rdi
movq 0x212c8(%rbp), %rsi
testq %rdi, %rdi
setne %r8b
testq %rsi, %rsi
setne %r9b
andb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x275a2
movl %eax, %ecx
movq %rdi, 0x20(%rsp,%rcx,8)
orl $0x2, %eax
movq %rsi, 0x28(%rsp,%rcx,8)
movl $0x1, 0x370(%rbx)
jmp 0x275a9
leaq 0x38d09(%rip), %rsi # 0x6029c
movl $0x10008, %edi # imm = 0x10008
callq 0x24251
jmp 0x2791a
testb %cl, %cl
jne 0x275d0
pushq $0x1
popq %rax
movq 0x20640(%rbp), %rdi
movq 0x350(%rbx), %rsi
leaq 0x20(%rsp), %r10
pushq $0x4
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq %rax
pushq %r10
callq 0x7460
popq %rcx
popq %rdx
movq 0x21268(%rbp), %rax
leaq 0x20(%rsp), %r14
movq %rax, (%r14)
movq 0x21290(%rbp), %rax
movq %rax, 0x8(%r14)
movq 0x20640(%rbp), %rdi
movq 0x350(%rbx), %rsi
pushq $0x2
popq %rcx
movq %r14, %rdx
callq 0x72d0
callq 0x7750
cltq
movq %rax, (%r14)
movq 0x20640(%rbp), %rdi
movq 0x350(%rbx), %rsi
movq 0x21288(%rbp), %rdx
pushq $0x6
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq $0x1
pushq %r14
callq 0x7460
popq %rcx
popq %rdx
movq 0x21298(%rbp), %rdx
movq 0x212a0(%rbp), %rax
testq %rdx, %rdx
setne %cl
testq %rax, %rax
setne %sil
andb %cl, %sil
cmpb $0x1, %sil
jne 0x27683
movq %rax, 0x20(%rsp)
movq 0x20640(%rbp), %rdi
movq 0x350(%rbx), %rsi
pushq $0x4
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq $0x1
pushq %r14
callq 0x7460
popq %rcx
popq %rdx
callq 0x73c0
testq %rax, %rax
je 0x2772d
movq %rax, %r15
movq $0x2, (%rax)
movl $0x1, 0xc(%rax)
movq 0x20640(%rbp), %rdi
movq 0x350(%rbx), %rsi
movq %rax, %rdx
callq 0x7230
movq %r15, %rdi
callq 0x7680
movq %rbx, %rdi
movl 0x40(%rsp), %esi
movl 0x1c(%rsp), %edx
callq 0x28159
callq 0x77c0
movq %rax, %r13
cmpb $0x0, 0x23c(%r12)
je 0x27707
leaq 0x13c(%r12), %rax
cmpb $0x0, (%rax)
je 0x27707
leaq 0x23c(%r12), %rcx
movq %rcx, (%r13)
movq %rax, 0x8(%r13)
movq 0x10(%rsp), %r15
jmp 0x27770
leaq 0x38bcc(%rip), %rdi # 0x602da
callq 0x7650
testq %rax, %rax
movq 0x10(%rsp), %r15
je 0x27745
cmpb $0x0, (%rax)
je 0x27745
movq %rax, (%r13)
movq 0x8(%r12), %rax
jmp 0x27760
leaq 0x38b85(%rip), %rsi # 0x602b9
movl $0x10005, %edi # imm = 0x10005
xorl %eax, %eax
callq 0x1eed8
jmp 0x2791a
movq 0x8(%r12), %rax
cmpb $0x0, (%rax)
je 0x27755
movq %rax, (%r13)
jmp 0x27760
leaq 0x38b8c(%rip), %rcx # 0x602e8
movq %rcx, (%r13)
cmpb $0x0, (%rax)
jne 0x2776c
leaq 0x38b8d(%rip), %rax # 0x602f9
movq %rax, 0x8(%r13)
movq 0x20640(%rbp), %rdi
movq 0x350(%rbx), %rsi
movq %r13, %rdx
callq 0x7300
movq %r13, %rdi
callq 0x7680
movq $0x5, 0x20(%rsp)
movq 0x20640(%rbp), %rdi
movq 0x350(%rbx), %rsi
movq 0x21328(%rbp), %rdx
pushq $0x4
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq $0x1
pushq %r14
callq 0x7460
popq %rcx
popq %rdx
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x27d0b
movq 0x20678(%rbp), %rdi
testq %rdi, %rdi
je 0x2781b
movq 0x350(%rbx), %r8
subq $0x10, %rsp
andq $0x0, 0x8(%rsp)
movq %r8, (%rsp)
leaq 0x38b14(%rip), %rsi # 0x6030a
leaq 0x38b18(%rip), %rcx # 0x60315
leaq 0x38b1e(%rip), %r9 # 0x60322
movl $0x408, %edx # imm = 0x408
xorl %eax, %eax
callq 0x74b0
popq %rcx
popq %rdx
movq %rax, 0x360(%rbx)
jmp 0x27822
movq 0x360(%rbx), %rax
movq 0x38(%rsp), %r14
testq %rax, %rax
je 0x2786d
leaq 0x20(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x38af2(%rip), %rsi # 0x6032e
movq %rax, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x7960
testq %rax, %rax
jne 0x2786d
movq 0x20640(%rbp), %rdi
movq 0x350(%rbx), %rsi
movq 0x20(%rsp), %rdx
orq 0x98(%rsp), %rdx
callq 0x7310
leaq 0x380(%rbx), %rsi
leaq 0x384(%rbx), %rdx
movq %rbx, %rdi
callq 0x27f49
leaq 0x378(%rbx), %rsi
leaq 0x37c(%rbx), %rdx
movq %rbx, %rdi
callq 0x28098
cmpl $0x0, (%r14)
je 0x278ea
movl 0x4(%r14), %eax
cmpl $0x36003, %eax # imm = 0x36003
je 0x278d8
cmpl $0x36002, %eax # imm = 0x36002
je 0x278c8
cmpl $0x36001, %eax # imm = 0x36001
jne 0x278ea
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2b57c
jmp 0x278e6
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2c378
jmp 0x278e6
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2cfc0
testl %eax, %eax
je 0x2791a
cmpq $0x0, 0x48(%rbx)
je 0x27909
movq %rbx, %rdi
callq 0x27930
movq %rbx, %rdi
callq 0x27962
movq %rbx, %rdi
callq 0x27af1
movq 0x20640(%rbp), %rdi
callq 0x7820
pushq $0x1
popq %rbp
jmp 0x2791c
xorl %ebp, %ebp
movl %ebp, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
updateWindowMode | static void updateWindowMode(_GLFWwindow* window)
{
if (window->monitor)
{
if (_glfw.x11.xinerama.available &&
_glfw.x11.NET_WM_FULLSCREEN_MONITORS)
{
sendEventToWM(window,
_glfw.x11.NET_WM_FULLSCREEN_MONITORS,
window->monitor->x11.index,
window->monitor->x11.index,
window->monitor->x11.index,
window->monitor->x11.index,
0);
}
if (_glfw.x11.NET_WM_STATE && _glfw.x11.NET_WM_STATE_FULLSCREEN)
{
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_ADD,
_glfw.x11.NET_WM_STATE_FULLSCREEN,
0, 1, 0);
}
else
{
// This is the butcher's way of removing window decorations
// Setting the override-redirect attribute on a window makes the
// window manager ignore the window completely (ICCCM, section 4)
// The good thing is that this makes undecorated full screen windows
// easy to do; the bad thing is that we have to do everything
// manually and some things (like iconify/restore) won't work at
// all, as those are tasks usually performed by the window manager
XSetWindowAttributes attributes;
attributes.override_redirect = True;
XChangeWindowAttributes(_glfw.x11.display,
window->x11.handle,
CWOverrideRedirect,
&attributes);
window->x11.overrideRedirect = GLFW_TRUE;
}
// Enable compositor bypass
if (!window->x11.transparent)
{
const unsigned long value = 1;
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_BYPASS_COMPOSITOR, XA_CARDINAL, 32,
PropModeReplace, (unsigned char*) &value, 1);
}
}
else
{
if (_glfw.x11.xinerama.available &&
_glfw.x11.NET_WM_FULLSCREEN_MONITORS)
{
XDeleteProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_FULLSCREEN_MONITORS);
}
if (_glfw.x11.NET_WM_STATE && _glfw.x11.NET_WM_STATE_FULLSCREEN)
{
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_REMOVE,
_glfw.x11.NET_WM_STATE_FULLSCREEN,
0, 1, 0);
}
else
{
XSetWindowAttributes attributes;
attributes.override_redirect = False;
XChangeWindowAttributes(_glfw.x11.display,
window->x11.handle,
CWOverrideRedirect,
&attributes);
window->x11.overrideRedirect = GLFW_FALSE;
}
// Disable compositor bypass
if (!window->x11.transparent)
{
XDeleteProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_BYPASS_COMPOSITOR);
}
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
leaq 0x49440(%rip), %r14 # 0x70db8
cmpl $0x0, 0x214f8(%r14)
setne %sil
movq 0x212e0(%r14), %rdx
testq %rdx, %rdx
setne %cl
andb %sil, %cl
testq %rax, %rax
je 0x279ec
testb %cl, %cl
je 0x279b8
movslq 0x118(%rax), %rcx
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %rcx, %r8
movq %rcx, %r9
callq 0x28442
movq 0x212a8(%r14), %rsi
movq 0x212b8(%r14), %rcx
testq %rsi, %rsi
setne %al
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x27a3a
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
movq %rdx, %r9
callq 0x28442
jmp 0x27a61
testb %cl, %cl
je 0x27a03
movq 0x20640(%r14), %rdi
movq 0x350(%rbx), %rsi
callq 0x7910
movq 0x212a8(%r14), %rsi
movq 0x212b8(%r14), %rcx
testq %rsi, %rsi
setne %al
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x27a9f
pushq $0x1
popq %r9
movq %rbx, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x28442
jmp 0x27ac5
pushq $0x1
popq %rbp
movq %rsp, %rcx
movl %ebp, 0x58(%rcx)
movq 0x20640(%r14), %rdi
movq 0x350(%rbx), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x78c0
movl %ebp, 0x368(%rbx)
cmpl $0x0, 0x374(%rbx)
jne 0x27ae8
movq %rsp, %rax
movq $0x1, (%rax)
movq 0x20640(%r14), %rdi
movq 0x350(%rbx), %rsi
movq 0x212d8(%r14), %rdx
pushq $0x6
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq $0x1
pushq %rax
callq 0x7460
popq %rcx
popq %rdx
jmp 0x27ae8
movq %rsp, %rcx
andl $0x0, 0x58(%rcx)
movq 0x20640(%r14), %rdi
movq 0x350(%rbx), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x78c0
andl $0x0, 0x368(%rbx)
cmpl $0x0, 0x374(%rbx)
jne 0x27ae8
movq 0x20640(%r14), %rdi
movq 0x350(%rbx), %rsi
movq 0x212d8(%r14), %rdx
callq 0x7910
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
acquireMonitor | static void acquireMonitor(_GLFWwindow* window)
{
if (_glfw.x11.saver.count == 0)
{
// Remember old screen saver settings
XGetScreenSaver(_glfw.x11.display,
&_glfw.x11.saver.timeout,
&_glfw.x11.saver.interval,
&_glfw.x11.saver.blanking,
&_glfw.x11.saver.exposure);
// Disable screen saver
XSetScreenSaver(_glfw.x11.display, 0, 0, DontPreferBlanking,
DefaultExposures);
}
if (!window->monitor->window)
_glfw.x11.saver.count++;
_glfwSetVideoModeX11(window->monitor, &window->videoMode);
if (window->x11.overrideRedirect)
{
int xpos, ypos;
GLFWvidmode mode;
// Manually position the window over its monitor
_glfwPlatformGetMonitorPos(window->monitor, &xpos, &ypos);
_glfwPlatformGetVideoMode(window->monitor, &mode);
XMoveResizeWindow(_glfw.x11.display, window->x11.handle,
xpos, ypos, mode.width, mode.height);
}
_glfwInputMonitorWindow(window->monitor, window);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x492b0(%rip), %r13 # 0x70db8
cmpl $0x0, 0x214a8(%r13)
jne 0x27b50
movq 0x20640(%r13), %rdi
leaq 0x214ac(%r13), %rsi
leaq 0x214b0(%r13), %rdx
leaq 0x214b4(%r13), %rcx
leaq 0x214b8(%r13), %r8
callq 0x7130
movq 0x20640(%r13), %rdi
pushq $0x2
popq %r8
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x7080
movq 0x48(%rbx), %rdi
cmpq $0x0, 0x90(%rdi)
jne 0x27b65
incl 0x214a8(%r13)
leaq 0x2c(%rbx), %rsi
callq 0x261f0
cmpl $0x0, 0x368(%rbx)
je 0x27bc1
movq 0x48(%rbx), %rdi
leaq 0x4(%rsp), %r14
movq %rsp, %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x26669
movq 0x48(%rbx), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x26393
movq 0x20640(%r13), %rdi
movq 0x350(%rbx), %rsi
movl (%r14), %edx
movl (%r15), %ecx
movl (%r12), %r8d
movl 0x4(%r12), %r9d
callq 0x7490
movq 0x48(%rbx), %rdi
movq %rbx, %rsi
callq 0x21922
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformDestroyWindow | void _glfwPlatformDestroyWindow(_GLFWwindow* window)
{
if (_glfw.x11.disabledCursorWindow == window)
_glfw.x11.disabledCursorWindow = NULL;
if (window->monitor)
releaseMonitor(window);
if (window->x11.ic)
{
XDestroyIC(window->x11.ic);
window->x11.ic = NULL;
}
if (window->context.destroy)
window->context.destroy(window);
if (window->x11.handle)
{
XDeleteContext(_glfw.x11.display, window->x11.handle, _glfw.x11.context);
XUnmapWindow(_glfw.x11.display, window->x11.handle);
XDestroyWindow(_glfw.x11.display, window->x11.handle);
window->x11.handle = (Window) 0;
}
if (window->x11.colormap)
{
XFreeColormap(_glfw.x11.display, window->x11.colormap);
window->x11.colormap = (Colormap) 0;
}
XFlush(_glfw.x11.display);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x491cf(%rip), %r14 # 0x70db8
cmpq %rdi, 0x21238(%r14)
jne 0x27bfa
andq $0x0, 0x21238(%r14)
cmpq $0x0, 0x48(%rbx)
je 0x27c09
movq %rbx, %rdi
callq 0x27cb3
movq 0x360(%rbx), %rdi
testq %rdi, %rdi
je 0x27c22
callq 0x74f0
andq $0x0, 0x360(%rbx)
movq 0x270(%rbx), %rax
testq %rax, %rax
je 0x27c33
movq %rbx, %rdi
callq *%rax
movq 0x350(%rbx), %rsi
testq %rsi, %rsi
je 0x27c80
movq 0x20640(%r14), %rdi
movl 0x20670(%r14), %edx
callq 0x7800
movq 0x20640(%r14), %rdi
movq 0x350(%rbx), %rsi
callq 0x7790
movq 0x20640(%r14), %rdi
movq 0x350(%rbx), %rsi
callq 0x7880
andq $0x0, 0x350(%rbx)
movq 0x348(%rbx), %rsi
testq %rsi, %rsi
je 0x27ca0
movq 0x20640(%r14), %rdi
callq 0x70d0
andq $0x0, 0x348(%rbx)
movq 0x20640(%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7820
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
releaseMonitor | static void releaseMonitor(_GLFWwindow* window)
{
if (window->monitor->window != window)
return;
_glfwInputMonitorWindow(window->monitor, NULL);
_glfwRestoreVideoModeX11(window->monitor);
_glfw.x11.saver.count--;
if (_glfw.x11.saver.count == 0)
{
// Restore old screen saver settings
XSetScreenSaver(_glfw.x11.display,
_glfw.x11.saver.timeout,
_glfw.x11.saver.interval,
_glfw.x11.saver.blanking,
_glfw.x11.saver.exposure);
}
} | pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
cmpq %rbx, 0x90(%rdi)
jne 0x27ce3
xorl %esi, %esi
callq 0x21922
movq 0x48(%rbx), %rdi
callq 0x2658b
leaq 0x490dd(%rip), %rax # 0x70db8
decl 0x214a8(%rax)
je 0x27ce5
popq %rbx
retq
movq 0x20640(%rax), %rdi
movl 0x214ac(%rax), %esi
movl 0x214b0(%rax), %edx
movl 0x214b4(%rax), %ecx
movl 0x214b8(%rax), %r8d
popq %rbx
jmp 0x7080
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformSetWindowTitle | void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
{
#if defined(X_HAVE_UTF8_STRING)
Xutf8SetWMProperties(_glfw.x11.display,
window->x11.handle,
title, title,
NULL, 0,
NULL, NULL, NULL);
#else
// This may be a slightly better fallback than using XStoreName and
// XSetIconName, which always store their arguments using STRING
XmbSetWMProperties(_glfw.x11.display,
window->x11.handle,
title, title,
NULL, 0,
NULL, NULL, NULL);
#endif
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_NAME, _glfw.x11.UTF8_STRING, 8,
PropModeReplace,
(unsigned char*) title, strlen(title));
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_ICON_NAME, _glfw.x11.UTF8_STRING, 8,
PropModeReplace,
(unsigned char*) title, strlen(title));
XFlush(_glfw.x11.display);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x49095(%rip), %r15 # 0x70db8
movq 0x20640(%r15), %rdi
movq 0x350(%r14), %rsi
subq $0x20, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %rbx, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7160
addq $0x20, %rsp
movq %r15, %rax
movq 0x20640(%r15), %r15
movq 0x350(%r14), %r12
movq 0x21270(%rax), %r13
movq 0x213b8(%rax), %rbp
movq %rbx, %rdi
callq 0x7240
pushq $0x8
popq %r8
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
xorl %r9d, %r9d
pushq %rax
pushq %rbx
callq 0x7460
popq %rcx
popq %rdx
leaq 0x49017(%rip), %rax # 0x70db8
movq 0x20640(%rax), %r15
movq 0x350(%r14), %r14
movq 0x21278(%rax), %r12
movq 0x213b8(%rax), %r13
movq %rax, %rbp
movq %rbx, %rdi
callq 0x7240
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
pushq $0x8
popq %r8
xorl %r9d, %r9d
pushq %rax
pushq %rbx
callq 0x7460
popq %rcx
popq %rdx
movq 0x20640(%rbp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7820
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.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;
unsigned long* icon = calloc(longCount, sizeof(unsigned long));
unsigned long* target = icon;
for (i = 0; i < count; i++)
{
*target++ = images[i].width;
*target++ = images[i].height;
for (j = 0; j < images[i].width * images[i].height; j++)
{
*target++ = (((unsigned long) images[i].pixels[j * 4 + 0]) << 16) |
(((unsigned long) images[i].pixels[j * 4 + 1]) << 8) |
(((unsigned long) images[i].pixels[j * 4 + 2]) << 0) |
(((unsigned long) images[i].pixels[j * 4 + 3]) << 24);
}
}
// NOTE: XChangeProperty expects 32-bit values like the image data above to be
// placed in the 32 least significant bits of individual longs. This is
// true even if long is 64-bit and a WM protocol calls for "packed" data.
// This is because of a historical mistake that then became part of the Xlib
// ABI. Xlib will pack these values into a regular array of 32-bit values
// before sending it over the wire.
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_ICON,
XA_CARDINAL, 32,
PropModeReplace,
(unsigned char*) icon,
longCount);
free(icon);
}
else
{
XDeleteProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_ICON);
}
XFlush(_glfw.x11.display);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x27f0c
movq %rdx, %r14
movl %esi, %r15d
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %r15d
movq %r15, %rcx
shlq $0x4, %rcx
xorl %r13d, %r13d
cmpq %rax, %rcx
je 0x27e46
movl 0x4(%r14,%rax), %edx
imull (%r14,%rax), %edx
addl %edx, %r13d
addl $0x2, %r13d
addq $0x10, %rax
jmp 0x27e2a
movslq %r13d, %rdi
pushq $0x8
popq %rsi
callq 0x7350
movq %rax, %r12
xorl %eax, %eax
xorl %ecx, %ecx
movq %r12, %rdx
cmpq %r15, %rcx
je 0x27ed1
movq %rcx, %rdi
shlq $0x4, %rdi
leaq (%r14,%rdi), %rsi
movslq (%r14,%rdi), %r8
movq %r8, (%rdx)
movslq 0x4(%r14,%rdi), %rdi
movq %rdi, 0x8(%rdx)
addq $0x10, %rdx
imull %r8d, %edi
testl %edi, %edi
cmovlel %eax, %edi
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x27ecc
movq 0x8(%rsi), %r9
movzbl (%r9,%r8,4), %r10d
shll $0x10, %r10d
movzbl 0x1(%r9,%r8,4), %r11d
shll $0x8, %r11d
orl %r10d, %r11d
movzbl 0x2(%r9,%r8,4), %r10d
orq %r11, %r10
movzbl 0x3(%r9,%r8,4), %r9d
shll $0x18, %r9d
orq %r10, %r9
movq %r9, (%rdx)
addq $0x8, %rdx
incq %r8
jmp 0x27e8b
incq %rcx
jmp 0x27e5b
leaq 0x48ee0(%rip), %rax # 0x70db8
movq 0x20640(%rax), %rdi
movq 0x350(%rbx), %rsi
movq 0x21280(%rax), %rdx
pushq $0x6
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
pushq %r13
pushq %r12
callq 0x7460
popq %rcx
popq %rdx
movq %r12, %rdi
callq 0x7630
jmp 0x27f2d
leaq 0x48ea5(%rip), %rax # 0x70db8
movq 0x20640(%rax), %rdi
movq 0x350(%rbx), %rsi
movq 0x21280(%rax), %rdx
callq 0x7910
leaq 0x48e84(%rip), %rax # 0x70db8
movq 0x20640(%rax), %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7820
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformGetWindowPos | void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos)
{
Window dummy;
int x, y;
XTranslateCoordinates(_glfw.x11.display, window->x11.handle, _glfw.x11.root,
0, 0, &x, &y, &dummy);
if (xpos)
*xpos = x;
if (ypos)
*ypos = y;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x48e5b(%rip), %rax # 0x70db8
movq 0x350(%rdi), %rsi
movq 0x20640(%rax), %rdi
movq 0x20650(%rax), %rdx
leaq 0x10(%rsp), %rax
leaq 0x8(%rsp), %r10
leaq 0xc(%rsp), %r9
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %rax
pushq %r10
callq 0x78e0
popq %rcx
popq %rdx
testq %r14, %r14
je 0x27f9c
movl 0xc(%rsp), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x27fa7
movl 0x8(%rsp), %eax
movl %eax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/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;
XSizeHints* hints = XAllocSizeHints();
if (XGetWMNormalHints(_glfw.x11.display, window->x11.handle, hints, &supplied))
{
hints->flags |= PPosition;
hints->x = hints->y = 0;
XSetWMNormalHints(_glfw.x11.display, window->x11.handle, hints);
}
XFree(hints);
}
XMoveWindow(_glfw.x11.display, window->x11.handle, xpos, ypos);
XFlush(_glfw.x11.display);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x28059
testl %eax, %eax
jne 0x28022
callq 0x70b0
movq %rax, %r15
leaq 0x48dde(%rip), %r12 # 0x70db8
movq 0x20640(%r12), %rdi
movq 0x350(%r14), %rsi
leaq 0x8(%rsp), %rcx
movq %rax, %rdx
callq 0x73e0
testl %eax, %eax
je 0x2801a
orb $0x4, (%r15)
andq $0x0, 0x8(%r15)
movq 0x20640(%r12), %rdi
movq 0x350(%r14), %rsi
movq %r15, %rdx
callq 0x7270
movq %r15, %rdi
callq 0x7680
leaq 0x48d8f(%rip), %r15 # 0x70db8
movq 0x20640(%r15), %rdi
movq 0x350(%r14), %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x7420
movq 0x20640(%r15), %rdi
callq 0x7820
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformGetWindowSize | void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height)
{
XWindowAttributes attribs;
XGetWindowAttributes(_glfw.x11.display, window->x11.handle, &attribs);
if (width)
*width = attribs.width;
if (height)
*height = attribs.height;
} | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x48d09(%rip), %rax # 0x70db8
movq 0x20640(%rax), %rax
movq 0x350(%rdi), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x79c0
testq %r14, %r14
je 0x280d4
movl 0x8(%rsp), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x280df
movl 0xc(%rsp), %eax
movl %eax, (%rbx)
addq $0x88, %rsp
popq %rbx
popq %r14
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformSetWindowSize | void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
{
if (window->monitor)
{
if (window->monitor->window == window)
acquireMonitor(window);
}
else
{
if (!window->resizable)
updateNormalHints(window, width, height);
XResizeWindow(_glfw.x11.display, window->x11.handle, width, height);
}
XFlush(_glfw.x11.display);
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x2810d
cmpq %r14, 0x90(%rax)
jne 0x28142
movq %r14, %rdi
callq 0x27af1
jmp 0x28142
movl %edx, %ebx
movl %esi, %ebp
cmpl $0x0, 0x8(%r14)
jne 0x28124
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x28159
leaq 0x48c8d(%rip), %rax # 0x70db8
movq 0x20640(%rax), %rdi
movq 0x350(%r14), %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x7760
leaq 0x48c6f(%rip), %rax # 0x70db8
movq 0x20640(%rax), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7820
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformGetWindowFrameSize | void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
int* left, int* top,
int* right, int* bottom)
{
long* extents = NULL;
if (window->monitor || !window->decorated)
return;
if (_glfw.x11.NET_FRAME_EXTENTS == None)
return;
if (!_glfwPlatformWindowVisible(window) &&
_glfw.x11.NET_REQUEST_FRAME_EXTENTS)
{
XEvent event;
double timeout = 0.5;
// Ensure _NET_FRAME_EXTENTS is set, allowing glfwGetWindowFrameSize to
// function before the window is mapped
sendEventToWM(window, _glfw.x11.NET_REQUEST_FRAME_EXTENTS,
0, 0, 0, 0, 0);
// HACK: Use a timeout because earlier versions of some window managers
// (at least Unity, Fluxbox and Xfwm) failed to send the reply
// They have been fixed but broken versions are still in the wild
// If you are affected by this and your window manager is NOT
// listed above, PLEASE report it to their and our issue trackers
while (!XCheckIfEvent(_glfw.x11.display,
&event,
isFrameExtentsEvent,
(XPointer) window))
{
if (!waitForX11Event(&timeout))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: The window manager has a broken _NET_REQUEST_FRAME_EXTENTS implementation; please report this issue");
return;
}
}
}
if (_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_FRAME_EXTENTS,
XA_CARDINAL,
(unsigned char**) &extents) == 4)
{
if (left)
*left = extents[0];
if (top)
*top = extents[2];
if (right)
*right = extents[1];
if (bottom)
*bottom = extents[3];
}
if (extents)
XFree(extents);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
andq $0x0, (%rsp)
cmpq $0x0, 0x48(%rdi)
je 0x28304
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r13
cmpl $0x0, 0xc(%rdi)
je 0x282f2
leaq 0x48aa4(%rip), %r15 # 0x70db8
cmpq $0x0, 0x21310(%r15)
je 0x282f2
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %r12
movq %r13, %rdi
callq 0x28059
testl %eax, %eax
sete %al
movq 0x21318(%r15), %rsi
testq %rsi, %rsi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x283db
movq %rbp, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
leaq 0x20(%rsp), %rbp
movq %rax, (%rbp)
movq %r13, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x28442
leaq 0x156(%rip), %rbx # 0x284e0
leaq 0x28(%rsp), %r14
movq 0x20640(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x7a60
testl %eax, %eax
jne 0x283cc
movq %rbp, %rdi
callq 0x27269
testl %eax, %eax
jne 0x2838f
leaq 0x37c05(%rip), %rsi # 0x5ffc0
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1eed8
jmp 0x282f2
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %rbp
movq 0x350(%r13), %rdi
movq 0x21310(%r15), %rsi
pushq $0x6
popq %rdx
movq %rsp, %rcx
callq 0x26e38
cmpq $0x4, %rax
jne 0x2842b
movq (%rsp), %rdi
testq %r12, %r12
je 0x28409
movl (%rdi), %eax
movl %eax, (%r12)
testq %rbp, %rbp
je 0x28414
movl 0x10(%rdi), %eax
movl %eax, (%rbp)
testq %r14, %r14
je 0x2841f
movl 0x8(%rdi), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x2842f
movl 0x18(%rdi), %eax
movl %eax, (%rbx)
jmp 0x28438
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x282f2
callq 0x7680
jmp 0x282f2
| /apitrace[P]apitrace-tests/thirdparty/glfw/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->xproperty.atom == _glfw.x11.NET_FRAME_EXTENTS;
} | xorl %eax, %eax
cmpl $0x1c, (%rsi)
jne 0x284ed
cmpl $0x0, 0x38(%rsi)
je 0x284ee
retq
movq 0x20(%rsi), %rcx
cmpq 0x350(%rdx), %rcx
jne 0x284ed
movq 0x28(%rsi), %rcx
leaq 0x488b2(%rip), %rdx # 0x70db8
xorl %eax, %eax
cmpq 0x21310(%rdx), %rcx
sete %al
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/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 of full screen windows requires a WM that supports EWMH full screen");
return;
}
if (_glfwPlatformWindowIconified(window))
{
XMapWindow(_glfw.x11.display, window->x11.handle);
waitForVisibilityNotify(window);
}
else if (_glfwPlatformWindowVisible(window))
{
if (_glfw.x11.NET_WM_STATE &&
_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT &&
_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
{
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_REMOVE,
_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ,
1, 0);
}
}
XFlush(_glfw.x11.display);
} | cmpl $0x0, 0x368(%rdi)
je 0x285ad
leaq 0x37a88(%rip), %rsi # 0x60029
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
jmp 0x1eed8
pushq %rbx
movq %rdi, %rbx
callq 0x28645
testl %eax, %eax
je 0x285f0
leaq 0x487f7(%rip), %rax # 0x70db8
movq 0x20640(%rax), %rdi
movq 0x350(%rbx), %rsi
callq 0x75c0
movq %rbx, %rdi
callq 0x28657
leaq 0x487d5(%rip), %rax # 0x70db8
movq 0x20640(%rax), %rdi
popq %rbx
jmp 0x7820
movq %rbx, %rdi
callq 0x28059
testl %eax, %eax
je 0x285dc
leaq 0x487b5(%rip), %rax # 0x70db8
movq 0x212a8(%rax), %rsi
movq 0x212c0(%rax), %rcx
testq %rsi, %rsi
setne %dl
testq %rcx, %rcx
setne %dil
andb %dl, %dil
movq 0x212c8(%rax), %r8
testq %r8, %r8
setne %al
andb %dil, %al
cmpb $0x1, %al
jne 0x285dc
pushq $0x1
popq %r9
movq %rbx, %rdi
xorl %edx, %edx
callq 0x28442
jmp 0x285dc
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformMaximizeWindow | void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
{
if (!_glfw.x11.NET_WM_STATE ||
!_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
!_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
{
return;
}
if (_glfwPlatformWindowVisible(window))
{
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_ADD,
_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ,
1, 0);
}
else
{
Atom* states = NULL;
unsigned long count =
_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_STATE,
XA_ATOM,
(unsigned char**) &states);
// NOTE: We don't check for failure as this property may not exist yet
// and that's fine (and we'll create it implicitly with append)
Atom missing[2] =
{
_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ
};
unsigned long missingCount = 2;
for (unsigned long i = 0; i < count; i++)
{
for (unsigned long j = 0; j < missingCount; j++)
{
if (states[i] == missing[j])
{
missing[j] = missing[missingCount - 1];
missingCount--;
}
}
}
if (states)
XFree(states);
if (!missingCount)
return;
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.NET_WM_STATE, XA_ATOM, 32,
PropModeAppend,
(unsigned char*) missing,
missingCount);
}
XFlush(_glfw.x11.display);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x486e3(%rip), %r15 # 0x70db8
cmpq $0x0, 0x212a8(%r15)
je 0x287de
cmpq $0x0, 0x212c0(%r15)
je 0x287de
cmpq $0x0, 0x212c8(%r15)
je 0x287de
movq %rdi, %rbx
callq 0x28059
testl %eax, %eax
je 0x28733
movq 0x212a8(%r15), %rsi
movq 0x212c0(%r15), %rcx
movq 0x212c8(%r15), %r8
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rdx, %r9
callq 0x28442
jmp 0x287d2
leaq 0x10(%rsp), %r14
andq $0x0, (%r14)
movq 0x350(%rbx), %rdi
movq 0x212a8(%r15), %rsi
pushq $0x4
popq %rdx
movq %r14, %rcx
callq 0x26e38
movups 0x212c0(%r15), %xmm0
movaps %xmm0, (%rsp)
pushq $0x2
popq %r12
xorl %ecx, %ecx
movq (%r14), %rdi
cmpq %rax, %rcx
je 0x28796
xorl %edx, %edx
cmpq %r12, %rdx
jae 0x28791
movq (%rdi,%rcx,8), %rsi
cmpq (%rsp,%rdx,8), %rsi
jne 0x2878c
movq -0x8(%rsp,%r12,8), %rsi
decq %r12
movq %rsi, (%rsp,%rdx,8)
incq %rdx
jmp 0x28771
incq %rcx
jmp 0x2876a
testq %rdi, %rdi
je 0x287a0
callq 0x7680
testq %r12, %r12
je 0x287de
movq 0x20640(%r15), %rdi
movq 0x350(%rbx), %rsi
movq 0x212a8(%r15), %rdx
movq %rsp, %rax
pushq $0x4
popq %rcx
pushq $0x20
popq %r8
pushq $0x2
popq %r9
pushq %r12
pushq %rax
callq 0x7460
popq %rcx
popq %rdx
movq 0x20640(%r15), %rdi
callq 0x7820
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformSetWindowDecorated | void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
{
struct
{
unsigned long flags;
unsigned long functions;
unsigned long decorations;
long input_mode;
unsigned long status;
} hints = {0};
hints.flags = MWM_HINTS_DECORATIONS;
hints.decorations = enabled ? MWM_DECOR_ALL : 0;
XChangeProperty(_glfw.x11.display, window->x11.handle,
_glfw.x11.MOTIF_WM_HINTS,
_glfw.x11.MOTIF_WM_HINTS, 32,
PropModeReplace,
(unsigned char*) &hints,
sizeof(hints) / sizeof(long));
} | subq $0x28, %rsp
xorps %xmm0, %xmm0
movq %rsp, %r10
movups %xmm0, 0x8(%r10)
movups %xmm0, 0x18(%r10)
movq $0x2, (%r10)
xorl %eax, %eax
testl %esi, %esi
setne %al
movq %rax, 0x10(%r10)
leaq 0x483a6(%rip), %rcx # 0x70db8
movq 0x20640(%rcx), %rax
movq 0x350(%rdi), %rsi
movq 0x21320(%rcx), %rcx
pushq $0x20
popq %r8
movq %rax, %rdi
movq %rcx, %rdx
xorl %r9d, %r9d
pushq $0x5
pushq %r10
callq 0x7460
addq $0x38, %rsp
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
disableRawMouseMotion | static void disableRawMouseMotion(_GLFWwindow* window)
{
XIEventMask em;
unsigned char mask[] = { 0 };
em.deviceid = XIAllMasterDevices;
em.mask_len = sizeof(mask);
em.mask = mask;
XISelectEvents(_glfw.x11.display, _glfw.x11.root, &em, 1);
} | subq $0x18, %rsp
leaq 0x7(%rsp), %rax
movb $0x0, (%rax)
movabsq $0x100000001, %rcx # imm = 0x100000001
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
leaq 0x47e63(%rip), %rax # 0x70db8
movq 0x20640(%rax), %rdi
movq 0x20650(%rax), %rsi
pushq $0x1
popq %rcx
callq *0x215a0(%rax)
addq $0x18, %rsp
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformPollEvents | void _glfwPlatformPollEvents(void)
{
drainEmptyEvents();
#if defined(__linux__)
_glfwDetectJoystickConnectionLinux();
#endif
XPending(_glfw.x11.display);
while (XQLength(_glfw.x11.display))
{
XEvent event;
XNextEvent(_glfw.x11.display, &event);
processEvent(&event);
}
_GLFWwindow* window = _glfw.x11.disabledCursorWindow;
if (window)
{
int width, height;
_glfwPlatformGetWindowSize(window, &width, &height);
// NOTE: Re-center the cursor only if it has moved since the last call,
// to avoid breaking glfwWaitEvents with MotionNotify
if (window->x11.lastCursorPosX != width / 2 ||
window->x11.lastCursorPosY != height / 2)
{
_glfwPlatformSetCursorPos(window, width / 2, height / 2);
}
}
XFlush(_glfw.x11.display);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
leaq 0x47e21(%rip), %r13 # 0x70db8
leaq 0x100(%rsp), %rbx
pushq $0x40
popq %r14
movl 0x21240(%r13), %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7740
cmpl $-0x1, %eax
jne 0x28fa3
callq 0x7040
cmpl $0x4, (%rax)
je 0x28fa3
callq 0x2db5e
movq 0x20640(%r13), %rdi
callq 0x74a0
leaq 0x38(%rsp), %r14
movq 0x20640(%r13), %rdi
callq 0x7a40
testl %eax, %eax
je 0x29e58
movq 0x20640(%r13), %rdi
movq %r14, %rsi
callq 0x7710
movl 0x38(%rsp), %eax
andl $-0x2, %eax
xorl %r12d, %r12d
cmpl $0x2, %eax
jne 0x29014
movl 0x8c(%rsp), %r12d
cmpq $0x0, 0x20678(%r13)
je 0x29030
movq %r14, %rdi
xorl %esi, %esi
callq 0x7280
testl %eax, %eax
sete %r15b
jmp 0x29033
movb $0x1, %r15b
cmpl $0x0, 0x213d8(%r13)
movl 0x38(%rsp), %eax
je 0x29062
movl 0x213e8(%r13), %ecx
incl %ecx
cmpl %ecx, %eax
jne 0x29062
movq %r14, %rdi
callq *0x21480(%r13)
callq 0x25eac
jmp 0x28fda
cmpl $0x0, 0x21488(%r13)
je 0x2909b
cmpl 0x21494(%r13), %eax
jne 0x2909b
cmpl $0x2, 0x60(%rsp)
jne 0x28fda
testb $0x10, 0x68(%rsp)
je 0x28fda
movl 0x6c(%rsp), %eax
movl %eax, 0x214a4(%r13)
jmp 0x28fda
cmpl $0x1d, %eax
je 0x2916a
cmpl $0x1e, %eax
je 0x2915d
cmpl $0x23, %eax
jne 0x29177
cmpl $0x0, 0x21570(%r13)
je 0x28fda
movq 0x21238(%r13), %r12
testq %r12, %r12
je 0x29149
cmpl $0x0, 0x1f8(%r12)
je 0x29149
movl 0x58(%rsp), %eax
cmpl 0x21580(%r13), %eax
jne 0x29149
movq 0x20640(%r13), %rdi
movq %r14, %rsi
callq 0x7550
testl %eax, %eax
je 0x29149
cmpl $0x11, 0x5c(%rsp)
jne 0x29149
movq 0x68(%rsp), %rax
cmpl $0x0, 0x40(%rax)
je 0x29149
movq 0x48(%rax), %rcx
movq 0x58(%rax), %rax
movsd 0x1e8(%r12), %xmm0
movb (%rcx), %cl
testb $0x1, %cl
je 0x2912e
addsd (%rax), %xmm0
addq $0x8, %rax
movsd 0x1f0(%r12), %xmm1
testb $0x2, %cl
je 0x29141
addsd (%rax), %xmm1
movq %r12, %rdi
callq 0x1f608
movq 0x20640(%r13), %rdi
movq %r14, %rsi
callq 0x71b0
jmp 0x28fda
movq %r14, %rdi
callq 0x26faa
jmp 0x28fda
movq %r14, %rdi
callq 0x2722e
jmp 0x28fda
andq $0x0, (%rsp)
movq 0x20640(%r13), %rdi
movq 0x58(%rsp), %rsi
movl 0x20670(%r13), %edx
movq %rsp, %rcx
callq 0x71e0
testl %eax, %eax
jne 0x28fda
movl 0x38(%rsp), %eax
addl $-0x2, %eax
cmpl $0x1f, %eax
ja 0x28fda
leaq 0x36d3a(%rip), %rdx # 0x5fef0
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
movl %r12d, %eax
jmpq *%rcx
pushq $-0x1
popq %rcx
cmpl $0xff, %r12d
ja 0x291d7
movswl 0x20d6a(%r13,%rax,2), %ecx
movl %ecx, 0x20(%rsp)
movl 0x88(%rsp), %edi
callq 0x2acb2
movl %eax, %ebp
xorl %eax, %eax
testb $0x6, %bpl
sete %al
movl %eax, 0x18(%rsp)
movq (%rsp), %rdi
cmpq $0x0, 0x360(%rdi)
je 0x2980a
movl %ebp, 0x28(%rsp)
movslq %r12d, %rbp
movq 0x398(%rdi,%rbp,8), %rax
testq %rax, %rax
je 0x29235
movq 0x70(%rsp), %rcx
subq %rax, %rcx
sete %al
cmpq $0x7fffffff, %rcx # imm = 0x7FFFFFFF
seta %cl
orb %al, %cl
jne 0x2925f
testl %r12d, %r12d
je 0x29252
movl 0x20(%rsp), %esi
movl %r12d, %edx
pushq $0x1
popq %rcx
movl 0x28(%rsp), %r8d
callq 0x1f4e8
movq (%rsp), %rdi
movq 0x70(%rsp), %rax
movq %rax, 0x398(%rdi,%rbp,8)
testb %r15b, %r15b
je 0x28fda
movq 0x360(%rdi), %rdi
movq %r14, %rsi
movq %rbx, %rdx
pushq $0x63
popq %rcx
xorl %r8d, %r8d
leaq 0x10(%rsp), %r15
movq %r15, %r9
callq 0x7360
movl %eax, %r12d
movl 0x10(%rsp), %eax
cmpl $-0x1, %eax
je 0x29af7
movq %rbx, %rbp
jmp 0x29b30
testb %r15b, %r15b
je 0x28fda
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x28fda
cmpq 0x21258(%r13), %rax
jne 0x29a12
movq 0x70(%rsp), %rax
testq %rax, %rax
je 0x28fda
cmpq 0x21268(%r13), %rax
jne 0x29bf6
movq (%rsp), %rdi
callq 0x22aa0
jmp 0x28fda
movl 0x70(%rsp), %esi
movl 0x74(%rsp), %edx
movq (%rsp), %rdi
cmpl 0x378(%rdi), %esi
jne 0x29309
cmpl 0x37c(%rdi), %edx
je 0x2932f
callq 0x22a73
movq (%rsp), %rdi
movl 0x70(%rsp), %esi
movl 0x74(%rsp), %edx
callq 0x22a46
movq (%rsp), %rdi
movq 0x70(%rsp), %rax
movq %rax, 0x378(%rdi)
movl 0x68(%rsp), %ebp
movl 0x6c(%rsp), %r15d
movl %ebp, 0x10(%rsp)
movl %r15d, 0xc(%rsp)
cmpl $0x0, 0x48(%rsp)
jne 0x293ae
movq 0x358(%rdi), %rax
cmpq 0x20650(%r13), %rax
je 0x293ae
callq 0x241fc
movq (%rsp), %rax
movq 0x358(%rax), %rsi
movq 0x20640(%r13), %rdi
movq 0x20650(%r13), %rdx
movl %ebp, %ecx
movl %r15d, %r8d
leaq 0x10(%rsp), %r9
pushq %rbx
leaq 0x14(%rsp), %rax
pushq %rax
callq 0x78e0
popq %rcx
popq %rdx
callq 0x24233
cmpl $0x3, 0x20680(%r13)
je 0x28fda
movl 0x10(%rsp), %ebp
movq (%rsp), %rdi
movl 0xc(%rsp), %r15d
cmpl 0x380(%rdi), %ebp
jne 0x293c3
cmpl 0x384(%rdi), %r15d
je 0x28fda
movl %ebp, %esi
movl %r15d, %edx
callq 0x22a37
movl 0x10(%rsp), %eax
movq (%rsp), %rcx
movl %eax, 0x380(%rcx)
movl 0xc(%rsp), %eax
movl %eax, 0x384(%rcx)
jmp 0x28fda
movl 0x78(%rsp), %ebp
movl 0x7c(%rsp), %r15d
movq (%rsp), %rdi
cmpl 0x390(%rdi), %ebp
jne 0x2940c
cmpl 0x394(%rdi), %r15d
je 0x2961a
cmpl $0x34003, 0x7c(%rdi) # imm = 0x34003
jne 0x2960c
cmpq %rdi, 0x21238(%r13)
jne 0x28fda
cmpl $0x0, 0x1f8(%rdi)
jne 0x28fda
movl %ebp, %eax
subl 0x388(%rdi), %eax
movl %r15d, %ecx
subl 0x38c(%rdi), %ecx
cvtsi2sd %eax, %xmm0
addsd 0x1e8(%rdi), %xmm0
cvtsi2sd %ecx, %xmm1
addsd 0x1f0(%rdi), %xmm1
jmp 0x29615
cmpl $0x0, 0x70(%rsp)
jne 0x28fda
movq 0x60(%rsp), %rax
cmpq 0x21260(%r13), %rax
jne 0x299da
movq (%rsp), %rdi
callq 0x28bcc
movl %eax, %ecx
andl $-0x3, %ecx
cmpl $0x1, %ecx
jne 0x28fda
xorl %ebp, %ebp
cmpl $0x3, %eax
sete %bpl
movq (%rsp), %rdi
cmpl %ebp, 0x36c(%rdi)
je 0x28fda
cmpq $0x0, 0x48(%rdi)
je 0x29da4
cmpl $0x3, %eax
jne 0x29d9f
callq 0x27cb3
jmp 0x29da4
movq (%rsp), %rdi
callq 0x22a91
jmp 0x28fda
movl 0x88(%rsp), %edi
callq 0x2acb2
movl 0x8c(%rsp), %esi
movq (%rsp), %rdi
leal -0x1(%rsi), %ecx
cmpl $0x6, %ecx
ja 0x29ab4
leaq 0x36a6c(%rip), %rdx # 0x5ff70
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %esi, %esi
jmp 0x29abc
movl 0x88(%rsp), %edi
callq 0x2acb2
movl 0x8c(%rsp), %esi
cmpl $0x3, %esi
je 0x299ba
cmpl $0x2, %esi
je 0x299b2
cmpl $0x1, %esi
jne 0x299c8
movq (%rsp), %rdi
xorl %esi, %esi
jmp 0x299c1
movl 0x60(%rsp), %eax
decl %eax
cmpl $0x2, %eax
jb 0x28fda
movq (%rsp), %rdi
cmpl $0x34003, 0x7c(%rdi) # imm = 0x34003
jne 0x29572
callq 0x2a15b
movq (%rsp), %rdi
movq 0x360(%rdi), %rax
testq %rax, %rax
je 0x2958a
movq %rax, %rdi
callq 0x7940
movq (%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x229b4
jmp 0x28fda
pushq $-0x1
popq %rbp
cmpl $0xff, %r12d
ja 0x295ac
movswl 0x20d6a(%r13,%rax,2), %ebp
movl 0x88(%rsp), %edi
callq 0x2acb2
movl %eax, %r15d
cmpl $0x0, 0x2148c(%r13)
je 0x2985d
movq (%rsp), %rdi
movl %ebp, %esi
movl %r12d, %edx
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x1f4e8
jmp 0x28fda
movl 0x78(%rsp), %ebp
movl 0x7c(%rsp), %r15d
movq (%rsp), %rdi
cmpl $0x34002, 0x7c(%rdi) # imm = 0x34002
jne 0x29600
callq 0x2a231
movq (%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x1f647
movq (%rsp), %rdi
cvtsi2sd %ebp, %xmm0
cvtsi2sd %r15d, %xmm1
callq 0x1f608
movq (%rsp), %rax
movl %ebp, 0x388(%rax)
movl %r15d, 0x38c(%rax)
jmp 0x28fda
movq 0x70(%rsp), %rsi
cmpq 0x21360(%r13), %rsi
jne 0x28fda
movq 0x58(%rsp), %rdi
movq 0x68(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x26e38
movq %rax, %r15
testq %rax, %rax
je 0x29904
movq %r15, 0x28(%rsp)
xorl %r12d, %r12d
movq 0x10(%rsp), %rdi
movq $0x0, 0x18(%rsp)
xorl %r15d, %r15d
leaq 0x33f79(%rip), %rsi # 0x5d5fb
callq 0x7850
testq %rax, %rax
je 0x298ce
movq %rax, %rbp
cmpb $0x23, (%rax)
movl $0x0, %edi
je 0x2967b
movq %r12, 0x20(%rsp)
movq %rbp, %rdi
leaq 0x36d2a(%rip), %rsi # 0x603d6
pushq $0x7
popq %rdx
callq 0x7260
testl %eax, %eax
jne 0x296cc
addq $0x6, %rbp
movq %rbp, %rax
leaq 0x1(%rax), %rbp
cmpb $0x2f, 0x1(%rax)
movq %rbp, %rax
jne 0x296bf
movq 0x18(%rsp), %rax
incq %rax
movq %rax, 0xf8(%rsp)
movq %rbp, %rdi
callq 0x7240
leaq 0x1(%rax), %rdi
pushq $0x1
popq %rsi
callq 0x7350
movq %rax, %r12
movq 0x18(%rsp), %rax
leaq 0x8(,%rax,8), %rsi
movq %r15, %rdi
callq 0x7920
movq %rax, %r15
movq 0x18(%rsp), %rax
movq %r12, (%r15,%rax,8)
movzbl (%rbp), %eax
cmpl $0x25, %eax
je 0x29723
testl %eax, %eax
jne 0x2975e
jmp 0x2976a
movb 0x1(%rbp), %cl
testb %cl, %cl
je 0x2975e
movb 0x2(%rbp), %dl
testb %dl, %dl
je 0x2975e
addq $0x2, %rbp
movb %cl, 0x100(%rsp)
movb %dl, 0x101(%rsp)
movb $0x0, 0x102(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
pushq $0x10
popq %rdx
callq 0x76f0
movb %al, (%r12)
jmp 0x29762
movb %al, (%r12)
incq %r12
incq %rbp
jmp 0x29714
movq 0x20(%rsp), %r12
incl %r12d
movq 0xf8(%rsp), %rax
movq %rax, 0x18(%rsp)
xorl %edi, %edi
jmp 0x2967b
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x1f647
jmp 0x28fda
movq 0x68(%rsp), %rax
movq (%rsp), %rcx
movq %rax, 0x358(%rcx)
jmp 0x28fda
movl 0x60(%rsp), %eax
decl %eax
cmpl $0x2, %eax
jb 0x28fda
movq (%rsp), %rdi
cmpl $0x34003, 0x7c(%rdi) # imm = 0x34003
jne 0x297d0
callq 0x2a1d9
movq (%rsp), %rdi
movq 0x360(%rdi), %rax
testq %rax, %rax
je 0x297e8
movq %rax, %rdi
callq 0x7060
movq (%rsp), %rdi
cmpq $0x0, 0x48(%rdi)
je 0x297fe
cmpl $0x0, 0x10(%rdi)
je 0x297fe
callq 0x28544
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x229b4
jmp 0x28fda
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x7480
movq (%rsp), %rdi
movl 0x20(%rsp), %esi
movl %r12d, %edx
pushq $0x1
popq %rcx
movl %ebp, %r8d
callq 0x1f4e8
movl 0x100(%rsp), %edi
callq 0x2ad54
cmpl $-0x1, %eax
je 0x28fda
movq (%rsp), %rdi
movl %eax, %esi
movl %ebp, %edx
movl 0x18(%rsp), %ecx
callq 0x1f55e
jmp 0x28fda
movq 0x20640(%r13), %rdi
pushq $0x1
popq %rsi
callq 0x75b0
testl %eax, %eax
je 0x295c9
movq 0x20640(%r13), %rdi
movq %rbx, %rsi
callq 0x71f0
cmpl $0x2, 0x100(%rsp)
jne 0x295c9
movq 0x120(%rsp), %rax
cmpq 0x58(%rsp), %rax
jne 0x295c9
cmpl %r12d, 0x154(%rsp)
jne 0x295c9
movq 0x138(%rsp), %rax
subq 0x70(%rsp), %rax
cmpq $0x14, %rax
jb 0x28fda
jmp 0x295c9
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %r15, %rdx
callq 0x1f656
movl %r12d, %r12d
xorl %ebp, %ebp
cmpq %rbp, %r12
je 0x298f7
movq (%r15,%rbp,8), %rdi
callq 0x7630
incq %rbp
jmp 0x298e4
movq %r15, %rdi
callq 0x7630
movq 0x28(%rsp), %r15
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x29913
callq 0x7680
cmpl $0x2, 0x214c0(%r13)
jl 0x28fda
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x72c0
movl $0x21, 0x100(%rsp)
movq 0x214c8(%r13), %rsi
movq %rsi, 0x120(%rsp)
movq 0x21358(%r13), %rax
movq %rax, 0x128(%rsp)
movl $0x20, 0x130(%rsp)
movq (%rsp), %rax
movq 0x350(%rax), %rax
movq %rax, 0x138(%rsp)
movq %r15, 0x140(%rsp)
movq 0x21348(%r13), %rax
movq %rax, 0x148(%rsp)
movq 0x20640(%r13), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x7100
movq 0x20640(%r13), %rdi
callq 0x7820
jmp 0x28fda
movq (%rsp), %rdi
pushq $0x2
jmp 0x299c0
movq (%rsp), %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
jmp 0x29abf
cmpl $0x8, %esi
jb 0x28fda
movq (%rsp), %rdi
addl $-0x5, %esi
jmp 0x299c1
cmpq 0x212a8(%r13), %rax
jne 0x28fda
movq (%rsp), %rdi
callq 0x28c1b
movq (%rsp), %rdi
cmpl %eax, 0x370(%rdi)
je 0x28fda
movl %eax, 0x370(%rdi)
movl %eax, %esi
callq 0x22a64
jmp 0x28fda
cmpq 0x21330(%r13), %rax
jne 0x29bb8
andq $0x0, 0x100(%rsp)
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %r15
movq %rdi, 0x214c8(%r13)
movq %r15, %rax
shrq $0x18, %rax
movl %eax, 0x214c0(%r13)
andq $0x0, 0x214d0(%r13)
cmpl $0x5, %eax
jg 0x28fda
testb $0x1, %r15b
je 0x29d4f
movq 0x21368(%r13), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rcx
callq 0x26e38
movq 0x100(%rsp), %rdi
jmp 0x29d62
xorpd %xmm0, %xmm0
movsd 0x36443(%rip), %xmm1 # 0x5fed0
callq 0x1f5be
jmp 0x28fda
pushq $0x1
popq %rdx
movl %edx, %esi
jmp 0x29abf
xorpd %xmm0, %xmm0
movsd 0x3642e(%rip), %xmm1 # 0x5fed8
callq 0x1f5be
jmp 0x28fda
addl $-0x5, %esi
jmp 0x29abc
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movl %eax, %ecx
callq 0x1f5cd
jmp 0x28fda
xorpd %xmm1, %xmm1
movsd 0x36401(%rip), %xmm0 # 0x5fed8
callq 0x1f5be
jmp 0x28fda
xorpd %xmm1, %xmm1
movsd 0x363e3(%rip), %xmm0 # 0x5fed0
callq 0x1f5be
jmp 0x28fda
movl %r12d, %eax
incl %eax
movslq %eax, %rdi
pushq $0x1
popq %rsi
callq 0x7350
movq %rax, %rbp
movq (%rsp), %rax
movq 0x360(%rax), %rdi
movq %r14, %rsi
movq %rbp, %rdx
movl %r12d, %ecx
xorl %r8d, %r8d
movq %r15, %r9
callq 0x7360
movl %eax, %r12d
movl 0x10(%rsp), %eax
cmpl $0x4, %eax
je 0x29b3a
cmpl $0x2, %eax
jne 0x29ba2
movslq %r12d, %r15
movb $0x0, (%rbp,%r15)
movq %rbp, %r12
movq %r12, %rax
subq %rbp, %rax
cmpq %r15, %rax
jge 0x29ba2
movq (%rsp), %rdi
movb (%r12), %cl
xorl %esi, %esi
pushq $-0x1
popq %rax
movl %esi, %edx
shll $0x6, %edx
movzbl %cl, %esi
addl %edx, %esi
movb 0x1(%r12), %cl
incq %r12
movl %ecx, %edx
andb $-0x40, %dl
incl %eax
negb %dl
jo 0x29b5e
leal 0x1(%rax), %ecx
cmpl $0x7, %ecx
jae 0x29ed7
movl %eax, %eax
leaq 0x36400(%rip), %rcx # 0x5ff90
subl (%rcx,%rax,4), %esi
movl 0x28(%rsp), %edx
movl 0x18(%rsp), %ecx
callq 0x1f55e
jmp 0x29b46
cmpq %rbx, %rbp
je 0x28fda
movq %rbp, %rdi
callq 0x7630
jmp 0x28fda
cmpq 0x21350(%r13), %rax
jne 0x29c3d
movl 0x214c0(%r13), %eax
cmpl $0x5, %eax
jg 0x28fda
movq 0x214d0(%r13), %rdx
testq %rdx, %rdx
je 0x29dba
testl %eax, %eax
jle 0x29e2f
movq 0x80(%rsp), %r9
jmp 0x29e32
cmpq 0x21290(%r13), %rax
jne 0x28fda
movl $0xc0, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73f0
movq 0x20640(%r13), %rdi
movq 0x20650(%r13), %rsi
movq %rsi, 0x120(%rsp)
movl $0x180000, %ecx # imm = 0x180000
xorl %edx, %edx
movq %rbx, %r8
callq 0x7100
jmp 0x28fda
cmpq 0x21338(%r13), %rax
jne 0x28fda
cmpl $0x5, 0x214c0(%r13)
jg 0x28fda
movq 0x80(%rsp), %rcx
movzwl %cx, %r8d
shrl $0x10, %ecx
movq 0x20640(%r13), %rdi
movq 0x20650(%r13), %rsi
movq (%rsp), %rax
movq 0x350(%rax), %rdx
leaq 0xc(%rsp), %r9
leaq 0x10(%rsp), %rax
pushq %rax
leaq 0x3c(%rsp), %rax
pushq %rax
callq 0x78e0
popq %rcx
popq %rdx
movq (%rsp), %rdi
cvtsi2sdl 0xc(%rsp), %xmm0
cvtsi2sdl 0x34(%rsp), %xmm1
callq 0x1f608
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x72c0
movl $0x21, 0x100(%rsp)
movq 0x21340(%r13), %rax
movq 0x214c8(%r13), %rsi
movq %rsi, 0x120(%rsp)
movq %rax, 0x128(%rsp)
movl $0x20, 0x130(%rsp)
movq (%rsp), %rax
movq 0x350(%rax), %rax
movq %rax, 0x138(%rsp)
leaq 0x148(%rsp), %rax
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
cmpq $0x0, 0x214d0(%r13)
je 0x2998e
movq $0x1, 0x140(%rsp)
cmpl $0x2, 0x214c0(%r13)
jl 0x2998e
movq 0x21348(%r13), %rax
movq %rax, 0x158(%rsp)
jmp 0x2998e
leaq 0x80(%rsp), %rdi
movq %rdi, 0x100(%rsp)
pushq $0x3
popq %rax
movq 0x21370(%r13), %rcx
xorl %edx, %edx
cmpq %rdx, %rax
je 0x29d84
leaq 0x1(%rdx), %rsi
cmpq %rcx, (%rdi,%rdx,8)
movq %rsi, %rdx
jne 0x29d6b
movq %rcx, 0x214d0(%r13)
testq %rdi, %rdi
setne %al
andb %r15b, %al
cmpb $0x1, %al
jne 0x28fda
callq 0x7680
jmp 0x28fda
callq 0x27af1
movq (%rsp), %rdi
movl %ebp, 0x36c(%rdi)
movl %ebp, %esi
callq 0x22a55
jmp 0x28fda
cmpl $0x2, %eax
jl 0x28fda
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x72c0
movl $0x21, 0x100(%rsp)
movq 0x21358(%r13), %rax
movq 0x214c8(%r13), %rsi
movq %rsi, 0x120(%rsp)
movq %rax, 0x128(%rsp)
movl $0x20, 0x130(%rsp)
movq (%rsp), %rax
movq 0x350(%rax), %rax
movq %rax, 0x138(%rsp)
leaq 0x148(%rsp), %rax
xorpd %xmm0, %xmm0
movupd %xmm0, -0x8(%rax)
jmp 0x2998e
xorl %r9d, %r9d
movq 0x20640(%r13), %rdi
movq 0x21360(%r13), %rcx
movq (%rsp), %rax
movq 0x350(%rax), %r8
movq %rcx, %rsi
callq 0x7050
jmp 0x28fda
movq 0x21238(%r13), %rbx
testq %rbx, %rbx
je 0x29eb9
leaq 0x100(%rsp), %r14
leaq 0x38(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x28098
movl 0x388(%rbx), %esi
movl (%r14), %eax
cltd
pushq $0x2
popq %rdi
idivl %edi
movl %eax, %ecx
movl (%r15), %eax
cmpl %ecx, %esi
jne 0x29ea6
movl 0x38c(%rbx), %esi
cltd
idivl %edi
cmpl %eax, %esi
jne 0x29ea9
jmp 0x29eb9
cltd
idivl %edi
cvtsi2sd %ecx, %xmm0
cvtsi2sd %eax, %xmm1
movq %rbx, %rdi
callq 0x29ef6
movq 0x20640(%r13), %rdi
callq 0x7820
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3645d(%rip), %rdi # 0x6033b
leaq 0x36461(%rip), %rsi # 0x60346
leaq 0x364c7(%rip), %rcx # 0x603b3
movl $0x214, %edx # imm = 0x214
callq 0x7340
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
waitForAnyEvent | static GLFWbool waitForAnyEvent(double* timeout)
{
nfds_t count = 2;
struct pollfd fds[3] =
{
{ ConnectionNumber(_glfw.x11.display), POLLIN },
{ _glfw.x11.emptyEventPipe[0], POLLIN }
};
#if defined(__linux__)
if (_glfw.linjs.inotify > 0)
fds[count++] = (struct pollfd) { _glfw.linjs.inotify, POLLIN };
#endif
while (!XPending(_glfw.x11.display))
{
if (!waitForData(fds, count, timeout))
return GLFW_FALSE;
for (int i = 1; i < count; i++)
{
if (fds[i].revents & POLLIN)
return GLFW_TRUE;
}
}
return GLFW_TRUE;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x46e3e(%rip), %r12 # 0x70db8
movq 0x20640(%r12), %rax
movl 0x10(%rax), %ecx
movl %ecx, (%rsp)
pushq $0x1
popq %rcx
movl %ecx, 0x4(%rsp)
movl 0x21240(%r12), %edx
movl %edx, 0x8(%rsp)
movl %ecx, 0xc(%rsp)
andq $0x0, 0x10(%rsp)
movq %rdi, %rbx
movl 0x216c0(%r12), %ecx
testl %ecx, %ecx
jle 0x29fc4
movl %ecx, 0x10(%rsp)
movl $0x1, 0x14(%rsp)
pushq $0x3
jmp 0x29fc6
pushq $0x2
popq %r14
leaq -0x1(%r14), %r13
movq %rsp, %r15
movq %rax, %rdi
callq 0x74a0
testl %eax, %eax
jne 0x2a00b
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2ab63
testl %eax, %eax
je 0x2a00b
xorl %eax, %eax
cmpq %rax, %r13
je 0x2a001
testb $0x1, 0xe(%rsp,%rax,8)
leaq 0x1(%rax), %rax
je 0x29fef
jmp 0x2a00b
movq 0x20640(%r12), %rax
jmp 0x29fcf
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformSetCursorMode | void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
{
if (mode == GLFW_CURSOR_DISABLED)
{
if (_glfwPlatformWindowFocused(window))
disableCursor(window);
}
else if (_glfw.x11.disabledCursorWindow == window)
enableCursor(window);
else
updateCursorImage(window);
XFlush(_glfw.x11.display);
} | pushq %rbx
movq %rdi, %rbx
cmpl $0x34003, %esi # imm = 0x34003
jne 0x2a125
movq %rbx, %rdi
callq 0x28b8b
testl %eax, %eax
je 0x2a147
movq %rbx, %rdi
callq 0x2a15b
jmp 0x2a147
leaq 0x46c8c(%rip), %rax # 0x70db8
cmpq %rbx, 0x21238(%rax)
je 0x2a13f
movq %rbx, %rdi
callq 0x2a231
jmp 0x2a147
movq %rbx, %rdi
callq 0x2a1d9
leaq 0x46c6a(%rip), %rax # 0x70db8
movq 0x20640(%rax), %rdi
popq %rbx
jmp 0x7820
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
enableCursor | static void enableCursor(_GLFWwindow* window)
{
if (window->rawMouseMotion)
disableRawMouseMotion(window);
_glfw.x11.disabledCursorWindow = NULL;
XUngrabPointer(_glfw.x11.display, CurrentTime);
_glfwPlatformSetCursorPos(window,
_glfw.x11.restoreCursorPosX,
_glfw.x11.restoreCursorPosY);
updateCursorImage(window);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x1f8(%rdi)
je 0x2a1ee
callq 0x28f2c
leaq 0x46bc3(%rip), %r14 # 0x70db8
andq $0x0, 0x21238(%r14)
movq 0x20640(%r14), %rdi
xorl %esi, %esi
callq 0x7530
movsd 0x21228(%r14), %xmm0
movsd 0x21230(%r14), %xmm1
movq %rbx, %rdi
callq 0x29ef6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a231
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformGetScancodeName | const char* _glfwPlatformGetScancodeName(int scancode)
{
if (!_glfw.x11.xkb.available)
return NULL;
if (scancode < 0 || scancode > 0xff ||
_glfw.x11.keycodes[scancode] == GLFW_KEY_UNKNOWN)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid scancode %i", scancode);
return NULL;
}
const int key = _glfw.x11.keycodes[scancode];
const KeySym keysym = XkbKeycodeToKeysym(_glfw.x11.display,
scancode, _glfw.x11.xkb.group, 0);
if (keysym == NoSymbol)
return NULL;
const uint32_t codepoint = _glfwKeySym2Unicode(keysym);
if (codepoint == GLFW_INVALID_CODEPOINT)
return NULL;
const size_t count = _glfwEncodeUTF8(_glfw.x11.keynames[key], codepoint);
if (count == 0)
return NULL;
_glfw.x11.keynames[key][count] = '\0';
return _glfw.x11.keynames[key];
} | pushq %r15
pushq %r14
pushq %rbx
leaq 0x46b1f(%rip), %r14 # 0x70db8
cmpl $0x0, 0x21488(%r14)
je 0x2a319
movl %edi, %eax
cmpl $0xff, %edi
ja 0x2a31d
movl %eax, %ecx
movswq 0x20d6a(%r14,%rcx,2), %r15
cmpq $-0x1, %r15
je 0x2a31d
movq 0x20640(%r14), %rdi
movl 0x214a4(%r14), %edx
movzbl %al, %esi
xorl %ebx, %ebx
xorl %ecx, %ecx
callq 0x7210
testq %rax, %rax
je 0x2a334
movl %eax, %edi
callq 0x2ad54
cmpl $-0x1, %eax
je 0x2a319
leaq (%r15,%r15,4), %r15
leaq (%r14,%r15), %rbx
addq $0x20698, %rbx # imm = 0x20698
movq %rbx, %rdi
movl %eax, %esi
callq 0x1edf4
testq %rax, %rax
je 0x2a319
addq 0x3ecca(%rip), %r15 # 0x68fd8
movb $0x0, 0x20698(%rax,%r15)
jmp 0x2a334
xorl %ebx, %ebx
jmp 0x2a334
leaq 0x35d5c(%rip), %rsi # 0x60080
xorl %ebx, %ebx
movl $0x10004, %edi # imm = 0x10004
movl %eax, %edx
xorl %eax, %eax
callq 0x1eed8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformSetClipboardString | void _glfwPlatformSetClipboardString(const char* string)
{
char* copy = _glfw_strdup(string);
free(_glfw.x11.clipboardString);
_glfw.x11.clipboardString = copy;
XSetSelectionOwner(_glfw.x11.display,
_glfw.x11.CLIPBOARD,
_glfw.x11.helperWindowHandle,
CurrentTime);
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) !=
_glfw.x11.helperWindowHandle)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to become owner of clipboard selection");
}
} | pushq %r14
pushq %rbx
pushq %rax
callq 0x1ee8d
movq %rax, %rbx
leaq 0x46996(%rip), %r14 # 0x70db8
movq 0x20690(%r14), %rdi
callq 0x7630
movq %rbx, 0x20690(%r14)
movq 0x21390(%r14), %rsi
movq 0x20640(%r14), %rdi
movq 0x20660(%r14), %rdx
xorl %ecx, %ecx
callq 0x7590
movq 0x20640(%r14), %rdi
movq 0x21390(%r14), %rsi
callq 0x79f0
cmpq 0x20660(%r14), %rax
jne 0x2a475
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x35c3e(%rip), %rsi # 0x600ba
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1eed8
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformGetRequiredInstanceExtensions | void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
{
if (!_glfw.vk.KHR_surface)
return;
if (!_glfw.vk.KHR_xcb_surface || !_glfw.x11.x11xcb.handle)
{
if (!_glfw.vk.KHR_xlib_surface)
return;
}
extensions[0] = "VK_KHR_surface";
// NOTE: VK_KHR_xcb_surface is preferred due to some early ICDs exposing but
// not correctly implementing VK_KHR_xlib_surface
if (_glfw.vk.KHR_xcb_surface && _glfw.x11.x11xcb.handle)
extensions[1] = "VK_KHR_xcb_surface";
else
extensions[1] = "VK_KHR_xlib_surface";
} | leaq 0x4661c(%rip), %rcx # 0x70db8
cmpl $0x0, 0x20620(%rcx)
je 0x2a7ca
movl 0x20628(%rcx), %eax
testl %eax, %eax
setne %dl
cmpq $0x0, 0x21528(%rcx)
setne %sil
testb %sil, %dl
jne 0x2a7cb
cmpl $0x0, 0x20624(%rcx)
jne 0x2a7cb
retq
leaq 0x334aa(%rip), %rdx # 0x5dc7c
movq %rdx, (%rdi)
cmpq $0x0, 0x21528(%rcx)
leaq 0x334bb(%rip), %rcx # 0x5dc9f
leaq 0x334a0(%rip), %rdx # 0x5dc8b
cmoveq %rdx, %rcx
testl %eax, %eax
cmoveq %rdx, %rcx
movq %rcx, 0x8(%rdi)
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformCreateWindowSurface | VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
_GLFWwindow* window,
const VkAllocationCallbacks* allocator,
VkSurfaceKHR* surface)
{
if (_glfw.vk.KHR_xcb_surface && _glfw.x11.x11xcb.handle)
{
VkResult err;
VkXcbSurfaceCreateInfoKHR sci;
PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR;
xcb_connection_t* connection = XGetXCBConnection(_glfw.x11.display);
if (!connection)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to retrieve XCB connection");
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
vkCreateXcbSurfaceKHR = (PFN_vkCreateXcbSurfaceKHR)
vkGetInstanceProcAddr(instance, "vkCreateXcbSurfaceKHR");
if (!vkCreateXcbSurfaceKHR)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"X11: Vulkan instance missing VK_KHR_xcb_surface extension");
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
memset(&sci, 0, sizeof(sci));
sci.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
sci.connection = connection;
sci.window = window->x11.handle;
err = vkCreateXcbSurfaceKHR(instance, &sci, allocator, surface);
if (err)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to create Vulkan XCB surface: %s",
_glfwGetVulkanResultString(err));
}
return err;
}
else
{
VkResult err;
VkXlibSurfaceCreateInfoKHR sci;
PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR;
vkCreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR)
vkGetInstanceProcAddr(instance, "vkCreateXlibSurfaceKHR");
if (!vkCreateXlibSurfaceKHR)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"X11: Vulkan instance missing VK_KHR_xlib_surface extension");
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
memset(&sci, 0, sizeof(sci));
sci.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
sci.dpy = _glfw.x11.display;
sci.window = window->x11.handle;
err = vkCreateXlibSurfaceKHR(instance, &sci, allocator, surface);
if (err)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to create Vulkan X11 surface: %s",
_glfwGetVulkanResultString(err));
}
return err;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x464ac(%rip), %rbp # 0x70db8
cmpl $0x0, 0x20628(%rbp)
je 0x2a99e
cmpq $0x0, 0x21528(%rbp)
je 0x2a99e
movq 0x20640(%rbp), %rdi
callq *0x21530(%rbp)
testq %rax, %rax
je 0x2aa1b
movq %rax, %r13
leaq 0x358a1(%rip), %rsi # 0x601e4
movq %r15, %rdi
callq *0x20618(%rbp)
testq %rax, %rax
je 0x2aa29
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movl $0x3b9add88, (%rsi) # imm = 0x3B9ADD88
movq %r13, 0x18(%rsi)
movq 0x350(%r12), %rcx
movq %rcx, 0x20(%rsi)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq *%rax
testl %eax, %eax
je 0x2aa0e
movl %eax, %ebx
movl %eax, %edi
callq 0x22581
leaq 0x3585e(%rip), %rsi # 0x601fa
jmp 0x2a9fd
leaq 0x35882(%rip), %rsi # 0x60227
movq %r15, %rdi
callq *0x20618(%rbp)
testq %rax, %rax
je 0x2aa12
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movl $0x3b9ad9a0, (%rsi) # imm = 0x3B9AD9A0
movq 0x20640(%rbp), %rcx
movq %rcx, 0x18(%rsi)
movq 0x350(%r12), %rcx
movq %rcx, 0x20(%rsi)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq *%rax
testl %eax, %eax
je 0x2aa0e
movl %eax, %ebx
movl %eax, %edi
callq 0x22581
leaq 0x35841(%rip), %rsi # 0x6023e
movl $0x10008, %edi # imm = 0x10008
movq %rax, %rdx
xorl %eax, %eax
callq 0x1eed8
jmp 0x2aa3f
xorl %ebx, %ebx
jmp 0x2aa3f
leaq 0x35790(%rip), %rsi # 0x601a9
jmp 0x2aa30
leaq 0x35732(%rip), %rsi # 0x60154
movl $0x10008, %edi # imm = 0x10008
jmp 0x2aa35
leaq 0x356ea(%rip), %rsi # 0x6011a
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x1eed8
pushq $-0x7
popq %rbx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
waitForData | static GLFWbool waitForData(struct pollfd* fds, nfds_t count, double* timeout)
{
for (;;)
{
if (timeout)
{
const uint64_t base = _glfwPlatformGetTimerValue();
#if defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__CYGWIN__)
const time_t seconds = (time_t) *timeout;
const long nanoseconds = (long) ((*timeout - seconds) * 1e9);
const struct timespec ts = { seconds, nanoseconds };
const int result = ppoll(fds, count, &ts, NULL);
#elif defined(__NetBSD__)
const time_t seconds = (time_t) *timeout;
const long nanoseconds = (long) ((*timeout - seconds) * 1e9);
const struct timespec ts = { seconds, nanoseconds };
const int result = pollts(fds, count, &ts, NULL);
#else
const int milliseconds = (int) (*timeout * 1e3);
const int result = poll(fds, count, milliseconds);
#endif
const int error = errno; // clock_gettime may overwrite our error
*timeout -= (_glfwPlatformGetTimerValue() - base) /
(double) _glfwPlatformGetTimerFrequency();
if (result > 0)
return GLFW_TRUE;
else if (result == -1 && error != EINTR && error != EAGAIN)
return GLFW_FALSE;
else if (*timeout <= 0.0)
return GLFW_FALSE;
}
else
{
const int result = poll(fds, count, -1);
if (result > 0)
return GLFW_TRUE;
else if (result == -1 && errno != EINTR && errno != EAGAIN)
return GLFW_FALSE;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %r14, %r14
je 0x2ac68
callq 0x2ae0f
movq %rax, %rbp
movsd (%r14), %xmm0
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm1
subsd %xmm1, %xmm0
mulsd 0x3533a(%rip), %xmm0 # 0x5fee0
cvttsd2si %xmm0, %rcx
movq %rax, (%rsp)
movq %rcx, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %rsp, %rdx
xorl %ecx, %ecx
callq 0x7030
movl %eax, %ebx
callq 0x7040
movl (%rax), %r13d
callq 0x2ae0f
subq %rbp, %rax
movq %rax, %xmm0
movq 0x17f7d(%rip), %xmm1 # 0x42b60
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x17f81(%rip), %xmm1 # 0x42b70
subpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
callq 0x2ae59
movq %rax, %xmm0
punpckldq 0x17f49(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x17f51(%rip), %xmm0 # 0x42b70
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd 0x10(%rsp), %xmm2
divsd %xmm1, %xmm2
movsd (%r14), %xmm0
subsd %xmm2, %xmm0
movsd %xmm0, (%r14)
testl %ebx, %ebx
jg 0x2aca0
cmpl $-0x1, %ebx
jne 0x2ac58
cmpl $0xb, %r13d
je 0x2ac58
cmpl $0x4, %r13d
jne 0x2ac9c
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jb 0x2ab7a
jmp 0x2ac9c
movq %r12, %rdi
movq %r15, %rsi
pushq $-0x1
popq %rdx
callq 0x77e0
testl %eax, %eax
jg 0x2aca0
cmpl $-0x1, %eax
jne 0x2ab7a
callq 0x7040
movl (%rax), %eax
cmpl $0x4, %eax
je 0x2ab7a
cmpl $0xb, %eax
je 0x2ab7a
xorl %eax, %eax
jmp 0x2aca3
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
isSelPropNewValueNotify | static Bool isSelPropNewValueNotify(Display* display, XEvent* event, XPointer pointer)
{
XEvent* notification = (XEvent*) pointer;
return event->type == PropertyNotify &&
event->xproperty.state == PropertyNewValue &&
event->xproperty.window == notification->xselection.requestor &&
event->xproperty.atom == notification->xselection.property;
} | xorl %eax, %eax
cmpl $0x1c, (%rsi)
jne 0x2ace6
cmpl $0x0, 0x38(%rsi)
je 0x2ace7
retq
movq 0x20(%rsi), %rcx
cmpq 0x20(%rdx), %rcx
jne 0x2ace6
movq 0x28(%rsi), %rcx
xorl %eax, %eax
cmpq 0x38(%rdx), %rcx
sete %al
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwKeySym2Unicode | uint32_t _glfwKeySym2Unicode(unsigned int keysym)
{
int min = 0;
int max = sizeof(keysymtab) / sizeof(struct codepair) - 1;
int mid;
// First check for Latin-1 characters (1:1 mapping)
if ((keysym >= 0x0020 && keysym <= 0x007e) ||
(keysym >= 0x00a0 && keysym <= 0x00ff))
{
return keysym;
}
// Also check for directly encoded 24-bit UCS characters
if ((keysym & 0xff000000) == 0x01000000)
return keysym & 0x00ffffff;
// Binary search in table
while (max >= min)
{
mid = (min + max) / 2;
if (keysymtab[mid].keysym < keysym)
min = mid + 1;
else if (keysymtab[mid].keysym > keysym)
max = mid - 1;
else
return keysymtab[mid].ucs;
}
// No matching Unicode value found
return GLFW_INVALID_CODEPOINT;
} | leal -0x20(%rdi), %eax
cmpl $0x5f, %eax
setb %al
leal -0xa0(%rdi), %ecx
cmpl $0x60, %ecx
setb %cl
orb %al, %cl
jne 0x2adcd
movl %edi, %eax
andl $0xff000000, %eax # imm = 0xFF000000
cmpl $0x1000000, %eax # imm = 0x1000000
jne 0x2ad83
andl $0xffffff, %edi # imm = 0xFFFFFF
jmp 0x2adcd
movl $0x33b, %r10d # imm = 0x33B
xorl %r9d, %r9d
pushq $-0x1
popq %rcx
pushq $0x2
popq %r8
leaq 0x35676(%rip), %rsi # 0x60410
cmpl %r9d, %r10d
jl 0x2adc4
leal (%r10,%r9), %eax
cltd
idivl %r8d
movslq %eax, %rdx
movzwl (%rsi,%rdx,4), %r11d
cmpl %edi, %r11d
jb 0x2adbd
jbe 0x2adc8
decl %eax
movl %eax, %r10d
jmp 0x2ad9a
incl %eax
movl %eax, %r9d
jmp 0x2ad9a
movl %ecx, %edi
jmp 0x2adcd
movzwl 0x2(%rsi,%rdx,4), %edi
movl %edi, %eax
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/xkb_unicode.c |
glfwInitTimerPOSIX | void _glfwInitTimerPOSIX(void)
{
#if defined(CLOCK_MONOTONIC)
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
{
_glfw.timer.posix.monotonic = GLFW_TRUE;
_glfw.timer.posix.frequency = 1000000000;
}
else
#endif
{
_glfw.timer.posix.monotonic = GLFW_FALSE;
_glfw.timer.posix.frequency = 1000000;
}
} | subq $0x18, %rsp
pushq $0x1
popq %rdi
leaq 0x8(%rsp), %rsi
callq 0x74e0
xorl %ecx, %ecx
testl %eax, %eax
movl $0x3b9aca00, %eax # imm = 0x3B9ACA00
movl $0xf4240, %edx # imm = 0xF4240
cmoveq %rax, %rdx
sete %cl
leaq 0x45fbb(%rip), %rax # 0x70db8
movl %ecx, 0x205e0(%rax)
movq %rdx, 0x205e8(%rax)
addq $0x18, %rsp
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/posix_time.c |
glfwPlatformGetTimerValue | uint64_t _glfwPlatformGetTimerValue(void)
{
#if defined(CLOCK_MONOTONIC)
if (_glfw.timer.posix.monotonic)
{
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (uint64_t) ts.tv_sec * (uint64_t) 1000000000 + (uint64_t) ts.tv_nsec;
}
else
#endif
{
struct timeval tv;
gettimeofday(&tv, NULL);
return (uint64_t) tv.tv_sec * (uint64_t) 1000000 + (uint64_t) tv.tv_usec;
}
} | pushq %rbx
subq $0x10, %rsp
leaq 0x45f9d(%rip), %rax # 0x70db8
cmpl $0x0, 0x205e0(%rax)
je 0x2ae3b
pushq $0x1
popq %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x74e0
imulq $0x3b9aca00, (%rbx), %rax # imm = 0x3B9ACA00
jmp 0x2ae4f
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x78d0
imulq $0xf4240, (%rbx), %rax # imm = 0xF4240
addq 0x8(%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/posix_time.c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.