name string | code string | asm string | file string |
|---|---|---|---|
curlx_uitouc | unsigned char curlx_uitouc(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_UCHAR);
return (unsigned char) (uinum & (unsigned int) CURL_MASK_UCHAR);
#ifdef __INTEL_CO... | movl %edi, %eax
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_uitosi | int curlx_uitosi(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_SINT);
return (int) (uinum & (unsigned int) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warni... | movl %edi, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_sitouz | size_t curlx_sitouz(int sinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sinum >= 0);
return (size_t) sinum;
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movslq %edi, %rax
retq
| /nomaster[P]curl/lib/warnless.c |
cappuccino::ut_map<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, (cappuccino::thread_safe)1>::do_insert(unsigned long const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::chrono::time_point<std::chrono::_V2::steady_clock, std::ch... | auto do_insert(const key_type& key, value_type&& value, std::chrono::steady_clock::time_point expire_time) -> void
{
keyed_element element;
element.m_value = std::move(value);
auto keyed_position = m_keyed_elements.emplace(key, std::move(element)).first;
m_ttl_list.emplace_back(exp... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
xorl %eax, %eax
movq %rax, -0x8(%r13)
movb $0x0, (%r13)
movq %rax, 0x10(%r13)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x3190
leaq 0x28(%... | /jbaldwin[P]libcappuccino/inc/cappuccino/ut_map.hpp |
EventLoop::addChannel(std::shared_ptr<Channel>) | void EventLoop::addChannel(ChannelPtr channel) {
assertInLoopThread();
poller_->addChannel(std::move(channel));
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb9ae
movq 0x8(%r14), %rdi
movq (%rbx), %rax
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%rsi)
movq %rcx, (%rbx)
callq 0xc490
movq -0x18(%rbp), %... | /Raven65[P]WebServer/net/EventLoop.cpp |
EventLoop::updateChannel(std::shared_ptr<Channel>) | void EventLoop::updateChannel(ChannelPtr channel) {
assert(channel->ownerLoop() == this);
assertInLoopThread();
poller_->updateChannel(std::move(channel));
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rsi), %rax
cmpq %rdi, 0x10(%rax)
jne 0xb4da
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb9ae
movq 0x8(%r14), %rdi
movq (%rbx), %rax
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%rsi)... | /Raven65[P]WebServer/net/EventLoop.cpp |
EventLoop::removeChannel(std::shared_ptr<Channel>) | void EventLoop::removeChannel(ChannelPtr channel) {
assert(channel->ownerLoop() == this);
assertInLoopThread();
poller_->removeChannel(std::move(channel));
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rsi), %rax
cmpq %rdi, 0x10(%rax)
jne 0xb56c
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb9ae
movq 0x8(%r14), %rdi
movq (%rbx), %rax
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%rsi)... | /Raven65[P]WebServer/net/EventLoop.cpp |
EventLoop::queueInLoop(std::function<void ()>) | void EventLoop::queueInLoop(Functor cb) {
{
MutexLockGuard lock(mutex_);
pendingFuntors_.push_back(std::move(cb));
}
if(!isInLoopThread() || callingPendingFunctors_) {
wakeup();
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
movq %r14, %rdi
callq 0xa350
leaq 0x80(%rbx), %rdi
movq %r15, %rsi
callq 0xbccc
movq %r14, %rdi
callq 0xa1a0
movl 0x40(%rbx), %r14d
movq 0xb914(%rip), %r15 # 0x16fe8
movl %fs:(%r15), %eax
te... | /Raven65[P]WebServer/net/EventLoop.cpp |
LogStream::operator<<(char const*) | LogStream& operator<<(const char* str) {
if (str)
buffer_.append(str, strlen(str));
else
buffer_.append("(null)", 6);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0xb8ea
movq %rsi, %r15
movq %rsi, %rdi
callq 0xa0f0
movq %rax, %r14
leaq 0xfa8(%rbx), %r12
movq 0xfa8(%rbx), %rdi
movl %r12d, %eax
subl %edi, %eax
cmpl %r14d, %eax
jle 0xb918
movq %r15, %rsi
movq %r14, %rdx
callq ... | /Raven65[P]WebServer/net/../base/LogStream.h |
EventLoop::assertInLoopThread() | void assertInLoopThread() { assert(isInLoopThread()); } | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x40(%rdi), %ebx
movq 0xb629(%rip), %r14 # 0x16fe8
movl %fs:(%r14), %eax
testl %eax, %eax
je 0xb9d0
cmpl %eax, %ebx
jne 0xb9db
popq %rbx
popq %r14
popq %rbp
retq
callq 0xf055
movl %fs:(%r14), %eax
jmp 0xb9c7
leaq 0x58b8(%rip), %rdi # 0x1129a
leaq 0x58c2(%r... | /Raven65[P]WebServer/net/EventLoop.h |
Channel::~Channel() | Channel::~Channel() {} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x98(%rdi), %rax
testq %rax, %rax
je 0xbf6a
leaq 0x88(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x78(%rbx), %rax
testq %rax, %rax
je 0xbf81
leaq 0x68(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x58(%rbx), %rax
tes... | /Raven65[P]WebServer/net/Channel.cpp |
Channel::handleEvent() | void Channel::handleEvent() {
if (fd_ == -1) return;
ChannelPtr guard(shared_from_this());
if ((revents_ & EPOLLHUP) && !(revents_ & EPOLLIN)) {
if(closeCallback_) closeCallback_();
}
if (revents_ & EPOLLERR) {
if (errorCallback_) errorCallback_();
else if (closeCallback_) cl... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
cmpl $-0x1, 0x18(%rdi)
je 0xc0b5
movq %rdi, %rbx
leaq -0x18(%rbp), %rdi
movq %rbx, %rsi
callq 0xc146
movl 0x20(%rbx), %eax
movl %eax, %ecx
andl $0x11, %ecx
cmpl $0x10, %ecx
jne 0xc049
cmpq $0x0, 0x98(%rbx)
je 0xc049
leaq 0x88(%rbx), %rdi
callq *0xa0(%rbx)
movl 0x20... | /Raven65[P]WebServer/net/Channel.cpp |
EPoller::EPoller() | EPoller::EPoller() : epollfd_(epoll_create1(EPOLL_CLOEXEC)), events_(kEventInit) {
if (epollfd_ < 0) {
LOG << "Error: Epoller";
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xfd8, %rsp # imm = 0xFD8
movq %rdi, %rbx
movl $0x80000, %edi # imm = 0x80000
callq 0xa2f0
movl %eax, (%rbx)
leaq 0x8(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
xorl %r14d, %r14d
movq %r14, 0x18(%rbx)
movl $0xc000, %edi ... | /Raven65[P]WebServer/net/EPoller.cpp |
EPoller::~EPoller() | EPoller::~EPoller() {
close(epollfd_);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0xa470
leaq 0x20(%rbx), %rdi
callq 0xc83a
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0xc2f5
popq %rbx
popq %rbp
jmp 0xa230
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0xa9d4
| /Raven65[P]WebServer/net/EPoller.cpp |
EPoller::fillActiveChannels(int, std::vector<std::shared_ptr<Channel>, std::allocator<std::shared_ptr<Channel>>>*) const | void EPoller::fillActiveChannels(int numEvents, ChannelList* activeChannels) const {
for(int i = 0; i < numEvents; ++i) {
int fd = events_[i].data.fd;
auto it = channels_.find(fd);
assert(it != channels_.end());
auto channel = it->second;
channel->setRevents(events_[i].events... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
jle 0xc449
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %r15
movl %esi, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %r12
xorl %r13d, %r13d
movq 0x8(%r14), %rax
movl 0x4(%rax,%r13), %eax
movl %eax, -0x2c(... | /Raven65[P]WebServer/net/EPoller.cpp |
EPoller::addChannel(std::shared_ptr<Channel>) | void EPoller::addChannel(ChannelPtr channel) {
int fd = channel->fd();
assert(channels_.find(fd) == channels_.end());
channels_[fd] = channel;
struct epoll_event event;
memset(&event, 0, sizeof event);
event.events = channel->events();
event.data.fd = fd;
if (epoll_ctl(epollfd... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xff0, %rsp # imm = 0xFF0
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movl 0x18(%rax), %eax
leaq -0x24(%rbp), %rsi
movl %eax, (%rsi)
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0xcb0e
testq %rax, %rax
jne 0xc584
leaq -0x24(%rb... | /Raven65[P]WebServer/net/EPoller.cpp |
Thread::Thread(std::function<void ()> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Thread::Thread(const ThreadFunc& func, const std::string& name)
: started_(false),
joined_(false),
pthreadId_(0),
tid_(0),
func_(func),
name_(name),
latch_(1) {
setDefaultName();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rdi, %r14
movw $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0xf484
leaq 0x38(%r14), %r15
leaq 0x48(%r14), %rbx
movq %rbx, 0x38(%r14)
movq (%r1... | /Raven65[P]WebServer/base/Thread.cpp |
AsyncLogging::threadFunc() | void AsyncLogging::threadFunc() {
assert(running_ == true);
latch_.countDown();
LogFile output(basename_);
BufferPtr newBuffer(new Buffer);
newBuffer->bzero();
BufferVector buffersToWrite;
buffersToWrite.reserve(16);
while (running_) {
assert(newBuffer && newBuffer->length() == ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpb $0x0, 0x4(%rdi)
je 0xfb7b
movq %rdi, %rbx
addq $0x178, %rdi # imm = 0x178
callq 0xf55e
leaq 0x8(%rbx), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x400, %edx # imm = 0x400
callq 0x105a4
movl $0x3d0908, %... | /Raven65[P]WebServer/base/AsyncLogging.cpp |
LogFile::~LogFile() | ~LogFile() = default; | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x30, %rdi
callq 0xfed0
leaq 0x28(%rbx), %rdi
callq 0xfefe
movq (%rbx), %rdi
addq $0x10, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0xfecc
popq %rbx
popq %rbp
jmp 0xa230
popq %rbx
popq %rbp
retq
nop
| /Raven65[P]WebServer/base/LogFile.h |
mainMenu(std::basic_ifstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&) | int mainMenu(ifstream &loadFile, ofstream &compressedFile, ofstream &mapper)
{
// Display user cmd line interface for selection if they want to compress or decmopress or close programm
cout << "Welcome to Pied Piper the brand new middle out compression engine"<< endl;
cout << "Please select what you w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x4675(%rip), %r12 # 0x6fc0
leaq 0x2771(%rip), %rsi # 0x50c3
movl $0x41, %edx
movq %r12, %rdi
callq 0x2210
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa,... | /Christian-Prather[P]Pied-Piper/HelperFunctions.cpp |
xs::sendMessage(de::Socket&, xs::Message const&) | void sendMessage (de::Socket& socket, const Message& message)
{
// Format message.
vector<deUint8> buf;
message.write(buf);
// Write to socket.
size_t pos = 0;
while (pos < buf.size())
{
size_t numLeft = buf.size() - pos;
size_t numSent = 0;
deSocketResult result = socket.send(&buf[pos], numLeft, &... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
subq %rsi, %rdx
je 0x6626
xorl %r15d, %r15d
lea... | /kaydenl[P]VK-GL-CTS/execserver/tools/xsClient.cpp |
xs::readMessage(de::Socket&) | Message* readMessage (de::Socket& socket)
{
// Header.
vector<deUint8> header;
readBytes(socket, header, MESSAGE_HEADER_SIZE);
MessageType type;
size_t messageSize;
Message::parseHeader(&header[0], (int)header.size(), type, messageSize);
// Simple messages without any data.
switch (type)
{
case MESSAGETYP... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movl $0x8, %edx
callq 0x66bd
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %eax
subl %edi, %eax
movslq %eax, %rsi
leaq 0xc(%rsp), %rdx
leaq 0x50(%rsp), %rcx
callq 0x781a
movl 0xc(%rsp), %e... | /kaydenl[P]VK-GL-CTS/execserver/tools/xsClient.cpp |
xs::parseString[abi:cxx11](char const*) | string parseString (const char* str)
{
if (str[0] == '\'' || str[0] == '"')
{
const char* p = str;
char endChar = *p++;
std::ostringstream o;
while (*p != endChar && *p)
{
if (*p == '\\')
{
switch (p[1])
{
case 0: DE_ASSERT(DE_FALSE); break;
case 'n': o << '\n'; break;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %ebp
cmpl $0x27, %ebp
je 0x6d82
cmpl $0x22, %ebp
jne 0x6e60
leaq 0x8(%rsp), %rdi
callq 0x6330
movb 0x1(%r14), %al
cmpb %bpl, %al
sete %cl
testb %al, %al
sete %dl
orb %cl, %dl
... | /kaydenl[P]VK-GL-CTS/execserver/tools/xsClient.cpp |
xs::runClient(int, char const* const*) | int runClient (int argc, const char* const* argv)
{
CommandLine cmdLine;
// Defaults.
cmdLine.address.setHost("127.0.0.1");
cmdLine.address.setPort(50016);
cmdLine.dstFileName = "TestResults.qpa";
// Parse command line.
for (int argNdx = 1; argNdx < argc; argNdx++)
{
const char* arg = argv[argNdx];
if (d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x8328
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
xorl %ecx, %ecx
movq %rcx, -0x8(%rax)
movb %cl, (%rax)
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rcx... | /kaydenl[P]VK-GL-CTS/execserver/tools/xsClient.cpp |
xs::Error::Error(char const*, char const*, char const*, int) | Error::Error (const char* message, const char* expr, const char* file, int line)
: std::runtime_error(formatError(message, expr, file, line))
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movl %r8d, 0xc(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0x6330
testq %r12, %r12
leaq 0x2df5(%rip), %rbp # 0xa3ee
cmovneq %r12, %rbp
m... | /kaydenl[P]VK-GL-CTS/execserver/xsDefs.cpp |
xs::Message::parseHeader(unsigned char const*, unsigned long, xs::MessageType&, unsigned long&) | void Message::parseHeader (const deUint8* data, size_t dataSize, MessageType& type, size_t& size)
{
XS_CHECK_MSG(dataSize >= MESSAGE_HEADER_SIZE, "Incomplete header");
MessageParser parser(data, dataSize);
size = (size_t)(MessageType)parser.get<int>();
type = (MessageType)parser.get<int>();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpq $0x7, %rsi
jbe 0x7864
movq %rcx, %r14
movq %rdx, %rbx
leaq 0x8(%rsp), %r15
movq %rdi, (%r15)
movq %rsi, 0x8(%r15)
movq $0x0, 0x10(%r15)
movq %r15, %rdi
callq 0x7fb8
movl %eax, %eax
movq %rax, (%r14)
movq %r15, %rdi
callq 0x7fb8
movl %eax, (%rbx)
addq $0x20, %rsp
po... | /kaydenl[P]VK-GL-CTS/execserver/xsProtocol.cpp |
xs::ExecuteBinaryMessage::write(std::vector<unsigned char, std::allocator<unsigned char>>&) const | void ExecuteBinaryMessage::write (vector<deUint8>& buf) const
{
MessageWriter writer(type, buf);
writer.put(name.c_str());
writer.put(params.c_str());
writer.put(workDir.c_str());
writer.put(caseList.c_str());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movl 0x8(%rdi), %esi
movq %rsp, %r14
movq %r14, %rdi
callq 0x8038
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x77c6
movq 0x30(%rbx), %rsi
movq %rsp, %rdi
callq 0x77c6
movq 0x50(%rbx), %rsi
movq %rsp, %rdi
callq 0x77c6
movq 0x70(%rbx), %rsi
movq %rsp, %rd... | /kaydenl[P]VK-GL-CTS/execserver/xsProtocol.cpp |
int xs::MessageParser::get<int>() | T get (void)
{
XS_CHECK_MSG(m_pos + sizeof(T) <= m_size, "Invalid payload size");
T netValue;
deMemcpy(&netValue, &m_data[m_pos], sizeof(T));
m_pos += sizeof(T);
return networkToHost(netValue);
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
leaq 0x4(%rax), %rcx
cmpq 0x8(%rdi), %rcx
ja 0x7fde
movq (%rdi), %rdx
movl (%rdx,%rax), %eax
movq %rcx, 0x10(%rdi)
bswapl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x6120
movq %rax, %rbx
leaq 0x24d1(%rip), %rsi # 0xa4c3
leaq 0x250a(%... | /kaydenl[P]VK-GL-CTS/execserver/xsProtocol.cpp |
xs::InfoMessage::~InfoMessage() | ~InfoMessage (void) {} | movq %rdi, %rax
leaq 0x5a14(%rip), %rcx # 0xdc90
movq %rcx, (%rdi)
movq 0x10(%rdi), %rdi
addq $0x20, %rax
cmpq %rax, %rdi
je 0x8297
movq (%rax), %rsi
incq %rsi
jmp 0x6250
retq
| /kaydenl[P]VK-GL-CTS/execserver/xsProtocol.hpp |
xs::TestMessage::~TestMessage() | ~TestMessage (void) {} | movq %rdi, %rax
leaq 0x58f2(%rip), %rcx # 0xdbc8
movq %rcx, (%rdi)
movq 0x10(%rdi), %rdi
addq $0x20, %rax
cmpq %rax, %rdi
je 0x82f1
movq (%rax), %rsi
incq %rsi
jmp 0x6250
retq
| /kaydenl[P]VK-GL-CTS/execserver/xsProtocol.hpp |
de::Socket::listen(de::SocketAddress const&) | void Socket::listen (const SocketAddress& address)
{
if (!deSocket_listen(m_socket, address))
throw SocketError("Listening on socket failed");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x8ee3
testl %eax, %eax
je 0x8686
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6120
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1fce(%rip), %rsi #... | /kaydenl[P]VK-GL-CTS/framework/delibs/decpp/deSocket.cpp |
deSocket_setFlags | deBool deSocket_setFlags (deSocket* sock, deUint32 flags)
{
deSocketHandle fd = sock->handle;
if (sock->state == DE_SOCKETSTATE_CLOSED)
return DE_FALSE;
/* Keepalive. */
{
int mode = (flags & DE_SOCKET_KEEPALIVE) ? 1 : 0;
if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (const char*)&mode, sizeof(mode)) != 0)
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl (%rdi), %ebp
xorl %r14d, %r14d
cmpl $0x0, 0x10(%rdi)
je 0x8ed7
movl %esi, %ebx
movl %esi, %eax
andl $0x1, %eax
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
movl %ebp, %edi
movl $0x1, %esi
movl $0x9, %edx
movl $0x4, %r8d
callq 0x6460
testl %eax, %eax
jne 0x8ed7
movl %ebx,... | /kaydenl[P]VK-GL-CTS/framework/delibs/deutil/deSocket.c |
deSocket_receive | deSocketResult deSocket_receive (deSocket* sock, void* buf, size_t bufSize, size_t* numReceivedPtr)
{
int numRecv = (int)recv(sock->handle, (char*)buf, (NativeSize)bufSize, 0);
deSocketResult result = mapSendRecvResult(numRecv);
if (numReceivedPtr)
*numReceivedPtr = (numRecv > 0) ? ((size_t)numRecv) : (0);
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movl (%rdi), %edi
xorl %ecx, %ecx
callq 0x60d0
movq %rax, %r15
movl %r15d, %edi
callq 0x93c5
movl %eax, %ebp
testq %r14, %r14
je 0x9436
xorl %eax, %eax
testl %r15d, %r15d
movslq %r15d, %rcx
cmovgq %rcx, %rax
movq %rax, (%r14)
cmpl $0... | /kaydenl[P]VK-GL-CTS/framework/delibs/deutil/deSocket.c |
deMalloc | DE_BEGIN_EXTERN_C
/*--------------------------------------------------------------------*//*!
* \brief Allocate a chunk of memory.
* \param numBytes Number of bytes to allocate.
* \return Pointer to the allocated memory (or null on failure).
*//*--------------------------------------------------------------------*... | jmp 0x6310
| /kaydenl[P]VK-GL-CTS/framework/delibs/debase/deMemory.c |
vs_start | int vs_start(struct bitstream *str, uint32_t *val) {
if (str->type == VS_H261 || str->type == VS_H263) {
int nzbit = (str->type == VS_H261 ? 15 : 16);
int nsbit = (str->type == VS_H261 ? 4 : 5);
int bit = 0;
while (str->zero_bits < nzbit) {
if (vs_bit(str, &bit)) return 1;
if (bit != 0) {
fprintf(std... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x2c(%rdi), %eax
testl $0xfffffffd, %eax # imm = 0xFFFFFFFD
jne 0x1ec7
xorl %ebp, %ebp
testl %eax, %eax
sete %bpl
movl $0x10, %r13d
subl %ebp, %r13d
xorl $0x5, %ebp
leaq 0x4(%rsp), %r12
movl $0x0, (%r... | /polachok[P]envytools/vstream/bitstream.c |
vs_infer | int vs_infer(struct bitstream *str, uint32_t *val, uint32_t ival) {
if (str->dir == VS_ENCODE) {
if (*val != ival) {
fprintf (stderr, "Wrong infered value: %d != %d\n", *val, ival);
return 1;
}
} else {
*val = ival;
}
return 0;
} | movl %edx, %ecx
cmpl $0x0, (%rdi)
je 0x24a4
movl %ecx, (%rsi)
xorl %eax, %eax
retq
movl (%rsi), %edx
xorl %eax, %eax
cmpl %ecx, %edx
jne 0x24ad
retq
pushq %rax
movq 0x6b43(%rip), %rax # 0x8ff8
movq (%rax), %rdi
leaq 0x3e44(%rip), %rsi # 0x6303
xorl %eax, %eax
callq 0x1060
movl $0x1, %eax
addq $0x8, %rsp
retq
| /polachok[P]envytools/vstream/bitstream.c |
h264_seqparm_mvc | int h264_seqparm_mvc(struct bitstream *str, struct h264_seqparm *seqparm) {
uint32_t bit_equal_to_one = 1;
int i, j, k;
if (str->dir == VS_DECODE)
seqparm->is_mvc = 1;
if (vs_u(str, &bit_equal_to_one, 1)) return 1;
if (!bit_equal_to_one) {
fprintf(stderr, "bit_equal_to_one invalid\n");
return 1;
}
if (vs_u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, 0x18(%rsp)
cmpl $0x1, (%rdi)
jne 0x3878
movl $0x1, 0xc98(%r14)
leaq 0x18(%rsp), %rsi
movl $0x1, %ebp
movq %r15, %rdi
movl $0x1, %edx
callq 0x1abd
testl %eax, %eax
jne 0x3ddc
cmpl $0x0, 0x18(%rsp... | /polachok[P]envytools/vstream/h264.c |
cnd_signal | int cnd_signal(cnd_t *cond)
{
#if defined(_TTHREAD_WIN32_)
int haveWaiters;
/* Are there any waiters? */
EnterCriticalSection(&cond->mWaitersCountLock);
haveWaiters = (cond->mWaitersCount > 0);
LeaveCriticalSection(&cond->mWaitersCountLock);
/* If we have any waiting threads, send them a signal */
if(ha... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x151c0
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /Rodousse[P]SSSGems/third_party/glfw/deps/tinycthread.c |
createHelperWindow | static Window createHelperWindow(void)
{
XSetWindowAttributes wa;
wa.event_mask = PropertyChangeMask;
return XCreateWindow(_glfw.x11.display, _glfw.x11.root,
0, 0, 1, 1, 0, 0,
InputOnly,
DefaultVisual(_glfw.x11.display, _glfw.x11.sc... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq $0x400000, -0x28(%rbp) # imm = 0x400000
leaq 0x3b796(%rip), %rax # 0x62a80
movq 0x1fec0(%rax), %rdi
leaq 0x3b788(%rip), %rax # 0x62a80
movq 0x1fed0(%rax), %rsi
leaq 0x3b77a(%rip), %rax # 0x62a80
movq 0x1fec0(%rax), %rax
movq 0xe8(%rax), %rax
leaq 0x3b765(%ri... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_init.c |
hasUsableInputMethodStyle | static GLFWbool hasUsableInputMethodStyle(void)
{
GLFWbool found = GLFW_FALSE;
XIMStyles* styles = NULL;
if (XGetIMValues(_glfw.x11.im, XNQueryInputStyle, &styles, NULL) != NULL)
return GLFW_FALSE;
for (unsigned int i = 0; i < styles->count_styles; i++)
{
if (styles->supported_st... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x3b682(%rip), %rax # 0x62a80
movq 0x1fef8(%rax), %rdi
leaq 0x30af8(%rip), %rsi # 0x57f04
leaq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x15220
cmpq $0x0, %rax
je 0x2742a
movl $0x0, -0x4(%... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_init.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 %rbp
movq %rsp, %rbp
leaq 0x3b5e5(%rip), %rax # 0x62a80
cmpq $0x0, 0x1fee0(%rax)
je 0x2750e
leaq 0x3b5d4(%rip), %rax # 0x62a80
movq 0x1fec0(%rax), %rdi
leaq 0x3b5c6(%rip), %rax # 0x62a80
movq 0x20c08(%rax), %rsi
callq 0x15a90
leaq 0x3b5b3(%rip), %rcx # 0x62a80
cmpq 0x1fee0(%rcx), %rax
jne 0x274db
... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_init.c |
glfwPlatformGetVersionString | const char* _glfwPlatformGetVersionString(void)
{
return _GLFW_VERSION_NUMBER " X11 GLX EGL OSMesa"
#if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
" clock_gettime"
#else
" gettimeofday"
#endif
#if defined(__linux__)
" evdev"
#endif
#if defined(_GLFW_BUILD_DLL)
" shared... | pushq %rbp
movq %rsp, %rbp
leaq 0x3003c(%rip), %rax # 0x577b7
popq %rbp
retq
nopl (%rax)
| /Rodousse[P]SSSGems/third_party/glfw/src/x11_init.c |
glfwExtensionSupported | GLFWAPI int glfwExtensionSupported(const char* extension)
{
_GLFWwindow* window;
assert(extension != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT,
"Canno... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1979e
leaq 0x3d248(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1970f
movq %rdi, %rbx
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x3a950(%rip), %rdi # 0x53fe8
callq 0x26699
testq %rax, %rax
je 0x1971b
cmpb $0x0, (%rbx)
je 0x1972... | /anael-seghezzi[P]glfw/src/context.c |
glfwStringInExtensionString | GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions)
{
const char* start = extensions;
for (;;)
{
const char* where;
const char* terminator;
where = strstr(start, string);
if (!where)
return GLFW_FALSE;
terminator = where + ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x13500
xorl %ebx, %ebx
testq %rax, %rax
je 0x19821
movq %rax, %r13
movq %r14, %rdi
callq 0x13400
movq %rax, %r12
movq %r15, %rax
leaq (%r12,%r13), %r15
cmpq %rax, %r13
je 0x197ff
cmpb $0x20, -0x... | /anael-seghezzi[P]glfw/src/context.c |
glfwSwapBuffers | GLFWAPI void glfwSwapBuffers(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT,
"Cannot swap buffers of a window that h... | testq %rdi, %rdi
je 0x19899
leaq 0x3d05f(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1987d
cmpl $0x0, 0x1f8(%rdi)
je 0x19886
jmpq *0x248(%rdi)
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
jmp 0x19892
leaq 0x14141(%rip), %rsi # 0x2d9ce
movl $0x1000a, %edi # imm = 0x1000A
xorl %eax, %eax... | /anael-seghezzi[P]glfw/src/context.c |
glfwSwapInterval | GLFWAPI void glfwSwapInterval(int interval)
{
_GLFWwindow* window;
_GLFW_REQUIRE_INIT();
window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT,
"Cannot set swap interval without a current OpenGL or OpenGL ES context... | pushq %rbx
leaq 0x3d007(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x198e7
movl %edi, %ebx
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x3a714(%rip), %rdi # 0x53fe8
callq 0x26699
testq %rax, %rax
je 0x198f0
movl %ebx, %edi
popq %rbx
jmpq *0x250(%rax)
movl $0x10001, %edi # imm = 0x10001
xorl %esi,... | /anael-seghezzi[P]glfw/src/context.c |
glfwGetProcAddress | GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
{
_GLFWwindow* window;
assert(procname != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT,
"Cannot que... | pushq %rbx
testq %rdi, %rdi
je 0x19959
leaq 0x3cfb7(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x19939
movq %rdi, %rbx
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x3a6c3(%rip), %rdi # 0x53fe8
callq 0x26699
testq %rax, %rax
je 0x19942
movq %rbx, %rdi
popq %rbx
jmpq *0x260(%rax)
movl $0x10001, %edi ... | /anael-seghezzi[P]glfw/src/context.c |
glfw_fminf | float _glfw_fminf(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 0x199ac
ucomiss %xmm1, %xmm1
jp 0x199a9
minss %xmm1, %xmm0
movaps %xmm0, %xmm1
movaps %xmm1, %xmm0
retq
| /anael-seghezzi[P]glfw/src/init.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 0x199c1
ucomiss %xmm1, %xmm1
jp 0x199be
maxss %xmm1, %xmm0
movaps %xmm0, %xmm1
movaps %xmm1, %xmm0
retq
| /anael-seghezzi[P]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 0x19a24
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movap... | /anael-seghezzi[P]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 %r14
pushq %rbx
pushq %rax
leaq 0x3cbae(%rip), %r14 # 0x568c8
cmpl $0x0, (%r14)
je 0x19d2a
movl $0x1, %ebx
jmp 0x19e01
xorl %ebx, %ebx
movl $0x20980, %edx # imm = 0x20980
movq %r14, %rdi
xorl %esi, %esi
callq 0x130f0
movq 0x3b4e6(%rip), %rax # 0x55228
movq %rax, 0x8(%r14)
movl 0x3b4e4(%rip), %eax... | /anael-seghezzi[P]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 0x3caae(%rip), %rbx # 0x568c8
movups %xmm0, 0x1feb0(%rbx)
movq 0x3f0(%rbx), %rdi
testq %rdi, %rdi
je 0x19e39
callq 0x1da4f
jmp 0x19e21
callq 0x1ab4a
movq 0x3e8(%rbx), %rdi
testq %rdi, %rdi
jne 0x19e34
cmpl $0x0, 0x400(%rbx)
jle 0x19e86
xorl %r15d, %r15d
movq ... | /anael-seghezzi[P]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 0x19f58
movl %edi, %edx
cmpl $0x51001, %edi # imm = 0x51001
je 0x19f51
cmpl $0x50001, %edx # imm = 0x50001
jne 0x19f5f
movl %esi, 0x3b2d8(%rip) # 0x55228
retq
movl %esi, 0x3b2d9(%rip) # 0x55230
retq
movl %esi, 0x3b2ce(%rip) # 0x5522c
retq
lea... | /anael-seghezzi[P]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 0x19f7d
movl $0x3, (%rdi)
testq %rsi, %rsi
je 0x19f88
movl $0x3, (%rsi)
testq %rdx, %rdx
je 0x19f93
movl $0x0, (%rdx)
retq
| /anael-seghezzi[P]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 0x19fa9
movq $0x0, (%rbx)
leaq 0x3c918(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x19fcf
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x3a027(%rip), %rdi # 0x53fe8
callq 0x26699
testq %rax, %rax
jne 0x19fd6
xorl %ecx, %ecx
jmp 0x19ffc
leaq 0x5d272(%rip), %rax... | /anael-seghezzi[P]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 0x1a05d
movl %esi, %eax
cmpl $0x1, %ecx
je 0x1a03d
testl %ecx, %ecx
jne 0x1a056
cmpb $0x0, 0x80(%rdi,%rax)
je 0x1a082
cmpl $0x0, 0x68(%rdi)
je 0x1a083
movb $0x3, 0x80(%rdi,%rax)
jmp 0x1a05d
cmpb $0x1, 0x80(%rdi,%rax)
movb $0x1, 0x80(%rdi,%rax)
movl $0x2, %eax
jne 0x1a05d
jm... | /anael-seghezzi[P]glfw/src/input.c |
glfwInputChar | void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, GLFWbool plain)
{
if (codepoint < 32 || (codepoint > 126 && codepoint < 160))
return;
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (window->callbacks.charmods)
window->call... | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %esi, %ebx
cmpl $0x20, %esi
setb %al
leal -0x7f(%rbx), %ecx
cmpl $0x21, %ecx
setb %cl
orb %al, %cl
jne 0x1a0e8
movq %rdi, %r14
movq 0x330(%rdi), %rcx
testq %rcx, %rcx
je 0x1a0cd
movl %edx, %eax
andl $-0x31, %eax
cmpl $0x0, 0x70(%r14)
cmovnel %edx, %eax
movq %r14, %r... | /anael-seghezzi[P]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 0x1a133
movl %ecx, %eax
andl $-0x31, %ecx
cmpl $0x0, 0x70(%rdi)
cmovnel %eax, %ecx
testl %edx, %edx
je 0x1a115
movl %edx, %eax
jmp 0x1a11d
movb $0x3, %al
cmpl $0x0, 0x6c(%rdi)
je 0x1a111
movl %esi, %r8d
movb %al, 0x78(%rdi,%r8)
movq 0x300(%rdi), %rax
testq %rax, %rax
je 0x1a133
jmpq *%rax
retq
| /anael-seghezzi[P]glfw/src/input.c |
glfwInputCursorPos | void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos)
{
if (window->virtualCursorPosX == xpos && window->virtualCursorPosY == ypos)
return;
window->virtualCursorPosX = xpos;
window->virtualCursorPosY = ypos;
if (window->callbacks.cursorPos)
window->callbacks.cursorPos... | movsd 0x1e0(%rdi), %xmm2
ucomisd %xmm0, %xmm2
jne 0x1a154
jp 0x1a154
movsd 0x1e8(%rdi), %xmm2
ucomisd %xmm1, %xmm2
jne 0x1a154
jnp 0x1a172
movsd %xmm0, 0x1e0(%rdi)
movsd %xmm1, 0x1e8(%rdi)
movq 0x308(%rdi), %rax
testq %rax, %rax
je 0x1a172
jmpq *%rax
retq
| /anael-seghezzi[P]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... | /anael-seghezzi[P]glfw/src/input.c |
glfwAllocJoystick | _GLFWjoystick* _glfwAllocJoystick(const char* name,
const char* guid,
int axisCount,
int buttonCount,
int hatCount)
{
int jid;
_GLFWjoystick* js;
for (jid = 0; jid <= GLF... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movl $0x408, %ebx # imm = 0x408
addq 0x39d96(%rip), %rbx # 0x53fe8
movl $0x10, %eax
cmpl $0x0, (%rbx)
je 0x1a26c
addq $0x1fa0, %rbx # imm = 0x1FA0
decq ... | /anael-seghezzi[P]glfw/src/input.c |
glfwGetInputMode | GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(0);
switch (mode)
{
case GLFW_CURSOR:
return window->cursorMode;
case GLFW_STICKY_KEYS:
return wind... | pushq %rbx
testq %rdi, %rdi
je 0x1a485
leaq 0x3c4ac(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1a443
movl %esi, %edx
leal -0x33001(%rdx), %eax
cmpl $0x4, %eax
ja 0x1a46c
leaq 0x2ead3(%rip), %rcx # 0x48f08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x74(%rdi), %ebx
jmp 0x1a481
xorl %ebx, %ebx
m... | /anael-seghezzi[P]glfw/src/input.c |
glfwSetInputMode | GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (mode == GLFW_CURSOR)
{
if (value != GLFW_CURSOR_NORMAL &&
value != GLFW_CURSOR_HIDDEN &&
value != ... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a73c
leaq 0x3c410(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1a508
movl %edx, %r14d
movl %esi, %edx
leal -0x33001(%rdx), %eax
cmpl $0x4, %eax
ja 0x1a6d7
movq %rdi, %rbx
leaq 0x2ea41(%rip), %rcx # 0x48f1c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%... | /anael-seghezzi[P]glfw/src/input.c |
glfwGetKey | GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (key < GLFW_KEY_SPACE || key > GLFW_KEY_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid key %i", key);
retur... | pushq %rbx
testq %rdi, %rdi
je 0x1a891
leaq 0x3c094(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1a85f
movl %esi, %edx
leal -0x15d(%rdx), %eax
cmpl $0xfffffec2, %eax # imm = 0xFFFFFEC2
ja 0x1a871
leaq 0x2e8ba(%rip), %rsi # 0x49109
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %ea... | /anael-seghezzi[P]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 0x1a90c
leaq 0x3c00b(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1a8e0
movl %esi, %edx
cmpl $0x8, %esi
jb 0x1a8f2
leaq 0x2e894(%rip), %rsi # 0x49164
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x199c5
jmp 0x1a908
xorl %ebx, %ebx
movl $0x1000... | /anael-seghezzi[P]glfw/src/input.c |
glfwGetCursorPos | GLFWAPI void glfwGetCursorPos(GLFWwindow* handle, double* xpos, double* ypos)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (xpos)
*xpos = 0;
if (ypos)
*ypos = 0;
_GLFW_REQUIRE_INIT();
if (window->cursorMode == GLFW_CURSOR_DISABLED)
{
if... | testq %rdi, %rdi
je 0x1a992
testq %rsi, %rsi
je 0x1a93c
movq $0x0, (%rsi)
testq %rdx, %rdx
je 0x1a948
movq $0x0, (%rdx)
leaq 0x3bf79(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1a984
cmpl $0x34003, 0x74(%rdi) # imm = 0x34003
jne 0x25817
testq %rsi, %rsi
je 0x1a972
movsd 0x1e0(%rdi), %xmm0
movsd %xmm0, (%rsi)
te... | /anael-seghezzi[P]glfw/src/input.c |
glfwSetCursorPos | GLFWAPI void glfwSetCursorPos(GLFWwindow* handle, double xpos, double ypos)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (xpos != xpos || xpos < -DBL_MAX || xpos > DBL_MAX ||
ypos != ypos || ypos < -DBL_MAX || ypos > DBL_MAX)
{
_gl... | pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x1aa88
leaq 0x3bf01(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1aa5d
ucomisd 0x2e510(%rip), %xmm0 # 0x48ee8
ja 0x1aa45
ucomisd %xmm0, %xmm0
jp 0x1aa45
movsd 0x2e508(%rip), %xmm2 # 0x48ef0
ucomisd %xmm0, %xmm2
ja 0x1aa45
ucomisd 0x2e4f2(%rip), %xmm1 # 0x48e... | /anael-seghezzi[P]glfw/src/input.c |
glfwCreateCursor | GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot)
{
_GLFWcursor* cursor;
assert(image != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
cursor = calloc(1, sizeof(_GLFWcursor));
cursor->next = _glfw.cursorListHead;
_glfw.cursorListHead = cursor;
if (!_glfwPlatfo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1ab2b
leaq 0x3be0d(%rip), %r12 # 0x568c8
cmpl $0x0, (%r12)
je 0x1ab0f
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x13790
movq %rax, %rbx
movq 0x3e8(%r12), %rax
movq %rax, (%rbx)
movq %rbx, 0x3e8... | /anael-seghezzi[P]glfw/src/input.c |
glfwDestroyCursor | GLFWAPI void glfwDestroyCursor(GLFWcursor* handle)
{
_GLFWcursor* cursor = (_GLFWcursor*) handle;
_GLFW_REQUIRE_INIT();
if (cursor == NULL)
return;
// Make sure the cursor is not being used by any window
{
_GLFWwindow* window;
for (window = _glfw.windowListHead; window; ... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x3bd73(%rip), %rax # 0x568c8
cmpl $0x0, (%rax)
je 0x1abb7
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1abcc
movq 0x3f0(%rax), %r14
testq %r14, %r14
je 0x1ab83
cmpq %rbx, 0x48(%r14)
jne 0x1ab7e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1ac66
movq (%r14), %r14
jmp 0x1ab69
movq %rbx, %rd... | /anael-seghezzi[P]glfw/src/input.c |
glfwCreateStandardCursor | GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape)
{
_GLFWcursor* cursor;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (shape != GLFW_ARROW_CURSOR &&
shape != GLFW_IBEAM_CURSOR &&
shape != GLFW_CROSSHAIR_CURSOR &&
shape != GLFW_HAND_CURSOR &&
shape != GLFW_HRESIZE_CURSOR &&
... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x3bce8(%rip), %r15 # 0x568c8
cmpl $0x0, (%r15)
je 0x1ac0f
movl %edi, %r14d
leal -0x36007(%r14), %eax
cmpl $-0x7, %eax
ja 0x1ac21
leaq 0x2e652(%rip), %rsi # 0x4924e
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
movl %r14d, %edx
xorl %eax, %eax
callq 0x199c5
j... | /anael-seghezzi[P]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 0x3a59d(%rip), %r14 # 0x568c8
cmpl $0x0, (%r14)
je 0x1c3b6
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1c3cb
ucomisd 0x2cbad(%rip), %xmm0 # 0x48ef8
ja 0x1c3cb
movsd %xmm0, (%rsp)
callq 0x265bd
movq %rax, %rbx
callq 0x26609
movq %rax, %xmm0
punpckldq 0x2cc64(%rip), %xmm0 # x... | /anael-seghezzi[P]glfw/src/input.c |
gladLoadGLLoader | int gladLoadGLLoader(GLADloadproc load) {
GLVersion.major = 0; GLVersion.minor = 0;
glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
if(glGetString == NULL) return 0;
if(glGetString(GL_VERSION) == NULL) return 0;
find_coreGL();
load_GL_VERSION_1_0(load);
load_GL_VERSION_1_1(load);
load_GL_VERSION_1_2(load... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
andq $0x0, 0x758df(%rip) # 0x89cc0
leaq 0x12e7f(%rip), %rdi # 0x27267
callq *%rbx
movq %rax, 0x758d7(%rip) # 0x89cc8
xorl %ebp, %ebp
testq %rax, %rax
je 0x17353
movl $0x1f02, %edi # imm = 0x1F02
call... | /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
glfwRefreshContextAttribs | GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
const _GLFWctxconfig* ctxconfig)
{
int i;
_GLFWwindow* previous;
const char* version;
const char* prefixes[] =
{
"OpenGL ES-CM ",
"OpenGL ES-CL ",
"OpenGL ES ",
NULL
};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r14
movl 0x4(%rsi), %eax
movl %eax, 0x1f4(%rdi)
movl $0x30001, 0x1f0(%rdi) # imm = 0x30001
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x3974d(%rip), %rdi # 0x50fe8
callq 0x237f6
movq %rax, %r15
mo... | /Konf[P]LearnOpenGL-CLion/glfw/src/context.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 0x7320b(%rip), %rbx # 0x8b348
cmpl $0x0, (%rbx)
je 0x1814a
pushq $0x1
popq %rbp
jmp 0x18226
xorl %ebp, %ebp
movl $0x20978, %edx # imm = 0x20978
movq %rbx, %rdi
xorl %esi, %esi
callq 0x130d0
movq 0x3a116(%rip), %rax # 0x52278
movq %rax, 0x8(%rbx)
movl 0x3a114(%rip),... | /Konf[P]LearnOpenGL-CLion/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 0x18467
movl %esi, %eax
cmpl $0x1, %ecx
je 0x18449
testl %ecx, %ecx
jne 0x18460
cmpb $0x0, 0x80(%rdi,%rax)
je 0x18487
cmpl $0x0, 0x68(%rdi)
je 0x18488
movb $0x3, 0x80(%rdi,%rax)
jmp 0x18467
cmpb $0x1, 0x80(%rdi,%rax)
movb $0x1, 0x80(%rdi,%rax)
jne 0x18467
pushq $0x2
popq %r... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwCreateCursor | GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot)
{
_GLFWcursor* cursor;
assert(image != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
cursor = calloc(1, sizeof(_GLFWcursor));
cursor->next = _glfw.cursorListHead;
_glfw.cursorListHead = cursor;
if (!_glfwPlatfo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x18d74
leaq 0x72640(%rip), %r12 # 0x8b348
cmpl $0x0, (%r12)
je 0x18d58
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x13770
movq %rax, %rbx
movq 0x3e0(%r12), %rax
movq %rax, (%rbx)
movq %... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.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 0x1a920
movl 0x4(%rdi), %eax
imull (%rdi), %eax
movl 0x4(%rsi), %ecx
imull (%rsi), %ecx
subl %ecx, %eax
jne 0x1a920
movl 0x14(%rdi), %eax
subl 0x14(%rsi), %eax
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/monitor.c |
glfwInitVulkan | GLFWbool _glfwInitVulkan(int mode)
{
VkResult err;
VkExtensionProperties* ep;
uint32_t i, count;
if (_glfw.vk.available)
return GLFW_TRUE;
#if !defined(_GLFW_VULKAN_STATIC)
#if defined(_GLFW_VULKAN_LIBRARY)
_glfw.vk.handle = _glfw_dlopen(_GLFW_VULKAN_LIBRARY);
#elif defined(_GLFW_WIN32)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x702fe(%rip), %rbx # 0x8b348
cmpl $0x0, 0x1fe68(%rbx)
je 0x1b05c
pushq $0x1
popq %r14
jmp 0x1b134
movl %edi, %r15d
leaq 0x2b332(%rip), %rdi # 0x46398
pushq $0x1
popq %rsi
callq 0x13520
movq %rax, 0x1fe70(%rbx)
testq %rax, %rax
je... | /Konf[P]LearnOpenGL-CLion/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 0x2d0(%rdi), %rax
testq %rax, %rax
je 0x1b6a8
movq %rbx, %rdi
movl %ebp, %esi
callq *%rax
testl %ebp, %ebp
je 0x1b6b1
popq %rbx
popq %r14
popq %rbp
retq
xorl %r14d, %r14d
cmpq $0x15d, %r14 # imm = 0x15D
je 0x1b6e7
cmpb $0x1, 0x80(%rbx,%r14... | /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwCreateWindow | GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
const char* title,
GLFWmonitor* monitor,
GLFWwindow* share)
{
_GLFWfbconfig fbconfig;
_GLFWctxconfig ctxconfig;
_GLFWwndconfig wndconfig;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3d8, %rsp # imm = 0x3D8
testq %rdx, %rdx
je 0x1b9dd
movl %edi, %r15d
testl %edi, %edi
js 0x1b9fc
movl %esi, %ebp
testl %esi, %esi
js 0x1ba1b
leaq 0x6fb82(%rip), %r14 # 0x8b348
cmpl $0x0, (%r14)
je 0x1b7fd
movq %rdx, %r12
testl %r15... | /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwSetWindowIcon | GLFWAPI void glfwSetWindowIcon(GLFWwindow* handle,
int count, const GLFWimage* images)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
assert(count >= 0);
assert(count == 0 || images != NULL);
_GLFW_REQUIRE_INIT();
_glfwPlatformSetWindowIcon... | pushq %rax
testq %rdi, %rdi
je 0x1beff
testl %esi, %esi
js 0x1bf1e
sete %al
testq %rdx, %rdx
setne %cl
orb %al, %cl
je 0x1bf3d
leaq 0x6f463(%rip), %rax # 0x8b348
cmpl $0x0, (%rax)
je 0x1bef0
popq %rax
jmp 0x20a7c
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rcx
jmp 0x17f99
leaq... | /Konf[P]LearnOpenGL-CLion/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 0x1c02f
testq %rsi, %rsi
je 0x1c008
andl $0x0, (%rsi)
testq %rdx, %rdx
je 0x1c010
andl $0x0, (%rdx)
leaq 0x6f331(%rip), %rax # 0x8b348
cmpl $0x0, (%rax)
je 0x1c021
jmp 0x20d19
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x17f99
pushq %rax
leaq 0xe14f(%rip), %... | /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwCreateCursorX11 | Cursor _glfwCreateCursorX11(const GLFWimage* image, int xhot, int yhot)
{
int i;
Cursor cursor;
if (!_glfw.x11.xcursor.handle)
return None;
XcursorImage* native = XcursorImageCreate(image->width, image->height);
if (native == NULL)
return None;
native->xhot = xhot;
native-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x6e3b7(%rip), %r12 # 0x8b348
cmpq $0x0, 0x20650(%r12)
je 0x1d042
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl (%rdi), %edi
movl 0x4(%rbx), %esi
callq *0x20658(%r12)
testq %rax, %rax
je 0x1d042
movq %rax, %r14
movl %r15d, 0x10(%rax)
movl %ebp, 0x1... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_init.c |
glfwRestoreVideoModeX11 | void _glfwRestoreVideoModeX11(_GLFWmonitor* monitor)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
if (monitor->x11.oldMode == None)
return;
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x1... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x6bf0d(%rip), %r12 # 0x8b348
cmpl $0x0, 0x20558(%r12)
je 0x1f4fd
cmpl $0x0, 0x2057c(%r12)
jne 0x1f4fd
movq %rdi, %rbx
cmpq $0x0, 0x98(%rdi)
je 0x1f4fd
movq 0x1feb8(%r12), %rdi
movq 0x1fec8(%r12), %rsi
callq *0x205d0(%r12)
movq %rax, %r14
movq 0x1feb8(%r12... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_monitor.c |
glfwPlatformGetGammaRamp | void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
{
const size_t size = XRRGetCrtcGammaSize(_glfw.x11.display,
monitor->x11.crtc);
XRRCrtcGamma* gamma = XRRGe... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x6bbc0(%rip), %rax # 0x8b348
cmpl $0x0, 0x20558(%rax)
je 0x1f82d
cmpl $0x0, 0x20578(%rax)
jne 0x1f82d
movq %rdi, %r15
movq 0x1feb8(%rax), %rdi
movq 0x90(%r15), %rsi
movq %rax, %r12
callq *0x205b0(%rax)
movslq %eax, %r14
movq 0x1feb8(%r12),... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_monitor.c |
glfwPlatformSetWindowMonitor | void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
_GLFWmonitor* monitor,
int xpos, int ypos,
int width, int height,
int refreshRate)
{
if (window->monitor == monitor)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
movq 0x40(%rdi), %rax
cmpq %rsi, %rax
je 0x214e1
testq %rax, %rax
je 0x2148a
movq %rbx, %rdi
callq 0x20934
movq %rbx, %rdi
movq %r13, %rsi
callq... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
updateCursorImage | static void updateCursorImage(_GLFWwindow* window)
{
if (window->cursorMode == GLFW_CURSOR_NORMAL)
{
if (window->cursor)
{
XDefineCursor(_glfw.x11.display, window->x11.handle,
window->cursor->x11.handle);
}
else
XUndefineCursor(_g... | cmpl $0x34001, 0x74(%rdi) # imm = 0x34001
jne 0x22c64
movq 0x48(%rdi), %rcx
leaq 0x68703(%rip), %rax # 0x8b348
movq 0x1feb8(%rax), %rax
movq 0x340(%rdi), %rsi
testq %rcx, %rcx
je 0x22c85
movq 0x8(%rcx), %rdx
movq %rax, %rdi
jmp 0x13760
leaq 0x686dd(%rip), %rax # 0x8b348
movq 0x340(%rdi), %rsi
movq 0x1feb8(%r... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.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 0x67c19(%rip), %rax # 0x8b348
cmpl $0x0, 0x1fe58(%rax)
je 0x2374f
pushq $0x1
popq %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x13130
imulq $0x3b9aca00, (%rbx), %rax # imm = 0x3B9ACA00
jmp 0x23763
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x131f0
imulq $0xf4240, (%rbx), %... | /Konf[P]LearnOpenGL-CLion/glfw/src/posix_time.c |
makeContextCurrentGLX | static void makeContextCurrentGLX(_GLFWwindow* window)
{
if (window)
{
if (!glXMakeCurrent(_glfw.x11.display,
window->context.glx.window,
window->context.glx.handle))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
... | pushq %rbx
movq %rdi, %rbx
leaq 0x66df8(%rip), %rcx # 0x8b348
movq 0x207a0(%rcx), %rax
movq 0x1feb8(%rcx), %rdi
testq %rbx, %rbx
je 0x24580
movq 0x268(%rbx), %rdx
movq 0x270(%rbx), %rsi
callq *%rax
testl %eax, %eax
jne 0x2458a
leaq 0x25870(%rip), %rsi # 0x49dee
jmp 0x245a6
xorl %esi, %esi
xorl %edx, %edx
callq ... | /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.c |
destroyContextOSMesa | static void destroyContextOSMesa(_GLFWwindow* window)
{
if (window->context.osmesa.handle)
{
OSMesaDestroyContext(window->context.osmesa.handle);
window->context.osmesa.handle = NULL;
}
if (window->context.osmesa.buffer)
{
free(window->context.osmesa.buffer);
window-... | pushq %rbx
movq %rdi, %rbx
movq 0x298(%rdi), %rdi
testq %rdi, %rdi
je 0x25b5e
leaq 0x657f8(%rip), %rax # 0x8b348
callq *0x20950(%rax)
andq $0x0, 0x298(%rbx)
movq 0x2a8(%rbx), %rdi
testq %rdi, %rdi
je 0x25b77
callq 0x133b0
andq $0x0, 0x2a0(%rbx)
popq %rbx
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/osmesa_context.c |
handleAbsEvent | static void handleAbsEvent(_GLFWjoystick* js, int code, int value)
{
const int index = js->linjs.absMap[code];
if (code >= ABS_HAT0X && code <= ABS_HAT3Y)
{
static const char stateMap[3][3] =
{
{ GLFW_HAT_CENTERED, GLFW_HAT_UP, GLFW_HAT_DOWN },
{ GLFW_HAT_LEFT,... | movl %esi, %eax
movslq %esi, %rcx
movl 0x187c(%rdi,%rcx,4), %esi
movl %ecx, %r8d
andl $-0x8, %r8d
cmpl $0x10, %r8d
jne 0x266b7
leal -0x10(%rax), %ecx
shrl %ecx
andl $0x1, %eax
leaq (%rdi,%rcx,8), %rcx
addq $0x1f7c, %rcx # imm = 0x1F7C
movl %eax, %eax
testl %edx, %edx
je 0x266f6
js 0x266fc
movl $0x2, (%rcx,%ra... | /Konf[P]LearnOpenGL-CLion/glfw/src/linux_joystick.c |
(anonymous namespace)::readOrDie[abi:cxx11](llvm::StringRef) | std::string readOrDie(llvm::StringRef Path) {
llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
llvm::MemoryBuffer::getFile(Path);
if (std::error_code EC = Text.getError()) {
llvm::errs() << "Error: can't read grammar file '" << Path
<< "': " << EC.message() << "\n";
::exit(1)... | subq $0xc8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xb8(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x11ff0
leaq 0x6e(%rsp), %rdi
callq 0x12040
leaq 0x98(%rsp), %rdi
leaq 0x70(%rsp), %rsi
xorl %r8d, %r8d
movl $0x1, %ecx
movl %r8... | /gen/Main.cpp |
llvm::formatv_object<decltype(std::make_tuple(support::detail::build_format_adapter(std::forward<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(fp0)), support::detail::build_format_adapter(std::forward<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(fp0))... | inline auto formatv(const char *Fmt, Ts &&...Vals)
-> formatv_object<decltype(std::make_tuple(
support::detail::build_format_adapter(std::forward<Ts>(Vals))...))> {
using ParamTuple = decltype(std::make_tuple(
support::detail::build_format_adapter(std::forward<Ts>(Vals))...));
return formatv_objec... | subq $0x108, %rsp # imm = 0x108
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movq %rcx, 0xe8(%rsp)
movq %r8, 0xe0(%rsp)
movq 0xf8(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
callq 0x7b90
movq 0xf0(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x16e... | /llvm/Support/FormatVariadic.h |
llvm::cl::parser<(anonymous namespace)::EmitType>::OptionInfo const* llvm::SmallVectorTemplateCommon<llvm::cl::parser<(anonymous namespace)::EmitType>::OptionInfo, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::cl::parser<(anonymous namespace)::EmitType>::OptionInfo, false>>(llvm::SmallVect... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4d300
addq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4d110
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
ja 0x15ab7
movq 0x40(%r... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorImpl<char const*>::erase(char const* const*) | iterator erase(const_iterator CI) {
// Just cast away constness because this is a non-const member function.
iterator I = const_cast<iterator>(CI);
assert(this->isReferenceToStorage(CI) && "Iterator to erase is out of bounds.");
iterator N = I;
// Shift all elts down one.
std::move(I+1, this->... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
callq 0x1c220
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), ... | /llvm/ADT/SmallVector.h |
llvm::cl::Option::printHelpStr(llvm::StringRef, unsigned long, unsigned long) | void Option::printHelpStr(StringRef HelpStr, size_t Indent,
size_t FirstLineIndentedBy) {
assert(Indent >= FirstLineIndentedBy);
std::pair<StringRef, StringRef> Split = HelpStr.split('\n');
outs().indent(Indent - FirstLineIndentedBy)
<< ArgHelpPrefix << Split.first << "\n";
while... | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x88(%rsp), %rsi
movl $0xa, %edx
callq 0x20b80
callq 0x5f420
movq %rax, %rdi
movq 0x80(%rsp), %rax
subq 0x78(%rsp), %rax
movl %eax, %esi
callq 0x5e720
movq %rax, %rdi
movq 0x9f97f(%rip), %... | /Support/CommandLine.cpp |
HandlePrefixedOrGroupedOption(llvm::StringRef&, llvm::StringRef&, bool&, llvm::StringMap<llvm::cl::Option*, llvm::MallocAllocator> const&) | static Option *
HandlePrefixedOrGroupedOption(StringRef &Arg, StringRef &Value,
bool &ErrorParsing,
const StringMap<Option *> &OptionsMap) {
if (Arg.size() == 1)
return nullptr;
// Do the lookup!
size_t Length = 0;
Option *PGOpt = getOptionPred(Ar... | subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq %rdx, 0xf8(%rsp)
movq %rcx, 0xf0(%rsp)
movq 0x108(%rsp), %rdi
callq 0x11670
cmpq $0x1, %rax
jne 0x27cfb
movq $0x0, 0x110(%rsp)
jmp 0x280f2
movq $0x0, 0xe8(%rsp)
movq 0x108(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0xd0(%rsp)
mo... | /Support/CommandLine.cpp |
llvm::cl::opt<(anonymous namespace)::HelpPrinterWrapper, true, llvm::cl::parser<bool>>::opt<char [5], llvm::cl::desc, llvm::cl::LocationClass<(anonymous namespace)::HelpPrinterWrapper>, llvm::cl::ValueExpected, llvm::cl::cat, llvm::cl::sub>(char const (&) [5], llvm::cl::desc const&, llvm::cl::LocationClass<(anonymous n... | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x140a0
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x2e870
movq 0x8(%... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [18], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<bool>, llvm::cl::cat, llvm::cl::sub>(char const (&) [18], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> const&, llvm::cl::cat const&, llvm::cl::sub const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x140a0
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x301a0
movq 0x8(%... | /llvm/Support/CommandLine.h |
llvm::cl::opt<(anonymous namespace)::VersionPrinter, true, llvm::cl::parser<bool>>::opt<char [8], llvm::cl::desc, llvm::cl::LocationClass<(anonymous namespace)::VersionPrinter>, llvm::cl::ValueExpected, llvm::cl::cat>(char const (&) [8], llvm::cl::desc const&, llvm::cl::LocationClass<(anonymous namespace)::VersionPrint... | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x140a0
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x30ba0
movq 0x8(%rsp), %rsi
leaq 0x944c... | /llvm/Support/CommandLine.h |
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.