name string | code string | asm string | file string |
|---|---|---|---|
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... | 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),... | /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", "QPDFObje... | 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... | /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
m... | /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;... | 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... | /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... | /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 0x1... | /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 0x1... | /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... | /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).*... | 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... | /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;
}
... | 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(%... | /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... | /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... | /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 0... | /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... | /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... | /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
mo... | /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... | 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, 0x3... | /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... | 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
ca... | /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-... | 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(%... | /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)
xorp... | /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(... | 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), %rs... | /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... | /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)
xorp... | /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), %rs... | /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), %rs... | /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' : ... | 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 0x334... | /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 = cou... | 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... | /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... | /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
ad... | /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(... | 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... | /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;
}... | 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... | /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(descriptio... | 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)
movap... | /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) ||
!_glf... | 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)
mov... | /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 < _glf... | 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... | /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:
... | 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
lea... | /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)
{
co... | 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... | /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[k... | 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 %r... | /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)
windo... | 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 : ... | 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,%r... | /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_BU... | 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), ... | /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, "Inval... | 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 $0x1000... | /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... | /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);
... | 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 = 0x... | /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 ||... | 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... | /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 * _glfwPlatfo... | 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 # x... | /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 GLFWv... | 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 %r... | /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), compareVideo... | 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 0x... | /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 sar... | 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 0x21... | /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)
... | 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, %... | /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();
... | 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), ... | /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 = (GLFWvkpr... | 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 0x227a... | /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... | 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... | /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);
re... | 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 $0x10... | /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 0x3... | /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), ... | /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 0x3... | /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... | /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:
... | 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 *%r... | /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);
... | 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 # 0... | /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.helpe... | 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(%rb... | /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, ... | 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... | /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
{
... | 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... | /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);
XRRCrtcIn... | 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(%r1... | /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->r... | 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)... | /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_... | 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
j... | /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->m... | 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, ... | /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.sav... | 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),... | /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;
}
i... | 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), %r... | /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 se... | 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... | /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
... | 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, %r... | /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(l... | 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 %ed... | /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 %r... | /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;
XSizeHin... | 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
call... | /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
m... | /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);
XResizeWindo... | 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)... | /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)
... | 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, 0x2131... | /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->xprope... | 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 ... | 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 ... | /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,
_g... | 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... | /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.de... | 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
mov... | /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);
}
... | 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, (%ra... | /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) { _glf... | 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, %r... | /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(wi... | 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
cal... | /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,
... | 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 ... | /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;
... | 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 %e... | /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,
... | 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
c... | /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_surf... | 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 ... | /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... | 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... | /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 secon... | 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... | /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 &&
... | 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... | 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, %r1... | /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;
... | 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 $... | /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 tim... | 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), %ra... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/posix_time.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.